From 9021158b33071e23d06f1ac86e05da8e4522eeb9 Mon Sep 17 00:00:00 2001 From: Yosuke-Ito-345 Date: Sat, 5 Jul 2025 20:44:55 +0900 Subject: [PATCH 01/10] changelog --- CHANGELOG_UNRELEASED.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/CHANGELOG_UNRELEASED.md b/CHANGELOG_UNRELEASED.md index 67bb43c3b6..2385214fcf 100644 --- a/CHANGELOG_UNRELEASED.md +++ b/CHANGELOG_UNRELEASED.md @@ -8,6 +8,11 @@ ### Renamed +- in `lebesgue_stieltjes_measure.v`: + + `cumulativeNy0` -> `cumulativeNy` + + `cumulativey1` -> `cumulativey` + + `cumulativey1` -> `cumulativey` + ### Generalized ### Deprecated From fcab882d7bed5191f7f19c42591f64a1bc3c8146 Mon Sep 17 00:00:00 2001 From: Yosuke-Ito-345 Date: Sun, 13 Jul 2025 12:53:02 +0900 Subject: [PATCH 02/10] generalize cumulative --- reals/constructive_ereal.v | 7 ++++ theories/lebesgue_stieltjes_measure.v | 56 ++++++++++++++------------- theories/probability.v | 35 +++++++++++++++++ 3 files changed, 71 insertions(+), 27 deletions(-) diff --git a/reals/constructive_ereal.v b/reals/constructive_ereal.v index 5fa11a3bbd..c7bd9390cb 100644 --- a/reals/constructive_ereal.v +++ b/reals/constructive_ereal.v @@ -1695,6 +1695,13 @@ Proof. by move: x => [x| |]//=; rewrite lee_fin => x0; rewrite ltNyr. Qed. Lemma lt0_fin_numE x : x < 0 -> (x \is a fin_num) = (-oo < x). Proof. by move/ltW; exact: le0_fin_numE. Qed. +Lemma gte_lte_real (x a b : \bar R) : (a < x < b) -> x \is a fin_num. +Proof. +case/andP => [ax xb]; apply/fin_numPlt/andP; split. + exact: (le_lt_trans (leNye a) ax). +exact: (lt_le_trans xb (leey b)). +Qed. + Lemma eqyP x : x = +oo <-> (forall A, (0 < A)%R -> A%:E <= x). Proof. split=> [-> // A A0|Ax]; first by rewrite leey. diff --git a/theories/lebesgue_stieltjes_measure.v b/theories/lebesgue_stieltjes_measure.v index 9a372846e7..76fef7687c 100644 --- a/theories/lebesgue_stieltjes_measure.v +++ b/theories/lebesgue_stieltjes_measure.v @@ -60,23 +60,24 @@ Reserved Notation "R .-ocitv.-measurable" Notation right_continuous f := (forall x, f%function @ at_right x --> f%function x). -Lemma right_continuousW (R : numFieldType) (f : R -> R) : - continuous f -> right_continuous f. +Lemma right_continuousW (R : numFieldType) {d} (U : orderNbhsType d) + (f : R -> U) : continuous f -> right_continuous f. Proof. by move=> cf x; apply: cvg_within_filter; exact/cf. Qed. -HB.mixin Record isCumulative (R : numFieldType) (f : R -> R) := { - cumulative_is_nondecreasing : {homo f : x y / x <= y} ; +HB.mixin Record isCumulative (R : numFieldType) {d} (U : orderNbhsType d) + (f : R -> U) := { + cumulative_is_nondecreasing : nondecreasing f ; cumulative_is_right_continuous : right_continuous f }. #[short(type=cumulative)] -HB.structure Definition Cumulative (R : numFieldType) := - { f of isCumulative R f }. +HB.structure Definition Cumulative + (R : numFieldType) {d} (U : orderNbhsType d) := { f of isCumulative R d U f }. -Arguments cumulative_is_nondecreasing {R} _. -Arguments cumulative_is_right_continuous {R} _. +Arguments cumulative_is_nondecreasing {R d U} _. +Arguments cumulative_is_right_continuous {R d U} _. -Lemma nondecreasing_right_continuousP (R : numFieldType) (a : R) (e : R) - (f : cumulative R) : +Lemma nondecreasing_right_continuousP (R : realFieldType) (a : R) (e : R) + (f : cumulative R R) : e > 0 -> exists d : {posnum R}, f (a + d%:num) <= f a + e. Proof. move=> e0; move: (cumulative_is_right_continuous f). @@ -100,7 +101,7 @@ Proof. by []. Qed. Let id_rc : right_continuous (@idfun R). Proof. by apply/right_continuousW => x; exact: cvg_id. Qed. -HB.instance Definition _ := isCumulative.Build R idfun id_nd id_rc. +HB.instance Definition _ := isCumulative.Build R _ R idfun id_nd id_rc. End id_is_cumulative. (* /TODO: move? *) @@ -373,7 +374,7 @@ apply/andP; split=> //; apply: contraTneq xbj => ->. by rewrite in_itv/= le_gtF// (itvP xabi). Qed. -Lemma wlength_ge0 (f : cumulative R) (I : set (ocitv_type R)) : +Lemma wlength_ge0 (f : cumulative R R) (I : set (ocitv_type R)) : (0 <= wlength f I)%E. Proof. by rewrite -(wlength0 f) le_wlength//; exact: cumulative_is_nondecreasing. @@ -381,14 +382,14 @@ Qed. #[local] Hint Extern 0 (0%:E <= wlength _ _) => solve[apply: wlength_ge0] : core. -HB.instance Definition _ (f : cumulative R) := +HB.instance Definition _ (f : cumulative R R) := isContent.Build _ _ R (wlength f) (wlength_ge0 f) (wlength_semi_additive f). Hint Extern 0 (measurable _) => solve [apply: is_ocitv] : core. -Lemma cumulative_content_sub_fsum (f : cumulative R) (D : {fset nat}) a0 b0 +Lemma cumulative_content_sub_fsum (f : cumulative R R) (D : {fset nat}) a0 b0 (a b : nat -> R) : (forall i, i \in D -> a i <= b i) -> `]a0, b0] `<=` \big[setU/set0]_(i <- D) `]a i, b i]%classic -> f b0 - f a0 <= \sum_(i <- D) (f (b i) - f (a i)). @@ -406,7 +407,7 @@ rewrite -sumEFin fsbig_finite//= set_fsetK// big_seq [in leRHS]big_seq. by apply: lee_sum => i iD; rewrite wlength_itv_bnd// Dab. Qed. -Lemma wlength_sigma_subadditive (f : cumulative R) : +Lemma wlength_sigma_subadditive (f : cumulative R R) : measurable_subset_sigma_subadditive (wlength f). Proof. move=> I A /(_ _)/cid2-/all_sig[b]/all_and2[_]/(_ _)/esym AE => -[a _ <-]. @@ -475,7 +476,7 @@ rewrite big_seq [in X in (_ <= X)%E]big_seq; apply: lee_sum => k kX. by rewrite AE leeD2l// lee_fin lerBlDl natrX De. Qed. -HB.instance Definition _ (f : cumulative R) := +HB.instance Definition _ (f : cumulative R R) := Content_SigmaSubAdditive_isMeasure.Build _ _ _ (wlength f) (wlength_sigma_subadditive f). @@ -490,17 +491,18 @@ move=> k; split => //; rewrite wlength_itv /= -EFinB. by case: ifP; rewrite ltey. Qed. -Definition lebesgue_stieltjes_measure (f : cumulative R) := +Definition lebesgue_stieltjes_measure (f : cumulative R R) := measure_extension (wlength f). -HB.instance Definition _ (f : cumulative R) := +HB.instance Definition _ (f : cumulative R R) := Measure.on (lebesgue_stieltjes_measure f). -Let sigmaT_finite_lebesgue_stieltjes_measure (f : cumulative R) : +Let sigmaT_finite_lebesgue_stieltjes_measure (f : cumulative R R) : sigma_finite setT (lebesgue_stieltjes_measure f). Proof. exact/measure_extension_sigma_finite/wlength_sigma_finite. Qed. -HB.instance Definition _ (f : cumulative R) := @Measure_isSigmaFinite.Build _ _ _ - (lebesgue_stieltjes_measure f) (sigmaT_finite_lebesgue_stieltjes_measure f). +HB.instance Definition _ (f : cumulative R R) := + @Measure_isSigmaFinite.Build _ _ _ (lebesgue_stieltjes_measure f) + (sigmaT_finite_lebesgue_stieltjes_measure f). End wlength_extension. Arguments lebesgue_stieltjes_measure {R}. @@ -512,7 +514,7 @@ Section lebesgue_stieltjes_measure. Variable R : realType. Let gitvs : measurableType _ := g_sigma_algebraType (@ocitv R). -Lemma lebesgue_stieltjes_measure_unique (f : cumulative R) +Lemma lebesgue_stieltjes_measure_unique (f : cumulative R R) (mu : {measure set gitvs -> \bar R}) : (forall X, ocitv X -> lebesgue_stieltjes_measure f X = mu X) -> forall X, measurable X -> lebesgue_stieltjes_measure f X = mu X. @@ -527,17 +529,17 @@ End lebesgue_stieltjes_measure. Section completed_lebesgue_stieltjes_measure. Context {R : realType}. -Definition completed_lebesgue_stieltjes_measure (f : cumulative R) := +Definition completed_lebesgue_stieltjes_measure (f : cumulative R R) := @completed_measure_extension _ _ _ (wlength f). -HB.instance Definition _ (f : cumulative R) := +HB.instance Definition _ (f : cumulative R R) := Measure.on (@completed_lebesgue_stieltjes_measure f). -Let sigmaT_finite_completed_lebesgue_stieltjes_measure (f : cumulative R) : +Let sigmaT_finite_completed_lebesgue_stieltjes_measure (f : cumulative R R) : sigma_finite setT (@completed_lebesgue_stieltjes_measure f). Proof. exact/completed_measure_extension_sigma_finite/wlength_sigma_finite. Qed. -HB.instance Definition _ (f : cumulative R) := +HB.instance Definition _ (f : cumulative R R) := @Measure_isSigmaFinite.Build _ _ _ (@completed_lebesgue_stieltjes_measure f) (sigmaT_finite_completed_lebesgue_stieltjes_measure f). @@ -619,7 +621,7 @@ HB.mixin Record isCumulativeBounded (R : numFieldType) (l r : R) (f : R -> R) := cumulativey : f @ +oo --> r }. #[short(type=cumulativeBounded)] -HB.structure Definition CumulativeBounded (R : numFieldType) (l r : R) := +HB.structure Definition CumulativeBounded (R : realFieldType) (l r : R) := { f of isCumulativeBounded R l r f & Cumulative R f}. Arguments cumulativeNy {R l r} s. diff --git a/theories/probability.v b/theories/probability.v index 0dc7b4f5a8..77d3c1ec28 100644 --- a/theories/probability.v +++ b/theories/probability.v @@ -247,6 +247,41 @@ have cdf_na : cdf X (a + n.+1%:R^-1) @[n --> \oo] --> cdf X a. by rewrite -(cvg_unique _ cdf_ns cdf_na). Unshelve. all: by end_near. Qed. +Lemma ereal_order_nbhsE : forall x : (\bar R), nbhs x = filter_from + (fun i => itv_open_ends i /\ x \in i) (fun i => [set` i]). +Proof. +move=> x; apply/seteqP; split=> A. + rewrite /nbhs/=/ereal_nbhs/=; case x =>[r||]. + - rewrite /nbhs/=/nbhs_ball_/filter_from/=; case=> e e_pos ball_re. + exists `](r - e)%:E, (r + e)%:E[ =>[|y/=]. + split; first by rewrite/itv_open_ends/=; right. + rewrite in_itv/= EFinB gte_subl// EFinD lteDl//; exact/andP. + rewrite in_itv/= => /[dup]/gte_lte_real/fineK<-. + rewrite !lte_fin => fy; apply: ball_re. + by rewrite /ball_/= -opprB normrN ltr_norml ltrBrDl (ltrBlDl _ r). + - case=> M [? MA]; rewrite /filter_from/=. + exists `]M%:E, +oo[ =>[|y/=]; rewrite in_itv/= andbT; last exact: MA. + by split; first by rewrite/itv_open_ends; left. + - case=> M [? MA]; rewrite /filter_from/=. + exists `]-oo, M%:E[ =>[|y/=]; rewrite in_itv/=; last exact: MA. + by split; first by rewrite /itv_open_ends; left. +rewrite /filter_from/= => [][][][[]r|[]][[]s|[]][][]; + rewrite /itv_is_ray/itv_is_bd_open// in_itv/= =>_. + - rewrite /nbhs/=/ereal_nbhs/= => /[dup]/gte_lte_real/fineK<-. + case/andP=> rx sx rsA; apply: (nbhs_interval rx sx) => *. + by apply: rsA =>/=; rewrite in_itv/=; apply/andP. + - rewrite nbhsE/= => rx ?; exists (`]r, +oo[)%classic; rewrite /open_nbhs//. + by split; [rewrite set_itvE; exact: open_ereal_gt_ereal | exact: rx]. + - rewrite nbhsE/= => xs ?; exists (`]-oo, s[)%classic; rewrite /open_nbhs//. + by split; [rewrite set_itvE; exact: open_ereal_lt_ereal | exact: xs]. + - by rewrite set_itvE/= subTset => _ ->; exact: filter_nbhsT. +Qed. + +HB.instance Definition _ := Order_isNbhs.Build _ (\bar R) ereal_order_nbhsE. + +HB.instance Definition _ := isCumulative.Build R _ (\bar R) (cdf X) + cdf_nondecreasing cdf_right_continuous. + End cumulative_distribution_function. Section cdf_of_lebesgue_stieltjes_mesure. From 03c4e66df440a1af59a2a66e706970d13a723987 Mon Sep 17 00:00:00 2001 From: Yosuke-Ito-345 Date: Sun, 13 Jul 2025 14:03:57 +0900 Subject: [PATCH 03/10] generalize cumulative --- .DS_Store | Bin 0 -> 8196 bytes _CoqProject | 1 - reals/#reals.v# | 714 +++++ reals/all_reals.v | 1 - reals/interval_inference.v | 1642 ----------- theories/.DS_Store | Bin 0 -> 6148 bytes theories/HBgraph.dot | 2825 +++++++++++++++++++ theories/cumulative_1.txt | 86 + theories/cumulative_1.v | 86 + theories/cumulative_2.txt | 86 + theories/cumulative_2.v | 86 + theories/cumulative_3.txt | 90 + theories/cumulative_3.v | 90 + theories/lebesgue_integral_theory/.DS_Store | Bin 0 -> 6148 bytes theories/probability_20250713.v | 2015 +++++++++++++ theories/probability_lscdf_20250703.v | 1929 +++++++++++++ theories/topology_theory/.DS_Store | Bin 0 -> 6148 bytes theories/topology_theory/num_topology.v | 4 + 18 files changed, 8011 insertions(+), 1644 deletions(-) create mode 100644 .DS_Store create mode 100644 reals/#reals.v# delete mode 100644 reals/interval_inference.v create mode 100644 theories/.DS_Store create mode 100644 theories/HBgraph.dot create mode 100644 theories/cumulative_1.txt create mode 100644 theories/cumulative_1.v create mode 100644 theories/cumulative_2.txt create mode 100644 theories/cumulative_2.v create mode 100644 theories/cumulative_3.txt create mode 100644 theories/cumulative_3.v create mode 100644 theories/lebesgue_integral_theory/.DS_Store create mode 100644 theories/probability_20250713.v create mode 100644 theories/probability_lscdf_20250703.v create mode 100644 theories/topology_theory/.DS_Store diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..4a74ecdf18e8038add760ae4f4d1c7ed968c88ae GIT binary patch literal 8196 zcmeHMTWl0n7(U;$zzmatX#p)Du(%N_w4trsQCW7&O=?=$-a+c@&Oj$jXO^AWEf*Ub zeFQHr8jVC_;w{nOi;BcVeK01P7!#=^V4`AtGU3GsF>0d!nKRqamPVfpN#`VU{`qg` z^#Aw!&)I*=7(=>bHZxYo7?bJYR99)b#o&7WOc_!nsU`~YXROF=&k3$AUNm zaR%ZH#2JV)5NF_a$N=5he8|(>`$8MfaR%ZH%*YJz^C3YGr>TgJ3K||AG=(hyQQiWC zgWjnR2z?R}O+|E6(9o6E6x{a2um0Z&geX~L# zE3z`6FFt*`dDF(`hD1xt`jLjj=`Afy4T<&lZ5$a<ZwJ@Q{RFmL!euph%O)Sm2*j65tH z!BG@Y#tEFnDLjcYcnVMB8N7g3@fu#o8+aEV;}d*}FK`KC_!i&e2VBEXxQ^d&1HVgi zr3KPLX^~VfHA`EijI>AEFaCC^Qbzri*dlqB=#=w;%BUd9NIEx78SUP)_o028Z{ISy zGG7$V9e38Pnyi1QE!lK?ulc*)YcwB>4|Qhk%FvWp7D zIw5nE>vM#4QoTo}0?}s)wq9K$Q)%e41>2~tlc^YWDP+|aZM{Mzr&kHKQQNG@Is~&# zeL$h&)2juWQqu~rd!2>6)~M~0WnKQy$o>~xf5|SfE9@G(PPqOX)lg7}mADt{um#(Z zA|$tB7uwN*1B7Re<^dSU!Nd?;LiBO?cnl+W9HV%GP<@tg%~Aa#Ucx!Nj5qNX-o`sP zj|=z^7x583!&kVB?S~@WJgy1r1$j3fpm_VLMKA{2zw&o*+~1lZxo5 apd_L3zyA;*zDCFQe|-N70EQ@>dDB0Hfmjp( literal 0 HcmV?d00001 diff --git a/_CoqProject b/_CoqProject index 47e426cfcf..4c48041b47 100644 --- a/_CoqProject +++ b/_CoqProject @@ -30,7 +30,6 @@ reals/constructive_ereal.v reals/reals.v reals/real_interval.v reals/signed.v -reals/interval_inference.v reals/prodnormedzmodule.v reals/all_reals.v experimental_reals/xfinmap.v diff --git a/reals/#reals.v# b/reals/#reals.v# new file mode 100644 index 0000000000..15ca7eaf63 --- /dev/null +++ b/reals/#reals.v# @@ -0,0 +1,714 @@ +(* mathcomp analysis (c) 2017 Inria and AIST. License: CeCILL-C. *) +(* -------------------------------------------------------------------- *) +(* Copyright (c) - 2015--2016 - IMDEA Software Institute *) +(* Copyright (c) - 2015--2018 - Inria *) +(* Copyright (c) - 2016--2018 - Polytechnique *) +(* -------------------------------------------------------------------- *) + +(**md**************************************************************************) +(* # An axiomatization of real numbers $\mathbb{R}$ *) +(* *) +(* This file provides a classical axiomatization of real numbers as a *) +(* discrete real archimedean field with in particular a theory of floor and *) +(* ceil. *) +(* *) +(* ``` *) +(* realType == type of real numbers *) +(* The HB class is Real. *) +(* sup A == where A : set R with R : realType, the supremum of A when *) +(* it exists, 0 otherwise *) +(* inf A := - sup (- A) *) +(* ``` *) +(* *) +(* The mixin corresponding to realType extends an archiFieldType with two *) +(* properties: *) +(* - when sup A exists, it is an upper bound of A (lemma sup_upper_bound) *) +(* - when sup A exists, there exists an element x in A such that *) +(* sup A - eps < x for any 0 < eps (lemma sup_adherent) *) +(* *) +(* ``` *) +(* Rint == the set of real numbers that can be written as z%:~R, *) +(* i.e., as an integer *) +(* Rtoint r == r when r is an integer, 0 otherwise *) +(* floor_set x := [set y | Rtoint y /\ y <= x] *) +(* Rfloor x == the floor of x as a real number *) +(* range1 x := [set y |x <= y < x + 1] *) +(* Rceil x == the ceil of x as a real number, i.e., - Rfloor (- x) *) +(* ``` *) +(* *) +(******************************************************************************) + +From Corelib Require Import Setoid. +From HB Require Import structures. +From mathcomp Require Import all_ssreflect all_algebra archimedean. +From mathcomp Require Import boolp classical_sets set_interval. + +Declare Scope real_scope. + +(* -------------------------------------------------------------------- *) +Set Implicit Arguments. +Unset Strict Implicit. +Unset Printing Implicit Defensive. +Unset SsrOldRewriteGoalsOrder. + +Import Order.TTheory Order.Syntax GRing.Theory Num.Def Num.Theory. +From mathcomp Require Import mathcomp_extra unstable. + +(* -------------------------------------------------------------------- *) +Delimit Scope real_scope with real. + +Local Open Scope classical_set_scope. +Local Open Scope ring_scope. + +Section subr_image. +Variable R : numDomainType. +Implicit Types (E : set R) (x : R). + +Lemma has_ub_lbN E : has_ubound E <-> has_lbound (-%R @` E). +Proof. +rewrite has_lb_ubN image_comp /comp /=. +by under eq_fun do rewrite opprK; rewrite image_id. +Qed. + +Lemma has_lbound0 : has_lbound (@set0 R). Proof. by exists 0. Qed. + +Lemma has_ubound0 : has_ubound (@set0 R). Proof. by exists 0. Qed. + +Lemma ubound0 : ubound (@set0 R) = setT. +Proof. by rewrite predeqE => r; split => // _. Qed. + +Lemma lboundT : lbound [set: R] = set0. +Proof. +rewrite predeqE => r; split => // /(_ (r - 1) Logic.I). +by rewrite addrC -subr_ge0 addrK ler0N1. +Qed. + +End subr_image. + +Section has_bound_lemmas. +Variable R : realDomainType. +Implicit Types E : set R. +Implicit Types x : R. + +Lemma has_ub_image_norm E : has_ubound (normr @` E) -> has_ubound E. +Proof. +case => M /ubP uM; exists `|M|; apply/ubP => r rS. +by rewrite (le_trans (ler_norm _))// (le_trans (uM _ _))//; exact: ler_norm. +Qed. + +Lemma has_inf_supN E : has_sup (-%R @` E) <-> has_inf E. +Proof. +split=> [ [NEn0 [x /ub_lbN xubE]] | [En0 [x /lb_ubN xlbe]] ]. +by split; [apply/nonemptyN|rewrite -[E]setNK; exists (- x)]. +by split; [apply/nonemptyN|exists (- x)]. +Qed. + +Lemma has_supPn {E} : E !=set0 -> + ~ has_sup E <-> (forall x, exists2 y, E y & x < y). +Proof. +move=> nzE; split=> [/asboolPn|/has_ubPn h [_]] //. +by rewrite asbool_and (asboolT nzE) /= => /asboolP/has_ubPn. +Qed. + +End has_bound_lemmas. + +(* -------------------------------------------------------------------- *) + +HB.mixin Record ArchimedeanField_isReal R of Num.ArchiField R := { + sup_upper_bound_subdef : forall E : set R, + has_sup E -> ubound E (supremum 0 E) ; + sup_adherent_subdef : forall (E : set R) (eps : R), + 0 < eps -> has_sup E -> exists2 e : R, E e & (supremum 0 E - eps) < e +}. + +#[short(type=realType)] +HB.structure Definition Real := {R of ArchimedeanField_isReal R + & Num.ArchiField R & Num.RealClosedField R}. + +#[export, non_forgetful_inheritance] +HB.instance Definition _ (R : realType) := + Order_isNbhs.Build _ R (@real_order_nbhsE R). + +Bind Scope ring_scope with Real.sort. + +(* -------------------------------------------------------------------- *) +Definition sup {R : realType} := @supremum _ R 0. +Definition inf {R : realType} (E : set R) := - sup (-%R @` E). + +(* -------------------------------------------------------------------- *) +Lemma sup_upper_bound {R : realType} (E : set R): + has_sup E -> ubound E (sup E). +Proof. exact: sup_upper_bound_subdef. Qed. + +Lemma sup_adherent {R : realType} (E : set R) (eps : R) : 0 < eps -> + has_sup E -> exists2 e : R, E e & (sup E - eps) < e. +Proof. exact: sup_adherent_subdef. Qed. + +(* -------------------------------------------------------------------- *) +Section IsInt. +Context {R : realFieldType}. + +Definition Rint_pred := fun x : R => `[< exists z, x == z%:~R >]. +Arguments Rint_pred _ /. +Definition Rint := [qualify a x | Rint_pred x]. + +Lemma Rint_def x : (x \is a Rint) = (`[< exists z, x == z%:~R >]). +Proof. by []. Qed. + +Lemma RintP x : reflect (exists z, x = z%:~R) (x \in Rint). +Proof. +by apply/(iffP idP) => [/asboolP[z /eqP]|[z]] ->; [|apply/asboolP]; exists z. +Qed. + +Lemma RintC z : z%:~R \is a Rint. +Proof. by apply/RintP; exists z. Qed. + +Lemma Rint0 : 0 \is a Rint. +Proof. by rewrite -[0](mulr0z 1) RintC. Qed. + +Lemma Rint1 : 1 \is a Rint. +Proof. by rewrite -[1]mulr1z RintC. Qed. + +Hint Resolve Rint0 Rint1 RintC : core. + +Lemma Rint_subring_closed : subring_closed Rint. +Proof. +split=> // _ _ /RintP[x ->] /RintP[y ->]; apply/RintP. +by exists (x - y); rewrite rmorphB. by exists (x * y); rewrite rmorphM. +Qed. + +HB.instance Definition _ := GRing.isSubringClosed.Build R Rint_pred + Rint_subring_closed. + +Lemma Rint_ler_addr1 (x y : R) : x \is a Rint -> y \is a Rint -> + (x + 1 <= y) = (x < y). +Proof. +move=> /RintP[xi ->] /RintP[yi ->]; rewrite -{2}[1]mulr1z. +by rewrite -intrD !(ltr_int, ler_int) lezD1. +Qed. + +Lemma Rint_ltr_addr1 (x y : R) : x \is a Rint -> y \is a Rint -> + (x < y + 1) = (x <= y). +Proof. +move=> /RintP[xi ->] /RintP[yi ->]; rewrite -{3}[1]mulr1z. +by rewrite -intrD !(ltr_int, ler_int) ltzD1. +Qed. + +End IsInt. +Arguments Rint_pred _ _ /. + +(* -------------------------------------------------------------------- *) +Section ToInt. +Context {R : realType}. + +Implicit Types x y : R. + +Definition Rtoint (x : R) : int := + if insub x : {? x | x \is a Rint} is Some Px then + xchoose (asboolP _ (tagged Px)) + else 0. + +Lemma RtointK (x : R): x \is a Rint -> (Rtoint x)%:~R = x. +Proof. +move=> Ix; rewrite /Rtoint insubT /= [RHS](eqP (xchooseP (asboolP _ Ix))). +by congr _%:~R; apply/eq_xchoose. +Qed. + +Lemma Rtointz (z : int): Rtoint z%:~R = z. +Proof. by apply/eqP; rewrite -(@eqr_int R) RtointK ?rpred_int. Qed. + +Lemma Rtointn (n : nat): Rtoint n%:R = n%:~R. +Proof. by rewrite -{1}mulrz_nat Rtointz. Qed. + +Lemma inj_Rtoint : {in Rint &, injective Rtoint}. +Proof. by move=> x y Ix Iy /= /(congr1 (@intmul R 1)); rewrite !RtointK. Qed. + +Lemma RtointN x : x \is a Rint -> Rtoint (- x) = - Rtoint x. +Proof. +move=> Ir; apply/eqP. +by rewrite -(@eqr_int R) RtointK // ?rpredN // mulrNz RtointK. +Qed. + +End ToInt. + +(* -------------------------------------------------------------------- *) + +Section RealDerivedOps. +Variable R : realType. + +Implicit Types x y : R. +Definition floor_set x := [set y : R | (y \is a Rint) && (y <= x)]. + +Definition Rfloor x : R := (floor x)%:~R. + +Definition range1 (x : R) := [set y | x <= y < x + 1]. + +Definition Rceil x : R := (ceil x)%:~R. + +End RealDerivedOps. + +(*-------------------------------------------------------------------- *) +Section RealLemmas. + +Variables (R : realType). + +Implicit Types E : set R. +Implicit Types x : R. + +Lemma sup_out E : ~ has_sup E -> sup E = 0. Proof. exact: supremum_out. Qed. + +Lemma sup0 : sup (@set0 R) = 0. Proof. exact: supremum0. Qed. + +Lemma sup1 x : sup [set x] = x. Proof. exact: supremum1. Qed. + +Lemma sup_ubound {E} : has_ubound E -> ubound E (sup E). +Proof. +move=> ubE; apply/ubP=> x x_in_E; move: (x) (x_in_E). +by apply/ubP/sup_upper_bound=> //; split; first by exists x. +Qed. + +Lemma sup_ub_strict E : has_ubound E -> + ~ E (sup E) -> E `<=` [set r | r < sup E]. +Proof. +move=> ubE EsupE r Er; rewrite /mkset lt_neqAle sup_ubound // andbT. +by apply/negP => /eqP supEr; move: EsupE; rewrite -supEr. +Qed. + +Lemma sup_total {E} x : has_sup E -> down E x \/ sup E <= x. +Proof. +move=> has_supE; rewrite orC. +case: (lerP (sup E) x)=> hx /=; [by left|right]. +have /sup_adherent/(_ has_supE) : 0 < sup E - x by rewrite subr_gt0. +by case=> e Ee; rewrite subKr => /ltW hlte; apply/downP; exists e. +Qed. + +Lemma sup_le_ub {E} x : E !=set0 -> (ubound E) x -> sup E <= x. +Proof. +move=> hasE leEx; set y := sup E; pose z := (x + y) / 2%:R. +have Dz: 2%:R * z = x + y by rewrite mulrC divfK// pnatr_eq0. +have ubE : has_sup E by split => //; exists x. +have [/downP [t Et lezt] | leyz] := sup_total z ubE. + rewrite -(lerD2l x) -Dz -mulr2n -[leRHS]mulr_natl. + rewrite ler_pM2l ?ltr0Sn //; apply/(le_trans lezt). + by move/ubP : leEx; exact. +rewrite -(lerD2r y) -Dz -mulr2n -[leLHS]mulr_natl. +by rewrite ler_pM2l ?ltr0Sn. +Qed. + +Lemma sup_setU (A B : set R) : has_sup B -> + (forall a b, A a -> B b -> a <= b) -> sup (A `|` B) = sup B. +Proof. +move=> [B0 [l Bl]] AB; apply/eqP; rewrite eq_le; apply/andP; split. +- apply sup_le_ub => [|x [Ax|]]; first by apply: subset_nonempty B0 => ?; right. + by case: B0 => b Bb; rewrite (le_trans (AB _ _ Ax Bb)) // sup_ubound //; exists l. +- by move=> Bx; rewrite sup_ubound //; exists l. +- apply sup_le_ub => // b Bb; apply: sup_ubound; last by right. + by exists l => x [Ax|Bx]; [rewrite (le_trans (AB _ _ Ax Bb)) // Bl|exact: Bl]. +Qed. + +Lemma sup_gt (S : set R) (x : R) : S !=set0 -> + (x < sup S -> exists2 y, S y & x < y)%R. +Proof. +move=> S0; rewrite not_exists2P => + g; apply/negP; rewrite -leNgt. +by apply sup_le_ub => // y Sy; move: (g y) => -[// | /negP]; rewrite leNgt. +Qed. + +End RealLemmas. +#[deprecated(since="mathcomp-analysis 1.3.0", note="Renamed `sup_ubound`.")] +Notation sup_ub := sup_ubound (only parsing). + +Section sup_sum. +Context {R : realType}. + +Lemma sup_sumE (A B : set R) : + has_sup A -> has_sup B -> sup [set x + y | x in A & y in B] = sup A + sup B. +Proof. +move=> /[dup] supA [[a Aa] ubA] /[dup] supB [[b Bb] ubB]. +have ABsup : has_sup [set x + y | x in A & y in B]. + split; first by exists (a + b), a => //; exists b. + case: ubA ubB => p up [q uq]; exists (p + q) => ? [r Ar [s Bs] <-]. + by apply: lerD; [exact: up | exact: uq]. +apply: le_anti; apply/andP; split. + apply: sup_le_ub; first by case: ABsup. + by move=> ? [p Ap [q Bq] <-]; apply: lerD; exact: sup_ubound. +rewrite leNgt -subr_gt0; apply/negP. +set eps := (_ + _ - _) => epos. +have e2pos : 0 < eps / 2%:R by rewrite divr_gt0// ltr0n. +have [r Ar supBr] := sup_adherent e2pos supA. +have [s Bs supAs] := sup_adherent e2pos supB. +have := ltrD supBr supAs. +rewrite -addrACA -opprD -splitr subKr; apply/negP; rewrite -leNgt. +by apply: sup_upper_bound => //; exists r => //; exists s. +Qed. + +Lemma inf_sumE (A B : set R) : + has_inf A -> has_inf B -> inf [set x + y | x in A & y in B] = inf A + inf B. +Proof. +move/has_inf_supN => ? /has_inf_supN ?; rewrite /inf. +rewrite [X in - sup X = _](_ : _ = + [set x + y | x in [set - x | x in A ] & y in [set - x | x in B]]). + rewrite eqEsubset; split => /= t [] /= x []a Aa. + case => b Bb <- <-; exists (- a); first by exists a. + by exists (- b); [exists b|rewrite opprD]. + move=> <- [y] [b Bb] <- <-; exists (a + b); last by rewrite opprD. + by exists a => //; exists b. +by rewrite sup_sumE // -opprD. +Qed. + +End sup_sum. + +(* -------------------------------------------------------------------- *) +Section InfTheory. + +Variables (R : realType). + +Implicit Types E : set R. +Implicit Types x : R. + +Lemma inf_adherent E (eps : R) : 0 < eps -> + has_inf E -> exists2 e, E e & e < inf E + eps. +Proof. +move=> + /has_inf_supN supNE => /sup_adherent /(_ supNE)[e NEx egtsup]. +exists (- e); first by case: NEx => x Ex <-{}; rewrite opprK. +by rewrite ltrNl -mulN1r mulrDr !mulN1r opprK. +Qed. + +Lemma inf_out E : ~ has_inf E -> inf E = 0. +Proof. +move=> ninfE; rewrite -oppr0 -(@sup_out _ (-%R @` E)) => // supNE; apply: ninfE. +exact/has_inf_supN. +Qed. + +Lemma inf0 : inf (@set0 R) = 0. +Proof. by rewrite /inf image_set0 sup0 oppr0. Qed. + +Lemma inf1 x : inf [set x] = x. +Proof. by rewrite /inf image_set1 sup1 opprK. Qed. + +Lemma inf_lbound E : has_lbound E -> lbound E (inf E). +Proof. by move/has_lb_ubN/sup_ubound/ub_lbN; rewrite setNK. Qed. + +Lemma inf_lb_strict E : has_lbound E -> + ~ E (inf E) -> E `<=` [set r | inf E < r]. +Proof. +move=> lE EinfE r Er; rewrite /mkset lt_neqAle inf_lbound // andbT. +by apply/negP => /eqP infEr; move: EinfE; rewrite infEr. +Qed. + +Lemma lb_le_inf E x : nonempty E -> (lbound E) x -> x <= inf E. +Proof. +by move=> /(nonemptyN E) En0 /lb_ubN /(sup_le_ub En0); rewrite lerNr. +Qed. + +Lemma has_infPn E : nonempty E -> + ~ has_inf E <-> (forall x, exists2 y, E y & y < x). +Proof. +move=> nzE; split=> [/asboolPn|/has_lbPn h [_] //]. +by rewrite asbool_and (asboolT nzE) /= => /asboolP/has_lbPn. +Qed. + +Lemma inf_setU (A B : set R) : has_inf A -> + (forall a b, A a -> B b -> a <= b) -> inf (A `|` B) = inf A. +Proof. +move=> hiA AB; congr (- _). +rewrite image_setU setUC sup_setU //; first exact/has_inf_supN. +by move=> _ _ [] b Bb <-{} [] a Aa <-{}; rewrite lerNl opprK; apply AB. +Qed. + +Lemma inf_lt (S : set R) (x : R) : S !=set0 -> + (inf S < x -> exists2 y, S y & y < x)%R. +Proof. +move=> /nonemptyN S0; rewrite /inf ltrNl => /sup_gt => /(_ S0)[r [r' Sr']]. +by move=> <-; rewrite ltrNr opprK => r'x; exists r'. +Qed. + +End InfTheory. +#[deprecated(since="mathcomp-analysis 1.3.0", note="Renamed `inf_lbound`.")] +Notation inf_lb := inf_lbound (only parsing). + +(* -------------------------------------------------------------------- *) +Section FloorTheory. +Variable R : realType. + +Implicit Types x y : R. + +Lemma has_sup_floor_set x : has_sup (floor_set x). +Proof. +split; [exists (- (Num.bound (-x))%:~R) | exists (Num.bound x)%:~R]. + rewrite /floor_set/mkset rpredN rpred_int /= lerNl. + case: (ger0P (-x)) => [/archi_boundP/ltW//|]. + by move/ltW/le_trans; apply; rewrite ler0z. +apply/ubP=> y /andP[_] /le_trans; apply. +case: (ger0P x)=> [/archi_boundP/ltW|] //. +by move/ltW/le_trans; apply; rewrite ler0z. +Qed. + +Lemma sup_in_floor_set x : (floor_set x) (sup (floor_set x)). +Proof. +have /(sup_adherent ltr01) [y Fy] := has_sup_floor_set x. +have /sup_upper_bound /ubP /(_ _ Fy) := has_sup_floor_set x. +rewrite le_eqVlt=> /orP[/eqP<-//| lt_yFx]. +rewrite ltrBlDr -ltrBlDl => lt1_FxBy. +pose e := sup (floor_set x) - y; have := has_sup_floor_set x. +move/sup_adherent=> -/(_ e) []; first by rewrite subr_gt0. +move=> z Fz; rewrite /= subKr => lt_yz. +have /sup_upper_bound /ubP /(_ _ Fz) := has_sup_floor_set x. +rewrite -(lerD2r (-y)) => /le_lt_trans /(_ lt1_FxBy). +case/andP: Fy Fz lt_yz=> /RintP[yi -> _]. +case/andP=> /RintP[zi -> _]; rewrite -rmorphB /= ltrz1 ltr_int. +rewrite lt_neqAle => /andP[ne_yz le_yz]. +rewrite -[_-_]gez0_abs ?subr_ge0 // ltz_nat ltnS leqn0. +by rewrite absz_eq0 subr_eq0 eq_sym (negbTE ne_yz). +Qed. + +Lemma isint_Rfloor x : Rfloor x \is a Rint. +Proof. by rewrite inE; exists (floor x). Qed. + +Lemma RfloorE x : Rfloor x = (floor x)%:~R. +Proof. by []. Qed. + +Lemma mem_rg1_floor x : (range1 (floor x)%:~R) x. +Proof. by rewrite /range1 /mkset intrD1 ge_floor floorD1_gt. Qed. + +Lemma mem_rg1_Rfloor x : (range1 (Rfloor x)) x. +Proof. exact: mem_rg1_floor. Qed. + +Lemma Rfloor_le x : Rfloor x <= x. +Proof. by case/andP: (mem_rg1_Rfloor x). Qed. + +Lemma lt_succ_Rfloor x : x < Rfloor x + 1. +Proof. by case/andP: (mem_rg1_Rfloor x). Qed. + +Lemma range1z_inj x (m1 m2 : int) : + (range1 m1%:~R) x -> (range1 m2%:~R) x -> m1 = m2. +Proof. +move=> /andP[m1x x_m1] /andP[m2x x_m2]. +wlog suffices: m1 m2 m1x {x_m1 m2x} x_m2 / (m1 <= m2). + by move=> ih; apply/eqP; rewrite eq_le !ih. +rewrite -(lerD2r 1) lezD1 -(@ltr_int R) intrD. +exact/(le_lt_trans m1x). +Qed. + +Lemma range1rr x : (range1 x) x. +Proof. by rewrite /range1/mkset lexx /= ltrDl ltr01. Qed. + +Lemma range1zP (m : int) x : Rfloor x = m%:~R <-> (range1 m%:~R) x. +Proof. +split=> [<-|h]; first exact/mem_rg1_Rfloor. +by congr intmul; apply/floor_def; rewrite -intrD1. +Qed. + +Lemma Rfloor_natz (z : int) : Rfloor z%:~R = z%:~R :> R. +Proof. by apply/range1zP/range1rr. Qed. + +Lemma Rfloor0 : Rfloor 0 = 0 :> R. Proof. by rewrite /Rfloor floor0. Qed. + +Lemma Rfloor1 : Rfloor 1 = 1 :> R. Proof. by rewrite /Rfloor floor1. Qed. + +Lemma le_Rfloor : {homo (@Rfloor R) : x y / x <= y}. +Proof. by move=> x y /Num.Theory.floor_le; rewrite ler_int. Qed. + +Lemma Rfloor_ge_int x (n : int) : (n%:~R <= x)= (n%:~R <= Rfloor x). +Proof. by rewrite ler_int floor_ge_int. Qed. + +Lemma Rfloor_lt_int x (z : int) : (x < z%:~R) = (Rfloor x < z%:~R). +Proof. by rewrite ltr_int -floor_lt_int. Qed. + +Lemma Rfloor_le0 x : x <= 0 -> Rfloor x <= 0. +Proof. by move=> ?; rewrite -Rfloor0 le_Rfloor. Qed. + +Lemma Rfloor_lt0 x : x < 0 -> Rfloor x < 0. +Proof. by move=> x0; rewrite (le_lt_trans _ x0) // Rfloor_le. Qed. + +Lemma ltr_add_invr (y x : R) : y < x -> exists k, y + k.+1%:R^-1 < x. +Proof. +move=> yx; exists (trunc (x - y)^-1). +by rewrite -ltrBrDl invf_plt 1?posrE 1?subr_gt0// truncnS_gt. +Qed. + +End FloorTheory. + +Section CeilTheory. +Variable R : realType. + +Implicit Types x y : R. + +Lemma isint_Rceil x : Rceil x \is a Rint. +Proof. by rewrite /Rceil RintC. Qed. + +Lemma Rceil0 : Rceil 0 = 0 :> R. +Proof. by rewrite /Rceil ceil0. Qed. + +Lemma Rceil_ge x : x <= Rceil x. +Proof. by rewrite Num.Theory.le_ceil ?num_real. Qed. + +Lemma le_Rceil : {homo (@Rceil R) : x y / x <= y}. +Proof. by move=> x y ?; rewrite /Rceil ler_int ceil_le. Qed. + +Lemma Rceil_ge0 x : 0 <= x -> 0 <= Rceil x. +Proof. by move=> x0; rewrite /Rceil ler0z -(ceil0 R) ceil_le. Qed. + +Lemma RceilE x : Rceil x = (ceil x)%:~R. +Proof. by []. Qed. + +#[deprecated(since="mathcomp-analysis 1.3.0", note="use `Num.Theory.ceil_le` instead")] +Lemma le_ceil : {homo @Num.ceil R : x y / x <= y}. +Proof. exact: ceil_le. Qed. + +End CeilTheory. + +(* -------------------------------------------------------------------- *) +Section Sup. +Context {R : realType}. +Implicit Types A B : set R. + +Lemma le_down A : A `<=` down A. +Proof. by move=> x xA; apply/downP; exists x. Qed. + +Lemma downK A : down (down A) = down A. +Proof. +rewrite predeqE => x; split; last by move=> Ax; apply/downP; exists x. +case/downP => y /downP[z Az yz xy]. +by apply/downP; exists z => //; rewrite (le_trans xy). +Qed. + +Lemma has_sup_down A : has_sup (down A) <-> has_sup A. +Proof. +split=> -[nzA nzubA]. + case: nzA => x /downP[y yS le_xy]; split; first by exists y. + case: nzubA=> u /ubP ubA; exists u; apply/ubP=> z zS. + by apply/ubA; apply/downP; exists z. +case: nzA => x xA; split; first by exists x; apply/le_down. +case: nzubA => u /ubP ubA; exists u; apply/ubP=> y /downP []. +by move=> z zA /le_trans; apply; apply/ubA. +Qed. + +Lemma le_sup A B : A `<=` down B -> nonempty A -> has_sup B -> + sup A <= sup B. +Proof. +move=> le_AB nz_A hs_B; have hs_A: has_sup A. + split=> //; case: hs_B => _ [x ubx]. + exists x; apply/ubP=> y /le_AB /downP[z zB le_yz]. + by apply/(le_trans le_yz); move/ubP: ubx; apply. +rewrite leNgt -subr_gt0; apply/negP => lt_sup. +case: (sup_adherent lt_sup hs_A )=> x /le_AB xdB. +rewrite subKr => lt_Bx; case/downP: xdB => z zB. +move/(lt_le_trans lt_Bx); rewrite ltNge. +by move/ubP : (sup_upper_bound hs_B) => ->. +Qed. + +Lemma le_inf A B : -%R @` B `<=` down (-%R @` A) -> nonempty B -> has_inf A -> + inf A <= inf B. +Proof. +move=> SBA AB Ai; rewrite lerNl opprK le_sup// ?has_inf_supN//. +exact/nonemptyN. +Qed. + +Lemma sup_down A : sup (down A) = sup A. +Proof. +have [supA|supNA] := pselect (has_sup A); last first. + by rewrite !sup_out // => /has_sup_down. +have supDA : has_sup (down A) by apply/has_sup_down. +apply/eqP; rewrite eq_le !le_sup //. +- by case: supA => -[x xA] _; exists x; apply/le_down. +- by rewrite downK; exact: le_down. +- by case: supA. +Qed. + +Lemma lt_sup_imfset {T : Type} (F : T -> R) l : + has_sup [set y | exists x, y = F x] -> + l < sup [set y | exists x, y = F x] -> + exists2 x, l < F x & F x <= sup [set y | exists x, y = F x]. +Proof. +set P := [set y | _] => hs; rewrite -subr_gt0. +move=> /sup_adherent/(_ hs)[_ [x ->]]; rewrite subKr=> lt_lFx. +by exists x => //; move/ubP : (sup_upper_bound hs) => -> //; exists x. +Qed. + +Lemma lt_inf_imfset {T : Type} (F : T -> R) l : + has_inf [set y | exists x, y = F x] -> + inf [set y | exists x, y = F x] < l -> + exists2 x, F x < l & inf [set y | exists x, y = F x] <= F x. +Proof. +set P := [set y | _]; move=> hs; rewrite -subr_gt0. +move=> /inf_adherent/(_ hs)[_ [x ->]]; rewrite addrC subrK => ltFxl. +by exists x => //; rewrite (inf_lbound hs.2)//; exists x. +Qed. + +End Sup. + +Lemma int_lbound_has_minimum (B : set int) i : B !=set0 -> lbound B i -> + exists j, B j /\ forall k, B k -> j <= k. +Proof. +move=> [i0 Bi0] lbBi; have [n i0in] : exists n, i0 - i = n%:Z. + by exists `|i0 - i|%N; rewrite gez0_abs // subr_ge0; exact: lbBi. +elim: n i lbBi i0in => [i lbBi /eqP|n ih i lbBi i0in1]. + by rewrite subr_eq0 => /eqP i0i; exists i0; split =>// k Bk; rewrite i0i lbBi. +have i0i1n : i0 - (i + 1) = n by rewrite opprD addrA i0in1 -addn1 PoszD addrK. +have [?|/not_forallP] := pselect (lbound B (i + 1)); first exact: (ih (i + 1)). +move=> /contrapT[x /not_implyP[Bx i1x]]; exists x; split => // k Bk. +rewrite (le_trans _ (lbBi _ Bk)) //. +by move/negP : i1x; rewrite -ltNge ltzD1. +Qed. + +Section rat_in_itvoo. + +Let bound_div (R : archiFieldType) (x y : R) : nat := + if y < 0 then 0%N else Num.bound (y / x). + +Let archi_bound_divP (R : archiFieldType) (x y : R) : + 0 < x -> y < x *+ bound_div x y. +Proof. +move=> x0; have [y0|y0] := leP 0 y; last by rewrite /bound_div y0 mulr0n. +rewrite /bound_div (ltNge y 0) y0/= -mulr_natl -ltr_pdivrMr//. +by rewrite archi_boundP// (divr_ge0 _(ltW _)). +Qed. + +Lemma rat_in_itvoo (R : archiFieldType) (x y : R) : + x < y -> exists q, ratr q \in `]x, y[. +Proof. +move=> xy; move: (xy); rewrite -subr_gt0. +move=> /(archi_bound_divP 1); set n := bound_div _ _ => nyx. +have [m1 m1nx] : exists m1, m1.+1%:~R > x *+ n. + have := archi_bound_divP (x *+ n) ltr01; set p := bound_div _ _ => nxp. + have [x0|x0] := ltP 0 x. + exists p.-1; rewrite prednK // lt0n; apply: contraPN nxp => /eqP ->. + by apply/negP; rewrite -leNgt mulrn_wge0 // ltW. + by exists 0%N; rewrite (le_lt_trans _ ltr01) // mulrn_wle0. +have [m2 m2nx] : exists m2, m2.+1%:~R > - x *+ n. + have := archi_bound_divP (- x *+ n) ltr01; set p := bound_div _ _ => nxp. + have [x0|x0] := ltP 0 x. + by exists O; rewrite (le_lt_trans _ ltr01) // nmulrn_rle0// oppr_lt0. + exists p.-1; rewrite prednK // -(ltr_nat R) (le_lt_trans _ nxp) //. + by rewrite mulrn_wge0 // oppr_ge0. +have : exists m, -(m2.+1 : int) <= m <= m1.+1 /\ m%:~R - 1 <= x *+ n < m%:~R. + have m2m1 : - (m2.+1 : int) < m1.+1. + by rewrite -(ltr_int R) (lt_trans _ m1nx)// rmorphN /= ltrNl // -mulNrn. + pose B := [set m : int | m%:~R > x *+ n]. + have m1B : B m1.+1 by []. + have m2B : lbound B (- m2.+1%:~R). + move=> i; rewrite /B /= -(opprK (x *+ n)) -ltrNl -mulNrn => nxi. + rewrite -(mulN1r m2.+1%:~R) mulN1r -lerNl. + by have := lt_trans nxi m2nx; rewrite intz -mulrNz ltr_int => /ltW. + have [m [Bm infB]] := int_lbound_has_minimum (ex_intro _ _ m1B) m2B. + have mN1B : ~ B (m - 1). + by move=> /infB; apply/negP; rewrite -ltNge ltrBlDr ltzD1. + exists m; split; [apply/andP; split|apply/andP; split] => //. + - by move: m2B; rewrite /lbound /= => /(_ _ Bm); rewrite intz. + - exact: infB. + - by rewrite leNgt; apply/negP; rewrite /B /= intrD in mN1B. +move=> [m [/andP[m2m mm1] /andP[mnx nxm]]]. +have [/andP[a b] c] : x *+ n < m%:~R <= 1 + x *+ n /\ 1 + x *+ n < y *+ n. + split; [apply/andP; split|] => //; first by rewrite -lerBlDl. + by move: nyx; rewrite mulrnDl -ltrBrDr mulNrn. +have n_gt0 : n != 0%N by apply: contraTN nyx => /eqP ->; rewrite mulr0n ltr10. +exists (m%:Q / n%:Q); rewrite in_itv /=; apply/andP; split. + rewrite rmorphM/= (@rmorphV _ _ _ n%:~R); first by rewrite unitfE // intr_eq0. + rewrite ltr_pdivlMr /=; first by rewrite ltr0q ltr0z ltz_nat lt0n. + by rewrite mulrC // !ratr_int mulr_natl. +rewrite rmorphM /= (@rmorphV _ _ _ n%:~R); first by rewrite unitfE // intr_eq0. +rewrite ltr_pdivrMr /=; first by rewrite ltr0q ltr0z ltz_nat lt0n. +by rewrite 2!ratr_int mulr_natr (le_lt_trans _ c). +Qed. + +End rat_in_itvoo. diff --git a/reals/all_reals.v b/reals/all_reals.v index 38290e6736..928723a8a3 100644 --- a/reals/all_reals.v +++ b/reals/all_reals.v @@ -1,4 +1,3 @@ -From mathcomp Require Export interval_inference. From mathcomp Require Export constructive_ereal. From mathcomp Require Export reals. From mathcomp Require Export real_interval. diff --git a/reals/interval_inference.v b/reals/interval_inference.v deleted file mode 100644 index d3be1c30eb..0000000000 --- a/reals/interval_inference.v +++ /dev/null @@ -1,1642 +0,0 @@ -(* mathcomp analysis (c) 2017 Inria and AIST. License: CeCILL-C. *) -From HB Require Import structures. -From mathcomp Require Import ssreflect ssrfun ssrbool. -From mathcomp Require Import ssrnat eqtype choice order ssralg ssrnum ssrint. -From mathcomp Require Import interval. -From mathcomp Require Import mathcomp_extra. - -(* N.B.: This file has been backported in mathcomp-algebra 2.4.0, when -performing changes here, be careful to keep both files reasonnably in -sync during the transition period before we can remove the current -file (i.e. the day we'll require mathcomp >= 2.4.0). *) - -(**md**************************************************************************) -(* # Numbers within an interval *) -(* *) -(* This file develops tools to make the manipulation of numbers within *) -(* a known interval easier, thanks to canonical structures. This adds types *) -(* like {itv R & `[a, b]}, a notation e%:itv that infers an enclosing *) -(* interval for expression e according to existing canonical instances and *) -(* %:num to cast back from type {itv R & i} to R. *) -(* For instance, for x : {i01 R}, we have (1 - x%:num)%:itv : {i01 R} *) -(* automatically inferred. *) -(* *) -(* ## types for values within known interval *) -(* *) -(* ``` *) -(* {itv R & i} == generic type of values in interval i : interval int *) -(* See interval.v for notations that can be used for i. *) -(* R must have a numDomainType structure. This type is shown *) -(* to be a porderType. *) -(* {i01 R} := {itv R & `[0, 1]} *) -(* Allows to solve automatically goals of the form x >= 0 *) -(* and x <= 1 when x is canonically a {i01 R}. *) -(* {i01 R} is canonically stable by common operations. *) -(* {posnum R} := {itv R & `]0, +oo[) *) -(* {nonneg R} := {itv R & `[0, +oo[) *) -(* ``` *) -(* *) -(* ## casts from/to values within known interval *) -(* *) -(* Explicit casts of x to some {itv R & i} according to existing canonical *) -(* instances: *) -(* ``` *) -(* x%:itv == cast to the most precisely known {itv R & i} *) -(* x%:i01 == cast to {i01 R}, or fail *) -(* x%:pos == cast to {posnum R}, or fail *) -(* x%:nng == cast to {nonneg R}, or fail *) -(* ``` *) -(* *) -(* Explicit casts of x from some {itv R & i} to R: *) -(* ``` *) -(* x%:num == cast from {itv R & i} *) -(* x%:posnum == cast from {posnum R} *) -(* x%:nngnum == cast from {nonneg R} *) -(* ``` *) -(* *) -(* ## sign proofs *) -(* *) -(* ``` *) -(* [itv of x] == proof that x is in the interval inferred by x%:itv *) -(* [gt0 of x] == proof that x > 0 *) -(* [lt0 of x] == proof that x < 0 *) -(* [ge0 of x] == proof that x >= 0 *) -(* [le0 of x] == proof that x <= 0 *) -(* [cmp0 of x] == proof that 0 >=< x *) -(* [neq0 of x] == proof that x != 0 *) -(* ``` *) -(* *) -(* ## constructors *) -(* *) -(* ``` *) -(* ItvNum xr lx xu == builds a {itv R & i} from proofs xr : x \in Num.real, *) -(* lx : map_itv_bound (Itv.num_sem R) l <= BLeft x *) -(* xu : BRight x <= map_itv_bound (Itv.num_sem R) u *) -(* where x : R with R : numDomainType *) -(* and l u : itv_bound int *) -(* ItvReal lx xu == builds a {itv R & i} from proofs *) -(* lx : map_itv_bound (Itv.num_sem R) l <= BLeft x *) -(* xu : BRight x <= map_itv_bound (Itv.num_sem R) u *) -(* where x : R with R : realDomainType *) -(* and l u : itv_bound int *) -(* Itv01 x0 x1 == builds a {i01 R} from proofs x0 : 0 <= x and x1 : x <= 1*) -(* where x : R with R : numDomainType *) -(* PosNum x0 == builds a {posnum R} from a proof x0 : x > 0 where x : R *) -(* NngNum x0 == builds a {posnum R} from a proof x0 : x >= 0 where x : R*) -(* ``` *) -(* *) -(* A number of canonical instances are provided for common operations, if *) -(* your favorite operator is missing, look below for examples on how to add *) -(* the appropriate Canonical. *) -(* Also note that all provided instances aren't necessarily optimal, *) -(* improvements welcome! *) -(* Canonical instances are also provided according to types, as a *) -(* fallback when no known operator appears in the expression. Look to top_typ *) -(* below for an example on how to add your favorite type. *) -(* *) -(******************************************************************************) - -Reserved Notation "{ 'itv' R & i }" - (at level 0, R at level 200, i at level 200, format "{ 'itv' R & i }"). -Reserved Notation "{ 'i01' R }" - (at level 0, R at level 200, format "{ 'i01' R }"). -Reserved Notation "{ 'posnum' R }" (at level 0, format "{ 'posnum' R }"). -Reserved Notation "{ 'nonneg' R }" (at level 0, format "{ 'nonneg' R }"). - -Reserved Notation "x %:itv" (at level 2, format "x %:itv"). -Reserved Notation "x %:i01" (at level 2, format "x %:i01"). -Reserved Notation "x %:pos" (at level 2, format "x %:pos"). -Reserved Notation "x %:nng" (at level 2, format "x %:nng"). -Reserved Notation "x %:inum" (at level 2, format "x %:inum"). -Reserved Notation "x %:num" (at level 2, format "x %:num"). -Reserved Notation "x %:posnum" (at level 2, format "x %:posnum"). -Reserved Notation "x %:nngnum" (at level 2, format "x %:nngnum"). - -Reserved Notation "[ 'itv' 'of' x ]" (format "[ 'itv' 'of' x ]"). -Reserved Notation "[ 'gt0' 'of' x ]" (format "[ 'gt0' 'of' x ]"). -Reserved Notation "[ 'lt0' 'of' x ]" (format "[ 'lt0' 'of' x ]"). -Reserved Notation "[ 'ge0' 'of' x ]" (format "[ 'ge0' 'of' x ]"). -Reserved Notation "[ 'le0' 'of' x ]" (format "[ 'le0' 'of' x ]"). -Reserved Notation "[ 'cmp0' 'of' x ]" (format "[ 'cmp0' 'of' x ]"). -Reserved Notation "[ 'neq0' 'of' x ]" (format "[ 'neq0' 'of' x ]"). - -Set Implicit Arguments. -Unset Strict Implicit. -Unset Printing Implicit Defensive. -Import Order.TTheory Order.Syntax. -Import GRing.Theory Num.Theory. - -Local Open Scope ring_scope. -Local Open Scope order_scope. - -Definition map_itv_bound S T (f : S -> T) (b : itv_bound S) : itv_bound T := - match b with - | BSide b x => BSide b (f x) - | BInfty b => BInfty _ b - end. - -Lemma map_itv_bound_comp S T U (f : T -> S) (g : U -> T) (b : itv_bound U) : - map_itv_bound (f \o g) b = map_itv_bound f (map_itv_bound g b). -Proof. by case: b. Qed. - -Definition map_itv S T (f : S -> T) (i : interval S) : interval T := - let 'Interval l u := i in Interval (map_itv_bound f l) (map_itv_bound f u). - -Lemma map_itv_comp S T U (f : T -> S) (g : U -> T) (i : interval U) : - map_itv (f \o g) i = map_itv f (map_itv g i). -Proof. by case: i => l u /=; rewrite -!map_itv_bound_comp. Qed. - -(* First, the interval arithmetic operations we will later use *) -Module IntItv. -Implicit Types (b : itv_bound int) (i j : interval int). - -Definition opp_bound b := - match b with - | BSide b x => BSide (~~ b) (intZmod.oppz x) - | BInfty b => BInfty _ (~~ b) - end. - -Lemma opp_bound_ge0 b : (BLeft 0%R <= opp_bound b)%O = (b <= BRight 0%R)%O. -Proof. by case: b => [[] b | []//]; rewrite /= !bnd_simp oppr_ge0. Qed. - -Lemma opp_bound_gt0 b : (BRight 0%R <= opp_bound b)%O = (b <= BLeft 0%R)%O. -Proof. -by case: b => [[] b | []//]; rewrite /= !bnd_simp ?oppr_ge0 ?oppr_gt0. -Qed. - -Definition opp i := - let: Interval l u := i in Interval (opp_bound u) (opp_bound l). -Arguments opp /. - -Definition add_boundl b1 b2 := - match b1, b2 with - | BSide b1 x1, BSide b2 x2 => BSide (b1 && b2) (intZmod.addz x1 x2) - | _, _ => BInfty _ true - end. - -Definition add_boundr b1 b2 := - match b1, b2 with - | BSide b1 x1, BSide b2 x2 => BSide (b1 || b2) (intZmod.addz x1 x2) - | _, _ => BInfty _ false - end. - -Definition add i1 i2 := - let: Interval l1 u1 := i1 in let: Interval l2 u2 := i2 in - Interval (add_boundl l1 l2) (add_boundr u1 u2). -Arguments add /. - -Variant signb := EqZero | NonNeg | NonPos. - -Definition sign_boundl b := - let: b0 := BLeft 0%Z in - if b == b0 then EqZero else if (b <= b0)%O then NonPos else NonNeg. - -Definition sign_boundr b := - let: b0 := BRight 0%Z in - if b == b0 then EqZero else if (b <= b0)%O then NonPos else NonNeg. - -Variant signi := Known of signb | Unknown | Empty. - -Definition sign i : signi := - let: Interval l u := i in - match sign_boundl l, sign_boundr u with - | EqZero, NonPos - | NonNeg, EqZero - | NonNeg, NonPos => Empty - | EqZero, EqZero => Known EqZero - | NonPos, EqZero - | NonPos, NonPos => Known NonPos - | EqZero, NonNeg - | NonNeg, NonNeg => Known NonNeg - | NonPos, NonNeg => Unknown - end. - -Definition mul_boundl b1 b2 := - match b1, b2 with - | BInfty _, _ - | _, BInfty _ - | BLeft 0%Z, _ - | _, BLeft 0%Z => BLeft 0%Z - | BSide b1 x1, BSide b2 x2 => BSide (b1 && b2) (intRing.mulz x1 x2) - end. - -Definition mul_boundr b1 b2 := - match b1, b2 with - | BLeft 0%Z, _ - | _, BLeft 0%Z => BLeft 0%Z - | BRight 0%Z, _ - | _, BRight 0%Z => BRight 0%Z - | BSide b1 x1, BSide b2 x2 => BSide (b1 || b2) (intRing.mulz x1 x2) - | _, BInfty _ - | BInfty _, _ => +oo%O - end. - -Lemma mul_boundrC b1 b2 : mul_boundr b1 b2 = mul_boundr b2 b1. -Proof. -by move: b1 b2 => [[] [[|?]|?] | []] [[] [[|?]|?] | []] //=; rewrite mulnC. -Qed. - -Lemma mul_boundr_gt0 b1 b2 : - (BRight 0%Z <= b1 -> BRight 0%Z <= b2 -> BRight 0%Z <= mul_boundr b1 b2)%O. -Proof. -case: b1 b2 => [b1b b1 | []] [b2b b2 | []]//=. -- by case: b1b b2b => -[]; case: b1 b2 => [[|b1] | b1] [[|b2] | b2]. -- by case: b1b b1 => -[[] |]. -- by case: b2b b2 => -[[] |]. -Qed. - -Definition mul i1 i2 := - let: Interval l1 u1 := i1 in let: Interval l2 u2 := i2 in - let: opp := opp_bound in - let: mull := mul_boundl in let: mulr := mul_boundr in - match sign i1, sign i2 with - | Empty, _ | _, Empty => `[1, 0] - | Known EqZero, _ | _, Known EqZero => `[0, 0] - | Known NonNeg, Known NonNeg => - Interval (mull l1 l2) (mulr u1 u2) - | Known NonPos, Known NonPos => - Interval (mull (opp u1) (opp u2)) (mulr (opp l1) (opp l2)) - | Known NonNeg, Known NonPos => - Interval (opp (mulr u1 (opp l2))) (opp (mull l1 (opp u2))) - | Known NonPos, Known NonNeg => - Interval (opp (mulr (opp l1) u2)) (opp (mull (opp u1) l2)) - | Known NonNeg, Unknown => - Interval (opp (mulr u1 (opp l2))) (mulr u1 u2) - | Known NonPos, Unknown => - Interval (opp (mulr (opp l1) u2)) (mulr (opp l1) (opp l2)) - | Unknown, Known NonNeg => - Interval (opp (mulr (opp l1) u2)) (mulr u1 u2) - | Unknown, Known NonPos => - Interval (opp (mulr u1 (opp l2))) (mulr (opp l1) (opp l2)) - | Unknown, Unknown => - Interval - (Order.min (opp (mulr (opp l1) u2)) (opp (mulr u1 (opp l2)))) - (Order.max (mulr (opp l1) (opp l2)) (mulr u1 u2)) - end. -Arguments mul /. - -Definition min i j := - let: Interval li ui := i in let: Interval lj uj := j in - Interval (Order.min li lj) (Order.min ui uj). -Arguments min /. - -Definition max i j := - let: Interval li ui := i in let: Interval lj uj := j in - Interval (Order.max li lj) (Order.max ui uj). -Arguments max /. - -Definition keep_nonneg_bound b := - match b with - | BSide _ (Posz _) => BLeft 0%Z - | BSide _ (Negz _) => -oo%O - | BInfty _ => -oo%O - end. -Arguments keep_nonneg_bound /. - -Definition keep_pos_bound b := - match b with - | BSide b 0%Z => BSide b 0%Z - | BSide _ (Posz (S _)) => BRight 0%Z - | BSide _ (Negz _) => -oo - | BInfty _ => -oo - end. -Arguments keep_pos_bound /. - -Definition keep_nonpos_bound b := - match b with - | BSide _ (Negz _) | BSide _ (Posz 0) => BRight 0%Z - | BSide _ (Posz (S _)) => +oo%O - | BInfty _ => +oo%O - end. -Arguments keep_nonpos_bound /. - -Definition keep_neg_bound b := - match b with - | BSide b 0%Z => BSide b 0%Z - | BSide _ (Negz _) => BLeft 0%Z - | BSide _ (Posz _) => +oo - | BInfty _ => +oo - end. -Arguments keep_neg_bound /. - -Definition inv i := - let: Interval l u := i in - Interval (keep_pos_bound l) (keep_neg_bound u). -Arguments inv /. - -Definition exprn_le1_bound b1 b2 := - if b2 isn't BSide _ 1%Z then +oo - else if (BLeft (-1)%Z <= b1)%O then BRight 1%Z else +oo. -Arguments exprn_le1_bound /. - -Definition exprn i := - let: Interval l u := i in - Interval (keep_pos_bound l) (exprn_le1_bound l u). -Arguments exprn /. - -Definition exprz i1 i2 := - let: Interval l2 _ := i2 in - if l2 is BSide _ (Posz _) then exprn i1 else - let: Interval l u := i1 in - Interval (keep_pos_bound l) +oo. -Arguments exprz /. - -Definition keep_sign i := - let: Interval l u := i in - Interval (keep_nonneg_bound l) (keep_nonpos_bound u). - -(* used in ereal.v *) -Definition keep_nonpos i := - let 'Interval l u := i in - Interval -oo%O (keep_nonpos_bound u). -Arguments keep_nonpos /. - -(* used in ereal.v *) -Definition keep_nonneg i := - let 'Interval l u := i in - Interval (keep_nonneg_bound l) +oo%O. -Arguments keep_nonneg /. - -End IntItv. - -Module Itv. - -Variant t := Top | Real of interval int. - -Definition sub (x y : t) := - match x, y with - | _, Top => true - | Top, Real _ => false - | Real xi, Real yi => subitv xi yi - end. - -Section Itv. -Context T (sem : interval int -> T -> bool). - -Definition spec (i : t) (x : T) := if i is Real i then sem i x else true. - -Record def (i : t) := Def { - r : T; - #[canonical=no] - P : spec i r -}. - -End Itv. - -Record typ i := Typ { - sort : Type; - #[canonical=no] - sort_sem : interval int -> sort -> bool; - #[canonical=no] - allP : forall x : sort, spec sort_sem i x -}. - -Definition mk {T f} i x P : @def T f i := @Def T f i x P. - -Definition from {T f i} {x : @def T f i} (phx : phantom T (r x)) := x. - -Definition fromP {T f i} {x : @def T f i} (phx : phantom T (r x)) := P x. - -Definition num_sem (R : numDomainType) (i : interval int) (x : R) : bool := - (x \in Num.real) && (x \in map_itv intr i). - -Definition nat_sem (i : interval int) (x : nat) : bool := Posz x \in i. - -Definition posnum (R : numDomainType) of phant R := - def (@num_sem R) (Real `]0, +oo[). - -Definition nonneg (R : numDomainType) of phant R := - def (@num_sem R) (Real `[0, +oo[). - -(* a few lifting helper functions *) -Definition real1 (op1 : interval int -> interval int) (x : Itv.t) : Itv.t := - match x with Itv.Top => Itv.Top | Itv.Real x => Itv.Real (op1 x) end. - -Definition real2 (op2 : interval int -> interval int -> interval int) - (x y : Itv.t) : Itv.t := - match x, y with - | Itv.Top, _ | _, Itv.Top => Itv.Top - | Itv.Real x, Itv.Real y => Itv.Real (op2 x y) - end. - -Lemma spec_real1 T f (op1 : T -> T) (op1i : interval int -> interval int) : - forall (x : T), (forall xi, f xi x = true -> f (op1i xi) (op1 x) = true) -> - forall xi, spec f xi x -> spec f (real1 op1i xi) (op1 x). -Proof. by move=> x + [//| xi]; apply. Qed. - -Lemma spec_real2 T f (op2 : T -> T -> T) - (op2i : interval int -> interval int -> interval int) (x y : T) : - (forall xi yi, f xi x = true -> f yi y = true -> - f (op2i xi yi) (op2 x y) = true) -> - forall xi yi, spec f xi x -> spec f yi y -> - spec f (real2 op2i xi yi) (op2 x y). -Proof. by move=> + [//| xi] [//| yi]; apply. Qed. - -Module Exports. -Arguments r {T sem i}. -Notation "{ 'itv' R & i }" := (def (@num_sem R) (Itv.Real i%Z)) : type_scope. -Notation "{ 'i01' R }" := {itv R & `[0, 1]} : type_scope. -Notation "{ 'posnum' R }" := (@posnum _ (Phant R)) : ring_scope. -Notation "{ 'nonneg' R }" := (@nonneg _ (Phant R)) : ring_scope. -Notation "x %:itv" := (from (Phantom _ x)) : ring_scope. -Notation "[ 'itv' 'of' x ]" := (fromP (Phantom _ x)) : ring_scope. -Notation num := r. -Notation "x %:inum" := (r x) (only parsing) : ring_scope. -Notation "x %:num" := (r x) : ring_scope. -Notation "x %:posnum" := (@r _ _ (Real `]0%Z, +oo[) x) : ring_scope. -Notation "x %:nngnum" := (@r _ _ (Real `[0%Z, +oo[) x) : ring_scope. -End Exports. -End Itv. -Export Itv.Exports. - -Local Notation num_spec := (Itv.spec (@Itv.num_sem _)). -Local Notation num_def R := (Itv.def (@Itv.num_sem R)). -Local Notation num_itv_bound R := (@map_itv_bound _ R intr). - -Local Notation nat_spec := (Itv.spec Itv.nat_sem). -Local Notation nat_def := (Itv.def Itv.nat_sem). - -Section POrder. -Context d (T : porderType d) (f : interval int -> T -> bool) (i : Itv.t). -Local Notation itv := (Itv.def f i). -HB.instance Definition _ := [isSub for @Itv.r T f i]. -HB.instance Definition _ : Order.POrder d itv := [POrder of itv by <:]. -End POrder. - -Section Order. -Variables (R : numDomainType) (i : interval int). -Local Notation nR := (num_def R (Itv.Real i)). - -Lemma itv_le_total_subproof : total (<=%O : rel nR). -Proof. -move=> x y; apply: real_comparable. -- by case: x => [x /=/andP[]]. -- by case: y => [y /=/andP[]]. -Qed. - -HB.instance Definition _ := Order.POrder_isTotal.Build ring_display nR - itv_le_total_subproof. - -End Order. - -Module TypInstances. - -Lemma top_typ_spec T f (x : T) : Itv.spec f Itv.Top x. -Proof. by []. Qed. - -Canonical top_typ T f := Itv.Typ (@top_typ_spec T f). - -Lemma real_domain_typ_spec (R : realDomainType) (x : R) : - num_spec (Itv.Real `]-oo, +oo[) x. -Proof. by rewrite /Itv.num_sem/= num_real. Qed. - -Canonical real_domain_typ (R : realDomainType) := - Itv.Typ (@real_domain_typ_spec R). - -Lemma real_field_typ_spec (R : realFieldType) (x : R) : - num_spec (Itv.Real `]-oo, +oo[) x. -Proof. exact: real_domain_typ_spec. Qed. - -Canonical real_field_typ (R : realFieldType) := - Itv.Typ (@real_field_typ_spec R). - -Lemma nat_typ_spec (x : nat) : nat_spec (Itv.Real `[0, +oo[) x. -Proof. by []. Qed. - -Canonical nat_typ := Itv.Typ nat_typ_spec. - -Lemma typ_inum_spec (i : Itv.t) (xt : Itv.typ i) (x : Itv.sort xt) : - Itv.spec (@Itv.sort_sem _ xt) i x. -Proof. by move: xt x => []. Qed. - -(* This adds _ <- Itv.r ( typ_inum ) - to canonical projections (c.f., Print Canonical Projections - Itv.r) meaning that if no other canonical instance (with a - registered head symbol) is found, a canonical instance of - Itv.typ, like the ones above, will be looked for. *) -Canonical typ_inum (i : Itv.t) (xt : Itv.typ i) (x : Itv.sort xt) := - Itv.mk (typ_inum_spec x). - -End TypInstances. -Export (canonicals) TypInstances. - -Class unify {T} f (x y : T) := Unify : f x y = true. -#[export] Hint Mode unify + + + + : typeclass_instances. -Class unify' {T} f (x y : T) := Unify' : f x y = true. -#[export] Instance unify'P {T} f (x y : T) : unify' f x y -> unify f x y := id. -#[export] -Hint Extern 0 (unify' _ _ _) => vm_compute; reflexivity : typeclass_instances. - -Notation unify_itv ix iy := (unify Itv.sub ix iy). - -#[export] Instance top_wider_anything i : unify_itv i Itv.Top. -Proof. by case: i. Qed. - -#[export] Instance real_wider_anyreal i : - unify_itv (Itv.Real i) (Itv.Real `]-oo, +oo[). -Proof. by case: i => [l u]; apply/andP; rewrite !bnd_simp. Qed. - -Section NumDomainTheory. -Context {R : numDomainType} {i : Itv.t}. -Implicit Type x : num_def R i. - -Lemma le_num_itv_bound (x y : itv_bound int) : - (num_itv_bound R x <= num_itv_bound R y)%O = (x <= y)%O. -Proof. -by case: x y => [[] x | x] [[] y | y]//=; rewrite !bnd_simp ?ler_int ?ltr_int. -Qed. - -Lemma num_itv_bound_le_BLeft (x : itv_bound int) (y : int) : - (num_itv_bound R x <= BLeft (y%:~R : R))%O = (x <= BLeft y)%O. -Proof. -rewrite -[BLeft y%:~R]/(map_itv_bound intr (BLeft y)). -by rewrite le_num_itv_bound. -Qed. - -Lemma BRight_le_num_itv_bound (x : int) (y : itv_bound int) : - (BRight (x%:~R : R) <= num_itv_bound R y)%O = (BRight x <= y)%O. -Proof. -rewrite -[BRight x%:~R]/(map_itv_bound intr (BRight x)). -by rewrite le_num_itv_bound. -Qed. - -Lemma num_spec_sub (x y : Itv.t) : Itv.sub x y -> - forall z : R, num_spec x z -> num_spec y z. -Proof. -case: x y => [| x] [| y] //= x_sub_y z /andP[rz]; rewrite /Itv.num_sem rz/=. -move: x y x_sub_y => [lx ux] [ly uy] /andP[lel leu] /=. -move=> /andP[lxz zux]; apply/andP; split. -- by apply: le_trans lxz; rewrite le_num_itv_bound. -- by apply: le_trans zux _; rewrite le_num_itv_bound. -Qed. - -Definition empty_itv := Itv.Real `[1, 0]%Z. - -Lemma bottom x : ~ unify_itv i empty_itv. -Proof. -case: x => x /= /[swap] /num_spec_sub /[apply] /andP[_] /=. -by rewrite in_itv/= => /andP[] /le_trans /[apply]; rewrite ler10. -Qed. - -Lemma gt0 x : unify_itv i (Itv.Real `]0%Z, +oo[) -> 0 < x%:num :> R. -Proof. -case: x => x /= /[swap] /num_spec_sub /[apply] /andP[_]. -by rewrite /= in_itv/= andbT. -Qed. - -Lemma le0F x : unify_itv i (Itv.Real `]0%Z, +oo[) -> x%:num <= 0 :> R = false. -Proof. -case: x => x /= /[swap] /num_spec_sub /[apply] /andP[_] /=. -by rewrite in_itv/= andbT => /lt_geF. -Qed. - -Lemma lt0 x : unify_itv i (Itv.Real `]-oo, 0%Z[) -> x%:num < 0 :> R. -Proof. -by case: x => x /= /[swap] /num_spec_sub /[apply] /andP[_] /=; rewrite in_itv. -Qed. - -Lemma ge0F x : unify_itv i (Itv.Real `]-oo, 0%Z[) -> 0 <= x%:num :> R = false. -Proof. -case: x => x /= /[swap] /num_spec_sub /[apply] /andP[_] /=. -by rewrite in_itv/= => /lt_geF. -Qed. - -Lemma ge0 x : unify_itv i (Itv.Real `[0%Z, +oo[) -> 0 <= x%:num :> R. -Proof. -case: x => x /= /[swap] /num_spec_sub /[apply] /andP[_] /=. -by rewrite in_itv/= andbT. -Qed. - -Lemma lt0F x : unify_itv i (Itv.Real `[0%Z, +oo[) -> x%:num < 0 :> R = false. -Proof. -case: x => x /= /[swap] /num_spec_sub /[apply] /andP[_] /=. -by rewrite in_itv/= andbT => /le_gtF. -Qed. - -Lemma le0 x : unify_itv i (Itv.Real `]-oo, 0%Z]) -> x%:num <= 0 :> R. -Proof. -by case: x => x /= /[swap] /num_spec_sub /[apply] /andP[_] /=; rewrite in_itv. -Qed. - -Lemma gt0F x : unify_itv i (Itv.Real `]-oo, 0%Z]) -> 0 < x%:num :> R = false. -Proof. -case: x => x /= /[swap] /num_spec_sub /[apply] /andP[_] /=. -by rewrite in_itv/= => /le_gtF. -Qed. - -Lemma cmp0 x : unify_itv i (Itv.Real `]-oo, +oo[) -> 0 >=< x%:num. -Proof. by case: i x => [//| i' [x /=/andP[]]]. Qed. - -Lemma neq0 x : - unify (fun ix iy => ~~ Itv.sub ix iy) (Itv.Real `[0%Z, 0%Z]) i -> - x%:num != 0 :> R. -Proof. -case: i x => [//| [l u] [x /= Px]]; apply: contra => /eqP x0 /=. -move: Px; rewrite x0 => /and3P[_ /= l0 u0]; apply/andP; split. -- by case: l l0 => [[] l /= |//]; rewrite !bnd_simp ?lerz0 ?ltrz0. -- by case: u u0 => [[] u /= |//]; rewrite !bnd_simp ?ler0z ?ltr0z. -Qed. - -Lemma eq0F x : - unify (fun ix iy => ~~ Itv.sub ix iy) (Itv.Real `[0%Z, 0%Z]) i -> - x%:num == 0 :> R = false. -Proof. by move=> u; apply/negbTE/neq0. Qed. - -Lemma lt1 x : unify_itv i (Itv.Real `]-oo, 1%Z[) -> x%:num < 1 :> R. -Proof. -by case: x => x /= /[swap] /num_spec_sub /[apply] /andP[_] /=; rewrite in_itv. -Qed. - -Lemma ge1F x : unify_itv i (Itv.Real `]-oo, 1%Z[) -> 1 <= x%:num :> R = false. -Proof. -case: x => x /= /[swap] /num_spec_sub /[apply] /andP[_] /=. -by rewrite in_itv/= => /lt_geF. -Qed. - -Lemma le1 x : unify_itv i (Itv.Real `]-oo, 1%Z]) -> x%:num <= 1 :> R. -Proof. -by case: x => x /= /[swap] /num_spec_sub /[apply] /andP[_] /=; rewrite in_itv. -Qed. - -Lemma gt1F x : unify_itv i (Itv.Real `]-oo, 1%Z]) -> 1 < x%:num :> R = false. -Proof. -case: x => x /= /[swap] /num_spec_sub /[apply] /andP[_] /=. -by rewrite in_itv/= => /le_gtF. -Qed. - -Lemma widen_itv_subproof x i' : Itv.sub i i' -> num_spec i' x%:num. -Proof. by case: x => x /= /[swap] /num_spec_sub; apply. Qed. - -Definition widen_itv x i' (uni : unify_itv i i') := - Itv.mk (widen_itv_subproof x uni). - -Lemma widen_itvE x (uni : unify_itv i i) : @widen_itv x i uni = x. -Proof. exact/val_inj. Qed. - -Lemma posE x (uni : unify_itv i (Itv.Real `]0%Z, +oo[)) : - (widen_itv x%:num%:itv uni)%:num = x%:num. -Proof. by []. Qed. - -Lemma nngE x (uni : unify_itv i (Itv.Real `[0%Z, +oo[)) : - (widen_itv x%:num%:itv uni)%:num = x%:num. -Proof. by []. Qed. - -End NumDomainTheory. - -Arguments bottom {R i} _ {_}. -Arguments gt0 {R i} _ {_}. -Arguments le0F {R i} _ {_}. -Arguments lt0 {R i} _ {_}. -Arguments ge0F {R i} _ {_}. -Arguments ge0 {R i} _ {_}. -Arguments lt0F {R i} _ {_}. -Arguments le0 {R i} _ {_}. -Arguments gt0F {R i} _ {_}. -Arguments cmp0 {R i} _ {_}. -Arguments neq0 {R i} _ {_}. -Arguments eq0F {R i} _ {_}. -Arguments lt1 {R i} _ {_}. -Arguments ge1F {R i} _ {_}. -Arguments le1 {R i} _ {_}. -Arguments gt1F {R i} _ {_}. -Arguments widen_itv {R i} _ {_ _}. -Arguments widen_itvE {R i} _ {_}. -Arguments posE {R i} _ {_}. -Arguments nngE {R i} _ {_}. - -Notation "[ 'gt0' 'of' x ]" := (ltac:(refine (gt0 x%:itv))). -Notation "[ 'lt0' 'of' x ]" := (ltac:(refine (lt0 x%:itv))). -Notation "[ 'ge0' 'of' x ]" := (ltac:(refine (ge0 x%:itv))). -Notation "[ 'le0' 'of' x ]" := (ltac:(refine (le0 x%:itv))). -Notation "[ 'cmp0' 'of' x ]" := (ltac:(refine (cmp0 x%:itv))). -Notation "[ 'neq0' 'of' x ]" := (ltac:(refine (neq0 x%:itv))). - -#[export] Hint Extern 0 (is_true (0%R < _)%R) => solve [apply: gt0] : core. -#[export] Hint Extern 0 (is_true (_ < 0%R)%R) => solve [apply: lt0] : core. -#[export] Hint Extern 0 (is_true (0%R <= _)%R) => solve [apply: ge0] : core. -#[export] Hint Extern 0 (is_true (_ <= 0%R)%R) => solve [apply: le0] : core. -#[export] Hint Extern 0 (is_true (_ \is Num.real)) => solve [apply: cmp0] - : core. -#[export] Hint Extern 0 (is_true (0%R >=< _)%R) => solve [apply: cmp0] : core. -#[export] Hint Extern 0 (is_true (_ != 0%R)) => solve [apply: neq0] : core. -#[export] Hint Extern 0 (is_true (_ < 1%R)%R) => solve [apply: lt1] : core. -#[export] Hint Extern 0 (is_true (_ <= 1%R)%R) => solve [apply: le1] : core. - -Notation "x %:i01" := (widen_itv x%:itv : {i01 _}) (only parsing) : ring_scope. -Notation "x %:i01" := (@widen_itv _ _ - (@Itv.from _ _ _ (Phantom _ x)) (Itv.Real `[0, 1]%Z) _) - (only printing) : ring_scope. -Notation "x %:pos" := (widen_itv x%:itv : {posnum _}) (only parsing) - : ring_scope. -Notation "x %:pos" := (@widen_itv _ _ - (@Itv.from _ _ _ (Phantom _ x)) (Itv.Real `]0%Z, +oo[) _) - (only printing) : ring_scope. -Notation "x %:nng" := (widen_itv x%:itv : {nonneg _}) (only parsing) - : ring_scope. -Notation "x %:nng" := (@widen_itv _ _ - (@Itv.from _ _ _ (Phantom _ x)) (Itv.Real `[0%Z, +oo[) _) - (only printing) : ring_scope. - -Local Open Scope ring_scope. - -Module Instances. - -Import IntItv. - -Section NumDomainInstances. -Context {R : numDomainType}. - -Lemma num_spec_zero : num_spec (Itv.Real `[0, 0]) (0 : R). -Proof. by apply/andP; split; [exact: real0 | rewrite /= in_itv/= lexx]. Qed. - -Canonical zero_inum := Itv.mk num_spec_zero. - -Lemma num_spec_one : num_spec (Itv.Real `[1, 1]) (1 : R). -Proof. by apply/andP; split; [exact: real1 | rewrite /= in_itv/= lexx]. Qed. - -Canonical one_inum := Itv.mk num_spec_one. - -Lemma opp_boundr (x : R) b : - (BRight (- x)%R <= num_itv_bound R (opp_bound b))%O - = (num_itv_bound R b <= BLeft x)%O. -Proof. -by case: b => [[] b | []//]; rewrite /= !bnd_simp mulrNz ?lerN2 // ltrN2. -Qed. - -Lemma opp_boundl (x : R) b : - (num_itv_bound R (opp_bound b) <= BLeft (- x)%R)%O - = (BRight x <= num_itv_bound R b)%O. -Proof. -by case: b => [[] b | []//]; rewrite /= !bnd_simp mulrNz ?lerN2 // ltrN2. -Qed. - -Lemma num_spec_opp (i : Itv.t) (x : num_def R i) (r := Itv.real1 opp i) : - num_spec r (- x%:num). -Proof. -apply: Itv.spec_real1 (Itv.P x). -case: x => x /= _ [l u] /and3P[xr lx xu]. -rewrite /Itv.num_sem/= realN xr/=; apply/andP. -by rewrite opp_boundl opp_boundr. -Qed. - -Canonical opp_inum (i : Itv.t) (x : num_def R i) := Itv.mk (num_spec_opp x). - -Lemma num_itv_add_boundl (x1 x2 : R) b1 b2 : - (num_itv_bound R b1 <= BLeft x1)%O -> (num_itv_bound R b2 <= BLeft x2)%O -> - (num_itv_bound R (add_boundl b1 b2) <= BLeft (x1 + x2)%R)%O. -Proof. -case: b1 b2 => [bb1 b1 |//] [bb2 b2 |//]. -case: bb1; case: bb2; rewrite /= !bnd_simp mulrzDr_tmp. -- exact: lerD. -- exact: ler_ltD. -- exact: ltr_leD. -- exact: ltrD. -Qed. - -Lemma num_itv_add_boundr (x1 x2 : R) b1 b2 : - (BRight x1 <= num_itv_bound R b1)%O -> (BRight x2 <= num_itv_bound R b2)%O -> - (BRight (x1 + x2)%R <= num_itv_bound R (add_boundr b1 b2))%O. -Proof. -case: b1 b2 => [bb1 b1 |//] [bb2 b2 |//]. -case: bb1; case: bb2; rewrite /= !bnd_simp mulrzDr_tmp. -- exact: ltrD. -- exact: ltr_leD. -- exact: ler_ltD. -- exact: lerD. -Qed. - -Lemma num_spec_add (xi yi : Itv.t) (x : num_def R xi) (y : num_def R yi) - (r := Itv.real2 add xi yi) : - num_spec r (x%:num + y%:num). -Proof. -apply: Itv.spec_real2 (Itv.P x) (Itv.P y). -case: x y => [x /= _] [y /= _] => {xi yi r} -[lx ux] [ly uy]/=. -move=> /andP[xr /=/andP[lxx xux]] /andP[yr /=/andP[lyy yuy]]. -rewrite /Itv.num_sem realD//=; apply/andP. -by rewrite num_itv_add_boundl ?num_itv_add_boundr. -Qed. - -Canonical add_inum (xi yi : Itv.t) (x : num_def R xi) (y : num_def R yi) := - Itv.mk (num_spec_add x y). - -Variant sign_spec (l u : itv_bound int) (x : R) : signi -> Set := - | ISignEqZero : l = BLeft 0 -> u = BRight 0 -> x = 0 -> - sign_spec l u x (Known EqZero) - | ISignNonNeg : (BLeft 0%:Z <= l)%O -> (BRight 0%:Z < u)%O -> 0 <= x -> - sign_spec l u x (Known NonNeg) - | ISignNonPos : (l < BLeft 0%:Z)%O -> (u <= BRight 0%:Z)%O -> x <= 0 -> - sign_spec l u x (Known NonPos) - | ISignBoth : (l < BLeft 0%:Z)%O -> (BRight 0%:Z < u)%O -> x \in Num.real -> - sign_spec l u x Unknown. - -Lemma signP (l u : itv_bound int) (x : R) : - (num_itv_bound R l <= BLeft x)%O -> (BRight x <= num_itv_bound R u)%O -> - x \in Num.real -> - sign_spec l u x (sign (Interval l u)). -Proof. -move=> + + xr; rewrite /sign/sign_boundl/sign_boundr. -have [lneg|lpos|->] := ltgtP l; have [uneg|upos|->] := ltgtP u => lx xu. -- apply: ISignNonPos => //; first exact: ltW. - have:= le_trans xu (eqbRL (le_num_itv_bound _ _) (ltW uneg)). - by rewrite bnd_simp. -- exact: ISignBoth. -- exact: ISignNonPos. -- have:= @ltxx _ _ (num_itv_bound R l). - rewrite (le_lt_trans lx) -?leBRight_ltBLeft ?(le_trans xu)//. - by rewrite le_num_itv_bound (le_trans (ltW uneg)). -- apply: ISignNonNeg => //; first exact: ltW. - have:= le_trans (eqbRL (le_num_itv_bound _ _) (ltW lpos)) lx. - by rewrite bnd_simp. -- have:= @ltxx _ _ (num_itv_bound R l). - rewrite (le_lt_trans lx) -?leBRight_ltBLeft ?(le_trans xu)//. - by rewrite le_num_itv_bound ?leBRight_ltBLeft. -- have:= @ltxx _ _ (num_itv_bound R (BLeft 0%Z)). - rewrite (le_lt_trans lx) -?leBRight_ltBLeft ?(le_trans xu)//. - by rewrite le_num_itv_bound -?ltBRight_leBLeft. -- exact: ISignNonNeg. -- apply: ISignEqZero => //. - by apply/le_anti/andP; move: lx xu; rewrite !bnd_simp. -Qed. - -Lemma num_itv_mul_boundl b1 b2 (x1 x2 : R) : - (BLeft 0%:Z <= b1 -> BLeft 0%:Z <= b2 -> - num_itv_bound R b1 <= BLeft x1 -> - num_itv_bound R b2 <= BLeft x2 -> - num_itv_bound R (mul_boundl b1 b2) <= BLeft (x1 * x2))%O. -Proof. -move: b1 b2 => [[] b1 | []//] [[] b2 | []//] /=; rewrite 4!bnd_simp. -- set bl := match b1 with 0%Z => _ | _ => _ end. - have -> : bl = BLeft (b1 * b2). - rewrite {}/bl; move: b1 b2 => [[|p1]|p1] [[|p2]|p2]; congr BLeft. - by rewrite mulr0. - by rewrite bnd_simp intrM -2!(ler0z R); apply: ler_pM. -- case: b1 => [[|b1] | b1]; rewrite !bnd_simp// => b1p b2p sx1 sx2. - + by rewrite mulr_ge0 ?(le_trans _ (ltW sx2)) ?ler0z. - + rewrite intrM (@lt_le_trans _ _ (b1.+1%:~R * x2)) ?ltr_pM2l//. - by rewrite ler_pM2r// (le_lt_trans _ sx2) ?ler0z. -- case: b2 => [[|b2] | b2]; rewrite !bnd_simp// => b1p b2p sx1 sx2. - + by rewrite mulr_ge0 ?(le_trans _ (ltW sx1)) ?ler0z. - + rewrite intrM (@le_lt_trans _ _ (b1%:~R * x2)) ?ler_wpM2l ?ler0z//. - by rewrite ltr_pM2r ?(lt_le_trans _ sx2). -- by rewrite -2!(ler0z R) bnd_simp intrM; apply: ltr_pM. -Qed. - -Lemma num_itv_mul_boundr b1 b2 (x1 x2 : R) : - (0 <= x1 -> 0 <= x2 -> - BRight x1 <= num_itv_bound R b1 -> - BRight x2 <= num_itv_bound R b2 -> - BRight (x1 * x2) <= num_itv_bound R (mul_boundr b1 b2))%O. -Proof. -case: b1 b2 => [b1b b1 | []] [b2b b2 | []] //= x1p x2p; last first. -- case: b2b b2 => -[[|//] | //] _ x20. - + have:= @ltxx _ (itv_bound R) (BLeft 0%:~R). - by rewrite (lt_le_trans _ x20). - + have -> : x2 = 0 by apply/le_anti/andP. - by rewrite mulr0. -- case: b1b b1 => -[[|//] |//] x10 _. - + have:= @ltxx _ (itv_bound R) (BLeft 0%Z%:~R). - by rewrite (lt_le_trans _ x10). - + by have -> : x1 = 0; [apply/le_anti/andP | rewrite mul0r]. -case: b1b b2b => -[]; rewrite -[intRing.mulz]/GRing.mul. -- case: b1 => [[|b1] | b1]; rewrite !bnd_simp => x1b x2b. - + by have:= @ltxx _ R 0; rewrite (le_lt_trans x1p x1b). - + case: b2 x2b => [[| b2] | b2] => x2b; rewrite bnd_simp. - * by have:= @ltxx _ R 0; rewrite (le_lt_trans x2p x2b). - * by rewrite intrM ltr_pM. - * have:= @ltxx _ R 0; rewrite (le_lt_trans x2p)//. - by rewrite (lt_le_trans x2b) ?lerz0. - + have:= @ltxx _ R 0; rewrite (le_lt_trans x1p)//. - by rewrite (lt_le_trans x1b) ?lerz0. -- case: b1 => [[|b1] | b1]; rewrite !bnd_simp => x1b x2b. - + by have:= @ltxx _ R 0; rewrite (le_lt_trans x1p x1b). - + case: b2 x2b => [[| b2] | b2] x2b; rewrite bnd_simp. - * exact: mulr_ge0_le0. - * by rewrite intrM (le_lt_trans (ler_wpM2l x1p x2b)) ?ltr_pM2r. - * have:= @ltxx _ _ x2. - by rewrite (le_lt_trans x2b) ?(lt_le_trans _ x2p) ?ltrz0. - + have:= @ltxx _ _ x1. - by rewrite (lt_le_trans x1b) ?(le_trans _ x1p) ?lerz0. -- case: b1 => [[|b1] | b1]; rewrite !bnd_simp => x1b x2b. - + case: b2 x2b => [[|b2] | b2] x2b; rewrite bnd_simp. - * by have:= @ltxx _ _ x2; rewrite (lt_le_trans x2b). - * by have -> : x1 = 0; [apply/le_anti/andP | rewrite mul0r]. - * have:= @ltxx _ _ x2. - by rewrite (lt_le_trans x2b) ?(le_trans _ x2p) ?lerz0. - + case: b2 x2b => [[|b2] | b2] x2b; rewrite bnd_simp. - * by have:= @ltxx _ _ x2; rewrite (lt_le_trans x2b). - * by rewrite intrM (le_lt_trans (ler_wpM2r x2p x1b)) ?ltr_pM2l. - * have:= @ltxx _ _ x2. - by rewrite (lt_le_trans x2b) ?(le_trans _ x2p) ?lerz0. - + have:= @ltxx _ _ x1. - by rewrite (le_lt_trans x1b) ?(lt_le_trans _ x1p) ?ltrz0. -- case: b1 => [[|b1] | b1]; rewrite !bnd_simp => x1b x2b. - + by have -> : x1 = 0; [apply/le_anti/andP | rewrite mul0r]. - + case: b2 x2b => [[| b2] | b2] x2b; rewrite bnd_simp. - * by have -> : x2 = 0; [apply/le_anti/andP | rewrite mulr0]. - * by rewrite intrM ler_pM. - * have:= @ltxx _ _ x2. - by rewrite (le_lt_trans x2b) ?(lt_le_trans _ x2p) ?ltrz0. - + have:= @ltxx _ _ x1. - by rewrite (le_lt_trans x1b) ?(lt_le_trans _ x1p) ?ltrz0. -Qed. - -Lemma BRight_le_mul_boundr b1 b2 (x1 x2 : R) : - (0 <= x1 -> x2 \in Num.real -> BRight 0%Z <= b2 -> - BRight x1 <= num_itv_bound R b1 -> - BRight x2 <= num_itv_bound R b2 -> - BRight (x1 * x2) <= num_itv_bound R (mul_boundr b1 b2))%O. -Proof. -move=> x1ge0 x2r b2ge0 lex1b1 lex2b2. -have /orP[x2ge0 | x2le0] := x2r; first exact: num_itv_mul_boundr. -have lem0 : (BRight (x1 * x2) <= BRight 0%R)%O. - by rewrite bnd_simp mulr_ge0_le0 // ltW. -apply: le_trans lem0 _. -rewrite -(mulr0z 1) BRight_le_num_itv_bound. -apply: mul_boundr_gt0 => //. -by rewrite -(@BRight_le_num_itv_bound R) (le_trans _ lex1b1). -Qed. - -Lemma comparable_num_itv_bound (x y : itv_bound int) : - (num_itv_bound R x >=< num_itv_bound R y)%O. -Proof. -by case: x y => [[] x | []] [[] y | []]//; apply/orP; - rewrite !bnd_simp ?ler_int ?ltr_int; - case: leP => xy; apply/orP => //; rewrite ltW ?orbT. -Qed. - -Lemma num_itv_bound_min (x y : itv_bound int) : - num_itv_bound R (Order.min x y) - = Order.min (num_itv_bound R x) (num_itv_bound R y). -Proof. -have [lexy | ltyx] := leP x y; [by rewrite !minEle le_num_itv_bound lexy|]. -rewrite minElt -if_neg -comparable_leNgt ?le_num_itv_bound ?ltW//. -exact: comparable_num_itv_bound. -Qed. - -Lemma num_itv_bound_max (x y : itv_bound int) : - num_itv_bound R (Order.max x y) - = Order.max (num_itv_bound R x) (num_itv_bound R y). -Proof. -have [lexy | ltyx] := leP x y; [by rewrite !maxEle le_num_itv_bound lexy|]. -rewrite maxElt -if_neg -comparable_leNgt ?le_num_itv_bound ?ltW//. -exact: comparable_num_itv_bound. -Qed. - -Lemma num_spec_mul (xi yi : Itv.t) (x : num_def R xi) (y : num_def R yi) - (r := Itv.real2 mul xi yi) : - num_spec r (x%:num * y%:num). -Proof. -rewrite {}/r; case: xi yi x y => [//| [xl xu]] [//| [yl yu]]. -case=> [x /=/and3P[xr /= xlx xxu]] [y /=/and3P[yr /= yly yyu]]. -rewrite -/(sign (Interval xl xu)) -/(sign (Interval yl yu)). -have ns000 : @Itv.num_sem R `[0, 0] 0 by apply/and3P. -have xyr : x * y \in Num.real by exact: realM. -case: (signP xlx xxu xr) => xlb xub xs. -- by rewrite xs mul0r; case: (signP yly yyu yr). -- case: (signP yly yyu yr) => ylb yub ys. - + by rewrite ys mulr0. - + apply/and3P; split=> //=. - * exact: num_itv_mul_boundl xlx yly. - * exact: num_itv_mul_boundr xxu yyu. - + apply/and3P; split=> //=; rewrite -[x * y]opprK -mulrN. - * by rewrite opp_boundl num_itv_mul_boundr ?oppr_ge0// opp_boundr. - * by rewrite opp_boundr num_itv_mul_boundl ?opp_boundl// opp_bound_ge0. - + apply/and3P; split=> //=. - * rewrite -[x * y]opprK -mulrN opp_boundl. - by rewrite BRight_le_mul_boundr ?realN ?opp_boundr// opp_bound_gt0 ltW. - * by rewrite BRight_le_mul_boundr// ltW. -- case: (signP yly yyu yr) => ylb yub ys. - + by rewrite ys mulr0. - + apply/and3P; split=> //=; rewrite -[x * y]opprK -mulNr. - * rewrite opp_boundl. - by rewrite num_itv_mul_boundr ?oppr_ge0 ?opp_boundr. - * by rewrite opp_boundr num_itv_mul_boundl ?opp_boundl// opp_bound_ge0. - + apply/and3P; split=> //=; rewrite -mulrNN. - * by rewrite num_itv_mul_boundl ?opp_bound_ge0 ?opp_boundl. - * by rewrite num_itv_mul_boundr ?oppr_ge0 ?opp_boundr. - + apply/and3P; split=> //=; rewrite -[x * y]opprK. - * rewrite -mulNr opp_boundl BRight_le_mul_boundr ?oppr_ge0 ?opp_boundr//. - exact: ltW. - * rewrite opprK -mulrNN. - by rewrite BRight_le_mul_boundr ?opp_boundr - ?oppr_ge0 ?realN ?opp_bound_gt0// ltW. -- case: (signP yly yyu yr) => ylb yub ys. - + by rewrite ys mulr0. - + apply/and3P; split=> //=; rewrite mulrC mul_boundrC. - * rewrite -[y * x]opprK -mulrN opp_boundl. - rewrite BRight_le_mul_boundr ?oppr_ge0 ?realN ?opp_boundr//. - by rewrite opp_bound_gt0 ltW. - * by rewrite BRight_le_mul_boundr// ltW. - + apply/and3P; split=> //=; rewrite mulrC mul_boundrC. - * rewrite -[y * x]opprK -mulNr opp_boundl. - by rewrite BRight_le_mul_boundr ?oppr_ge0 ?opp_boundr// ltW. - * rewrite -mulrNN BRight_le_mul_boundr ?oppr_ge0 ?realN ?opp_boundr//. - by rewrite opp_bound_gt0 ltW. -apply/and3P; rewrite xyr/= num_itv_bound_min num_itv_bound_max. -rewrite (comparable_ge_min _ (comparable_num_itv_bound _ _)). -rewrite (comparable_le_max _ (comparable_num_itv_bound _ _)). -case: (comparable_leP xr) => [x0 | /ltW x0]; split=> //. -- apply/orP; right; rewrite -[x * y]opprK -mulrN opp_boundl. - by rewrite BRight_le_mul_boundr ?realN ?opp_boundr// opp_bound_gt0 ltW. -- by apply/orP; right; rewrite BRight_le_mul_boundr// ltW. -- apply/orP; left; rewrite -[x * y]opprK -mulNr opp_boundl. - by rewrite BRight_le_mul_boundr ?oppr_ge0 ?opp_boundr// ltW. -- apply/orP; left; rewrite -mulrNN. - rewrite BRight_le_mul_boundr ?oppr_ge0 ?realN ?opp_boundr//. - by rewrite opp_bound_gt0 ltW. -Qed. - -Canonical mul_inum (xi yi : Itv.t) (x : num_def R xi) (y : num_def R yi) := - Itv.mk (num_spec_mul x y). - -Lemma num_spec_min (xi yi : Itv.t) (x : num_def R xi) (y : num_def R yi) - (r := Itv.real2 min xi yi) : - num_spec r (Order.min x%:num y%:num). -Proof. -apply: Itv.spec_real2 (Itv.P x) (Itv.P y). -case: x y => [x /= _] [y /= _] => {xi yi r} -[lx ux] [ly uy]/=. -move=> /andP[xr /=/andP[lxx xux]] /andP[yr /=/andP[lyy yuy]]. -apply/and3P; split; rewrite ?min_real//= num_itv_bound_min real_BSide_min//. -- apply: (comparable_le_min2 (comparable_num_itv_bound _ _)) => //. - exact: real_comparable. -- apply: (comparable_le_min2 _ (comparable_num_itv_bound _ _)) => //. - exact: real_comparable. -Qed. - -Lemma num_spec_max (xi yi : Itv.t) (x : num_def R xi) (y : num_def R yi) - (r := Itv.real2 max xi yi) : - num_spec r (Order.max x%:num y%:num). -Proof. -apply: Itv.spec_real2 (Itv.P x) (Itv.P y). -case: x y => [x /= _] [y /= _] => {xi yi r} -[lx ux] [ly uy]/=. -move=> /andP[xr /=/andP[lxx xux]] /andP[yr /=/andP[lyy yuy]]. -apply/and3P; split; rewrite ?max_real//= num_itv_bound_max real_BSide_max//. -- apply: (comparable_le_max2 (comparable_num_itv_bound _ _)) => //. - exact: real_comparable. -- apply: (comparable_le_max2 _ (comparable_num_itv_bound _ _)) => //. - exact: real_comparable. -Qed. - -(* We can't directly put an instance on Order.min for R : numDomainType - since we may want instances for other porderType - (typically \bar R or even nat). So we resort on this additional - canonical structure. *) -Record min_max_typ d := MinMaxTyp { - min_max_sort : porderType d; - #[canonical=no] - min_max_sem : interval int -> min_max_sort -> bool; - #[canonical=no] - min_max_minP : forall (xi yi : Itv.t) (x : Itv.def min_max_sem xi) - (y : Itv.def min_max_sem yi), - let: r := Itv.real2 min xi yi in - Itv.spec min_max_sem r (Order.min x%:num y%:num); - #[canonical=no] - min_max_maxP : forall (xi yi : Itv.t) (x : Itv.def min_max_sem xi) - (y : Itv.def min_max_sem yi), - let: r := Itv.real2 max xi yi in - Itv.spec min_max_sem r (Order.max x%:num y%:num); -}. - -(* The default instances on porderType, for min... *) -Canonical min_typ_inum d (t : min_max_typ d) (xi yi : Itv.t) - (x : Itv.def (@min_max_sem d t) xi) (y : Itv.def (@min_max_sem d t) yi) - (r := Itv.real2 min xi yi) := - Itv.mk (min_max_minP x y). - -(* ...and for max *) -Canonical max_typ_inum d (t : min_max_typ d) (xi yi : Itv.t) - (x : Itv.def (@min_max_sem d t) xi) (y : Itv.def (@min_max_sem d t) yi) - (r := Itv.real2 min xi yi) := - Itv.mk (min_max_maxP x y). - -(* Instance of the above structure for numDomainType *) -Canonical num_min_max_typ := MinMaxTyp num_spec_min num_spec_max. - -Lemma nat_num_spec (i : Itv.t) (n : nat) : nat_spec i n = num_spec i (n%:R : R). -Proof. -case: i => [//| [l u]]; rewrite /= /Itv.num_sem realn/=; congr (_ && _). -- by case: l => [[] l |//]; rewrite !bnd_simp ?pmulrn ?ler_int ?ltr_int. -- by case: u => [[] u |//]; rewrite !bnd_simp ?pmulrn ?ler_int ?ltr_int. -Qed. - -Definition natmul_itv (i1 i2 : Itv.t) : Itv.t := - match i1, i2 with - | Itv.Top, _ => Itv.Top - | _, Itv.Top => Itv.Real `]-oo, +oo[ - | Itv.Real i1, Itv.Real i2 => Itv.Real (mul i1 i2) - end. -Arguments natmul_itv /. - -Lemma num_spec_natmul (xi ni : Itv.t) (x : num_def R xi) (n : nat_def ni) - (r := natmul_itv xi ni) : - num_spec r (x%:num *+ n%:num). -Proof. -rewrite {}/r; case: xi x ni n => [//| xi] x [| ni] n. - by apply/and3P; case: n%:num => [|?]; rewrite ?mulr0n ?realrMn. -have Pn : num_spec (Itv.Real ni) (n%:num%:R : R). - by case: n => /= n; rewrite [Itv.nat_sem ni n](nat_num_spec (Itv.Real ni)). -rewrite -mulr_natr -[n%:num%:R]/((Itv.Def Pn)%:num). -by rewrite (@num_spec_mul (Itv.Real xi) (Itv.Real ni)). -Qed. - -Canonical natmul_inum (xi ni : Itv.t) (x : num_def R xi) (n : nat_def ni) := - Itv.mk (num_spec_natmul x n). - -Lemma num_spec_int (i : Itv.t) (n : int) : - num_spec i n = num_spec i (n%:~R : R). -Proof. -case: i => [//| [l u]]; rewrite /= /Itv.num_sem num_real realz/=. -congr (andb _ _). -- by case: l => [[] l |//]; rewrite !bnd_simp intz ?ler_int ?ltr_int. -- by case: u => [[] u |//]; rewrite !bnd_simp intz ?ler_int ?ltr_int. -Qed. - -Lemma num_spec_intmul (xi ii : Itv.t) (x : num_def R xi) (i : num_def int ii) - (r := natmul_itv xi ii) : - num_spec r (x%:num *~ i%:num). -Proof. -rewrite {}/r; case: xi x ii i => [//| xi] x [| ii] i. - by apply/and3P; case: i%:inum => [[|n] | n]; rewrite ?mulr0z ?realN ?realrMn. -have Pi : num_spec (Itv.Real ii) (i%:num%:~R : R). - by case: i => /= i; rewrite [Itv.num_sem ii i](num_spec_int (Itv.Real ii)). -rewrite -mulrzr -[i%:num%:~R]/((Itv.Def Pi)%:num). -by rewrite (@num_spec_mul (Itv.Real xi) (Itv.Real ii)). -Qed. - -Canonical intmul_inum (xi ni : Itv.t) (x : num_def R xi) (n : num_def int ni) := - Itv.mk (num_spec_intmul x n). - -Lemma num_itv_bound_keep_pos (op : R -> R) (x : R) b : - {homo op : x / 0 <= x} -> {homo op : x / 0 < x} -> - (num_itv_bound R b <= BLeft x)%O -> - (num_itv_bound R (keep_pos_bound b) <= BLeft (op x))%O. -Proof. -case: b => [[] [] [| b] // | []//] hle hlt; rewrite !bnd_simp. -- exact: hle. -- by move=> blex; apply: le_lt_trans (hlt _ _) => //; apply: lt_le_trans blex. -- exact: hlt. -- by move=> bltx; apply: le_lt_trans (hlt _ _) => //; apply: le_lt_trans bltx. -Qed. - -Lemma num_itv_bound_keep_neg (op : R -> R) (x : R) b : - {homo op : x / x <= 0} -> {homo op : x / x < 0} -> - (BRight x <= num_itv_bound R b)%O -> - (BRight (op x) <= num_itv_bound R (keep_neg_bound b))%O. -Proof. -case: b => [[] [[|//] | b] | []//] hge hgt; rewrite !bnd_simp. -- exact: hgt. -- by move=> xltb; apply: hgt; apply: lt_le_trans xltb _; rewrite lerz0. -- exact: hge. -- by move=> xleb; apply: hgt; apply: le_lt_trans xleb _; rewrite ltrz0. -Qed. - -Lemma num_spec_inv (i : Itv.t) (x : num_def R i) (r := Itv.real1 inv i) : - num_spec r (x%:num^-1). -Proof. -apply: Itv.spec_real1 (Itv.P x). -case: x => x /= _ [l u] /and3P[xr /= lx xu]. -rewrite /Itv.num_sem/= realV xr/=; apply/andP; split. -- apply: num_itv_bound_keep_pos lx. - + by move=> ?; rewrite invr_ge0. - + by move=> ?; rewrite invr_gt0. -- apply: num_itv_bound_keep_neg xu. - + by move=> ?; rewrite invr_le0. - + by move=> ?; rewrite invr_lt0. -Qed. - -Canonical inv_inum (i : Itv.t) (x : num_def R i) := Itv.mk (num_spec_inv x). - -Lemma num_itv_bound_exprn_le1 (x : R) n l u : - (num_itv_bound R l <= BLeft x)%O -> - (BRight x <= num_itv_bound R u)%O -> - (BRight (x ^+ n) <= num_itv_bound R (exprn_le1_bound l u))%O. -Proof. -case: u => [bu [[//|[|//]] |//] | []//]. -rewrite /exprn_le1_bound; case: (leP _ l) => [lge1 /= |//] lx xu. -rewrite bnd_simp; case: n => [| n]; rewrite ?expr0//. -have xN1 : -1 <= x. - case: l lge1 lx => [[] l | []//]; rewrite !bnd_simp -(@ler_int R). - - exact: le_trans. - - by move=> + /ltW; apply: le_trans. -have x1 : x <= 1 by case: bu xu; rewrite bnd_simp// => /ltW. -have xr : x \is Num.real by exact: ler1_real. -case: (real_ge0P xr) => x0; first by rewrite expr_le1. -rewrite -[x]opprK exprNn; apply: le_trans (ler_piMl _ _) _. -- by rewrite exprn_ge0 ?oppr_ge0 1?ltW. -- suff: -1 <= (-1) ^+ n.+1 :> R /\ (-1) ^+ n.+1 <= 1 :> R => [[]//|]. - elim: n => [|n [IHn1 IHn2]]; rewrite ?expr1// ![_ ^+ n.+2]exprS !mulN1r. - by rewrite lerNl opprK lerNl. -- by rewrite expr_le1 ?oppr_ge0 1?lerNl// ltW. -Qed. - -Lemma num_spec_exprn (i : Itv.t) (x : num_def R i) n (r := Itv.real1 exprn i) : - num_spec r (x%:num ^+ n). -Proof. -apply: (@Itv.spec_real1 _ _ (fun x => x^+n) _ _ _ _ (Itv.P x)). -case: x => x /= _ [l u] /and3P[xr /= lx xu]. -rewrite /Itv.num_sem realX//=; apply/andP; split. -- apply: (@num_itv_bound_keep_pos (fun x => x^+n)) lx. - + exact: exprn_ge0. - + exact: exprn_gt0. -- exact: num_itv_bound_exprn_le1 lx xu. -Qed. - -Canonical exprn_inum (i : Itv.t) (x : num_def R i) n := - Itv.mk (num_spec_exprn x n). - -Lemma num_spec_exprz (xi ki : Itv.t) (x : num_def R xi) (k : num_def int ki) - (r := Itv.real2 exprz xi ki) : - num_spec r (x%:num ^ k%:num). -Proof. -rewrite {}/r; case: ki k => [|[lk uk]] k; first by case: xi x. -case: xi x => [//|xi x]; rewrite /Itv.real2. -have P : Itv.num_sem - (let 'Interval l _ := xi in Interval (keep_pos_bound l) +oo) - (x%:num ^ k%:num). - case: xi x => lx ux x; apply/and3P; split=> [||//]. - have xr : x%:num \is Num.real by case: x => x /=/andP[]. - by case: k%:num => n; rewrite ?realV realX. - apply: (@num_itv_bound_keep_pos (fun x => x ^ k%:num)); - [exact: exprz_ge0 | exact: exprz_gt0 |]. - by case: x => x /=/and3P[]. -case: lk k P => [slk [lk | lk] | slk] k P; [|exact: P..]. -case: k P => -[k | k] /= => [_ _|]; rewrite -/(exprn xi); last first. - by move=> /and3P[_ /=]; case: slk; rewrite bnd_simp -pmulrn natz. -exact: (@num_spec_exprn (Itv.Real xi)). -Qed. - -Canonical exprz_inum (xi ki : Itv.t) (x : num_def R xi) (k : num_def int ki) := - Itv.mk (num_spec_exprz x k). - -Lemma num_spec_norm {V : normedZmodType R} (x : V) : - num_spec (Itv.Real `[0, +oo[) `|x|. -Proof. by apply/and3P; split; rewrite //= ?normr_real ?bnd_simp ?normr_ge0. Qed. - -Canonical norm_inum {V : normedZmodType R} (x : V) := Itv.mk (num_spec_norm x). - -End NumDomainInstances. - -Section RcfInstances. -Context {R : rcfType}. - -Definition sqrt_itv (i : Itv.t) : Itv.t := - match i with - | Itv.Top => Itv.Real `[0%Z, +oo[ - | Itv.Real (Interval l u) => - match l with - | BSide b 0%Z => Itv.Real (Interval (BSide b 0%Z) +oo) - | BSide b (Posz (S _)) => Itv.Real `]0%Z, +oo[ - | _ => Itv.Real `[0, +oo[ - end - end. -Arguments sqrt_itv /. - -Lemma num_spec_sqrt (i : Itv.t) (x : num_def R i) (r := sqrt_itv i) : - num_spec r (Num.sqrt x%:num). -Proof. -have: Itv.num_sem `[0%Z, +oo[ (Num.sqrt x%:num). - by apply/and3P; rewrite /= num_real !bnd_simp sqrtr_ge0. -rewrite {}/r; case: i x => [//| [[bl [l |//] |//] u]] [x /= +] _. -case: bl l => -[| l] /and3P[xr /= bx _]; apply/and3P; split=> //=; - move: bx; rewrite !bnd_simp ?sqrtr_ge0// sqrtr_gt0; - [exact: lt_le_trans | exact: le_lt_trans..]. -Qed. - -Canonical sqrt_inum (i : Itv.t) (x : num_def R i) := Itv.mk (num_spec_sqrt x). - -End RcfInstances. - -Section NumClosedFieldInstances. -Context {R : numClosedFieldType}. - -Definition sqrtC_itv (i : Itv.t) : Itv.t := - match i with - | Itv.Top => Itv.Top - | Itv.Real (Interval l u) => - match l with - | BSide b (Posz _) => Itv.Real (Interval (BSide b 0%Z) +oo) - | _ => Itv.Top - end - end. -Arguments sqrtC_itv /. - -Lemma num_spec_sqrtC (i : Itv.t) (x : num_def R i) (r := sqrtC_itv i) : - num_spec r (sqrtC x%:num). -Proof. -rewrite {}/r; case: i x => [//| [l u] [x /=/and3P[xr /= lx xu]]]. -case: l lx => [bl [l |//] |[]//] lx; apply/and3P; split=> //=. - by apply: sqrtC_real; case: bl lx => /[!bnd_simp] [|/ltW]; apply: le_trans. -case: bl lx => /[!bnd_simp] lx. -- by rewrite sqrtC_ge0; apply: le_trans lx. -- by rewrite sqrtC_gt0; apply: le_lt_trans lx. -Qed. - -Canonical sqrtC_inum (i : Itv.t) (x : num_def R i) := Itv.mk (num_spec_sqrtC x). - -End NumClosedFieldInstances. - -Section NatInstances. -Local Open Scope nat_scope. -Implicit Type (n : nat). - -Lemma nat_spec_zero : nat_spec (Itv.Real `[0, 0]%Z) 0. Proof. by []. Qed. - -Canonical zeron_inum := Itv.mk nat_spec_zero. - -Lemma nat_spec_add (xi yi : Itv.t) (x : nat_def xi) (y : nat_def yi) - (r := Itv.real2 add xi yi) : - nat_spec r (x%:num + y%:num). -Proof. -have Px : num_spec xi (x%:num%:R : int). - by case: x => /= x; rewrite (@nat_num_spec int). -have Py : num_spec yi (y%:num%:R : int). - by case: y => /= y; rewrite (@nat_num_spec int). -rewrite (@nat_num_spec int) natrD. -rewrite -[x%:num%:R]/((Itv.Def Px)%:num) -[y%:num%:R]/((Itv.Def Py)%:num). -exact: num_spec_add. -Qed. - -Canonical addn_inum (xi yi : Itv.t) (x : nat_def xi) (y : nat_def yi) := - Itv.mk (nat_spec_add x y). - -Lemma nat_spec_succ (i : Itv.t) (n : nat_def i) - (r := Itv.real2 add i (Itv.Real `[1, 1]%Z)) : - nat_spec r (S n%:num). -Proof. -pose i1 := Itv.Real `[1, 1]%Z; have P1 : nat_spec i1 1 by []. -by rewrite -addn1 -[1%N]/((Itv.Def P1)%:num); apply: nat_spec_add. -Qed. - -Canonical succn_inum (i : Itv.t) (n : nat_def i) := Itv.mk (nat_spec_succ n). - -Lemma nat_spec_double (i : Itv.t) (n : nat_def i) (r := Itv.real2 add i i) : - nat_spec r (n%:num.*2). -Proof. by rewrite -addnn nat_spec_add. Qed. - -Canonical double_inum (i : Itv.t) (x : nat_def i) := Itv.mk (nat_spec_double x). - -Lemma nat_spec_mul (xi yi : Itv.t) (x : nat_def xi) (y : nat_def yi) - (r := Itv.real2 mul xi yi) : - nat_spec r (x%:num * y%:num). -Proof. -have Px : num_spec xi (x%:num%:R : int). - by case: x => /= x; rewrite (@nat_num_spec int). -have Py : num_spec yi (y%:num%:R : int). - by case: y => /= y; rewrite (@nat_num_spec int). -rewrite (@nat_num_spec int) natrM. -rewrite -[x%:num%:R]/((Itv.Def Px)%:num) -[y%:num%:R]/((Itv.Def Py)%:num). -exact: num_spec_mul. -Qed. - -Canonical muln_inum (xi yi : Itv.t) (x : nat_def xi) (y : nat_def yi) := - Itv.mk (nat_spec_mul x y). - -Lemma nat_spec_exp (i : Itv.t) (x : nat_def i) n (r := Itv.real1 exprn i) : - nat_spec r (x%:num ^ n). -Proof. -have Px : num_spec i (x%:num%:R : int). - by case: x => /= x; rewrite (@nat_num_spec int). -rewrite (@nat_num_spec int) natrX -[x%:num%:R]/((Itv.Def Px)%:num). -exact: num_spec_exprn. -Qed. - -Canonical expn_inum (i : Itv.t) (x : nat_def i) n := Itv.mk (nat_spec_exp x n). - -Lemma nat_spec_min (xi yi : Itv.t) (x : nat_def xi) (y : nat_def yi) - (r := Itv.real2 min xi yi) : - nat_spec r (minn x%:num y%:num). -Proof. -have Px : num_spec xi (x%:num%:R : int). - by case: x => /= x; rewrite (@nat_num_spec int). -have Py : num_spec yi (y%:num%:R : int). - by case: y => /= y; rewrite (@nat_num_spec int). -rewrite (@nat_num_spec int) -minEnat natr_min. -rewrite -[x%:num%:R]/((Itv.Def Px)%:num) -[y%:num%:R]/((Itv.Def Py)%:num). -exact: num_spec_min. -Qed. - -Canonical minn_inum (xi yi : Itv.t) (x : nat_def xi) (y : nat_def yi) := - Itv.mk (nat_spec_min x y). - -Lemma nat_spec_max (xi yi : Itv.t) (x : nat_def xi) (y : nat_def yi) - (r := Itv.real2 max xi yi) : - nat_spec r (maxn x%:num y%:num). -Proof. -have Px : num_spec xi (x%:num%:R : int). - by case: x => /= x; rewrite (@nat_num_spec int). -have Py : num_spec yi (y%:num%:R : int). - by case: y => /= y; rewrite (@nat_num_spec int). -rewrite (@nat_num_spec int) -maxEnat natr_max. -rewrite -[x%:num%:R]/((Itv.Def Px)%:num) -[y%:num%:R]/((Itv.Def Py)%:num). -exact: num_spec_max. -Qed. - -Canonical maxn_inum (xi yi : Itv.t) (x : nat_def xi) (y : nat_def yi) := - Itv.mk (nat_spec_max x y). - -Canonical nat_min_max_typ := MinMaxTyp nat_spec_min nat_spec_max. - -Lemma nat_spec_factorial (n : nat) : nat_spec (Itv.Real `[1%Z, +oo[) n`!. -Proof. by apply/andP; rewrite bnd_simp lez_nat fact_gt0. Qed. - -Canonical factorial_inum n := Itv.mk (nat_spec_factorial n). - -End NatInstances. - -Section IntInstances. - -Lemma num_spec_Posz n : num_spec (Itv.Real `[0, +oo[) (Posz n). -Proof. by apply/and3P; rewrite /= num_real !bnd_simp. Qed. - -Canonical Posz_inum n := Itv.mk (num_spec_Posz n). - -Lemma num_spec_Negz n : num_spec (Itv.Real `]-oo, -1]) (Negz n). -Proof. by apply/and3P; rewrite /= num_real !bnd_simp. Qed. - -Canonical Negz_inum n := Itv.mk (num_spec_Negz n). - -End IntInstances. - -End Instances. -Export (canonicals) Instances. - -Section Morph. -Context {R : numDomainType} {i : Itv.t}. -Local Notation nR := (num_def R i). -Implicit Types x y : nR. -Local Notation num := (@num R (@Itv.num_sem R) i). - -Lemma num_eq : {mono num : x y / x == y}. Proof. by []. Qed. -Lemma num_le : {mono num : x y / (x <= y)%O}. Proof. by []. Qed. -Lemma num_lt : {mono num : x y / (x < y)%O}. Proof. by []. Qed. -Lemma num_min : {morph num : x y / Order.min x y}. -Proof. by move=> x y; rewrite !minEle num_le -fun_if. Qed. -Lemma num_max : {morph num : x y / Order.max x y}. -Proof. by move=> x y; rewrite !maxEle num_le -fun_if. Qed. - -End Morph. - -Section MorphNum. -Context {R : numDomainType}. - -Lemma num_abs_eq0 (a : R) : (`|a|%:nng == 0%:nng) = (a == 0). -Proof. by rewrite -normr_eq0. Qed. - -End MorphNum. - -Section MorphReal. -Context {R : numDomainType} {i : interval int}. -Local Notation nR := (num_def R (Itv.Real i)). -Implicit Type x y : nR. -Local Notation num := (@num R (@Itv.num_sem R) i). - -Lemma num_le_max a x y : - a <= Num.max x%:num y%:num = (a <= x%:num) || (a <= y%:num). -Proof. by rewrite -comparable_le_max// real_comparable. Qed. - -Lemma num_ge_max a x y : - Num.max x%:num y%:num <= a = (x%:num <= a) && (y%:num <= a). -Proof. by rewrite -comparable_ge_max// real_comparable. Qed. - -Lemma num_le_min a x y : - a <= Num.min x%:num y%:num = (a <= x%:num) && (a <= y%:num). -Proof. by rewrite -comparable_le_min// real_comparable. Qed. - -Lemma num_ge_min a x y : - Num.min x%:num y%:num <= a = (x%:num <= a) || (y%:num <= a). -Proof. by rewrite -comparable_ge_min// real_comparable. Qed. - -Lemma num_lt_max a x y : - a < Num.max x%:num y%:num = (a < x%:num) || (a < y%:num). -Proof. by rewrite -comparable_lt_max// real_comparable. Qed. - -Lemma num_gt_max a x y : - Num.max x%:num y%:num < a = (x%:num < a) && (y%:num < a). -Proof. by rewrite -comparable_gt_max// real_comparable. Qed. - -Lemma num_lt_min a x y : - a < Num.min x%:num y%:num = (a < x%:num) && (a < y%:num). -Proof. by rewrite -comparable_lt_min// real_comparable. Qed. - -Lemma num_gt_min a x y : - Num.min x%:num y%:num < a = (x%:num < a) || (y%:num < a). -Proof. by rewrite -comparable_gt_min// real_comparable. Qed. - -End MorphReal. - -Section MorphGe0. -Context {R : numDomainType}. -Local Notation nR := (num_def R (Itv.Real `[0%Z, +oo[)). -Implicit Type x y : nR. -Local Notation num := (@num R (@Itv.num_sem R) (Itv.Real `[0%Z, +oo[)). - -Lemma num_abs_le a x : 0 <= a -> (`|a|%:nng <= x) = (a <= x%:num). -Proof. by move=> a0; rewrite -num_le//= ger0_norm. Qed. - -Lemma num_abs_lt a x : 0 <= a -> (`|a|%:nng < x) = (a < x%:num). -Proof. by move=> a0; rewrite -num_lt/= ger0_norm. Qed. -End MorphGe0. - -Section ItvNum. -Context (R : numDomainType). -Context (x : R) (l u : itv_bound int). -Context (x_real : x \in Num.real). -Context (l_le_x : (num_itv_bound R l <= BLeft x)%O). -Context (x_le_u : (BRight x <= num_itv_bound R u)%O). -Lemma itvnum_subdef : num_spec (Itv.Real (Interval l u)) x. -Proof. by apply/and3P. Qed. -Definition ItvNum : num_def R (Itv.Real (Interval l u)) := Itv.mk itvnum_subdef. -End ItvNum. - -Section ItvReal. -Context (R : realDomainType). -Context (x : R) (l u : itv_bound int). -Context (l_le_x : (num_itv_bound R l <= BLeft x)%O). -Context (x_le_u : (BRight x <= num_itv_bound R u)%O). -Lemma itvreal_subdef : num_spec (Itv.Real (Interval l u)) x. -Proof. by apply/and3P; split; first exact: num_real. Qed. -Definition ItvReal : num_def R (Itv.Real (Interval l u)) := - Itv.mk itvreal_subdef. -End ItvReal. - -Section Itv01. -Context (R : numDomainType). -Context (x : R) (x_ge0 : 0 <= x) (x_le1 : x <= 1). -Lemma itv01_subdef : num_spec (Itv.Real `[0%Z, 1%Z]) x. -Proof. by apply/and3P; split; rewrite ?bnd_simp// ger0_real. Qed. -Definition Itv01 : num_def R (Itv.Real `[0%Z, 1%Z]) := Itv.mk itv01_subdef. -End Itv01. - -Section Posnum. -Context (R : numDomainType) (x : R) (x_gt0 : 0 < x). -Lemma posnum_subdef : num_spec (Itv.Real `]0, +oo[) x. -Proof. by apply/and3P; rewrite /= gtr0_real. Qed. -Definition PosNum : {posnum R} := Itv.mk posnum_subdef. -End Posnum. - -Section Nngnum. -Context (R : numDomainType) (x : R) (x_ge0 : 0 <= x). -Lemma nngnum_subdef : num_spec (Itv.Real `[0, +oo[) x. -Proof. by apply/and3P; rewrite /= ger0_real. Qed. -Definition NngNum : {nonneg R} := Itv.mk nngnum_subdef. -End Nngnum. - -Variant posnum_spec (R : numDomainType) (x : R) : - R -> bool -> bool -> bool -> Type := -| IsPosnum (p : {posnum R}) : posnum_spec x (p%:num) false true true. - -Lemma posnumP (R : numDomainType) (x : R) : 0 < x -> - posnum_spec x x (x == 0) (0 <= x) (0 < x). -Proof. -move=> x_gt0; case: real_ltgt0P (x_gt0) => []; rewrite ?gtr0_real // => _ _. -by rewrite -[x]/(PosNum x_gt0)%:num; constructor. -Qed. - -Variant nonneg_spec (R : numDomainType) (x : R) : R -> bool -> Type := -| IsNonneg (p : {nonneg R}) : nonneg_spec x (p%:num) true. - -Lemma nonnegP (R : numDomainType) (x : R) : 0 <= x -> nonneg_spec x x (0 <= x). -Proof. by move=> xge0; rewrite xge0 -[x]/(NngNum xge0)%:num; constructor. Qed. - -Section Test1. - -Variable R : numDomainType. -Variable x : {i01 R}. - -Goal 0%:i01 = 1%:i01 :> {i01 R}. -Proof. -Abort. - -Goal (- x%:num)%:itv = (- x%:num)%:itv :> {itv R & `[-1, 0]}. -Proof. -Abort. - -Goal (1 - x%:num)%:i01 = x. -Proof. -Abort. - -End Test1. - -Section Test2. - -Variable R : realDomainType. -Variable x y : {i01 R}. - -Goal (x%:num * y%:num)%:i01 = x%:num%:i01. -Proof. -Abort. - -End Test2. - -Module Test3. -Section Test3. -Variable R : realDomainType. - -Definition s_of_pq (p q : {i01 R}) : {i01 R} := - (1 - ((1 - p%:num)%:i01%:num * (1 - q%:num)%:i01%:num))%:i01. - -Lemma s_of_p0 (p : {i01 R}) : s_of_pq p 0%:i01 = p. -Proof. by apply/val_inj; rewrite /= subr0 mulr1 subKr. Qed. - -End Test3. -End Test3. diff --git a/theories/.DS_Store b/theories/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..5008ddfcf53c02e82d7eee2e57c38e5672ef89f6 GIT binary patch literal 6148 zcmeH~Jr2S!425mzP>H1@V-^m;4Wg<&0T*E43hX&L&p$$qDprKhvt+--jT7}7np#A3 zem<@ulZcFPQ@L2!n>{z**++&mCkOWA81W14cNZlEfg7;MkzE(HCqgga^y>{tEnwC%0;vJ&^%eQ zLs35+`xjp>T0 Monoid_AddLaw; +SemiGroup_ComLaw -> Monoid_AddLaw; +Monoid_Law -> Monoid_AddLaw; +SemiGroup_Law -> Monoid_AddLaw; +choice_Choice -> GRing_Algebra; +eqtype_Equality -> GRing_Algebra; +GRing_LSemiAlgebra -> GRing_Algebra; +GRing_LSemiModule -> GRing_Algebra; +GRing_Lalgebra -> GRing_Algebra; +GRing_Lmodule -> GRing_Algebra; +GRing_Nmodule -> GRing_Algebra; +GRing_NzRing -> GRing_Algebra; +GRing_NzSemiRing -> GRing_Algebra; +GRing_PzRing -> GRing_Algebra; +GRing_PzSemiRing -> GRing_Algebra; +GRing_SemiAlgebra -> GRing_Algebra; +GRing_Zmodule -> GRing_Algebra; +choice_Choice -> AlgebraOfSets; +eqtype_Equality -> AlgebraOfSets; +Pointed -> AlgebraOfSets; +RingOfSets -> AlgebraOfSets; +SemiRingOfSets -> AlgebraOfSets; +Num_ArchiNumDomain -> Num_ArchiClosedField; +Num_ArchiNumField -> Num_ArchiClosedField; +choice_Choice -> Num_ArchiClosedField; +GRing_ClosedField -> Num_ArchiClosedField; +Num_ClosedField -> Num_ArchiClosedField; +GRing_ComNzRing -> Num_ArchiClosedField; +GRing_ComNzSemiRing -> Num_ArchiClosedField; +GRing_ComPzRing -> Num_ArchiClosedField; +GRing_ComPzSemiRing -> Num_ArchiClosedField; +GRing_ComUnitRing -> Num_ArchiClosedField; +GRing_DecidableField -> Num_ArchiClosedField; +eqtype_Equality -> Num_ArchiClosedField; +GRing_Field -> Num_ArchiClosedField; +GRing_IntegralDomain -> Num_ArchiClosedField; +GRing_Nmodule -> Num_ArchiClosedField; +Num_NormedZmodule -> Num_ArchiClosedField; +Num_NumDomain -> Num_ArchiClosedField; +Num_NumField -> Num_ArchiClosedField; +GRing_NzRing -> Num_ArchiClosedField; +GRing_NzSemiRing -> Num_ArchiClosedField; +Order_POrder -> Num_ArchiClosedField; +Num_POrderedZmodule -> Num_ArchiClosedField; +GRing_PzRing -> Num_ArchiClosedField; +GRing_PzSemiRing -> Num_ArchiClosedField; +Num_SemiNormedZmodule -> Num_ArchiClosedField; +GRing_UnitRing -> Num_ArchiClosedField; +GRing_Zmodule -> Num_ArchiClosedField; +choice_Choice -> Num_ArchiNumDomain; +GRing_ComNzRing -> Num_ArchiNumDomain; +GRing_ComNzSemiRing -> Num_ArchiNumDomain; +GRing_ComPzRing -> Num_ArchiNumDomain; +GRing_ComPzSemiRing -> Num_ArchiNumDomain; +GRing_ComUnitRing -> Num_ArchiNumDomain; +eqtype_Equality -> Num_ArchiNumDomain; +GRing_IntegralDomain -> Num_ArchiNumDomain; +GRing_Nmodule -> Num_ArchiNumDomain; +Num_NormedZmodule -> Num_ArchiNumDomain; +Num_NumDomain -> Num_ArchiNumDomain; +GRing_NzRing -> Num_ArchiNumDomain; +GRing_NzSemiRing -> Num_ArchiNumDomain; +Order_POrder -> Num_ArchiNumDomain; +Num_POrderedZmodule -> Num_ArchiNumDomain; +GRing_PzRing -> Num_ArchiNumDomain; +GRing_PzSemiRing -> Num_ArchiNumDomain; +Num_SemiNormedZmodule -> Num_ArchiNumDomain; +GRing_UnitRing -> Num_ArchiNumDomain; +GRing_Zmodule -> Num_ArchiNumDomain; +Num_ArchiNumDomain -> Num_ArchiNumField; +choice_Choice -> Num_ArchiNumField; +GRing_ComNzRing -> Num_ArchiNumField; +GRing_ComNzSemiRing -> Num_ArchiNumField; +GRing_ComPzRing -> Num_ArchiNumField; +GRing_ComPzSemiRing -> Num_ArchiNumField; +GRing_ComUnitRing -> Num_ArchiNumField; +eqtype_Equality -> Num_ArchiNumField; +GRing_Field -> Num_ArchiNumField; +GRing_IntegralDomain -> Num_ArchiNumField; +GRing_Nmodule -> Num_ArchiNumField; +Num_NormedZmodule -> Num_ArchiNumField; +Num_NumDomain -> Num_ArchiNumField; +Num_NumField -> Num_ArchiNumField; +GRing_NzRing -> Num_ArchiNumField; +GRing_NzSemiRing -> Num_ArchiNumField; +Order_POrder -> Num_ArchiNumField; +Num_POrderedZmodule -> Num_ArchiNumField; +GRing_PzRing -> Num_ArchiNumField; +GRing_PzSemiRing -> Num_ArchiNumField; +Num_SemiNormedZmodule -> Num_ArchiNumField; +GRing_UnitRing -> Num_ArchiNumField; +GRing_Zmodule -> Num_ArchiNumField; +Num_ArchiNumDomain -> Num_ArchiRealClosedField; +Num_ArchiNumField -> Num_ArchiRealClosedField; +Num_ArchiRealDomain -> Num_ArchiRealClosedField; +Num_ArchiRealField -> Num_ArchiRealClosedField; +choice_Choice -> Num_ArchiRealClosedField; +GRing_ComNzRing -> Num_ArchiRealClosedField; +GRing_ComNzSemiRing -> Num_ArchiRealClosedField; +GRing_ComPzRing -> Num_ArchiRealClosedField; +GRing_ComPzSemiRing -> Num_ArchiRealClosedField; +GRing_ComUnitRing -> Num_ArchiRealClosedField; +Order_DistrLattice -> Num_ArchiRealClosedField; +eqtype_Equality -> Num_ArchiRealClosedField; +GRing_Field -> Num_ArchiRealClosedField; +GRing_IntegralDomain -> Num_ArchiRealClosedField; +Order_JoinSemilattice -> Num_ArchiRealClosedField; +Order_Lattice -> Num_ArchiRealClosedField; +Order_MeetSemilattice -> Num_ArchiRealClosedField; +GRing_Nmodule -> Num_ArchiRealClosedField; +Num_NormedZmodule -> Num_ArchiRealClosedField; +Num_NumDomain -> Num_ArchiRealClosedField; +Num_NumField -> Num_ArchiRealClosedField; +GRing_NzRing -> Num_ArchiRealClosedField; +GRing_NzSemiRing -> Num_ArchiRealClosedField; +Order_POrder -> Num_ArchiRealClosedField; +Num_POrderedZmodule -> Num_ArchiRealClosedField; +GRing_PzRing -> Num_ArchiRealClosedField; +GRing_PzSemiRing -> Num_ArchiRealClosedField; +Num_RealClosedField -> Num_ArchiRealClosedField; +Num_RealDomain -> Num_ArchiRealClosedField; +Num_RealField -> Num_ArchiRealClosedField; +Num_SemiNormedZmodule -> Num_ArchiRealClosedField; +Order_Total -> Num_ArchiRealClosedField; +GRing_UnitRing -> Num_ArchiRealClosedField; +GRing_Zmodule -> Num_ArchiRealClosedField; +Num_ArchiNumDomain -> Num_ArchiRealDomain; +choice_Choice -> Num_ArchiRealDomain; +GRing_ComNzRing -> Num_ArchiRealDomain; +GRing_ComNzSemiRing -> Num_ArchiRealDomain; +GRing_ComPzRing -> Num_ArchiRealDomain; +GRing_ComPzSemiRing -> Num_ArchiRealDomain; +GRing_ComUnitRing -> Num_ArchiRealDomain; +Order_DistrLattice -> Num_ArchiRealDomain; +eqtype_Equality -> Num_ArchiRealDomain; +GRing_IntegralDomain -> Num_ArchiRealDomain; +Order_JoinSemilattice -> Num_ArchiRealDomain; +Order_Lattice -> Num_ArchiRealDomain; +Order_MeetSemilattice -> Num_ArchiRealDomain; +GRing_Nmodule -> Num_ArchiRealDomain; +Num_NormedZmodule -> Num_ArchiRealDomain; +Num_NumDomain -> Num_ArchiRealDomain; +GRing_NzRing -> Num_ArchiRealDomain; +GRing_NzSemiRing -> Num_ArchiRealDomain; +Order_POrder -> Num_ArchiRealDomain; +Num_POrderedZmodule -> Num_ArchiRealDomain; +GRing_PzRing -> Num_ArchiRealDomain; +GRing_PzSemiRing -> Num_ArchiRealDomain; +Num_RealDomain -> Num_ArchiRealDomain; +Num_SemiNormedZmodule -> Num_ArchiRealDomain; +Order_Total -> Num_ArchiRealDomain; +GRing_UnitRing -> Num_ArchiRealDomain; +GRing_Zmodule -> Num_ArchiRealDomain; +Num_ArchiNumDomain -> Num_ArchiRealField; +Num_ArchiNumField -> Num_ArchiRealField; +Num_ArchiRealDomain -> Num_ArchiRealField; +choice_Choice -> Num_ArchiRealField; +GRing_ComNzRing -> Num_ArchiRealField; +GRing_ComNzSemiRing -> Num_ArchiRealField; +GRing_ComPzRing -> Num_ArchiRealField; +GRing_ComPzSemiRing -> Num_ArchiRealField; +GRing_ComUnitRing -> Num_ArchiRealField; +Order_DistrLattice -> Num_ArchiRealField; +eqtype_Equality -> Num_ArchiRealField; +GRing_Field -> Num_ArchiRealField; +GRing_IntegralDomain -> Num_ArchiRealField; +Order_JoinSemilattice -> Num_ArchiRealField; +Order_Lattice -> Num_ArchiRealField; +Order_MeetSemilattice -> Num_ArchiRealField; +GRing_Nmodule -> Num_ArchiRealField; +Num_NormedZmodule -> Num_ArchiRealField; +Num_NumDomain -> Num_ArchiRealField; +Num_NumField -> Num_ArchiRealField; +GRing_NzRing -> Num_ArchiRealField; +GRing_NzSemiRing -> Num_ArchiRealField; +Order_POrder -> Num_ArchiRealField; +Num_POrderedZmodule -> Num_ArchiRealField; +GRing_PzRing -> Num_ArchiRealField; +GRing_PzSemiRing -> Num_ArchiRealField; +Num_RealDomain -> Num_ArchiRealField; +Num_RealField -> Num_ArchiRealField; +Num_SemiNormedZmodule -> Num_ArchiRealField; +Order_Total -> Num_ArchiRealField; +GRing_UnitRing -> Num_ArchiRealField; +GRing_Zmodule -> Num_ArchiRealField; +Order_BJoinSemilattice -> Order_BDistrLattice; +Order_BLattice -> Order_BDistrLattice; +Order_BMeetSemilattice -> Order_BDistrLattice; +Order_BPOrder -> Order_BDistrLattice; +choice_Choice -> Order_BDistrLattice; +Order_DistrLattice -> Order_BDistrLattice; +eqtype_Equality -> Order_BDistrLattice; +Order_JoinSemilattice -> Order_BDistrLattice; +Order_Lattice -> Order_BDistrLattice; +Order_MeetSemilattice -> Order_BDistrLattice; +Order_POrder -> Order_BDistrLattice; +Order_BLatticeClosed -> Order_BJoinLatticeClosed; +Order_JoinLatticeClosed -> Order_BJoinLatticeClosed; +Order_BPOrder -> Order_BJoinSemilattice; +choice_Choice -> Order_BJoinSemilattice; +eqtype_Equality -> Order_BJoinSemilattice; +Order_JoinSemilattice -> Order_BJoinSemilattice; +Order_POrder -> Order_BJoinSemilattice; +Order_BJoinSemilattice -> Order_BJoinSubLattice; +Order_BLattice -> Order_BJoinSubLattice; +Order_BMeetSemilattice -> Order_BJoinSubLattice; +Order_BPOrder -> Order_BJoinSubLattice; +choice_Choice -> Order_BJoinSubLattice; +eqtype_Equality -> Order_BJoinSubLattice; +Order_JoinSemilattice -> Order_BJoinSubLattice; +Order_JoinSubBLattice -> Order_BJoinSubLattice; +Order_JoinSubLattice -> Order_BJoinSubLattice; +Order_Lattice -> Order_BJoinSubLattice; +Order_MeetSemilattice -> Order_BJoinSubLattice; +Order_POrder -> Order_BJoinSubLattice; +SubChoice -> Order_BJoinSubLattice; +SubEquality -> Order_BJoinSubLattice; +Order_SubPOrder -> Order_BJoinSubLattice; +Order_SubPOrderBLattice -> Order_BJoinSubLattice; +Order_SubPOrderLattice -> Order_BJoinSubLattice; +SubType -> Order_BJoinSubLattice; +Order_BJoinSemilattice -> Order_BJoinSubTLattice; +Order_BJoinSubLattice -> Order_BJoinSubTLattice; +Order_BLattice -> Order_BJoinSubTLattice; +Order_BMeetSemilattice -> Order_BJoinSubTLattice; +Order_BPOrder -> Order_BJoinSubTLattice; +choice_Choice -> Order_BJoinSubTLattice; +eqtype_Equality -> Order_BJoinSubTLattice; +Order_JoinSemilattice -> Order_BJoinSubTLattice; +Order_JoinSubBLattice -> Order_BJoinSubTLattice; +Order_JoinSubLattice -> Order_BJoinSubTLattice; +Order_JoinSubTBLattice -> Order_BJoinSubTLattice; +Order_JoinSubTLattice -> Order_BJoinSubTLattice; +Order_Lattice -> Order_BJoinSubTLattice; +Order_MeetSemilattice -> Order_BJoinSubTLattice; +Order_POrder -> Order_BJoinSubTLattice; +SubChoice -> Order_BJoinSubTLattice; +SubEquality -> Order_BJoinSubTLattice; +Order_SubPOrder -> Order_BJoinSubTLattice; +Order_SubPOrderBLattice -> Order_BJoinSubTLattice; +Order_SubPOrderLattice -> Order_BJoinSubTLattice; +Order_SubPOrderTBLattice -> Order_BJoinSubTLattice; +Order_SubPOrderTLattice -> Order_BJoinSubTLattice; +SubType -> Order_BJoinSubTLattice; +Order_TBJoinSemilattice -> Order_BJoinSubTLattice; +Order_TBLattice -> Order_BJoinSubTLattice; +Order_TBMeetSemilattice -> Order_BJoinSubTLattice; +Order_TBPOrder -> Order_BJoinSubTLattice; +Order_TJoinSemilattice -> Order_BJoinSubTLattice; +Order_TLattice -> Order_BJoinSubTLattice; +Order_TMeetSemilattice -> Order_BJoinSubTLattice; +Order_TPOrder -> Order_BJoinSubTLattice; +Order_BJoinSemilattice -> Order_BLattice; +Order_BMeetSemilattice -> Order_BLattice; +Order_BPOrder -> Order_BLattice; +choice_Choice -> Order_BLattice; +eqtype_Equality -> Order_BLattice; +Order_JoinSemilattice -> Order_BLattice; +Order_Lattice -> Order_BLattice; +Order_MeetSemilattice -> Order_BLattice; +Order_POrder -> Order_BLattice; +Order_BPOrder -> Order_BMeetSemilattice; +choice_Choice -> Order_BMeetSemilattice; +eqtype_Equality -> Order_BMeetSemilattice; +Order_MeetSemilattice -> Order_BMeetSemilattice; +Order_POrder -> Order_BMeetSemilattice; +choice_Choice -> Order_BPOrder; +eqtype_Equality -> Order_BPOrder; +Order_POrder -> Order_BPOrder; +Order_BJoinSemilattice -> Order_BSubLattice; +Order_BJoinSubLattice -> Order_BSubLattice; +Order_BLattice -> Order_BSubLattice; +Order_BMeetSemilattice -> Order_BSubLattice; +Order_BPOrder -> Order_BSubLattice; +choice_Choice -> Order_BSubLattice; +eqtype_Equality -> Order_BSubLattice; +Order_JoinSemilattice -> Order_BSubLattice; +Order_JoinSubBLattice -> Order_BSubLattice; +Order_JoinSubLattice -> Order_BSubLattice; +Order_Lattice -> Order_BSubLattice; +Order_MeetSemilattice -> Order_BSubLattice; +Order_MeetSubBLattice -> Order_BSubLattice; +Order_MeetSubLattice -> Order_BSubLattice; +Order_POrder -> Order_BSubLattice; +Order_SubBLattice -> Order_BSubLattice; +SubChoice -> Order_BSubLattice; +SubEquality -> Order_BSubLattice; +Order_SubLattice -> Order_BSubLattice; +Order_SubPOrder -> Order_BSubLattice; +Order_SubPOrderBLattice -> Order_BSubLattice; +Order_SubPOrderLattice -> Order_BSubLattice; +SubType -> Order_BSubLattice; +Order_BJoinSemilattice -> Order_BSubTLattice; +Order_BJoinSubLattice -> Order_BSubTLattice; +Order_BJoinSubTLattice -> Order_BSubTLattice; +Order_BLattice -> Order_BSubTLattice; +Order_BMeetSemilattice -> Order_BSubTLattice; +Order_BPOrder -> Order_BSubTLattice; +Order_BSubLattice -> Order_BSubTLattice; +choice_Choice -> Order_BSubTLattice; +eqtype_Equality -> Order_BSubTLattice; +Order_JoinSemilattice -> Order_BSubTLattice; +Order_JoinSubBLattice -> Order_BSubTLattice; +Order_JoinSubLattice -> Order_BSubTLattice; +Order_JoinSubTBLattice -> Order_BSubTLattice; +Order_JoinSubTLattice -> Order_BSubTLattice; +Order_Lattice -> Order_BSubTLattice; +Order_MeetSemilattice -> Order_BSubTLattice; +Order_MeetSubBLattice -> Order_BSubTLattice; +Order_MeetSubLattice -> Order_BSubTLattice; +Order_MeetSubTBLattice -> Order_BSubTLattice; +Order_MeetSubTLattice -> Order_BSubTLattice; +Order_POrder -> Order_BSubTLattice; +Order_SubBLattice -> Order_BSubTLattice; +SubChoice -> Order_BSubTLattice; +SubEquality -> Order_BSubTLattice; +Order_SubLattice -> Order_BSubTLattice; +Order_SubPOrder -> Order_BSubTLattice; +Order_SubPOrderBLattice -> Order_BSubTLattice; +Order_SubPOrderLattice -> Order_BSubTLattice; +Order_SubPOrderTBLattice -> Order_BSubTLattice; +Order_SubPOrderTLattice -> Order_BSubTLattice; +Order_SubTBLattice -> Order_BSubTLattice; +Order_SubTLattice -> Order_BSubTLattice; +SubType -> Order_BSubTLattice; +Order_TBJoinSemilattice -> Order_BSubTLattice; +Order_TBLattice -> Order_BSubTLattice; +Order_TBMeetSemilattice -> Order_BSubTLattice; +Order_TBPOrder -> Order_BSubTLattice; +Order_TJoinSemilattice -> Order_BSubTLattice; +Order_TLattice -> Order_BSubTLattice; +Order_TMeetSemilattice -> Order_BSubTLattice; +Order_TPOrder -> Order_BSubTLattice; +Order_BDistrLattice -> Order_BTotal; +Order_BJoinSemilattice -> Order_BTotal; +Order_BLattice -> Order_BTotal; +Order_BMeetSemilattice -> Order_BTotal; +Order_BPOrder -> Order_BTotal; +choice_Choice -> Order_BTotal; +Order_DistrLattice -> Order_BTotal; +eqtype_Equality -> Order_BTotal; +Order_JoinSemilattice -> Order_BTotal; +Order_Lattice -> Order_BTotal; +Order_MeetSemilattice -> Order_BTotal; +Order_POrder -> Order_BTotal; +Order_Total -> Order_BTotal; +choice_Choice -> BaseFinGroup; +Countable -> BaseFinGroup; +eqtype_Equality -> BaseFinGroup; +fintype_Finite -> BaseFinGroup; +choice_Choice -> BiPointed; +eqtype_Equality -> BiPointed; +BiPointed -> BiPointedTopological; +choice_Choice -> BiPointedTopological; +eqtype_Equality -> BiPointedTopological; +Filtered -> BiPointedTopological; +Nbhs -> BiPointedTopological; +Topological -> BiPointedTopological; +Fun -> Bij; +InjFun -> Bij; +Inject -> Bij; +OInvFun -> Bij; +OInversible -> Bij; +SurjFun -> Bij; +Surject -> Bij; +Order_BDistrLattice -> Order_CBDistrLattice; +Order_BJoinSemilattice -> Order_CBDistrLattice; +Order_BLattice -> Order_CBDistrLattice; +Order_BMeetSemilattice -> Order_CBDistrLattice; +Order_BPOrder -> Order_CBDistrLattice; +Order_CDistrLattice -> Order_CBDistrLattice; +choice_Choice -> Order_CBDistrLattice; +Order_DistrLattice -> Order_CBDistrLattice; +eqtype_Equality -> Order_CBDistrLattice; +Order_JoinSemilattice -> Order_CBDistrLattice; +Order_Lattice -> Order_CBDistrLattice; +Order_MeetSemilattice -> Order_CBDistrLattice; +Order_POrder -> Order_CBDistrLattice; +choice_Choice -> Order_CDistrLattice; +Order_DistrLattice -> Order_CDistrLattice; +eqtype_Equality -> Order_CDistrLattice; +Order_JoinSemilattice -> Order_CDistrLattice; +Order_Lattice -> Order_CDistrLattice; +Order_MeetSemilattice -> Order_CDistrLattice; +Order_POrder -> Order_CDistrLattice; +Order_BDistrLattice -> Order_CTBDistrLattice; +Order_BJoinSemilattice -> Order_CTBDistrLattice; +Order_BLattice -> Order_CTBDistrLattice; +Order_BMeetSemilattice -> Order_CTBDistrLattice; +Order_BPOrder -> Order_CTBDistrLattice; +Order_CBDistrLattice -> Order_CTBDistrLattice; +Order_CDistrLattice -> Order_CTBDistrLattice; +Order_CTDistrLattice -> Order_CTBDistrLattice; +choice_Choice -> Order_CTBDistrLattice; +Order_DistrLattice -> Order_CTBDistrLattice; +eqtype_Equality -> Order_CTBDistrLattice; +Order_JoinSemilattice -> Order_CTBDistrLattice; +Order_Lattice -> Order_CTBDistrLattice; +Order_MeetSemilattice -> Order_CTBDistrLattice; +Order_POrder -> Order_CTBDistrLattice; +Order_TBDistrLattice -> Order_CTBDistrLattice; +Order_TBJoinSemilattice -> Order_CTBDistrLattice; +Order_TBLattice -> Order_CTBDistrLattice; +Order_TBMeetSemilattice -> Order_CTBDistrLattice; +Order_TBPOrder -> Order_CTBDistrLattice; +Order_TDistrLattice -> Order_CTBDistrLattice; +Order_TJoinSemilattice -> Order_CTBDistrLattice; +Order_TLattice -> Order_CTBDistrLattice; +Order_TMeetSemilattice -> Order_CTBDistrLattice; +Order_TPOrder -> Order_CTBDistrLattice; +Order_CDistrLattice -> Order_CTDistrLattice; +choice_Choice -> Order_CTDistrLattice; +Order_DistrLattice -> Order_CTDistrLattice; +eqtype_Equality -> Order_CTDistrLattice; +Order_JoinSemilattice -> Order_CTDistrLattice; +Order_Lattice -> Order_CTDistrLattice; +Order_MeetSemilattice -> Order_CTDistrLattice; +Order_POrder -> Order_CTDistrLattice; +Order_TDistrLattice -> Order_CTDistrLattice; +Order_TJoinSemilattice -> Order_CTDistrLattice; +Order_TLattice -> Order_CTDistrLattice; +Order_TMeetSemilattice -> Order_CTDistrLattice; +Order_TPOrder -> Order_CTDistrLattice; +eqtype_Equality -> choice_Choice; +choice_Choice -> GRing_ClosedField; +GRing_ComNzRing -> GRing_ClosedField; +GRing_ComNzSemiRing -> GRing_ClosedField; +GRing_ComPzRing -> GRing_ClosedField; +GRing_ComPzSemiRing -> GRing_ClosedField; +GRing_ComUnitRing -> GRing_ClosedField; +GRing_DecidableField -> GRing_ClosedField; +eqtype_Equality -> GRing_ClosedField; +GRing_Field -> GRing_ClosedField; +GRing_IntegralDomain -> GRing_ClosedField; +GRing_Nmodule -> GRing_ClosedField; +GRing_NzRing -> GRing_ClosedField; +GRing_NzSemiRing -> GRing_ClosedField; +GRing_PzRing -> GRing_ClosedField; +GRing_PzSemiRing -> GRing_ClosedField; +GRing_UnitRing -> GRing_ClosedField; +GRing_Zmodule -> GRing_ClosedField; +choice_Choice -> Num_ClosedField; +GRing_ClosedField -> Num_ClosedField; +GRing_ComNzRing -> Num_ClosedField; +GRing_ComNzSemiRing -> Num_ClosedField; +GRing_ComPzRing -> Num_ClosedField; +GRing_ComPzSemiRing -> Num_ClosedField; +GRing_ComUnitRing -> Num_ClosedField; +GRing_DecidableField -> Num_ClosedField; +eqtype_Equality -> Num_ClosedField; +GRing_Field -> Num_ClosedField; +GRing_IntegralDomain -> Num_ClosedField; +GRing_Nmodule -> Num_ClosedField; +Num_NormedZmodule -> Num_ClosedField; +Num_NumDomain -> Num_ClosedField; +Num_NumField -> Num_ClosedField; +GRing_NzRing -> Num_ClosedField; +GRing_NzSemiRing -> Num_ClosedField; +Order_POrder -> Num_ClosedField; +Num_POrderedZmodule -> Num_ClosedField; +GRing_PzRing -> Num_ClosedField; +GRing_PzSemiRing -> Num_ClosedField; +Num_SemiNormedZmodule -> Num_ClosedField; +GRing_UnitRing -> Num_ClosedField; +GRing_Zmodule -> Num_ClosedField; +GRing_Algebra -> GRing_ComAlgebra; +choice_Choice -> GRing_ComAlgebra; +GRing_ComNzRing -> GRing_ComAlgebra; +GRing_ComNzSemiRing -> GRing_ComAlgebra; +GRing_ComPzRing -> GRing_ComAlgebra; +GRing_ComPzSemiRing -> GRing_ComAlgebra; +GRing_ComSemiAlgebra -> GRing_ComAlgebra; +eqtype_Equality -> GRing_ComAlgebra; +GRing_LSemiAlgebra -> GRing_ComAlgebra; +GRing_LSemiModule -> GRing_ComAlgebra; +GRing_Lalgebra -> GRing_ComAlgebra; +GRing_Lmodule -> GRing_ComAlgebra; +GRing_Nmodule -> GRing_ComAlgebra; +GRing_NzRing -> GRing_ComAlgebra; +GRing_NzSemiRing -> GRing_ComAlgebra; +GRing_PzRing -> GRing_ComAlgebra; +GRing_PzSemiRing -> GRing_ComAlgebra; +GRing_SemiAlgebra -> GRing_ComAlgebra; +GRing_Zmodule -> GRing_ComAlgebra; +SemiGroup_ComLaw -> Monoid_ComLaw; +Monoid_Law -> Monoid_ComLaw; +SemiGroup_Law -> Monoid_ComLaw; +SemiGroup_Law -> SemiGroup_ComLaw; +choice_Choice -> GRing_ComNzRing; +GRing_ComNzSemiRing -> GRing_ComNzRing; +GRing_ComPzRing -> GRing_ComNzRing; +GRing_ComPzSemiRing -> GRing_ComNzRing; +eqtype_Equality -> GRing_ComNzRing; +GRing_Nmodule -> GRing_ComNzRing; +GRing_NzRing -> GRing_ComNzRing; +GRing_NzSemiRing -> GRing_ComNzRing; +GRing_PzRing -> GRing_ComNzRing; +GRing_PzSemiRing -> GRing_ComNzRing; +GRing_Zmodule -> GRing_ComNzRing; +choice_Choice -> GRing_ComNzSemiRing; +GRing_ComPzSemiRing -> GRing_ComNzSemiRing; +eqtype_Equality -> GRing_ComNzSemiRing; +GRing_Nmodule -> GRing_ComNzSemiRing; +GRing_NzSemiRing -> GRing_ComNzSemiRing; +GRing_PzSemiRing -> GRing_ComNzSemiRing; +choice_Choice -> GRing_ComPzRing; +GRing_ComPzSemiRing -> GRing_ComPzRing; +eqtype_Equality -> GRing_ComPzRing; +GRing_Nmodule -> GRing_ComPzRing; +GRing_PzRing -> GRing_ComPzRing; +GRing_PzSemiRing -> GRing_ComPzRing; +GRing_Zmodule -> GRing_ComPzRing; +choice_Choice -> GRing_ComPzSemiRing; +eqtype_Equality -> GRing_ComPzSemiRing; +GRing_Nmodule -> GRing_ComPzSemiRing; +GRing_PzSemiRing -> GRing_ComPzSemiRing; +choice_Choice -> GRing_ComSemiAlgebra; +GRing_ComNzSemiRing -> GRing_ComSemiAlgebra; +GRing_ComPzSemiRing -> GRing_ComSemiAlgebra; +eqtype_Equality -> GRing_ComSemiAlgebra; +GRing_LSemiAlgebra -> GRing_ComSemiAlgebra; +GRing_LSemiModule -> GRing_ComSemiAlgebra; +GRing_Nmodule -> GRing_ComSemiAlgebra; +GRing_NzSemiRing -> GRing_ComSemiAlgebra; +GRing_PzSemiRing -> GRing_ComSemiAlgebra; +GRing_SemiAlgebra -> GRing_ComSemiAlgebra; +GRing_Algebra -> GRing_ComUnitAlgebra; +choice_Choice -> GRing_ComUnitAlgebra; +GRing_ComAlgebra -> GRing_ComUnitAlgebra; +GRing_ComNzRing -> GRing_ComUnitAlgebra; +GRing_ComNzSemiRing -> GRing_ComUnitAlgebra; +GRing_ComPzRing -> GRing_ComUnitAlgebra; +GRing_ComPzSemiRing -> GRing_ComUnitAlgebra; +GRing_ComSemiAlgebra -> GRing_ComUnitAlgebra; +GRing_ComUnitRing -> GRing_ComUnitAlgebra; +eqtype_Equality -> GRing_ComUnitAlgebra; +GRing_LSemiAlgebra -> GRing_ComUnitAlgebra; +GRing_LSemiModule -> GRing_ComUnitAlgebra; +GRing_Lalgebra -> GRing_ComUnitAlgebra; +GRing_Lmodule -> GRing_ComUnitAlgebra; +GRing_Nmodule -> GRing_ComUnitAlgebra; +GRing_NzRing -> GRing_ComUnitAlgebra; +GRing_NzSemiRing -> GRing_ComUnitAlgebra; +GRing_PzRing -> GRing_ComUnitAlgebra; +GRing_PzSemiRing -> GRing_ComUnitAlgebra; +GRing_SemiAlgebra -> GRing_ComUnitAlgebra; +GRing_UnitAlgebra -> GRing_ComUnitAlgebra; +GRing_UnitRing -> GRing_ComUnitAlgebra; +GRing_Zmodule -> GRing_ComUnitAlgebra; +choice_Choice -> GRing_ComUnitRing; +GRing_ComNzRing -> GRing_ComUnitRing; +GRing_ComNzSemiRing -> GRing_ComUnitRing; +GRing_ComPzRing -> GRing_ComUnitRing; +GRing_ComPzSemiRing -> GRing_ComUnitRing; +eqtype_Equality -> GRing_ComUnitRing; +GRing_Nmodule -> GRing_ComUnitRing; +GRing_NzRing -> GRing_ComUnitRing; +GRing_NzSemiRing -> GRing_ComUnitRing; +GRing_PzRing -> GRing_ComUnitRing; +GRing_PzSemiRing -> GRing_ComUnitRing; +GRing_UnitRing -> GRing_ComUnitRing; +GRing_Zmodule -> GRing_ComUnitRing; +choice_Choice -> Complete; +eqtype_Equality -> Complete; +Filtered -> Complete; +Nbhs -> Complete; +Pointed -> Complete; +PointedFiltered -> Complete; +PointedNbhs -> Complete; +PointedTopological -> Complete; +PointedUniform -> Complete; +Topological -> Complete; +Uniform -> Complete; +choice_Choice -> CompleteNormedModule; +Complete -> CompleteNormedModule; +CompletePseudoMetric -> CompleteNormedModule; +eqtype_Equality -> CompleteNormedModule; +Filtered -> CompleteNormedModule; +GRing_LSemiModule -> CompleteNormedModule; +GRing_Lmodule -> CompleteNormedModule; +Nbhs -> CompleteNormedModule; +NbhsLmodule -> CompleteNormedModule; +NbhsNmodule -> CompleteNormedModule; +NbhsZmodule -> CompleteNormedModule; +GRing_Nmodule -> CompleteNormedModule; +NormedModule -> CompleteNormedModule; +Num_NormedZmodule -> CompleteNormedModule; +Pointed -> CompleteNormedModule; +PointedFiltered -> CompleteNormedModule; +PointedNbhs -> CompleteNormedModule; +PointedTopological -> CompleteNormedModule; +PointedUniform -> CompleteNormedModule; +PreTopologicalLmodule -> CompleteNormedModule; +PreTopologicalNmodule -> CompleteNormedModule; +PreTopologicalZmodule -> CompleteNormedModule; +PreUniformLmodule -> CompleteNormedModule; +PreUniformNmodule -> CompleteNormedModule; +PreUniformZmodule -> CompleteNormedModule; +PseudoMetric -> CompleteNormedModule; +PseudoMetricNormedZmod -> CompleteNormedModule; +PseudoPointedMetric -> CompleteNormedModule; +Num_SemiNormedZmodule -> CompleteNormedModule; +Topological -> CompleteNormedModule; +TopologicalLmodule -> CompleteNormedModule; +TopologicalNmodule -> CompleteNormedModule; +TopologicalZmodule -> CompleteNormedModule; +Tvs -> CompleteNormedModule; +Uniform -> CompleteNormedModule; +GRing_Zmodule -> CompleteNormedModule; +choice_Choice -> CompletePseudoMetric; +Complete -> CompletePseudoMetric; +eqtype_Equality -> CompletePseudoMetric; +Filtered -> CompletePseudoMetric; +Nbhs -> CompletePseudoMetric; +Pointed -> CompletePseudoMetric; +PointedFiltered -> CompletePseudoMetric; +PointedNbhs -> CompletePseudoMetric; +PointedTopological -> CompletePseudoMetric; +PointedUniform -> CompletePseudoMetric; +PseudoMetric -> CompletePseudoMetric; +PseudoPointedMetric -> CompletePseudoMetric; +Topological -> CompletePseudoMetric; +Uniform -> CompletePseudoMetric; +Continuous -> ContinuousFun; +Fun -> ContinuousFun; +choice_Choice -> Countable; +eqtype_Equality -> Countable; +choice_Choice -> GRing_DecidableField; +GRing_ComNzRing -> GRing_DecidableField; +GRing_ComNzSemiRing -> GRing_DecidableField; +GRing_ComPzRing -> GRing_DecidableField; +GRing_ComPzSemiRing -> GRing_DecidableField; +GRing_ComUnitRing -> GRing_DecidableField; +eqtype_Equality -> GRing_DecidableField; +GRing_Field -> GRing_DecidableField; +GRing_IntegralDomain -> GRing_DecidableField; +GRing_Nmodule -> GRing_DecidableField; +GRing_NzRing -> GRing_DecidableField; +GRing_NzSemiRing -> GRing_DecidableField; +GRing_PzRing -> GRing_DecidableField; +GRing_PzSemiRing -> GRing_DecidableField; +GRing_UnitRing -> GRing_DecidableField; +GRing_Zmodule -> GRing_DecidableField; +choice_Choice -> DiscreteNbhs; +eqtype_Equality -> DiscreteNbhs; +Filtered -> DiscreteNbhs; +Nbhs -> DiscreteNbhs; +choice_Choice -> DiscreteOrderTopology; +DiscreteNbhs -> DiscreteOrderTopology; +DiscreteTopology -> DiscreteOrderTopology; +Order_DistrLattice -> DiscreteOrderTopology; +eqtype_Equality -> DiscreteOrderTopology; +Filtered -> DiscreteOrderTopology; +Order_JoinSemilattice -> DiscreteOrderTopology; +Order_Lattice -> DiscreteOrderTopology; +Order_MeetSemilattice -> DiscreteOrderTopology; +Nbhs -> DiscreteOrderTopology; +OrderNbhs -> DiscreteOrderTopology; +OrderTopological -> DiscreteOrderTopology; +Order_POrder -> DiscreteOrderTopology; +Topological -> DiscreteOrderTopology; +Order_Total -> DiscreteOrderTopology; +choice_Choice -> DiscretePseudoMetric; +DiscreteNbhs -> DiscretePseudoMetric; +DiscreteTopology -> DiscretePseudoMetric; +DiscreteUniform -> DiscretePseudoMetric; +eqtype_Equality -> DiscretePseudoMetric; +Filtered -> DiscretePseudoMetric; +Nbhs -> DiscretePseudoMetric; +PseudoMetric -> DiscretePseudoMetric; +Topological -> DiscretePseudoMetric; +Uniform -> DiscretePseudoMetric; +choice_Choice -> DiscreteTopology; +DiscreteNbhs -> DiscreteTopology; +eqtype_Equality -> DiscreteTopology; +Filtered -> DiscreteTopology; +Nbhs -> DiscreteTopology; +Topological -> DiscreteTopology; +choice_Choice -> DiscreteUniform; +DiscreteNbhs -> DiscreteUniform; +DiscreteTopology -> DiscreteUniform; +eqtype_Equality -> DiscreteUniform; +Filtered -> DiscreteUniform; +Nbhs -> DiscreteUniform; +Topological -> DiscreteUniform; +Uniform -> DiscreteUniform; +choice_Choice -> Order_DistrLattice; +eqtype_Equality -> Order_DistrLattice; +Order_JoinSemilattice -> Order_DistrLattice; +Order_Lattice -> Order_DistrLattice; +Order_MeetSemilattice -> Order_DistrLattice; +Order_POrder -> Order_DistrLattice; +GRing_Mul2Closed -> GRing_DivClosed; +GRing_MulClosed -> GRing_DivClosed; +GRing_AddClosed -> GRing_DivalgClosed; +GRing_DivClosed -> GRing_DivalgClosed; +GRing_DivringClosed -> GRing_DivalgClosed; +GRing_Mul2Closed -> GRing_DivalgClosed; +GRing_MulClosed -> GRing_DivalgClosed; +GRing_OppClosed -> GRing_DivalgClosed; +GRing_SdivClosed -> GRing_DivalgClosed; +GRing_Semiring2Closed -> GRing_DivalgClosed; +GRing_SemiringClosed -> GRing_DivalgClosed; +GRing_SmulClosed -> GRing_DivalgClosed; +GRing_SubalgClosed -> GRing_DivalgClosed; +GRing_SubmodClosed -> GRing_DivalgClosed; +GRing_SubringClosed -> GRing_DivalgClosed; +GRing_ZmodClosed -> GRing_DivalgClosed; +GRing_AddClosed -> GRing_DivringClosed; +GRing_DivClosed -> GRing_DivringClosed; +GRing_Mul2Closed -> GRing_DivringClosed; +GRing_MulClosed -> GRing_DivringClosed; +GRing_OppClosed -> GRing_DivringClosed; +GRing_SdivClosed -> GRing_DivringClosed; +GRing_Semiring2Closed -> GRing_DivringClosed; +GRing_SemiringClosed -> GRing_DivringClosed; +GRing_SmulClosed -> GRing_DivringClosed; +GRing_SubringClosed -> GRing_DivringClosed; +GRing_ZmodClosed -> GRing_DivringClosed; +choice_Choice -> Empty; +Countable -> Empty; +eqtype_Equality -> Empty; +fintype_Finite -> Empty; +eqtype_Equality -> EqQuotient; +Quotient -> EqQuotient; +choice_Choice -> GRing_Field; +GRing_ComNzRing -> GRing_Field; +GRing_ComNzSemiRing -> GRing_Field; +GRing_ComPzRing -> GRing_Field; +GRing_ComPzSemiRing -> GRing_Field; +GRing_ComUnitRing -> GRing_Field; +eqtype_Equality -> GRing_Field; +GRing_IntegralDomain -> GRing_Field; +GRing_Nmodule -> GRing_Field; +GRing_NzRing -> GRing_Field; +GRing_NzSemiRing -> GRing_Field; +GRing_PzRing -> GRing_Field; +GRing_PzSemiRing -> GRing_Field; +GRing_UnitRing -> GRing_Field; +GRing_Zmodule -> GRing_Field; +choice_Choice -> Filtered; +eqtype_Equality -> Filtered; +Order_BMeetSemilattice -> Order_FinBMeetSemilattice; +Order_BPOrder -> Order_FinBMeetSemilattice; +choice_Choice -> Order_FinBMeetSemilattice; +Countable -> Order_FinBMeetSemilattice; +eqtype_Equality -> Order_FinBMeetSemilattice; +Order_FinBPOrder -> Order_FinBMeetSemilattice; +Order_FinMeetSemilattice -> Order_FinBMeetSemilattice; +Order_FinPOrder -> Order_FinBMeetSemilattice; +fintype_Finite -> Order_FinBMeetSemilattice; +Order_MeetSemilattice -> Order_FinBMeetSemilattice; +Order_POrder -> Order_FinBMeetSemilattice; +Order_BPOrder -> Order_FinBPOrder; +choice_Choice -> Order_FinBPOrder; +Countable -> Order_FinBPOrder; +eqtype_Equality -> Order_FinBPOrder; +Order_FinPOrder -> Order_FinBPOrder; +fintype_Finite -> Order_FinBPOrder; +Order_POrder -> Order_FinBPOrder; +Order_CDistrLattice -> Order_FinCDistrLattice; +choice_Choice -> Order_FinCDistrLattice; +Countable -> Order_FinCDistrLattice; +Order_DistrLattice -> Order_FinCDistrLattice; +eqtype_Equality -> Order_FinCDistrLattice; +Order_FinDistrLattice -> Order_FinCDistrLattice; +Order_FinJoinSemilattice -> Order_FinCDistrLattice; +Order_FinLattice -> Order_FinCDistrLattice; +Order_FinMeetSemilattice -> Order_FinCDistrLattice; +Order_FinPOrder -> Order_FinCDistrLattice; +fintype_Finite -> Order_FinCDistrLattice; +Order_JoinSemilattice -> Order_FinCDistrLattice; +Order_Lattice -> Order_FinCDistrLattice; +Order_MeetSemilattice -> Order_FinCDistrLattice; +Order_POrder -> Order_FinCDistrLattice; +Order_BDistrLattice -> Order_FinCTBDistrLattice; +Order_BJoinSemilattice -> Order_FinCTBDistrLattice; +Order_BLattice -> Order_FinCTBDistrLattice; +Order_BMeetSemilattice -> Order_FinCTBDistrLattice; +Order_BPOrder -> Order_FinCTBDistrLattice; +Order_CBDistrLattice -> Order_FinCTBDistrLattice; +Order_CDistrLattice -> Order_FinCTBDistrLattice; +Order_CTBDistrLattice -> Order_FinCTBDistrLattice; +Order_CTDistrLattice -> Order_FinCTBDistrLattice; +choice_Choice -> Order_FinCTBDistrLattice; +Countable -> Order_FinCTBDistrLattice; +Order_DistrLattice -> Order_FinCTBDistrLattice; +eqtype_Equality -> Order_FinCTBDistrLattice; +Order_FinBMeetSemilattice -> Order_FinCTBDistrLattice; +Order_FinBPOrder -> Order_FinCTBDistrLattice; +Order_FinCDistrLattice -> Order_FinCTBDistrLattice; +Order_FinDistrLattice -> Order_FinCTBDistrLattice; +Order_FinJoinSemilattice -> Order_FinCTBDistrLattice; +Order_FinLattice -> Order_FinCTBDistrLattice; +Order_FinMeetSemilattice -> Order_FinCTBDistrLattice; +Order_FinPOrder -> Order_FinCTBDistrLattice; +Order_FinTBDistrLattice -> Order_FinCTBDistrLattice; +Order_FinTBLattice -> Order_FinCTBDistrLattice; +Order_FinTBPOrder -> Order_FinCTBDistrLattice; +Order_FinTJoinSemilattice -> Order_FinCTBDistrLattice; +Order_FinTPOrder -> Order_FinCTBDistrLattice; +fintype_Finite -> Order_FinCTBDistrLattice; +Order_JoinSemilattice -> Order_FinCTBDistrLattice; +Order_Lattice -> Order_FinCTBDistrLattice; +Order_MeetSemilattice -> Order_FinCTBDistrLattice; +Order_POrder -> Order_FinCTBDistrLattice; +Order_TBDistrLattice -> Order_FinCTBDistrLattice; +Order_TBJoinSemilattice -> Order_FinCTBDistrLattice; +Order_TBLattice -> Order_FinCTBDistrLattice; +Order_TBMeetSemilattice -> Order_FinCTBDistrLattice; +Order_TBPOrder -> Order_FinCTBDistrLattice; +Order_TDistrLattice -> Order_FinCTBDistrLattice; +Order_TJoinSemilattice -> Order_FinCTBDistrLattice; +Order_TLattice -> Order_FinCTBDistrLattice; +Order_TMeetSemilattice -> Order_FinCTBDistrLattice; +Order_TPOrder -> Order_FinCTBDistrLattice; +choice_Choice -> Order_FinDistrLattice; +Countable -> Order_FinDistrLattice; +Order_DistrLattice -> Order_FinDistrLattice; +eqtype_Equality -> Order_FinDistrLattice; +Order_FinJoinSemilattice -> Order_FinDistrLattice; +Order_FinLattice -> Order_FinDistrLattice; +Order_FinMeetSemilattice -> Order_FinDistrLattice; +Order_FinPOrder -> Order_FinDistrLattice; +fintype_Finite -> Order_FinDistrLattice; +Order_JoinSemilattice -> Order_FinDistrLattice; +Order_Lattice -> Order_FinDistrLattice; +Order_MeetSemilattice -> Order_FinDistrLattice; +Order_POrder -> Order_FinDistrLattice; +BaseFinGroup -> FinGroup; +choice_Choice -> FinGroup; +Countable -> FinGroup; +eqtype_Equality -> FinGroup; +fintype_Finite -> FinGroup; +choice_Choice -> Order_FinJoinSemilattice; +Countable -> Order_FinJoinSemilattice; +eqtype_Equality -> Order_FinJoinSemilattice; +Order_FinPOrder -> Order_FinJoinSemilattice; +fintype_Finite -> Order_FinJoinSemilattice; +Order_JoinSemilattice -> Order_FinJoinSemilattice; +Order_POrder -> Order_FinJoinSemilattice; +choice_Choice -> Order_FinLattice; +Countable -> Order_FinLattice; +eqtype_Equality -> Order_FinLattice; +Order_FinJoinSemilattice -> Order_FinLattice; +Order_FinMeetSemilattice -> Order_FinLattice; +Order_FinPOrder -> Order_FinLattice; +fintype_Finite -> Order_FinLattice; +Order_JoinSemilattice -> Order_FinLattice; +Order_Lattice -> Order_FinLattice; +Order_MeetSemilattice -> Order_FinLattice; +Order_POrder -> Order_FinLattice; +choice_Choice -> Order_FinMeetSemilattice; +Countable -> Order_FinMeetSemilattice; +eqtype_Equality -> Order_FinMeetSemilattice; +Order_FinPOrder -> Order_FinMeetSemilattice; +fintype_Finite -> Order_FinMeetSemilattice; +Order_MeetSemilattice -> Order_FinMeetSemilattice; +Order_POrder -> Order_FinMeetSemilattice; +choice_Choice -> Order_FinPOrder; +Countable -> Order_FinPOrder; +eqtype_Equality -> Order_FinPOrder; +fintype_Finite -> Order_FinPOrder; +Order_POrder -> Order_FinPOrder; +Order_BDistrLattice -> Order_FinTBDistrLattice; +Order_BJoinSemilattice -> Order_FinTBDistrLattice; +Order_BLattice -> Order_FinTBDistrLattice; +Order_BMeetSemilattice -> Order_FinTBDistrLattice; +Order_BPOrder -> Order_FinTBDistrLattice; +choice_Choice -> Order_FinTBDistrLattice; +Countable -> Order_FinTBDistrLattice; +Order_DistrLattice -> Order_FinTBDistrLattice; +eqtype_Equality -> Order_FinTBDistrLattice; +Order_FinBMeetSemilattice -> Order_FinTBDistrLattice; +Order_FinBPOrder -> Order_FinTBDistrLattice; +Order_FinDistrLattice -> Order_FinTBDistrLattice; +Order_FinJoinSemilattice -> Order_FinTBDistrLattice; +Order_FinLattice -> Order_FinTBDistrLattice; +Order_FinMeetSemilattice -> Order_FinTBDistrLattice; +Order_FinPOrder -> Order_FinTBDistrLattice; +Order_FinTBLattice -> Order_FinTBDistrLattice; +Order_FinTBPOrder -> Order_FinTBDistrLattice; +Order_FinTJoinSemilattice -> Order_FinTBDistrLattice; +Order_FinTPOrder -> Order_FinTBDistrLattice; +fintype_Finite -> Order_FinTBDistrLattice; +Order_JoinSemilattice -> Order_FinTBDistrLattice; +Order_Lattice -> Order_FinTBDistrLattice; +Order_MeetSemilattice -> Order_FinTBDistrLattice; +Order_POrder -> Order_FinTBDistrLattice; +Order_TBDistrLattice -> Order_FinTBDistrLattice; +Order_TBJoinSemilattice -> Order_FinTBDistrLattice; +Order_TBLattice -> Order_FinTBDistrLattice; +Order_TBMeetSemilattice -> Order_FinTBDistrLattice; +Order_TBPOrder -> Order_FinTBDistrLattice; +Order_TDistrLattice -> Order_FinTBDistrLattice; +Order_TJoinSemilattice -> Order_FinTBDistrLattice; +Order_TLattice -> Order_FinTBDistrLattice; +Order_TMeetSemilattice -> Order_FinTBDistrLattice; +Order_TPOrder -> Order_FinTBDistrLattice; +Order_BJoinSemilattice -> Order_FinTBLattice; +Order_BLattice -> Order_FinTBLattice; +Order_BMeetSemilattice -> Order_FinTBLattice; +Order_BPOrder -> Order_FinTBLattice; +choice_Choice -> Order_FinTBLattice; +Countable -> Order_FinTBLattice; +eqtype_Equality -> Order_FinTBLattice; +Order_FinBMeetSemilattice -> Order_FinTBLattice; +Order_FinBPOrder -> Order_FinTBLattice; +Order_FinJoinSemilattice -> Order_FinTBLattice; +Order_FinLattice -> Order_FinTBLattice; +Order_FinMeetSemilattice -> Order_FinTBLattice; +Order_FinPOrder -> Order_FinTBLattice; +Order_FinTBPOrder -> Order_FinTBLattice; +Order_FinTJoinSemilattice -> Order_FinTBLattice; +Order_FinTPOrder -> Order_FinTBLattice; +fintype_Finite -> Order_FinTBLattice; +Order_JoinSemilattice -> Order_FinTBLattice; +Order_Lattice -> Order_FinTBLattice; +Order_MeetSemilattice -> Order_FinTBLattice; +Order_POrder -> Order_FinTBLattice; +Order_TBJoinSemilattice -> Order_FinTBLattice; +Order_TBLattice -> Order_FinTBLattice; +Order_TBMeetSemilattice -> Order_FinTBLattice; +Order_TBPOrder -> Order_FinTBLattice; +Order_TJoinSemilattice -> Order_FinTBLattice; +Order_TLattice -> Order_FinTBLattice; +Order_TMeetSemilattice -> Order_FinTBLattice; +Order_TPOrder -> Order_FinTBLattice; +Order_BPOrder -> Order_FinTBPOrder; +choice_Choice -> Order_FinTBPOrder; +Countable -> Order_FinTBPOrder; +eqtype_Equality -> Order_FinTBPOrder; +Order_FinBPOrder -> Order_FinTBPOrder; +Order_FinPOrder -> Order_FinTBPOrder; +Order_FinTPOrder -> Order_FinTBPOrder; +fintype_Finite -> Order_FinTBPOrder; +Order_POrder -> Order_FinTBPOrder; +Order_TBPOrder -> Order_FinTBPOrder; +Order_TPOrder -> Order_FinTBPOrder; +Order_BDistrLattice -> Order_FinTBTotal; +Order_BJoinSemilattice -> Order_FinTBTotal; +Order_BLattice -> Order_FinTBTotal; +Order_BMeetSemilattice -> Order_FinTBTotal; +Order_BPOrder -> Order_FinTBTotal; +Order_BTotal -> Order_FinTBTotal; +choice_Choice -> Order_FinTBTotal; +Countable -> Order_FinTBTotal; +Order_DistrLattice -> Order_FinTBTotal; +eqtype_Equality -> Order_FinTBTotal; +Order_FinBMeetSemilattice -> Order_FinTBTotal; +Order_FinBPOrder -> Order_FinTBTotal; +Order_FinDistrLattice -> Order_FinTBTotal; +Order_FinJoinSemilattice -> Order_FinTBTotal; +Order_FinLattice -> Order_FinTBTotal; +Order_FinMeetSemilattice -> Order_FinTBTotal; +Order_FinPOrder -> Order_FinTBTotal; +Order_FinTBDistrLattice -> Order_FinTBTotal; +Order_FinTBLattice -> Order_FinTBTotal; +Order_FinTBPOrder -> Order_FinTBTotal; +Order_FinTJoinSemilattice -> Order_FinTBTotal; +Order_FinTPOrder -> Order_FinTBTotal; +Order_FinTotal -> Order_FinTBTotal; +fintype_Finite -> Order_FinTBTotal; +Order_JoinSemilattice -> Order_FinTBTotal; +Order_Lattice -> Order_FinTBTotal; +Order_MeetSemilattice -> Order_FinTBTotal; +Order_POrder -> Order_FinTBTotal; +Order_TBDistrLattice -> Order_FinTBTotal; +Order_TBJoinSemilattice -> Order_FinTBTotal; +Order_TBLattice -> Order_FinTBTotal; +Order_TBMeetSemilattice -> Order_FinTBTotal; +Order_TBPOrder -> Order_FinTBTotal; +Order_TBTotal -> Order_FinTBTotal; +Order_TDistrLattice -> Order_FinTBTotal; +Order_TJoinSemilattice -> Order_FinTBTotal; +Order_TLattice -> Order_FinTBTotal; +Order_TMeetSemilattice -> Order_FinTBTotal; +Order_TPOrder -> Order_FinTBTotal; +Order_TTotal -> Order_FinTBTotal; +Order_Total -> Order_FinTBTotal; +choice_Choice -> Order_FinTJoinSemilattice; +Countable -> Order_FinTJoinSemilattice; +eqtype_Equality -> Order_FinTJoinSemilattice; +Order_FinJoinSemilattice -> Order_FinTJoinSemilattice; +Order_FinPOrder -> Order_FinTJoinSemilattice; +Order_FinTPOrder -> Order_FinTJoinSemilattice; +fintype_Finite -> Order_FinTJoinSemilattice; +Order_JoinSemilattice -> Order_FinTJoinSemilattice; +Order_POrder -> Order_FinTJoinSemilattice; +Order_TJoinSemilattice -> Order_FinTJoinSemilattice; +Order_TPOrder -> Order_FinTJoinSemilattice; +choice_Choice -> Order_FinTPOrder; +Countable -> Order_FinTPOrder; +eqtype_Equality -> Order_FinTPOrder; +Order_FinPOrder -> Order_FinTPOrder; +fintype_Finite -> Order_FinTPOrder; +Order_POrder -> Order_FinTPOrder; +Order_TPOrder -> Order_FinTPOrder; +choice_Choice -> Order_FinTotal; +Countable -> Order_FinTotal; +Order_DistrLattice -> Order_FinTotal; +eqtype_Equality -> Order_FinTotal; +Order_FinDistrLattice -> Order_FinTotal; +Order_FinJoinSemilattice -> Order_FinTotal; +Order_FinLattice -> Order_FinTotal; +Order_FinMeetSemilattice -> Order_FinTotal; +Order_FinPOrder -> Order_FinTotal; +fintype_Finite -> Order_FinTotal; +Order_JoinSemilattice -> Order_FinTotal; +Order_Lattice -> Order_FinTotal; +Order_MeetSemilattice -> Order_FinTotal; +Order_POrder -> Order_FinTotal; +Order_Total -> Order_FinTotal; +choice_Choice -> fintype_Finite; +Countable -> fintype_Finite; +eqtype_Equality -> fintype_Finite; +Content -> FiniteMeasure; +FinNumFun -> FiniteMeasure; +Measure -> FiniteMeasure; +SFiniteMeasure -> FiniteMeasure; +SigmaFiniteContent -> FiniteMeasure; +SigmaFiniteMeasure -> FiniteMeasure; +Fun -> InjFun; +Inject -> InjFun; +OInvFun -> InjFun; +OInversible -> InjFun; +OInversible -> Inject; +choice_Choice -> GRing_IntegralDomain; +GRing_ComNzRing -> GRing_IntegralDomain; +GRing_ComNzSemiRing -> GRing_IntegralDomain; +GRing_ComPzRing -> GRing_IntegralDomain; +GRing_ComPzSemiRing -> GRing_IntegralDomain; +GRing_ComUnitRing -> GRing_IntegralDomain; +eqtype_Equality -> GRing_IntegralDomain; +GRing_Nmodule -> GRing_IntegralDomain; +GRing_NzRing -> GRing_IntegralDomain; +GRing_NzSemiRing -> GRing_IntegralDomain; +GRing_PzRing -> GRing_IntegralDomain; +GRing_PzSemiRing -> GRing_IntegralDomain; +GRing_UnitRing -> GRing_IntegralDomain; +GRing_Zmodule -> GRing_IntegralDomain; +Fun -> InvFun; +Inversible -> InvFun; +OInvFun -> InvFun; +OInversible -> InvFun; +OInversible -> Inversible; +Order_OrderMorphism -> Order_JoinLatticeMorphism; +choice_Choice -> Order_JoinSemilattice; +eqtype_Equality -> Order_JoinSemilattice; +Order_POrder -> Order_JoinSemilattice; +Order_BJoinSemilattice -> Order_JoinSubBLattice; +Order_BLattice -> Order_JoinSubBLattice; +Order_BMeetSemilattice -> Order_JoinSubBLattice; +Order_BPOrder -> Order_JoinSubBLattice; +choice_Choice -> Order_JoinSubBLattice; +eqtype_Equality -> Order_JoinSubBLattice; +Order_JoinSemilattice -> Order_JoinSubBLattice; +Order_JoinSubLattice -> Order_JoinSubBLattice; +Order_Lattice -> Order_JoinSubBLattice; +Order_MeetSemilattice -> Order_JoinSubBLattice; +Order_POrder -> Order_JoinSubBLattice; +SubChoice -> Order_JoinSubBLattice; +SubEquality -> Order_JoinSubBLattice; +Order_SubPOrder -> Order_JoinSubBLattice; +Order_SubPOrderBLattice -> Order_JoinSubBLattice; +Order_SubPOrderLattice -> Order_JoinSubBLattice; +SubType -> Order_JoinSubBLattice; +choice_Choice -> Order_JoinSubLattice; +eqtype_Equality -> Order_JoinSubLattice; +Order_JoinSemilattice -> Order_JoinSubLattice; +Order_Lattice -> Order_JoinSubLattice; +Order_MeetSemilattice -> Order_JoinSubLattice; +Order_POrder -> Order_JoinSubLattice; +SubChoice -> Order_JoinSubLattice; +SubEquality -> Order_JoinSubLattice; +Order_SubPOrder -> Order_JoinSubLattice; +Order_SubPOrderLattice -> Order_JoinSubLattice; +SubType -> Order_JoinSubLattice; +Order_BJoinSemilattice -> Order_JoinSubTBLattice; +Order_BLattice -> Order_JoinSubTBLattice; +Order_BMeetSemilattice -> Order_JoinSubTBLattice; +Order_BPOrder -> Order_JoinSubTBLattice; +choice_Choice -> Order_JoinSubTBLattice; +eqtype_Equality -> Order_JoinSubTBLattice; +Order_JoinSemilattice -> Order_JoinSubTBLattice; +Order_JoinSubBLattice -> Order_JoinSubTBLattice; +Order_JoinSubLattice -> Order_JoinSubTBLattice; +Order_JoinSubTLattice -> Order_JoinSubTBLattice; +Order_Lattice -> Order_JoinSubTBLattice; +Order_MeetSemilattice -> Order_JoinSubTBLattice; +Order_POrder -> Order_JoinSubTBLattice; +SubChoice -> Order_JoinSubTBLattice; +SubEquality -> Order_JoinSubTBLattice; +Order_SubPOrder -> Order_JoinSubTBLattice; +Order_SubPOrderBLattice -> Order_JoinSubTBLattice; +Order_SubPOrderLattice -> Order_JoinSubTBLattice; +Order_SubPOrderTBLattice -> Order_JoinSubTBLattice; +Order_SubPOrderTLattice -> Order_JoinSubTBLattice; +SubType -> Order_JoinSubTBLattice; +Order_TBJoinSemilattice -> Order_JoinSubTBLattice; +Order_TBLattice -> Order_JoinSubTBLattice; +Order_TBMeetSemilattice -> Order_JoinSubTBLattice; +Order_TBPOrder -> Order_JoinSubTBLattice; +Order_TJoinSemilattice -> Order_JoinSubTBLattice; +Order_TLattice -> Order_JoinSubTBLattice; +Order_TMeetSemilattice -> Order_JoinSubTBLattice; +Order_TPOrder -> Order_JoinSubTBLattice; +choice_Choice -> Order_JoinSubTLattice; +eqtype_Equality -> Order_JoinSubTLattice; +Order_JoinSemilattice -> Order_JoinSubTLattice; +Order_JoinSubLattice -> Order_JoinSubTLattice; +Order_Lattice -> Order_JoinSubTLattice; +Order_MeetSemilattice -> Order_JoinSubTLattice; +Order_POrder -> Order_JoinSubTLattice; +SubChoice -> Order_JoinSubTLattice; +SubEquality -> Order_JoinSubTLattice; +Order_SubPOrder -> Order_JoinSubTLattice; +Order_SubPOrderLattice -> Order_JoinSubTLattice; +Order_SubPOrderTLattice -> Order_JoinSubTLattice; +SubType -> Order_JoinSubTLattice; +Order_TJoinSemilattice -> Order_JoinSubTLattice; +Order_TLattice -> Order_JoinSubTLattice; +Order_TMeetSemilattice -> Order_JoinSubTLattice; +Order_TPOrder -> Order_JoinSubTLattice; +GRing_Additive -> GRing_LRMorphism; +GRing_Linear -> GRing_LRMorphism; +GRing_RMorphism -> GRing_LRMorphism; +choice_Choice -> GRing_LSemiAlgebra; +eqtype_Equality -> GRing_LSemiAlgebra; +GRing_LSemiModule -> GRing_LSemiAlgebra; +GRing_Nmodule -> GRing_LSemiAlgebra; +GRing_NzSemiRing -> GRing_LSemiAlgebra; +GRing_PzSemiRing -> GRing_LSemiAlgebra; +choice_Choice -> GRing_LSemiModule; +eqtype_Equality -> GRing_LSemiModule; +GRing_Nmodule -> GRing_LSemiModule; +choice_Choice -> GRing_Lalgebra; +eqtype_Equality -> GRing_Lalgebra; +GRing_LSemiAlgebra -> GRing_Lalgebra; +GRing_LSemiModule -> GRing_Lalgebra; +GRing_Lmodule -> GRing_Lalgebra; +GRing_Nmodule -> GRing_Lalgebra; +GRing_NzRing -> GRing_Lalgebra; +GRing_NzSemiRing -> GRing_Lalgebra; +GRing_PzRing -> GRing_Lalgebra; +GRing_PzSemiRing -> GRing_Lalgebra; +GRing_Zmodule -> GRing_Lalgebra; +choice_Choice -> Order_Lattice; +eqtype_Equality -> Order_Lattice; +Order_JoinSemilattice -> Order_Lattice; +Order_MeetSemilattice -> Order_Lattice; +Order_POrder -> Order_Lattice; +Order_JoinLatticeClosed -> Order_LatticeClosed; +Order_MeetLatticeClosed -> Order_LatticeClosed; +Order_JoinLatticeMorphism -> Order_LatticeMorphism; +Order_MeetLatticeMorphism -> Order_LatticeMorphism; +Order_OrderMorphism -> Order_LatticeMorphism; +SemiGroup_Law -> Monoid_Law; +GRing_Scale_PreLaw -> GRing_Scale_Law; +GRing_Additive -> GRing_Linear; +choice_Choice -> GRing_Lmodule; +eqtype_Equality -> GRing_Lmodule; +GRing_LSemiModule -> GRing_Lmodule; +GRing_Nmodule -> GRing_Lmodule; +GRing_Zmodule -> GRing_Lmodule; +AlgebraOfSets -> Measurable; +choice_Choice -> Measurable; +eqtype_Equality -> Measurable; +Pointed -> Measurable; +RingOfSets -> Measurable; +SemiRingOfSets -> Measurable; +SigmaRing -> Measurable; +Content -> Measure; +Order_OrderMorphism -> Order_MeetLatticeMorphism; +choice_Choice -> Order_MeetSemilattice; +eqtype_Equality -> Order_MeetSemilattice; +Order_POrder -> Order_MeetSemilattice; +Order_BJoinSemilattice -> Order_MeetSubBLattice; +Order_BLattice -> Order_MeetSubBLattice; +Order_BMeetSemilattice -> Order_MeetSubBLattice; +Order_BPOrder -> Order_MeetSubBLattice; +choice_Choice -> Order_MeetSubBLattice; +eqtype_Equality -> Order_MeetSubBLattice; +Order_JoinSemilattice -> Order_MeetSubBLattice; +Order_Lattice -> Order_MeetSubBLattice; +Order_MeetSemilattice -> Order_MeetSubBLattice; +Order_MeetSubLattice -> Order_MeetSubBLattice; +Order_POrder -> Order_MeetSubBLattice; +SubChoice -> Order_MeetSubBLattice; +SubEquality -> Order_MeetSubBLattice; +Order_SubPOrder -> Order_MeetSubBLattice; +Order_SubPOrderBLattice -> Order_MeetSubBLattice; +Order_SubPOrderLattice -> Order_MeetSubBLattice; +SubType -> Order_MeetSubBLattice; +choice_Choice -> Order_MeetSubLattice; +eqtype_Equality -> Order_MeetSubLattice; +Order_JoinSemilattice -> Order_MeetSubLattice; +Order_Lattice -> Order_MeetSubLattice; +Order_MeetSemilattice -> Order_MeetSubLattice; +Order_POrder -> Order_MeetSubLattice; +SubChoice -> Order_MeetSubLattice; +SubEquality -> Order_MeetSubLattice; +Order_SubPOrder -> Order_MeetSubLattice; +Order_SubPOrderLattice -> Order_MeetSubLattice; +SubType -> Order_MeetSubLattice; +Order_BJoinSemilattice -> Order_MeetSubTBLattice; +Order_BLattice -> Order_MeetSubTBLattice; +Order_BMeetSemilattice -> Order_MeetSubTBLattice; +Order_BPOrder -> Order_MeetSubTBLattice; +choice_Choice -> Order_MeetSubTBLattice; +eqtype_Equality -> Order_MeetSubTBLattice; +Order_JoinSemilattice -> Order_MeetSubTBLattice; +Order_Lattice -> Order_MeetSubTBLattice; +Order_MeetSemilattice -> Order_MeetSubTBLattice; +Order_MeetSubBLattice -> Order_MeetSubTBLattice; +Order_MeetSubLattice -> Order_MeetSubTBLattice; +Order_MeetSubTLattice -> Order_MeetSubTBLattice; +Order_POrder -> Order_MeetSubTBLattice; +SubChoice -> Order_MeetSubTBLattice; +SubEquality -> Order_MeetSubTBLattice; +Order_SubPOrder -> Order_MeetSubTBLattice; +Order_SubPOrderBLattice -> Order_MeetSubTBLattice; +Order_SubPOrderLattice -> Order_MeetSubTBLattice; +Order_SubPOrderTBLattice -> Order_MeetSubTBLattice; +Order_SubPOrderTLattice -> Order_MeetSubTBLattice; +SubType -> Order_MeetSubTBLattice; +Order_TBJoinSemilattice -> Order_MeetSubTBLattice; +Order_TBLattice -> Order_MeetSubTBLattice; +Order_TBMeetSemilattice -> Order_MeetSubTBLattice; +Order_TBPOrder -> Order_MeetSubTBLattice; +Order_TJoinSemilattice -> Order_MeetSubTBLattice; +Order_TLattice -> Order_MeetSubTBLattice; +Order_TMeetSemilattice -> Order_MeetSubTBLattice; +Order_TPOrder -> Order_MeetSubTBLattice; +choice_Choice -> Order_MeetSubTLattice; +eqtype_Equality -> Order_MeetSubTLattice; +Order_JoinSemilattice -> Order_MeetSubTLattice; +Order_Lattice -> Order_MeetSubTLattice; +Order_MeetSemilattice -> Order_MeetSubTLattice; +Order_MeetSubLattice -> Order_MeetSubTLattice; +Order_POrder -> Order_MeetSubTLattice; +SubChoice -> Order_MeetSubTLattice; +SubEquality -> Order_MeetSubTLattice; +Order_SubPOrder -> Order_MeetSubTLattice; +Order_SubPOrderLattice -> Order_MeetSubTLattice; +Order_SubPOrderTLattice -> Order_MeetSubTLattice; +SubType -> Order_MeetSubTLattice; +Order_TJoinSemilattice -> Order_MeetSubTLattice; +Order_TLattice -> Order_MeetSubTLattice; +Order_TMeetSemilattice -> Order_MeetSubTLattice; +Order_TPOrder -> Order_MeetSubTLattice; +GRing_Mul2Closed -> GRing_MulClosed; +choice_Choice -> Nbhs; +eqtype_Equality -> Nbhs; +Filtered -> Nbhs; +choice_Choice -> NbhsLmodule; +eqtype_Equality -> NbhsLmodule; +Filtered -> NbhsLmodule; +GRing_LSemiModule -> NbhsLmodule; +GRing_Lmodule -> NbhsLmodule; +Nbhs -> NbhsLmodule; +NbhsNmodule -> NbhsLmodule; +NbhsZmodule -> NbhsLmodule; +GRing_Nmodule -> NbhsLmodule; +GRing_Zmodule -> NbhsLmodule; +choice_Choice -> NbhsNmodule; +eqtype_Equality -> NbhsNmodule; +Filtered -> NbhsNmodule; +Nbhs -> NbhsNmodule; +GRing_Nmodule -> NbhsNmodule; +choice_Choice -> NbhsZmodule; +eqtype_Equality -> NbhsZmodule; +Filtered -> NbhsZmodule; +Nbhs -> NbhsZmodule; +NbhsNmodule -> NbhsZmodule; +GRing_Nmodule -> NbhsZmodule; +GRing_Zmodule -> NbhsZmodule; +choice_Choice -> GRing_Nmodule; +eqtype_Equality -> GRing_Nmodule; +choice_Choice -> NormedModule; +eqtype_Equality -> NormedModule; +Filtered -> NormedModule; +GRing_LSemiModule -> NormedModule; +GRing_Lmodule -> NormedModule; +Nbhs -> NormedModule; +NbhsLmodule -> NormedModule; +NbhsNmodule -> NormedModule; +NbhsZmodule -> NormedModule; +GRing_Nmodule -> NormedModule; +Num_NormedZmodule -> NormedModule; +Pointed -> NormedModule; +PointedFiltered -> NormedModule; +PointedNbhs -> NormedModule; +PointedTopological -> NormedModule; +PointedUniform -> NormedModule; +PreTopologicalLmodule -> NormedModule; +PreTopologicalNmodule -> NormedModule; +PreTopologicalZmodule -> NormedModule; +PreUniformLmodule -> NormedModule; +PreUniformNmodule -> NormedModule; +PreUniformZmodule -> NormedModule; +PseudoMetric -> NormedModule; +PseudoMetricNormedZmod -> NormedModule; +PseudoPointedMetric -> NormedModule; +Num_SemiNormedZmodule -> NormedModule; +Topological -> NormedModule; +TopologicalLmodule -> NormedModule; +TopologicalNmodule -> NormedModule; +TopologicalZmodule -> NormedModule; +Tvs -> NormedModule; +Uniform -> NormedModule; +GRing_Zmodule -> NormedModule; +choice_Choice -> Num_NormedZmodule; +eqtype_Equality -> Num_NormedZmodule; +GRing_Nmodule -> Num_NormedZmodule; +Num_SemiNormedZmodule -> Num_NormedZmodule; +GRing_Zmodule -> Num_NormedZmodule; +choice_Choice -> Num_NumDomain; +GRing_ComNzRing -> Num_NumDomain; +GRing_ComNzSemiRing -> Num_NumDomain; +GRing_ComPzRing -> Num_NumDomain; +GRing_ComPzSemiRing -> Num_NumDomain; +GRing_ComUnitRing -> Num_NumDomain; +eqtype_Equality -> Num_NumDomain; +GRing_IntegralDomain -> Num_NumDomain; +GRing_Nmodule -> Num_NumDomain; +Num_NormedZmodule -> Num_NumDomain; +GRing_NzRing -> Num_NumDomain; +GRing_NzSemiRing -> Num_NumDomain; +Order_POrder -> Num_NumDomain; +Num_POrderedZmodule -> Num_NumDomain; +GRing_PzRing -> Num_NumDomain; +GRing_PzSemiRing -> Num_NumDomain; +Num_SemiNormedZmodule -> Num_NumDomain; +GRing_UnitRing -> Num_NumDomain; +GRing_Zmodule -> Num_NumDomain; +choice_Choice -> Num_NumField; +GRing_ComNzRing -> Num_NumField; +GRing_ComNzSemiRing -> Num_NumField; +GRing_ComPzRing -> Num_NumField; +GRing_ComPzSemiRing -> Num_NumField; +GRing_ComUnitRing -> Num_NumField; +eqtype_Equality -> Num_NumField; +GRing_Field -> Num_NumField; +GRing_IntegralDomain -> Num_NumField; +GRing_Nmodule -> Num_NumField; +Num_NormedZmodule -> Num_NumField; +Num_NumDomain -> Num_NumField; +GRing_NzRing -> Num_NumField; +GRing_NzSemiRing -> Num_NumField; +Order_POrder -> Num_NumField; +Num_POrderedZmodule -> Num_NumField; +GRing_PzRing -> Num_NumField; +GRing_PzSemiRing -> Num_NumField; +Num_SemiNormedZmodule -> Num_NumField; +GRing_UnitRing -> Num_NumField; +GRing_Zmodule -> Num_NumField; +choice_Choice -> GRing_NzRing; +eqtype_Equality -> GRing_NzRing; +GRing_Nmodule -> GRing_NzRing; +GRing_NzSemiRing -> GRing_NzRing; +GRing_PzRing -> GRing_NzRing; +GRing_PzSemiRing -> GRing_NzRing; +GRing_Zmodule -> GRing_NzRing; +choice_Choice -> GRing_NzSemiRing; +eqtype_Equality -> GRing_NzSemiRing; +GRing_Nmodule -> GRing_NzSemiRing; +GRing_PzSemiRing -> GRing_NzSemiRing; +Fun -> OInvFun; +OInversible -> OInvFun; +choice_Choice -> OrderNbhs; +Order_DistrLattice -> OrderNbhs; +eqtype_Equality -> OrderNbhs; +Filtered -> OrderNbhs; +Order_JoinSemilattice -> OrderNbhs; +Order_Lattice -> OrderNbhs; +Order_MeetSemilattice -> OrderNbhs; +Nbhs -> OrderNbhs; +Order_POrder -> OrderNbhs; +Order_Total -> OrderNbhs; +choice_Choice -> OrderPseudoMetric; +Order_DistrLattice -> OrderPseudoMetric; +eqtype_Equality -> OrderPseudoMetric; +Filtered -> OrderPseudoMetric; +Order_JoinSemilattice -> OrderPseudoMetric; +Order_Lattice -> OrderPseudoMetric; +Order_MeetSemilattice -> OrderPseudoMetric; +Nbhs -> OrderPseudoMetric; +OrderNbhs -> OrderPseudoMetric; +OrderTopological -> OrderPseudoMetric; +OrderUniform -> OrderPseudoMetric; +Order_POrder -> OrderPseudoMetric; +PseudoMetric -> OrderPseudoMetric; +Topological -> OrderPseudoMetric; +Order_Total -> OrderPseudoMetric; +Uniform -> OrderPseudoMetric; +choice_Choice -> OrderTopological; +Order_DistrLattice -> OrderTopological; +eqtype_Equality -> OrderTopological; +Filtered -> OrderTopological; +Order_JoinSemilattice -> OrderTopological; +Order_Lattice -> OrderTopological; +Order_MeetSemilattice -> OrderTopological; +Nbhs -> OrderTopological; +OrderNbhs -> OrderTopological; +Order_POrder -> OrderTopological; +Topological -> OrderTopological; +Order_Total -> OrderTopological; +choice_Choice -> OrderUniform; +Order_DistrLattice -> OrderUniform; +eqtype_Equality -> OrderUniform; +Filtered -> OrderUniform; +Order_JoinSemilattice -> OrderUniform; +Order_Lattice -> OrderUniform; +Order_MeetSemilattice -> OrderUniform; +Nbhs -> OrderUniform; +OrderNbhs -> OrderUniform; +OrderTopological -> OrderUniform; +Order_POrder -> OrderUniform; +Topological -> OrderUniform; +Order_Total -> OrderUniform; +Uniform -> OrderUniform; +choice_Choice -> Order_POrder; +eqtype_Equality -> Order_POrder; +choice_Choice -> Num_POrderedZmodule; +eqtype_Equality -> Num_POrderedZmodule; +GRing_Nmodule -> Num_POrderedZmodule; +Order_POrder -> Num_POrderedZmodule; +GRing_Zmodule -> Num_POrderedZmodule; +choice_Choice -> Pointed; +eqtype_Equality -> Pointed; +choice_Choice -> PointedDiscreteOrderTopology; +DiscreteNbhs -> PointedDiscreteOrderTopology; +DiscreteOrderTopology -> PointedDiscreteOrderTopology; +DiscreteTopology -> PointedDiscreteOrderTopology; +Order_DistrLattice -> PointedDiscreteOrderTopology; +eqtype_Equality -> PointedDiscreteOrderTopology; +Filtered -> PointedDiscreteOrderTopology; +Order_JoinSemilattice -> PointedDiscreteOrderTopology; +Order_Lattice -> PointedDiscreteOrderTopology; +Order_MeetSemilattice -> PointedDiscreteOrderTopology; +Nbhs -> PointedDiscreteOrderTopology; +OrderNbhs -> PointedDiscreteOrderTopology; +OrderTopological -> PointedDiscreteOrderTopology; +Order_POrder -> PointedDiscreteOrderTopology; +Pointed -> PointedDiscreteOrderTopology; +PointedDiscreteTopology -> PointedDiscreteOrderTopology; +PointedFiltered -> PointedDiscreteOrderTopology; +PointedNbhs -> PointedDiscreteOrderTopology; +PointedTopological -> PointedDiscreteOrderTopology; +Topological -> PointedDiscreteOrderTopology; +Order_Total -> PointedDiscreteOrderTopology; +choice_Choice -> PointedDiscreteTopology; +DiscreteNbhs -> PointedDiscreteTopology; +DiscreteTopology -> PointedDiscreteTopology; +eqtype_Equality -> PointedDiscreteTopology; +Filtered -> PointedDiscreteTopology; +Nbhs -> PointedDiscreteTopology; +Pointed -> PointedDiscreteTopology; +PointedFiltered -> PointedDiscreteTopology; +PointedNbhs -> PointedDiscreteTopology; +PointedTopological -> PointedDiscreteTopology; +Topological -> PointedDiscreteTopology; +choice_Choice -> PointedFiltered; +eqtype_Equality -> PointedFiltered; +Filtered -> PointedFiltered; +Pointed -> PointedFiltered; +choice_Choice -> PointedNbhs; +eqtype_Equality -> PointedNbhs; +Filtered -> PointedNbhs; +Nbhs -> PointedNbhs; +Pointed -> PointedNbhs; +PointedFiltered -> PointedNbhs; +choice_Choice -> PointedTopological; +eqtype_Equality -> PointedTopological; +Filtered -> PointedTopological; +Nbhs -> PointedTopological; +Pointed -> PointedTopological; +PointedFiltered -> PointedTopological; +PointedNbhs -> PointedTopological; +Topological -> PointedTopological; +choice_Choice -> PointedUniform; +eqtype_Equality -> PointedUniform; +Filtered -> PointedUniform; +Nbhs -> PointedUniform; +Pointed -> PointedUniform; +PointedFiltered -> PointedUniform; +PointedNbhs -> PointedUniform; +PointedTopological -> PointedUniform; +Topological -> PointedUniform; +Uniform -> PointedUniform; +choice_Choice -> PreTopologicalLmodule; +eqtype_Equality -> PreTopologicalLmodule; +Filtered -> PreTopologicalLmodule; +GRing_LSemiModule -> PreTopologicalLmodule; +GRing_Lmodule -> PreTopologicalLmodule; +Nbhs -> PreTopologicalLmodule; +NbhsLmodule -> PreTopologicalLmodule; +NbhsNmodule -> PreTopologicalLmodule; +NbhsZmodule -> PreTopologicalLmodule; +GRing_Nmodule -> PreTopologicalLmodule; +PreTopologicalNmodule -> PreTopologicalLmodule; +PreTopologicalZmodule -> PreTopologicalLmodule; +Topological -> PreTopologicalLmodule; +GRing_Zmodule -> PreTopologicalLmodule; +choice_Choice -> PreTopologicalNmodule; +eqtype_Equality -> PreTopologicalNmodule; +Filtered -> PreTopologicalNmodule; +Nbhs -> PreTopologicalNmodule; +NbhsNmodule -> PreTopologicalNmodule; +GRing_Nmodule -> PreTopologicalNmodule; +Topological -> PreTopologicalNmodule; +choice_Choice -> PreTopologicalZmodule; +eqtype_Equality -> PreTopologicalZmodule; +Filtered -> PreTopologicalZmodule; +Nbhs -> PreTopologicalZmodule; +NbhsNmodule -> PreTopologicalZmodule; +NbhsZmodule -> PreTopologicalZmodule; +GRing_Nmodule -> PreTopologicalZmodule; +PreTopologicalNmodule -> PreTopologicalZmodule; +Topological -> PreTopologicalZmodule; +GRing_Zmodule -> PreTopologicalZmodule; +choice_Choice -> PreUniformLmodule; +eqtype_Equality -> PreUniformLmodule; +Filtered -> PreUniformLmodule; +GRing_LSemiModule -> PreUniformLmodule; +GRing_Lmodule -> PreUniformLmodule; +Nbhs -> PreUniformLmodule; +NbhsLmodule -> PreUniformLmodule; +NbhsNmodule -> PreUniformLmodule; +NbhsZmodule -> PreUniformLmodule; +GRing_Nmodule -> PreUniformLmodule; +PreTopologicalLmodule -> PreUniformLmodule; +PreTopologicalNmodule -> PreUniformLmodule; +PreTopologicalZmodule -> PreUniformLmodule; +PreUniformNmodule -> PreUniformLmodule; +PreUniformZmodule -> PreUniformLmodule; +Topological -> PreUniformLmodule; +Uniform -> PreUniformLmodule; +GRing_Zmodule -> PreUniformLmodule; +choice_Choice -> PreUniformNmodule; +eqtype_Equality -> PreUniformNmodule; +Filtered -> PreUniformNmodule; +Nbhs -> PreUniformNmodule; +NbhsNmodule -> PreUniformNmodule; +GRing_Nmodule -> PreUniformNmodule; +PreTopologicalNmodule -> PreUniformNmodule; +Topological -> PreUniformNmodule; +Uniform -> PreUniformNmodule; +choice_Choice -> PreUniformZmodule; +eqtype_Equality -> PreUniformZmodule; +Filtered -> PreUniformZmodule; +Nbhs -> PreUniformZmodule; +NbhsNmodule -> PreUniformZmodule; +NbhsZmodule -> PreUniformZmodule; +GRing_Nmodule -> PreUniformZmodule; +PreTopologicalNmodule -> PreUniformZmodule; +PreTopologicalZmodule -> PreUniformZmodule; +PreUniformNmodule -> PreUniformZmodule; +Topological -> PreUniformZmodule; +Uniform -> PreUniformZmodule; +GRing_Zmodule -> PreUniformZmodule; +Content -> Probability; +FinNumFun -> Probability; +FiniteMeasure -> Probability; +Measure -> Probability; +SFiniteMeasure -> Probability; +SigmaFiniteContent -> Probability; +SigmaFiniteMeasure -> Probability; +SubProbability -> Probability; +choice_Choice -> PseudoMetric; +eqtype_Equality -> PseudoMetric; +Filtered -> PseudoMetric; +Nbhs -> PseudoMetric; +Topological -> PseudoMetric; +Uniform -> PseudoMetric; +choice_Choice -> PseudoMetricNormedZmod; +eqtype_Equality -> PseudoMetricNormedZmod; +Filtered -> PseudoMetricNormedZmod; +Nbhs -> PseudoMetricNormedZmod; +NbhsNmodule -> PseudoMetricNormedZmod; +NbhsZmodule -> PseudoMetricNormedZmod; +GRing_Nmodule -> PseudoMetricNormedZmod; +Num_NormedZmodule -> PseudoMetricNormedZmod; +Pointed -> PseudoMetricNormedZmod; +PointedFiltered -> PseudoMetricNormedZmod; +PointedNbhs -> PseudoMetricNormedZmod; +PointedTopological -> PseudoMetricNormedZmod; +PointedUniform -> PseudoMetricNormedZmod; +PreTopologicalNmodule -> PseudoMetricNormedZmod; +PreTopologicalZmodule -> PseudoMetricNormedZmod; +PreUniformNmodule -> PseudoMetricNormedZmod; +PreUniformZmodule -> PseudoMetricNormedZmod; +PseudoMetric -> PseudoMetricNormedZmod; +PseudoPointedMetric -> PseudoMetricNormedZmod; +Num_SemiNormedZmodule -> PseudoMetricNormedZmod; +Topological -> PseudoMetricNormedZmod; +Uniform -> PseudoMetricNormedZmod; +GRing_Zmodule -> PseudoMetricNormedZmod; +choice_Choice -> PseudoPointedMetric; +eqtype_Equality -> PseudoPointedMetric; +Filtered -> PseudoPointedMetric; +Nbhs -> PseudoPointedMetric; +Pointed -> PseudoPointedMetric; +PointedFiltered -> PseudoPointedMetric; +PointedNbhs -> PseudoPointedMetric; +PointedTopological -> PseudoPointedMetric; +PointedUniform -> PseudoPointedMetric; +PseudoMetric -> PseudoPointedMetric; +Topological -> PseudoPointedMetric; +Uniform -> PseudoPointedMetric; +choice_Choice -> GRing_PzRing; +eqtype_Equality -> GRing_PzRing; +GRing_Nmodule -> GRing_PzRing; +GRing_PzSemiRing -> GRing_PzRing; +GRing_Zmodule -> GRing_PzRing; +choice_Choice -> GRing_PzSemiRing; +eqtype_Equality -> GRing_PzSemiRing; +GRing_Nmodule -> GRing_PzSemiRing; +GRing_Additive -> GRing_RMorphism; +Num_ArchiNumDomain -> reals_Real; +Num_ArchiNumField -> reals_Real; +Num_ArchiRealClosedField -> reals_Real; +Num_ArchiRealDomain -> reals_Real; +Num_ArchiRealField -> reals_Real; +choice_Choice -> reals_Real; +GRing_ComNzRing -> reals_Real; +GRing_ComNzSemiRing -> reals_Real; +GRing_ComPzRing -> reals_Real; +GRing_ComPzSemiRing -> reals_Real; +GRing_ComUnitRing -> reals_Real; +Order_DistrLattice -> reals_Real; +eqtype_Equality -> reals_Real; +GRing_Field -> reals_Real; +GRing_IntegralDomain -> reals_Real; +Order_JoinSemilattice -> reals_Real; +Order_Lattice -> reals_Real; +Order_MeetSemilattice -> reals_Real; +GRing_Nmodule -> reals_Real; +Num_NormedZmodule -> reals_Real; +Num_NumDomain -> reals_Real; +Num_NumField -> reals_Real; +GRing_NzRing -> reals_Real; +GRing_NzSemiRing -> reals_Real; +Order_POrder -> reals_Real; +Num_POrderedZmodule -> reals_Real; +GRing_PzRing -> reals_Real; +GRing_PzSemiRing -> reals_Real; +Num_RealClosedField -> reals_Real; +Num_RealDomain -> reals_Real; +Num_RealField -> reals_Real; +Num_SemiNormedZmodule -> reals_Real; +Order_Total -> reals_Real; +GRing_UnitRing -> reals_Real; +GRing_Zmodule -> reals_Real; +choice_Choice -> Num_RealClosedField; +GRing_ComNzRing -> Num_RealClosedField; +GRing_ComNzSemiRing -> Num_RealClosedField; +GRing_ComPzRing -> Num_RealClosedField; +GRing_ComPzSemiRing -> Num_RealClosedField; +GRing_ComUnitRing -> Num_RealClosedField; +Order_DistrLattice -> Num_RealClosedField; +eqtype_Equality -> Num_RealClosedField; +GRing_Field -> Num_RealClosedField; +GRing_IntegralDomain -> Num_RealClosedField; +Order_JoinSemilattice -> Num_RealClosedField; +Order_Lattice -> Num_RealClosedField; +Order_MeetSemilattice -> Num_RealClosedField; +GRing_Nmodule -> Num_RealClosedField; +Num_NormedZmodule -> Num_RealClosedField; +Num_NumDomain -> Num_RealClosedField; +Num_NumField -> Num_RealClosedField; +GRing_NzRing -> Num_RealClosedField; +GRing_NzSemiRing -> Num_RealClosedField; +Order_POrder -> Num_RealClosedField; +Num_POrderedZmodule -> Num_RealClosedField; +GRing_PzRing -> Num_RealClosedField; +GRing_PzSemiRing -> Num_RealClosedField; +Num_RealDomain -> Num_RealClosedField; +Num_RealField -> Num_RealClosedField; +Num_SemiNormedZmodule -> Num_RealClosedField; +Order_Total -> Num_RealClosedField; +GRing_UnitRing -> Num_RealClosedField; +GRing_Zmodule -> Num_RealClosedField; +choice_Choice -> Num_RealDomain; +GRing_ComNzRing -> Num_RealDomain; +GRing_ComNzSemiRing -> Num_RealDomain; +GRing_ComPzRing -> Num_RealDomain; +GRing_ComPzSemiRing -> Num_RealDomain; +GRing_ComUnitRing -> Num_RealDomain; +Order_DistrLattice -> Num_RealDomain; +eqtype_Equality -> Num_RealDomain; +GRing_IntegralDomain -> Num_RealDomain; +Order_JoinSemilattice -> Num_RealDomain; +Order_Lattice -> Num_RealDomain; +Order_MeetSemilattice -> Num_RealDomain; +GRing_Nmodule -> Num_RealDomain; +Num_NormedZmodule -> Num_RealDomain; +Num_NumDomain -> Num_RealDomain; +GRing_NzRing -> Num_RealDomain; +GRing_NzSemiRing -> Num_RealDomain; +Order_POrder -> Num_RealDomain; +Num_POrderedZmodule -> Num_RealDomain; +GRing_PzRing -> Num_RealDomain; +GRing_PzSemiRing -> Num_RealDomain; +Num_SemiNormedZmodule -> Num_RealDomain; +Order_Total -> Num_RealDomain; +GRing_UnitRing -> Num_RealDomain; +GRing_Zmodule -> Num_RealDomain; +choice_Choice -> Num_RealField; +GRing_ComNzRing -> Num_RealField; +GRing_ComNzSemiRing -> Num_RealField; +GRing_ComPzRing -> Num_RealField; +GRing_ComPzSemiRing -> Num_RealField; +GRing_ComUnitRing -> Num_RealField; +Order_DistrLattice -> Num_RealField; +eqtype_Equality -> Num_RealField; +GRing_Field -> Num_RealField; +GRing_IntegralDomain -> Num_RealField; +Order_JoinSemilattice -> Num_RealField; +Order_Lattice -> Num_RealField; +Order_MeetSemilattice -> Num_RealField; +GRing_Nmodule -> Num_RealField; +Num_NormedZmodule -> Num_RealField; +Num_NumDomain -> Num_RealField; +Num_NumField -> Num_RealField; +GRing_NzRing -> Num_RealField; +GRing_NzSemiRing -> Num_RealField; +Order_POrder -> Num_RealField; +Num_POrderedZmodule -> Num_RealField; +GRing_PzRing -> Num_RealField; +GRing_PzSemiRing -> Num_RealField; +Num_RealDomain -> Num_RealField; +Num_SemiNormedZmodule -> Num_RealField; +Order_Total -> Num_RealField; +GRing_UnitRing -> Num_RealField; +GRing_Zmodule -> Num_RealField; +choice_Choice -> RingOfSets; +eqtype_Equality -> RingOfSets; +Pointed -> RingOfSets; +SemiRingOfSets -> RingOfSets; +Content -> SFiniteMeasure; +Measure -> SFiniteMeasure; +GRing_DivClosed -> GRing_SdivClosed; +GRing_Mul2Closed -> GRing_SdivClosed; +GRing_MulClosed -> GRing_SdivClosed; +GRing_OppClosed -> GRing_SdivClosed; +GRing_SmulClosed -> GRing_SdivClosed; +choice_Choice -> GRing_SemiAlgebra; +eqtype_Equality -> GRing_SemiAlgebra; +GRing_LSemiAlgebra -> GRing_SemiAlgebra; +GRing_LSemiModule -> GRing_SemiAlgebra; +GRing_Nmodule -> GRing_SemiAlgebra; +GRing_NzSemiRing -> GRing_SemiAlgebra; +GRing_PzSemiRing -> GRing_SemiAlgebra; +GRing_Scale_PreLaw -> GRing_Scale_SemiLaw; +choice_Choice -> Num_SemiNormedZmodule; +eqtype_Equality -> Num_SemiNormedZmodule; +GRing_Nmodule -> Num_SemiNormedZmodule; +GRing_Zmodule -> Num_SemiNormedZmodule; +choice_Choice -> SemiRingOfSets; +eqtype_Equality -> SemiRingOfSets; +Pointed -> SemiRingOfSets; +GRing_AddClosed -> GRing_Semiring2Closed; +GRing_Mul2Closed -> GRing_Semiring2Closed; +GRing_AddClosed -> GRing_SemiringClosed; +GRing_Mul2Closed -> GRing_SemiringClosed; +GRing_MulClosed -> GRing_SemiringClosed; +GRing_Semiring2Closed -> GRing_SemiringClosed; +Content -> SigmaFiniteContent; +Content -> SigmaFiniteMeasure; +Measure -> SigmaFiniteMeasure; +SFiniteMeasure -> SigmaFiniteMeasure; +SigmaFiniteContent -> SigmaFiniteMeasure; +choice_Choice -> SigmaRing; +eqtype_Equality -> SigmaRing; +Pointed -> SigmaRing; +RingOfSets -> SigmaRing; +SemiRingOfSets -> SigmaRing; +GRing_Mul2Closed -> GRing_SmulClosed; +GRing_MulClosed -> GRing_SmulClosed; +GRing_OppClosed -> GRing_SmulClosed; +Bij -> SplitBij; +Fun -> SplitBij; +InjFun -> SplitBij; +Inject -> SplitBij; +InvFun -> SplitBij; +Inversible -> SplitBij; +OInvFun -> SplitBij; +OInversible -> SplitBij; +SplitInj -> SplitBij; +SplitInjFun -> SplitBij; +SplitSurj -> SplitBij; +SplitSurjFun -> SplitBij; +SurjFun -> SplitBij; +Surject -> SplitBij; +Inject -> SplitInj; +Inversible -> SplitInj; +OInversible -> SplitInj; +Fun -> SplitInjFun; +InjFun -> SplitInjFun; +Inject -> SplitInjFun; +InvFun -> SplitInjFun; +Inversible -> SplitInjFun; +OInvFun -> SplitInjFun; +OInversible -> SplitInjFun; +SplitInj -> SplitInjFun; +Inversible -> SplitSurj; +OInversible -> SplitSurj; +Surject -> SplitSurj; +Fun -> SplitSurjFun; +InvFun -> SplitSurjFun; +Inversible -> SplitSurjFun; +OInvFun -> SplitSurjFun; +OInversible -> SplitSurjFun; +SplitSurj -> SplitSurjFun; +SurjFun -> SplitSurjFun; +Surject -> SplitSurjFun; +GRing_Algebra -> GRing_SubAlgebra; +choice_Choice -> GRing_SubAlgebra; +eqtype_Equality -> GRing_SubAlgebra; +GRing_LSemiAlgebra -> GRing_SubAlgebra; +GRing_LSemiModule -> GRing_SubAlgebra; +GRing_Lalgebra -> GRing_SubAlgebra; +GRing_Lmodule -> GRing_SubAlgebra; +GRing_Nmodule -> GRing_SubAlgebra; +GRing_NzRing -> GRing_SubAlgebra; +GRing_NzSemiRing -> GRing_SubAlgebra; +GRing_PzRing -> GRing_SubAlgebra; +GRing_PzSemiRing -> GRing_SubAlgebra; +GRing_SemiAlgebra -> GRing_SubAlgebra; +SubChoice -> GRing_SubAlgebra; +SubEquality -> GRing_SubAlgebra; +GRing_SubLSemiAlgebra -> GRing_SubAlgebra; +GRing_SubLSemiModule -> GRing_SubAlgebra; +GRing_SubLalgebra -> GRing_SubAlgebra; +GRing_SubLmodule -> GRing_SubAlgebra; +GRing_SubNmodule -> GRing_SubAlgebra; +GRing_SubNzRing -> GRing_SubAlgebra; +GRing_SubNzSemiRing -> GRing_SubAlgebra; +GRing_SubPzRing -> GRing_SubAlgebra; +GRing_SubPzSemiRing -> GRing_SubAlgebra; +GRing_SubSemiAlgebra -> GRing_SubAlgebra; +SubType -> GRing_SubAlgebra; +GRing_SubZmodule -> GRing_SubAlgebra; +GRing_Zmodule -> GRing_SubAlgebra; +Order_BJoinSemilattice -> Order_SubBLattice; +Order_BLattice -> Order_SubBLattice; +Order_BMeetSemilattice -> Order_SubBLattice; +Order_BPOrder -> Order_SubBLattice; +choice_Choice -> Order_SubBLattice; +eqtype_Equality -> Order_SubBLattice; +Order_JoinSemilattice -> Order_SubBLattice; +Order_JoinSubBLattice -> Order_SubBLattice; +Order_JoinSubLattice -> Order_SubBLattice; +Order_Lattice -> Order_SubBLattice; +Order_MeetSemilattice -> Order_SubBLattice; +Order_MeetSubBLattice -> Order_SubBLattice; +Order_MeetSubLattice -> Order_SubBLattice; +Order_POrder -> Order_SubBLattice; +SubChoice -> Order_SubBLattice; +SubEquality -> Order_SubBLattice; +Order_SubLattice -> Order_SubBLattice; +Order_SubPOrder -> Order_SubBLattice; +Order_SubPOrderBLattice -> Order_SubBLattice; +Order_SubPOrderLattice -> Order_SubBLattice; +SubType -> Order_SubBLattice; +choice_Choice -> SubChoice; +eqtype_Equality -> SubChoice; +SubEquality -> SubChoice; +SubType -> SubChoice; +choice_Choice -> GRing_SubComNzRing; +GRing_ComNzRing -> GRing_SubComNzRing; +GRing_ComNzSemiRing -> GRing_SubComNzRing; +GRing_ComPzRing -> GRing_SubComNzRing; +GRing_ComPzSemiRing -> GRing_SubComNzRing; +eqtype_Equality -> GRing_SubComNzRing; +GRing_Nmodule -> GRing_SubComNzRing; +GRing_NzRing -> GRing_SubComNzRing; +GRing_NzSemiRing -> GRing_SubComNzRing; +GRing_PzRing -> GRing_SubComNzRing; +GRing_PzSemiRing -> GRing_SubComNzRing; +SubChoice -> GRing_SubComNzRing; +GRing_SubComNzSemiRing -> GRing_SubComNzRing; +GRing_SubComPzRing -> GRing_SubComNzRing; +GRing_SubComPzSemiRing -> GRing_SubComNzRing; +SubEquality -> GRing_SubComNzRing; +GRing_SubNmodule -> GRing_SubComNzRing; +GRing_SubNzRing -> GRing_SubComNzRing; +GRing_SubNzSemiRing -> GRing_SubComNzRing; +GRing_SubPzRing -> GRing_SubComNzRing; +GRing_SubPzSemiRing -> GRing_SubComNzRing; +SubType -> GRing_SubComNzRing; +GRing_SubZmodule -> GRing_SubComNzRing; +GRing_Zmodule -> GRing_SubComNzRing; +choice_Choice -> GRing_SubComNzSemiRing; +GRing_ComNzSemiRing -> GRing_SubComNzSemiRing; +GRing_ComPzSemiRing -> GRing_SubComNzSemiRing; +eqtype_Equality -> GRing_SubComNzSemiRing; +GRing_Nmodule -> GRing_SubComNzSemiRing; +GRing_NzSemiRing -> GRing_SubComNzSemiRing; +GRing_PzSemiRing -> GRing_SubComNzSemiRing; +SubChoice -> GRing_SubComNzSemiRing; +GRing_SubComPzSemiRing -> GRing_SubComNzSemiRing; +SubEquality -> GRing_SubComNzSemiRing; +GRing_SubNmodule -> GRing_SubComNzSemiRing; +GRing_SubNzSemiRing -> GRing_SubComNzSemiRing; +GRing_SubPzSemiRing -> GRing_SubComNzSemiRing; +SubType -> GRing_SubComNzSemiRing; +choice_Choice -> GRing_SubComPzRing; +GRing_ComPzRing -> GRing_SubComPzRing; +GRing_ComPzSemiRing -> GRing_SubComPzRing; +eqtype_Equality -> GRing_SubComPzRing; +GRing_Nmodule -> GRing_SubComPzRing; +GRing_PzRing -> GRing_SubComPzRing; +GRing_PzSemiRing -> GRing_SubComPzRing; +SubChoice -> GRing_SubComPzRing; +GRing_SubComPzSemiRing -> GRing_SubComPzRing; +SubEquality -> GRing_SubComPzRing; +GRing_SubNmodule -> GRing_SubComPzRing; +GRing_SubPzRing -> GRing_SubComPzRing; +GRing_SubPzSemiRing -> GRing_SubComPzRing; +SubType -> GRing_SubComPzRing; +GRing_SubZmodule -> GRing_SubComPzRing; +GRing_Zmodule -> GRing_SubComPzRing; +choice_Choice -> GRing_SubComPzSemiRing; +GRing_ComPzSemiRing -> GRing_SubComPzSemiRing; +eqtype_Equality -> GRing_SubComPzSemiRing; +GRing_Nmodule -> GRing_SubComPzSemiRing; +GRing_PzSemiRing -> GRing_SubComPzSemiRing; +SubChoice -> GRing_SubComPzSemiRing; +SubEquality -> GRing_SubComPzSemiRing; +GRing_SubNmodule -> GRing_SubComPzSemiRing; +GRing_SubPzSemiRing -> GRing_SubComPzSemiRing; +SubType -> GRing_SubComPzSemiRing; +choice_Choice -> GRing_SubComUnitRing; +GRing_ComNzRing -> GRing_SubComUnitRing; +GRing_ComNzSemiRing -> GRing_SubComUnitRing; +GRing_ComPzRing -> GRing_SubComUnitRing; +GRing_ComPzSemiRing -> GRing_SubComUnitRing; +GRing_ComUnitRing -> GRing_SubComUnitRing; +eqtype_Equality -> GRing_SubComUnitRing; +GRing_Nmodule -> GRing_SubComUnitRing; +GRing_NzRing -> GRing_SubComUnitRing; +GRing_NzSemiRing -> GRing_SubComUnitRing; +GRing_PzRing -> GRing_SubComUnitRing; +GRing_PzSemiRing -> GRing_SubComUnitRing; +SubChoice -> GRing_SubComUnitRing; +GRing_SubComNzRing -> GRing_SubComUnitRing; +GRing_SubComNzSemiRing -> GRing_SubComUnitRing; +GRing_SubComPzRing -> GRing_SubComUnitRing; +GRing_SubComPzSemiRing -> GRing_SubComUnitRing; +SubEquality -> GRing_SubComUnitRing; +GRing_SubNmodule -> GRing_SubComUnitRing; +GRing_SubNzRing -> GRing_SubComUnitRing; +GRing_SubNzSemiRing -> GRing_SubComUnitRing; +GRing_SubPzRing -> GRing_SubComUnitRing; +GRing_SubPzSemiRing -> GRing_SubComUnitRing; +SubType -> GRing_SubComUnitRing; +GRing_SubUnitRing -> GRing_SubComUnitRing; +GRing_SubZmodule -> GRing_SubComUnitRing; +GRing_UnitRing -> GRing_SubComUnitRing; +GRing_Zmodule -> GRing_SubComUnitRing; +choice_Choice -> SubCountable; +Countable -> SubCountable; +eqtype_Equality -> SubCountable; +SubChoice -> SubCountable; +SubEquality -> SubCountable; +SubType -> SubCountable; +eqtype_Equality -> SubEquality; +SubType -> SubEquality; +choice_Choice -> GRing_SubField; +GRing_ComNzRing -> GRing_SubField; +GRing_ComNzSemiRing -> GRing_SubField; +GRing_ComPzRing -> GRing_SubField; +GRing_ComPzSemiRing -> GRing_SubField; +GRing_ComUnitRing -> GRing_SubField; +eqtype_Equality -> GRing_SubField; +GRing_Field -> GRing_SubField; +GRing_IntegralDomain -> GRing_SubField; +GRing_Nmodule -> GRing_SubField; +GRing_NzRing -> GRing_SubField; +GRing_NzSemiRing -> GRing_SubField; +GRing_PzRing -> GRing_SubField; +GRing_PzSemiRing -> GRing_SubField; +SubChoice -> GRing_SubField; +GRing_SubComNzRing -> GRing_SubField; +GRing_SubComNzSemiRing -> GRing_SubField; +GRing_SubComPzRing -> GRing_SubField; +GRing_SubComPzSemiRing -> GRing_SubField; +GRing_SubComUnitRing -> GRing_SubField; +SubEquality -> GRing_SubField; +GRing_SubIntegralDomain -> GRing_SubField; +GRing_SubNmodule -> GRing_SubField; +GRing_SubNzRing -> GRing_SubField; +GRing_SubNzSemiRing -> GRing_SubField; +GRing_SubPzRing -> GRing_SubField; +GRing_SubPzSemiRing -> GRing_SubField; +SubType -> GRing_SubField; +GRing_SubUnitRing -> GRing_SubField; +GRing_SubZmodule -> GRing_SubField; +GRing_UnitRing -> GRing_SubField; +GRing_Zmodule -> GRing_SubField; +choice_Choice -> SubFinite; +Countable -> SubFinite; +eqtype_Equality -> SubFinite; +fintype_Finite -> SubFinite; +SubChoice -> SubFinite; +SubCountable -> SubFinite; +SubEquality -> SubFinite; +SubType -> SubFinite; +choice_Choice -> GRing_SubIntegralDomain; +GRing_ComNzRing -> GRing_SubIntegralDomain; +GRing_ComNzSemiRing -> GRing_SubIntegralDomain; +GRing_ComPzRing -> GRing_SubIntegralDomain; +GRing_ComPzSemiRing -> GRing_SubIntegralDomain; +GRing_ComUnitRing -> GRing_SubIntegralDomain; +eqtype_Equality -> GRing_SubIntegralDomain; +GRing_IntegralDomain -> GRing_SubIntegralDomain; +GRing_Nmodule -> GRing_SubIntegralDomain; +GRing_NzRing -> GRing_SubIntegralDomain; +GRing_NzSemiRing -> GRing_SubIntegralDomain; +GRing_PzRing -> GRing_SubIntegralDomain; +GRing_PzSemiRing -> GRing_SubIntegralDomain; +SubChoice -> GRing_SubIntegralDomain; +GRing_SubComNzRing -> GRing_SubIntegralDomain; +GRing_SubComNzSemiRing -> GRing_SubIntegralDomain; +GRing_SubComPzRing -> GRing_SubIntegralDomain; +GRing_SubComPzSemiRing -> GRing_SubIntegralDomain; +GRing_SubComUnitRing -> GRing_SubIntegralDomain; +SubEquality -> GRing_SubIntegralDomain; +GRing_SubNmodule -> GRing_SubIntegralDomain; +GRing_SubNzRing -> GRing_SubIntegralDomain; +GRing_SubNzSemiRing -> GRing_SubIntegralDomain; +GRing_SubPzRing -> GRing_SubIntegralDomain; +GRing_SubPzSemiRing -> GRing_SubIntegralDomain; +SubType -> GRing_SubIntegralDomain; +GRing_SubUnitRing -> GRing_SubIntegralDomain; +GRing_SubZmodule -> GRing_SubIntegralDomain; +GRing_UnitRing -> GRing_SubIntegralDomain; +GRing_Zmodule -> GRing_SubIntegralDomain; +choice_Choice -> GRing_SubLSemiAlgebra; +eqtype_Equality -> GRing_SubLSemiAlgebra; +GRing_LSemiAlgebra -> GRing_SubLSemiAlgebra; +GRing_LSemiModule -> GRing_SubLSemiAlgebra; +GRing_Nmodule -> GRing_SubLSemiAlgebra; +GRing_NzSemiRing -> GRing_SubLSemiAlgebra; +GRing_PzSemiRing -> GRing_SubLSemiAlgebra; +SubChoice -> GRing_SubLSemiAlgebra; +SubEquality -> GRing_SubLSemiAlgebra; +GRing_SubLSemiModule -> GRing_SubLSemiAlgebra; +GRing_SubNmodule -> GRing_SubLSemiAlgebra; +GRing_SubNzSemiRing -> GRing_SubLSemiAlgebra; +GRing_SubPzSemiRing -> GRing_SubLSemiAlgebra; +SubType -> GRing_SubLSemiAlgebra; +choice_Choice -> GRing_SubLSemiModule; +eqtype_Equality -> GRing_SubLSemiModule; +GRing_LSemiModule -> GRing_SubLSemiModule; +GRing_Nmodule -> GRing_SubLSemiModule; +SubChoice -> GRing_SubLSemiModule; +SubEquality -> GRing_SubLSemiModule; +GRing_SubNmodule -> GRing_SubLSemiModule; +SubType -> GRing_SubLSemiModule; +choice_Choice -> GRing_SubLalgebra; +eqtype_Equality -> GRing_SubLalgebra; +GRing_LSemiAlgebra -> GRing_SubLalgebra; +GRing_LSemiModule -> GRing_SubLalgebra; +GRing_Lalgebra -> GRing_SubLalgebra; +GRing_Lmodule -> GRing_SubLalgebra; +GRing_Nmodule -> GRing_SubLalgebra; +GRing_NzRing -> GRing_SubLalgebra; +GRing_NzSemiRing -> GRing_SubLalgebra; +GRing_PzRing -> GRing_SubLalgebra; +GRing_PzSemiRing -> GRing_SubLalgebra; +SubChoice -> GRing_SubLalgebra; +SubEquality -> GRing_SubLalgebra; +GRing_SubLSemiAlgebra -> GRing_SubLalgebra; +GRing_SubLSemiModule -> GRing_SubLalgebra; +GRing_SubLmodule -> GRing_SubLalgebra; +GRing_SubNmodule -> GRing_SubLalgebra; +GRing_SubNzRing -> GRing_SubLalgebra; +GRing_SubNzSemiRing -> GRing_SubLalgebra; +GRing_SubPzRing -> GRing_SubLalgebra; +GRing_SubPzSemiRing -> GRing_SubLalgebra; +SubType -> GRing_SubLalgebra; +GRing_SubZmodule -> GRing_SubLalgebra; +GRing_Zmodule -> GRing_SubLalgebra; +choice_Choice -> Order_SubLattice; +eqtype_Equality -> Order_SubLattice; +Order_JoinSemilattice -> Order_SubLattice; +Order_JoinSubLattice -> Order_SubLattice; +Order_Lattice -> Order_SubLattice; +Order_MeetSemilattice -> Order_SubLattice; +Order_MeetSubLattice -> Order_SubLattice; +Order_POrder -> Order_SubLattice; +SubChoice -> Order_SubLattice; +SubEquality -> Order_SubLattice; +Order_SubPOrder -> Order_SubLattice; +Order_SubPOrderLattice -> Order_SubLattice; +SubType -> Order_SubLattice; +choice_Choice -> GRing_SubLmodule; +eqtype_Equality -> GRing_SubLmodule; +GRing_LSemiModule -> GRing_SubLmodule; +GRing_Lmodule -> GRing_SubLmodule; +GRing_Nmodule -> GRing_SubLmodule; +SubChoice -> GRing_SubLmodule; +SubEquality -> GRing_SubLmodule; +GRing_SubLSemiModule -> GRing_SubLmodule; +GRing_SubNmodule -> GRing_SubLmodule; +SubType -> GRing_SubLmodule; +GRing_SubZmodule -> GRing_SubLmodule; +GRing_Zmodule -> GRing_SubLmodule; +choice_Choice -> GRing_SubNmodule; +eqtype_Equality -> GRing_SubNmodule; +GRing_Nmodule -> GRing_SubNmodule; +SubChoice -> GRing_SubNmodule; +SubEquality -> GRing_SubNmodule; +SubType -> GRing_SubNmodule; +choice_Choice -> GRing_SubNzRing; +eqtype_Equality -> GRing_SubNzRing; +GRing_Nmodule -> GRing_SubNzRing; +GRing_NzRing -> GRing_SubNzRing; +GRing_NzSemiRing -> GRing_SubNzRing; +GRing_PzRing -> GRing_SubNzRing; +GRing_PzSemiRing -> GRing_SubNzRing; +SubChoice -> GRing_SubNzRing; +SubEquality -> GRing_SubNzRing; +GRing_SubNmodule -> GRing_SubNzRing; +GRing_SubNzSemiRing -> GRing_SubNzRing; +GRing_SubPzRing -> GRing_SubNzRing; +GRing_SubPzSemiRing -> GRing_SubNzRing; +SubType -> GRing_SubNzRing; +GRing_SubZmodule -> GRing_SubNzRing; +GRing_Zmodule -> GRing_SubNzRing; +choice_Choice -> GRing_SubNzSemiRing; +eqtype_Equality -> GRing_SubNzSemiRing; +GRing_Nmodule -> GRing_SubNzSemiRing; +GRing_NzSemiRing -> GRing_SubNzSemiRing; +GRing_PzSemiRing -> GRing_SubNzSemiRing; +SubChoice -> GRing_SubNzSemiRing; +SubEquality -> GRing_SubNzSemiRing; +GRing_SubNmodule -> GRing_SubNzSemiRing; +GRing_SubPzSemiRing -> GRing_SubNzSemiRing; +SubType -> GRing_SubNzSemiRing; +choice_Choice -> Order_SubOrder; +Order_DistrLattice -> Order_SubOrder; +eqtype_Equality -> Order_SubOrder; +Order_JoinSemilattice -> Order_SubOrder; +Order_JoinSubLattice -> Order_SubOrder; +Order_Lattice -> Order_SubOrder; +Order_MeetSemilattice -> Order_SubOrder; +Order_MeetSubLattice -> Order_SubOrder; +Order_POrder -> Order_SubOrder; +SubChoice -> Order_SubOrder; +SubEquality -> Order_SubOrder; +Order_SubLattice -> Order_SubOrder; +Order_SubPOrder -> Order_SubOrder; +Order_SubPOrderLattice -> Order_SubOrder; +SubType -> Order_SubOrder; +Order_Total -> Order_SubOrder; +choice_Choice -> Order_SubPOrder; +eqtype_Equality -> Order_SubPOrder; +Order_POrder -> Order_SubPOrder; +SubChoice -> Order_SubPOrder; +SubEquality -> Order_SubPOrder; +SubType -> Order_SubPOrder; +Order_BJoinSemilattice -> Order_SubPOrderBLattice; +Order_BLattice -> Order_SubPOrderBLattice; +Order_BMeetSemilattice -> Order_SubPOrderBLattice; +Order_BPOrder -> Order_SubPOrderBLattice; +choice_Choice -> Order_SubPOrderBLattice; +eqtype_Equality -> Order_SubPOrderBLattice; +Order_JoinSemilattice -> Order_SubPOrderBLattice; +Order_Lattice -> Order_SubPOrderBLattice; +Order_MeetSemilattice -> Order_SubPOrderBLattice; +Order_POrder -> Order_SubPOrderBLattice; +SubChoice -> Order_SubPOrderBLattice; +SubEquality -> Order_SubPOrderBLattice; +Order_SubPOrder -> Order_SubPOrderBLattice; +Order_SubPOrderLattice -> Order_SubPOrderBLattice; +SubType -> Order_SubPOrderBLattice; +choice_Choice -> Order_SubPOrderLattice; +eqtype_Equality -> Order_SubPOrderLattice; +Order_JoinSemilattice -> Order_SubPOrderLattice; +Order_Lattice -> Order_SubPOrderLattice; +Order_MeetSemilattice -> Order_SubPOrderLattice; +Order_POrder -> Order_SubPOrderLattice; +SubChoice -> Order_SubPOrderLattice; +SubEquality -> Order_SubPOrderLattice; +Order_SubPOrder -> Order_SubPOrderLattice; +SubType -> Order_SubPOrderLattice; +Order_BJoinSemilattice -> Order_SubPOrderTBLattice; +Order_BLattice -> Order_SubPOrderTBLattice; +Order_BMeetSemilattice -> Order_SubPOrderTBLattice; +Order_BPOrder -> Order_SubPOrderTBLattice; +choice_Choice -> Order_SubPOrderTBLattice; +eqtype_Equality -> Order_SubPOrderTBLattice; +Order_JoinSemilattice -> Order_SubPOrderTBLattice; +Order_Lattice -> Order_SubPOrderTBLattice; +Order_MeetSemilattice -> Order_SubPOrderTBLattice; +Order_POrder -> Order_SubPOrderTBLattice; +SubChoice -> Order_SubPOrderTBLattice; +SubEquality -> Order_SubPOrderTBLattice; +Order_SubPOrder -> Order_SubPOrderTBLattice; +Order_SubPOrderBLattice -> Order_SubPOrderTBLattice; +Order_SubPOrderLattice -> Order_SubPOrderTBLattice; +Order_SubPOrderTLattice -> Order_SubPOrderTBLattice; +SubType -> Order_SubPOrderTBLattice; +Order_TBJoinSemilattice -> Order_SubPOrderTBLattice; +Order_TBLattice -> Order_SubPOrderTBLattice; +Order_TBMeetSemilattice -> Order_SubPOrderTBLattice; +Order_TBPOrder -> Order_SubPOrderTBLattice; +Order_TJoinSemilattice -> Order_SubPOrderTBLattice; +Order_TLattice -> Order_SubPOrderTBLattice; +Order_TMeetSemilattice -> Order_SubPOrderTBLattice; +Order_TPOrder -> Order_SubPOrderTBLattice; +choice_Choice -> Order_SubPOrderTLattice; +eqtype_Equality -> Order_SubPOrderTLattice; +Order_JoinSemilattice -> Order_SubPOrderTLattice; +Order_Lattice -> Order_SubPOrderTLattice; +Order_MeetSemilattice -> Order_SubPOrderTLattice; +Order_POrder -> Order_SubPOrderTLattice; +SubChoice -> Order_SubPOrderTLattice; +SubEquality -> Order_SubPOrderTLattice; +Order_SubPOrder -> Order_SubPOrderTLattice; +Order_SubPOrderLattice -> Order_SubPOrderTLattice; +SubType -> Order_SubPOrderTLattice; +Order_TJoinSemilattice -> Order_SubPOrderTLattice; +Order_TLattice -> Order_SubPOrderTLattice; +Order_TMeetSemilattice -> Order_SubPOrderTLattice; +Order_TPOrder -> Order_SubPOrderTLattice; +Content -> SubProbability; +FinNumFun -> SubProbability; +FiniteMeasure -> SubProbability; +Measure -> SubProbability; +SFiniteMeasure -> SubProbability; +SigmaFiniteContent -> SubProbability; +SigmaFiniteMeasure -> SubProbability; +choice_Choice -> GRing_SubPzRing; +eqtype_Equality -> GRing_SubPzRing; +GRing_Nmodule -> GRing_SubPzRing; +GRing_PzRing -> GRing_SubPzRing; +GRing_PzSemiRing -> GRing_SubPzRing; +SubChoice -> GRing_SubPzRing; +SubEquality -> GRing_SubPzRing; +GRing_SubNmodule -> GRing_SubPzRing; +GRing_SubPzSemiRing -> GRing_SubPzRing; +SubType -> GRing_SubPzRing; +GRing_SubZmodule -> GRing_SubPzRing; +GRing_Zmodule -> GRing_SubPzRing; +choice_Choice -> GRing_SubPzSemiRing; +eqtype_Equality -> GRing_SubPzSemiRing; +GRing_Nmodule -> GRing_SubPzSemiRing; +GRing_PzSemiRing -> GRing_SubPzSemiRing; +SubChoice -> GRing_SubPzSemiRing; +SubEquality -> GRing_SubPzSemiRing; +GRing_SubNmodule -> GRing_SubPzSemiRing; +SubType -> GRing_SubPzSemiRing; +choice_Choice -> GRing_SubSemiAlgebra; +eqtype_Equality -> GRing_SubSemiAlgebra; +GRing_LSemiAlgebra -> GRing_SubSemiAlgebra; +GRing_LSemiModule -> GRing_SubSemiAlgebra; +GRing_Nmodule -> GRing_SubSemiAlgebra; +GRing_NzSemiRing -> GRing_SubSemiAlgebra; +GRing_PzSemiRing -> GRing_SubSemiAlgebra; +GRing_SemiAlgebra -> GRing_SubSemiAlgebra; +SubChoice -> GRing_SubSemiAlgebra; +SubEquality -> GRing_SubSemiAlgebra; +GRing_SubLSemiAlgebra -> GRing_SubSemiAlgebra; +GRing_SubLSemiModule -> GRing_SubSemiAlgebra; +GRing_SubNmodule -> GRing_SubSemiAlgebra; +GRing_SubNzSemiRing -> GRing_SubSemiAlgebra; +GRing_SubPzSemiRing -> GRing_SubSemiAlgebra; +SubType -> GRing_SubSemiAlgebra; +Order_BJoinSemilattice -> Order_SubTBLattice; +Order_BLattice -> Order_SubTBLattice; +Order_BMeetSemilattice -> Order_SubTBLattice; +Order_BPOrder -> Order_SubTBLattice; +choice_Choice -> Order_SubTBLattice; +eqtype_Equality -> Order_SubTBLattice; +Order_JoinSemilattice -> Order_SubTBLattice; +Order_JoinSubBLattice -> Order_SubTBLattice; +Order_JoinSubLattice -> Order_SubTBLattice; +Order_JoinSubTBLattice -> Order_SubTBLattice; +Order_JoinSubTLattice -> Order_SubTBLattice; +Order_Lattice -> Order_SubTBLattice; +Order_MeetSemilattice -> Order_SubTBLattice; +Order_MeetSubBLattice -> Order_SubTBLattice; +Order_MeetSubLattice -> Order_SubTBLattice; +Order_MeetSubTBLattice -> Order_SubTBLattice; +Order_MeetSubTLattice -> Order_SubTBLattice; +Order_POrder -> Order_SubTBLattice; +Order_SubBLattice -> Order_SubTBLattice; +SubChoice -> Order_SubTBLattice; +SubEquality -> Order_SubTBLattice; +Order_SubLattice -> Order_SubTBLattice; +Order_SubPOrder -> Order_SubTBLattice; +Order_SubPOrderBLattice -> Order_SubTBLattice; +Order_SubPOrderLattice -> Order_SubTBLattice; +Order_SubPOrderTBLattice -> Order_SubTBLattice; +Order_SubPOrderTLattice -> Order_SubTBLattice; +Order_SubTLattice -> Order_SubTBLattice; +SubType -> Order_SubTBLattice; +Order_TBJoinSemilattice -> Order_SubTBLattice; +Order_TBLattice -> Order_SubTBLattice; +Order_TBMeetSemilattice -> Order_SubTBLattice; +Order_TBPOrder -> Order_SubTBLattice; +Order_TJoinSemilattice -> Order_SubTBLattice; +Order_TLattice -> Order_SubTBLattice; +Order_TMeetSemilattice -> Order_SubTBLattice; +Order_TPOrder -> Order_SubTBLattice; +choice_Choice -> Order_SubTLattice; +eqtype_Equality -> Order_SubTLattice; +Order_JoinSemilattice -> Order_SubTLattice; +Order_JoinSubLattice -> Order_SubTLattice; +Order_JoinSubTLattice -> Order_SubTLattice; +Order_Lattice -> Order_SubTLattice; +Order_MeetSemilattice -> Order_SubTLattice; +Order_MeetSubLattice -> Order_SubTLattice; +Order_MeetSubTLattice -> Order_SubTLattice; +Order_POrder -> Order_SubTLattice; +SubChoice -> Order_SubTLattice; +SubEquality -> Order_SubTLattice; +Order_SubLattice -> Order_SubTLattice; +Order_SubPOrder -> Order_SubTLattice; +Order_SubPOrderLattice -> Order_SubTLattice; +Order_SubPOrderTLattice -> Order_SubTLattice; +SubType -> Order_SubTLattice; +Order_TJoinSemilattice -> Order_SubTLattice; +Order_TLattice -> Order_SubTLattice; +Order_TMeetSemilattice -> Order_SubTLattice; +Order_TPOrder -> Order_SubTLattice; +choice_Choice -> GRing_SubUnitRing; +eqtype_Equality -> GRing_SubUnitRing; +GRing_Nmodule -> GRing_SubUnitRing; +GRing_NzRing -> GRing_SubUnitRing; +GRing_NzSemiRing -> GRing_SubUnitRing; +GRing_PzRing -> GRing_SubUnitRing; +GRing_PzSemiRing -> GRing_SubUnitRing; +SubChoice -> GRing_SubUnitRing; +SubEquality -> GRing_SubUnitRing; +GRing_SubNmodule -> GRing_SubUnitRing; +GRing_SubNzRing -> GRing_SubUnitRing; +GRing_SubNzSemiRing -> GRing_SubUnitRing; +GRing_SubPzRing -> GRing_SubUnitRing; +GRing_SubPzSemiRing -> GRing_SubUnitRing; +SubType -> GRing_SubUnitRing; +GRing_SubZmodule -> GRing_SubUnitRing; +GRing_UnitRing -> GRing_SubUnitRing; +GRing_Zmodule -> GRing_SubUnitRing; +choice_Choice -> GRing_SubZmodule; +eqtype_Equality -> GRing_SubZmodule; +GRing_Nmodule -> GRing_SubZmodule; +SubChoice -> GRing_SubZmodule; +SubEquality -> GRing_SubZmodule; +GRing_SubNmodule -> GRing_SubZmodule; +SubType -> GRing_SubZmodule; +GRing_Zmodule -> GRing_SubZmodule; +GRing_AddClosed -> GRing_SubalgClosed; +GRing_Mul2Closed -> GRing_SubalgClosed; +GRing_MulClosed -> GRing_SubalgClosed; +GRing_Semiring2Closed -> GRing_SubalgClosed; +GRing_SemiringClosed -> GRing_SubalgClosed; +GRing_SubmodClosed -> GRing_SubalgClosed; +GRing_AddClosed -> GRing_SubmodClosed; +GRing_AddClosed -> GRing_SubringClosed; +GRing_Mul2Closed -> GRing_SubringClosed; +GRing_MulClosed -> GRing_SubringClosed; +GRing_OppClosed -> GRing_SubringClosed; +GRing_Semiring2Closed -> GRing_SubringClosed; +GRing_SemiringClosed -> GRing_SubringClosed; +GRing_SmulClosed -> GRing_SubringClosed; +GRing_ZmodClosed -> GRing_SubringClosed; +Fun -> SurjFun; +OInvFun -> SurjFun; +OInversible -> SurjFun; +Surject -> SurjFun; +OInversible -> Surject; +Order_BDistrLattice -> Order_TBDistrLattice; +Order_BJoinSemilattice -> Order_TBDistrLattice; +Order_BLattice -> Order_TBDistrLattice; +Order_BMeetSemilattice -> Order_TBDistrLattice; +Order_BPOrder -> Order_TBDistrLattice; +choice_Choice -> Order_TBDistrLattice; +Order_DistrLattice -> Order_TBDistrLattice; +eqtype_Equality -> Order_TBDistrLattice; +Order_JoinSemilattice -> Order_TBDistrLattice; +Order_Lattice -> Order_TBDistrLattice; +Order_MeetSemilattice -> Order_TBDistrLattice; +Order_POrder -> Order_TBDistrLattice; +Order_TBJoinSemilattice -> Order_TBDistrLattice; +Order_TBLattice -> Order_TBDistrLattice; +Order_TBMeetSemilattice -> Order_TBDistrLattice; +Order_TBPOrder -> Order_TBDistrLattice; +Order_TDistrLattice -> Order_TBDistrLattice; +Order_TJoinSemilattice -> Order_TBDistrLattice; +Order_TLattice -> Order_TBDistrLattice; +Order_TMeetSemilattice -> Order_TBDistrLattice; +Order_TPOrder -> Order_TBDistrLattice; +Order_BJoinSemilattice -> Order_TBJoinSemilattice; +Order_BPOrder -> Order_TBJoinSemilattice; +choice_Choice -> Order_TBJoinSemilattice; +eqtype_Equality -> Order_TBJoinSemilattice; +Order_JoinSemilattice -> Order_TBJoinSemilattice; +Order_POrder -> Order_TBJoinSemilattice; +Order_TBPOrder -> Order_TBJoinSemilattice; +Order_TJoinSemilattice -> Order_TBJoinSemilattice; +Order_TPOrder -> Order_TBJoinSemilattice; +Order_BJoinSemilattice -> Order_TBLattice; +Order_BLattice -> Order_TBLattice; +Order_BMeetSemilattice -> Order_TBLattice; +Order_BPOrder -> Order_TBLattice; +choice_Choice -> Order_TBLattice; +eqtype_Equality -> Order_TBLattice; +Order_JoinSemilattice -> Order_TBLattice; +Order_Lattice -> Order_TBLattice; +Order_MeetSemilattice -> Order_TBLattice; +Order_POrder -> Order_TBLattice; +Order_TBJoinSemilattice -> Order_TBLattice; +Order_TBMeetSemilattice -> Order_TBLattice; +Order_TBPOrder -> Order_TBLattice; +Order_TJoinSemilattice -> Order_TBLattice; +Order_TLattice -> Order_TBLattice; +Order_TMeetSemilattice -> Order_TBLattice; +Order_TPOrder -> Order_TBLattice; +Order_BLatticeClosed -> Order_TBLatticeClosed; +Order_TLatticeClosed -> Order_TBLatticeClosed; +Order_BLatticeMorphism -> Order_TBLatticeMorphism; +Order_TLatticeMorphism -> Order_TBLatticeMorphism; +Order_BMeetSemilattice -> Order_TBMeetSemilattice; +Order_BPOrder -> Order_TBMeetSemilattice; +choice_Choice -> Order_TBMeetSemilattice; +eqtype_Equality -> Order_TBMeetSemilattice; +Order_MeetSemilattice -> Order_TBMeetSemilattice; +Order_POrder -> Order_TBMeetSemilattice; +Order_TBPOrder -> Order_TBMeetSemilattice; +Order_TMeetSemilattice -> Order_TBMeetSemilattice; +Order_TPOrder -> Order_TBMeetSemilattice; +Order_BPOrder -> Order_TBPOrder; +choice_Choice -> Order_TBPOrder; +eqtype_Equality -> Order_TBPOrder; +Order_POrder -> Order_TBPOrder; +Order_TPOrder -> Order_TBPOrder; +Order_BJoinSemilattice -> Order_TBSubLattice; +Order_BJoinSubLattice -> Order_TBSubLattice; +Order_BJoinSubTLattice -> Order_TBSubLattice; +Order_BLattice -> Order_TBSubLattice; +Order_BMeetSemilattice -> Order_TBSubLattice; +Order_BPOrder -> Order_TBSubLattice; +Order_BSubLattice -> Order_TBSubLattice; +Order_BSubTLattice -> Order_TBSubLattice; +choice_Choice -> Order_TBSubLattice; +eqtype_Equality -> Order_TBSubLattice; +Order_JoinSemilattice -> Order_TBSubLattice; +Order_JoinSubBLattice -> Order_TBSubLattice; +Order_JoinSubLattice -> Order_TBSubLattice; +Order_JoinSubTBLattice -> Order_TBSubLattice; +Order_JoinSubTLattice -> Order_TBSubLattice; +Order_Lattice -> Order_TBSubLattice; +Order_MeetSemilattice -> Order_TBSubLattice; +Order_MeetSubBLattice -> Order_TBSubLattice; +Order_MeetSubLattice -> Order_TBSubLattice; +Order_MeetSubTBLattice -> Order_TBSubLattice; +Order_MeetSubTLattice -> Order_TBSubLattice; +Order_POrder -> Order_TBSubLattice; +Order_SubBLattice -> Order_TBSubLattice; +SubChoice -> Order_TBSubLattice; +SubEquality -> Order_TBSubLattice; +Order_SubLattice -> Order_TBSubLattice; +Order_SubPOrder -> Order_TBSubLattice; +Order_SubPOrderBLattice -> Order_TBSubLattice; +Order_SubPOrderLattice -> Order_TBSubLattice; +Order_SubPOrderTBLattice -> Order_TBSubLattice; +Order_SubPOrderTLattice -> Order_TBSubLattice; +Order_SubTBLattice -> Order_TBSubLattice; +Order_SubTLattice -> Order_TBSubLattice; +SubType -> Order_TBSubLattice; +Order_TBJoinSemilattice -> Order_TBSubLattice; +Order_TBLattice -> Order_TBSubLattice; +Order_TBMeetSemilattice -> Order_TBSubLattice; +Order_TBPOrder -> Order_TBSubLattice; +Order_TJoinSemilattice -> Order_TBSubLattice; +Order_TLattice -> Order_TBSubLattice; +Order_TMeetSemilattice -> Order_TBSubLattice; +Order_TMeetSubBLattice -> Order_TBSubLattice; +Order_TMeetSubLattice -> Order_TBSubLattice; +Order_TPOrder -> Order_TBSubLattice; +Order_TSubBLattice -> Order_TBSubLattice; +Order_TSubLattice -> Order_TBSubLattice; +Order_BDistrLattice -> Order_TBTotal; +Order_BJoinSemilattice -> Order_TBTotal; +Order_BLattice -> Order_TBTotal; +Order_BMeetSemilattice -> Order_TBTotal; +Order_BPOrder -> Order_TBTotal; +Order_BTotal -> Order_TBTotal; +choice_Choice -> Order_TBTotal; +Order_DistrLattice -> Order_TBTotal; +eqtype_Equality -> Order_TBTotal; +Order_JoinSemilattice -> Order_TBTotal; +Order_Lattice -> Order_TBTotal; +Order_MeetSemilattice -> Order_TBTotal; +Order_POrder -> Order_TBTotal; +Order_TBDistrLattice -> Order_TBTotal; +Order_TBJoinSemilattice -> Order_TBTotal; +Order_TBLattice -> Order_TBTotal; +Order_TBMeetSemilattice -> Order_TBTotal; +Order_TBPOrder -> Order_TBTotal; +Order_TDistrLattice -> Order_TBTotal; +Order_TJoinSemilattice -> Order_TBTotal; +Order_TLattice -> Order_TBTotal; +Order_TMeetSemilattice -> Order_TBTotal; +Order_TPOrder -> Order_TBTotal; +Order_TTotal -> Order_TBTotal; +Order_Total -> Order_TBTotal; +choice_Choice -> Order_TDistrLattice; +Order_DistrLattice -> Order_TDistrLattice; +eqtype_Equality -> Order_TDistrLattice; +Order_JoinSemilattice -> Order_TDistrLattice; +Order_Lattice -> Order_TDistrLattice; +Order_MeetSemilattice -> Order_TDistrLattice; +Order_POrder -> Order_TDistrLattice; +Order_TJoinSemilattice -> Order_TDistrLattice; +Order_TLattice -> Order_TDistrLattice; +Order_TMeetSemilattice -> Order_TDistrLattice; +Order_TPOrder -> Order_TDistrLattice; +choice_Choice -> Order_TJoinSemilattice; +eqtype_Equality -> Order_TJoinSemilattice; +Order_JoinSemilattice -> Order_TJoinSemilattice; +Order_POrder -> Order_TJoinSemilattice; +Order_TPOrder -> Order_TJoinSemilattice; +choice_Choice -> Order_TLattice; +eqtype_Equality -> Order_TLattice; +Order_JoinSemilattice -> Order_TLattice; +Order_Lattice -> Order_TLattice; +Order_MeetSemilattice -> Order_TLattice; +Order_POrder -> Order_TLattice; +Order_TJoinSemilattice -> Order_TLattice; +Order_TMeetSemilattice -> Order_TLattice; +Order_TPOrder -> Order_TLattice; +Order_MeetLatticeClosed -> Order_TMeetLatticeClosed; +Order_TLatticeClosed -> Order_TMeetLatticeClosed; +choice_Choice -> Order_TMeetSemilattice; +eqtype_Equality -> Order_TMeetSemilattice; +Order_MeetSemilattice -> Order_TMeetSemilattice; +Order_POrder -> Order_TMeetSemilattice; +Order_TPOrder -> Order_TMeetSemilattice; +Order_BJoinSemilattice -> Order_TMeetSubBLattice; +Order_BLattice -> Order_TMeetSubBLattice; +Order_BMeetSemilattice -> Order_TMeetSubBLattice; +Order_BPOrder -> Order_TMeetSubBLattice; +choice_Choice -> Order_TMeetSubBLattice; +eqtype_Equality -> Order_TMeetSubBLattice; +Order_JoinSemilattice -> Order_TMeetSubBLattice; +Order_Lattice -> Order_TMeetSubBLattice; +Order_MeetSemilattice -> Order_TMeetSubBLattice; +Order_MeetSubBLattice -> Order_TMeetSubBLattice; +Order_MeetSubLattice -> Order_TMeetSubBLattice; +Order_MeetSubTBLattice -> Order_TMeetSubBLattice; +Order_MeetSubTLattice -> Order_TMeetSubBLattice; +Order_POrder -> Order_TMeetSubBLattice; +SubChoice -> Order_TMeetSubBLattice; +SubEquality -> Order_TMeetSubBLattice; +Order_SubPOrder -> Order_TMeetSubBLattice; +Order_SubPOrderBLattice -> Order_TMeetSubBLattice; +Order_SubPOrderLattice -> Order_TMeetSubBLattice; +Order_SubPOrderTBLattice -> Order_TMeetSubBLattice; +Order_SubPOrderTLattice -> Order_TMeetSubBLattice; +SubType -> Order_TMeetSubBLattice; +Order_TBJoinSemilattice -> Order_TMeetSubBLattice; +Order_TBLattice -> Order_TMeetSubBLattice; +Order_TBMeetSemilattice -> Order_TMeetSubBLattice; +Order_TBPOrder -> Order_TMeetSubBLattice; +Order_TJoinSemilattice -> Order_TMeetSubBLattice; +Order_TLattice -> Order_TMeetSubBLattice; +Order_TMeetSemilattice -> Order_TMeetSubBLattice; +Order_TMeetSubLattice -> Order_TMeetSubBLattice; +Order_TPOrder -> Order_TMeetSubBLattice; +choice_Choice -> Order_TMeetSubLattice; +eqtype_Equality -> Order_TMeetSubLattice; +Order_JoinSemilattice -> Order_TMeetSubLattice; +Order_Lattice -> Order_TMeetSubLattice; +Order_MeetSemilattice -> Order_TMeetSubLattice; +Order_MeetSubLattice -> Order_TMeetSubLattice; +Order_MeetSubTLattice -> Order_TMeetSubLattice; +Order_POrder -> Order_TMeetSubLattice; +SubChoice -> Order_TMeetSubLattice; +SubEquality -> Order_TMeetSubLattice; +Order_SubPOrder -> Order_TMeetSubLattice; +Order_SubPOrderLattice -> Order_TMeetSubLattice; +Order_SubPOrderTLattice -> Order_TMeetSubLattice; +SubType -> Order_TMeetSubLattice; +Order_TJoinSemilattice -> Order_TMeetSubLattice; +Order_TLattice -> Order_TMeetSubLattice; +Order_TMeetSemilattice -> Order_TMeetSubLattice; +Order_TPOrder -> Order_TMeetSubLattice; +choice_Choice -> Order_TPOrder; +eqtype_Equality -> Order_TPOrder; +Order_POrder -> Order_TPOrder; +Order_BJoinSemilattice -> Order_TSubBLattice; +Order_BLattice -> Order_TSubBLattice; +Order_BMeetSemilattice -> Order_TSubBLattice; +Order_BPOrder -> Order_TSubBLattice; +choice_Choice -> Order_TSubBLattice; +eqtype_Equality -> Order_TSubBLattice; +Order_JoinSemilattice -> Order_TSubBLattice; +Order_JoinSubBLattice -> Order_TSubBLattice; +Order_JoinSubLattice -> Order_TSubBLattice; +Order_JoinSubTBLattice -> Order_TSubBLattice; +Order_JoinSubTLattice -> Order_TSubBLattice; +Order_Lattice -> Order_TSubBLattice; +Order_MeetSemilattice -> Order_TSubBLattice; +Order_MeetSubBLattice -> Order_TSubBLattice; +Order_MeetSubLattice -> Order_TSubBLattice; +Order_MeetSubTBLattice -> Order_TSubBLattice; +Order_MeetSubTLattice -> Order_TSubBLattice; +Order_POrder -> Order_TSubBLattice; +Order_SubBLattice -> Order_TSubBLattice; +SubChoice -> Order_TSubBLattice; +SubEquality -> Order_TSubBLattice; +Order_SubLattice -> Order_TSubBLattice; +Order_SubPOrder -> Order_TSubBLattice; +Order_SubPOrderBLattice -> Order_TSubBLattice; +Order_SubPOrderLattice -> Order_TSubBLattice; +Order_SubPOrderTBLattice -> Order_TSubBLattice; +Order_SubPOrderTLattice -> Order_TSubBLattice; +Order_SubTBLattice -> Order_TSubBLattice; +Order_SubTLattice -> Order_TSubBLattice; +SubType -> Order_TSubBLattice; +Order_TBJoinSemilattice -> Order_TSubBLattice; +Order_TBLattice -> Order_TSubBLattice; +Order_TBMeetSemilattice -> Order_TSubBLattice; +Order_TBPOrder -> Order_TSubBLattice; +Order_TJoinSemilattice -> Order_TSubBLattice; +Order_TLattice -> Order_TSubBLattice; +Order_TMeetSemilattice -> Order_TSubBLattice; +Order_TMeetSubBLattice -> Order_TSubBLattice; +Order_TMeetSubLattice -> Order_TSubBLattice; +Order_TPOrder -> Order_TSubBLattice; +Order_TSubLattice -> Order_TSubBLattice; +choice_Choice -> Order_TSubLattice; +eqtype_Equality -> Order_TSubLattice; +Order_JoinSemilattice -> Order_TSubLattice; +Order_JoinSubLattice -> Order_TSubLattice; +Order_JoinSubTLattice -> Order_TSubLattice; +Order_Lattice -> Order_TSubLattice; +Order_MeetSemilattice -> Order_TSubLattice; +Order_MeetSubLattice -> Order_TSubLattice; +Order_MeetSubTLattice -> Order_TSubLattice; +Order_POrder -> Order_TSubLattice; +SubChoice -> Order_TSubLattice; +SubEquality -> Order_TSubLattice; +Order_SubLattice -> Order_TSubLattice; +Order_SubPOrder -> Order_TSubLattice; +Order_SubPOrderLattice -> Order_TSubLattice; +Order_SubPOrderTLattice -> Order_TSubLattice; +Order_SubTLattice -> Order_TSubLattice; +SubType -> Order_TSubLattice; +Order_TJoinSemilattice -> Order_TSubLattice; +Order_TLattice -> Order_TSubLattice; +Order_TMeetSemilattice -> Order_TSubLattice; +Order_TMeetSubLattice -> Order_TSubLattice; +Order_TPOrder -> Order_TSubLattice; +choice_Choice -> Order_TTotal; +Order_DistrLattice -> Order_TTotal; +eqtype_Equality -> Order_TTotal; +Order_JoinSemilattice -> Order_TTotal; +Order_Lattice -> Order_TTotal; +Order_MeetSemilattice -> Order_TTotal; +Order_POrder -> Order_TTotal; +Order_TDistrLattice -> Order_TTotal; +Order_TJoinSemilattice -> Order_TTotal; +Order_TLattice -> Order_TTotal; +Order_TMeetSemilattice -> Order_TTotal; +Order_TPOrder -> Order_TTotal; +Order_Total -> Order_TTotal; +choice_Choice -> Topological; +eqtype_Equality -> Topological; +Filtered -> Topological; +Nbhs -> Topological; +choice_Choice -> TopologicalLmodule; +eqtype_Equality -> TopologicalLmodule; +Filtered -> TopologicalLmodule; +GRing_LSemiModule -> TopologicalLmodule; +GRing_Lmodule -> TopologicalLmodule; +Nbhs -> TopologicalLmodule; +NbhsLmodule -> TopologicalLmodule; +NbhsNmodule -> TopologicalLmodule; +NbhsZmodule -> TopologicalLmodule; +GRing_Nmodule -> TopologicalLmodule; +PreTopologicalLmodule -> TopologicalLmodule; +PreTopologicalNmodule -> TopologicalLmodule; +PreTopologicalZmodule -> TopologicalLmodule; +Topological -> TopologicalLmodule; +TopologicalNmodule -> TopologicalLmodule; +TopologicalZmodule -> TopologicalLmodule; +GRing_Zmodule -> TopologicalLmodule; +choice_Choice -> TopologicalNmodule; +eqtype_Equality -> TopologicalNmodule; +Filtered -> TopologicalNmodule; +Nbhs -> TopologicalNmodule; +NbhsNmodule -> TopologicalNmodule; +GRing_Nmodule -> TopologicalNmodule; +PreTopologicalNmodule -> TopologicalNmodule; +Topological -> TopologicalNmodule; +choice_Choice -> TopologicalZmodule; +eqtype_Equality -> TopologicalZmodule; +Filtered -> TopologicalZmodule; +Nbhs -> TopologicalZmodule; +NbhsNmodule -> TopologicalZmodule; +NbhsZmodule -> TopologicalZmodule; +GRing_Nmodule -> TopologicalZmodule; +PreTopologicalNmodule -> TopologicalZmodule; +PreTopologicalZmodule -> TopologicalZmodule; +Topological -> TopologicalZmodule; +TopologicalNmodule -> TopologicalZmodule; +GRing_Zmodule -> TopologicalZmodule; +choice_Choice -> Order_Total; +Order_DistrLattice -> Order_Total; +eqtype_Equality -> Order_Total; +Order_JoinSemilattice -> Order_Total; +Order_Lattice -> Order_Total; +Order_MeetSemilattice -> Order_Total; +Order_POrder -> Order_Total; +choice_Choice -> Tvs; +eqtype_Equality -> Tvs; +Filtered -> Tvs; +GRing_LSemiModule -> Tvs; +GRing_Lmodule -> Tvs; +Nbhs -> Tvs; +NbhsLmodule -> Tvs; +NbhsNmodule -> Tvs; +NbhsZmodule -> Tvs; +GRing_Nmodule -> Tvs; +PreTopologicalLmodule -> Tvs; +PreTopologicalNmodule -> Tvs; +PreTopologicalZmodule -> Tvs; +PreUniformLmodule -> Tvs; +PreUniformNmodule -> Tvs; +PreUniformZmodule -> Tvs; +Topological -> Tvs; +TopologicalLmodule -> Tvs; +TopologicalNmodule -> Tvs; +TopologicalZmodule -> Tvs; +Uniform -> Tvs; +GRing_Zmodule -> Tvs; +choice_Choice -> Uniform; +eqtype_Equality -> Uniform; +Filtered -> Uniform; +Nbhs -> Uniform; +Topological -> Uniform; +choice_Choice -> UniformLmodule; +eqtype_Equality -> UniformLmodule; +Filtered -> UniformLmodule; +GRing_LSemiModule -> UniformLmodule; +GRing_Lmodule -> UniformLmodule; +Nbhs -> UniformLmodule; +NbhsLmodule -> UniformLmodule; +NbhsNmodule -> UniformLmodule; +NbhsZmodule -> UniformLmodule; +GRing_Nmodule -> UniformLmodule; +PreTopologicalLmodule -> UniformLmodule; +PreTopologicalNmodule -> UniformLmodule; +PreTopologicalZmodule -> UniformLmodule; +PreUniformLmodule -> UniformLmodule; +PreUniformNmodule -> UniformLmodule; +PreUniformZmodule -> UniformLmodule; +Topological -> UniformLmodule; +Uniform -> UniformLmodule; +UniformNmodule -> UniformLmodule; +UniformZmodule -> UniformLmodule; +GRing_Zmodule -> UniformLmodule; +choice_Choice -> UniformNmodule; +eqtype_Equality -> UniformNmodule; +Filtered -> UniformNmodule; +Nbhs -> UniformNmodule; +NbhsNmodule -> UniformNmodule; +GRing_Nmodule -> UniformNmodule; +PreTopologicalNmodule -> UniformNmodule; +PreUniformNmodule -> UniformNmodule; +Topological -> UniformNmodule; +Uniform -> UniformNmodule; +choice_Choice -> UniformZmodule; +eqtype_Equality -> UniformZmodule; +Filtered -> UniformZmodule; +Nbhs -> UniformZmodule; +NbhsNmodule -> UniformZmodule; +NbhsZmodule -> UniformZmodule; +GRing_Nmodule -> UniformZmodule; +PreTopologicalNmodule -> UniformZmodule; +PreTopologicalZmodule -> UniformZmodule; +PreUniformNmodule -> UniformZmodule; +PreUniformZmodule -> UniformZmodule; +Topological -> UniformZmodule; +Uniform -> UniformZmodule; +UniformNmodule -> UniformZmodule; +GRing_Zmodule -> UniformZmodule; +GRing_Algebra -> GRing_UnitAlgebra; +choice_Choice -> GRing_UnitAlgebra; +eqtype_Equality -> GRing_UnitAlgebra; +GRing_LSemiAlgebra -> GRing_UnitAlgebra; +GRing_LSemiModule -> GRing_UnitAlgebra; +GRing_Lalgebra -> GRing_UnitAlgebra; +GRing_Lmodule -> GRing_UnitAlgebra; +GRing_Nmodule -> GRing_UnitAlgebra; +GRing_NzRing -> GRing_UnitAlgebra; +GRing_NzSemiRing -> GRing_UnitAlgebra; +GRing_PzRing -> GRing_UnitAlgebra; +GRing_PzSemiRing -> GRing_UnitAlgebra; +GRing_SemiAlgebra -> GRing_UnitAlgebra; +GRing_UnitRing -> GRing_UnitAlgebra; +GRing_Zmodule -> GRing_UnitAlgebra; +choice_Choice -> GRing_UnitRing; +eqtype_Equality -> GRing_UnitRing; +GRing_Nmodule -> GRing_UnitRing; +GRing_NzRing -> GRing_UnitRing; +GRing_NzSemiRing -> GRing_UnitRing; +GRing_PzRing -> GRing_UnitRing; +GRing_PzSemiRing -> GRing_UnitRing; +GRing_Zmodule -> GRing_UnitRing; +GRing_AddClosed -> GRing_ZmodClosed; +GRing_OppClosed -> GRing_ZmodClosed; +choice_Choice -> GRing_Zmodule; +eqtype_Equality -> GRing_Zmodule; +GRing_Nmodule -> GRing_Zmodule; +} \ No newline at end of file diff --git a/theories/cumulative_1.txt b/theories/cumulative_1.txt new file mode 100644 index 0000000000..e05b7e6d8a --- /dev/null +++ b/theories/cumulative_1.txt @@ -0,0 +1,86 @@ +(* mathcomp analysis (c) 2017 Inria and AIST. License: CeCILL-C. *) +From mathcomp Require Import all_ssreflect ssralg ssrnum ssrint interval. +From mathcomp Require Import finmap fingroup perm rat archimedean. +From HB Require Import structures. +From mathcomp Require Import mathcomp_extra unstable boolp classical_sets. +From mathcomp Require Import functions fsbigop cardinality. +From mathcomp Require Import reals ereal interval_inference topology numfun. +From mathcomp Require Import normedtype sequences esum real_interval measure. +From mathcomp Require Import realfun. + +(**md**************************************************************************) +(* # Lebesgue Stieltjes Measure *) +(* *) +(* This file contains a formalization of the Lebesgue-Stieltjes measure using *) +(* the Measure Extension theorem from measure.v. *) +(* *) +(* References: *) +(* - Achim Klenke. Probability Theory 2nd edition. 2014 *) +(* - Y. Ishiguro, R. Affeldt. The Radon-Nikodym Theorem and the Lebesgue- *) +(* Stieltjes measure in Coq. Computer Software 41(2).2024 *) +(* *) +(* ``` *) +(* right_continuous f == the function f is right-continuous *) +(* cumulative R == type of non-decreasing, right-continuous *) +(* functions (with R : numFieldType) *) +(* The HB class is Cumulative. *) +(* instance: idfun *) +(* ocitv_type R == alias for R : realType *) +(* ocitv == set of open-closed intervals ]x, y] where *) +(* x and y are real numbers *) +(* R.-ocitv == display for ocitv_type R *) +(* R.-ocitv.-measurable == semiring of sets of open-closed intervals *) +(* wlength f A := f b - f a with the hull of the set of real *) +(* numbers A being delimited by a and b *) +(* lebesgue_stieltjes_measure f == Lebesgue-Stieltjes measure for f *) +(* f is a cumulative function. *) +(* completed_lebesgue_stieltjes_measure f == the completed Lebesgue-Stieltjes *) +(* measure *) +(* ``` *) +(* *) +(******************************************************************************) + +Set Implicit Arguments. +Unset Strict Implicit. +Unset Printing Implicit Defensive. +Import Order.TTheory GRing.Theory Num.Def Num.Theory. +Import numFieldTopology.Exports. + +Local Open Scope classical_set_scope. +Local Open Scope ring_scope. + +Reserved Notation "R .-ocitv" (at level 1, format "R .-ocitv"). +Reserved Notation "R .-ocitv.-measurable" + (at level 2, format "R .-ocitv.-measurable"). + +(* TODO: move? *) +Notation right_continuous f := + (forall x, f%function @ at_right x --> f%function x). + +Lemma right_continuousW (R : numFieldType) {d} (U : orderTopologicalType d) + (f : R -> U) : continuous f -> right_continuous f. +Proof. by move=> cf x; apply: cvg_within_filter; exact/cf. Qed. + +HB.mixin Record isCumulative (R : numFieldType) {d} (U : orderTopologicalType d) + (f : R -> U) := { + cumulative_is_nondecreasing : nondecreasing f ; + cumulative_is_right_continuous : right_continuous f }. + +#[short(type=cumulative)] +HB.structure Definition Cumulative + (R : numFieldType) {d} (U : orderTopologicalType d) := { f of isCumulative R d U f }. + +Arguments cumulative_is_nondecreasing {R d U} _. +Arguments cumulative_is_right_continuous {R d U} _. + +Section id_is_cumulative. +Variable R : realType. + +Let id_nd : {homo @idfun R : x y / x <= y}. +Proof. by []. Qed. + +Let id_rc : right_continuous (@idfun R). +Proof. apply: right_continuousW=> x; exact: cvg_id. Qed. (* fail *) + +HB.instance Definition _ := isCumulative.Build R _ R idfun id_nd id_rc. +End id_is_cumulative. diff --git a/theories/cumulative_1.v b/theories/cumulative_1.v new file mode 100644 index 0000000000..e05b7e6d8a --- /dev/null +++ b/theories/cumulative_1.v @@ -0,0 +1,86 @@ +(* mathcomp analysis (c) 2017 Inria and AIST. License: CeCILL-C. *) +From mathcomp Require Import all_ssreflect ssralg ssrnum ssrint interval. +From mathcomp Require Import finmap fingroup perm rat archimedean. +From HB Require Import structures. +From mathcomp Require Import mathcomp_extra unstable boolp classical_sets. +From mathcomp Require Import functions fsbigop cardinality. +From mathcomp Require Import reals ereal interval_inference topology numfun. +From mathcomp Require Import normedtype sequences esum real_interval measure. +From mathcomp Require Import realfun. + +(**md**************************************************************************) +(* # Lebesgue Stieltjes Measure *) +(* *) +(* This file contains a formalization of the Lebesgue-Stieltjes measure using *) +(* the Measure Extension theorem from measure.v. *) +(* *) +(* References: *) +(* - Achim Klenke. Probability Theory 2nd edition. 2014 *) +(* - Y. Ishiguro, R. Affeldt. The Radon-Nikodym Theorem and the Lebesgue- *) +(* Stieltjes measure in Coq. Computer Software 41(2).2024 *) +(* *) +(* ``` *) +(* right_continuous f == the function f is right-continuous *) +(* cumulative R == type of non-decreasing, right-continuous *) +(* functions (with R : numFieldType) *) +(* The HB class is Cumulative. *) +(* instance: idfun *) +(* ocitv_type R == alias for R : realType *) +(* ocitv == set of open-closed intervals ]x, y] where *) +(* x and y are real numbers *) +(* R.-ocitv == display for ocitv_type R *) +(* R.-ocitv.-measurable == semiring of sets of open-closed intervals *) +(* wlength f A := f b - f a with the hull of the set of real *) +(* numbers A being delimited by a and b *) +(* lebesgue_stieltjes_measure f == Lebesgue-Stieltjes measure for f *) +(* f is a cumulative function. *) +(* completed_lebesgue_stieltjes_measure f == the completed Lebesgue-Stieltjes *) +(* measure *) +(* ``` *) +(* *) +(******************************************************************************) + +Set Implicit Arguments. +Unset Strict Implicit. +Unset Printing Implicit Defensive. +Import Order.TTheory GRing.Theory Num.Def Num.Theory. +Import numFieldTopology.Exports. + +Local Open Scope classical_set_scope. +Local Open Scope ring_scope. + +Reserved Notation "R .-ocitv" (at level 1, format "R .-ocitv"). +Reserved Notation "R .-ocitv.-measurable" + (at level 2, format "R .-ocitv.-measurable"). + +(* TODO: move? *) +Notation right_continuous f := + (forall x, f%function @ at_right x --> f%function x). + +Lemma right_continuousW (R : numFieldType) {d} (U : orderTopologicalType d) + (f : R -> U) : continuous f -> right_continuous f. +Proof. by move=> cf x; apply: cvg_within_filter; exact/cf. Qed. + +HB.mixin Record isCumulative (R : numFieldType) {d} (U : orderTopologicalType d) + (f : R -> U) := { + cumulative_is_nondecreasing : nondecreasing f ; + cumulative_is_right_continuous : right_continuous f }. + +#[short(type=cumulative)] +HB.structure Definition Cumulative + (R : numFieldType) {d} (U : orderTopologicalType d) := { f of isCumulative R d U f }. + +Arguments cumulative_is_nondecreasing {R d U} _. +Arguments cumulative_is_right_continuous {R d U} _. + +Section id_is_cumulative. +Variable R : realType. + +Let id_nd : {homo @idfun R : x y / x <= y}. +Proof. by []. Qed. + +Let id_rc : right_continuous (@idfun R). +Proof. apply: right_continuousW=> x; exact: cvg_id. Qed. (* fail *) + +HB.instance Definition _ := isCumulative.Build R _ R idfun id_nd id_rc. +End id_is_cumulative. diff --git a/theories/cumulative_2.txt b/theories/cumulative_2.txt new file mode 100644 index 0000000000..302d7d8302 --- /dev/null +++ b/theories/cumulative_2.txt @@ -0,0 +1,86 @@ +(* mathcomp analysis (c) 2017 Inria and AIST. License: CeCILL-C. *) +From mathcomp Require Import all_ssreflect ssralg ssrnum ssrint interval. +From mathcomp Require Import finmap fingroup perm rat archimedean. +From HB Require Import structures. +From mathcomp Require Import mathcomp_extra unstable boolp classical_sets. +From mathcomp Require Import functions fsbigop cardinality. +From mathcomp Require Import reals ereal interval_inference topology numfun. +From mathcomp Require Import normedtype sequences esum real_interval measure. +From mathcomp Require Import realfun. + +(**md**************************************************************************) +(* # Lebesgue Stieltjes Measure *) +(* *) +(* This file contains a formalization of the Lebesgue-Stieltjes measure using *) +(* the Measure Extension theorem from measure.v. *) +(* *) +(* References: *) +(* - Achim Klenke. Probability Theory 2nd edition. 2014 *) +(* - Y. Ishiguro, R. Affeldt. The Radon-Nikodym Theorem and the Lebesgue- *) +(* Stieltjes measure in Coq. Computer Software 41(2).2024 *) +(* *) +(* ``` *) +(* right_continuous f == the function f is right-continuous *) +(* cumulative R == type of non-decreasing, right-continuous *) +(* functions (with R : numFieldType) *) +(* The HB class is Cumulative. *) +(* instance: idfun *) +(* ocitv_type R == alias for R : realType *) +(* ocitv == set of open-closed intervals ]x, y] where *) +(* x and y are real numbers *) +(* R.-ocitv == display for ocitv_type R *) +(* R.-ocitv.-measurable == semiring of sets of open-closed intervals *) +(* wlength f A := f b - f a with the hull of the set of real *) +(* numbers A being delimited by a and b *) +(* lebesgue_stieltjes_measure f == Lebesgue-Stieltjes measure for f *) +(* f is a cumulative function. *) +(* completed_lebesgue_stieltjes_measure f == the completed Lebesgue-Stieltjes *) +(* measure *) +(* ``` *) +(* *) +(******************************************************************************) + +Set Implicit Arguments. +Unset Strict Implicit. +Unset Printing Implicit Defensive. +Import Order.TTheory GRing.Theory Num.Def Num.Theory. +Import numFieldTopology.Exports. + +Local Open Scope classical_set_scope. +Local Open Scope ring_scope. + +Reserved Notation "R .-ocitv" (at level 1, format "R .-ocitv"). +Reserved Notation "R .-ocitv.-measurable" + (at level 2, format "R .-ocitv.-measurable"). + +(* TODO: move? *) +Notation right_continuous f := + (forall x, f%function @ at_right x --> f%function x). + +Lemma right_continuousW (R : numFieldType) {d} (U : orderTopologicalType d) + (f : R -> U) : continuous f -> right_continuous f. +Proof. by move=> cf x; apply: cvg_within_filter; exact/cf. Qed. + +HB.mixin Record isCumulative (R : numFieldType) {d} (U : orderTopologicalType d) + (f : R -> U) := { + cumulative_is_nondecreasing : nondecreasing f ; + cumulative_is_right_continuous : right_continuous f }. + +#[short(type=cumulative)] +HB.structure Definition Cumulative + (R : numFieldType) {d} (U : orderTopologicalType d) := { f of isCumulative R d U f }. + +Arguments cumulative_is_nondecreasing {R d U} _. +Arguments cumulative_is_right_continuous {R d U} _. + +Section id_is_cumulative. +Variable R : realFieldType. + +Let id_nd : {homo @idfun R : x y / x <= y}. +Proof. by []. Qed. + +Let id_rc : right_continuous (@idfun R). +Proof. apply: right_continuousW=> x; exact: cvg_id. Qed. (* succeed *) + +HB.instance Definition _ := isCumulative.Build R _ R idfun id_nd id_rc. +End id_is_cumulative. diff --git a/theories/cumulative_2.v b/theories/cumulative_2.v new file mode 100644 index 0000000000..302d7d8302 --- /dev/null +++ b/theories/cumulative_2.v @@ -0,0 +1,86 @@ +(* mathcomp analysis (c) 2017 Inria and AIST. License: CeCILL-C. *) +From mathcomp Require Import all_ssreflect ssralg ssrnum ssrint interval. +From mathcomp Require Import finmap fingroup perm rat archimedean. +From HB Require Import structures. +From mathcomp Require Import mathcomp_extra unstable boolp classical_sets. +From mathcomp Require Import functions fsbigop cardinality. +From mathcomp Require Import reals ereal interval_inference topology numfun. +From mathcomp Require Import normedtype sequences esum real_interval measure. +From mathcomp Require Import realfun. + +(**md**************************************************************************) +(* # Lebesgue Stieltjes Measure *) +(* *) +(* This file contains a formalization of the Lebesgue-Stieltjes measure using *) +(* the Measure Extension theorem from measure.v. *) +(* *) +(* References: *) +(* - Achim Klenke. Probability Theory 2nd edition. 2014 *) +(* - Y. Ishiguro, R. Affeldt. The Radon-Nikodym Theorem and the Lebesgue- *) +(* Stieltjes measure in Coq. Computer Software 41(2).2024 *) +(* *) +(* ``` *) +(* right_continuous f == the function f is right-continuous *) +(* cumulative R == type of non-decreasing, right-continuous *) +(* functions (with R : numFieldType) *) +(* The HB class is Cumulative. *) +(* instance: idfun *) +(* ocitv_type R == alias for R : realType *) +(* ocitv == set of open-closed intervals ]x, y] where *) +(* x and y are real numbers *) +(* R.-ocitv == display for ocitv_type R *) +(* R.-ocitv.-measurable == semiring of sets of open-closed intervals *) +(* wlength f A := f b - f a with the hull of the set of real *) +(* numbers A being delimited by a and b *) +(* lebesgue_stieltjes_measure f == Lebesgue-Stieltjes measure for f *) +(* f is a cumulative function. *) +(* completed_lebesgue_stieltjes_measure f == the completed Lebesgue-Stieltjes *) +(* measure *) +(* ``` *) +(* *) +(******************************************************************************) + +Set Implicit Arguments. +Unset Strict Implicit. +Unset Printing Implicit Defensive. +Import Order.TTheory GRing.Theory Num.Def Num.Theory. +Import numFieldTopology.Exports. + +Local Open Scope classical_set_scope. +Local Open Scope ring_scope. + +Reserved Notation "R .-ocitv" (at level 1, format "R .-ocitv"). +Reserved Notation "R .-ocitv.-measurable" + (at level 2, format "R .-ocitv.-measurable"). + +(* TODO: move? *) +Notation right_continuous f := + (forall x, f%function @ at_right x --> f%function x). + +Lemma right_continuousW (R : numFieldType) {d} (U : orderTopologicalType d) + (f : R -> U) : continuous f -> right_continuous f. +Proof. by move=> cf x; apply: cvg_within_filter; exact/cf. Qed. + +HB.mixin Record isCumulative (R : numFieldType) {d} (U : orderTopologicalType d) + (f : R -> U) := { + cumulative_is_nondecreasing : nondecreasing f ; + cumulative_is_right_continuous : right_continuous f }. + +#[short(type=cumulative)] +HB.structure Definition Cumulative + (R : numFieldType) {d} (U : orderTopologicalType d) := { f of isCumulative R d U f }. + +Arguments cumulative_is_nondecreasing {R d U} _. +Arguments cumulative_is_right_continuous {R d U} _. + +Section id_is_cumulative. +Variable R : realFieldType. + +Let id_nd : {homo @idfun R : x y / x <= y}. +Proof. by []. Qed. + +Let id_rc : right_continuous (@idfun R). +Proof. apply: right_continuousW=> x; exact: cvg_id. Qed. (* succeed *) + +HB.instance Definition _ := isCumulative.Build R _ R idfun id_nd id_rc. +End id_is_cumulative. diff --git a/theories/cumulative_3.txt b/theories/cumulative_3.txt new file mode 100644 index 0000000000..b5a840e047 --- /dev/null +++ b/theories/cumulative_3.txt @@ -0,0 +1,90 @@ +(* mathcomp analysis (c) 2017 Inria and AIST. License: CeCILL-C. *) +From mathcomp Require Import all_ssreflect ssralg ssrnum ssrint interval. +From mathcomp Require Import finmap fingroup perm rat archimedean. +From HB Require Import structures. +From mathcomp Require Import mathcomp_extra unstable boolp classical_sets. +From mathcomp Require Import functions fsbigop cardinality. +From mathcomp Require Import reals ereal interval_inference topology numfun. +From mathcomp Require Import normedtype sequences esum real_interval measure. +From mathcomp Require Import realfun. + +(**md**************************************************************************) +(* # Lebesgue Stieltjes Measure *) +(* *) +(* This file contains a formalization of the Lebesgue-Stieltjes measure using *) +(* the Measure Extension theorem from measure.v. *) +(* *) +(* References: *) +(* - Achim Klenke. Probability Theory 2nd edition. 2014 *) +(* - Y. Ishiguro, R. Affeldt. The Radon-Nikodym Theorem and the Lebesgue- *) +(* Stieltjes measure in Coq. Computer Software 41(2).2024 *) +(* *) +(* ``` *) +(* right_continuous f == the function f is right-continuous *) +(* cumulative R == type of non-decreasing, right-continuous *) +(* functions (with R : numFieldType) *) +(* The HB class is Cumulative. *) +(* instance: idfun *) +(* ocitv_type R == alias for R : realType *) +(* ocitv == set of open-closed intervals ]x, y] where *) +(* x and y are real numbers *) +(* R.-ocitv == display for ocitv_type R *) +(* R.-ocitv.-measurable == semiring of sets of open-closed intervals *) +(* wlength f A := f b - f a with the hull of the set of real *) +(* numbers A being delimited by a and b *) +(* lebesgue_stieltjes_measure f == Lebesgue-Stieltjes measure for f *) +(* f is a cumulative function. *) +(* completed_lebesgue_stieltjes_measure f == the completed Lebesgue-Stieltjes *) +(* measure *) +(* ``` *) +(* *) +(******************************************************************************) + +Set Implicit Arguments. +Unset Strict Implicit. +Unset Printing Implicit Defensive. +Import Order.TTheory GRing.Theory Num.Def Num.Theory. +Import numFieldTopology.Exports. + +Local Open Scope classical_set_scope. +Local Open Scope ring_scope. + +Reserved Notation "R .-ocitv" (at level 1, format "R .-ocitv"). +Reserved Notation "R .-ocitv.-measurable" + (at level 2, format "R .-ocitv.-measurable"). + +(* TODO: move? *) +Notation right_continuous f := + (forall x, f%function @ at_right x --> f%function x). + +Lemma right_continuousW (R : numFieldType) {d} (U : orderTopologicalType d) + (f : R -> U) : continuous f -> right_continuous f. +Proof. by move=> cf x; apply: cvg_within_filter; exact/cf. Qed. + +HB.mixin Record isCumulative (R : numFieldType) {d} (U : orderTopologicalType d) + (f : R -> U) := { + cumulative_is_nondecreasing : nondecreasing f ; + cumulative_is_right_continuous : right_continuous f }. + +#[short(type=cumulative)] +HB.structure Definition Cumulative + (R : numFieldType) {d} (U : orderTopologicalType d) := { f of isCumulative R d U f }. + +Arguments cumulative_is_nondecreasing {R d U} _. +Arguments cumulative_is_right_continuous {R d U} _. + +#[export, non_forgetful_inheritance] +HB.instance Definition _ (R : realType) := + Order_isNbhs.Build _ R (@real_order_nbhsE R). + +Section id_is_cumulative. +Variable R : realType. + +Let id_nd : {homo @idfun R : x y / x <= y}. +Proof. by []. Qed. + +Let id_rc : right_continuous (@idfun R). +Proof. apply: right_continuousW=> x; exact: cvg_id. Qed. (* succeed *) + +HB.instance Definition _ := isCumulative.Build R _ R idfun id_nd id_rc. +End id_is_cumulative. diff --git a/theories/cumulative_3.v b/theories/cumulative_3.v new file mode 100644 index 0000000000..b5a840e047 --- /dev/null +++ b/theories/cumulative_3.v @@ -0,0 +1,90 @@ +(* mathcomp analysis (c) 2017 Inria and AIST. License: CeCILL-C. *) +From mathcomp Require Import all_ssreflect ssralg ssrnum ssrint interval. +From mathcomp Require Import finmap fingroup perm rat archimedean. +From HB Require Import structures. +From mathcomp Require Import mathcomp_extra unstable boolp classical_sets. +From mathcomp Require Import functions fsbigop cardinality. +From mathcomp Require Import reals ereal interval_inference topology numfun. +From mathcomp Require Import normedtype sequences esum real_interval measure. +From mathcomp Require Import realfun. + +(**md**************************************************************************) +(* # Lebesgue Stieltjes Measure *) +(* *) +(* This file contains a formalization of the Lebesgue-Stieltjes measure using *) +(* the Measure Extension theorem from measure.v. *) +(* *) +(* References: *) +(* - Achim Klenke. Probability Theory 2nd edition. 2014 *) +(* - Y. Ishiguro, R. Affeldt. The Radon-Nikodym Theorem and the Lebesgue- *) +(* Stieltjes measure in Coq. Computer Software 41(2).2024 *) +(* *) +(* ``` *) +(* right_continuous f == the function f is right-continuous *) +(* cumulative R == type of non-decreasing, right-continuous *) +(* functions (with R : numFieldType) *) +(* The HB class is Cumulative. *) +(* instance: idfun *) +(* ocitv_type R == alias for R : realType *) +(* ocitv == set of open-closed intervals ]x, y] where *) +(* x and y are real numbers *) +(* R.-ocitv == display for ocitv_type R *) +(* R.-ocitv.-measurable == semiring of sets of open-closed intervals *) +(* wlength f A := f b - f a with the hull of the set of real *) +(* numbers A being delimited by a and b *) +(* lebesgue_stieltjes_measure f == Lebesgue-Stieltjes measure for f *) +(* f is a cumulative function. *) +(* completed_lebesgue_stieltjes_measure f == the completed Lebesgue-Stieltjes *) +(* measure *) +(* ``` *) +(* *) +(******************************************************************************) + +Set Implicit Arguments. +Unset Strict Implicit. +Unset Printing Implicit Defensive. +Import Order.TTheory GRing.Theory Num.Def Num.Theory. +Import numFieldTopology.Exports. + +Local Open Scope classical_set_scope. +Local Open Scope ring_scope. + +Reserved Notation "R .-ocitv" (at level 1, format "R .-ocitv"). +Reserved Notation "R .-ocitv.-measurable" + (at level 2, format "R .-ocitv.-measurable"). + +(* TODO: move? *) +Notation right_continuous f := + (forall x, f%function @ at_right x --> f%function x). + +Lemma right_continuousW (R : numFieldType) {d} (U : orderTopologicalType d) + (f : R -> U) : continuous f -> right_continuous f. +Proof. by move=> cf x; apply: cvg_within_filter; exact/cf. Qed. + +HB.mixin Record isCumulative (R : numFieldType) {d} (U : orderTopologicalType d) + (f : R -> U) := { + cumulative_is_nondecreasing : nondecreasing f ; + cumulative_is_right_continuous : right_continuous f }. + +#[short(type=cumulative)] +HB.structure Definition Cumulative + (R : numFieldType) {d} (U : orderTopologicalType d) := { f of isCumulative R d U f }. + +Arguments cumulative_is_nondecreasing {R d U} _. +Arguments cumulative_is_right_continuous {R d U} _. + +#[export, non_forgetful_inheritance] +HB.instance Definition _ (R : realType) := + Order_isNbhs.Build _ R (@real_order_nbhsE R). + +Section id_is_cumulative. +Variable R : realType. + +Let id_nd : {homo @idfun R : x y / x <= y}. +Proof. by []. Qed. + +Let id_rc : right_continuous (@idfun R). +Proof. apply: right_continuousW=> x; exact: cvg_id. Qed. (* succeed *) + +HB.instance Definition _ := isCumulative.Build R _ R idfun id_nd id_rc. +End id_is_cumulative. diff --git a/theories/lebesgue_integral_theory/.DS_Store b/theories/lebesgue_integral_theory/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..5008ddfcf53c02e82d7eee2e57c38e5672ef89f6 GIT binary patch literal 6148 zcmeH~Jr2S!425mzP>H1@V-^m;4Wg<&0T*E43hX&L&p$$qDprKhvt+--jT7}7np#A3 zem<@ulZcFPQ@L2!n>{z**++&mCkOWA81W14cNZlEfg7;MkzE(HCqgga^y>{tEnwC%0;vJ&^%eQ zLs35+`xjp>T0-> T'} == random variable: a measurable function to the *) +(* measurableType T' from the measured space *) +(* characterized by the probability P *) +(* distribution P X == measure image of the probability measure P by the *) +(* random variable X : {RV P -> T'} *) +(* P as type probability T R with T of type *) +(* measurableType. *) +(* Declared as an instance of probability measure. *) +(* 'E_P[X] == expectation of the real measurable function X *) +(* covariance X Y == covariance between real random variable X and Y *) +(* 'V_P[X] == variance of the real random variable X *) +(* 'M_P X == moment generating function of the random variable X *) +(* with sample space corresponding to the probability *) +(* measure P *) +(* {dmfun T >-> R} == type of discrete real-valued measurable functions *) +(* {dRV P >-> R} == real-valued discrete random variable *) +(* dRV_dom X == domain of the discrete random variable X *) +(* dRV_enum X == bijection between the domain and the range of X *) +(* pmf X r := fine (P (X @^-1` [set r])) *) +(* cdf X r == cumulative distribution function of X *) +(* := distribution P X `]-oo, r] *) +(* enum_prob X k == probability of the kth value in the range of X *) +(* ``` *) +(* *) +(* ``` *) +(* bernoulli_pmf p == Bernoulli pmf with parameter p : R *) +(* bernoulli p == Bernoulli probability measure when 0 <= p <= 1 *) +(* and \d_false otherwise *) +(* binomial_pmf n p == binomial pmf with parameters n : nat and p : R *) +(* binomial_prob n p == binomial probability measure when 0 <= p <= 1 *) +(* and \d_0%N otherwise *) +(* bin_prob n k p == $\binom{n}{k}p^k (1-p)^(n-k)$ *) +(* Computes a binomial distribution term for *) +(* k successes in n trials with success rate p *) +(* uniform_pdf a b == uniform pdf over the interval [a,b] *) +(* uniform_prob a b ab == uniform probability over the interval [a,b] *) +(* where ab0 a proof that 0 < b - a *) +(* normal_peak s := (sqrtr (s ^+ 2 * pi *+ 2))^-1 *) +(* normal_fun m s x := expR (- (x - m) ^+ 2 / (s ^+ 2 *+ 2)) *) +(* normal_pdf m s == pdf of the normal distribution with mean m and *) +(* standard deviation s *) +(* Using normal_peak and normal_pdf. *) +(* normal_prob m s == normal probability measure *) +(* exponential_pdf r == pdf of the exponential distribution with rate r *) +(* exponential_prob r == exponential probability measure *) +(* ``` *) +(* *) +(******************************************************************************) + +Reserved Notation "'{' 'RV' P >-> R '}'" + (at level 0, format "'{' 'RV' P '>->' R '}'"). +Reserved Notation "''E_' P [ X ]" (format "''E_' P [ X ]"). +Reserved Notation "''V_' P [ X ]" (format "''V_' P [ X ]"). +Reserved Notation "'M_ P X" (at level 5, P, X at level 4, format "''M_' P X"). +Reserved Notation "{ 'dmfun' aT >-> T }" (format "{ 'dmfun' aT >-> T }"). +Reserved Notation "'{' 'dRV' P >-> R '}'" (format "'{' 'dRV' P '>->' R '}'"). + +Set Implicit Arguments. +Unset Strict Implicit. +Unset Printing Implicit Defensive. + +Import Order.TTheory GRing.Theory Num.Def Num.Theory. +Import numFieldTopology.Exports. + +Local Open Scope classical_set_scope. +Local Open Scope ring_scope. + +Definition random_variable d d' (T : measurableType d) (T' : measurableType d') + (R : realType) (P : probability T R) := {mfun T >-> T'}. + +Notation "{ 'RV' P >-> T' }" := (@random_variable _ _ _ T' _ P) : form_scope. + +Lemma notin_range_measure d d' (T : measurableType d) (T' : measurableType d') + (R : realType) (P : {measure set T -> \bar R}) (X : T -> R) r : + r \notin range X -> P (X @^-1` [set r]) = 0%E. +Proof. by rewrite notin_setE => hr; rewrite preimage10. Qed. + +Lemma probability_range d d' (T : measurableType d) (T' : measurableType d') + (R : realType) (P : probability T R) (X : {RV P >-> R}) : + P (X @^-1` range X) = 1%E. +Proof. by rewrite preimage_range probability_setT. Qed. + +Definition distribution d d' (T : measurableType d) (T' : measurableType d') + (R : realType) (P : probability T R) (X : {mfun T >-> T'}) := + pushforward P X. + +Section distribution_is_probability. +Context d d' {T : measurableType d} {T' : measurableType d'} {R : realType} + {P : probability T R}. +Variable X : {mfun T >-> T'}. + +Let distribution0 : distribution P X set0 = 0%E. +Proof. exact: measure0. Qed. + +Let distribution_ge0 A : (0 <= distribution P X A)%E. +Proof. exact: measure_ge0. Qed. + +Let distribution_sigma_additive : semi_sigma_additive (distribution P X). +Proof. exact: measure_semi_sigma_additive. Qed. + +HB.instance Definition _ := isMeasure.Build _ _ _ (distribution P X) + distribution0 distribution_ge0 distribution_sigma_additive. + +Let distribution_is_probability : distribution P X [set: _] = 1%:E. +Proof. +by rewrite /distribution /= /pushforward /= preimage_setT probability_setT. +Qed. + +HB.instance Definition _ := Measure_isProbability.Build _ _ _ + (distribution P X) distribution_is_probability. + +End distribution_is_probability. + +Section transfer_probability. +Local Open Scope ereal_scope. +Context d d' {T : measurableType d} {T' : measurableType d'} {R : realType} + (P : probability T R). + +Lemma probability_distribution (X : {RV P >-> T'}) r : + P [set x | X x = r] = distribution P X [set r]. +Proof. by []. Qed. + +Lemma ge0_integral_distribution (X : {RV P >-> T'}) (f : T' -> \bar R) : + measurable_fun [set: T'] f -> (forall y, 0 <= f y) -> + \int[distribution P X]_y f y = \int[P]_x (f \o X) x. +Proof. by move=> mf f0; rewrite ge0_integral_pushforward. Qed. + +Lemma integral_distribution (X : {RV P >-> T'}) (f : T' -> \bar R) : + measurable_fun [set: T'] f -> P.-integrable [set: T] (f \o X) -> + \int[distribution P X]_y f y = \int[P]_x (f \o X) x. +Proof. by move=> mf intf; rewrite integral_pushforward. Qed. + +End transfer_probability. + +Definition cdf d (T : measurableType d) (R : realType) (P : probability T R) + (X : {RV P >-> R}) (r : R) := distribution P X `]-oo, r]. + +Section cumulative_distribution_function. +Context d {T : measurableType d} {R : realType} (P : probability T R). +Variable X : {RV P >-> R}. +Local Open Scope ereal_scope. + +Lemma cdf_ge0 r : 0 <= cdf X r. Proof. by []. Qed. + +Lemma cdf_le1 r : cdf X r <= 1. Proof. exact: probability_le1. Qed. + +Lemma cdf_nondecreasing : nondecreasing_fun (cdf X). +Proof. by move=> r s rs; rewrite le_measure ?inE//; exact: subitvPr. Qed. + +Lemma cvg_cdfy1 : cdf X @ +oo%R --> 1. +Proof. +pose s : \bar R := ereal_sup (range (cdf X)). +have cdf_s : cdf X r @[r --> +oo%R] --> s. + exact: nondecreasing_cvge cdf_nondecreasing. +have cdf_ns : cdf X n%:R @[n --> \oo%R] --> s. + by move/cvge_pinftyP : cdf_s; apply; exact/cvgryPge/nbhs_infty_ger. +have cdf_n1 : cdf X n%:R @[n --> \oo] --> 1. + rewrite -(probability_setT P). + pose F n := X @^-1` `]-oo, n%:R]. + have <- : \bigcup_n F n = setT. + rewrite -preimage_bigcup -subTset => t _/=. + by exists (trunc (X t)).+1 => //=; rewrite in_itv/= ltW// truncnS_gt. + apply: nondecreasing_cvg_mu => //; first exact: bigcup_measurable. + move=> n m nm; apply/subsetPset => x/=; rewrite !in_itv/= => /le_trans. + by apply; rewrite ler_nat. +by rewrite -(cvg_unique _ cdf_ns cdf_n1). +Qed. + +Lemma cvg_cdfNy0 : cdf X @ -oo%R --> 0. +Proof. +rewrite cvgNy_compNP. +have cdf_opp_noninc : {homo cdf X \o -%R : q r / (q <= r)%R >-> q >= r}. + by move=> q r; rewrite -lterN2; exact: cdf_nondecreasing. +pose s := ereal_inf (range (cdf X \o -%R)). +have cdf_opp_s : (cdf X \o -%R) r @[r --> +oo%R] --> s. + exact: nonincreasing_cvge cdf_opp_noninc. +have cdf_opp_ns : (cdf X \o -%R) n%:R @[n --> \oo] --> s. + by move/cvge_pinftyP : cdf_opp_s; apply; exact/cvgryPge/nbhs_infty_ger. +have cdf_opp_n0 : (cdf X \o -%R) n%:R @[n --> \oo] --> 0. + rewrite -(measure0 P). + pose F n := X @^-1` `]-oo, (- n%:R)%R]. + have <- : \bigcap_n F n = set0. + rewrite -subset0 => t. + set m := (trunc `|X t|).+1. + move=> /(_ m I); rewrite /F/= in_itv/= leNgt => /negP; apply. + by rewrite ltrNl /m (le_lt_trans (ler_norm _))// normrN truncnS_gt. + apply: nonincreasing_cvg_mu => //=. + + by rewrite (le_lt_trans (probability_le1 _ _)) ?ltry. + + exact: bigcap_measurable. + + move=> m n mn; apply/subsetPset => x/=; rewrite !in_itv => /le_trans; apply. + by rewrite lerN2 ler_nat. +by rewrite (_ : 0%E = s)// (cvg_unique _ cdf_opp_ns cdf_opp_n0). +Qed. + +Lemma cdf_right_continuous : right_continuous (cdf X). +Proof. +move=> a. +pose s := fine (ereal_inf (cdf X @` `]a, a + 1%R]%classic)). +have cdf_s : cdf X r @[r --> a^'+] --> s%:E. + rewrite /s fineK. + - apply: nondecreasing_at_right_cvge; first by rewrite ltBSide /= ?ltrDl. + by move=> *; exact: cdf_nondecreasing. + - apply/fin_numPlt/andP; split=>//. + + by rewrite (lt_le_trans (ltNyr 0%R)) ?lb_ereal_inf//= => l[? _] <-. + + rewrite (le_lt_trans _ (ltry 1%R))// ereal_inf_le//=. + exists (cdf X (a + 1)); last exact: cdf_le1. + by exists (a + 1%R) => //; rewrite in_itv /=; apply/andP; rewrite ltrDl. +have cdf_ns : cdf X (a + n.+1%:R^-1) @[n --> \oo] --> s%:E. + move/cvge_at_rightP : cdf_s; apply; split=> [n|]; rewrite ?ltrDl //. + rewrite -[X in _ --> X]addr0; apply: (@cvgD _ R^o); first exact: cvg_cst. + by rewrite gtr0_cvgV0 ?cvg_shiftS; [exact: cvgr_idn | near=> n]. +have cdf_na : cdf X (a + n.+1%:R^-1) @[n --> \oo] --> cdf X a. + pose F n := X @^-1` `]-oo, a + n.+1%:R^-1%R]. + suff : P (F n) @[n --> \oo] --> P (\bigcap_n F n). + by rewrite [in X in _ --> X -> _]/F -preimage_bigcap -itvNycEbigcap. + apply: nonincreasing_cvg_mu => [| | |m n mn]. + - by rewrite -ge0_fin_numE// fin_num_measure//; exact: measurable_sfunP. + - by move=> ?; exact: measurable_sfunP. + - by apply: bigcap_measurable => // ? _; exact: measurable_sfunP. + - apply/subsetPset; apply: preimage_subset; apply: subset_itvl. + by rewrite bnd_simp lerD2l lef_pV2 ?posrE// ler_nat. +by rewrite -(cvg_unique _ cdf_ns cdf_na). +Unshelve. all: by end_near. Qed. + +Lemma gte_lte_real (x a b : \bar R) : + (a < x < b) -> x \is a fin_num. +Proof. +case/andP => [ax xb]; apply/fin_numPlt/andP; split. + exact: (le_lt_trans (leNye a) ax). +exact: (lt_le_trans xb (leey b)). +Qed. + +Lemma ereal_order_nbhsE : forall x : (\bar R), nbhs x = filter_from + (fun i => itv_open_ends i /\ x \in i) (fun i => [set` i]). +Proof. +move=> x; apply/seteqP; split=> A. + rewrite /nbhs/=/ereal_nbhs/=; case x =>[r||]. + - rewrite /nbhs/=/nbhs_ball_/filter_from/=; case=> e e_pos ball_re. + exists `](r - e)%:E, (r + e)%:E[ =>[|y/=]. + split; first by rewrite/itv_open_ends/=; right. + rewrite in_itv/= EFinB gte_subl// EFinD lteDl//; exact/andP. + rewrite in_itv/= => /[dup]/gte_lte_real/fineK<-. + rewrite !lte_fin => fy; apply: ball_re. + by rewrite /ball_/= -opprB normrN ltr_norml ltrBrDl (ltrBlDl _ r). + - case=> M [? MA]; rewrite /filter_from/=. + exists `]M%:E, +oo[ =>[|y/=]; rewrite in_itv/= andbT; last exact: MA. + by split; first by rewrite/itv_open_ends; left. + - case=> M [? MA]; rewrite /filter_from/=. + exists `]-oo, M%:E[ =>[|y/=]; rewrite in_itv/=; last exact: MA. + by split; first by rewrite /itv_open_ends; left. +rewrite /filter_from/= => [][][][[]r|[]][[]s|[]][][]; + rewrite /itv_is_ray/itv_is_bd_open// in_itv/= =>_. + - rewrite /nbhs/=/ereal_nbhs/= => /[dup]/gte_lte_real/fineK<-. + case/andP=> rx sx rsA; apply: (nbhs_interval rx sx) => *. + by apply: rsA =>/=; rewrite in_itv/=; apply/andP. + - rewrite nbhsE/= => rx ?; exists (`]r, +oo[)%classic; rewrite /open_nbhs//. + by split; [rewrite set_itvE; exact: open_ereal_gt_ereal | exact: rx]. + - rewrite nbhsE/= => xs ?; exists (`]-oo, s[)%classic; rewrite /open_nbhs//. + by split; [rewrite set_itvE; exact: open_ereal_lt_ereal | exact: xs]. + - by rewrite set_itvE/= subTset => _ ->; exact: filter_nbhsT. +Qed. + +HB.instance Definition _ := Order_isNbhs.Build _ (\bar R) ereal_order_nbhsE. + +HB.instance Definition _ := isCumulative.Build R _ (\bar R) (cdf X) + cdf_nondecreasing cdf_right_continuous. + +End cumulative_distribution_function. + +Section cdf_of_lebesgue_stieltjes_mesure. +Context {R : realType} (f : cumulativeBounded (0:R) (1:R)). +Local Open Scope measure_display_scope. + +Let T := g_sigma_algebraType R.-ocitv.-measurable. +Let lsf := lebesgue_stieltjes_measure f. + +Let idTR : T -> R := idfun. + +#[local] HB.instance Definition _ := + @isMeasurableFun.Build _ _ T R idTR (@measurable_id _ _ setT). + +Lemma cdf_lebesgue_stieltjes_id r : cdf (idTR : {RV lsf >-> R}) r = (f r)%:E. +Proof. +rewrite /= preimage_id itvNybndEbigcup. +have : lsf `]-n%:R, r] @[n --> \oo] --> (f r)%:E. + suff : ((f r)%:E - (f (-n%:R))%:E)%E @[n --> \oo] --> (f r)%:E. + apply: cvg_trans; apply: near_eq_cvg; near=> n. + rewrite /lsf /lebesgue_stieltjes_measure /measure_extension/=. + rewrite measurable_mu_extE/= ?wlength_itv_bnd//; last exact: is_ocitv. + by rewrite lerNl; near: n; exact: nbhs_infty_ger. + rewrite -[X in _ --> X](sube0 (f r)%:E); apply: (cvgeB _ (cvg_cst _ )) => //. + apply: (cvg_comp _ _ (cvg_comp _ _ _ (cumulativeNy f))) => //. + by apply: (cvg_comp _ _ cvgr_idn); rewrite ninfty. +have : lsf `]- n%:R, r] @[n --> \oo] --> lsf (\bigcup_n `]-n%:R, r]%classic). + apply: nondecreasing_cvg_mu; rewrite /I//; first exact: bigcup_measurable. + by move=> *; apply/subsetPset/subset_itv; rewrite leBSide//= lerN2 ler_nat. +exact: cvg_unique. +Unshelve. all: by end_near. Qed. + +End cdf_of_lebesgue_stieltjes_mesure. + +HB.lock Definition expectation {d} {T : measurableType d} {R : realType} + (P : probability T R) (X : T -> R) := (\int[P]_w (X w)%:E)%E. +Canonical expectation_unlockable := Unlockable expectation.unlock. +Arguments expectation {d T R} P _%_R. +Notation "''E_' P [ X ]" := (@expectation _ _ _ P X) : ereal_scope. + +Section expectation_lemmas. +Local Open Scope ereal_scope. +Context d (T : measurableType d) (R : realType) (P : probability T R). + +Lemma expectation_def (X : {RV P >-> R}) : 'E_P[X] = (\int[P]_w (X w)%:E)%E. +Proof. by rewrite unlock. Qed. + +Lemma expectation_fin_num (X : T -> R) : X \in Lfun P 1 -> + 'E_P[X] \is a fin_num. +Proof. +by move=> ?; rewrite unlock integrable_fin_num//; exact/Lfun1_integrable. +Qed. + +Lemma expectation_cst r : 'E_P[cst r] = r%:E. +Proof. by rewrite unlock/= integral_cst//= probability_setT mule1. Qed. + +Lemma expectation_indic (A : set T) (mA : measurable A) : 'E_P[\1_A] = P A. +Proof. by rewrite unlock integral_indic// setIT. Qed. + +Lemma integrable_expectation (X : {RV P >-> R}) + (iX : P.-integrable [set: T] (EFin \o X)) : `| 'E_P[X] | < +oo. +Proof. +move: iX => /integrableP[? Xoo]; rewrite (le_lt_trans _ Xoo)// unlock. +exact: le_trans (le_abse_integral _ _ _). +Qed. + +Lemma expectationZl (X : T -> R) (k : R) : X \in Lfun P 1 -> + 'E_P[k \o* X] = k%:E * 'E_P [X]. +Proof. +by move=> ?; rewrite unlock muleC -integralZr//; exact/Lfun1_integrable. +Qed. + +Lemma expectation_ge0 (X : T -> R) : (forall x, 0 <= X x)%R -> + 0 <= 'E_P[X]. +Proof. +by move=> ?; rewrite unlock integral_ge0// => x _; rewrite lee_fin. +Qed. + +Lemma expectation_le (X Y : T -> R) : + measurable_fun [set: T] X -> measurable_fun [set: T] Y -> + (forall x, 0 <= X x)%R -> (forall x, 0 <= Y x)%R -> + {ae P, (forall x, X x <= Y x)%R} -> 'E_P[X] <= 'E_P[Y]. +Proof. +move=> mX mY X0 Y0 XY; rewrite unlock ae_ge0_le_integral => //. +- by move=> t _; apply: X0. +- exact/measurable_EFinP. +- by move=> t _; apply: Y0. +- exact/measurable_EFinP. +- move: XY => [N [mN PN XYN]]; exists N; split => // t /= h. + by apply: XYN => /=; apply: contra_not h; rewrite lee_fin. +Qed. + +Lemma expectationD (X Y : T -> R) : X \in Lfun P 1 -> Y \in Lfun P 1 -> + 'E_P[X \+ Y] = 'E_P[X] + 'E_P[Y]. +Proof. +by move=> ? ?; rewrite unlock integralD_EFin//; exact/Lfun1_integrable. +Qed. + +Lemma expectationB (X Y : T -> R) : X \in Lfun P 1 -> Y \in Lfun P 1 -> + 'E_P[X \- Y] = 'E_P[X] - 'E_P[Y]. +Proof. +by move=> ? ?; rewrite unlock integralB_EFin//; exact/Lfun1_integrable. +Qed. + +Lemma expectation_sum (X : seq (T -> R)) : + (forall Xi, Xi \in X -> Xi \in Lfun P 1) -> + 'E_P[\sum_(Xi <- X) Xi] = \sum_(Xi <- X) 'E_P[Xi]. +Proof. +elim: X => [|X0 X IHX] intX; first by rewrite !big_nil expectation_cst. +rewrite !big_cons expectationD; last 2 first. + by rewrite intX// mem_head. + by rewrite big_seq rpred_sum// => Y YX/=; rewrite intX// inE YX orbT. +by rewrite IHX//= => Xi XiX; rewrite intX// inE XiX orbT. +Qed. + +End expectation_lemmas. +#[deprecated(since="mathcomp-analysis 1.8.0", note="renamed to `expectationZl`")] +Notation expectationM := expectationZl (only parsing). + +HB.lock Definition covariance {d} {T : measurableType d} {R : realType} + (P : probability T R) (X Y : T -> R) := + 'E_P[(X \- cst (fine 'E_P[X])) * (Y \- cst (fine 'E_P[Y]))]%E. +Canonical covariance_unlockable := Unlockable covariance.unlock. +Arguments covariance {d T R} P _%_R _%_R. + +Hint Extern 0 (fin_num_fun _) => + (apply: fin_num_measure) : core. + +Section covariance_lemmas. +Local Open Scope ereal_scope. +Context d (T : measurableType d) (R : realType) (P : probability T R). + +Lemma covarianceE (X Y : T -> R) : + X \in Lfun P 1 -> Y \in Lfun P 1 -> + (X * Y)%R \in Lfun P 1 -> + covariance P X Y = 'E_P[X * Y] - 'E_P[X] * 'E_P[Y]. +Proof. +move=> l1X l1Y l1XY. +rewrite unlock [X in 'E_P[X]](_ : _ = (X \* Y \- fine 'E_P[X] \o* Y + \- fine 'E_P[Y] \o* X \+ fine ('E_P[X] * 'E_P[Y]) \o* cst 1)%R); last first. + apply/funeqP => x /=; rewrite mulrDr !mulrDl/= mul1r. + rewrite fineM ?expectation_fin_num// mulrNN addrA. + by rewrite mulrN mulNr [Z in (X x * Y x - Z)%R]mulrC. +rewrite expectationD/= ?rpredB//= ?Lfun_scale ?Lfun_cst//. +rewrite 2?expectationB//= ?rpredB ?Lfun_scale// 3?expectationZl//= ?Lfun_cst//. +rewrite expectation_cst mule1 fineM ?expectation_fin_num// EFinM. +rewrite !fineK ?expectation_fin_num//. +by rewrite muleC subeK ?fin_numM ?expectation_fin_num. +Qed. + +Lemma covarianceC (X Y : T -> R) : covariance P X Y = covariance P Y X. +Proof. +by rewrite unlock; congr expectation; apply/funeqP => x /=; rewrite mulrC. +Qed. + +Lemma covariance_fin_num (X Y : T -> R) : + X \in Lfun P 1 -> Y \in Lfun P 1 -> + (X * Y)%R \in Lfun P 1 -> + covariance P X Y \is a fin_num. +Proof. +by move=> ? ? ?; rewrite covarianceE// fin_numB fin_numM expectation_fin_num. +Qed. + +Lemma covariance_cst_l c (X : T -> R) : covariance P (cst c) X = 0. +Proof. +rewrite unlock expectation_cst/=. +rewrite [X in 'E_P[X]](_ : _ = cst 0%R) ?expectation_cst//. +by apply/funeqP => x; rewrite /GRing.mul/= subrr mul0r. +Qed. + +Lemma covariance_cst_r (X : T -> R) c : covariance P X (cst c) = 0. +Proof. by rewrite covarianceC covariance_cst_l. Qed. + +Lemma covarianceZl a (X Y : T -> R) : + X \in Lfun P 1 -> Y \in Lfun P 1 -> + (X * Y)%R \in Lfun P 1 -> + covariance P (a \o* X)%R Y = a%:E * covariance P X Y. +Proof. +move=> X1 Y1 XY1. +have aXY : (a \o* X * Y = a \o* (X * Y))%R by apply/funeqP => x; rewrite mulrAC. +rewrite [LHS]covarianceE => [||//|] //=; last 2 first. +- by rewrite Lfun_scale. +- by rewrite aXY Lfun_scale. +rewrite covarianceE// aXY !expectationZl//. +by rewrite -muleA -muleBr// fin_num_adde_defr// expectation_fin_num. +Qed. + +Lemma covarianceZr a (X Y : T -> R) : X \in Lfun P 1 -> Y \in Lfun P 1 -> + (X * Y)%R \in Lfun P 1 -> + covariance P X (a \o* Y)%R = a%:E * covariance P X Y. +Proof. +move=> X1 Y1 XY1. +by rewrite [in RHS]covarianceC covarianceC covarianceZl; last rewrite mulrC. +Qed. + +Lemma covarianceNl (X Y : T -> R) : X \in Lfun P 1 -> Y \in Lfun P 1 -> + (X * Y)%R \in Lfun P 1 -> + covariance P (\- X)%R Y = - covariance P X Y. +Proof. +move=> X1 Y1 XY1. +have -> : (\- X = -1 \o* X)%R by apply/funeqP => x /=; rewrite mulrN mulr1. +by rewrite covarianceZl// EFinN mulNe mul1e. +Qed. + +Lemma covarianceNr (X Y : T -> R) : X \in Lfun P 1 -> Y \in Lfun P 1 -> + (X * Y)%R \in Lfun P 1 -> + covariance P X (\- Y)%R = - covariance P X Y. +Proof. by move=> X1 Y1 XY1; rewrite !(covarianceC X) covarianceNl 1?mulrC. Qed. + +Lemma covarianceNN (X Y : T -> R) : X \in Lfun P 1 -> Y \in Lfun P 1 -> + (X * Y)%R \in Lfun P 1 -> + covariance P (\- X)%R (\- Y)%R = covariance P X Y. +Proof. +by move=> ? ? ?; rewrite covarianceNl//= ?covarianceNr ?oppeK ?mulrN//= ?rpredN. +Qed. + +Lemma covarianceDl (X Y Z : T -> R) : + X \in Lfun P 2%:E -> Y \in Lfun P 2%:E -> Z \in Lfun P 2%:E -> + covariance P (X \+ Y)%R Z = covariance P X Z + covariance P Y Z. +Proof. +move=> X2 Y2 Z2. +have Pfin : P setT \is a fin_num := fin_num_measure P _ measurableT. +have X1 := Lfun_subset12 Pfin X2. +have Y1 := Lfun_subset12 Pfin Y2. +have Z1 := Lfun_subset12 Pfin Z2. +have XY1 := Lfun2_mul_Lfun1 X2 Y2. +have YZ1 := Lfun2_mul_Lfun1 Y2 Z2. +have XZ1 := Lfun2_mul_Lfun1 X2 Z2. +rewrite [LHS]covarianceE//= ?mulrDl ?compreDr ?rpredD//= 2?expectationD//=. +rewrite muleDl ?fin_num_adde_defr ?expectation_fin_num//. +rewrite oppeD ?fin_num_adde_defr ?fin_numM ?expectation_fin_num//. +by rewrite addeACA 2?covarianceE. +Qed. + +Lemma covarianceDr (X Y Z : T -> R) : + X \in Lfun P 2%:E -> Y \in Lfun P 2%:E -> Z \in Lfun P 2%:E -> + covariance P X (Y \+ Z)%R = covariance P X Y + covariance P X Z. +Proof. +by move=> X2 Y2 Z2; rewrite covarianceC covarianceDl ?(covarianceC X) 1?mulrC. +Qed. + +Lemma covarianceBl (X Y Z : T -> R) : + X \in Lfun P 2%:E -> Y \in Lfun P 2%:E -> Z \in Lfun P 2%:E -> + covariance P (X \- Y)%R Z = covariance P X Z - covariance P Y Z. +Proof. +move=> X2 Y2 Z2. +have Pfin : P setT \is a fin_num := fin_num_measure P _ measurableT. +have Y1 := Lfun_subset12 Pfin Y2. +have Z1 := Lfun_subset12 Pfin Z2. +have YZ1 := Lfun2_mul_Lfun1 Y2 Z2. +by rewrite -[(X \- Y)%R]/(X \+ (\- Y))%R covarianceDl ?covarianceNl ?rpredN. +Qed. + +Lemma covarianceBr (X Y Z : T -> R) : + X \in Lfun P 2%:E -> Y \in Lfun P 2%:E -> Z \in Lfun P 2%:E -> + covariance P X (Y \- Z)%R = covariance P X Y - covariance P X Z. +Proof. +move=> X2 Y2 Z2. +have Pfin : P setT \is a fin_num := fin_num_measure P _ measurableT. +have Y1 := Lfun_subset12 Pfin Y2. +have Z1 := Lfun_subset12 Pfin Z2. +have YZ1 := Lfun2_mul_Lfun1 Y2 Z2. +by rewrite !(covarianceC X) covarianceBl 1?(mulrC _ X). +Qed. + +End covariance_lemmas. + +Section variance. +Local Open Scope ereal_scope. +Context d (T : measurableType d) (R : realType) (P : probability T R). + +Definition variance (X : T -> R) := covariance P X X. +Local Notation "''V_' P [ X ]" := (variance X). + +Lemma varianceE (X : T -> R) : X \in Lfun P 2%:E -> + 'V_P[X] = 'E_P[X ^+ 2] - ('E_P[X]) ^+ 2. +Proof. +move=> X2; rewrite /variance. +by rewrite covarianceE ?Lfun2_mul_Lfun1// Lfun_subset12 ?fin_num_measure. +Qed. + +Lemma variance_fin_num (X : T -> R) : X \in Lfun P 2%:E -> + 'V_P[X] \is a fin_num. +Proof. +move=> X2. +by rewrite covariance_fin_num ?Lfun2_mul_Lfun1// Lfun_subset12 ?fin_num_measure. +Qed. + +Lemma variance_ge0 (X : T -> R) : 0 <= 'V_P[X]. +Proof. +by rewrite /variance unlock; apply: expectation_ge0 => x; exact: sqr_ge0. +Qed. + +Lemma variance_cst r : 'V_P[cst r] = 0%E. +Proof. +rewrite /variance unlock expectation_cst/=. +rewrite [X in 'E_P[X]](_ : _ = cst 0%R) ?expectation_cst//. +by apply/funext => x; rewrite /GRing.exp/GRing.mul/= subrr mulr0. +Qed. + +Lemma varianceZ a (X : T -> R) : X \in Lfun P 2%:E -> + 'V_P[(a \o* X)%R] = (a ^+ 2)%:E * 'V_P[X]. +Proof. +move=> X2. +have Pfin : P setT \is a fin_num := fin_num_measure P _ measurableT. +have X1 := Lfun_subset12 Pfin X2. +rewrite /variance covarianceZl//=. +- by rewrite covarianceZr// ?muleA ?EFinM// Lfun2_mul_Lfun1. +- by rewrite Lfun_scale. +- by rewrite Lfun2_mul_Lfun1// Lfun_scale// ler1n. +Qed. + +Lemma varianceN (X : T -> R) : X \in Lfun P 2%:E -> 'V_P[(\- X)%R] = 'V_P[X]. +Proof. +move=> X2; rewrite /variance. +by rewrite covarianceNN ?Lfun2_mul_Lfun1 ?Lfun_subset12 ?fin_num_measure. +Qed. + +Lemma varianceD (X Y : T -> R) : X \in Lfun P 2%:E -> Y \in Lfun P 2%:E -> + 'V_P[X \+ Y]%R = 'V_P[X] + 'V_P[Y] + 2%:E * covariance P X Y. +Proof. +move=> X2 Y2. +have Pfin : P setT \is a fin_num := fin_num_measure P _ measurableT. +have X1 := Lfun_subset12 Pfin X2. +have Y1 := Lfun_subset12 Pfin Y2. +have XY1 := Lfun2_mul_Lfun1 X2 Y2. +rewrite -['V_P[_]]/(covariance P (X \+ Y)%R (X \+ Y)%R). +rewrite covarianceDl ?rpredD ?lee1n//= covarianceDr// covarianceDr//. +rewrite (covarianceC P Y X) [LHS]addeA [LHS](ACl (1*4*(2*3)))/=. +by rewrite -[2%R]/(1 + 1)%R EFinD muleDl ?mul1e// covariance_fin_num. +Qed. + +Lemma varianceB (X Y : T -> R) : X \in Lfun P 2%:E -> Y \in Lfun P 2%:E -> + 'V_P[(X \- Y)%R] = 'V_P[X] + 'V_P[Y] - 2%:E * covariance P X Y. +Proof. +move=> X2 Y2. +have Pfin : P setT \is a fin_num := fin_num_measure P _ measurableT. +have X1 := Lfun_subset12 Pfin X2. +have Y1 := Lfun_subset12 Pfin Y2. +have XY1 := Lfun2_mul_Lfun1 X2 Y2. +rewrite -[(X \- Y)%R]/(X \+ (\- Y))%R. +by rewrite varianceD/= ?varianceN ?covarianceNr ?muleN ?rpredN. +Qed. + +Lemma varianceD_cst_l c (X : T -> R) : X \in Lfun P 2%:E -> + 'V_P[(cst c \+ X)%R] = 'V_P[X]. +Proof. +move=> X2. +by rewrite varianceD ?Lfun_cst// variance_cst add0e covariance_cst_l mule0 adde0. +Qed. + +Lemma varianceD_cst_r (X : T -> R) c : X \in Lfun P 2%:E -> + 'V_P[(X \+ cst c)%R] = 'V_P[X]. +Proof. +move=> X2. +have -> : (X \+ cst c = cst c \+ X)%R by apply/funeqP => x /=; rewrite addrC. +exact: varianceD_cst_l. +Qed. + +Lemma varianceB_cst_l c (X : T -> R) : X \in Lfun P 2%:E -> + 'V_P[(cst c \- X)%R] = 'V_P[X]. +Proof. +move=> X2; rewrite -[(cst c \- X)%R]/(cst c \+ (\- X))%R. +by rewrite varianceD_cst_l/= ?rpredN// varianceN. +Qed. + +Lemma varianceB_cst_r (X : T -> R) c : X \in Lfun P 2%:E -> + 'V_P[(X \- cst c)%R] = 'V_P[X]. +Proof. +by move=> X2; rewrite -[(X \- cst c)%R]/(X \+ (cst (- c)))%R varianceD_cst_r. +Qed. + +Lemma covariance_le (X Y : T -> R) : X \in Lfun P 2%:E -> Y \in Lfun P 2%:E -> + covariance P X Y <= sqrte 'V_P[X] * sqrte 'V_P[Y]. +Proof. +move=> X2 Y2. +have Pfin : P setT \is a fin_num := fin_num_measure P _ measurableT. +have X1 := Lfun_subset12 Pfin X2. +have Y1 := Lfun_subset12 Pfin Y2. +have XY1 := Lfun2_mul_Lfun1 X2 Y2. +rewrite -sqrteM ?variance_ge0//. +rewrite lee_sqrE ?sqrte_ge0// sqr_sqrte ?mule_ge0 ?variance_ge0//. +rewrite -(fineK (variance_fin_num X2)) -(fineK (variance_fin_num Y2)). +rewrite -(fineK (covariance_fin_num X1 Y1 XY1)). +rewrite -EFin_expe -EFinM lee_fin -(@ler_pM2l _ 4) ?ltr0n// [leRHS]mulrA. +rewrite [in leLHS](_ : 4 = 2 * 2)%R -natrM// [in leLHS]natrM mulrACA -expr2. +rewrite -subr_le0. +set a := fine (variance X). +set b := (2 * fine (covariance P X Y))%R. +set c := fine (variance Y). +pose p := Poly [:: c; b; a]. +have -> : a = p`_2 by rewrite !coefE. +have -> : b = p`_1 by rewrite !coefE. +have -> : c = p`_0 by rewrite !coefE. +rewrite deg_le2_poly_ge0 ?size_Poly// => r. +rewrite horner_Poly/= mul0r add0r mulrDl -mulrA -expr2. +rewrite -lee_fin !EFinD EFinM fineK ?variance_fin_num// muleC -varianceZ//. +rewrite 2!EFinM ?fineK ?variance_fin_num// ?covariance_fin_num//. +rewrite -muleA [_ * r%:E]muleC -covarianceZl//. +rewrite addeAC -varianceD ?variance_ge0//=. +by rewrite Lfun_scale// ler1n. +Qed. + +End variance. +Notation "'V_ P [ X ]" := (variance P X). + +Definition mmt_gen_fun d (T : measurableType d) (R : realType) + (P : probability T R) (X : T -> R) (t : R) := ('E_P[expR \o t \o* X])%E. +Notation "'M_ P X" := (@mmt_gen_fun _ _ _ P X). + +Section markov_chebyshev_cantelli. +Local Open Scope ereal_scope. +Context d (T : measurableType d) (R : realType) (P : probability T R). + +Lemma markov (X : {RV P >-> R}) (f : R -> R) (eps : R) : (0 < eps)%R -> + measurable_fun [set: R] f -> (forall r, 0 <= r -> 0 <= f r)%R -> + {in Num.nneg &, {homo f : x y / x <= y}}%R -> + (f eps)%:E * P [set x | eps%:E <= `| (X x)%:E | ] <= + 'E_P[f \o (fun x => `| x |%R) \o X]. +Proof. +move=> e0 mf f0 f_nd; rewrite -(setTI [set _ | _]). +apply: (le_trans (@le_integral_comp_abse _ _ _ P _ measurableT (EFin \o X) + eps (er_map f) _ _ _ _ e0)) => //=. +- exact: measurable_er_map. +- by case => //= r _; exact: f0. +- move=> [x| |] [y| |]; rewrite !inE/= !in_itv/= ?andbT ?lee_fin ?leey//. + by move=> ? ? ?; rewrite f_nd. +- exact/measurable_EFinP. +- by rewrite unlock. +Qed. + +Lemma chernoff (X : {RV P >-> R}) (r a : R) : (0 < r)%R -> + P [set x | X x >= a]%R <= 'M_P X r * (expR (- (r * a)))%:E. +Proof. +move=> t0; rewrite /mmt_gen_fun. +have -> : expR \o r \o* X = (normr \o normr) \o (expR \o r \o* X). + by apply: funext => t /=; rewrite normr_id ger0_norm ?expR_ge0. +rewrite expRN lee_pdivlMr ?expR_gt0//. +rewrite (le_trans _ (markov _ (expR_gt0 (r * a)) _ _ _))//; last first. + exact: (monoW_in (@ger0_le_norm _)). +rewrite ger0_norm ?expR_ge0// muleC lee_pmul2l// ?lte_fin ?expR_gt0//. +rewrite [X in _ <= P X](_ : _ = [set x | a <= X x]%R)//; apply: eq_set => t/=. +by rewrite ger0_norm ?expR_ge0// lee_fin ler_expR mulrC ler_pM2r. +Qed. + +Lemma chebyshev (X : {RV P >-> R}) (eps : R) : (0 < eps)%R -> + P [set x | (eps <= `| X x - fine ('E_P[X])|)%R ] <= (eps ^- 2)%:E * 'V_P[X]. +Proof. +move => heps; have [->|hv] := eqVneq 'V_P[X] +oo. + by rewrite mulr_infty gtr0_sg ?mul1e// ?leey// invr_gt0// exprn_gt0. +have h (Y : {RV P >-> R}) : + P [set x | (eps <= `|Y x|)%R] <= (eps ^- 2)%:E * 'E_P[Y ^+ 2]. + rewrite -lee_pdivrMl; last by rewrite invr_gt0// exprn_gt0. + rewrite exprnN expfV exprz_inv opprK -exprnP. + apply: (@le_trans _ _ ('E_P[(@GRing.exp R ^~ 2%N \o normr) \o Y])). + apply: (@markov Y (@GRing.exp R ^~ 2%N)) => //. + - by move=> r _; exact: sqr_ge0. + - move=> x y; rewrite !nnegrE => x0 y0. + by rewrite ler_sqr. + apply: expectation_le. + - by apply: measurableT_comp => //; exact: measurableT_comp. + - by []. + - by move=> x /=; exact: sqr_ge0. + - by move=> x /=; exact: sqr_ge0. + - by apply/aeW => t /=; rewrite real_normK// num_real. +have := h (X \- cst (fine ('E_P[X])))%R. +by move=> /le_trans; apply; rewrite /variance [in leRHS]unlock. +Qed. + +Lemma cantelli (X : {RV P >-> R}) (lambda : R) : + (X : T -> R) \in Lfun P 2%:E -> (0 < lambda)%R -> + P [set x | lambda%:E <= (X x)%:E - 'E_P[X]] + <= (fine 'V_P[X] / (fine 'V_P[X] + lambda^2))%:E. +Proof. +move=> /[dup] X2. +move=> /(Lfun_subset12 (fin_num_measure P _ measurableT)) X1 lambda_gt0. +have finEK : (fine 'E_P[X])%:E = 'E_P[X] by rewrite fineK ?expectation_fin_num. +have finVK : (fine 'V_P[X])%:E = 'V_P[X] by rewrite fineK ?variance_fin_num. +pose Y := (X \- cst (fine 'E_P[X]))%R. +have Y2 : (Y : T -> R) \in Lfun P 2%:E. + by rewrite /Y rpredB ?lee1n//= => _; rewrite Lfun_cst. +have EY : 'E_P[Y] = 0. + rewrite expectationB ?Lfun_cst//= expectation_cst. + by rewrite finEK subee// expectation_fin_num. +have VY : 'V_P[Y] = 'V_P[X] by rewrite varianceB_cst_r. +have le (u : R) : (0 <= u)%R -> + P [set x | lambda%:E <= (X x)%:E - 'E_P[X]] + <= ((fine 'V_P[X] + u^2) / (lambda + u)^2)%:E. + move=> uge0; rewrite EFinM. + have -> : (fine 'V_P[X] + u^2)%:E = 'E_P[(Y \+ cst u)^+2]%R. + rewrite -VY -[RHS](@subeK _ _ (('E_P[(Y \+ cst u)%R])^+2)); last first. + rewrite fin_numX// expectation_fin_num//= rpredD ?Lfun_cst//. + by rewrite rpredB// Lfun_cst. + rewrite -varianceE/=; last first. + by rewrite rpredD ?lee1n//= => _; rewrite Lfun_cst. + rewrite -expe2 expectationD/= ?Lfun_cst//; last by rewrite rpredB ?Lfun_cst. + rewrite EY// add0e expectation_cst -EFinM. + by rewrite (varianceD_cst_r _ Y2) EFinD fineK ?variance_fin_num. + have le : [set x | lambda%:E <= (X x)%:E - 'E_P[X]] + `<=` [set x | ((lambda + u)^2)%:E <= ((Y x + u)^+2)%:E]. + move=> x /= le; rewrite lee_fin; apply: lerXn2r. + - exact: addr_ge0 (ltW lambda_gt0) _. + - apply/(addr_ge0 _ uge0)/(le_trans (ltW lambda_gt0) _). + by rewrite -lee_fin EFinB finEK. + - by rewrite lerD2r -lee_fin EFinB finEK. + apply: (le_trans (le_measure _ _ _ le)). + - rewrite -[[set _ | _]]setTI inE; apply: emeasurable_fun_c_infty => [//|]. + apply: emeasurable_funB=> //. + by move/Lfun1_integrable : X1 => /measurable_int. + - rewrite -[[set _ | _]]setTI inE; apply: emeasurable_fun_c_infty => [//|]. + rewrite measurable_EFinP [X in measurable_fun _ X](_ : _ = + (fun x => x ^+ 2) \o (fun x => Y x + u))%R//. + by apply/measurableT_comp => //; exact/measurable_funD. + set eps := ((lambda + u) ^ 2)%R. + have peps : (0 < eps)%R by rewrite exprz_gt0 ?ltr_wpDr. + rewrite (lee_pdivlMr _ _ peps) muleC. + under eq_set => x. + rewrite -[leRHS]gee0_abs ?lee_fin ?sqr_ge0 -?lee_fin => [|//]. + rewrite -[(_ ^+ 2)%R]/(((Y \+ cst u) ^+ 2) x)%R; over. + rewrite -[X in X%:E * _]gtr0_norm => [|//]. + apply: (le_trans (markov _ peps _ _ _)) => //=. + by move=> x y /[!nnegrE] /ger0_norm-> /ger0_norm->. + rewrite -/Y le_eqVlt; apply/orP; left; apply/eqP; congr expectation. + by apply/funeqP => x /=; rewrite -expr2 normr_id ger0_norm ?sqr_ge0. +pose u0 := (fine 'V_P[X] / lambda)%R. +have u0ge0 : (0 <= u0)%R. + by apply: divr_ge0 (ltW lambda_gt0); rewrite -lee_fin finVK variance_ge0. +apply: le_trans (le _ u0ge0) _; rewrite lee_fin le_eqVlt; apply/orP; left. +rewrite eqr_div; [|apply: lt0r_neq0..]; last 2 first. +- by rewrite exprz_gt0 -1?[ltLHS]addr0 ?ltr_leD. +- by rewrite ltr_wpDl ?fine_ge0 ?variance_ge0 ?exprz_gt0. +apply/eqP; have -> : fine 'V_P[X] = (u0 * lambda)%R. + by rewrite /u0 -mulrA mulVf ?mulr1 ?gt_eqF. +by rewrite -mulrDl -mulrDr (addrC u0) [in RHS](mulrAC u0) -exprnP expr2 !mulrA. +Qed. + +End markov_chebyshev_cantelli. + +HB.mixin Record MeasurableFun_isDiscrete d d' (T : measurableType d) + (T' : measurableType d') (X : T -> T') of @MeasurableFun d d' T T' X := { + countable_range : countable (range X) +}. + +HB.structure Definition discreteMeasurableFun d d' (T : measurableType d) + (T' : measurableType d') := { + X of isMeasurableFun d d' T T' X & MeasurableFun_isDiscrete d d' T T' X +}. + +Notation "{ 'dmfun' aT >-> T }" := + (@discreteMeasurableFun.type _ _ aT T) : form_scope. + +Definition discrete_random_variable d d' (T : measurableType d) + (T' : measurableType d') (R : realType) (P : probability T R) := + {dmfun T >-> T'}. + +Notation "{ 'dRV' P >-> T }" := + (@discrete_random_variable _ _ _ T _ P) : form_scope. + +Section dRV_definitions. +Context {d} {d'} {T : measurableType d} {T' : measurableType d'} {R : realType} + (P : probability T R). + +Lemma dRV_dom_enum (X : {dRV P >-> T'}) : + { B : set nat & {splitbij B >-> range X}}. +Proof. +have /countable_bijP/cid[B] := @countable_range _ _ _ _ X. +move/card_esym/ppcard_eqP/unsquash => f. +exists B; exact: f. +Qed. + +Definition dRV_dom (X : {dRV P >-> T'}) : set nat := projT1 (dRV_dom_enum X). + +Definition dRV_enum (X : {dRV P >-> T'}) : {splitbij (dRV_dom X) >-> range X} := + projT2 (dRV_dom_enum X). + +Definition enum_prob (X : {dRV P >-> T'}) := + (fun k => P (X @^-1` [set dRV_enum X k])) \_ (dRV_dom X). + +End dRV_definitions. + +Section distribution_dRV. +Local Open Scope ereal_scope. +Context d d' (T : measurableType d) (T' : measurableType d') (R : realType) + (P : probability T R). +Variable X : {dRV P >-> T'}. + +Lemma distribution_dRV_enum (n : nat) : n \in dRV_dom X -> + distribution P X [set dRV_enum X n] = enum_prob X n. +Proof. +by move=> nX; rewrite /distribution/= /enum_prob/= patchE nX. +Qed. + +Hypothesis measurable_set1T' : forall x : T', measurable [set x]. + +Lemma distribution_dRV A : measurable A -> + distribution P X A = \sum_(k mA; rewrite /distribution /pushforward. +have mAX i : dRV_dom X i -> measurable (X @^-1` (A `&` [set dRV_enum X i])). + move=> domXi; rewrite preimage_setI. + by apply: measurableI; rewrite //-[X in _ X]setTI; exact/measurable_funP. +have tAX : trivIset (dRV_dom X) (fun k => X @^-1` (A `&` [set dRV_enum X k])). + under eq_fun do rewrite preimage_setI; rewrite -/(trivIset _ _). + apply: trivIset_setIl; apply/trivIsetP => i j iX jX /eqP ij. + rewrite -preimage_setI (_ : _ `&` _ = set0)//. + by apply/seteqP; split => //= x [] -> {x} /inj; rewrite inE inE => /(_ iX jX). +have := measure_bigcup P _ (fun k => X @^-1` (A `&` [set dRV_enum X k])) mAX tAX. +rewrite -preimage_bigcup => {mAX tAX}PXU. +rewrite -{1}(setIT A) -(setUv (\bigcup_(i in dRV_dom X) [set dRV_enum X i])). +rewrite setIUr preimage_setU measureU; last 3 first. + - by rewrite preimage_setI; apply: measurableI; rewrite //-[X in _ X]setTI; + apply/measurable_funP => //; exact: bigcup_measurable. + - by rewrite preimage_setI; apply: measurableI; rewrite //-[X in _ X]setTI; + apply/measurable_funP => //; apply: measurableC; exact: bigcup_measurable. + - by rewrite -preimage_setI -setIIr setIA setICK preimage_set0. +rewrite [X in _ + X = _](_ : _ = 0) ?adde0; last first. + rewrite (_ : _ @^-1` _ = set0) ?measure0//; apply/disjoints_subset => x AXx. + rewrite setCK /bigcup /=; exists ((dRV_enum X)^-1 (X x))%function. + exact: funS. + by rewrite invK// inE. +rewrite setI_bigcupr; etransitivity; first exact: PXU. +rewrite eseries_mkcond; apply: eq_eseriesr => k _. +rewrite /enum_prob patchE; case: ifPn => nX; rewrite ?mul0e//. +rewrite diracE; have [kA|] := boolP (_ \in A). + by rewrite mule1 setIidr// => _ /= ->; exact: set_mem. +rewrite notin_setE => kA. +rewrite mule0 (disjoints_subset _ _).2 ?preimage_set0 ?measure0//. +by apply: subsetCr; rewrite sub1set inE. +Qed. + +Lemma sum_enum_prob : \sum_(n /esym; apply: eq_trans. +by rewrite [RHS]eseries_mkcond; apply: eq_eseriesr => k _; rewrite diracT mule1. +Qed. + +End distribution_dRV. + +Section discrete_distribution. +Local Open Scope ereal_scope. +Context d (T : measurableType d) (R : realType) (P : probability T R). + +Lemma dRV_expectation (X : {dRV P >-> R}) : + P.-integrable [set: T] (EFin \o X) -> + 'E_P[X] = \sum_(n ix; rewrite unlock. +rewrite -[in LHS](_ : \bigcup_k (if k \in dRV_dom X then + X @^-1` [set dRV_enum X k] else set0) = setT); last first. + apply/seteqP; split => // t _. + exists ((dRV_enum X)^-1%function (X t)) => //. + case: ifPn=> [_|]. + by rewrite invK// inE. + by rewrite notin_setE/=; apply; apply: funS. +have tA : trivIset (dRV_dom X) (fun k => [set dRV_enum X k]). + by move=> i j iX jX [r [/= ->{r}]] /inj; rewrite !inE; exact. +have {tA}/trivIset_mkcond tXA : + trivIset (dRV_dom X) (fun k => X @^-1` [set dRV_enum X k]). + apply/trivIsetP => /= i j iX jX ij. + move/trivIsetP : tA => /(_ i j iX jX) Aij. + by rewrite -preimage_setI Aij ?preimage_set0. +rewrite integral_bigcup //; last 2 first. + - by move=> k; case: ifPn. + - apply: (integrableS measurableT) => //. + by rewrite -bigcup_mkcond; exact: bigcup_measurable. +transitivity (\sum_(i i _; case: ifPn => iX. + by apply: eq_integral => t; rewrite in_setE/= => ->. + by rewrite !integral_set0. +transitivity (\sum_(i i _; rewrite -integralZl//; last 2 first. + - by case: ifPn. + - apply/integrableP; split => //. + rewrite (eq_integral (cst 1%E)); last by move=> x _; rewrite abse1. + rewrite integral_cst//; last by case: ifPn. + rewrite mul1e (@le_lt_trans _ _ 1%E) ?ltey//. + by case: ifPn => // _; exact: probability_le1. + by apply: eq_integral => y _; rewrite mule1. +apply: eq_eseriesr => k _; case: ifPn => kX. + rewrite /= integral_cst//= mul1e probability_distribution muleC. + by rewrite distribution_dRV_enum. +by rewrite integral_set0 mule0 /enum_prob patchE (negbTE kX) mul0e. +Qed. + +Definition pmf (X : {RV P >-> R}) (r : R) : R := fine (P (X @^-1` [set r])). + +Lemma expectation_pmf (X : {dRV P >-> R}) : + P.-integrable [set: T] (EFin \o X) -> 'E_P[X] = + \sum_(n iX; rewrite dRV_expectation// [in RHS]eseries_mkcond. +apply: eq_eseriesr => k _. +rewrite /enum_prob patchE; case: ifPn => kX; last by rewrite mul0e. +by rewrite /pmf fineK// fin_num_measure. +Qed. + +End discrete_distribution. + +Section bernoulli_pmf. +Context {R : realType} (p : R). +Local Open Scope ring_scope. + +Definition bernoulli_pmf b := if b then p else 1 - p. + +Lemma bernoulli_pmf_ge0 (p01 : 0 <= p <= 1) b : 0 <= bernoulli_pmf b. +Proof. +rewrite /bernoulli_pmf. +by move: p01 => /andP[p0 p1]; case: ifPn => // _; rewrite subr_ge0. +Qed. + +Lemma bernoulli_pmf1 (p01 : 0 <= p <= 1) : + \sum_(i \in [set: bool]) (bernoulli_pmf i)%:E = 1%E. +Proof. +rewrite setT_bool fsbigU//=; last by move=> x [/= ->]. +by rewrite !fsbig_set1/= -EFinD addrCA subrr addr0. +Qed. + +End bernoulli_pmf. + +Lemma measurable_bernoulli_pmf {R : realType} D n : + measurable_fun D (@bernoulli_pmf R ^~ n). +Proof. +by apply/measurable_funTS/measurable_fun_if => //=; exact: measurable_funB. +Qed. + +Definition bernoulli {R : realType} (p : R) : set bool -> \bar R := fun A => + if (0 <= p <= 1)%R then \sum_(b \in A) (bernoulli_pmf p b)%:E else \d_false A. + +Section bernoulli. +Context {R : realType} (p : R). + +Local Notation bernoulli := (bernoulli p). + +Let bernoulli0 : bernoulli set0 = 0. +Proof. +by rewrite /bernoulli; case: ifPn => // p01; rewrite fsbig_set0. +Qed. + +Let bernoulli_ge0 U : (0 <= bernoulli U)%E. +Proof. +rewrite /bernoulli; case: ifPn => // p01. +rewrite fsbig_finite//= sumEFin lee_fin. +by apply: sumr_ge0 => /= b _; exact: bernoulli_pmf_ge0. +Qed. + +Let bernoulli_sigma_additive : semi_sigma_additive bernoulli. +Proof. +move=> F mF tF mUF; rewrite /bernoulli; case: ifPn => p01; last first. + exact: measure_semi_sigma_additive. +apply: cvg_toP. + apply: ereal_nondecreasing_is_cvgn => m n mn. + apply: lee_sum_nneg_natr => // k _ _. + rewrite fsbig_finite//= sumEFin lee_fin. + by apply: sumr_ge0 => /= b _; exact: bernoulli_pmf_ge0. +transitivity (\sum_(0 <= i k _; rewrite esum_fset//= => b _. + by rewrite lee_fin bernoulli_pmf_ge0. +rewrite -nneseries_sum_bigcup//=; last first. + by move=> b; rewrite lee_fin bernoulli_pmf_ge0. +by rewrite esum_fset//= => b _; rewrite lee_fin bernoulli_pmf_ge0. +Qed. + +HB.instance Definition _ := isMeasure.Build _ _ _ bernoulli + bernoulli0 bernoulli_ge0 bernoulli_sigma_additive. + +Let bernoulli_setT : bernoulli [set: _] = 1%E. +Proof. +rewrite /bernoulli/=; case: ifPn => p01; last by rewrite probability_setT. +by rewrite bernoulli_pmf1. +Qed. + +HB.instance Definition _ := + @Measure_isProbability.Build _ _ R bernoulli bernoulli_setT. + +Lemma eq_bernoulli (P : probability bool R) : + P [set true] = p%:E -> P =1 bernoulli. +Proof. +move=> Ptrue sb; rewrite /bernoulli /bernoulli_pmf. +have Pfalse: P [set false] = (1 - p%:E)%E. + rewrite -Ptrue -(probability_setT P) setT_bool measureU//; last first. + by rewrite disjoints_subset => -[]//. + by rewrite addeAC subee ?add0e//= Ptrue. +have: (0 <= p%:E <= 1)%E by rewrite -Ptrue measure_ge0 probability_le1. +rewrite !lee_fin => ->. +have eq_sb := etrans (bigcup_imset1 (_ : set bool) id) (image_id _). +rewrite -[in LHS](eq_sb sb)/= measure_fin_bigcup//; last 2 first. +- exact: finite_finset. +- by move=> [] [] _ _ [[]]//= []. +- by apply: eq_fsbigr => /= -[]. +Qed. + +End bernoulli. + +Section bernoulli_measure. +Context {R : realType}. +Variables (p : R) (p0 : (0 <= p)%R) (p1 : ((NngNum p0)%:num <= 1)%R). + +Lemma bernoulli_dirac : bernoulli p = measure_add + (mscale (NngNum p0) \d_true) (mscale (1 - (Itv01 p0 p1)%:num)%:nng \d_false). +Proof. +apply/funext => U; rewrite /bernoulli; case: ifPn => [p01|]; last first. + by rewrite p0/= p1. +rewrite measure_addE/= /mscale/=. +have := @subsetT _ U; rewrite setT_bool => UT. +have [->|->|->|->] /= := subset_set2 UT. +- rewrite -esum_fset//=; last by move=> b; rewrite lee_fin bernoulli_pmf_ge0. + by rewrite esum_set0 2!measure0 2!mule0 adde0. +- rewrite -esum_fset//=; last by move=> b; rewrite lee_fin bernoulli_pmf_ge0. + rewrite esum_set1/= ?lee_fin// 2!diracE mem_set//= memNset//= mule0 adde0. + by rewrite mule1. +- rewrite -esum_fset//=; last by move=> b; rewrite lee_fin bernoulli_pmf_ge0. + rewrite esum_set1/= ?lee_fin ?subr_ge0// 2!diracE memNset//= mem_set//=. + by rewrite mule0 add0e mule1. +- rewrite fsbigU//=; last by move=> x [->]. + by rewrite 2!fsbig_set1/= -setT_bool 2!diracT !mule1. +Qed. + +End bernoulli_measure. +Arguments bernoulli {R}. + +Lemma eq_bernoulliV2 {R : realType} (P : probability bool R) : + P [set true] = P [set false] -> P =1 bernoulli 2^-1. +Proof. +move=> Ptrue_eq_false; apply/eq_bernoulli. +have : P [set: bool] = 1%E := probability_setT P. +rewrite setT_bool measureU//=; last first. + by rewrite disjoints_subset => -[]//. +rewrite Ptrue_eq_false -mule2n; move/esym/eqP. +by rewrite -mule_natl -eqe_pdivrMl// mule1 => /eqP<-. +Qed. + +Section integral_bernoulli. +Context {R : realType}. +Variables (p : R) (p01 : (0 <= p <= 1)%R). +Local Open Scope ereal_scope. + +Lemma bernoulliE A : bernoulli p A = p%:E * \d_true A + (`1-p)%:E * \d_false A. +Proof. by case/andP : p01 => p0 p1; rewrite bernoulli_dirac// measure_addE. Qed. + +Lemma integral_bernoulli (f : bool -> \bar R) : (forall x, 0 <= f x) -> + \int[bernoulli p]_y (f y) = p%:E * f true + (`1-p)%:E * f false. +Proof. +move=> f0; case/andP : p01 => p0 p1; rewrite bernoulli_dirac/=. +rewrite ge0_integral_measure_sum// 2!big_ord_recl/= big_ord0 adde0/=. +by rewrite !ge0_integral_mscale//= !integral_dirac//= !diracT !mul1e. +Qed. + +End integral_bernoulli. + +Section measurable_bernoulli. +Local Open Scope ring_scope. +Variable R : realType. +Implicit Type p : R. + +Lemma measurable_bernoulli : + measurable_fun setT (bernoulli : R -> pprobability bool R). +Proof. +apply: (measurability (@pset _ _ _ : set (set (pprobability _ R)))) => //. +move=> _ -[_ [r r01] [Ys mYs <-]] <-; apply: emeasurable_fun_infty_o => //=. +apply: measurable_fun_if => //=. + by apply: measurable_and => //; exact: measurable_fun_ler. +apply: (eq_measurable_fun (fun t => + \sum_(b <- fset_set Ys) (bernoulli_pmf t b)%:E)). + move=> x /set_mem[_/= x01]. + by rewrite fsbig_finite//=. +apply: emeasurable_sum => n; move=> k Ysk; apply/measurableT_comp => //. +exact: measurable_bernoulli_pmf. +Qed. + +Lemma measurable_bernoulli2 U : measurable U -> + measurable_fun setT (bernoulli ^~ U : R -> \bar R). +Proof. +by move=> ?; exact: (measurable_kernel (kprobability measurable_bernoulli)). +Qed. + +End measurable_bernoulli. +Arguments measurable_bernoulli {R}. + +Section binomial_pmf. +Local Open Scope ring_scope. +Context {R : realType} (n : nat) (p : R). + +Definition binomial_pmf k := p ^+ k * (`1-p) ^+ (n - k) *+ 'C(n, k). + +Lemma binomial_pmf_ge0 k (p01 : (0 <= p <= 1)%R) : 0 <= binomial_pmf k. +Proof. +move: p01 => /andP[p0 p1]; rewrite mulrn_wge0// mulr_ge0// ?exprn_ge0//. +exact: onem_ge0. +Qed. + +End binomial_pmf. + +Lemma measurable_binomial_pmf {R : realType} D n k : + measurable_fun D (@binomial_pmf R n ^~ k). +Proof. +apply: (@measurableT_comp _ _ _ _ _ _ (fun x : R => x *+ 'C(n, k))%R) => /=. + exact: natmul_measurable. +by apply: measurable_funM => //; apply: measurable_funX; exact: measurable_funB. +Qed. + +Definition binomial_prob {R : realType} (n : nat) (p : R) : set nat -> \bar R := + fun U => if (0 <= p <= 1)%R then + \esum_(k in U) (binomial_pmf n p k)%:E else \d_0%N U. + +Section binomial. +Context {R : realType} (n : nat) (p : R). +Local Open Scope ereal_scope. + +Local Notation binomial := (binomial_prob n p). + +Let binomial0 : binomial set0 = 0. +Proof. by rewrite /binomial measure0; case: ifPn => //; rewrite esum_set0. Qed. + +Let binomial_ge0 U : 0 <= binomial U. +Proof. +rewrite /binomial; case: ifPn => // p01; apply: esum_ge0 => /= k Uk. +by rewrite lee_fin binomial_pmf_ge0. +Qed. + +Let binomial_sigma_additive : semi_sigma_additive binomial. +Proof. +move=> F mF tF mUF; rewrite /binomial; case: ifPn => p01; last first. + exact: measure_semi_sigma_additive. +apply: cvg_toP. + apply: ereal_nondecreasing_is_cvgn => a b ab. + apply: lee_sum_nneg_natr => // k _ _. + by apply: esum_ge0 => /= ? _; exact: binomial_pmf_ge0. +by rewrite nneseries_sum_bigcup// => i; rewrite lee_fin binomial_pmf_ge0. +Qed. + +HB.instance Definition _ := isMeasure.Build _ _ _ binomial + binomial0 binomial_ge0 binomial_sigma_additive. + +Let binomial_setT : binomial [set: _] = 1. +Proof. +rewrite /binomial; case: ifPn; last by move=> _; rewrite probability_setT. +move=> p01; rewrite /binomial_pmf. +have pkn k : 0%R <= (p ^+ k * `1-p ^+ (n - k) *+ 'C(n, k))%:E. + case/andP : p01 => p0 p1. + by rewrite lee_fin mulrn_wge0// mulr_ge0 ?exprn_ge0 ?subr_ge0. +rewrite (esumID `I_n.+1)// [X in _ + X]esum1 ?adde0; last first. + by move=> /= k [_ /negP]; rewrite -leqNgt => nk; rewrite bin_small. +rewrite setTI esum_fset// -fsbig_ord//=. +under eq_bigr do rewrite mulrC. +rewrite sumEFin -exprDn_comm; last exact: mulrC. +by rewrite addrC add_onemK expr1n. +Qed. + +HB.instance Definition _ := + @Measure_isProbability.Build _ _ R binomial binomial_setT. + +End binomial. + +Section binomial_probability. +Local Open Scope ring_scope. +Context {R : realType} (n : nat) (p : R) + (p0 : (0 <= p)%R) (p1 : ((NngNum p0)%:num <= 1)%R). + +Definition bin_prob (k : nat) : {nonneg R} := + ((NngNum p0)%:num ^+ k * (NngNum (onem_ge0 p1))%:num ^+ (n - k)%N *+ 'C(n, k))%:nng. + +Lemma bin_prob0 : bin_prob 0 = ((NngNum (onem_ge0 p1))%:num^+n)%:nng. +Proof. +rewrite /bin_prob bin0 subn0/=; apply/val_inj => /=. +by rewrite expr0 mul1r mulr1n. +Qed. + +Lemma bin_prob1 : bin_prob 1 = + ((NngNum p0)%:num * (NngNum (onem_ge0 p1))%:num ^+ n.-1 *+ n)%:nng. +Proof. +by rewrite /bin_prob bin1/=; apply/val_inj => /=; rewrite expr1 subn1. +Qed. + +Lemma binomial_msum : + binomial_prob n p = msum (fun k => mscale (bin_prob k) \d_k) n.+1. +Proof. +apply/funext => U. +rewrite /binomial_prob; case: ifPn => [_|]; last by rewrite p1 p0. +rewrite /msum/= /mscale/= /binomial_pmf. +have pkn k : (0%R <= (p ^+ k * `1-p ^+ (n - k) *+ 'C(n, k))%:E)%E. + by rewrite lee_fin mulrn_wge0// mulr_ge0 ?exprn_ge0 ?subr_ge0. +rewrite (esumID `I_n.+1)//= [X in _ + X]esum1 ?adde0; last first. + by move=> /= k [_ /negP]; rewrite -leqNgt => nk; rewrite bin_small. +rewrite esum_mkcondl esum_fset//; last by move=> i /= _; case: ifPn. +rewrite -fsbig_ord//=; apply: eq_bigr => i _. +by rewrite diracE; case: ifPn => /= iU; [rewrite mule1|rewrite mule0]. +Qed. + +Lemma binomial_probE U : binomial_prob n p U = + (\sum_(k < n.+1) (bin_prob k)%:num%:E * (\d_(nat_of_ord k) U))%E. +Proof. by rewrite binomial_msum. Qed. + +Lemma integral_binomial (f : nat -> \bar R) : (forall x, 0 <= f x)%E -> + (\int[binomial_prob n p]_y (f y) = + \sum_(k < n.+1) (bin_prob k)%:num%:E * f k)%E. +Proof. +move=> f0; rewrite binomial_msum ge0_integral_measure_sum//=. +apply: eq_bigr => i _. +by rewrite ge0_integral_mscale//= integral_dirac//= diracT mul1e. +Qed. + +End binomial_probability. + +Lemma integral_binomial_prob (R : realType) n p U : (0 <= p <= 1)%R -> + (\int[binomial_prob n p]_y \d_(0 < y)%N U = + bernoulli (1 - `1-p ^+ n) U :> \bar R)%E. +Proof. +move=> /andP[p0 p1]; rewrite bernoulliE//=; last first. + rewrite subr_ge0 exprn_ile1//=; [|exact/onem_ge0|exact/onem_le1]. + by rewrite lerBlDr addrC -lerBlDr subrr; exact/exprn_ge0/onem_ge0. +rewrite (@integral_binomial _ n p _ _ (fun y => \d_(1 <= y)%N U))//. +rewrite !big_ord_recl/=. +rewrite expr0 mul1r subn0 bin0 ltnn mulr1n addrC. +rewrite onemD opprK onem1 add0r; congr +%E. +rewrite /bump; under eq_bigr do rewrite leq0n add1n ltnS leq0n. +rewrite -ge0_sume_distrl; last first. + move=> i _. + by apply/mulrn_wge0/mulr_ge0; apply/exprn_ge0 => //; exact/onem_ge0. +congr *%E. +transitivity (\sum_(i < n.+1) (`1-p ^+ (n - i) * p ^+ i *+ 'C(n, i))%:E - + (`1-p ^+ n)%:E)%E. + rewrite big_ord_recl/=. + rewrite expr0 mulr1 subn0 bin0 mulr1n addrAC -EFinD subrr add0e. + by rewrite /bump; under [RHS]eq_bigr do rewrite leq0n add1n mulrC. +rewrite sumEFin -(@exprDn_comm _ `1-p p n)//. + by rewrite subrK expr1n. +by rewrite /GRing.comm/onem mulrC. +Qed. + +Lemma measurable_binomial_prob (R : realType) (n : nat) : + measurable_fun setT (binomial_prob n : R -> pprobability _ _). +Proof. +apply: (measurability (@pset _ _ _ : set (set (pprobability _ R)))) => //. +move=> _ -[_ [r r01] [Ys mYs <-]] <-; apply: emeasurable_fun_infty_o => //=. +apply: measurable_fun_if => //=. + by apply: measurable_and => //; exact: measurable_fun_ler. +apply: (eq_measurable_fun (fun t => + \sum_(k x /set_mem[_/= x01]. + rewrite nneseries_esum//; last by move=> *; rewrite lee_fin binomial_pmf_ge0. + by rewrite set_mem_set. +apply: ge0_emeasurable_sum. + by move=> k x/= [_ x01] _; rewrite lee_fin binomial_pmf_ge0. +by move=> k Ysk; apply/measurableT_comp => //; exact: measurable_binomial_pmf. +Qed. + +Section uniform_probability. +Local Open Scope ring_scope. +Context (R : realType) (a b : R). + +Definition uniform_pdf x := if a <= x <= b then (b - a)^-1 else 0. + +Lemma uniform_pdf_ge0 x : a < b -> 0 <= uniform_pdf x. +Proof. +move=> ab; rewrite /uniform_pdf; case: ifPn => // axb. +by rewrite invr_ge0// ltW// subr_gt0. +Qed. + +Lemma measurable_uniform_pdf : measurable_fun setT uniform_pdf. +Proof. +rewrite /uniform_pdf /=; apply: measurable_fun_if => //=. +by apply: measurable_and => //; exact: measurable_fun_ler. +Qed. + +Local Notation mu := lebesgue_measure. + +Lemma integral_uniform_pdf U : + (\int[mu]_(x in U) (uniform_pdf x)%:E = + \int[mu]_(x in U `&` `[a, b]) (uniform_pdf x)%:E)%E. +Proof. +rewrite [RHS]integral_mkcondr/=; apply: eq_integral => x xU. +rewrite patchE; case: ifPn => //. +rewrite notin_setE/= in_itv/= => /negP/negbTE xab. +by rewrite /uniform_pdf xab. +Qed. + +Lemma integral_uniform_pdf1 A (ab : a < b) : `[a, b] `<=` A -> + (\int[mu]_(x in A) (uniform_pdf x)%:E = 1)%E. +Proof. +move=> abA; rewrite integral_uniform_pdf setIidr//. +rewrite (eq_integral (fun=> (b - a)^-1%:E)); last first. + by move=> x; rewrite inE/= in_itv/= /uniform_pdf => ->. +rewrite integral_cst//= lebesgue_measure_itv/= lte_fin. +by rewrite ab -EFinD -EFinM mulVf// gt_eqF// subr_gt0. +Qed. + +Definition uniform_prob (ab : a < b) : set _ -> \bar R := + fun U => (\int[mu]_(x in U) (uniform_pdf x)%:E)%E. + +Hypothesis ab : (a < b)%R. + +Let uniform0 : uniform_prob ab set0 = 0. +Proof. by rewrite /uniform_prob integral_set0. Qed. + +Let uniform_ge0 U : (0 <= uniform_prob ab U)%E. +Proof. +by apply: integral_ge0 => /= x Ux; rewrite lee_fin uniform_pdf_ge0. +Qed. + +Lemma integrable_uniform_pdf : + mu.-integrable setT (fun x => (uniform_pdf x)%:E). +Proof. +apply/integrableP; split. + by apply: measurableT_comp => //; exact: measurable_uniform_pdf. +under eq_integral. + move=> x _; rewrite gee0_abs//; last by rewrite lee_fin uniform_pdf_ge0. + over. +by rewrite /= integral_uniform_pdf1 ?ltry// -subr_gt0. +Qed. + +Let uniform_sigma_additive : semi_sigma_additive (uniform_prob ab). +Proof. +move=> /= F mF tF mUF; rewrite /uniform_prob; apply: cvg_toP. + apply: ereal_nondecreasing_is_cvgn => m n mn. + apply: lee_sum_nneg_natr => // k _ _. + by apply: integral_ge0 => /= x Fkx; rewrite lee_fin uniform_pdf_ge0. +rewrite ge0_integral_bigcup//=. +- apply: measurable_funTS; apply: measurableT_comp => //. + exact: measurable_uniform_pdf. +- by move=> x _; rewrite lee_fin uniform_pdf_ge0. +Qed. + +HB.instance Definition _ := isMeasure.Build _ _ _ (uniform_prob ab) + uniform0 uniform_ge0 uniform_sigma_additive. + +Let uniform_setT : uniform_prob ab [set: _] = 1%:E. +Proof. by rewrite /uniform_prob /mscale/= integral_uniform_pdf1. Qed. + +HB.instance Definition _ := @Measure_isProbability.Build _ _ R + (uniform_prob ab) uniform_setT. + +Lemma dominates_uniform_prob : uniform_prob ab `<< mu. +Proof. +move=> A mA muA0; rewrite /uniform_prob integral_uniform_pdf. +apply/eqP; rewrite eq_le; apply/andP; split; last first. + apply: integral_ge0 => x [Ax /=]; rewrite in_itv /= => xab. + by rewrite lee_fin uniform_pdf_ge0. +apply: (@le_trans _ _ + (\int[mu]_(x in A `&` `[a, b]%classic) (b - a)^-1%:E))%E; last first. + rewrite integral_cst//= ?mul1e//. + by rewrite pmule_rle0 ?lte_fin ?invr_gt0// ?subr_gt0// -muA0 measureIl. + exact: measurableI. +apply: ge0_le_integral => //=. +- exact: measurableI. +- by move=> x [Ax]; rewrite /= in_itv/= => axb; rewrite lee_fin uniform_pdf_ge0. +- by apply/measurable_EFinP/measurable_funTS; exact: measurable_uniform_pdf. +- by move=> x [Ax _]; rewrite lee_fin invr_ge0// ltW// subr_gt0. +- by move=> x [Ax]; rewrite in_itv/= /uniform_pdf => ->. +Qed. + +Let integral_uniform_indic E : measurable E -> + (\int[uniform_prob ab]_x (\1_E x)%:E = + (b - a)^-1%:E * \int[mu]_(x in `[a, b]) (\1_E x)%:E)%E. +Proof. +move=> mE; rewrite integral_indic//= /uniform_prob setIT -ge0_integralZl//=. +- rewrite [LHS]integral_mkcond/= [RHS]integral_mkcond/=. + apply: eq_integral => x _; rewrite !patchE; case: ifPn => xE. + case: ifPn. + rewrite inE/= in_itv/= => xab. + by rewrite /uniform_pdf xab indicE xE mule1. + by rewrite notin_setE/= in_itv/= => /negP/negbTE; rewrite /uniform_pdf => ->. + case: ifPn => //. + by rewrite inE/= in_itv/= => axb; rewrite indicE (negbTE xE) mule0. +- exact/measurable_EFinP/measurable_indic. +- by rewrite lee_fin invr_ge0// ltW// subr_gt0. +Qed. + +Import HBNNSimple. + +Let integral_uniform_nnsfun (f : {nnsfun _ >-> R}) : + (\int[uniform_prob ab]_x (f x)%:E = + (b - a)^-1%:E * \int[mu]_(x in `[a, b]) (f x)%:E)%E. +Proof. +under [LHS]eq_integral do rewrite fimfunE -fsumEFin//. +rewrite [LHS]ge0_integral_fsum//; last 2 first. + - by move=> r; exact/measurable_EFinP/measurableT_comp. + - by move=> n x _; rewrite EFinM nnfun_muleindic_ge0. +rewrite -[RHS]ge0_integralZl//; last 3 first. + - exact/measurable_EFinP/measurable_funTS. + - by move=> x _; rewrite lee_fin. + - by rewrite lee_fin invr_ge0// ltW// subr_gt0. +under [RHS]eq_integral. + move=> x xD; rewrite fimfunE -fsumEFin// ge0_mule_fsumr; last first. + by move=> r; rewrite EFinM nnfun_muleindic_ge0. + over. +rewrite [RHS]ge0_integral_fsum//; last 2 first. + - by move=> r; apply/measurable_EFinP; do 2 apply/measurableT_comp => //. + - move=> n x _; rewrite EFinM mule_ge0//; last by rewrite nnfun_muleindic_ge0. + by rewrite lee_fin invr_ge0// ltW// subr_gt0. +apply: eq_fsbigr => r _; rewrite ge0_integralZl//. +- by rewrite !integralZl_indic_nnsfun//= integral_uniform_indic// muleCA. +- exact/measurable_EFinP/measurableT_comp. +- by move=> t _; rewrite nnfun_muleindic_ge0. +- by rewrite lee_fin invr_ge0// ltW// subr_gt0. +Qed. + +Lemma integral_uniform (f : _ -> \bar R) : + measurable_fun setT f -> (forall x, 0 <= f x)%E -> + (\int[uniform_prob ab]_x f x = (b - a)^-1%:E * \int[mu]_(x in `[a, b]) f x)%E. +Proof. +move=> mf f0. +pose f_ := nnsfun_approx measurableT mf. +transitivity (lim (\int[uniform_prob ab]_x (f_ n x)%:E @[n --> \oo])%E). + rewrite -monotone_convergence//=. + - apply: eq_integral => ? /[!inE] xD; apply/esym/cvg_lim => //=. + exact: cvg_nnsfun_approx. + - by move=> n; exact/measurable_EFinP/measurable_funTS. + - by move=> n ? _; rewrite lee_fin. + - by move=> ? _ ? ? mn; rewrite lee_fin; exact/lefP/nd_nnsfun_approx. +rewrite [X in _ = (_ * X)%E](_ : _ = lim + (\int[mu]_(x in `[a, b]) (f_ n x)%:E @[n --> \oo])%E); last first. + rewrite -monotone_convergence//=. + - apply: eq_integral => ? /[!inE] xD; apply/esym/cvg_lim => //. + exact: cvg_nnsfun_approx. + - by move=> n; exact/measurable_EFinP/measurable_funTS. + - by move=> n ? _; rewrite lee_fin. + - by move=> ? _ ? ? ?; rewrite lee_fin; exact/lefP/nd_nnsfun_approx. +rewrite -limeMl//. + by apply: congr_lim; apply/funext => n /=; exact: integral_uniform_nnsfun. +apply/ereal_nondecreasing_is_cvgn => x y xy; apply: ge0_le_integral => //=. +- by move=> ? _; rewrite lee_fin. +- exact/measurable_EFinP/measurable_funTS. +- by move=> ? _; rewrite lee_fin. +- exact/measurable_EFinP/measurable_funTS. +- by move=> ? _; rewrite lee_fin; exact/lefP/nd_nnsfun_approx. +Qed. + +End uniform_probability. + +Section normal_density. +Context {R : realType}. +Local Open Scope ring_scope. +Local Import Num.ExtraDef. +Implicit Types m s x : R. + +Definition normal_fun m s x := expR (- (x - m) ^+ 2 / (s ^+ 2 *+ 2)). + +Lemma measurable_normal_fun m s : measurable_fun [set :R] (normal_fun m s). +Proof. +apply: measurableT_comp => //=; apply: measurable_funM => //=. +apply: measurableT_comp => //=; apply: measurable_funX => //=. +exact: measurable_funB. +Qed. + +Lemma normal_fun_ge0 m s x : 0 <= normal_fun m s x. +Proof. exact: expR_ge0. Qed. + +Lemma normal_fun_center m s : normal_fun m s = normal_fun 0 s \o center m. +Proof. by apply/funext => x/=; rewrite /normal_fun/= subr0. Qed. + +Definition normal_peak s := (sqrtr (s ^+ 2 * pi *+ 2))^-1. + +Lemma normal_peak_ge0 s : 0 <= normal_peak s. Proof. by rewrite invr_ge0. Qed. + +Lemma normal_peak_gt0 s : s != 0 -> 0 < normal_peak s. +Proof. +move=> s0; rewrite invr_gt0// sqrtr_gt0. +by rewrite pmulrn_rgt0// mulr_gt0 ?pi_gt0// exprn_even_gt0/=. +Qed. + +Let normal_pdf0 m s x : R := normal_peak s * normal_fun m s x. + +Definition normal_pdf m s x := + if s == 0 then \1_`[0, 1] x else normal_pdf0 m s x. + +Lemma normal_pdfE m s : s != 0 -> normal_pdf m s = normal_pdf0 m s. +Proof. by rewrite /normal_pdf; have [_|s0] := eqVneq s 0. Qed. + +Let normal_pdf0_center m s : normal_pdf0 m s = normal_pdf0 0 s \o center m. +Proof. by rewrite /normal_pdf0 normal_fun_center. Qed. + +Let normal_pdf0_ge0 m s x : 0 <= normal_pdf0 m s x. +Proof. by rewrite mulr_ge0 ?normal_peak_ge0 ?expR_ge0. Qed. + +Let normal_pdf0_gt0 m s x : s != 0 -> 0 < normal_pdf0 m s x. +Proof. by move=> s0; rewrite mulr_gt0 ?expR_gt0// normal_peak_gt0. Qed. + +Let measurable_normal_pdf0 m s : measurable_fun setT (normal_pdf0 m s). +Proof. by apply: measurable_funM => //=; exact: measurable_normal_fun. Qed. + +Lemma measurable_normal_pdf m s : measurable_fun setT (normal_pdf m s). +Proof. +by rewrite /normal_pdf; have [_|] := eqVneq s 0; first exact: measurable_indic. +Qed. + +Let continuous_normal_pdf0 m s : continuous (normal_pdf0 m s). +Proof. +move=> x; apply: cvgM; first exact: cvg_cst. +apply: (cvg_comp _ expR); last exact: continuous_expR. +apply: cvgM; last exact: cvg_cst. +apply: (@cvgN _ R^o). +apply: (cvg_comp (fun x => x - m) (fun x => x ^+ 2)). + by apply: (@cvgB _ R^o) => //; [exact: cvg_id|exact: cvg_cst]. +exact: sqr_continuous. +Qed. + +Let normal_pdf0_ub m s x : normal_pdf0 m s x <= normal_peak s. +Proof. +rewrite /normal_pdf0 ler_piMr ?normal_peak_ge0//. +rewrite -[leRHS]expR0 ler_expR mulNr oppr_le0 mulr_ge0// ?sqr_ge0//. +by rewrite invr_ge0 mulrn_wge0// sqr_ge0. +Qed. + +Lemma normal_pdf_ge0 m s x : 0 <= normal_pdf m s x. +Proof. by rewrite /normal_pdf; case: ifP. Qed. + +Lemma continuous_normal_pdf m s : s != 0 -> continuous (normal_pdf m s). +Proof. by rewrite /normal_pdf; have [|] := eqVneq s 0. Qed. + +Lemma normal_pdf_ub m s x : s != 0 -> normal_pdf m s x <= normal_peak s. +Proof. by rewrite /normal_pdf; have [|] := eqVneq s 0. Qed. + +End normal_density. + +Definition normal_prob {R : realType} (m : R) (s : R) : set _ -> \bar R := + fun V => (\int[lebesgue_measure]_(x in V) (normal_pdf m s x)%:E)%E. + +Section normal_probability. +Variables (R : realType) (m sigma : R). +Local Open Scope ring_scope. +Notation mu := lebesgue_measure. + +Local Notation normal_peak := (normal_peak sigma). +Local Notation normal_fun := (normal_fun m sigma). + +Let F (x : R^o) := (x - m) / (Num.sqrt (sigma ^+ 2 *+ 2)). + +Let normal_gauss_fun x : normal_fun x = gauss_fun (F x). +Proof. +congr expR; rewrite mulNr exprMn exprVn; congr (- (_ * _^-1)%R). +by rewrite sqr_sqrtr// pmulrn_lge0// sqr_ge0. +Qed. + +Let F'E : F^`()%classic = cst (Num.sqrt (sigma ^+ 2 *+ 2))^-1. +Proof. +apply/funext => x; rewrite /F derive1E deriveM// deriveD// derive_cst scaler0. +by rewrite add0r derive_id derive_cst addr0 scaler1. +Qed. + +Let integral_gaussFF' : sigma != 0 -> + (\int[mu]_x ((((gauss_fun \o F) * + (F^`())%classic) x)%:E * (Num.sqrt (sigma ^+ 2 *+ 2))%:E))%E = + normal_peak^-1%:E. +Proof. +move=> s0; rewrite /normal_peak invrK. +rewrite -mulrnAr -[in RHS]mulr_natr sqrtrM ?(sqrtrM 2) ?sqr_ge0 ?pi_ge0// !EFinM. +rewrite muleCA ge0_integralZr//=; first last. + by move=> x _; rewrite lee_fin mulr_ge0//= ?gauss_fun_ge0// F'E/= invr_ge0. + rewrite F'E; apply/measurable_EFinP/measurable_funM => //. + apply/measurableT_comp => //; first exact: measurable_gauss_fun. + by apply: measurable_funM => //; exact: measurable_funD. +congr *%E; last by rewrite -(mulr_natr (_ ^+ 2)) sqrtrM ?sqr_ge0. +rewrite -increasing_ge0_integration_by_substitutionT//. +- exact: integralT_gauss. +- move=> x y xy; rewrite /F ltr_pM2r ?ltr_leB ?gt_eqF//. + by rewrite invr_gt0 ?sqrtr_gt0 ?pmulrn_lgt0 ?exprn_even_gt0. +- by rewrite F'E => ?; exact: cvg_cst. +- by rewrite F'E; exact: is_cvg_cst. +- by rewrite F'E; exact: is_cvg_cst. +- apply/gt0_cvgMlNy; last exact: cvg_addrr_Ny. + by rewrite invr_gt0// sqrtr_gt0 -mulr_natr mulr_gt0// exprn_even_gt0. +- apply/gt0_cvgMly; last exact: cvg_addrr. + by rewrite invr_gt0// sqrtr_gt0 -mulr_natr mulr_gt0// exprn_even_gt0. +- exact: continuous_gauss_fun. +- by move=> x; rewrite gauss_fun_ge0. +Qed. + +Let integral_normal_fun : sigma != 0 -> + (\int[mu]_x (normal_fun x)%:E)%E = normal_peak^-1%:E. +Proof. +move=> s0; rewrite -integral_gaussFF'//; apply: eq_integral => /= x _. +rewrite F'E !fctE/= EFinM -muleA -EFinM mulVf ?mulr1 ?mule1. + by rewrite normal_gauss_fun. +by rewrite gt_eqF// sqrtr_gt0 pmulrn_lgt0// exprn_even_gt0. +Qed. + +Let integrable_normal_fun : sigma != 0 -> + mu.-integrable [set: R] (EFin \o normal_fun). +Proof. +move=> s0; apply/integrableP; split. + by apply/measurable_EFinP; exact: measurable_normal_fun. +under eq_integral do rewrite /= ger0_norm ?expR_ge0//. +by rewrite /= integral_normal_fun// ltry. +Qed. + +Lemma integral_normal_pdf : (\int[mu]_x (normal_pdf m sigma x)%:E = 1%E)%E. +Proof. +rewrite /normal_pdf; have [_|s0] := eqVneq sigma 0. + by rewrite integral_indic//= setIT lebesgue_measure_itv/= lte01 oppr0 adde0. +under eq_integral do rewrite EFinM. +rewrite integralZl//=; last exact: integrable_normal_fun. +by rewrite integral_normal_fun// -EFinM divff// gt_eqF// normal_peak_gt0. +Qed. + +Lemma integrable_normal_pdf : mu.-integrable [set: R] + (fun x => (normal_pdf m sigma x)%:E). +Proof. +apply/integrableP; split. + by apply/measurable_EFinP; exact: measurable_normal_pdf. +apply/abse_integralP => //=; last by rewrite integral_normal_pdf abse1 ltry. +by apply/measurable_EFinP; exact: measurable_normal_pdf. +Qed. + +Local Notation normal_pdf := (normal_pdf m sigma). +Local Notation normal_prob := (normal_prob m sigma). + +Let normal0 : normal_prob set0 = 0%E. +Proof. by rewrite /normal_prob integral_set0. Qed. + +Let normal_ge0 A : (0 <= normal_prob A)%E. +Proof. +rewrite /normal_prob integral_ge0//= => x _. +by rewrite lee_fin normal_pdf_ge0 ?ltW. +Qed. + +Let normal_sigma_additive : semi_sigma_additive normal_prob. +Proof. +move=> /= A mA tA mUA. +rewrite /normal_prob/= integral_bigcup//=; last first. + by apply: (integrableS _ _ (subsetT _)) => //; exact: integrable_normal_pdf. +apply: is_cvg_ereal_nneg_natsum_cond => n _ _. +by apply: integral_ge0 => /= x ?; rewrite lee_fin normal_pdf_ge0 ?ltW. +Qed. + +HB.instance Definition _ := isMeasure.Build _ _ _ + normal_prob normal0 normal_ge0 normal_sigma_additive. + +Let normal_setT : normal_prob [set: _] = 1%E. +Proof. by rewrite /normal_prob integral_normal_pdf. Qed. + +HB.instance Definition _ := + @Measure_isProbability.Build _ _ R normal_prob normal_setT. + +Lemma normal_prob_dominates : normal_prob `<< mu. +Proof. +move=> A mA muA0; rewrite /normal_prob /normal_pdf. +have [s0|s0] := eqVneq sigma 0. + apply: null_set_integral => //=; apply: (integrableS measurableT) => //=. + exact: integrable_indic_itv. +apply/eqP; rewrite eq_le; apply/andP; split; last first. + apply: integral_ge0 => x _. + by rewrite lee_fin mulr_ge0 ?normal_peak_ge0 ?normal_fun_ge0. +apply: (@le_trans _ _ (\int[mu]_(x in A) (normal_peak)%:E))%E; last first. + by rewrite integral_cst//= muA0 mule0. +apply: ge0_le_integral => //=. +- by move=> x _; rewrite lee_fin mulr_ge0 ?normal_peak_ge0 ?normal_fun_ge0. +- apply/measurable_funTS/measurableT_comp => //=. + by apply: measurable_funM => //; exact: measurable_normal_fun. +- by move=> x _; rewrite lee_fin normal_peak_ge0. +- by move=> x _; have := normal_pdf_ub m x s0; rewrite /normal_pdf (negbTE s0). +Qed. + +End normal_probability. + +Section exponential_pdf. +Context {R : realType}. +Notation mu := lebesgue_measure. +Variable rate : R. +Hypothesis rate_gt0 : 0 < rate. + +Let exponential_pdfT x := rate * expR (- rate * x). +Definition exponential_pdf := exponential_pdfT \_ `[0%R, +oo[. + +Lemma exponential_pdf_ge0 x : 0 <= exponential_pdf x. +Proof. +by apply: restrict_ge0 => {}x _; apply: mulr_ge0; [exact: ltW|exact: expR_ge0]. +Qed. + +Lemma lt0_exponential_pdf x : x < 0 -> exponential_pdf x = 0. +Proof. +move=> x0; rewrite /exponential_pdf patchE ifF//. +by apply/negP; rewrite inE/= in_itv/= andbT; apply/negP; rewrite -ltNge. +Qed. + +Let continuous_exponential_pdfT : continuous exponential_pdfT. +Proof. +move=> x. +apply: (@continuousM _ R^o (fun=> rate) (fun x => expR (- rate * x))). + exact: cst_continuous. +apply: continuous_comp; last exact: continuous_expR. +by apply: continuousM => //; apply: (@continuousN _ R^o); exact: cst_continuous. +Qed. + +Lemma measurable_exponential_pdf : measurable_fun [set: R] exponential_pdf. +Proof. +apply/measurable_restrict => //; apply: measurable_funTS. +exact: continuous_measurable_fun. +Qed. + +Lemma exponential_pdfE x : 0 <= x -> exponential_pdf x = exponential_pdfT x. +Proof. +by move=> x0; rewrite /exponential_pdf patchE ifT// inE/= in_itv/= x0. +Qed. + +Lemma in_continuous_exponential_pdf : + {in `]0, +oo[%R, continuous exponential_pdf}. +Proof. +move=> x; rewrite in_itv/= andbT => x0. +apply/(@cvgrPdist_lt _ R^o) => e e0; near=> y. +rewrite 2?(exponential_pdfE (ltW _))//; last by near: y; exact: lt_nbhsr. +near: y; move: e e0; apply/(@cvgrPdist_lt _ R^o). +by apply: continuous_comp => //; exact: continuous_exponential_pdfT. +Unshelve. end_near. Qed. + +Lemma within_continuous_exponential_pdf : + {within [set` `[0, +oo[%R], continuous exponential_pdf}. +Proof. +apply/continuous_within_itvcyP; split. + exact: in_continuous_exponential_pdf. +apply/(@cvgrPdist_le _ R^o) => e e0; near=> t. +rewrite 2?exponential_pdfE//. +near: t; move: e e0; apply/cvgrPdist_le. +by apply: cvg_at_right_filter; exact: continuous_exponential_pdfT. +Unshelve. end_near. Qed. + +End exponential_pdf. + +Definition exponential_prob {R : realType} (rate : R) := + fun V => (\int[lebesgue_measure]_(x in V) (exponential_pdf rate x)%:E)%E. + +Section exponential_prob. +Context {R : realType}. +Local Open Scope ring_scope. +Notation mu := lebesgue_measure. +Variable rate : R. +Hypothesis rate_gt0 : 0 < rate. + +Lemma derive1_exponential_pdf : + {in `]0, +oo[%R, (fun x => - (expR : R^o -> R^o) (- rate * x))^`()%classic + =1 exponential_pdf rate}. +Proof. +move=> z; rewrite in_itv/= andbT => z0. +rewrite derive1_comp// derive1N// derive1_id mulN1r derive1_comp// derive1E. +have/funeqP -> := @derive_expR R. +by rewrite derive1Ml// derive1_id mulr1 mulrN opprK mulrC exponential_pdfE ?ltW. +Qed. + +Let cexpNM : continuous (fun z : R^o => expR (- rate * z)). +Proof. +move=> z; apply: continuous_comp; last exact: continuous_expR. +by apply: continuousM => //; apply: (@continuousN _ R^o); exact: cst_continuous. +Qed. + +Lemma exponential_prob_itv0c (x : R) : 0 < x -> + exponential_prob rate `[0, x] = (1 - (expR (- rate * x))%:E)%E. +Proof. +move=> x0. +rewrite (_: 1 = - (- expR (- rate * 0))%:E)%E; last first. + by rewrite mulr0 expR0 EFinN oppeK. +rewrite addeC. +apply: (@continuous_FTC2 _ _ (fun x => - expR (- rate * x))) => //. +- apply: (@continuous_subspaceW R^o _ _ [set` `[0, +oo[%R]). + + exact: subset_itvl. + + exact: within_continuous_exponential_pdf. +- split. + + by move=> z _; exact: ex_derive. + + by apply/cvg_at_right_filter; apply: cvgN; exact: cexpNM. + + by apply/cvg_at_left_filter; apply: cvgN; exact: cexpNM. +- move=> z; rewrite in_itv/= => /andP[z0 _]. + by apply: derive1_exponential_pdf; rewrite in_itv/= andbT. +Qed. + +Lemma integral_exponential_pdf : (\int[mu]_x (exponential_pdf rate x)%:E = 1)%E. +Proof. +have mEex : measurable_fun setT (EFin \o exponential_pdf rate). + by apply/measurable_EFinP; exact: measurable_exponential_pdf. +rewrite -(setUv `[0, +oo[%classic) ge0_integral_setU//=; last 4 first. + exact: measurableC. + by rewrite setUv. + by move=> x _; rewrite lee_fin exponential_pdf_ge0. + exact/disj_setPCl. +rewrite [X in _ + X]integral0_eq ?adde0; last first. + by move=> x x0; rewrite /exponential_pdf patchE ifF// memNset. +rewrite (@ge0_continuous_FTC2y _ _ + (fun x => - (expR (- rate * x))) _ 0)//. +- by rewrite mulr0 expR0 EFinN oppeK add0e. +- by move=> x _; apply: exponential_pdf_ge0. +- exact: within_continuous_exponential_pdf. +- rewrite -oppr0; apply: (@cvgN _ R^o). + rewrite (_ : (fun x => expR (- rate * x)) = + (fun z => expR (- z)) \o (fun z => rate * z)); last first. + by apply: eq_fun => x; rewrite mulNr. + apply: (@cvg_comp _ R^o _ _ _ _ (pinfty_nbhs R)); last exact: cvgr_expR. + exact: gt0_cvgMry. +- by apply: (@cvgN _ R^o); apply: cvg_at_right_filter; exact: cexpNM. +- exact: derive1_exponential_pdf. +Qed. + +Lemma integrable_exponential_pdf : + mu.-integrable setT (EFin \o (exponential_pdf rate)). +Proof. +have mEex : measurable_fun setT (EFin \o exponential_pdf rate). + by apply/measurable_EFinP; exact: measurable_exponential_pdf. +apply/integrableP; split => //. +under eq_integral do rewrite /= ger0_norm ?exponential_pdf_ge0//. +by rewrite /= integral_exponential_pdf ltry. +Qed. + +Local Notation exponential := (exponential_prob rate). + +Let exponential0 : exponential set0 = 0%E. +Proof. by rewrite /exponential integral_set0. Qed. + +Let exponential_ge0 A : (0 <= exponential A)%E. +Proof. +rewrite /exponential integral_ge0//= => x _. +by rewrite lee_fin exponential_pdf_ge0. +Qed. + +Let exponential_sigma_additive : semi_sigma_additive exponential. +Proof. +move=> /= F mF tF mUF; rewrite /exponential; apply: cvg_toP. + apply: ereal_nondecreasing_is_cvgn => m n mn. + apply: lee_sum_nneg_natr => // k _ _; apply: integral_ge0 => /= x Fkx. + by rewrite lee_fin; apply: exponential_pdf_ge0. +rewrite ge0_integral_bigcup//=. +- apply/measurable_funTS/measurableT_comp => //. + exact: measurable_exponential_pdf. +- by move=> x _; rewrite lee_fin exponential_pdf_ge0. +Qed. + +HB.instance Definition _ := isMeasure.Build _ _ _ + exponential exponential0 exponential_ge0 exponential_sigma_additive. + +Let exponential_setT : exponential [set: R] = 1%E. +Proof. by rewrite /exponential integral_exponential_pdf. Qed. + +HB.instance Definition _ := + @Measure_isProbability.Build _ _ R exponential exponential_setT. + +End exponential_prob. + +Section poisson_pmf. +Local Open Scope ring_scope. +Context {R : realType}. +Implicit Types (rate : R) (k : nat). + +Definition poisson_pmf rate k : R := + (rate ^+ k) * k`!%:R^-1 * expR (- rate). + +Lemma poisson_pmf_ge0 rate k : 0 <= rate -> 0 <= poisson_pmf rate k. +Proof. by move=> r0; rewrite /poisson_pmf 2?mulr_ge0// exprn_ge0. Qed. + +End poisson_pmf. + +Lemma measurable_poisson_pmf {R : realType} D (rate : R) k : + measurable_fun D (@poisson_pmf R ^~ k). +Proof. +apply: measurable_funM; first exact: measurable_funM. +by apply: measurable_funTS; exact: measurableT_comp. +Qed. + +Definition poisson_prob {R : realType} (rate : R) (k : nat) + : set nat -> \bar R := + fun U => if 0 <= rate then + \esum_(k in U) (poisson_pmf rate k)%:E else \d_0%N U. + +Section poisson. +Context {R : realType} (rate : R) (k : nat). +Local Open Scope ereal_scope. + +Local Notation poisson := (poisson_prob rate k). + +Let poisson0 : poisson set0 = 0. +Proof. by rewrite /poisson measure0; case: ifPn => //; rewrite esum_set0. Qed. + +Let poisson_ge0 U : 0 <= poisson U. +Proof. +rewrite /poisson; case: ifPn => // rate0; apply: esum_ge0 => /= n Un. +by rewrite lee_fin poisson_pmf_ge0. +Qed. + +Let poisson_sigma_additive : semi_sigma_additive poisson. +Proof. +move=> F mF tF mUF; rewrite /poisson; case: ifPn => rate0; last first. + exact: measure_semi_sigma_additive. +apply: cvg_toP. + apply: ereal_nondecreasing_is_cvgn => a b ab. + apply: lee_sum_nneg_natr => // n _ _. + by apply: esum_ge0 => /= ? _; exact: poisson_pmf_ge0. +by rewrite nneseries_sum_bigcup// => i; rewrite lee_fin poisson_pmf_ge0. +Qed. + +HB.instance Definition _ := isMeasure.Build _ _ _ poisson + poisson0 poisson_ge0 poisson_sigma_additive. + +Let poisson_setT : poisson [set: nat] = 1. +Proof. +rewrite /poisson; case: ifPn => [rate0|_]; last by rewrite probability_setT. +rewrite [RHS](_ : _ = (expR (- rate))%:E * (expR rate)%:E); last first. + by rewrite -EFinM expRN mulVf ?gt_eqF ?expR_gt0. +rewrite -nneseries_esumT; last by move=> *; rewrite lee_fin poisson_pmf_ge0. +under eq_eseriesr do rewrite EFinM muleC. +rewrite nneseriesZl/=; last by move=> *; rewrite lee_fin divr_ge0// exprn_ge0. +congr *%E; rewrite expRE -EFin_lim; last first. + rewrite /pseries/=; under eq_fun do rewrite mulrC. + exact: is_cvg_series_exp_coeff. +apply/congr_lim/funext => n/=; rewrite /pseries/= /series/= -sumEFin//. +by under eq_bigr do rewrite mulrC. +Qed. + +HB.instance Definition _ := + @Measure_isProbability.Build _ _ R poisson poisson_setT. + +End poisson. + +Lemma measurable_poisson_prob {R : realType} n : + measurable_fun setT (poisson_prob ^~ n : R -> pprobability _ _). +Proof. +apply: (measurability (@pset _ _ _ : set (set (pprobability _ R)))) => //. +move=> _ -[_ [r r01] [Ys mYs <-]] <-; apply: emeasurable_fun_infty_o => //=. +apply: measurable_fun_if => //=; first exact: measurable_fun_ler. +apply: (eq_measurable_fun (fun t => + \sum_(k x /set_mem[_/= x01]. + by rewrite nneseries_esum ?set_mem_set// =>*; rewrite lee_fin poisson_pmf_ge0. +apply: ge0_emeasurable_sum. + by move=> k x/= [_ x01] _; rewrite lee_fin poisson_pmf_ge0. +by move=> k Ysk; apply/measurableT_comp => //; exact: measurable_poisson_pmf. +Qed. diff --git a/theories/probability_lscdf_20250703.v b/theories/probability_lscdf_20250703.v new file mode 100644 index 0000000000..fe44df0ad1 --- /dev/null +++ b/theories/probability_lscdf_20250703.v @@ -0,0 +1,1929 @@ +(* mathcomp analysis (c) 2025 Inria and AIST. License: CeCILL-C. *) +From HB Require Import structures. +From mathcomp Require Import all_ssreflect ssralg. +From mathcomp Require Import poly ssrnum ssrint interval archimedean finmap. +From mathcomp Require Import mathcomp_extra unstable boolp classical_sets. +From mathcomp Require Import functions cardinality fsbigop. +From mathcomp Require Import exp numfun lebesgue_measure lebesgue_integral. +From mathcomp Require Import reals interval_inference ereal topology normedtype. +From mathcomp Require Import sequences derive esum measure exp trigo realfun. +From mathcomp Require Import numfun lebesgue_measure lebesgue_integral kernel. +From mathcomp Require Import ftc gauss_integral hoelder. + +(**md**************************************************************************) +(* # Probability *) +(* *) +(* This file provides basic notions of probability theory. See measure.v for *) +(* the type probability T R (a measure that sums to 1). *) +(* *) +(* About integrability: as a rule of thumb, in this file, we favor the use *) +(* of `Lfun P n` hypotheses instead of the `integrable` predicate from *) +(* `lebesgue_integral.v`. *) +(* *) +(* ``` *) +(* {RV P >-> T'} == random variable: a measurable function to the *) +(* measurableType T' from the measured space *) +(* characterized by the probability P *) +(* distribution P X == measure image of the probability measure P by the *) +(* random variable X : {RV P -> T'} *) +(* P as type probability T R with T of type *) +(* measurableType. *) +(* Declared as an instance of probability measure. *) +(* 'E_P[X] == expectation of the real measurable function X *) +(* covariance X Y == covariance between real random variable X and Y *) +(* 'V_P[X] == variance of the real random variable X *) +(* 'M_P X == moment generating function of the random variable X *) +(* with sample space corresponding to the probability *) +(* measure P *) +(* {dmfun T >-> R} == type of discrete real-valued measurable functions *) +(* {dRV P >-> R} == real-valued discrete random variable *) +(* dRV_dom X == domain of the discrete random variable X *) +(* dRV_enum X == bijection between the domain and the range of X *) +(* pmf X r := fine (P (X @^-1` [set r])) *) +(* cdf X r == cumulative distribution function of X *) +(* := distribution P X `]-oo, r] *) +(* enum_prob X k == probability of the kth value in the range of X *) +(* ``` *) +(* *) +(* ``` *) +(* bernoulli_pmf p == Bernoulli pmf with parameter p : R *) +(* bernoulli p == Bernoulli probability measure when 0 <= p <= 1 *) +(* and \d_false otherwise *) +(* binomial_pmf n p == binomial pmf with parameters n : nat and p : R *) +(* binomial_prob n p == binomial probability measure when 0 <= p <= 1 *) +(* and \d_0%N otherwise *) +(* bin_prob n k p == $\binom{n}{k}p^k (1-p)^(n-k)$ *) +(* Computes a binomial distribution term for *) +(* k successes in n trials with success rate p *) +(* uniform_pdf a b == uniform pdf over the interval [a,b] *) +(* uniform_prob a b ab == uniform probability over the interval [a,b] *) +(* where ab0 a proof that 0 < b - a *) +(* normal_peak s := (sqrtr (s ^+ 2 * pi *+ 2))^-1 *) +(* normal_fun m s x := expR (- (x - m) ^+ 2 / (s ^+ 2 *+ 2)) *) +(* normal_pdf m s == pdf of the normal distribution with mean m and *) +(* standard deviation s *) +(* Using normal_peak and normal_pdf. *) +(* normal_prob m s == normal probability measure *) +(* exponential_pdf r == pdf of the exponential distribution with rate r *) +(* exponential_prob r == exponential probability measure *) +(* ``` *) +(* *) +(******************************************************************************) + +Reserved Notation "'{' 'RV' P >-> R '}'" + (at level 0, format "'{' 'RV' P '>->' R '}'"). +Reserved Notation "''E_' P [ X ]" (format "''E_' P [ X ]"). +Reserved Notation "''V_' P [ X ]" (format "''V_' P [ X ]"). +Reserved Notation "'M_ P X" (at level 5, P, X at level 4, format "''M_' P X"). +Reserved Notation "{ 'dmfun' aT >-> T }" (format "{ 'dmfun' aT >-> T }"). +Reserved Notation "'{' 'dRV' P >-> R '}'" (format "'{' 'dRV' P '>->' R '}'"). + +Set Implicit Arguments. +Unset Strict Implicit. +Unset Printing Implicit Defensive. + +Import Order.TTheory GRing.Theory Num.Def Num.Theory. +Import numFieldTopology.Exports. + +Local Open Scope classical_set_scope. +Local Open Scope ring_scope. + +Definition random_variable d d' (T : measurableType d) (T' : measurableType d') + (R : realType) (P : probability T R) := {mfun T >-> T'}. + +Notation "{ 'RV' P >-> T' }" := (@random_variable _ _ _ T' _ P) : form_scope. + +Lemma notin_range_measure d d' (T : measurableType d) (T' : measurableType d') + (R : realType) (P : {measure set T -> \bar R}) (X : T -> R) r : + r \notin range X -> P (X @^-1` [set r]) = 0%E. +Proof. by rewrite notin_setE => hr; rewrite preimage10. Qed. + +Lemma probability_range d d' (T : measurableType d) (T' : measurableType d') + (R : realType) (P : probability T R) (X : {RV P >-> R}) : + P (X @^-1` range X) = 1%E. +Proof. by rewrite preimage_range probability_setT. Qed. + +Definition distribution d d' (T : measurableType d) (T' : measurableType d') + (R : realType) (P : probability T R) (X : {mfun T >-> T'}) := + pushforward P X. + +Section distribution_is_probability. +Context d d' {T : measurableType d} {T' : measurableType d'} {R : realType} + {P : probability T R}. +Variable X : {mfun T >-> T'}. + +Let distribution0 : distribution P X set0 = 0%E. +Proof. exact: measure0. Qed. + +Let distribution_ge0 A : (0 <= distribution P X A)%E. +Proof. exact: measure_ge0. Qed. + +Let distribution_sigma_additive : semi_sigma_additive (distribution P X). +Proof. exact: measure_semi_sigma_additive. Qed. + +HB.instance Definition _ := isMeasure.Build _ _ _ (distribution P X) + distribution0 distribution_ge0 distribution_sigma_additive. + +Let distribution_is_probability : distribution P X [set: _] = 1%:E. +Proof. +by rewrite /distribution /= /pushforward /= preimage_setT probability_setT. +Qed. + +HB.instance Definition _ := Measure_isProbability.Build _ _ _ + (distribution P X) distribution_is_probability. + +End distribution_is_probability. + +Section transfer_probability. +Local Open Scope ereal_scope. +Context d d' {T : measurableType d} {T' : measurableType d'} {R : realType} + (P : probability T R). + +Lemma probability_distribution (X : {RV P >-> T'}) r : + P [set x | X x = r] = distribution P X [set r]. +Proof. by []. Qed. + +Lemma ge0_integral_distribution (X : {RV P >-> T'}) (f : T' -> \bar R) : + measurable_fun [set: T'] f -> (forall y, 0 <= f y) -> + \int[distribution P X]_y f y = \int[P]_x (f \o X) x. +Proof. by move=> mf f0; rewrite ge0_integral_pushforward. Qed. + +Lemma integral_distribution (X : {RV P >-> T'}) (f : T' -> \bar R) : + measurable_fun [set: T'] f -> P.-integrable [set: T] (f \o X) -> + \int[distribution P X]_y f y = \int[P]_x (f \o X) x. +Proof. by move=> mf intf; rewrite integral_pushforward. Qed. + +End transfer_probability. + +Definition cdf d (T : measurableType d) (R : realType) (P : probability T R) + (X : {RV P >-> R}) (r : R) := distribution P X `]-oo, r]. + +Section cumulative_distribution_function. +Context d {T : measurableType d} {R : realType} (P : probability T R). +Variable X : {RV P >-> R}. +Local Open Scope ereal_scope. + +Lemma cdf_ge0 r : 0 <= cdf X r. Proof. by []. Qed. + +Lemma cdf_le1 r : cdf X r <= 1. Proof. exact: probability_le1. Qed. + +Lemma cdf_nondecreasing : nondecreasing_fun (cdf X). +Proof. by move=> r s rs; rewrite le_measure ?inE//; exact: subitvPr. Qed. + +Lemma cvg_cdfy1 : cdf X @ +oo%R --> 1. +Proof. +pose s : \bar R := ereal_sup (range (cdf X)). +have cdf_s : cdf X r @[r --> +oo%R] --> s. + exact: nondecreasing_cvge cdf_nondecreasing. +have cdf_ns : cdf X n%:R @[n --> \oo%R] --> s. + by move/cvge_pinftyP : cdf_s; apply; exact/cvgryPge/nbhs_infty_ger. +have cdf_n1 : cdf X n%:R @[n --> \oo] --> 1. + rewrite -(probability_setT P). + pose F n := X @^-1` `]-oo, n%:R]. + have <- : \bigcup_n F n = setT. + rewrite -preimage_bigcup -subTset => t _/=. + by exists (trunc (X t)).+1 => //=; rewrite in_itv/= ltW// truncnS_gt. + apply: nondecreasing_cvg_mu => //; first exact: bigcup_measurable. + move=> n m nm; apply/subsetPset => x/=; rewrite !in_itv/= => /le_trans. + by apply; rewrite ler_nat. +by rewrite -(cvg_unique _ cdf_ns cdf_n1). +Qed. + +Lemma cvg_cdfNy0 : cdf X @ -oo%R --> 0. +Proof. +rewrite cvgNy_compNP. +have cdf_opp_noninc : {homo cdf X \o -%R : q r / (q <= r)%R >-> q >= r}. + by move=> q r; rewrite -lterN2; exact: cdf_nondecreasing. +pose s := ereal_inf (range (cdf X \o -%R)). +have cdf_opp_s : (cdf X \o -%R) r @[r --> +oo%R] --> s. + exact: nonincreasing_cvge cdf_opp_noninc. +have cdf_opp_ns : (cdf X \o -%R) n%:R @[n --> \oo] --> s. + by move/cvge_pinftyP : cdf_opp_s; apply; exact/cvgryPge/nbhs_infty_ger. +have cdf_opp_n0 : (cdf X \o -%R) n%:R @[n --> \oo] --> 0. + rewrite -(measure0 P). + pose F n := X @^-1` `]-oo, (- n%:R)%R]. + have <- : \bigcap_n F n = set0. + rewrite -subset0 => t. + set m := (trunc `|X t|).+1. + move=> /(_ m I); rewrite /F/= in_itv/= leNgt => /negP; apply. + by rewrite ltrNl /m (le_lt_trans (ler_norm _))// normrN truncnS_gt. + apply: nonincreasing_cvg_mu => //=. + + by rewrite (le_lt_trans (probability_le1 _ _)) ?ltry. + + exact: bigcap_measurable. + + move=> m n mn; apply/subsetPset => x/=; rewrite !in_itv => /le_trans; apply. + by rewrite lerN2 ler_nat. +by rewrite (_ : 0%E = s)// (cvg_unique _ cdf_opp_ns cdf_opp_n0). +Qed. + +Lemma cdf_right_continuous : right_continuous (cdf X). +Proof. +move=> a. +pose s := fine (ereal_inf (cdf X @` `]a, a + 1%R]%classic)). +have cdf_s : cdf X r @[r --> a^'+] --> s%:E. + rewrite /s fineK. + - apply: nondecreasing_at_right_cvge; first by rewrite ltBSide /= ?ltrDl. + by move=> *; exact: cdf_nondecreasing. + - apply/fin_numPlt/andP; split=>//. + + by rewrite (lt_le_trans (ltNyr 0%R)) ?lb_ereal_inf//= => l[? _] <-. + + rewrite (le_lt_trans _ (ltry 1%R))// ereal_inf_le//=. + exists (cdf X (a + 1)); last exact: cdf_le1. + by exists (a + 1%R) => //; rewrite in_itv /=; apply/andP; rewrite ltrDl. +have cdf_ns : cdf X (a + n.+1%:R^-1) @[n --> \oo] --> s%:E. + move/cvge_at_rightP : cdf_s; apply; split=> [n|]; rewrite ?ltrDl //. + rewrite -[X in _ --> X]addr0; apply: (@cvgD _ R^o); first exact: cvg_cst. + by rewrite gtr0_cvgV0 ?cvg_shiftS; [exact: cvgr_idn | near=> n]. +have cdf_na : cdf X (a + n.+1%:R^-1) @[n --> \oo] --> cdf X a. + pose F n := X @^-1` `]-oo, a + n.+1%:R^-1%R]. + suff : P (F n) @[n --> \oo] --> P (\bigcap_n F n). + by rewrite [in X in _ --> X -> _]/F -preimage_bigcap -itvNycEbigcap. + apply: nonincreasing_cvg_mu => [| | |m n mn]. + - by rewrite -ge0_fin_numE// fin_num_measure//; exact: measurable_sfunP. + - by move=> ?; exact: measurable_sfunP. + - by apply: bigcap_measurable => // ? _; exact: measurable_sfunP. + - apply/subsetPset; apply: preimage_subset; apply: subset_itvl. + by rewrite bnd_simp lerD2l lef_pV2 ?posrE// ler_nat. +by rewrite -(cvg_unique _ cdf_ns cdf_na). +Unshelve. all: by end_near. Qed. + +End cumulative_distribution_function. + +Section cdf_of_lebesgue_stieltjes_mesure. +Context {R : realType} (f : cumulative R) + (f_y1 : f @ +oo --> (1:R)) (f_Ny0 : f @ -oo --> (0:R)). +Local Open Scope measure_display_scope. + +Let T := g_sigma_algebraType R.-ocitv.-measurable. +Let lsf := lebesgue_stieltjes_measure f. + +Let lebesgue_stieltjes_setT : lsf setT = 1%E. +Proof. +pose I n := `]-(n%:R):R, n%:R]%classic. +have <- : \bigcup_n I n = setT. + rewrite -subTset=> x _; rewrite /bigcup/=; exists (truncn`|x|).+1=>//. + by rewrite /I/= subset_itv_oo_oc// in_itv/= -real_ltr_norml//= truncnS_gt. +have cvg_cup : (lsf \o I) n @[n --> \oo] --> lsf (\bigcup_n I n). + apply: nondecreasing_cvg_mu; rewrite /I//; first exact: bigcup_measurable. + by move=> *; apply/subsetPset/subset_itv; rewrite leBSide/= ?lerN2 ler_nat. +have cvg_1 : (lsf \o I) n @[n --> \oo] --> 1%E. + rewrite /comp/I/lsf/lebesgue_stieltjes_measure/measure_extension/=. + suff : ((f n%:R)%:E - (f (1 *- n))%:E)%E @[n --> \oo] --> 1%E => ?. + under eq_cvg=> n. + rewrite measurable_mu_extE/=; last exact: is_ocitv. + rewrite wlength_itv_bnd; last exact: (le_trans _ (ler0n R n)). + over. + assumption. + rewrite -(sube0 1); apply: cvgeB=>//; apply: cvg_EFin; try by near=> F. + by rewrite /comp; apply/(cvg_comp _ _ (@cvgr_idn R))/f_y1. + rewrite /comp/=; apply: ((iffLR (cvg_ninftyP _ _)) f_Ny0). + by apply: (cvg_comp _ _ (@cvgr_idn R)); rewrite ninfty. +by rewrite -(cvg_unique _ cvg_cup cvg_1). +Unshelve. all: end_near. Qed. + +HB.instance Definition _ := @Measure_isProbability.Build _ _ _ + (lebesgue_stieltjes_measure f) lebesgue_stieltjes_setT. + +Let idTR : T -> R := (fun x => x). + +Lemma measurable_idTR : measurable_fun setT idTR. +Proof. by apply: measurable_id. Qed. + +#[local] HB.instance Definition _ := + @isMeasurableFun.Build _ _ T R idTR measurable_idTR. + +Let Xid : {RV lsf >-> R} := idTR. + +Lemma cdf_lebesgue_stieltjes_id r : cdf Xid r = EFin (f r). +Proof. +rewrite /= preimage_id. +have <- : (\bigcup_n `]-n%:R, r]%classic) = `]-oo, r]%classic. + apply/seteqP; split=> x/=; first by case=> n _/=; rewrite !in_itv/=; case/andP. + rewrite in_itv/= => xr; exists (truncn`|x|).+1=>//=; rewrite in_itv/=. + apply/andP; split=>//; rewrite ltrNl -normrN. + apply: le_lt_trans; [exact: ler_norm | exact: truncnS_gt]. +have cvg_cup : (lsf `]-n%:R, r])@[n --> \oo] --> + lsf (\bigcup_n `]-n%:R, r]%classic). + apply: nondecreasing_cvg_mu; rewrite /I//; first exact: bigcup_measurable. + by move=> *; apply/subsetPset/subset_itv; rewrite leBSide//= lerN2 ler_nat//. +have cvg_fr : (lsf `]-n%:R, r])@[n --> \oo] --> (f r)%:E. + suff : ((f r)%:E - (f (-n%:R))%:E)%E@[n --> \oo] --> (f r)%:E. + apply: cvg_trans; apply: near_eq_cvg; near=> n. + rewrite /lsf/lebesgue_stieltjes_measure/measure_extension/=. + rewrite measurable_mu_extE/= ?wlength_itv_bnd//; last exact: is_ocitv. + near: n; exists (truncn`|r|).+1=>// n/=; rewrite truncn_lt_nat// lerNl. + by move/ltW; apply /le_trans; rewrite -normrN ler_norm. + rewrite -[X in _ --> X](sube0 (f r)%:E). + apply: cvgeB=>//; first exact: cvg_cst. + apply: cvg_comp; [apply: cvg_comp; last exact: f_Ny0 | by[]]. + by apply: cvg_comp; [exact: cvgr_idn | rewrite ninfty]. +by rewrite -(cvg_unique _ cvg_cup cvg_fr). +Unshelve. all: by end_near. Qed. + +End cdf_of_lebesgue_stieltjes_mesure. + +HB.lock Definition expectation {d} {T : measurableType d} {R : realType} + (P : probability T R) (X : T -> R) := (\int[P]_w (X w)%:E)%E. +Canonical expectation_unlockable := Unlockable expectation.unlock. +Arguments expectation {d T R} P _%_R. +Notation "''E_' P [ X ]" := (@expectation _ _ _ P X) : ereal_scope. + +Section expectation_lemmas. +Local Open Scope ereal_scope. +Context d (T : measurableType d) (R : realType) (P : probability T R). + +Lemma expectation_def (X : {RV P >-> R}) : 'E_P[X] = (\int[P]_w (X w)%:E)%E. +Proof. by rewrite unlock. Qed. + +Lemma expectation_fin_num (X : T -> R) : X \in Lfun P 1 -> + 'E_P[X] \is a fin_num. +Proof. +by move=> ?; rewrite unlock integral_fune_fin_num//; exact/Lfun1_integrable. +Qed. + +Lemma expectation_cst r : 'E_P[cst r] = r%:E. +Proof. by rewrite unlock/= integral_cst//= probability_setT mule1. Qed. + +Lemma expectation_indic (A : set T) (mA : measurable A) : 'E_P[\1_A] = P A. +Proof. by rewrite unlock integral_indic// setIT. Qed. + +Lemma integrable_expectation (X : {RV P >-> R}) + (iX : P.-integrable [set: T] (EFin \o X)) : `| 'E_P[X] | < +oo. +Proof. +move: iX => /integrableP[? Xoo]; rewrite (le_lt_trans _ Xoo)// unlock. +exact: le_trans (le_abse_integral _ _ _). +Qed. + +Lemma expectationZl (X : T -> R) (k : R) : X \in Lfun P 1 -> + 'E_P[k \o* X] = k%:E * 'E_P [X]. +Proof. +by move=> ?; rewrite unlock muleC -integralZr//; exact/Lfun1_integrable. +Qed. + +Lemma expectation_ge0 (X : T -> R) : (forall x, 0 <= X x)%R -> + 0 <= 'E_P[X]. +Proof. +by move=> ?; rewrite unlock integral_ge0// => x _; rewrite lee_fin. +Qed. + +Lemma expectation_le (X Y : T -> R) : + measurable_fun [set: T] X -> measurable_fun [set: T] Y -> + (forall x, 0 <= X x)%R -> (forall x, 0 <= Y x)%R -> + {ae P, (forall x, X x <= Y x)%R} -> 'E_P[X] <= 'E_P[Y]. +Proof. +move=> mX mY X0 Y0 XY; rewrite unlock ae_ge0_le_integral => //. +- by move=> t _; apply: X0. +- exact/measurable_EFinP. +- by move=> t _; apply: Y0. +- exact/measurable_EFinP. +- move: XY => [N [mN PN XYN]]; exists N; split => // t /= h. + by apply: XYN => /=; apply: contra_not h; rewrite lee_fin. +Qed. + +Lemma expectationD (X Y : T -> R) : X \in Lfun P 1 -> Y \in Lfun P 1 -> + 'E_P[X \+ Y] = 'E_P[X] + 'E_P[Y]. +Proof. +by move=> ? ?; rewrite unlock integralD_EFin//; exact/Lfun1_integrable. +Qed. + +Lemma expectationB (X Y : T -> R) : X \in Lfun P 1 -> Y \in Lfun P 1 -> + 'E_P[X \- Y] = 'E_P[X] - 'E_P[Y]. +Proof. +by move=> ? ?; rewrite unlock integralB_EFin//; exact/Lfun1_integrable. +Qed. + +Lemma expectation_sum (X : seq (T -> R)) : + (forall Xi, Xi \in X -> Xi \in Lfun P 1) -> + 'E_P[\sum_(Xi <- X) Xi] = \sum_(Xi <- X) 'E_P[Xi]. +Proof. +elim: X => [|X0 X IHX] intX; first by rewrite !big_nil expectation_cst. +rewrite !big_cons expectationD; last 2 first. + by rewrite intX// mem_head. + by rewrite big_seq rpred_sum// => Y YX/=; rewrite intX// inE YX orbT. +by rewrite IHX//= => Xi XiX; rewrite intX// inE XiX orbT. +Qed. + +End expectation_lemmas. +#[deprecated(since="mathcomp-analysis 1.8.0", note="renamed to `expectationZl`")] +Notation expectationM := expectationZl (only parsing). + +HB.lock Definition covariance {d} {T : measurableType d} {R : realType} + (P : probability T R) (X Y : T -> R) := + 'E_P[(X \- cst (fine 'E_P[X])) * (Y \- cst (fine 'E_P[Y]))]%E. +Canonical covariance_unlockable := Unlockable covariance.unlock. +Arguments covariance {d T R} P _%_R _%_R. + +Hint Extern 0 (fin_num_fun _) => + (apply: fin_num_measure) : core. + +Section covariance_lemmas. +Local Open Scope ereal_scope. +Context d (T : measurableType d) (R : realType) (P : probability T R). + +Lemma covarianceE (X Y : T -> R) : + X \in Lfun P 1 -> Y \in Lfun P 1 -> + (X * Y)%R \in Lfun P 1 -> + covariance P X Y = 'E_P[X * Y] - 'E_P[X] * 'E_P[Y]. +Proof. +move=> l1X l1Y l1XY. +rewrite unlock [X in 'E_P[X]](_ : _ = (X \* Y \- fine 'E_P[X] \o* Y + \- fine 'E_P[Y] \o* X \+ fine ('E_P[X] * 'E_P[Y]) \o* cst 1)%R); last first. + apply/funeqP => x /=; rewrite mulrDr !mulrDl/= mul1r. + rewrite fineM ?expectation_fin_num// mulrNN addrA. + by rewrite mulrN mulNr [Z in (X x * Y x - Z)%R]mulrC. +rewrite expectationD/= ?rpredB//= ?Lfun_scale ?Lfun_cst//. +rewrite 2?expectationB//= ?rpredB ?Lfun_scale// 3?expectationZl//= ?Lfun_cst//. +rewrite expectation_cst mule1 fineM ?expectation_fin_num// EFinM. +rewrite !fineK ?expectation_fin_num//. +by rewrite muleC subeK ?fin_numM ?expectation_fin_num. +Qed. + +Lemma covarianceC (X Y : T -> R) : covariance P X Y = covariance P Y X. +Proof. +by rewrite unlock; congr expectation; apply/funeqP => x /=; rewrite mulrC. +Qed. + +Lemma covariance_fin_num (X Y : T -> R) : + X \in Lfun P 1 -> Y \in Lfun P 1 -> + (X * Y)%R \in Lfun P 1 -> + covariance P X Y \is a fin_num. +Proof. +by move=> ? ? ?; rewrite covarianceE// fin_numB fin_numM expectation_fin_num. +Qed. + +Lemma covariance_cst_l c (X : T -> R) : covariance P (cst c) X = 0. +Proof. +rewrite unlock expectation_cst/=. +rewrite [X in 'E_P[X]](_ : _ = cst 0%R) ?expectation_cst//. +by apply/funeqP => x; rewrite /GRing.mul/= subrr mul0r. +Qed. + +Lemma covariance_cst_r (X : T -> R) c : covariance P X (cst c) = 0. +Proof. by rewrite covarianceC covariance_cst_l. Qed. + +Lemma covarianceZl a (X Y : T -> R) : + X \in Lfun P 1 -> Y \in Lfun P 1 -> + (X * Y)%R \in Lfun P 1 -> + covariance P (a \o* X)%R Y = a%:E * covariance P X Y. +Proof. +move=> X1 Y1 XY1. +have aXY : (a \o* X * Y = a \o* (X * Y))%R by apply/funeqP => x; rewrite mulrAC. +rewrite [LHS]covarianceE => [||//|] //=; last 2 first. +- by rewrite Lfun_scale. +- by rewrite aXY Lfun_scale. +rewrite covarianceE// aXY !expectationZl//. +by rewrite -muleA -muleBr// fin_num_adde_defr// expectation_fin_num. +Qed. + +Lemma covarianceZr a (X Y : T -> R) : X \in Lfun P 1 -> Y \in Lfun P 1 -> + (X * Y)%R \in Lfun P 1 -> + covariance P X (a \o* Y)%R = a%:E * covariance P X Y. +Proof. +move=> X1 Y1 XY1. +by rewrite [in RHS]covarianceC covarianceC covarianceZl; last rewrite mulrC. +Qed. + +Lemma covarianceNl (X Y : T -> R) : X \in Lfun P 1 -> Y \in Lfun P 1 -> + (X * Y)%R \in Lfun P 1 -> + covariance P (\- X)%R Y = - covariance P X Y. +Proof. +move=> X1 Y1 XY1. +have -> : (\- X = -1 \o* X)%R by apply/funeqP => x /=; rewrite mulrN mulr1. +by rewrite covarianceZl// EFinN mulNe mul1e. +Qed. + +Lemma covarianceNr (X Y : T -> R) : X \in Lfun P 1 -> Y \in Lfun P 1 -> + (X * Y)%R \in Lfun P 1 -> + covariance P X (\- Y)%R = - covariance P X Y. +Proof. by move=> X1 Y1 XY1; rewrite !(covarianceC X) covarianceNl 1?mulrC. Qed. + +Lemma covarianceNN (X Y : T -> R) : X \in Lfun P 1 -> Y \in Lfun P 1 -> + (X * Y)%R \in Lfun P 1 -> + covariance P (\- X)%R (\- Y)%R = covariance P X Y. +Proof. +by move=> ? ? ?; rewrite covarianceNl//= ?covarianceNr ?oppeK ?mulrN//= ?rpredN. +Qed. + +Lemma covarianceDl (X Y Z : T -> R) : + X \in Lfun P 2%:E -> Y \in Lfun P 2%:E -> Z \in Lfun P 2%:E -> + covariance P (X \+ Y)%R Z = covariance P X Z + covariance P Y Z. +Proof. +move=> X2 Y2 Z2. +have Pfin : P setT \is a fin_num := fin_num_measure P _ measurableT. +have X1 := Lfun_subset12 Pfin X2. +have Y1 := Lfun_subset12 Pfin Y2. +have Z1 := Lfun_subset12 Pfin Z2. +have XY1 := Lfun2_mul_Lfun1 X2 Y2. +have YZ1 := Lfun2_mul_Lfun1 Y2 Z2. +have XZ1 := Lfun2_mul_Lfun1 X2 Z2. +rewrite [LHS]covarianceE//= ?mulrDl ?compreDr ?rpredD//= 2?expectationD//=. +rewrite muleDl ?fin_num_adde_defr ?expectation_fin_num//. +rewrite oppeD ?fin_num_adde_defr ?fin_numM ?expectation_fin_num//. +by rewrite addeACA 2?covarianceE. +Qed. + +Lemma covarianceDr (X Y Z : T -> R) : + X \in Lfun P 2%:E -> Y \in Lfun P 2%:E -> Z \in Lfun P 2%:E -> + covariance P X (Y \+ Z)%R = covariance P X Y + covariance P X Z. +Proof. +by move=> X2 Y2 Z2; rewrite covarianceC covarianceDl ?(covarianceC X) 1?mulrC. +Qed. + +Lemma covarianceBl (X Y Z : T -> R) : + X \in Lfun P 2%:E -> Y \in Lfun P 2%:E -> Z \in Lfun P 2%:E -> + covariance P (X \- Y)%R Z = covariance P X Z - covariance P Y Z. +Proof. +move=> X2 Y2 Z2. +have Pfin : P setT \is a fin_num := fin_num_measure P _ measurableT. +have Y1 := Lfun_subset12 Pfin Y2. +have Z1 := Lfun_subset12 Pfin Z2. +have YZ1 := Lfun2_mul_Lfun1 Y2 Z2. +by rewrite -[(X \- Y)%R]/(X \+ (\- Y))%R covarianceDl ?covarianceNl ?rpredN. +Qed. + +Lemma covarianceBr (X Y Z : T -> R) : + X \in Lfun P 2%:E -> Y \in Lfun P 2%:E -> Z \in Lfun P 2%:E -> + covariance P X (Y \- Z)%R = covariance P X Y - covariance P X Z. +Proof. +move=> X2 Y2 Z2. +have Pfin : P setT \is a fin_num := fin_num_measure P _ measurableT. +have Y1 := Lfun_subset12 Pfin Y2. +have Z1 := Lfun_subset12 Pfin Z2. +have YZ1 := Lfun2_mul_Lfun1 Y2 Z2. +by rewrite !(covarianceC X) covarianceBl 1?(mulrC _ X). +Qed. + +End covariance_lemmas. + +Section variance. +Local Open Scope ereal_scope. +Context d (T : measurableType d) (R : realType) (P : probability T R). + +Definition variance (X : T -> R) := covariance P X X. +Local Notation "''V_' P [ X ]" := (variance X). + +Lemma varianceE (X : T -> R) : X \in Lfun P 2%:E -> + 'V_P[X] = 'E_P[X ^+ 2] - ('E_P[X]) ^+ 2. +Proof. +move=> X2; rewrite /variance. +by rewrite covarianceE ?Lfun2_mul_Lfun1// Lfun_subset12 ?fin_num_measure. +Qed. + +Lemma variance_fin_num (X : T -> R) : X \in Lfun P 2%:E -> + 'V_P[X] \is a fin_num. +Proof. +move=> X2. +by rewrite covariance_fin_num ?Lfun2_mul_Lfun1// Lfun_subset12 ?fin_num_measure. +Qed. + +Lemma variance_ge0 (X : T -> R) : 0 <= 'V_P[X]. +Proof. +by rewrite /variance unlock; apply: expectation_ge0 => x; exact: sqr_ge0. +Qed. + +Lemma variance_cst r : 'V_P[cst r] = 0%E. +Proof. +rewrite /variance unlock expectation_cst/=. +rewrite [X in 'E_P[X]](_ : _ = cst 0%R) ?expectation_cst//. +by apply/funext => x; rewrite /GRing.exp/GRing.mul/= subrr mulr0. +Qed. + +Lemma varianceZ a (X : T -> R) : X \in Lfun P 2%:E -> + 'V_P[(a \o* X)%R] = (a ^+ 2)%:E * 'V_P[X]. +Proof. +move=> X2. +have Pfin : P setT \is a fin_num := fin_num_measure P _ measurableT. +have X1 := Lfun_subset12 Pfin X2. +rewrite /variance covarianceZl//=. +- by rewrite covarianceZr// ?muleA ?EFinM// Lfun2_mul_Lfun1. +- by rewrite Lfun_scale. +- by rewrite Lfun2_mul_Lfun1// Lfun_scale// ler1n. +Qed. + +Lemma varianceN (X : T -> R) : X \in Lfun P 2%:E -> 'V_P[(\- X)%R] = 'V_P[X]. +Proof. +move=> X2; rewrite /variance. +by rewrite covarianceNN ?Lfun2_mul_Lfun1 ?Lfun_subset12 ?fin_num_measure. +Qed. + +Lemma varianceD (X Y : T -> R) : X \in Lfun P 2%:E -> Y \in Lfun P 2%:E -> + 'V_P[X \+ Y]%R = 'V_P[X] + 'V_P[Y] + 2%:E * covariance P X Y. +Proof. +move=> X2 Y2. +have Pfin : P setT \is a fin_num := fin_num_measure P _ measurableT. +have X1 := Lfun_subset12 Pfin X2. +have Y1 := Lfun_subset12 Pfin Y2. +have XY1 := Lfun2_mul_Lfun1 X2 Y2. +rewrite -['V_P[_]]/(covariance P (X \+ Y)%R (X \+ Y)%R). +rewrite covarianceDl ?rpredD ?lee1n//= covarianceDr// covarianceDr//. +rewrite (covarianceC P Y X) [LHS]addeA [LHS](ACl (1*4*(2*3)))/=. +by rewrite -[2%R]/(1 + 1)%R EFinD muleDl ?mul1e// covariance_fin_num. +Qed. + +Lemma varianceB (X Y : T -> R) : X \in Lfun P 2%:E -> Y \in Lfun P 2%:E -> + 'V_P[(X \- Y)%R] = 'V_P[X] + 'V_P[Y] - 2%:E * covariance P X Y. +Proof. +move=> X2 Y2. +have Pfin : P setT \is a fin_num := fin_num_measure P _ measurableT. +have X1 := Lfun_subset12 Pfin X2. +have Y1 := Lfun_subset12 Pfin Y2. +have XY1 := Lfun2_mul_Lfun1 X2 Y2. +rewrite -[(X \- Y)%R]/(X \+ (\- Y))%R. +by rewrite varianceD/= ?varianceN ?covarianceNr ?muleN ?rpredN. +Qed. + +Lemma varianceD_cst_l c (X : T -> R) : X \in Lfun P 2%:E -> + 'V_P[(cst c \+ X)%R] = 'V_P[X]. +Proof. +move=> X2. +by rewrite varianceD ?Lfun_cst// variance_cst add0e covariance_cst_l mule0 adde0. +Qed. + +Lemma varianceD_cst_r (X : T -> R) c : X \in Lfun P 2%:E -> + 'V_P[(X \+ cst c)%R] = 'V_P[X]. +Proof. +move=> X2. +have -> : (X \+ cst c = cst c \+ X)%R by apply/funeqP => x /=; rewrite addrC. +exact: varianceD_cst_l. +Qed. + +Lemma varianceB_cst_l c (X : T -> R) : X \in Lfun P 2%:E -> + 'V_P[(cst c \- X)%R] = 'V_P[X]. +Proof. +move=> X2; rewrite -[(cst c \- X)%R]/(cst c \+ (\- X))%R. +by rewrite varianceD_cst_l/= ?rpredN// varianceN. +Qed. + +Lemma varianceB_cst_r (X : T -> R) c : X \in Lfun P 2%:E -> + 'V_P[(X \- cst c)%R] = 'V_P[X]. +Proof. +by move=> X2; rewrite -[(X \- cst c)%R]/(X \+ (cst (- c)))%R varianceD_cst_r. +Qed. + +Lemma covariance_le (X Y : T -> R) : X \in Lfun P 2%:E -> Y \in Lfun P 2%:E -> + covariance P X Y <= sqrte 'V_P[X] * sqrte 'V_P[Y]. +Proof. +move=> X2 Y2. +have Pfin : P setT \is a fin_num := fin_num_measure P _ measurableT. +have X1 := Lfun_subset12 Pfin X2. +have Y1 := Lfun_subset12 Pfin Y2. +have XY1 := Lfun2_mul_Lfun1 X2 Y2. +rewrite -sqrteM ?variance_ge0//. +rewrite lee_sqrE ?sqrte_ge0// sqr_sqrte ?mule_ge0 ?variance_ge0//. +rewrite -(fineK (variance_fin_num X2)) -(fineK (variance_fin_num Y2)). +rewrite -(fineK (covariance_fin_num X1 Y1 XY1)). +rewrite -EFin_expe -EFinM lee_fin -(@ler_pM2l _ 4) ?ltr0n// [leRHS]mulrA. +rewrite [in leLHS](_ : 4 = 2 * 2)%R -natrM// [in leLHS]natrM mulrACA -expr2. +rewrite -subr_le0. +set a := fine (variance X). +set b := (2 * fine (covariance P X Y))%R. +set c := fine (variance Y). +pose p := Poly [:: c; b; a]. +have -> : a = p`_2 by rewrite !coefE. +have -> : b = p`_1 by rewrite !coefE. +have -> : c = p`_0 by rewrite !coefE. +rewrite deg_le2_poly_ge0 ?size_Poly// => r. +rewrite horner_Poly/= mul0r add0r mulrDl -mulrA -expr2. +rewrite -lee_fin !EFinD EFinM fineK ?variance_fin_num// muleC -varianceZ//. +rewrite 2!EFinM ?fineK ?variance_fin_num// ?covariance_fin_num//. +rewrite -muleA [_ * r%:E]muleC -covarianceZl//. +rewrite addeAC -varianceD ?variance_ge0//=. +by rewrite Lfun_scale// ler1n. +Qed. + +End variance. +Notation "'V_ P [ X ]" := (variance P X). + +Definition mmt_gen_fun d (T : measurableType d) (R : realType) + (P : probability T R) (X : T -> R) (t : R) := ('E_P[expR \o t \o* X])%E. +Notation "'M_ P X" := (@mmt_gen_fun _ _ _ P X). + +Section markov_chebyshev_cantelli. +Local Open Scope ereal_scope. +Context d (T : measurableType d) (R : realType) (P : probability T R). + +Lemma markov (X : {RV P >-> R}) (f : R -> R) (eps : R) : (0 < eps)%R -> + measurable_fun [set: R] f -> (forall r, 0 <= r -> 0 <= f r)%R -> + {in Num.nneg &, {homo f : x y / x <= y}}%R -> + (f eps)%:E * P [set x | eps%:E <= `| (X x)%:E | ] <= + 'E_P[f \o (fun x => `| x |%R) \o X]. +Proof. +move=> e0 mf f0 f_nd; rewrite -(setTI [set _ | _]). +apply: (le_trans (@le_integral_comp_abse _ _ _ P _ measurableT (EFin \o X) + eps (er_map f) _ _ _ _ e0)) => //=. +- exact: measurable_er_map. +- by case => //= r _; exact: f0. +- move=> [x| |] [y| |]; rewrite !inE/= !in_itv/= ?andbT ?lee_fin ?leey//. + by move=> ? ? ?; rewrite f_nd. +- exact/measurable_EFinP. +- by rewrite unlock. +Qed. + +Lemma chernoff (X : {RV P >-> R}) (r a : R) : (0 < r)%R -> + P [set x | X x >= a]%R <= 'M_P X r * (expR (- (r * a)))%:E. +Proof. +move=> t0; rewrite /mmt_gen_fun. +have -> : expR \o r \o* X = (normr \o normr) \o (expR \o r \o* X). + by apply: funext => t /=; rewrite normr_id ger0_norm ?expR_ge0. +rewrite expRN lee_pdivlMr ?expR_gt0//. +rewrite (le_trans _ (markov _ (expR_gt0 (r * a)) _ _ _))//; last first. + exact: (monoW_in (@ger0_le_norm _)). +rewrite ger0_norm ?expR_ge0// muleC lee_pmul2l// ?lte_fin ?expR_gt0//. +rewrite [X in _ <= P X](_ : _ = [set x | a <= X x]%R)//; apply: eq_set => t/=. +by rewrite ger0_norm ?expR_ge0// lee_fin ler_expR mulrC ler_pM2r. +Qed. + +Lemma chebyshev (X : {RV P >-> R}) (eps : R) : (0 < eps)%R -> + P [set x | (eps <= `| X x - fine ('E_P[X])|)%R ] <= (eps ^- 2)%:E * 'V_P[X]. +Proof. +move => heps; have [->|hv] := eqVneq 'V_P[X] +oo. + by rewrite mulr_infty gtr0_sg ?mul1e// ?leey// invr_gt0// exprn_gt0. +have h (Y : {RV P >-> R}) : + P [set x | (eps <= `|Y x|)%R] <= (eps ^- 2)%:E * 'E_P[Y ^+ 2]. + rewrite -lee_pdivrMl; last by rewrite invr_gt0// exprn_gt0. + rewrite exprnN expfV exprz_inv opprK -exprnP. + apply: (@le_trans _ _ ('E_P[(@GRing.exp R ^~ 2%N \o normr) \o Y])). + apply: (@markov Y (@GRing.exp R ^~ 2%N)) => //. + - by move=> r _; exact: sqr_ge0. + - move=> x y; rewrite !nnegrE => x0 y0. + by rewrite ler_sqr. + apply: expectation_le. + - by apply: measurableT_comp => //; exact: measurableT_comp. + - by []. + - by move=> x /=; exact: sqr_ge0. + - by move=> x /=; exact: sqr_ge0. + - by apply/aeW => t /=; rewrite real_normK// num_real. +have := h (X \- cst (fine ('E_P[X])))%R. +by move=> /le_trans; apply; rewrite /variance [in leRHS]unlock. +Qed. + +Lemma cantelli (X : {RV P >-> R}) (lambda : R) : + (X : T -> R) \in Lfun P 2%:E -> (0 < lambda)%R -> + P [set x | lambda%:E <= (X x)%:E - 'E_P[X]] + <= (fine 'V_P[X] / (fine 'V_P[X] + lambda^2))%:E. +Proof. +move=> /[dup] X2. +move=> /(Lfun_subset12 (fin_num_measure P _ measurableT)) X1 lambda_gt0. +have finEK : (fine 'E_P[X])%:E = 'E_P[X] by rewrite fineK ?expectation_fin_num. +have finVK : (fine 'V_P[X])%:E = 'V_P[X] by rewrite fineK ?variance_fin_num. +pose Y := (X \- cst (fine 'E_P[X]))%R. +have Y2 : (Y : T -> R) \in Lfun P 2%:E. + by rewrite /Y rpredB ?lee1n//= => _; rewrite Lfun_cst. +have EY : 'E_P[Y] = 0. + rewrite expectationB ?Lfun_cst//= expectation_cst. + by rewrite finEK subee// expectation_fin_num. +have VY : 'V_P[Y] = 'V_P[X] by rewrite varianceB_cst_r. +have le (u : R) : (0 <= u)%R -> + P [set x | lambda%:E <= (X x)%:E - 'E_P[X]] + <= ((fine 'V_P[X] + u^2) / (lambda + u)^2)%:E. + move=> uge0; rewrite EFinM. + have -> : (fine 'V_P[X] + u^2)%:E = 'E_P[(Y \+ cst u)^+2]%R. + rewrite -VY -[RHS](@subeK _ _ (('E_P[(Y \+ cst u)%R])^+2)); last first. + rewrite fin_numX// expectation_fin_num//= rpredD ?Lfun_cst//. + by rewrite rpredB// Lfun_cst. + rewrite -varianceE/=; last first. + by rewrite rpredD ?lee1n//= => _; rewrite Lfun_cst. + rewrite -expe2 expectationD/= ?Lfun_cst//; last by rewrite rpredB ?Lfun_cst. + rewrite EY// add0e expectation_cst -EFinM. + by rewrite (varianceD_cst_r _ Y2) EFinD fineK ?variance_fin_num. + have le : [set x | lambda%:E <= (X x)%:E - 'E_P[X]] + `<=` [set x | ((lambda + u)^2)%:E <= ((Y x + u)^+2)%:E]. + move=> x /= le; rewrite lee_fin; apply: lerXn2r. + - exact: addr_ge0 (ltW lambda_gt0) _. + - apply/(addr_ge0 _ uge0)/(le_trans (ltW lambda_gt0) _). + by rewrite -lee_fin EFinB finEK. + - by rewrite lerD2r -lee_fin EFinB finEK. + apply: (le_trans (le_measure _ _ _ le)). + - rewrite -[[set _ | _]]setTI inE; apply: emeasurable_fun_c_infty => [//|]. + apply: emeasurable_funB=> //. + by move/Lfun1_integrable : X1 => /measurable_int. + - rewrite -[[set _ | _]]setTI inE; apply: emeasurable_fun_c_infty => [//|]. + rewrite measurable_EFinP [X in measurable_fun _ X](_ : _ = + (fun x => x ^+ 2) \o (fun x => Y x + u))%R//. + by apply/measurableT_comp => //; exact/measurable_funD. + set eps := ((lambda + u) ^ 2)%R. + have peps : (0 < eps)%R by rewrite exprz_gt0 ?ltr_wpDr. + rewrite (lee_pdivlMr _ _ peps) muleC. + under eq_set => x. + rewrite -[leRHS]gee0_abs ?lee_fin ?sqr_ge0 -?lee_fin => [|//]. + rewrite -[(_ ^+ 2)%R]/(((Y \+ cst u) ^+ 2) x)%R; over. + rewrite -[X in X%:E * _]gtr0_norm => [|//]. + apply: (le_trans (markov _ peps _ _ _)) => //=. + by move=> x y /[!nnegrE] /ger0_norm-> /ger0_norm->. + rewrite -/Y le_eqVlt; apply/orP; left; apply/eqP; congr expectation. + by apply/funeqP => x /=; rewrite -expr2 normr_id ger0_norm ?sqr_ge0. +pose u0 := (fine 'V_P[X] / lambda)%R. +have u0ge0 : (0 <= u0)%R. + by apply: divr_ge0 (ltW lambda_gt0); rewrite -lee_fin finVK variance_ge0. +apply: le_trans (le _ u0ge0) _; rewrite lee_fin le_eqVlt; apply/orP; left. +rewrite eqr_div; [|apply: lt0r_neq0..]; last 2 first. +- by rewrite exprz_gt0 -1?[ltLHS]addr0 ?ltr_leD. +- by rewrite ltr_wpDl ?fine_ge0 ?variance_ge0 ?exprz_gt0. +apply/eqP; have -> : fine 'V_P[X] = (u0 * lambda)%R. + by rewrite /u0 -mulrA mulVr ?mulr1 ?unitfE ?gt_eqF. +by rewrite -mulrDl -mulrDr (addrC u0) [in RHS](mulrAC u0) -exprnP expr2 !mulrA. +Qed. + +End markov_chebyshev_cantelli. + +HB.mixin Record MeasurableFun_isDiscrete d d' (T : measurableType d) + (T' : measurableType d') (X : T -> T') of @MeasurableFun d d' T T' X := { + countable_range : countable (range X) +}. + +HB.structure Definition discreteMeasurableFun d d' (T : measurableType d) + (T' : measurableType d') := { + X of isMeasurableFun d d' T T' X & MeasurableFun_isDiscrete d d' T T' X +}. + +Notation "{ 'dmfun' aT >-> T }" := + (@discreteMeasurableFun.type _ _ aT T) : form_scope. + +Definition discrete_random_variable d d' (T : measurableType d) + (T' : measurableType d') (R : realType) (P : probability T R) := + {dmfun T >-> T'}. + +Notation "{ 'dRV' P >-> T }" := + (@discrete_random_variable _ _ _ T _ P) : form_scope. + +Section dRV_definitions. +Context {d} {d'} {T : measurableType d} {T' : measurableType d'} {R : realType} + (P : probability T R). + +Lemma dRV_dom_enum (X : {dRV P >-> T'}) : + { B : set nat & {splitbij B >-> range X}}. +Proof. +have /countable_bijP/cid[B] := @countable_range _ _ _ _ X. +move/card_esym/ppcard_eqP/unsquash => f. +exists B; exact: f. +Qed. + +Definition dRV_dom (X : {dRV P >-> T'}) : set nat := projT1 (dRV_dom_enum X). + +Definition dRV_enum (X : {dRV P >-> T'}) : {splitbij (dRV_dom X) >-> range X} := + projT2 (dRV_dom_enum X). + +Definition enum_prob (X : {dRV P >-> T'}) := + (fun k => P (X @^-1` [set dRV_enum X k])) \_ (dRV_dom X). + +End dRV_definitions. + +Section distribution_dRV. +Local Open Scope ereal_scope. +Context d d' (T : measurableType d) (T' : measurableType d') (R : realType) + (P : probability T R). +Variable X : {dRV P >-> T'}. + +Lemma distribution_dRV_enum (n : nat) : n \in dRV_dom X -> + distribution P X [set dRV_enum X n] = enum_prob X n. +Proof. +by move=> nX; rewrite /distribution/= /enum_prob/= patchE nX. +Qed. + +Hypothesis measurable_set1T' : forall x : T', measurable [set x]. + +Lemma distribution_dRV A : measurable A -> + distribution P X A = \sum_(k mA; rewrite /distribution /pushforward. +have mAX i : dRV_dom X i -> measurable (X @^-1` (A `&` [set dRV_enum X i])). + move=> domXi; rewrite preimage_setI. + by apply: measurableI; rewrite //-[X in _ X]setTI; exact/measurable_funP. +have tAX : trivIset (dRV_dom X) (fun k => X @^-1` (A `&` [set dRV_enum X k])). + under eq_fun do rewrite preimage_setI; rewrite -/(trivIset _ _). + apply: trivIset_setIl; apply/trivIsetP => i j iX jX /eqP ij. + rewrite -preimage_setI (_ : _ `&` _ = set0)//. + by apply/seteqP; split => //= x [] -> {x} /inj; rewrite inE inE => /(_ iX jX). +have := measure_bigcup P _ (fun k => X @^-1` (A `&` [set dRV_enum X k])) mAX tAX. +rewrite -preimage_bigcup => {mAX tAX}PXU. +rewrite -{1}(setIT A) -(setUv (\bigcup_(i in dRV_dom X) [set dRV_enum X i])). +rewrite setIUr preimage_setU measureU; last 3 first. + - by rewrite preimage_setI; apply: measurableI; rewrite //-[X in _ X]setTI; + apply/measurable_funP => //; exact: bigcup_measurable. + - by rewrite preimage_setI; apply: measurableI; rewrite //-[X in _ X]setTI; + apply/measurable_funP => //; apply: measurableC; exact: bigcup_measurable. + - by rewrite -preimage_setI -setIIr setIA setICK preimage_set0. +rewrite [X in _ + X = _](_ : _ = 0) ?adde0; last first. + rewrite (_ : _ @^-1` _ = set0) ?measure0//; apply/disjoints_subset => x AXx. + rewrite setCK /bigcup /=; exists ((dRV_enum X)^-1 (X x))%function. + exact: funS. + by rewrite invK// inE. +rewrite setI_bigcupr; etransitivity; first exact: PXU. +rewrite eseries_mkcond; apply: eq_eseriesr => k _. +rewrite /enum_prob patchE; case: ifPn => nX; rewrite ?mul0e//. +rewrite diracE; have [kA|] := boolP (_ \in A). + by rewrite mule1 setIidr// => _ /= ->; exact: set_mem. +rewrite notin_setE => kA. +rewrite mule0 (disjoints_subset _ _).2 ?preimage_set0 ?measure0//. +by apply: subsetCr; rewrite sub1set inE. +Qed. + +Lemma sum_enum_prob : \sum_(n /esym; apply: eq_trans. +by rewrite [RHS]eseries_mkcond; apply: eq_eseriesr => k _; rewrite diracT mule1. +Qed. + +End distribution_dRV. + +Section discrete_distribution. +Local Open Scope ereal_scope. +Context d (T : measurableType d) (R : realType) (P : probability T R). + +Lemma dRV_expectation (X : {dRV P >-> R}) : + P.-integrable [set: T] (EFin \o X) -> + 'E_P[X] = \sum_(n ix; rewrite unlock. +rewrite -[in LHS](_ : \bigcup_k (if k \in dRV_dom X then + X @^-1` [set dRV_enum X k] else set0) = setT); last first. + apply/seteqP; split => // t _. + exists ((dRV_enum X)^-1%function (X t)) => //. + case: ifPn=> [_|]. + by rewrite invK// inE. + by rewrite notin_setE/=; apply; apply: funS. +have tA : trivIset (dRV_dom X) (fun k => [set dRV_enum X k]). + by move=> i j iX jX [r [/= ->{r}]] /inj; rewrite !inE; exact. +have {tA}/trivIset_mkcond tXA : + trivIset (dRV_dom X) (fun k => X @^-1` [set dRV_enum X k]). + apply/trivIsetP => /= i j iX jX ij. + move/trivIsetP : tA => /(_ i j iX jX) Aij. + by rewrite -preimage_setI Aij ?preimage_set0. +rewrite integral_bigcup //; last 2 first. + - by move=> k; case: ifPn. + - apply: (integrableS measurableT) => //. + by rewrite -bigcup_mkcond; exact: bigcup_measurable. +transitivity (\sum_(i i _; case: ifPn => iX. + by apply: eq_integral => t; rewrite in_setE/= => ->. + by rewrite !integral_set0. +transitivity (\sum_(i i _; rewrite -integralZl//; last 2 first. + - by case: ifPn. + - apply/integrableP; split => //. + rewrite (eq_integral (cst 1%E)); last by move=> x _; rewrite abse1. + rewrite integral_cst//; last by case: ifPn. + rewrite mul1e (@le_lt_trans _ _ 1%E) ?ltey//. + by case: ifPn => // _; exact: probability_le1. + by apply: eq_integral => y _; rewrite mule1. +apply: eq_eseriesr => k _; case: ifPn => kX. + rewrite /= integral_cst//= mul1e probability_distribution muleC. + by rewrite distribution_dRV_enum. +by rewrite integral_set0 mule0 /enum_prob patchE (negbTE kX) mul0e. +Qed. + +Definition pmf (X : {RV P >-> R}) (r : R) : R := fine (P (X @^-1` [set r])). + +Lemma expectation_pmf (X : {dRV P >-> R}) : + P.-integrable [set: T] (EFin \o X) -> 'E_P[X] = + \sum_(n iX; rewrite dRV_expectation// [in RHS]eseries_mkcond. +apply: eq_eseriesr => k _. +rewrite /enum_prob patchE; case: ifPn => kX; last by rewrite mul0e. +by rewrite /pmf fineK// fin_num_measure. +Qed. + +End discrete_distribution. + +Section bernoulli_pmf. +Context {R : realType} (p : R). +Local Open Scope ring_scope. + +Definition bernoulli_pmf b := if b then p else 1 - p. + +Lemma bernoulli_pmf_ge0 (p01 : 0 <= p <= 1) b : 0 <= bernoulli_pmf b. +Proof. +rewrite /bernoulli_pmf. +by move: p01 => /andP[p0 p1]; case: ifPn => // _; rewrite subr_ge0. +Qed. + +Lemma bernoulli_pmf1 (p01 : 0 <= p <= 1) : + \sum_(i \in [set: bool]) (bernoulli_pmf i)%:E = 1%E. +Proof. +rewrite setT_bool fsbigU//=; last by move=> x [/= ->]. +by rewrite !fsbig_set1/= -EFinD addrCA subrr addr0. +Qed. + +End bernoulli_pmf. + +Lemma measurable_bernoulli_pmf {R : realType} D n : + measurable_fun D (@bernoulli_pmf R ^~ n). +Proof. +by apply/measurable_funTS/measurable_fun_if => //=; exact: measurable_funB. +Qed. + +Definition bernoulli {R : realType} (p : R) : set bool -> \bar R := fun A => + if (0 <= p <= 1)%R then \sum_(b \in A) (bernoulli_pmf p b)%:E else \d_false A. + +Section bernoulli. +Context {R : realType} (p : R). + +Local Notation bernoulli := (bernoulli p). + +Let bernoulli0 : bernoulli set0 = 0. +Proof. +by rewrite /bernoulli; case: ifPn => // p01; rewrite fsbig_set0. +Qed. + +Let bernoulli_ge0 U : (0 <= bernoulli U)%E. +Proof. +rewrite /bernoulli; case: ifPn => // p01. +rewrite fsbig_finite//= sumEFin lee_fin. +by apply: sumr_ge0 => /= b _; exact: bernoulli_pmf_ge0. +Qed. + +Let bernoulli_sigma_additive : semi_sigma_additive bernoulli. +Proof. +move=> F mF tF mUF; rewrite /bernoulli; case: ifPn => p01; last first. + exact: measure_semi_sigma_additive. +apply: cvg_toP. + apply: ereal_nondecreasing_is_cvgn => m n mn. + apply: lee_sum_nneg_natr => // k _ _. + rewrite fsbig_finite//= sumEFin lee_fin. + by apply: sumr_ge0 => /= b _; exact: bernoulli_pmf_ge0. +transitivity (\sum_(0 <= i k _; rewrite esum_fset//= => b _. + by rewrite lee_fin bernoulli_pmf_ge0. +rewrite -nneseries_sum_bigcup//=; last first. + by move=> b; rewrite lee_fin bernoulli_pmf_ge0. +by rewrite esum_fset//= => b _; rewrite lee_fin bernoulli_pmf_ge0. +Qed. + +HB.instance Definition _ := isMeasure.Build _ _ _ bernoulli + bernoulli0 bernoulli_ge0 bernoulli_sigma_additive. + +Let bernoulli_setT : bernoulli [set: _] = 1%E. +Proof. +rewrite /bernoulli/=; case: ifPn => p01; last by rewrite probability_setT. +by rewrite bernoulli_pmf1. +Qed. + +HB.instance Definition _ := + @Measure_isProbability.Build _ _ R bernoulli bernoulli_setT. + +Lemma eq_bernoulli (P : probability bool R) : + P [set true] = p%:E -> P =1 bernoulli. +Proof. +move=> Ptrue sb; rewrite /bernoulli /bernoulli_pmf. +have Pfalse: P [set false] = (1 - p%:E)%E. + rewrite -Ptrue -(probability_setT P) setT_bool measureU//; last first. + by rewrite disjoints_subset => -[]//. + by rewrite addeAC subee ?add0e//= Ptrue. +have: (0 <= p%:E <= 1)%E by rewrite -Ptrue measure_ge0 probability_le1. +rewrite !lee_fin => ->. +have eq_sb := etrans (bigcup_imset1 (_ : set bool) id) (image_id _). +rewrite -[in LHS](eq_sb sb)/= measure_fin_bigcup//; last 2 first. +- exact: finite_finset. +- by move=> [] [] _ _ [[]]//= []. +- by apply: eq_fsbigr => /= -[]. +Qed. + +End bernoulli. + +Section bernoulli_measure. +Context {R : realType}. +Variables (p : R) (p0 : (0 <= p)%R) (p1 : ((NngNum p0)%:num <= 1)%R). + +Lemma bernoulli_dirac : bernoulli p = measure_add + (mscale (NngNum p0) \d_true) (mscale (1 - (Itv01 p0 p1)%:num)%:nng \d_false). +Proof. +apply/funext => U; rewrite /bernoulli; case: ifPn => [p01|]; last first. + by rewrite p0/= p1. +rewrite measure_addE/= /mscale/=. +have := @subsetT _ U; rewrite setT_bool => UT. +have [->|->|->|->] /= := subset_set2 UT. +- rewrite -esum_fset//=; last by move=> b; rewrite lee_fin bernoulli_pmf_ge0. + by rewrite esum_set0 2!measure0 2!mule0 adde0. +- rewrite -esum_fset//=; last by move=> b; rewrite lee_fin bernoulli_pmf_ge0. + rewrite esum_set1/= ?lee_fin// 2!diracE mem_set//= memNset//= mule0 adde0. + by rewrite mule1. +- rewrite -esum_fset//=; last by move=> b; rewrite lee_fin bernoulli_pmf_ge0. + rewrite esum_set1/= ?lee_fin ?subr_ge0// 2!diracE memNset//= mem_set//=. + by rewrite mule0 add0e mule1. +- rewrite fsbigU//=; last by move=> x [->]. + by rewrite 2!fsbig_set1/= -setT_bool 2!diracT !mule1. +Qed. + +End bernoulli_measure. +Arguments bernoulli {R}. + +Lemma eq_bernoulliV2 {R : realType} (P : probability bool R) : + P [set true] = P [set false] -> P =1 bernoulli 2^-1. +Proof. +move=> Ptrue_eq_false; apply/eq_bernoulli. +have : P [set: bool] = 1%E := probability_setT P. +rewrite setT_bool measureU//=; last first. + by rewrite disjoints_subset => -[]//. +rewrite Ptrue_eq_false -mule2n; move/esym/eqP. +by rewrite -mule_natl -eqe_pdivrMl// mule1 => /eqP<-. +Qed. + +Section integral_bernoulli. +Context {R : realType}. +Variables (p : R) (p01 : (0 <= p <= 1)%R). +Local Open Scope ereal_scope. + +Lemma bernoulliE A : bernoulli p A = p%:E * \d_true A + (`1-p)%:E * \d_false A. +Proof. by case/andP : p01 => p0 p1; rewrite bernoulli_dirac// measure_addE. Qed. + +Lemma integral_bernoulli (f : bool -> \bar R) : (forall x, 0 <= f x) -> + \int[bernoulli p]_y (f y) = p%:E * f true + (`1-p)%:E * f false. +Proof. +move=> f0; case/andP : p01 => p0 p1; rewrite bernoulli_dirac/=. +rewrite ge0_integral_measure_sum// 2!big_ord_recl/= big_ord0 adde0/=. +by rewrite !ge0_integral_mscale//= !integral_dirac//= !diracT !mul1e. +Qed. + +End integral_bernoulli. + +Section measurable_bernoulli. +Local Open Scope ring_scope. +Variable R : realType. +Implicit Type p : R. + +Lemma measurable_bernoulli : + measurable_fun setT (bernoulli : R -> pprobability bool R). +Proof. +apply: (@measurability _ _ _ _ _ _ + (@pset _ _ _ : set (set (pprobability _ R)))) => //. +move=> _ -[_ [r r01] [Ys mYs <-]] <-; apply: emeasurable_fun_infty_o => //=. +apply: measurable_fun_if => //=. + by apply: measurable_and => //; exact: measurable_fun_ler. +apply: (eq_measurable_fun (fun t => + \sum_(b <- fset_set Ys) (bernoulli_pmf t b)%:E)). + move=> x /set_mem[_/= x01]. + by rewrite fsbig_finite//=. +apply: emeasurable_sum => n; move=> k Ysk; apply/measurableT_comp => //. +exact: measurable_bernoulli_pmf. +Qed. + +Lemma measurable_bernoulli2 U : measurable U -> + measurable_fun setT (bernoulli ^~ U : R -> \bar R). +Proof. +by move=> ?; exact: (measurable_kernel (kprobability measurable_bernoulli)). +Qed. + +End measurable_bernoulli. +Arguments measurable_bernoulli {R}. + +Section binomial_pmf. +Local Open Scope ring_scope. +Context {R : realType} (n : nat) (p : R). + +Definition binomial_pmf k := p ^+ k * (`1-p) ^+ (n - k) *+ 'C(n, k). + +Lemma binomial_pmf_ge0 k (p01 : (0 <= p <= 1)%R) : 0 <= binomial_pmf k. +Proof. +move: p01 => /andP[p0 p1]; rewrite mulrn_wge0// mulr_ge0// ?exprn_ge0//. +exact: onem_ge0. +Qed. + +End binomial_pmf. + +Lemma measurable_binomial_pmf {R : realType} D n k : + measurable_fun D (@binomial_pmf R n ^~ k). +Proof. +apply: (@measurableT_comp _ _ _ _ _ _ (fun x : R => x *+ 'C(n, k))%R) => /=. + exact: natmul_measurable. +by apply: measurable_funM => //; apply: measurable_funX; exact: measurable_funB. +Qed. + +Definition binomial_prob {R : realType} (n : nat) (p : R) : set nat -> \bar R := + fun U => if (0 <= p <= 1)%R then + \esum_(k in U) (binomial_pmf n p k)%:E else \d_0%N U. + +Section binomial. +Context {R : realType} (n : nat) (p : R). +Local Open Scope ereal_scope. + +Local Notation binomial := (binomial_prob n p). + +Let binomial0 : binomial set0 = 0. +Proof. by rewrite /binomial measure0; case: ifPn => //; rewrite esum_set0. Qed. + +Let binomial_ge0 U : 0 <= binomial U. +Proof. +rewrite /binomial; case: ifPn => // p01; apply: esum_ge0 => /= k Uk. +by rewrite lee_fin binomial_pmf_ge0. +Qed. + +Let binomial_sigma_additive : semi_sigma_additive binomial. +Proof. +move=> F mF tF mUF; rewrite /binomial; case: ifPn => p01; last first. + exact: measure_semi_sigma_additive. +apply: cvg_toP. + apply: ereal_nondecreasing_is_cvgn => a b ab. + apply: lee_sum_nneg_natr => // k _ _. + by apply: esum_ge0 => /= ? _; exact: binomial_pmf_ge0. +by rewrite nneseries_sum_bigcup// => i; rewrite lee_fin binomial_pmf_ge0. +Qed. + +HB.instance Definition _ := isMeasure.Build _ _ _ binomial + binomial0 binomial_ge0 binomial_sigma_additive. + +Let binomial_setT : binomial [set: _] = 1. +Proof. +rewrite /binomial; case: ifPn; last by move=> _; rewrite probability_setT. +move=> p01; rewrite /binomial_pmf. +have pkn k : 0%R <= (p ^+ k * `1-p ^+ (n - k) *+ 'C(n, k))%:E. + case/andP : p01 => p0 p1. + by rewrite lee_fin mulrn_wge0// mulr_ge0 ?exprn_ge0 ?subr_ge0. +rewrite (esumID `I_n.+1)// [X in _ + X]esum1 ?adde0; last first. + by move=> /= k [_ /negP]; rewrite -leqNgt => nk; rewrite bin_small. +rewrite setTI esum_fset// -fsbig_ord//=. +under eq_bigr do rewrite mulrC. +rewrite sumEFin -exprDn_comm; last exact: mulrC. +by rewrite addrC add_onemK expr1n. +Qed. + +HB.instance Definition _ := + @Measure_isProbability.Build _ _ R binomial binomial_setT. + +End binomial. + +Section binomial_probability. +Local Open Scope ring_scope. +Context {R : realType} (n : nat) (p : R) + (p0 : (0 <= p)%R) (p1 : ((NngNum p0)%:num <= 1)%R). + +Definition bin_prob (k : nat) : {nonneg R} := + ((NngNum p0)%:num ^+ k * (NngNum (onem_ge0 p1))%:num ^+ (n - k)%N *+ 'C(n, k))%:nng. + +Lemma bin_prob0 : bin_prob 0 = ((NngNum (onem_ge0 p1))%:num^+n)%:nng. +Proof. +rewrite /bin_prob bin0 subn0/=; apply/val_inj => /=. +by rewrite expr0 mul1r mulr1n. +Qed. + +Lemma bin_prob1 : bin_prob 1 = + ((NngNum p0)%:num * (NngNum (onem_ge0 p1))%:num ^+ n.-1 *+ n)%:nng. +Proof. +by rewrite /bin_prob bin1/=; apply/val_inj => /=; rewrite expr1 subn1. +Qed. + +Lemma binomial_msum : + binomial_prob n p = msum (fun k => mscale (bin_prob k) \d_k) n.+1. +Proof. +apply/funext => U. +rewrite /binomial_prob; case: ifPn => [_|]; last by rewrite p1 p0. +rewrite /msum/= /mscale/= /binomial_pmf. +have pkn k : (0%R <= (p ^+ k * `1-p ^+ (n - k) *+ 'C(n, k))%:E)%E. + by rewrite lee_fin mulrn_wge0// mulr_ge0 ?exprn_ge0 ?subr_ge0. +rewrite (esumID `I_n.+1)//= [X in _ + X]esum1 ?adde0; last first. + by move=> /= k [_ /negP]; rewrite -leqNgt => nk; rewrite bin_small. +rewrite esum_mkcondl esum_fset//; last by move=> i /= _; case: ifPn. +rewrite -fsbig_ord//=; apply: eq_bigr => i _. +by rewrite diracE; case: ifPn => /= iU; [rewrite mule1|rewrite mule0]. +Qed. + +Lemma binomial_probE U : binomial_prob n p U = + (\sum_(k < n.+1) (bin_prob k)%:num%:E * (\d_(nat_of_ord k) U))%E. +Proof. by rewrite binomial_msum. Qed. + +Lemma integral_binomial (f : nat -> \bar R) : (forall x, 0 <= f x)%E -> + (\int[binomial_prob n p]_y (f y) = + \sum_(k < n.+1) (bin_prob k)%:num%:E * f k)%E. +Proof. +move=> f0; rewrite binomial_msum ge0_integral_measure_sum//=. +apply: eq_bigr => i _. +by rewrite ge0_integral_mscale//= integral_dirac//= diracT mul1e. +Qed. + +End binomial_probability. + +Lemma integral_binomial_prob (R : realType) n p U : (0 <= p <= 1)%R -> + (\int[binomial_prob n p]_y \d_(0 < y)%N U = + bernoulli (1 - `1-p ^+ n) U :> \bar R)%E. +Proof. +move=> /andP[p0 p1]; rewrite bernoulliE//=; last first. + rewrite subr_ge0 exprn_ile1//=; [|exact/onem_ge0|exact/onem_le1]. + by rewrite lerBlDr addrC -lerBlDr subrr; exact/exprn_ge0/onem_ge0. +rewrite (@integral_binomial _ n p _ _ (fun y => \d_(1 <= y)%N U))//. +rewrite !big_ord_recl/=. +rewrite expr0 mul1r subn0 bin0 ltnn mulr1n addrC. +rewrite onemD opprK onem1 add0r; congr +%E. +rewrite /bump; under eq_bigr do rewrite leq0n add1n ltnS leq0n. +rewrite -ge0_sume_distrl; last first. + move=> i _. + by apply/mulrn_wge0/mulr_ge0; apply/exprn_ge0 => //; exact/onem_ge0. +congr *%E. +transitivity (\sum_(i < n.+1) (`1-p ^+ (n - i) * p ^+ i *+ 'C(n, i))%:E - + (`1-p ^+ n)%:E)%E. + rewrite big_ord_recl/=. + rewrite expr0 mulr1 subn0 bin0 mulr1n addrAC -EFinD subrr add0e. + by rewrite /bump; under [RHS]eq_bigr do rewrite leq0n add1n mulrC. +rewrite sumEFin -(@exprDn_comm _ `1-p p n)//. + by rewrite subrK expr1n. +by rewrite /GRing.comm/onem mulrC. +Qed. + +Lemma measurable_binomial_prob (R : realType) (n : nat) : + measurable_fun setT (binomial_prob n : R -> pprobability _ _). +Proof. +apply: (@measurability _ _ _ _ _ _ + (@pset _ _ _ : set (set (pprobability _ R)))) => //. +move=> _ -[_ [r r01] [Ys mYs <-]] <-; apply: emeasurable_fun_infty_o => //=. +rewrite /binomial_prob/=. +set f := (X in measurable_fun _ X). +apply: measurable_fun_if => //=. + by apply: measurable_and => //; exact: measurable_fun_ler. +apply: (eq_measurable_fun (fun t => + \sum_(k x /set_mem[_/= x01]. + rewrite nneseries_esum// -1?[in RHS](set_mem_set Ys)// => k kYs. + by rewrite lee_fin binomial_pmf_ge0. +apply: ge0_emeasurable_sum. + by move=> k x/= [_ x01] _; rewrite lee_fin binomial_pmf_ge0. +move=> k Ysk; apply/measurableT_comp => //. +exact: measurable_binomial_pmf. +Qed. + +Section uniform_probability. +Local Open Scope ring_scope. +Context (R : realType) (a b : R). + +Definition uniform_pdf x := if a <= x <= b then (b - a)^-1 else 0. + +Lemma uniform_pdf_ge0 x : a < b -> 0 <= uniform_pdf x. +Proof. +move=> ab; rewrite /uniform_pdf; case: ifPn => // axb. +by rewrite invr_ge0// ltW// subr_gt0. +Qed. + +Lemma measurable_uniform_pdf : measurable_fun setT uniform_pdf. +Proof. +rewrite /uniform_pdf /=; apply: measurable_fun_if => //=. +by apply: measurable_and => //; exact: measurable_fun_ler. +Qed. + +Local Notation mu := lebesgue_measure. + +Lemma integral_uniform_pdf U : + (\int[mu]_(x in U) (uniform_pdf x)%:E = + \int[mu]_(x in U `&` `[a, b]) (uniform_pdf x)%:E)%E. +Proof. +rewrite [RHS]integral_mkcondr/=; apply: eq_integral => x xU. +rewrite patchE; case: ifPn => //. +rewrite notin_setE/= in_itv/= => /negP/negbTE xab. +by rewrite /uniform_pdf xab. +Qed. + +Lemma integral_uniform_pdf1 A (ab : a < b) : `[a, b] `<=` A -> + (\int[mu]_(x in A) (uniform_pdf x)%:E = 1)%E. +Proof. +move=> abA; rewrite integral_uniform_pdf setIidr//. +rewrite (eq_integral (fun=> (b - a)^-1%:E)); last first. + by move=> x; rewrite inE/= in_itv/= /uniform_pdf => ->. +rewrite integral_cst//= lebesgue_measure_itv/= lte_fin. +by rewrite ab -EFinD -EFinM mulVf// gt_eqF// subr_gt0. +Qed. + +Definition uniform_prob (ab : a < b) : set _ -> \bar R := + fun U => (\int[mu]_(x in U) (uniform_pdf x)%:E)%E. + +Hypothesis ab : (a < b)%R. + +Let uniform0 : uniform_prob ab set0 = 0. +Proof. by rewrite /uniform_prob integral_set0. Qed. + +Let uniform_ge0 U : (0 <= uniform_prob ab U)%E. +Proof. +by apply: integral_ge0 => /= x Ux; rewrite lee_fin uniform_pdf_ge0. +Qed. + +Lemma integrable_uniform_pdf : + mu.-integrable setT (fun x => (uniform_pdf x)%:E). +Proof. +apply/integrableP; split. + by apply: measurableT_comp => //; exact: measurable_uniform_pdf. +under eq_integral. + move=> x _; rewrite gee0_abs//; last by rewrite lee_fin uniform_pdf_ge0. + over. +by rewrite /= integral_uniform_pdf1 ?ltry// -subr_gt0. +Qed. + +Let uniform_sigma_additive : semi_sigma_additive (uniform_prob ab). +Proof. +move=> /= F mF tF mUF; rewrite /uniform_prob; apply: cvg_toP. + apply: ereal_nondecreasing_is_cvgn => m n mn. + apply: lee_sum_nneg_natr => // k _ _. + by apply: integral_ge0 => /= x Fkx; rewrite lee_fin uniform_pdf_ge0. +rewrite ge0_integral_bigcup//=. +- apply: measurable_funTS; apply: measurableT_comp => //. + exact: measurable_uniform_pdf. +- by move=> x _; rewrite lee_fin uniform_pdf_ge0. +Qed. + +HB.instance Definition _ := isMeasure.Build _ _ _ (uniform_prob ab) + uniform0 uniform_ge0 uniform_sigma_additive. + +Let uniform_setT : uniform_prob ab [set: _] = 1%:E. +Proof. by rewrite /uniform_prob /mscale/= integral_uniform_pdf1. Qed. + +HB.instance Definition _ := @Measure_isProbability.Build _ _ R + (uniform_prob ab) uniform_setT. + +Lemma dominates_uniform_prob : uniform_prob ab `<< mu. +Proof. +move=> A mA muA0; rewrite /uniform_prob integral_uniform_pdf. +apply/eqP; rewrite eq_le; apply/andP; split; last first. + apply: integral_ge0 => x [Ax /=]; rewrite in_itv /= => xab. + by rewrite lee_fin uniform_pdf_ge0. +apply: (@le_trans _ _ + (\int[mu]_(x in A `&` `[a, b]%classic) (b - a)^-1%:E))%E; last first. + rewrite integral_cst//= ?mul1e//. + by rewrite pmule_rle0 ?lte_fin ?invr_gt0// ?subr_gt0// -muA0 measureIl. + exact: measurableI. +apply: ge0_le_integral => //=. +- exact: measurableI. +- by move=> x [Ax]; rewrite /= in_itv/= => axb; rewrite lee_fin uniform_pdf_ge0. +- by apply/measurable_EFinP/measurable_funTS; exact: measurable_uniform_pdf. +- by move=> x [Ax _]; rewrite lee_fin invr_ge0// ltW// subr_gt0. +- by move=> x [Ax]; rewrite in_itv/= /uniform_pdf => ->. +Qed. + +Let integral_uniform_indic E : measurable E -> + (\int[uniform_prob ab]_x (\1_E x)%:E = + (b - a)^-1%:E * \int[mu]_(x in `[a, b]) (\1_E x)%:E)%E. +Proof. +move=> mE; rewrite integral_indic//= /uniform_prob setIT -ge0_integralZl//=. +- rewrite [LHS]integral_mkcond/= [RHS]integral_mkcond/=. + apply: eq_integral => x _; rewrite !patchE; case: ifPn => xE. + case: ifPn. + rewrite inE/= in_itv/= => xab. + by rewrite /uniform_pdf xab indicE xE mule1. + by rewrite notin_setE/= in_itv/= => /negP/negbTE; rewrite /uniform_pdf => ->. + case: ifPn => //. + by rewrite inE/= in_itv/= => axb; rewrite indicE (negbTE xE) mule0. +- exact/measurable_EFinP/measurable_indic. +- by rewrite lee_fin invr_ge0// ltW// subr_gt0. +Qed. + +Import HBNNSimple. + +Let integral_uniform_nnsfun (f : {nnsfun _ >-> R}) : + (\int[uniform_prob ab]_x (f x)%:E = + (b - a)^-1%:E * \int[mu]_(x in `[a, b]) (f x)%:E)%E. +Proof. +under [LHS]eq_integral do rewrite fimfunE -fsumEFin//. +rewrite [LHS]ge0_integral_fsum//; last 2 first. + - by move=> r; exact/measurable_EFinP/measurableT_comp. + - by move=> n x _; rewrite EFinM nnfun_muleindic_ge0. +rewrite -[RHS]ge0_integralZl//; last 3 first. + - exact/measurable_EFinP/measurable_funTS. + - by move=> x _; rewrite lee_fin. + - by rewrite lee_fin invr_ge0// ltW// subr_gt0. +under [RHS]eq_integral. + move=> x xD; rewrite fimfunE -fsumEFin// ge0_mule_fsumr; last first. + by move=> r; rewrite EFinM nnfun_muleindic_ge0. + over. +rewrite [RHS]ge0_integral_fsum//; last 2 first. + - by move=> r; apply/measurable_EFinP; do 2 apply/measurableT_comp => //. + - move=> n x _; rewrite EFinM mule_ge0//; last by rewrite nnfun_muleindic_ge0. + by rewrite lee_fin invr_ge0// ltW// subr_gt0. +apply: eq_fsbigr => r _; rewrite ge0_integralZl//. +- by rewrite !integralZl_indic_nnsfun//= integral_uniform_indic// muleCA. +- exact/measurable_EFinP/measurableT_comp. +- by move=> t _; rewrite nnfun_muleindic_ge0. +- by rewrite lee_fin invr_ge0// ltW// subr_gt0. +Qed. + +Lemma integral_uniform (f : _ -> \bar R) : + measurable_fun setT f -> (forall x, 0 <= f x)%E -> + (\int[uniform_prob ab]_x f x = (b - a)^-1%:E * \int[mu]_(x in `[a, b]) f x)%E. +Proof. +move=> mf f0. +pose f_ := nnsfun_approx measurableT mf. +transitivity (lim (\int[uniform_prob ab]_x (f_ n x)%:E @[n --> \oo])%E). + rewrite -monotone_convergence//=. + - apply: eq_integral => ? /[!inE] xD; apply/esym/cvg_lim => //=. + exact: cvg_nnsfun_approx. + - by move=> n; exact/measurable_EFinP/measurable_funTS. + - by move=> n ? _; rewrite lee_fin. + - by move=> ? _ ? ? mn; rewrite lee_fin; exact/lefP/nd_nnsfun_approx. +rewrite [X in _ = (_ * X)%E](_ : _ = lim + (\int[mu]_(x in `[a, b]) (f_ n x)%:E @[n --> \oo])%E); last first. + rewrite -monotone_convergence//=. + - apply: eq_integral => ? /[!inE] xD; apply/esym/cvg_lim => //. + exact: cvg_nnsfun_approx. + - by move=> n; exact/measurable_EFinP/measurable_funTS. + - by move=> n ? _; rewrite lee_fin. + - by move=> ? _ ? ? ?; rewrite lee_fin; exact/lefP/nd_nnsfun_approx. +rewrite -limeMl//. + by apply: congr_lim; apply/funext => n /=; exact: integral_uniform_nnsfun. +apply/ereal_nondecreasing_is_cvgn => x y xy; apply: ge0_le_integral => //=. +- by move=> ? _; rewrite lee_fin. +- exact/measurable_EFinP/measurable_funTS. +- by move=> ? _; rewrite lee_fin. +- exact/measurable_EFinP/measurable_funTS. +- by move=> ? _; rewrite lee_fin; exact/lefP/nd_nnsfun_approx. +Qed. + +End uniform_probability. + +Section normal_density. +Context {R : realType}. +Local Open Scope ring_scope. +Local Import Num.ExtraDef. +Implicit Types m s x : R. + +Definition normal_fun m s x := expR (- (x - m) ^+ 2 / (s ^+ 2 *+ 2)). + +Lemma measurable_normal_fun m s : measurable_fun [set :R] (normal_fun m s). +Proof. +apply: measurableT_comp => //=; apply: measurable_funM => //=. +apply: measurableT_comp => //=; apply: measurable_funX => //=. +exact: measurable_funB. +Qed. + +Lemma normal_fun_ge0 m s x : 0 <= normal_fun m s x. +Proof. exact: expR_ge0. Qed. + +Lemma normal_fun_center m s : normal_fun m s = normal_fun 0 s \o center m. +Proof. by apply/funext => x/=; rewrite /normal_fun/= subr0. Qed. + +Definition normal_peak s := (sqrtr (s ^+ 2 * pi *+ 2))^-1. + +Lemma normal_peak_ge0 s : 0 <= normal_peak s. Proof. by rewrite invr_ge0. Qed. + +Lemma normal_peak_gt0 s : s != 0 -> 0 < normal_peak s. +Proof. +move=> s0; rewrite invr_gt0// sqrtr_gt0. +by rewrite pmulrn_rgt0// mulr_gt0 ?pi_gt0// exprn_even_gt0/=. +Qed. + +Let normal_pdf0 m s x : R := normal_peak s * normal_fun m s x. + +Definition normal_pdf m s x := + if s == 0 then \1_`[0, 1] x else normal_pdf0 m s x. + +Lemma normal_pdfE m s : s != 0 -> normal_pdf m s = normal_pdf0 m s. +Proof. by rewrite /normal_pdf; have [_|s0] := eqVneq s 0. Qed. + +Let normal_pdf0_center m s : normal_pdf0 m s = normal_pdf0 0 s \o center m. +Proof. by rewrite /normal_pdf0 normal_fun_center. Qed. + +Let normal_pdf0_ge0 m s x : 0 <= normal_pdf0 m s x. +Proof. by rewrite mulr_ge0 ?normal_peak_ge0 ?expR_ge0. Qed. + +Let normal_pdf0_gt0 m s x : s != 0 -> 0 < normal_pdf0 m s x. +Proof. by move=> s0; rewrite mulr_gt0 ?expR_gt0// normal_peak_gt0. Qed. + +Let measurable_normal_pdf0 m s : measurable_fun setT (normal_pdf0 m s). +Proof. by apply: measurable_funM => //=; exact: measurable_normal_fun. Qed. + +Lemma measurable_normal_pdf m s : measurable_fun setT (normal_pdf m s). +Proof. +by rewrite /normal_pdf; have [_|] := eqVneq s 0; first exact: measurable_indic. +Qed. + +Let continuous_normal_pdf0 m s : continuous (normal_pdf0 m s). +Proof. +move=> x; apply: cvgM; first exact: cvg_cst. +apply: (cvg_comp _ expR); last exact: continuous_expR. +apply: cvgM; last exact: cvg_cst. +apply: (@cvgN _ R^o). +apply: (cvg_comp (fun x => x - m) (fun x => x ^+ 2)). + by apply: (@cvgB _ R^o) => //; [exact: cvg_id|exact: cvg_cst]. +exact: sqr_continuous. +Qed. + +Let normal_pdf0_ub m s x : normal_pdf0 m s x <= normal_peak s. +Proof. +rewrite /normal_pdf0 ler_piMr ?normal_peak_ge0//. +rewrite -[leRHS]expR0 ler_expR mulNr oppr_le0 mulr_ge0// ?sqr_ge0//. +by rewrite invr_ge0 mulrn_wge0// sqr_ge0. +Qed. + +Lemma normal_pdf_ge0 m s x : 0 <= normal_pdf m s x. +Proof. by rewrite /normal_pdf; case: ifP. Qed. + +Lemma continuous_normal_pdf m s : s != 0 -> continuous (normal_pdf m s). +Proof. by rewrite /normal_pdf; have [|] := eqVneq s 0. Qed. + +Lemma normal_pdf_ub m s x : s != 0 -> normal_pdf m s x <= normal_peak s. +Proof. by rewrite /normal_pdf; have [|] := eqVneq s 0. Qed. + +End normal_density. + +Definition normal_prob {R : realType} (m : R) (s : R) : set _ -> \bar R := + fun V => (\int[lebesgue_measure]_(x in V) (normal_pdf m s x)%:E)%E. + +Section normal_probability. +Variables (R : realType) (m sigma : R). +Local Open Scope ring_scope. +Notation mu := lebesgue_measure. + +Local Notation normal_peak := (normal_peak sigma). +Local Notation normal_fun := (normal_fun m sigma). + +Let F (x : R^o) := (x - m) / (Num.sqrt (sigma ^+ 2 *+ 2)). + +Let normal_gauss_fun x : normal_fun x = gauss_fun (F x). +Proof. +congr expR; rewrite mulNr exprMn exprVn; congr (- (_ * _^-1)%R). +by rewrite sqr_sqrtr// pmulrn_lge0// sqr_ge0. +Qed. + +Let F'E : F^`()%classic = cst (Num.sqrt (sigma ^+ 2 *+ 2))^-1. +Proof. +apply/funext => x; rewrite /F derive1E deriveM// deriveD// derive_cst scaler0. +by rewrite add0r derive_id derive_cst addr0 scaler1. +Qed. + +Let integral_gaussFF' : sigma != 0 -> + (\int[mu]_x ((((gauss_fun \o F) * + (F^`())%classic) x)%:E * (Num.sqrt (sigma ^+ 2 *+ 2))%:E))%E = + normal_peak^-1%:E. +Proof. +move=> s0; rewrite /normal_peak invrK. +rewrite -mulrnAr -[in RHS]mulr_natr sqrtrM ?(sqrtrM 2) ?sqr_ge0 ?pi_ge0// !EFinM. +rewrite muleCA ge0_integralZr//=; first last. + by move=> x _; rewrite lee_fin mulr_ge0//= ?gauss_fun_ge0// F'E/= invr_ge0. + rewrite F'E; apply/measurable_EFinP/measurable_funM => //. + apply/measurableT_comp => //; first exact: measurable_gauss_fun. + by apply: measurable_funM => //; exact: measurable_funD. +congr *%E; last by rewrite -(mulr_natr (_ ^+ 2)) sqrtrM ?sqr_ge0. +rewrite -increasing_ge0_integration_by_substitutionT//. +- exact: integralT_gauss. +- move=> x y xy; rewrite /F ltr_pM2r ?ltr_leB ?gt_eqF//. + by rewrite invr_gt0 ?sqrtr_gt0 ?pmulrn_lgt0 ?exprn_even_gt0. +- by rewrite F'E => ?; exact: cvg_cst. +- by rewrite F'E; exact: is_cvg_cst. +- by rewrite F'E; exact: is_cvg_cst. +- apply/gt0_cvgMlNy; last exact: cvg_addrr_Ny. + by rewrite invr_gt0// sqrtr_gt0 -mulr_natr mulr_gt0// exprn_even_gt0. +- apply/gt0_cvgMly; last exact: cvg_addrr. + by rewrite invr_gt0// sqrtr_gt0 -mulr_natr mulr_gt0// exprn_even_gt0. +- exact: continuous_gauss_fun. +- by move=> x; rewrite gauss_fun_ge0. +Qed. + +Let integral_normal_fun : sigma != 0 -> + (\int[mu]_x (normal_fun x)%:E)%E = normal_peak^-1%:E. +Proof. +move=> s0; rewrite -integral_gaussFF'//; apply: eq_integral => /= x _. +rewrite F'E !fctE/= EFinM -muleA -EFinM mulVf ?mulr1 ?mule1. + by rewrite normal_gauss_fun. +by rewrite gt_eqF// sqrtr_gt0 pmulrn_lgt0// exprn_even_gt0. +Qed. + +Let integrable_normal_fun : sigma != 0 -> + mu.-integrable [set: R] (EFin \o normal_fun). +Proof. +move=> s0; apply/integrableP; split. + by apply/measurable_EFinP; exact: measurable_normal_fun. +under eq_integral do rewrite /= ger0_norm ?expR_ge0//. +by rewrite /= integral_normal_fun// ltry. +Qed. + +Lemma integral_normal_pdf : (\int[mu]_x (normal_pdf m sigma x)%:E = 1%E)%E. +Proof. +rewrite /normal_pdf; have [_|s0] := eqVneq sigma 0. + by rewrite integral_indic//= setIT lebesgue_measure_itv/= lte01 oppr0 adde0. +under eq_integral do rewrite EFinM. +rewrite integralZl//=; last exact: integrable_normal_fun. +by rewrite integral_normal_fun// -EFinM divff// gt_eqF// normal_peak_gt0. +Qed. + +Lemma integrable_normal_pdf : mu.-integrable [set: R] + (fun x => (normal_pdf m sigma x)%:E). +Proof. +apply/integrableP; split. + by apply/measurable_EFinP; exact: measurable_normal_pdf. +apply/abse_integralP => //=; last by rewrite integral_normal_pdf abse1 ltry. +by apply/measurable_EFinP; exact: measurable_normal_pdf. +Qed. + +Local Notation normal_pdf := (normal_pdf m sigma). +Local Notation normal_prob := (normal_prob m sigma). + +Let normal0 : normal_prob set0 = 0%E. +Proof. by rewrite /normal_prob integral_set0. Qed. + +Let normal_ge0 A : (0 <= normal_prob A)%E. +Proof. +rewrite /normal_prob integral_ge0//= => x _. +by rewrite lee_fin normal_pdf_ge0 ?ltW. +Qed. + +Let normal_sigma_additive : semi_sigma_additive normal_prob. +Proof. +move=> /= A mA tA mUA. +rewrite /normal_prob/= integral_bigcup//=; last first. + by apply: (integrableS _ _ (subsetT _)) => //; exact: integrable_normal_pdf. +apply: is_cvg_ereal_nneg_natsum_cond => n _ _. +by apply: integral_ge0 => /= x ?; rewrite lee_fin normal_pdf_ge0 ?ltW. +Qed. + +HB.instance Definition _ := isMeasure.Build _ _ _ + normal_prob normal0 normal_ge0 normal_sigma_additive. + +Let normal_setT : normal_prob [set: _] = 1%E. +Proof. by rewrite /normal_prob integral_normal_pdf. Qed. + +HB.instance Definition _ := + @Measure_isProbability.Build _ _ R normal_prob normal_setT. + +Lemma normal_prob_dominates : normal_prob `<< mu. +Proof. +move=> A mA muA0; rewrite /normal_prob /normal_pdf. +have [s0|s0] := eqVneq sigma 0. + apply: null_set_integral => //=; apply: (integrableS measurableT) => //=. + exact: integrable_indic_itv. +apply/eqP; rewrite eq_le; apply/andP; split; last first. + apply: integral_ge0 => x _. + by rewrite lee_fin mulr_ge0 ?normal_peak_ge0 ?normal_fun_ge0. +apply: (@le_trans _ _ (\int[mu]_(x in A) (normal_peak)%:E))%E; last first. + by rewrite integral_cst//= muA0 mule0. +apply: ge0_le_integral => //=. +- by move=> x _; rewrite lee_fin mulr_ge0 ?normal_peak_ge0 ?normal_fun_ge0. +- apply/measurable_funTS/measurableT_comp => //=. + by apply: measurable_funM => //; exact: measurable_normal_fun. +- by move=> x _; rewrite lee_fin normal_peak_ge0. +- by move=> x _; have := normal_pdf_ub m x s0; rewrite /normal_pdf (negbTE s0). +Qed. + +End normal_probability. + +Section exponential_pdf. +Context {R : realType}. +Notation mu := lebesgue_measure. +Variable rate : R. +Hypothesis rate_gt0 : 0 < rate. + +Let exponential_pdfT x := rate * expR (- rate * x). +Definition exponential_pdf := exponential_pdfT \_ `[0%R, +oo[. + +Lemma exponential_pdf_ge0 x : 0 <= exponential_pdf x. +Proof. +by apply: restrict_ge0 => {}x _; apply: mulr_ge0; [exact: ltW|exact: expR_ge0]. +Qed. + +Lemma lt0_exponential_pdf x : x < 0 -> exponential_pdf x = 0. +Proof. +move=> x0; rewrite /exponential_pdf patchE ifF//. +by apply/negP; rewrite inE/= in_itv/= andbT; apply/negP; rewrite -ltNge. +Qed. + +Let continuous_exponential_pdfT : continuous exponential_pdfT. +Proof. +move=> x. +apply: (@continuousM _ R^o (fun=> rate) (fun x => expR (- rate * x))). + exact: cst_continuous. +apply: continuous_comp; last exact: continuous_expR. +by apply: continuousM => //; apply: (@continuousN _ R^o); exact: cst_continuous. +Qed. + +Lemma measurable_exponential_pdf : measurable_fun [set: R] exponential_pdf. +Proof. +apply/measurable_restrict => //; apply: measurable_funTS. +exact: continuous_measurable_fun. +Qed. + +Lemma exponential_pdfE x : 0 <= x -> exponential_pdf x = exponential_pdfT x. +Proof. +by move=> x0; rewrite /exponential_pdf patchE ifT// inE/= in_itv/= x0. +Qed. + +Lemma in_continuous_exponential_pdf : + {in `]0, +oo[%R, continuous exponential_pdf}. +Proof. +move=> x; rewrite in_itv/= andbT => x0. +apply/(@cvgrPdist_lt _ R^o) => e e0; near=> y. +rewrite 2?(exponential_pdfE (ltW _))//; last by near: y; exact: lt_nbhsr. +near: y; move: e e0; apply/(@cvgrPdist_lt _ R^o). +by apply: continuous_comp => //; exact: continuous_exponential_pdfT. +Unshelve. end_near. Qed. + +Lemma within_continuous_exponential_pdf : + {within [set` `[0, +oo[%R], continuous exponential_pdf}. +Proof. +apply/continuous_within_itvcyP; split. + exact: in_continuous_exponential_pdf. +apply/(@cvgrPdist_le _ R^o) => e e0; near=> t. +rewrite 2?exponential_pdfE//. +near: t; move: e e0; apply/cvgrPdist_le. +by apply: cvg_at_right_filter; exact: continuous_exponential_pdfT. +Unshelve. end_near. Qed. + +End exponential_pdf. + +Definition exponential_prob {R : realType} (rate : R) := + fun V => (\int[lebesgue_measure]_(x in V) (exponential_pdf rate x)%:E)%E. + +Section exponential_prob. +Context {R : realType}. +Local Open Scope ring_scope. +Notation mu := lebesgue_measure. +Variable rate : R. +Hypothesis rate_gt0 : 0 < rate. + +Lemma derive1_exponential_pdf : + {in `]0, +oo[%R, (fun x => - (expR : R^o -> R^o) (- rate * x))^`()%classic + =1 exponential_pdf rate}. +Proof. +move=> z; rewrite in_itv/= andbT => z0. +rewrite derive1_comp// derive1N// derive1_id mulN1r derive1_comp// derive1E. +have/funeqP -> := @derive_expR R. +by rewrite derive1Ml// derive1_id mulr1 mulrN opprK mulrC exponential_pdfE ?ltW. +Qed. + +Let cexpNM : continuous (fun z : R^o => expR (- rate * z)). +Proof. +move=> z; apply: continuous_comp; last exact: continuous_expR. +by apply: continuousM => //; apply: (@continuousN _ R^o); exact: cst_continuous. +Qed. + +Lemma exponential_prob_itv0c (x : R) : 0 < x -> + exponential_prob rate `[0, x] = (1 - (expR (- rate * x))%:E)%E. +Proof. +move=> x0. +rewrite (_: 1 = - (- expR (- rate * 0))%:E)%E; last first. + by rewrite mulr0 expR0 EFinN oppeK. +rewrite addeC. +apply: (@continuous_FTC2 _ _ (fun x => - expR (- rate * x))) => //. +- apply: (@continuous_subspaceW R^o _ _ [set` `[0, +oo[%R]). + + exact: subset_itvl. + + exact: within_continuous_exponential_pdf. +- split. + + by move=> z _; exact: ex_derive. + + by apply/cvg_at_right_filter; apply: cvgN; exact: cexpNM. + + by apply/cvg_at_left_filter; apply: cvgN; exact: cexpNM. +- move=> z; rewrite in_itv/= => /andP[z0 _]. + by apply: derive1_exponential_pdf; rewrite in_itv/= andbT. +Qed. + +Lemma integral_exponential_pdf : (\int[mu]_x (exponential_pdf rate x)%:E = 1)%E. +Proof. +have mEex : measurable_fun setT (EFin \o exponential_pdf rate). + by apply/measurable_EFinP; exact: measurable_exponential_pdf. +rewrite -(setUv `[0, +oo[%classic) ge0_integral_setU//=; last 4 first. + exact: measurableC. + by rewrite setUv. + by move=> x _; rewrite lee_fin exponential_pdf_ge0. + exact/disj_setPCl. +rewrite [X in _ + X]integral0_eq ?adde0; last first. + by move=> x x0; rewrite /exponential_pdf patchE ifF// memNset. +rewrite (@ge0_continuous_FTC2y _ _ + (fun x => - (expR (- rate * x))) _ 0)//. +- by rewrite mulr0 expR0 EFinN oppeK add0e. +- by move=> x _; apply: exponential_pdf_ge0. +- exact: within_continuous_exponential_pdf. +- rewrite -oppr0; apply: (@cvgN _ R^o). + rewrite (_ : (fun x => expR (- rate * x)) = + (fun z => expR (- z)) \o (fun z => rate * z)); last first. + by apply: eq_fun => x; rewrite mulNr. + apply: (@cvg_comp _ R^o _ _ _ _ (pinfty_nbhs R)); last exact: cvgr_expR. + exact: gt0_cvgMry. +- by apply: (@cvgN _ R^o); apply: cvg_at_right_filter; exact: cexpNM. +- exact: derive1_exponential_pdf. +Qed. + +Lemma integrable_exponential_pdf : + mu.-integrable setT (EFin \o (exponential_pdf rate)). +Proof. +have mEex : measurable_fun setT (EFin \o exponential_pdf rate). + by apply/measurable_EFinP; exact: measurable_exponential_pdf. +apply/integrableP; split => //. +under eq_integral do rewrite /= ger0_norm ?exponential_pdf_ge0//. +by rewrite /= integral_exponential_pdf ltry. +Qed. + +Local Notation exponential := (exponential_prob rate). + +Let exponential0 : exponential set0 = 0%E. +Proof. by rewrite /exponential integral_set0. Qed. + +Let exponential_ge0 A : (0 <= exponential A)%E. +Proof. +rewrite /exponential integral_ge0//= => x _. +by rewrite lee_fin exponential_pdf_ge0. +Qed. + +Let exponential_sigma_additive : semi_sigma_additive exponential. +Proof. +move=> /= F mF tF mUF; rewrite /exponential; apply: cvg_toP. + apply: ereal_nondecreasing_is_cvgn => m n mn. + apply: lee_sum_nneg_natr => // k _ _; apply: integral_ge0 => /= x Fkx. + by rewrite lee_fin; apply: exponential_pdf_ge0. +rewrite ge0_integral_bigcup//=. +- apply/measurable_funTS/measurableT_comp => //. + exact: measurable_exponential_pdf. +- by move=> x _; rewrite lee_fin exponential_pdf_ge0. +Qed. + +HB.instance Definition _ := isMeasure.Build _ _ _ + exponential exponential0 exponential_ge0 exponential_sigma_additive. + +Let exponential_setT : exponential [set: R] = 1%E. +Proof. by rewrite /exponential integral_exponential_pdf. Qed. + +HB.instance Definition _ := + @Measure_isProbability.Build _ _ R exponential exponential_setT. + +End exponential_prob. diff --git a/theories/topology_theory/.DS_Store b/theories/topology_theory/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..5008ddfcf53c02e82d7eee2e57c38e5672ef89f6 GIT binary patch literal 6148 zcmeH~Jr2S!425mzP>H1@V-^m;4Wg<&0T*E43hX&L&p$$qDprKhvt+--jT7}7np#A3 zem<@ulZcFPQ@L2!n>{z**++&mCkOWA81W14cNZlEfg7;MkzE(HCqgga^y>{tEnwC%0;vJ&^%eQ zLs35+`xjp>T0 Date: Sun, 13 Jul 2025 14:07:48 +0900 Subject: [PATCH 04/10] Revert "generalize cumulative" This reverts commit 558558ec2b062927f846362758867e3054a8dc48. Reason: I mistakenly committed some unnecessary files. --- .DS_Store | Bin 8196 -> 0 bytes _CoqProject | 1 + reals/#reals.v# | 714 ----- reals/all_reals.v | 1 + reals/interval_inference.v | 1642 +++++++++++ theories/.DS_Store | Bin 6148 -> 0 bytes theories/HBgraph.dot | 2825 ------------------- theories/cumulative_1.txt | 86 - theories/cumulative_1.v | 86 - theories/cumulative_2.txt | 86 - theories/cumulative_2.v | 86 - theories/cumulative_3.txt | 90 - theories/cumulative_3.v | 90 - theories/lebesgue_integral_theory/.DS_Store | Bin 6148 -> 0 bytes theories/probability_20250713.v | 2015 ------------- theories/probability_lscdf_20250703.v | 1929 ------------- theories/topology_theory/.DS_Store | Bin 6148 -> 0 bytes theories/topology_theory/num_topology.v | 4 - 18 files changed, 1644 insertions(+), 8011 deletions(-) delete mode 100644 .DS_Store delete mode 100644 reals/#reals.v# create mode 100644 reals/interval_inference.v delete mode 100644 theories/.DS_Store delete mode 100644 theories/HBgraph.dot delete mode 100644 theories/cumulative_1.txt delete mode 100644 theories/cumulative_1.v delete mode 100644 theories/cumulative_2.txt delete mode 100644 theories/cumulative_2.v delete mode 100644 theories/cumulative_3.txt delete mode 100644 theories/cumulative_3.v delete mode 100644 theories/lebesgue_integral_theory/.DS_Store delete mode 100644 theories/probability_20250713.v delete mode 100644 theories/probability_lscdf_20250703.v delete mode 100644 theories/topology_theory/.DS_Store diff --git a/.DS_Store b/.DS_Store deleted file mode 100644 index 4a74ecdf18e8038add760ae4f4d1c7ed968c88ae..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 8196 zcmeHMTWl0n7(U;$zzmatX#p)Du(%N_w4trsQCW7&O=?=$-a+c@&Oj$jXO^AWEf*Ub zeFQHr8jVC_;w{nOi;BcVeK01P7!#=^V4`AtGU3GsF>0d!nKRqamPVfpN#`VU{`qg` z^#Aw!&)I*=7(=>bHZxYo7?bJYR99)b#o&7WOc_!nsU`~YXROF=&k3$AUNm zaR%ZH#2JV)5NF_a$N=5he8|(>`$8MfaR%ZH%*YJz^C3YGr>TgJ3K||AG=(hyQQiWC zgWjnR2z?R}O+|E6(9o6E6x{a2um0Z&geX~L# zE3z`6FFt*`dDF(`hD1xt`jLjj=`Afy4T<&lZ5$a<ZwJ@Q{RFmL!euph%O)Sm2*j65tH z!BG@Y#tEFnDLjcYcnVMB8N7g3@fu#o8+aEV;}d*}FK`KC_!i&e2VBEXxQ^d&1HVgi zr3KPLX^~VfHA`EijI>AEFaCC^Qbzri*dlqB=#=w;%BUd9NIEx78SUP)_o028Z{ISy zGG7$V9e38Pnyi1QE!lK?ulc*)YcwB>4|Qhk%FvWp7D zIw5nE>vM#4QoTo}0?}s)wq9K$Q)%e41>2~tlc^YWDP+|aZM{Mzr&kHKQQNG@Is~&# zeL$h&)2juWQqu~rd!2>6)~M~0WnKQy$o>~xf5|SfE9@G(PPqOX)lg7}mADt{um#(Z zA|$tB7uwN*1B7Re<^dSU!Nd?;LiBO?cnl+W9HV%GP<@tg%~Aa#Ucx!Nj5qNX-o`sP zj|=z^7x583!&kVB?S~@WJgy1r1$j3fpm_VLMKA{2zw&o*+~1lZxo5 apd_L3zyA;*zDCFQe|-N70EQ@>dDB0Hfmjp( diff --git a/_CoqProject b/_CoqProject index 4c48041b47..47e426cfcf 100644 --- a/_CoqProject +++ b/_CoqProject @@ -30,6 +30,7 @@ reals/constructive_ereal.v reals/reals.v reals/real_interval.v reals/signed.v +reals/interval_inference.v reals/prodnormedzmodule.v reals/all_reals.v experimental_reals/xfinmap.v diff --git a/reals/#reals.v# b/reals/#reals.v# deleted file mode 100644 index 15ca7eaf63..0000000000 --- a/reals/#reals.v# +++ /dev/null @@ -1,714 +0,0 @@ -(* mathcomp analysis (c) 2017 Inria and AIST. License: CeCILL-C. *) -(* -------------------------------------------------------------------- *) -(* Copyright (c) - 2015--2016 - IMDEA Software Institute *) -(* Copyright (c) - 2015--2018 - Inria *) -(* Copyright (c) - 2016--2018 - Polytechnique *) -(* -------------------------------------------------------------------- *) - -(**md**************************************************************************) -(* # An axiomatization of real numbers $\mathbb{R}$ *) -(* *) -(* This file provides a classical axiomatization of real numbers as a *) -(* discrete real archimedean field with in particular a theory of floor and *) -(* ceil. *) -(* *) -(* ``` *) -(* realType == type of real numbers *) -(* The HB class is Real. *) -(* sup A == where A : set R with R : realType, the supremum of A when *) -(* it exists, 0 otherwise *) -(* inf A := - sup (- A) *) -(* ``` *) -(* *) -(* The mixin corresponding to realType extends an archiFieldType with two *) -(* properties: *) -(* - when sup A exists, it is an upper bound of A (lemma sup_upper_bound) *) -(* - when sup A exists, there exists an element x in A such that *) -(* sup A - eps < x for any 0 < eps (lemma sup_adherent) *) -(* *) -(* ``` *) -(* Rint == the set of real numbers that can be written as z%:~R, *) -(* i.e., as an integer *) -(* Rtoint r == r when r is an integer, 0 otherwise *) -(* floor_set x := [set y | Rtoint y /\ y <= x] *) -(* Rfloor x == the floor of x as a real number *) -(* range1 x := [set y |x <= y < x + 1] *) -(* Rceil x == the ceil of x as a real number, i.e., - Rfloor (- x) *) -(* ``` *) -(* *) -(******************************************************************************) - -From Corelib Require Import Setoid. -From HB Require Import structures. -From mathcomp Require Import all_ssreflect all_algebra archimedean. -From mathcomp Require Import boolp classical_sets set_interval. - -Declare Scope real_scope. - -(* -------------------------------------------------------------------- *) -Set Implicit Arguments. -Unset Strict Implicit. -Unset Printing Implicit Defensive. -Unset SsrOldRewriteGoalsOrder. - -Import Order.TTheory Order.Syntax GRing.Theory Num.Def Num.Theory. -From mathcomp Require Import mathcomp_extra unstable. - -(* -------------------------------------------------------------------- *) -Delimit Scope real_scope with real. - -Local Open Scope classical_set_scope. -Local Open Scope ring_scope. - -Section subr_image. -Variable R : numDomainType. -Implicit Types (E : set R) (x : R). - -Lemma has_ub_lbN E : has_ubound E <-> has_lbound (-%R @` E). -Proof. -rewrite has_lb_ubN image_comp /comp /=. -by under eq_fun do rewrite opprK; rewrite image_id. -Qed. - -Lemma has_lbound0 : has_lbound (@set0 R). Proof. by exists 0. Qed. - -Lemma has_ubound0 : has_ubound (@set0 R). Proof. by exists 0. Qed. - -Lemma ubound0 : ubound (@set0 R) = setT. -Proof. by rewrite predeqE => r; split => // _. Qed. - -Lemma lboundT : lbound [set: R] = set0. -Proof. -rewrite predeqE => r; split => // /(_ (r - 1) Logic.I). -by rewrite addrC -subr_ge0 addrK ler0N1. -Qed. - -End subr_image. - -Section has_bound_lemmas. -Variable R : realDomainType. -Implicit Types E : set R. -Implicit Types x : R. - -Lemma has_ub_image_norm E : has_ubound (normr @` E) -> has_ubound E. -Proof. -case => M /ubP uM; exists `|M|; apply/ubP => r rS. -by rewrite (le_trans (ler_norm _))// (le_trans (uM _ _))//; exact: ler_norm. -Qed. - -Lemma has_inf_supN E : has_sup (-%R @` E) <-> has_inf E. -Proof. -split=> [ [NEn0 [x /ub_lbN xubE]] | [En0 [x /lb_ubN xlbe]] ]. -by split; [apply/nonemptyN|rewrite -[E]setNK; exists (- x)]. -by split; [apply/nonemptyN|exists (- x)]. -Qed. - -Lemma has_supPn {E} : E !=set0 -> - ~ has_sup E <-> (forall x, exists2 y, E y & x < y). -Proof. -move=> nzE; split=> [/asboolPn|/has_ubPn h [_]] //. -by rewrite asbool_and (asboolT nzE) /= => /asboolP/has_ubPn. -Qed. - -End has_bound_lemmas. - -(* -------------------------------------------------------------------- *) - -HB.mixin Record ArchimedeanField_isReal R of Num.ArchiField R := { - sup_upper_bound_subdef : forall E : set R, - has_sup E -> ubound E (supremum 0 E) ; - sup_adherent_subdef : forall (E : set R) (eps : R), - 0 < eps -> has_sup E -> exists2 e : R, E e & (supremum 0 E - eps) < e -}. - -#[short(type=realType)] -HB.structure Definition Real := {R of ArchimedeanField_isReal R - & Num.ArchiField R & Num.RealClosedField R}. - -#[export, non_forgetful_inheritance] -HB.instance Definition _ (R : realType) := - Order_isNbhs.Build _ R (@real_order_nbhsE R). - -Bind Scope ring_scope with Real.sort. - -(* -------------------------------------------------------------------- *) -Definition sup {R : realType} := @supremum _ R 0. -Definition inf {R : realType} (E : set R) := - sup (-%R @` E). - -(* -------------------------------------------------------------------- *) -Lemma sup_upper_bound {R : realType} (E : set R): - has_sup E -> ubound E (sup E). -Proof. exact: sup_upper_bound_subdef. Qed. - -Lemma sup_adherent {R : realType} (E : set R) (eps : R) : 0 < eps -> - has_sup E -> exists2 e : R, E e & (sup E - eps) < e. -Proof. exact: sup_adherent_subdef. Qed. - -(* -------------------------------------------------------------------- *) -Section IsInt. -Context {R : realFieldType}. - -Definition Rint_pred := fun x : R => `[< exists z, x == z%:~R >]. -Arguments Rint_pred _ /. -Definition Rint := [qualify a x | Rint_pred x]. - -Lemma Rint_def x : (x \is a Rint) = (`[< exists z, x == z%:~R >]). -Proof. by []. Qed. - -Lemma RintP x : reflect (exists z, x = z%:~R) (x \in Rint). -Proof. -by apply/(iffP idP) => [/asboolP[z /eqP]|[z]] ->; [|apply/asboolP]; exists z. -Qed. - -Lemma RintC z : z%:~R \is a Rint. -Proof. by apply/RintP; exists z. Qed. - -Lemma Rint0 : 0 \is a Rint. -Proof. by rewrite -[0](mulr0z 1) RintC. Qed. - -Lemma Rint1 : 1 \is a Rint. -Proof. by rewrite -[1]mulr1z RintC. Qed. - -Hint Resolve Rint0 Rint1 RintC : core. - -Lemma Rint_subring_closed : subring_closed Rint. -Proof. -split=> // _ _ /RintP[x ->] /RintP[y ->]; apply/RintP. -by exists (x - y); rewrite rmorphB. by exists (x * y); rewrite rmorphM. -Qed. - -HB.instance Definition _ := GRing.isSubringClosed.Build R Rint_pred - Rint_subring_closed. - -Lemma Rint_ler_addr1 (x y : R) : x \is a Rint -> y \is a Rint -> - (x + 1 <= y) = (x < y). -Proof. -move=> /RintP[xi ->] /RintP[yi ->]; rewrite -{2}[1]mulr1z. -by rewrite -intrD !(ltr_int, ler_int) lezD1. -Qed. - -Lemma Rint_ltr_addr1 (x y : R) : x \is a Rint -> y \is a Rint -> - (x < y + 1) = (x <= y). -Proof. -move=> /RintP[xi ->] /RintP[yi ->]; rewrite -{3}[1]mulr1z. -by rewrite -intrD !(ltr_int, ler_int) ltzD1. -Qed. - -End IsInt. -Arguments Rint_pred _ _ /. - -(* -------------------------------------------------------------------- *) -Section ToInt. -Context {R : realType}. - -Implicit Types x y : R. - -Definition Rtoint (x : R) : int := - if insub x : {? x | x \is a Rint} is Some Px then - xchoose (asboolP _ (tagged Px)) - else 0. - -Lemma RtointK (x : R): x \is a Rint -> (Rtoint x)%:~R = x. -Proof. -move=> Ix; rewrite /Rtoint insubT /= [RHS](eqP (xchooseP (asboolP _ Ix))). -by congr _%:~R; apply/eq_xchoose. -Qed. - -Lemma Rtointz (z : int): Rtoint z%:~R = z. -Proof. by apply/eqP; rewrite -(@eqr_int R) RtointK ?rpred_int. Qed. - -Lemma Rtointn (n : nat): Rtoint n%:R = n%:~R. -Proof. by rewrite -{1}mulrz_nat Rtointz. Qed. - -Lemma inj_Rtoint : {in Rint &, injective Rtoint}. -Proof. by move=> x y Ix Iy /= /(congr1 (@intmul R 1)); rewrite !RtointK. Qed. - -Lemma RtointN x : x \is a Rint -> Rtoint (- x) = - Rtoint x. -Proof. -move=> Ir; apply/eqP. -by rewrite -(@eqr_int R) RtointK // ?rpredN // mulrNz RtointK. -Qed. - -End ToInt. - -(* -------------------------------------------------------------------- *) - -Section RealDerivedOps. -Variable R : realType. - -Implicit Types x y : R. -Definition floor_set x := [set y : R | (y \is a Rint) && (y <= x)]. - -Definition Rfloor x : R := (floor x)%:~R. - -Definition range1 (x : R) := [set y | x <= y < x + 1]. - -Definition Rceil x : R := (ceil x)%:~R. - -End RealDerivedOps. - -(*-------------------------------------------------------------------- *) -Section RealLemmas. - -Variables (R : realType). - -Implicit Types E : set R. -Implicit Types x : R. - -Lemma sup_out E : ~ has_sup E -> sup E = 0. Proof. exact: supremum_out. Qed. - -Lemma sup0 : sup (@set0 R) = 0. Proof. exact: supremum0. Qed. - -Lemma sup1 x : sup [set x] = x. Proof. exact: supremum1. Qed. - -Lemma sup_ubound {E} : has_ubound E -> ubound E (sup E). -Proof. -move=> ubE; apply/ubP=> x x_in_E; move: (x) (x_in_E). -by apply/ubP/sup_upper_bound=> //; split; first by exists x. -Qed. - -Lemma sup_ub_strict E : has_ubound E -> - ~ E (sup E) -> E `<=` [set r | r < sup E]. -Proof. -move=> ubE EsupE r Er; rewrite /mkset lt_neqAle sup_ubound // andbT. -by apply/negP => /eqP supEr; move: EsupE; rewrite -supEr. -Qed. - -Lemma sup_total {E} x : has_sup E -> down E x \/ sup E <= x. -Proof. -move=> has_supE; rewrite orC. -case: (lerP (sup E) x)=> hx /=; [by left|right]. -have /sup_adherent/(_ has_supE) : 0 < sup E - x by rewrite subr_gt0. -by case=> e Ee; rewrite subKr => /ltW hlte; apply/downP; exists e. -Qed. - -Lemma sup_le_ub {E} x : E !=set0 -> (ubound E) x -> sup E <= x. -Proof. -move=> hasE leEx; set y := sup E; pose z := (x + y) / 2%:R. -have Dz: 2%:R * z = x + y by rewrite mulrC divfK// pnatr_eq0. -have ubE : has_sup E by split => //; exists x. -have [/downP [t Et lezt] | leyz] := sup_total z ubE. - rewrite -(lerD2l x) -Dz -mulr2n -[leRHS]mulr_natl. - rewrite ler_pM2l ?ltr0Sn //; apply/(le_trans lezt). - by move/ubP : leEx; exact. -rewrite -(lerD2r y) -Dz -mulr2n -[leLHS]mulr_natl. -by rewrite ler_pM2l ?ltr0Sn. -Qed. - -Lemma sup_setU (A B : set R) : has_sup B -> - (forall a b, A a -> B b -> a <= b) -> sup (A `|` B) = sup B. -Proof. -move=> [B0 [l Bl]] AB; apply/eqP; rewrite eq_le; apply/andP; split. -- apply sup_le_ub => [|x [Ax|]]; first by apply: subset_nonempty B0 => ?; right. - by case: B0 => b Bb; rewrite (le_trans (AB _ _ Ax Bb)) // sup_ubound //; exists l. -- by move=> Bx; rewrite sup_ubound //; exists l. -- apply sup_le_ub => // b Bb; apply: sup_ubound; last by right. - by exists l => x [Ax|Bx]; [rewrite (le_trans (AB _ _ Ax Bb)) // Bl|exact: Bl]. -Qed. - -Lemma sup_gt (S : set R) (x : R) : S !=set0 -> - (x < sup S -> exists2 y, S y & x < y)%R. -Proof. -move=> S0; rewrite not_exists2P => + g; apply/negP; rewrite -leNgt. -by apply sup_le_ub => // y Sy; move: (g y) => -[// | /negP]; rewrite leNgt. -Qed. - -End RealLemmas. -#[deprecated(since="mathcomp-analysis 1.3.0", note="Renamed `sup_ubound`.")] -Notation sup_ub := sup_ubound (only parsing). - -Section sup_sum. -Context {R : realType}. - -Lemma sup_sumE (A B : set R) : - has_sup A -> has_sup B -> sup [set x + y | x in A & y in B] = sup A + sup B. -Proof. -move=> /[dup] supA [[a Aa] ubA] /[dup] supB [[b Bb] ubB]. -have ABsup : has_sup [set x + y | x in A & y in B]. - split; first by exists (a + b), a => //; exists b. - case: ubA ubB => p up [q uq]; exists (p + q) => ? [r Ar [s Bs] <-]. - by apply: lerD; [exact: up | exact: uq]. -apply: le_anti; apply/andP; split. - apply: sup_le_ub; first by case: ABsup. - by move=> ? [p Ap [q Bq] <-]; apply: lerD; exact: sup_ubound. -rewrite leNgt -subr_gt0; apply/negP. -set eps := (_ + _ - _) => epos. -have e2pos : 0 < eps / 2%:R by rewrite divr_gt0// ltr0n. -have [r Ar supBr] := sup_adherent e2pos supA. -have [s Bs supAs] := sup_adherent e2pos supB. -have := ltrD supBr supAs. -rewrite -addrACA -opprD -splitr subKr; apply/negP; rewrite -leNgt. -by apply: sup_upper_bound => //; exists r => //; exists s. -Qed. - -Lemma inf_sumE (A B : set R) : - has_inf A -> has_inf B -> inf [set x + y | x in A & y in B] = inf A + inf B. -Proof. -move/has_inf_supN => ? /has_inf_supN ?; rewrite /inf. -rewrite [X in - sup X = _](_ : _ = - [set x + y | x in [set - x | x in A ] & y in [set - x | x in B]]). - rewrite eqEsubset; split => /= t [] /= x []a Aa. - case => b Bb <- <-; exists (- a); first by exists a. - by exists (- b); [exists b|rewrite opprD]. - move=> <- [y] [b Bb] <- <-; exists (a + b); last by rewrite opprD. - by exists a => //; exists b. -by rewrite sup_sumE // -opprD. -Qed. - -End sup_sum. - -(* -------------------------------------------------------------------- *) -Section InfTheory. - -Variables (R : realType). - -Implicit Types E : set R. -Implicit Types x : R. - -Lemma inf_adherent E (eps : R) : 0 < eps -> - has_inf E -> exists2 e, E e & e < inf E + eps. -Proof. -move=> + /has_inf_supN supNE => /sup_adherent /(_ supNE)[e NEx egtsup]. -exists (- e); first by case: NEx => x Ex <-{}; rewrite opprK. -by rewrite ltrNl -mulN1r mulrDr !mulN1r opprK. -Qed. - -Lemma inf_out E : ~ has_inf E -> inf E = 0. -Proof. -move=> ninfE; rewrite -oppr0 -(@sup_out _ (-%R @` E)) => // supNE; apply: ninfE. -exact/has_inf_supN. -Qed. - -Lemma inf0 : inf (@set0 R) = 0. -Proof. by rewrite /inf image_set0 sup0 oppr0. Qed. - -Lemma inf1 x : inf [set x] = x. -Proof. by rewrite /inf image_set1 sup1 opprK. Qed. - -Lemma inf_lbound E : has_lbound E -> lbound E (inf E). -Proof. by move/has_lb_ubN/sup_ubound/ub_lbN; rewrite setNK. Qed. - -Lemma inf_lb_strict E : has_lbound E -> - ~ E (inf E) -> E `<=` [set r | inf E < r]. -Proof. -move=> lE EinfE r Er; rewrite /mkset lt_neqAle inf_lbound // andbT. -by apply/negP => /eqP infEr; move: EinfE; rewrite infEr. -Qed. - -Lemma lb_le_inf E x : nonempty E -> (lbound E) x -> x <= inf E. -Proof. -by move=> /(nonemptyN E) En0 /lb_ubN /(sup_le_ub En0); rewrite lerNr. -Qed. - -Lemma has_infPn E : nonempty E -> - ~ has_inf E <-> (forall x, exists2 y, E y & y < x). -Proof. -move=> nzE; split=> [/asboolPn|/has_lbPn h [_] //]. -by rewrite asbool_and (asboolT nzE) /= => /asboolP/has_lbPn. -Qed. - -Lemma inf_setU (A B : set R) : has_inf A -> - (forall a b, A a -> B b -> a <= b) -> inf (A `|` B) = inf A. -Proof. -move=> hiA AB; congr (- _). -rewrite image_setU setUC sup_setU //; first exact/has_inf_supN. -by move=> _ _ [] b Bb <-{} [] a Aa <-{}; rewrite lerNl opprK; apply AB. -Qed. - -Lemma inf_lt (S : set R) (x : R) : S !=set0 -> - (inf S < x -> exists2 y, S y & y < x)%R. -Proof. -move=> /nonemptyN S0; rewrite /inf ltrNl => /sup_gt => /(_ S0)[r [r' Sr']]. -by move=> <-; rewrite ltrNr opprK => r'x; exists r'. -Qed. - -End InfTheory. -#[deprecated(since="mathcomp-analysis 1.3.0", note="Renamed `inf_lbound`.")] -Notation inf_lb := inf_lbound (only parsing). - -(* -------------------------------------------------------------------- *) -Section FloorTheory. -Variable R : realType. - -Implicit Types x y : R. - -Lemma has_sup_floor_set x : has_sup (floor_set x). -Proof. -split; [exists (- (Num.bound (-x))%:~R) | exists (Num.bound x)%:~R]. - rewrite /floor_set/mkset rpredN rpred_int /= lerNl. - case: (ger0P (-x)) => [/archi_boundP/ltW//|]. - by move/ltW/le_trans; apply; rewrite ler0z. -apply/ubP=> y /andP[_] /le_trans; apply. -case: (ger0P x)=> [/archi_boundP/ltW|] //. -by move/ltW/le_trans; apply; rewrite ler0z. -Qed. - -Lemma sup_in_floor_set x : (floor_set x) (sup (floor_set x)). -Proof. -have /(sup_adherent ltr01) [y Fy] := has_sup_floor_set x. -have /sup_upper_bound /ubP /(_ _ Fy) := has_sup_floor_set x. -rewrite le_eqVlt=> /orP[/eqP<-//| lt_yFx]. -rewrite ltrBlDr -ltrBlDl => lt1_FxBy. -pose e := sup (floor_set x) - y; have := has_sup_floor_set x. -move/sup_adherent=> -/(_ e) []; first by rewrite subr_gt0. -move=> z Fz; rewrite /= subKr => lt_yz. -have /sup_upper_bound /ubP /(_ _ Fz) := has_sup_floor_set x. -rewrite -(lerD2r (-y)) => /le_lt_trans /(_ lt1_FxBy). -case/andP: Fy Fz lt_yz=> /RintP[yi -> _]. -case/andP=> /RintP[zi -> _]; rewrite -rmorphB /= ltrz1 ltr_int. -rewrite lt_neqAle => /andP[ne_yz le_yz]. -rewrite -[_-_]gez0_abs ?subr_ge0 // ltz_nat ltnS leqn0. -by rewrite absz_eq0 subr_eq0 eq_sym (negbTE ne_yz). -Qed. - -Lemma isint_Rfloor x : Rfloor x \is a Rint. -Proof. by rewrite inE; exists (floor x). Qed. - -Lemma RfloorE x : Rfloor x = (floor x)%:~R. -Proof. by []. Qed. - -Lemma mem_rg1_floor x : (range1 (floor x)%:~R) x. -Proof. by rewrite /range1 /mkset intrD1 ge_floor floorD1_gt. Qed. - -Lemma mem_rg1_Rfloor x : (range1 (Rfloor x)) x. -Proof. exact: mem_rg1_floor. Qed. - -Lemma Rfloor_le x : Rfloor x <= x. -Proof. by case/andP: (mem_rg1_Rfloor x). Qed. - -Lemma lt_succ_Rfloor x : x < Rfloor x + 1. -Proof. by case/andP: (mem_rg1_Rfloor x). Qed. - -Lemma range1z_inj x (m1 m2 : int) : - (range1 m1%:~R) x -> (range1 m2%:~R) x -> m1 = m2. -Proof. -move=> /andP[m1x x_m1] /andP[m2x x_m2]. -wlog suffices: m1 m2 m1x {x_m1 m2x} x_m2 / (m1 <= m2). - by move=> ih; apply/eqP; rewrite eq_le !ih. -rewrite -(lerD2r 1) lezD1 -(@ltr_int R) intrD. -exact/(le_lt_trans m1x). -Qed. - -Lemma range1rr x : (range1 x) x. -Proof. by rewrite /range1/mkset lexx /= ltrDl ltr01. Qed. - -Lemma range1zP (m : int) x : Rfloor x = m%:~R <-> (range1 m%:~R) x. -Proof. -split=> [<-|h]; first exact/mem_rg1_Rfloor. -by congr intmul; apply/floor_def; rewrite -intrD1. -Qed. - -Lemma Rfloor_natz (z : int) : Rfloor z%:~R = z%:~R :> R. -Proof. by apply/range1zP/range1rr. Qed. - -Lemma Rfloor0 : Rfloor 0 = 0 :> R. Proof. by rewrite /Rfloor floor0. Qed. - -Lemma Rfloor1 : Rfloor 1 = 1 :> R. Proof. by rewrite /Rfloor floor1. Qed. - -Lemma le_Rfloor : {homo (@Rfloor R) : x y / x <= y}. -Proof. by move=> x y /Num.Theory.floor_le; rewrite ler_int. Qed. - -Lemma Rfloor_ge_int x (n : int) : (n%:~R <= x)= (n%:~R <= Rfloor x). -Proof. by rewrite ler_int floor_ge_int. Qed. - -Lemma Rfloor_lt_int x (z : int) : (x < z%:~R) = (Rfloor x < z%:~R). -Proof. by rewrite ltr_int -floor_lt_int. Qed. - -Lemma Rfloor_le0 x : x <= 0 -> Rfloor x <= 0. -Proof. by move=> ?; rewrite -Rfloor0 le_Rfloor. Qed. - -Lemma Rfloor_lt0 x : x < 0 -> Rfloor x < 0. -Proof. by move=> x0; rewrite (le_lt_trans _ x0) // Rfloor_le. Qed. - -Lemma ltr_add_invr (y x : R) : y < x -> exists k, y + k.+1%:R^-1 < x. -Proof. -move=> yx; exists (trunc (x - y)^-1). -by rewrite -ltrBrDl invf_plt 1?posrE 1?subr_gt0// truncnS_gt. -Qed. - -End FloorTheory. - -Section CeilTheory. -Variable R : realType. - -Implicit Types x y : R. - -Lemma isint_Rceil x : Rceil x \is a Rint. -Proof. by rewrite /Rceil RintC. Qed. - -Lemma Rceil0 : Rceil 0 = 0 :> R. -Proof. by rewrite /Rceil ceil0. Qed. - -Lemma Rceil_ge x : x <= Rceil x. -Proof. by rewrite Num.Theory.le_ceil ?num_real. Qed. - -Lemma le_Rceil : {homo (@Rceil R) : x y / x <= y}. -Proof. by move=> x y ?; rewrite /Rceil ler_int ceil_le. Qed. - -Lemma Rceil_ge0 x : 0 <= x -> 0 <= Rceil x. -Proof. by move=> x0; rewrite /Rceil ler0z -(ceil0 R) ceil_le. Qed. - -Lemma RceilE x : Rceil x = (ceil x)%:~R. -Proof. by []. Qed. - -#[deprecated(since="mathcomp-analysis 1.3.0", note="use `Num.Theory.ceil_le` instead")] -Lemma le_ceil : {homo @Num.ceil R : x y / x <= y}. -Proof. exact: ceil_le. Qed. - -End CeilTheory. - -(* -------------------------------------------------------------------- *) -Section Sup. -Context {R : realType}. -Implicit Types A B : set R. - -Lemma le_down A : A `<=` down A. -Proof. by move=> x xA; apply/downP; exists x. Qed. - -Lemma downK A : down (down A) = down A. -Proof. -rewrite predeqE => x; split; last by move=> Ax; apply/downP; exists x. -case/downP => y /downP[z Az yz xy]. -by apply/downP; exists z => //; rewrite (le_trans xy). -Qed. - -Lemma has_sup_down A : has_sup (down A) <-> has_sup A. -Proof. -split=> -[nzA nzubA]. - case: nzA => x /downP[y yS le_xy]; split; first by exists y. - case: nzubA=> u /ubP ubA; exists u; apply/ubP=> z zS. - by apply/ubA; apply/downP; exists z. -case: nzA => x xA; split; first by exists x; apply/le_down. -case: nzubA => u /ubP ubA; exists u; apply/ubP=> y /downP []. -by move=> z zA /le_trans; apply; apply/ubA. -Qed. - -Lemma le_sup A B : A `<=` down B -> nonempty A -> has_sup B -> - sup A <= sup B. -Proof. -move=> le_AB nz_A hs_B; have hs_A: has_sup A. - split=> //; case: hs_B => _ [x ubx]. - exists x; apply/ubP=> y /le_AB /downP[z zB le_yz]. - by apply/(le_trans le_yz); move/ubP: ubx; apply. -rewrite leNgt -subr_gt0; apply/negP => lt_sup. -case: (sup_adherent lt_sup hs_A )=> x /le_AB xdB. -rewrite subKr => lt_Bx; case/downP: xdB => z zB. -move/(lt_le_trans lt_Bx); rewrite ltNge. -by move/ubP : (sup_upper_bound hs_B) => ->. -Qed. - -Lemma le_inf A B : -%R @` B `<=` down (-%R @` A) -> nonempty B -> has_inf A -> - inf A <= inf B. -Proof. -move=> SBA AB Ai; rewrite lerNl opprK le_sup// ?has_inf_supN//. -exact/nonemptyN. -Qed. - -Lemma sup_down A : sup (down A) = sup A. -Proof. -have [supA|supNA] := pselect (has_sup A); last first. - by rewrite !sup_out // => /has_sup_down. -have supDA : has_sup (down A) by apply/has_sup_down. -apply/eqP; rewrite eq_le !le_sup //. -- by case: supA => -[x xA] _; exists x; apply/le_down. -- by rewrite downK; exact: le_down. -- by case: supA. -Qed. - -Lemma lt_sup_imfset {T : Type} (F : T -> R) l : - has_sup [set y | exists x, y = F x] -> - l < sup [set y | exists x, y = F x] -> - exists2 x, l < F x & F x <= sup [set y | exists x, y = F x]. -Proof. -set P := [set y | _] => hs; rewrite -subr_gt0. -move=> /sup_adherent/(_ hs)[_ [x ->]]; rewrite subKr=> lt_lFx. -by exists x => //; move/ubP : (sup_upper_bound hs) => -> //; exists x. -Qed. - -Lemma lt_inf_imfset {T : Type} (F : T -> R) l : - has_inf [set y | exists x, y = F x] -> - inf [set y | exists x, y = F x] < l -> - exists2 x, F x < l & inf [set y | exists x, y = F x] <= F x. -Proof. -set P := [set y | _]; move=> hs; rewrite -subr_gt0. -move=> /inf_adherent/(_ hs)[_ [x ->]]; rewrite addrC subrK => ltFxl. -by exists x => //; rewrite (inf_lbound hs.2)//; exists x. -Qed. - -End Sup. - -Lemma int_lbound_has_minimum (B : set int) i : B !=set0 -> lbound B i -> - exists j, B j /\ forall k, B k -> j <= k. -Proof. -move=> [i0 Bi0] lbBi; have [n i0in] : exists n, i0 - i = n%:Z. - by exists `|i0 - i|%N; rewrite gez0_abs // subr_ge0; exact: lbBi. -elim: n i lbBi i0in => [i lbBi /eqP|n ih i lbBi i0in1]. - by rewrite subr_eq0 => /eqP i0i; exists i0; split =>// k Bk; rewrite i0i lbBi. -have i0i1n : i0 - (i + 1) = n by rewrite opprD addrA i0in1 -addn1 PoszD addrK. -have [?|/not_forallP] := pselect (lbound B (i + 1)); first exact: (ih (i + 1)). -move=> /contrapT[x /not_implyP[Bx i1x]]; exists x; split => // k Bk. -rewrite (le_trans _ (lbBi _ Bk)) //. -by move/negP : i1x; rewrite -ltNge ltzD1. -Qed. - -Section rat_in_itvoo. - -Let bound_div (R : archiFieldType) (x y : R) : nat := - if y < 0 then 0%N else Num.bound (y / x). - -Let archi_bound_divP (R : archiFieldType) (x y : R) : - 0 < x -> y < x *+ bound_div x y. -Proof. -move=> x0; have [y0|y0] := leP 0 y; last by rewrite /bound_div y0 mulr0n. -rewrite /bound_div (ltNge y 0) y0/= -mulr_natl -ltr_pdivrMr//. -by rewrite archi_boundP// (divr_ge0 _(ltW _)). -Qed. - -Lemma rat_in_itvoo (R : archiFieldType) (x y : R) : - x < y -> exists q, ratr q \in `]x, y[. -Proof. -move=> xy; move: (xy); rewrite -subr_gt0. -move=> /(archi_bound_divP 1); set n := bound_div _ _ => nyx. -have [m1 m1nx] : exists m1, m1.+1%:~R > x *+ n. - have := archi_bound_divP (x *+ n) ltr01; set p := bound_div _ _ => nxp. - have [x0|x0] := ltP 0 x. - exists p.-1; rewrite prednK // lt0n; apply: contraPN nxp => /eqP ->. - by apply/negP; rewrite -leNgt mulrn_wge0 // ltW. - by exists 0%N; rewrite (le_lt_trans _ ltr01) // mulrn_wle0. -have [m2 m2nx] : exists m2, m2.+1%:~R > - x *+ n. - have := archi_bound_divP (- x *+ n) ltr01; set p := bound_div _ _ => nxp. - have [x0|x0] := ltP 0 x. - by exists O; rewrite (le_lt_trans _ ltr01) // nmulrn_rle0// oppr_lt0. - exists p.-1; rewrite prednK // -(ltr_nat R) (le_lt_trans _ nxp) //. - by rewrite mulrn_wge0 // oppr_ge0. -have : exists m, -(m2.+1 : int) <= m <= m1.+1 /\ m%:~R - 1 <= x *+ n < m%:~R. - have m2m1 : - (m2.+1 : int) < m1.+1. - by rewrite -(ltr_int R) (lt_trans _ m1nx)// rmorphN /= ltrNl // -mulNrn. - pose B := [set m : int | m%:~R > x *+ n]. - have m1B : B m1.+1 by []. - have m2B : lbound B (- m2.+1%:~R). - move=> i; rewrite /B /= -(opprK (x *+ n)) -ltrNl -mulNrn => nxi. - rewrite -(mulN1r m2.+1%:~R) mulN1r -lerNl. - by have := lt_trans nxi m2nx; rewrite intz -mulrNz ltr_int => /ltW. - have [m [Bm infB]] := int_lbound_has_minimum (ex_intro _ _ m1B) m2B. - have mN1B : ~ B (m - 1). - by move=> /infB; apply/negP; rewrite -ltNge ltrBlDr ltzD1. - exists m; split; [apply/andP; split|apply/andP; split] => //. - - by move: m2B; rewrite /lbound /= => /(_ _ Bm); rewrite intz. - - exact: infB. - - by rewrite leNgt; apply/negP; rewrite /B /= intrD in mN1B. -move=> [m [/andP[m2m mm1] /andP[mnx nxm]]]. -have [/andP[a b] c] : x *+ n < m%:~R <= 1 + x *+ n /\ 1 + x *+ n < y *+ n. - split; [apply/andP; split|] => //; first by rewrite -lerBlDl. - by move: nyx; rewrite mulrnDl -ltrBrDr mulNrn. -have n_gt0 : n != 0%N by apply: contraTN nyx => /eqP ->; rewrite mulr0n ltr10. -exists (m%:Q / n%:Q); rewrite in_itv /=; apply/andP; split. - rewrite rmorphM/= (@rmorphV _ _ _ n%:~R); first by rewrite unitfE // intr_eq0. - rewrite ltr_pdivlMr /=; first by rewrite ltr0q ltr0z ltz_nat lt0n. - by rewrite mulrC // !ratr_int mulr_natl. -rewrite rmorphM /= (@rmorphV _ _ _ n%:~R); first by rewrite unitfE // intr_eq0. -rewrite ltr_pdivrMr /=; first by rewrite ltr0q ltr0z ltz_nat lt0n. -by rewrite 2!ratr_int mulr_natr (le_lt_trans _ c). -Qed. - -End rat_in_itvoo. diff --git a/reals/all_reals.v b/reals/all_reals.v index 928723a8a3..38290e6736 100644 --- a/reals/all_reals.v +++ b/reals/all_reals.v @@ -1,3 +1,4 @@ +From mathcomp Require Export interval_inference. From mathcomp Require Export constructive_ereal. From mathcomp Require Export reals. From mathcomp Require Export real_interval. diff --git a/reals/interval_inference.v b/reals/interval_inference.v new file mode 100644 index 0000000000..d3be1c30eb --- /dev/null +++ b/reals/interval_inference.v @@ -0,0 +1,1642 @@ +(* mathcomp analysis (c) 2017 Inria and AIST. License: CeCILL-C. *) +From HB Require Import structures. +From mathcomp Require Import ssreflect ssrfun ssrbool. +From mathcomp Require Import ssrnat eqtype choice order ssralg ssrnum ssrint. +From mathcomp Require Import interval. +From mathcomp Require Import mathcomp_extra. + +(* N.B.: This file has been backported in mathcomp-algebra 2.4.0, when +performing changes here, be careful to keep both files reasonnably in +sync during the transition period before we can remove the current +file (i.e. the day we'll require mathcomp >= 2.4.0). *) + +(**md**************************************************************************) +(* # Numbers within an interval *) +(* *) +(* This file develops tools to make the manipulation of numbers within *) +(* a known interval easier, thanks to canonical structures. This adds types *) +(* like {itv R & `[a, b]}, a notation e%:itv that infers an enclosing *) +(* interval for expression e according to existing canonical instances and *) +(* %:num to cast back from type {itv R & i} to R. *) +(* For instance, for x : {i01 R}, we have (1 - x%:num)%:itv : {i01 R} *) +(* automatically inferred. *) +(* *) +(* ## types for values within known interval *) +(* *) +(* ``` *) +(* {itv R & i} == generic type of values in interval i : interval int *) +(* See interval.v for notations that can be used for i. *) +(* R must have a numDomainType structure. This type is shown *) +(* to be a porderType. *) +(* {i01 R} := {itv R & `[0, 1]} *) +(* Allows to solve automatically goals of the form x >= 0 *) +(* and x <= 1 when x is canonically a {i01 R}. *) +(* {i01 R} is canonically stable by common operations. *) +(* {posnum R} := {itv R & `]0, +oo[) *) +(* {nonneg R} := {itv R & `[0, +oo[) *) +(* ``` *) +(* *) +(* ## casts from/to values within known interval *) +(* *) +(* Explicit casts of x to some {itv R & i} according to existing canonical *) +(* instances: *) +(* ``` *) +(* x%:itv == cast to the most precisely known {itv R & i} *) +(* x%:i01 == cast to {i01 R}, or fail *) +(* x%:pos == cast to {posnum R}, or fail *) +(* x%:nng == cast to {nonneg R}, or fail *) +(* ``` *) +(* *) +(* Explicit casts of x from some {itv R & i} to R: *) +(* ``` *) +(* x%:num == cast from {itv R & i} *) +(* x%:posnum == cast from {posnum R} *) +(* x%:nngnum == cast from {nonneg R} *) +(* ``` *) +(* *) +(* ## sign proofs *) +(* *) +(* ``` *) +(* [itv of x] == proof that x is in the interval inferred by x%:itv *) +(* [gt0 of x] == proof that x > 0 *) +(* [lt0 of x] == proof that x < 0 *) +(* [ge0 of x] == proof that x >= 0 *) +(* [le0 of x] == proof that x <= 0 *) +(* [cmp0 of x] == proof that 0 >=< x *) +(* [neq0 of x] == proof that x != 0 *) +(* ``` *) +(* *) +(* ## constructors *) +(* *) +(* ``` *) +(* ItvNum xr lx xu == builds a {itv R & i} from proofs xr : x \in Num.real, *) +(* lx : map_itv_bound (Itv.num_sem R) l <= BLeft x *) +(* xu : BRight x <= map_itv_bound (Itv.num_sem R) u *) +(* where x : R with R : numDomainType *) +(* and l u : itv_bound int *) +(* ItvReal lx xu == builds a {itv R & i} from proofs *) +(* lx : map_itv_bound (Itv.num_sem R) l <= BLeft x *) +(* xu : BRight x <= map_itv_bound (Itv.num_sem R) u *) +(* where x : R with R : realDomainType *) +(* and l u : itv_bound int *) +(* Itv01 x0 x1 == builds a {i01 R} from proofs x0 : 0 <= x and x1 : x <= 1*) +(* where x : R with R : numDomainType *) +(* PosNum x0 == builds a {posnum R} from a proof x0 : x > 0 where x : R *) +(* NngNum x0 == builds a {posnum R} from a proof x0 : x >= 0 where x : R*) +(* ``` *) +(* *) +(* A number of canonical instances are provided for common operations, if *) +(* your favorite operator is missing, look below for examples on how to add *) +(* the appropriate Canonical. *) +(* Also note that all provided instances aren't necessarily optimal, *) +(* improvements welcome! *) +(* Canonical instances are also provided according to types, as a *) +(* fallback when no known operator appears in the expression. Look to top_typ *) +(* below for an example on how to add your favorite type. *) +(* *) +(******************************************************************************) + +Reserved Notation "{ 'itv' R & i }" + (at level 0, R at level 200, i at level 200, format "{ 'itv' R & i }"). +Reserved Notation "{ 'i01' R }" + (at level 0, R at level 200, format "{ 'i01' R }"). +Reserved Notation "{ 'posnum' R }" (at level 0, format "{ 'posnum' R }"). +Reserved Notation "{ 'nonneg' R }" (at level 0, format "{ 'nonneg' R }"). + +Reserved Notation "x %:itv" (at level 2, format "x %:itv"). +Reserved Notation "x %:i01" (at level 2, format "x %:i01"). +Reserved Notation "x %:pos" (at level 2, format "x %:pos"). +Reserved Notation "x %:nng" (at level 2, format "x %:nng"). +Reserved Notation "x %:inum" (at level 2, format "x %:inum"). +Reserved Notation "x %:num" (at level 2, format "x %:num"). +Reserved Notation "x %:posnum" (at level 2, format "x %:posnum"). +Reserved Notation "x %:nngnum" (at level 2, format "x %:nngnum"). + +Reserved Notation "[ 'itv' 'of' x ]" (format "[ 'itv' 'of' x ]"). +Reserved Notation "[ 'gt0' 'of' x ]" (format "[ 'gt0' 'of' x ]"). +Reserved Notation "[ 'lt0' 'of' x ]" (format "[ 'lt0' 'of' x ]"). +Reserved Notation "[ 'ge0' 'of' x ]" (format "[ 'ge0' 'of' x ]"). +Reserved Notation "[ 'le0' 'of' x ]" (format "[ 'le0' 'of' x ]"). +Reserved Notation "[ 'cmp0' 'of' x ]" (format "[ 'cmp0' 'of' x ]"). +Reserved Notation "[ 'neq0' 'of' x ]" (format "[ 'neq0' 'of' x ]"). + +Set Implicit Arguments. +Unset Strict Implicit. +Unset Printing Implicit Defensive. +Import Order.TTheory Order.Syntax. +Import GRing.Theory Num.Theory. + +Local Open Scope ring_scope. +Local Open Scope order_scope. + +Definition map_itv_bound S T (f : S -> T) (b : itv_bound S) : itv_bound T := + match b with + | BSide b x => BSide b (f x) + | BInfty b => BInfty _ b + end. + +Lemma map_itv_bound_comp S T U (f : T -> S) (g : U -> T) (b : itv_bound U) : + map_itv_bound (f \o g) b = map_itv_bound f (map_itv_bound g b). +Proof. by case: b. Qed. + +Definition map_itv S T (f : S -> T) (i : interval S) : interval T := + let 'Interval l u := i in Interval (map_itv_bound f l) (map_itv_bound f u). + +Lemma map_itv_comp S T U (f : T -> S) (g : U -> T) (i : interval U) : + map_itv (f \o g) i = map_itv f (map_itv g i). +Proof. by case: i => l u /=; rewrite -!map_itv_bound_comp. Qed. + +(* First, the interval arithmetic operations we will later use *) +Module IntItv. +Implicit Types (b : itv_bound int) (i j : interval int). + +Definition opp_bound b := + match b with + | BSide b x => BSide (~~ b) (intZmod.oppz x) + | BInfty b => BInfty _ (~~ b) + end. + +Lemma opp_bound_ge0 b : (BLeft 0%R <= opp_bound b)%O = (b <= BRight 0%R)%O. +Proof. by case: b => [[] b | []//]; rewrite /= !bnd_simp oppr_ge0. Qed. + +Lemma opp_bound_gt0 b : (BRight 0%R <= opp_bound b)%O = (b <= BLeft 0%R)%O. +Proof. +by case: b => [[] b | []//]; rewrite /= !bnd_simp ?oppr_ge0 ?oppr_gt0. +Qed. + +Definition opp i := + let: Interval l u := i in Interval (opp_bound u) (opp_bound l). +Arguments opp /. + +Definition add_boundl b1 b2 := + match b1, b2 with + | BSide b1 x1, BSide b2 x2 => BSide (b1 && b2) (intZmod.addz x1 x2) + | _, _ => BInfty _ true + end. + +Definition add_boundr b1 b2 := + match b1, b2 with + | BSide b1 x1, BSide b2 x2 => BSide (b1 || b2) (intZmod.addz x1 x2) + | _, _ => BInfty _ false + end. + +Definition add i1 i2 := + let: Interval l1 u1 := i1 in let: Interval l2 u2 := i2 in + Interval (add_boundl l1 l2) (add_boundr u1 u2). +Arguments add /. + +Variant signb := EqZero | NonNeg | NonPos. + +Definition sign_boundl b := + let: b0 := BLeft 0%Z in + if b == b0 then EqZero else if (b <= b0)%O then NonPos else NonNeg. + +Definition sign_boundr b := + let: b0 := BRight 0%Z in + if b == b0 then EqZero else if (b <= b0)%O then NonPos else NonNeg. + +Variant signi := Known of signb | Unknown | Empty. + +Definition sign i : signi := + let: Interval l u := i in + match sign_boundl l, sign_boundr u with + | EqZero, NonPos + | NonNeg, EqZero + | NonNeg, NonPos => Empty + | EqZero, EqZero => Known EqZero + | NonPos, EqZero + | NonPos, NonPos => Known NonPos + | EqZero, NonNeg + | NonNeg, NonNeg => Known NonNeg + | NonPos, NonNeg => Unknown + end. + +Definition mul_boundl b1 b2 := + match b1, b2 with + | BInfty _, _ + | _, BInfty _ + | BLeft 0%Z, _ + | _, BLeft 0%Z => BLeft 0%Z + | BSide b1 x1, BSide b2 x2 => BSide (b1 && b2) (intRing.mulz x1 x2) + end. + +Definition mul_boundr b1 b2 := + match b1, b2 with + | BLeft 0%Z, _ + | _, BLeft 0%Z => BLeft 0%Z + | BRight 0%Z, _ + | _, BRight 0%Z => BRight 0%Z + | BSide b1 x1, BSide b2 x2 => BSide (b1 || b2) (intRing.mulz x1 x2) + | _, BInfty _ + | BInfty _, _ => +oo%O + end. + +Lemma mul_boundrC b1 b2 : mul_boundr b1 b2 = mul_boundr b2 b1. +Proof. +by move: b1 b2 => [[] [[|?]|?] | []] [[] [[|?]|?] | []] //=; rewrite mulnC. +Qed. + +Lemma mul_boundr_gt0 b1 b2 : + (BRight 0%Z <= b1 -> BRight 0%Z <= b2 -> BRight 0%Z <= mul_boundr b1 b2)%O. +Proof. +case: b1 b2 => [b1b b1 | []] [b2b b2 | []]//=. +- by case: b1b b2b => -[]; case: b1 b2 => [[|b1] | b1] [[|b2] | b2]. +- by case: b1b b1 => -[[] |]. +- by case: b2b b2 => -[[] |]. +Qed. + +Definition mul i1 i2 := + let: Interval l1 u1 := i1 in let: Interval l2 u2 := i2 in + let: opp := opp_bound in + let: mull := mul_boundl in let: mulr := mul_boundr in + match sign i1, sign i2 with + | Empty, _ | _, Empty => `[1, 0] + | Known EqZero, _ | _, Known EqZero => `[0, 0] + | Known NonNeg, Known NonNeg => + Interval (mull l1 l2) (mulr u1 u2) + | Known NonPos, Known NonPos => + Interval (mull (opp u1) (opp u2)) (mulr (opp l1) (opp l2)) + | Known NonNeg, Known NonPos => + Interval (opp (mulr u1 (opp l2))) (opp (mull l1 (opp u2))) + | Known NonPos, Known NonNeg => + Interval (opp (mulr (opp l1) u2)) (opp (mull (opp u1) l2)) + | Known NonNeg, Unknown => + Interval (opp (mulr u1 (opp l2))) (mulr u1 u2) + | Known NonPos, Unknown => + Interval (opp (mulr (opp l1) u2)) (mulr (opp l1) (opp l2)) + | Unknown, Known NonNeg => + Interval (opp (mulr (opp l1) u2)) (mulr u1 u2) + | Unknown, Known NonPos => + Interval (opp (mulr u1 (opp l2))) (mulr (opp l1) (opp l2)) + | Unknown, Unknown => + Interval + (Order.min (opp (mulr (opp l1) u2)) (opp (mulr u1 (opp l2)))) + (Order.max (mulr (opp l1) (opp l2)) (mulr u1 u2)) + end. +Arguments mul /. + +Definition min i j := + let: Interval li ui := i in let: Interval lj uj := j in + Interval (Order.min li lj) (Order.min ui uj). +Arguments min /. + +Definition max i j := + let: Interval li ui := i in let: Interval lj uj := j in + Interval (Order.max li lj) (Order.max ui uj). +Arguments max /. + +Definition keep_nonneg_bound b := + match b with + | BSide _ (Posz _) => BLeft 0%Z + | BSide _ (Negz _) => -oo%O + | BInfty _ => -oo%O + end. +Arguments keep_nonneg_bound /. + +Definition keep_pos_bound b := + match b with + | BSide b 0%Z => BSide b 0%Z + | BSide _ (Posz (S _)) => BRight 0%Z + | BSide _ (Negz _) => -oo + | BInfty _ => -oo + end. +Arguments keep_pos_bound /. + +Definition keep_nonpos_bound b := + match b with + | BSide _ (Negz _) | BSide _ (Posz 0) => BRight 0%Z + | BSide _ (Posz (S _)) => +oo%O + | BInfty _ => +oo%O + end. +Arguments keep_nonpos_bound /. + +Definition keep_neg_bound b := + match b with + | BSide b 0%Z => BSide b 0%Z + | BSide _ (Negz _) => BLeft 0%Z + | BSide _ (Posz _) => +oo + | BInfty _ => +oo + end. +Arguments keep_neg_bound /. + +Definition inv i := + let: Interval l u := i in + Interval (keep_pos_bound l) (keep_neg_bound u). +Arguments inv /. + +Definition exprn_le1_bound b1 b2 := + if b2 isn't BSide _ 1%Z then +oo + else if (BLeft (-1)%Z <= b1)%O then BRight 1%Z else +oo. +Arguments exprn_le1_bound /. + +Definition exprn i := + let: Interval l u := i in + Interval (keep_pos_bound l) (exprn_le1_bound l u). +Arguments exprn /. + +Definition exprz i1 i2 := + let: Interval l2 _ := i2 in + if l2 is BSide _ (Posz _) then exprn i1 else + let: Interval l u := i1 in + Interval (keep_pos_bound l) +oo. +Arguments exprz /. + +Definition keep_sign i := + let: Interval l u := i in + Interval (keep_nonneg_bound l) (keep_nonpos_bound u). + +(* used in ereal.v *) +Definition keep_nonpos i := + let 'Interval l u := i in + Interval -oo%O (keep_nonpos_bound u). +Arguments keep_nonpos /. + +(* used in ereal.v *) +Definition keep_nonneg i := + let 'Interval l u := i in + Interval (keep_nonneg_bound l) +oo%O. +Arguments keep_nonneg /. + +End IntItv. + +Module Itv. + +Variant t := Top | Real of interval int. + +Definition sub (x y : t) := + match x, y with + | _, Top => true + | Top, Real _ => false + | Real xi, Real yi => subitv xi yi + end. + +Section Itv. +Context T (sem : interval int -> T -> bool). + +Definition spec (i : t) (x : T) := if i is Real i then sem i x else true. + +Record def (i : t) := Def { + r : T; + #[canonical=no] + P : spec i r +}. + +End Itv. + +Record typ i := Typ { + sort : Type; + #[canonical=no] + sort_sem : interval int -> sort -> bool; + #[canonical=no] + allP : forall x : sort, spec sort_sem i x +}. + +Definition mk {T f} i x P : @def T f i := @Def T f i x P. + +Definition from {T f i} {x : @def T f i} (phx : phantom T (r x)) := x. + +Definition fromP {T f i} {x : @def T f i} (phx : phantom T (r x)) := P x. + +Definition num_sem (R : numDomainType) (i : interval int) (x : R) : bool := + (x \in Num.real) && (x \in map_itv intr i). + +Definition nat_sem (i : interval int) (x : nat) : bool := Posz x \in i. + +Definition posnum (R : numDomainType) of phant R := + def (@num_sem R) (Real `]0, +oo[). + +Definition nonneg (R : numDomainType) of phant R := + def (@num_sem R) (Real `[0, +oo[). + +(* a few lifting helper functions *) +Definition real1 (op1 : interval int -> interval int) (x : Itv.t) : Itv.t := + match x with Itv.Top => Itv.Top | Itv.Real x => Itv.Real (op1 x) end. + +Definition real2 (op2 : interval int -> interval int -> interval int) + (x y : Itv.t) : Itv.t := + match x, y with + | Itv.Top, _ | _, Itv.Top => Itv.Top + | Itv.Real x, Itv.Real y => Itv.Real (op2 x y) + end. + +Lemma spec_real1 T f (op1 : T -> T) (op1i : interval int -> interval int) : + forall (x : T), (forall xi, f xi x = true -> f (op1i xi) (op1 x) = true) -> + forall xi, spec f xi x -> spec f (real1 op1i xi) (op1 x). +Proof. by move=> x + [//| xi]; apply. Qed. + +Lemma spec_real2 T f (op2 : T -> T -> T) + (op2i : interval int -> interval int -> interval int) (x y : T) : + (forall xi yi, f xi x = true -> f yi y = true -> + f (op2i xi yi) (op2 x y) = true) -> + forall xi yi, spec f xi x -> spec f yi y -> + spec f (real2 op2i xi yi) (op2 x y). +Proof. by move=> + [//| xi] [//| yi]; apply. Qed. + +Module Exports. +Arguments r {T sem i}. +Notation "{ 'itv' R & i }" := (def (@num_sem R) (Itv.Real i%Z)) : type_scope. +Notation "{ 'i01' R }" := {itv R & `[0, 1]} : type_scope. +Notation "{ 'posnum' R }" := (@posnum _ (Phant R)) : ring_scope. +Notation "{ 'nonneg' R }" := (@nonneg _ (Phant R)) : ring_scope. +Notation "x %:itv" := (from (Phantom _ x)) : ring_scope. +Notation "[ 'itv' 'of' x ]" := (fromP (Phantom _ x)) : ring_scope. +Notation num := r. +Notation "x %:inum" := (r x) (only parsing) : ring_scope. +Notation "x %:num" := (r x) : ring_scope. +Notation "x %:posnum" := (@r _ _ (Real `]0%Z, +oo[) x) : ring_scope. +Notation "x %:nngnum" := (@r _ _ (Real `[0%Z, +oo[) x) : ring_scope. +End Exports. +End Itv. +Export Itv.Exports. + +Local Notation num_spec := (Itv.spec (@Itv.num_sem _)). +Local Notation num_def R := (Itv.def (@Itv.num_sem R)). +Local Notation num_itv_bound R := (@map_itv_bound _ R intr). + +Local Notation nat_spec := (Itv.spec Itv.nat_sem). +Local Notation nat_def := (Itv.def Itv.nat_sem). + +Section POrder. +Context d (T : porderType d) (f : interval int -> T -> bool) (i : Itv.t). +Local Notation itv := (Itv.def f i). +HB.instance Definition _ := [isSub for @Itv.r T f i]. +HB.instance Definition _ : Order.POrder d itv := [POrder of itv by <:]. +End POrder. + +Section Order. +Variables (R : numDomainType) (i : interval int). +Local Notation nR := (num_def R (Itv.Real i)). + +Lemma itv_le_total_subproof : total (<=%O : rel nR). +Proof. +move=> x y; apply: real_comparable. +- by case: x => [x /=/andP[]]. +- by case: y => [y /=/andP[]]. +Qed. + +HB.instance Definition _ := Order.POrder_isTotal.Build ring_display nR + itv_le_total_subproof. + +End Order. + +Module TypInstances. + +Lemma top_typ_spec T f (x : T) : Itv.spec f Itv.Top x. +Proof. by []. Qed. + +Canonical top_typ T f := Itv.Typ (@top_typ_spec T f). + +Lemma real_domain_typ_spec (R : realDomainType) (x : R) : + num_spec (Itv.Real `]-oo, +oo[) x. +Proof. by rewrite /Itv.num_sem/= num_real. Qed. + +Canonical real_domain_typ (R : realDomainType) := + Itv.Typ (@real_domain_typ_spec R). + +Lemma real_field_typ_spec (R : realFieldType) (x : R) : + num_spec (Itv.Real `]-oo, +oo[) x. +Proof. exact: real_domain_typ_spec. Qed. + +Canonical real_field_typ (R : realFieldType) := + Itv.Typ (@real_field_typ_spec R). + +Lemma nat_typ_spec (x : nat) : nat_spec (Itv.Real `[0, +oo[) x. +Proof. by []. Qed. + +Canonical nat_typ := Itv.Typ nat_typ_spec. + +Lemma typ_inum_spec (i : Itv.t) (xt : Itv.typ i) (x : Itv.sort xt) : + Itv.spec (@Itv.sort_sem _ xt) i x. +Proof. by move: xt x => []. Qed. + +(* This adds _ <- Itv.r ( typ_inum ) + to canonical projections (c.f., Print Canonical Projections + Itv.r) meaning that if no other canonical instance (with a + registered head symbol) is found, a canonical instance of + Itv.typ, like the ones above, will be looked for. *) +Canonical typ_inum (i : Itv.t) (xt : Itv.typ i) (x : Itv.sort xt) := + Itv.mk (typ_inum_spec x). + +End TypInstances. +Export (canonicals) TypInstances. + +Class unify {T} f (x y : T) := Unify : f x y = true. +#[export] Hint Mode unify + + + + : typeclass_instances. +Class unify' {T} f (x y : T) := Unify' : f x y = true. +#[export] Instance unify'P {T} f (x y : T) : unify' f x y -> unify f x y := id. +#[export] +Hint Extern 0 (unify' _ _ _) => vm_compute; reflexivity : typeclass_instances. + +Notation unify_itv ix iy := (unify Itv.sub ix iy). + +#[export] Instance top_wider_anything i : unify_itv i Itv.Top. +Proof. by case: i. Qed. + +#[export] Instance real_wider_anyreal i : + unify_itv (Itv.Real i) (Itv.Real `]-oo, +oo[). +Proof. by case: i => [l u]; apply/andP; rewrite !bnd_simp. Qed. + +Section NumDomainTheory. +Context {R : numDomainType} {i : Itv.t}. +Implicit Type x : num_def R i. + +Lemma le_num_itv_bound (x y : itv_bound int) : + (num_itv_bound R x <= num_itv_bound R y)%O = (x <= y)%O. +Proof. +by case: x y => [[] x | x] [[] y | y]//=; rewrite !bnd_simp ?ler_int ?ltr_int. +Qed. + +Lemma num_itv_bound_le_BLeft (x : itv_bound int) (y : int) : + (num_itv_bound R x <= BLeft (y%:~R : R))%O = (x <= BLeft y)%O. +Proof. +rewrite -[BLeft y%:~R]/(map_itv_bound intr (BLeft y)). +by rewrite le_num_itv_bound. +Qed. + +Lemma BRight_le_num_itv_bound (x : int) (y : itv_bound int) : + (BRight (x%:~R : R) <= num_itv_bound R y)%O = (BRight x <= y)%O. +Proof. +rewrite -[BRight x%:~R]/(map_itv_bound intr (BRight x)). +by rewrite le_num_itv_bound. +Qed. + +Lemma num_spec_sub (x y : Itv.t) : Itv.sub x y -> + forall z : R, num_spec x z -> num_spec y z. +Proof. +case: x y => [| x] [| y] //= x_sub_y z /andP[rz]; rewrite /Itv.num_sem rz/=. +move: x y x_sub_y => [lx ux] [ly uy] /andP[lel leu] /=. +move=> /andP[lxz zux]; apply/andP; split. +- by apply: le_trans lxz; rewrite le_num_itv_bound. +- by apply: le_trans zux _; rewrite le_num_itv_bound. +Qed. + +Definition empty_itv := Itv.Real `[1, 0]%Z. + +Lemma bottom x : ~ unify_itv i empty_itv. +Proof. +case: x => x /= /[swap] /num_spec_sub /[apply] /andP[_] /=. +by rewrite in_itv/= => /andP[] /le_trans /[apply]; rewrite ler10. +Qed. + +Lemma gt0 x : unify_itv i (Itv.Real `]0%Z, +oo[) -> 0 < x%:num :> R. +Proof. +case: x => x /= /[swap] /num_spec_sub /[apply] /andP[_]. +by rewrite /= in_itv/= andbT. +Qed. + +Lemma le0F x : unify_itv i (Itv.Real `]0%Z, +oo[) -> x%:num <= 0 :> R = false. +Proof. +case: x => x /= /[swap] /num_spec_sub /[apply] /andP[_] /=. +by rewrite in_itv/= andbT => /lt_geF. +Qed. + +Lemma lt0 x : unify_itv i (Itv.Real `]-oo, 0%Z[) -> x%:num < 0 :> R. +Proof. +by case: x => x /= /[swap] /num_spec_sub /[apply] /andP[_] /=; rewrite in_itv. +Qed. + +Lemma ge0F x : unify_itv i (Itv.Real `]-oo, 0%Z[) -> 0 <= x%:num :> R = false. +Proof. +case: x => x /= /[swap] /num_spec_sub /[apply] /andP[_] /=. +by rewrite in_itv/= => /lt_geF. +Qed. + +Lemma ge0 x : unify_itv i (Itv.Real `[0%Z, +oo[) -> 0 <= x%:num :> R. +Proof. +case: x => x /= /[swap] /num_spec_sub /[apply] /andP[_] /=. +by rewrite in_itv/= andbT. +Qed. + +Lemma lt0F x : unify_itv i (Itv.Real `[0%Z, +oo[) -> x%:num < 0 :> R = false. +Proof. +case: x => x /= /[swap] /num_spec_sub /[apply] /andP[_] /=. +by rewrite in_itv/= andbT => /le_gtF. +Qed. + +Lemma le0 x : unify_itv i (Itv.Real `]-oo, 0%Z]) -> x%:num <= 0 :> R. +Proof. +by case: x => x /= /[swap] /num_spec_sub /[apply] /andP[_] /=; rewrite in_itv. +Qed. + +Lemma gt0F x : unify_itv i (Itv.Real `]-oo, 0%Z]) -> 0 < x%:num :> R = false. +Proof. +case: x => x /= /[swap] /num_spec_sub /[apply] /andP[_] /=. +by rewrite in_itv/= => /le_gtF. +Qed. + +Lemma cmp0 x : unify_itv i (Itv.Real `]-oo, +oo[) -> 0 >=< x%:num. +Proof. by case: i x => [//| i' [x /=/andP[]]]. Qed. + +Lemma neq0 x : + unify (fun ix iy => ~~ Itv.sub ix iy) (Itv.Real `[0%Z, 0%Z]) i -> + x%:num != 0 :> R. +Proof. +case: i x => [//| [l u] [x /= Px]]; apply: contra => /eqP x0 /=. +move: Px; rewrite x0 => /and3P[_ /= l0 u0]; apply/andP; split. +- by case: l l0 => [[] l /= |//]; rewrite !bnd_simp ?lerz0 ?ltrz0. +- by case: u u0 => [[] u /= |//]; rewrite !bnd_simp ?ler0z ?ltr0z. +Qed. + +Lemma eq0F x : + unify (fun ix iy => ~~ Itv.sub ix iy) (Itv.Real `[0%Z, 0%Z]) i -> + x%:num == 0 :> R = false. +Proof. by move=> u; apply/negbTE/neq0. Qed. + +Lemma lt1 x : unify_itv i (Itv.Real `]-oo, 1%Z[) -> x%:num < 1 :> R. +Proof. +by case: x => x /= /[swap] /num_spec_sub /[apply] /andP[_] /=; rewrite in_itv. +Qed. + +Lemma ge1F x : unify_itv i (Itv.Real `]-oo, 1%Z[) -> 1 <= x%:num :> R = false. +Proof. +case: x => x /= /[swap] /num_spec_sub /[apply] /andP[_] /=. +by rewrite in_itv/= => /lt_geF. +Qed. + +Lemma le1 x : unify_itv i (Itv.Real `]-oo, 1%Z]) -> x%:num <= 1 :> R. +Proof. +by case: x => x /= /[swap] /num_spec_sub /[apply] /andP[_] /=; rewrite in_itv. +Qed. + +Lemma gt1F x : unify_itv i (Itv.Real `]-oo, 1%Z]) -> 1 < x%:num :> R = false. +Proof. +case: x => x /= /[swap] /num_spec_sub /[apply] /andP[_] /=. +by rewrite in_itv/= => /le_gtF. +Qed. + +Lemma widen_itv_subproof x i' : Itv.sub i i' -> num_spec i' x%:num. +Proof. by case: x => x /= /[swap] /num_spec_sub; apply. Qed. + +Definition widen_itv x i' (uni : unify_itv i i') := + Itv.mk (widen_itv_subproof x uni). + +Lemma widen_itvE x (uni : unify_itv i i) : @widen_itv x i uni = x. +Proof. exact/val_inj. Qed. + +Lemma posE x (uni : unify_itv i (Itv.Real `]0%Z, +oo[)) : + (widen_itv x%:num%:itv uni)%:num = x%:num. +Proof. by []. Qed. + +Lemma nngE x (uni : unify_itv i (Itv.Real `[0%Z, +oo[)) : + (widen_itv x%:num%:itv uni)%:num = x%:num. +Proof. by []. Qed. + +End NumDomainTheory. + +Arguments bottom {R i} _ {_}. +Arguments gt0 {R i} _ {_}. +Arguments le0F {R i} _ {_}. +Arguments lt0 {R i} _ {_}. +Arguments ge0F {R i} _ {_}. +Arguments ge0 {R i} _ {_}. +Arguments lt0F {R i} _ {_}. +Arguments le0 {R i} _ {_}. +Arguments gt0F {R i} _ {_}. +Arguments cmp0 {R i} _ {_}. +Arguments neq0 {R i} _ {_}. +Arguments eq0F {R i} _ {_}. +Arguments lt1 {R i} _ {_}. +Arguments ge1F {R i} _ {_}. +Arguments le1 {R i} _ {_}. +Arguments gt1F {R i} _ {_}. +Arguments widen_itv {R i} _ {_ _}. +Arguments widen_itvE {R i} _ {_}. +Arguments posE {R i} _ {_}. +Arguments nngE {R i} _ {_}. + +Notation "[ 'gt0' 'of' x ]" := (ltac:(refine (gt0 x%:itv))). +Notation "[ 'lt0' 'of' x ]" := (ltac:(refine (lt0 x%:itv))). +Notation "[ 'ge0' 'of' x ]" := (ltac:(refine (ge0 x%:itv))). +Notation "[ 'le0' 'of' x ]" := (ltac:(refine (le0 x%:itv))). +Notation "[ 'cmp0' 'of' x ]" := (ltac:(refine (cmp0 x%:itv))). +Notation "[ 'neq0' 'of' x ]" := (ltac:(refine (neq0 x%:itv))). + +#[export] Hint Extern 0 (is_true (0%R < _)%R) => solve [apply: gt0] : core. +#[export] Hint Extern 0 (is_true (_ < 0%R)%R) => solve [apply: lt0] : core. +#[export] Hint Extern 0 (is_true (0%R <= _)%R) => solve [apply: ge0] : core. +#[export] Hint Extern 0 (is_true (_ <= 0%R)%R) => solve [apply: le0] : core. +#[export] Hint Extern 0 (is_true (_ \is Num.real)) => solve [apply: cmp0] + : core. +#[export] Hint Extern 0 (is_true (0%R >=< _)%R) => solve [apply: cmp0] : core. +#[export] Hint Extern 0 (is_true (_ != 0%R)) => solve [apply: neq0] : core. +#[export] Hint Extern 0 (is_true (_ < 1%R)%R) => solve [apply: lt1] : core. +#[export] Hint Extern 0 (is_true (_ <= 1%R)%R) => solve [apply: le1] : core. + +Notation "x %:i01" := (widen_itv x%:itv : {i01 _}) (only parsing) : ring_scope. +Notation "x %:i01" := (@widen_itv _ _ + (@Itv.from _ _ _ (Phantom _ x)) (Itv.Real `[0, 1]%Z) _) + (only printing) : ring_scope. +Notation "x %:pos" := (widen_itv x%:itv : {posnum _}) (only parsing) + : ring_scope. +Notation "x %:pos" := (@widen_itv _ _ + (@Itv.from _ _ _ (Phantom _ x)) (Itv.Real `]0%Z, +oo[) _) + (only printing) : ring_scope. +Notation "x %:nng" := (widen_itv x%:itv : {nonneg _}) (only parsing) + : ring_scope. +Notation "x %:nng" := (@widen_itv _ _ + (@Itv.from _ _ _ (Phantom _ x)) (Itv.Real `[0%Z, +oo[) _) + (only printing) : ring_scope. + +Local Open Scope ring_scope. + +Module Instances. + +Import IntItv. + +Section NumDomainInstances. +Context {R : numDomainType}. + +Lemma num_spec_zero : num_spec (Itv.Real `[0, 0]) (0 : R). +Proof. by apply/andP; split; [exact: real0 | rewrite /= in_itv/= lexx]. Qed. + +Canonical zero_inum := Itv.mk num_spec_zero. + +Lemma num_spec_one : num_spec (Itv.Real `[1, 1]) (1 : R). +Proof. by apply/andP; split; [exact: real1 | rewrite /= in_itv/= lexx]. Qed. + +Canonical one_inum := Itv.mk num_spec_one. + +Lemma opp_boundr (x : R) b : + (BRight (- x)%R <= num_itv_bound R (opp_bound b))%O + = (num_itv_bound R b <= BLeft x)%O. +Proof. +by case: b => [[] b | []//]; rewrite /= !bnd_simp mulrNz ?lerN2 // ltrN2. +Qed. + +Lemma opp_boundl (x : R) b : + (num_itv_bound R (opp_bound b) <= BLeft (- x)%R)%O + = (BRight x <= num_itv_bound R b)%O. +Proof. +by case: b => [[] b | []//]; rewrite /= !bnd_simp mulrNz ?lerN2 // ltrN2. +Qed. + +Lemma num_spec_opp (i : Itv.t) (x : num_def R i) (r := Itv.real1 opp i) : + num_spec r (- x%:num). +Proof. +apply: Itv.spec_real1 (Itv.P x). +case: x => x /= _ [l u] /and3P[xr lx xu]. +rewrite /Itv.num_sem/= realN xr/=; apply/andP. +by rewrite opp_boundl opp_boundr. +Qed. + +Canonical opp_inum (i : Itv.t) (x : num_def R i) := Itv.mk (num_spec_opp x). + +Lemma num_itv_add_boundl (x1 x2 : R) b1 b2 : + (num_itv_bound R b1 <= BLeft x1)%O -> (num_itv_bound R b2 <= BLeft x2)%O -> + (num_itv_bound R (add_boundl b1 b2) <= BLeft (x1 + x2)%R)%O. +Proof. +case: b1 b2 => [bb1 b1 |//] [bb2 b2 |//]. +case: bb1; case: bb2; rewrite /= !bnd_simp mulrzDr_tmp. +- exact: lerD. +- exact: ler_ltD. +- exact: ltr_leD. +- exact: ltrD. +Qed. + +Lemma num_itv_add_boundr (x1 x2 : R) b1 b2 : + (BRight x1 <= num_itv_bound R b1)%O -> (BRight x2 <= num_itv_bound R b2)%O -> + (BRight (x1 + x2)%R <= num_itv_bound R (add_boundr b1 b2))%O. +Proof. +case: b1 b2 => [bb1 b1 |//] [bb2 b2 |//]. +case: bb1; case: bb2; rewrite /= !bnd_simp mulrzDr_tmp. +- exact: ltrD. +- exact: ltr_leD. +- exact: ler_ltD. +- exact: lerD. +Qed. + +Lemma num_spec_add (xi yi : Itv.t) (x : num_def R xi) (y : num_def R yi) + (r := Itv.real2 add xi yi) : + num_spec r (x%:num + y%:num). +Proof. +apply: Itv.spec_real2 (Itv.P x) (Itv.P y). +case: x y => [x /= _] [y /= _] => {xi yi r} -[lx ux] [ly uy]/=. +move=> /andP[xr /=/andP[lxx xux]] /andP[yr /=/andP[lyy yuy]]. +rewrite /Itv.num_sem realD//=; apply/andP. +by rewrite num_itv_add_boundl ?num_itv_add_boundr. +Qed. + +Canonical add_inum (xi yi : Itv.t) (x : num_def R xi) (y : num_def R yi) := + Itv.mk (num_spec_add x y). + +Variant sign_spec (l u : itv_bound int) (x : R) : signi -> Set := + | ISignEqZero : l = BLeft 0 -> u = BRight 0 -> x = 0 -> + sign_spec l u x (Known EqZero) + | ISignNonNeg : (BLeft 0%:Z <= l)%O -> (BRight 0%:Z < u)%O -> 0 <= x -> + sign_spec l u x (Known NonNeg) + | ISignNonPos : (l < BLeft 0%:Z)%O -> (u <= BRight 0%:Z)%O -> x <= 0 -> + sign_spec l u x (Known NonPos) + | ISignBoth : (l < BLeft 0%:Z)%O -> (BRight 0%:Z < u)%O -> x \in Num.real -> + sign_spec l u x Unknown. + +Lemma signP (l u : itv_bound int) (x : R) : + (num_itv_bound R l <= BLeft x)%O -> (BRight x <= num_itv_bound R u)%O -> + x \in Num.real -> + sign_spec l u x (sign (Interval l u)). +Proof. +move=> + + xr; rewrite /sign/sign_boundl/sign_boundr. +have [lneg|lpos|->] := ltgtP l; have [uneg|upos|->] := ltgtP u => lx xu. +- apply: ISignNonPos => //; first exact: ltW. + have:= le_trans xu (eqbRL (le_num_itv_bound _ _) (ltW uneg)). + by rewrite bnd_simp. +- exact: ISignBoth. +- exact: ISignNonPos. +- have:= @ltxx _ _ (num_itv_bound R l). + rewrite (le_lt_trans lx) -?leBRight_ltBLeft ?(le_trans xu)//. + by rewrite le_num_itv_bound (le_trans (ltW uneg)). +- apply: ISignNonNeg => //; first exact: ltW. + have:= le_trans (eqbRL (le_num_itv_bound _ _) (ltW lpos)) lx. + by rewrite bnd_simp. +- have:= @ltxx _ _ (num_itv_bound R l). + rewrite (le_lt_trans lx) -?leBRight_ltBLeft ?(le_trans xu)//. + by rewrite le_num_itv_bound ?leBRight_ltBLeft. +- have:= @ltxx _ _ (num_itv_bound R (BLeft 0%Z)). + rewrite (le_lt_trans lx) -?leBRight_ltBLeft ?(le_trans xu)//. + by rewrite le_num_itv_bound -?ltBRight_leBLeft. +- exact: ISignNonNeg. +- apply: ISignEqZero => //. + by apply/le_anti/andP; move: lx xu; rewrite !bnd_simp. +Qed. + +Lemma num_itv_mul_boundl b1 b2 (x1 x2 : R) : + (BLeft 0%:Z <= b1 -> BLeft 0%:Z <= b2 -> + num_itv_bound R b1 <= BLeft x1 -> + num_itv_bound R b2 <= BLeft x2 -> + num_itv_bound R (mul_boundl b1 b2) <= BLeft (x1 * x2))%O. +Proof. +move: b1 b2 => [[] b1 | []//] [[] b2 | []//] /=; rewrite 4!bnd_simp. +- set bl := match b1 with 0%Z => _ | _ => _ end. + have -> : bl = BLeft (b1 * b2). + rewrite {}/bl; move: b1 b2 => [[|p1]|p1] [[|p2]|p2]; congr BLeft. + by rewrite mulr0. + by rewrite bnd_simp intrM -2!(ler0z R); apply: ler_pM. +- case: b1 => [[|b1] | b1]; rewrite !bnd_simp// => b1p b2p sx1 sx2. + + by rewrite mulr_ge0 ?(le_trans _ (ltW sx2)) ?ler0z. + + rewrite intrM (@lt_le_trans _ _ (b1.+1%:~R * x2)) ?ltr_pM2l//. + by rewrite ler_pM2r// (le_lt_trans _ sx2) ?ler0z. +- case: b2 => [[|b2] | b2]; rewrite !bnd_simp// => b1p b2p sx1 sx2. + + by rewrite mulr_ge0 ?(le_trans _ (ltW sx1)) ?ler0z. + + rewrite intrM (@le_lt_trans _ _ (b1%:~R * x2)) ?ler_wpM2l ?ler0z//. + by rewrite ltr_pM2r ?(lt_le_trans _ sx2). +- by rewrite -2!(ler0z R) bnd_simp intrM; apply: ltr_pM. +Qed. + +Lemma num_itv_mul_boundr b1 b2 (x1 x2 : R) : + (0 <= x1 -> 0 <= x2 -> + BRight x1 <= num_itv_bound R b1 -> + BRight x2 <= num_itv_bound R b2 -> + BRight (x1 * x2) <= num_itv_bound R (mul_boundr b1 b2))%O. +Proof. +case: b1 b2 => [b1b b1 | []] [b2b b2 | []] //= x1p x2p; last first. +- case: b2b b2 => -[[|//] | //] _ x20. + + have:= @ltxx _ (itv_bound R) (BLeft 0%:~R). + by rewrite (lt_le_trans _ x20). + + have -> : x2 = 0 by apply/le_anti/andP. + by rewrite mulr0. +- case: b1b b1 => -[[|//] |//] x10 _. + + have:= @ltxx _ (itv_bound R) (BLeft 0%Z%:~R). + by rewrite (lt_le_trans _ x10). + + by have -> : x1 = 0; [apply/le_anti/andP | rewrite mul0r]. +case: b1b b2b => -[]; rewrite -[intRing.mulz]/GRing.mul. +- case: b1 => [[|b1] | b1]; rewrite !bnd_simp => x1b x2b. + + by have:= @ltxx _ R 0; rewrite (le_lt_trans x1p x1b). + + case: b2 x2b => [[| b2] | b2] => x2b; rewrite bnd_simp. + * by have:= @ltxx _ R 0; rewrite (le_lt_trans x2p x2b). + * by rewrite intrM ltr_pM. + * have:= @ltxx _ R 0; rewrite (le_lt_trans x2p)//. + by rewrite (lt_le_trans x2b) ?lerz0. + + have:= @ltxx _ R 0; rewrite (le_lt_trans x1p)//. + by rewrite (lt_le_trans x1b) ?lerz0. +- case: b1 => [[|b1] | b1]; rewrite !bnd_simp => x1b x2b. + + by have:= @ltxx _ R 0; rewrite (le_lt_trans x1p x1b). + + case: b2 x2b => [[| b2] | b2] x2b; rewrite bnd_simp. + * exact: mulr_ge0_le0. + * by rewrite intrM (le_lt_trans (ler_wpM2l x1p x2b)) ?ltr_pM2r. + * have:= @ltxx _ _ x2. + by rewrite (le_lt_trans x2b) ?(lt_le_trans _ x2p) ?ltrz0. + + have:= @ltxx _ _ x1. + by rewrite (lt_le_trans x1b) ?(le_trans _ x1p) ?lerz0. +- case: b1 => [[|b1] | b1]; rewrite !bnd_simp => x1b x2b. + + case: b2 x2b => [[|b2] | b2] x2b; rewrite bnd_simp. + * by have:= @ltxx _ _ x2; rewrite (lt_le_trans x2b). + * by have -> : x1 = 0; [apply/le_anti/andP | rewrite mul0r]. + * have:= @ltxx _ _ x2. + by rewrite (lt_le_trans x2b) ?(le_trans _ x2p) ?lerz0. + + case: b2 x2b => [[|b2] | b2] x2b; rewrite bnd_simp. + * by have:= @ltxx _ _ x2; rewrite (lt_le_trans x2b). + * by rewrite intrM (le_lt_trans (ler_wpM2r x2p x1b)) ?ltr_pM2l. + * have:= @ltxx _ _ x2. + by rewrite (lt_le_trans x2b) ?(le_trans _ x2p) ?lerz0. + + have:= @ltxx _ _ x1. + by rewrite (le_lt_trans x1b) ?(lt_le_trans _ x1p) ?ltrz0. +- case: b1 => [[|b1] | b1]; rewrite !bnd_simp => x1b x2b. + + by have -> : x1 = 0; [apply/le_anti/andP | rewrite mul0r]. + + case: b2 x2b => [[| b2] | b2] x2b; rewrite bnd_simp. + * by have -> : x2 = 0; [apply/le_anti/andP | rewrite mulr0]. + * by rewrite intrM ler_pM. + * have:= @ltxx _ _ x2. + by rewrite (le_lt_trans x2b) ?(lt_le_trans _ x2p) ?ltrz0. + + have:= @ltxx _ _ x1. + by rewrite (le_lt_trans x1b) ?(lt_le_trans _ x1p) ?ltrz0. +Qed. + +Lemma BRight_le_mul_boundr b1 b2 (x1 x2 : R) : + (0 <= x1 -> x2 \in Num.real -> BRight 0%Z <= b2 -> + BRight x1 <= num_itv_bound R b1 -> + BRight x2 <= num_itv_bound R b2 -> + BRight (x1 * x2) <= num_itv_bound R (mul_boundr b1 b2))%O. +Proof. +move=> x1ge0 x2r b2ge0 lex1b1 lex2b2. +have /orP[x2ge0 | x2le0] := x2r; first exact: num_itv_mul_boundr. +have lem0 : (BRight (x1 * x2) <= BRight 0%R)%O. + by rewrite bnd_simp mulr_ge0_le0 // ltW. +apply: le_trans lem0 _. +rewrite -(mulr0z 1) BRight_le_num_itv_bound. +apply: mul_boundr_gt0 => //. +by rewrite -(@BRight_le_num_itv_bound R) (le_trans _ lex1b1). +Qed. + +Lemma comparable_num_itv_bound (x y : itv_bound int) : + (num_itv_bound R x >=< num_itv_bound R y)%O. +Proof. +by case: x y => [[] x | []] [[] y | []]//; apply/orP; + rewrite !bnd_simp ?ler_int ?ltr_int; + case: leP => xy; apply/orP => //; rewrite ltW ?orbT. +Qed. + +Lemma num_itv_bound_min (x y : itv_bound int) : + num_itv_bound R (Order.min x y) + = Order.min (num_itv_bound R x) (num_itv_bound R y). +Proof. +have [lexy | ltyx] := leP x y; [by rewrite !minEle le_num_itv_bound lexy|]. +rewrite minElt -if_neg -comparable_leNgt ?le_num_itv_bound ?ltW//. +exact: comparable_num_itv_bound. +Qed. + +Lemma num_itv_bound_max (x y : itv_bound int) : + num_itv_bound R (Order.max x y) + = Order.max (num_itv_bound R x) (num_itv_bound R y). +Proof. +have [lexy | ltyx] := leP x y; [by rewrite !maxEle le_num_itv_bound lexy|]. +rewrite maxElt -if_neg -comparable_leNgt ?le_num_itv_bound ?ltW//. +exact: comparable_num_itv_bound. +Qed. + +Lemma num_spec_mul (xi yi : Itv.t) (x : num_def R xi) (y : num_def R yi) + (r := Itv.real2 mul xi yi) : + num_spec r (x%:num * y%:num). +Proof. +rewrite {}/r; case: xi yi x y => [//| [xl xu]] [//| [yl yu]]. +case=> [x /=/and3P[xr /= xlx xxu]] [y /=/and3P[yr /= yly yyu]]. +rewrite -/(sign (Interval xl xu)) -/(sign (Interval yl yu)). +have ns000 : @Itv.num_sem R `[0, 0] 0 by apply/and3P. +have xyr : x * y \in Num.real by exact: realM. +case: (signP xlx xxu xr) => xlb xub xs. +- by rewrite xs mul0r; case: (signP yly yyu yr). +- case: (signP yly yyu yr) => ylb yub ys. + + by rewrite ys mulr0. + + apply/and3P; split=> //=. + * exact: num_itv_mul_boundl xlx yly. + * exact: num_itv_mul_boundr xxu yyu. + + apply/and3P; split=> //=; rewrite -[x * y]opprK -mulrN. + * by rewrite opp_boundl num_itv_mul_boundr ?oppr_ge0// opp_boundr. + * by rewrite opp_boundr num_itv_mul_boundl ?opp_boundl// opp_bound_ge0. + + apply/and3P; split=> //=. + * rewrite -[x * y]opprK -mulrN opp_boundl. + by rewrite BRight_le_mul_boundr ?realN ?opp_boundr// opp_bound_gt0 ltW. + * by rewrite BRight_le_mul_boundr// ltW. +- case: (signP yly yyu yr) => ylb yub ys. + + by rewrite ys mulr0. + + apply/and3P; split=> //=; rewrite -[x * y]opprK -mulNr. + * rewrite opp_boundl. + by rewrite num_itv_mul_boundr ?oppr_ge0 ?opp_boundr. + * by rewrite opp_boundr num_itv_mul_boundl ?opp_boundl// opp_bound_ge0. + + apply/and3P; split=> //=; rewrite -mulrNN. + * by rewrite num_itv_mul_boundl ?opp_bound_ge0 ?opp_boundl. + * by rewrite num_itv_mul_boundr ?oppr_ge0 ?opp_boundr. + + apply/and3P; split=> //=; rewrite -[x * y]opprK. + * rewrite -mulNr opp_boundl BRight_le_mul_boundr ?oppr_ge0 ?opp_boundr//. + exact: ltW. + * rewrite opprK -mulrNN. + by rewrite BRight_le_mul_boundr ?opp_boundr + ?oppr_ge0 ?realN ?opp_bound_gt0// ltW. +- case: (signP yly yyu yr) => ylb yub ys. + + by rewrite ys mulr0. + + apply/and3P; split=> //=; rewrite mulrC mul_boundrC. + * rewrite -[y * x]opprK -mulrN opp_boundl. + rewrite BRight_le_mul_boundr ?oppr_ge0 ?realN ?opp_boundr//. + by rewrite opp_bound_gt0 ltW. + * by rewrite BRight_le_mul_boundr// ltW. + + apply/and3P; split=> //=; rewrite mulrC mul_boundrC. + * rewrite -[y * x]opprK -mulNr opp_boundl. + by rewrite BRight_le_mul_boundr ?oppr_ge0 ?opp_boundr// ltW. + * rewrite -mulrNN BRight_le_mul_boundr ?oppr_ge0 ?realN ?opp_boundr//. + by rewrite opp_bound_gt0 ltW. +apply/and3P; rewrite xyr/= num_itv_bound_min num_itv_bound_max. +rewrite (comparable_ge_min _ (comparable_num_itv_bound _ _)). +rewrite (comparable_le_max _ (comparable_num_itv_bound _ _)). +case: (comparable_leP xr) => [x0 | /ltW x0]; split=> //. +- apply/orP; right; rewrite -[x * y]opprK -mulrN opp_boundl. + by rewrite BRight_le_mul_boundr ?realN ?opp_boundr// opp_bound_gt0 ltW. +- by apply/orP; right; rewrite BRight_le_mul_boundr// ltW. +- apply/orP; left; rewrite -[x * y]opprK -mulNr opp_boundl. + by rewrite BRight_le_mul_boundr ?oppr_ge0 ?opp_boundr// ltW. +- apply/orP; left; rewrite -mulrNN. + rewrite BRight_le_mul_boundr ?oppr_ge0 ?realN ?opp_boundr//. + by rewrite opp_bound_gt0 ltW. +Qed. + +Canonical mul_inum (xi yi : Itv.t) (x : num_def R xi) (y : num_def R yi) := + Itv.mk (num_spec_mul x y). + +Lemma num_spec_min (xi yi : Itv.t) (x : num_def R xi) (y : num_def R yi) + (r := Itv.real2 min xi yi) : + num_spec r (Order.min x%:num y%:num). +Proof. +apply: Itv.spec_real2 (Itv.P x) (Itv.P y). +case: x y => [x /= _] [y /= _] => {xi yi r} -[lx ux] [ly uy]/=. +move=> /andP[xr /=/andP[lxx xux]] /andP[yr /=/andP[lyy yuy]]. +apply/and3P; split; rewrite ?min_real//= num_itv_bound_min real_BSide_min//. +- apply: (comparable_le_min2 (comparable_num_itv_bound _ _)) => //. + exact: real_comparable. +- apply: (comparable_le_min2 _ (comparable_num_itv_bound _ _)) => //. + exact: real_comparable. +Qed. + +Lemma num_spec_max (xi yi : Itv.t) (x : num_def R xi) (y : num_def R yi) + (r := Itv.real2 max xi yi) : + num_spec r (Order.max x%:num y%:num). +Proof. +apply: Itv.spec_real2 (Itv.P x) (Itv.P y). +case: x y => [x /= _] [y /= _] => {xi yi r} -[lx ux] [ly uy]/=. +move=> /andP[xr /=/andP[lxx xux]] /andP[yr /=/andP[lyy yuy]]. +apply/and3P; split; rewrite ?max_real//= num_itv_bound_max real_BSide_max//. +- apply: (comparable_le_max2 (comparable_num_itv_bound _ _)) => //. + exact: real_comparable. +- apply: (comparable_le_max2 _ (comparable_num_itv_bound _ _)) => //. + exact: real_comparable. +Qed. + +(* We can't directly put an instance on Order.min for R : numDomainType + since we may want instances for other porderType + (typically \bar R or even nat). So we resort on this additional + canonical structure. *) +Record min_max_typ d := MinMaxTyp { + min_max_sort : porderType d; + #[canonical=no] + min_max_sem : interval int -> min_max_sort -> bool; + #[canonical=no] + min_max_minP : forall (xi yi : Itv.t) (x : Itv.def min_max_sem xi) + (y : Itv.def min_max_sem yi), + let: r := Itv.real2 min xi yi in + Itv.spec min_max_sem r (Order.min x%:num y%:num); + #[canonical=no] + min_max_maxP : forall (xi yi : Itv.t) (x : Itv.def min_max_sem xi) + (y : Itv.def min_max_sem yi), + let: r := Itv.real2 max xi yi in + Itv.spec min_max_sem r (Order.max x%:num y%:num); +}. + +(* The default instances on porderType, for min... *) +Canonical min_typ_inum d (t : min_max_typ d) (xi yi : Itv.t) + (x : Itv.def (@min_max_sem d t) xi) (y : Itv.def (@min_max_sem d t) yi) + (r := Itv.real2 min xi yi) := + Itv.mk (min_max_minP x y). + +(* ...and for max *) +Canonical max_typ_inum d (t : min_max_typ d) (xi yi : Itv.t) + (x : Itv.def (@min_max_sem d t) xi) (y : Itv.def (@min_max_sem d t) yi) + (r := Itv.real2 min xi yi) := + Itv.mk (min_max_maxP x y). + +(* Instance of the above structure for numDomainType *) +Canonical num_min_max_typ := MinMaxTyp num_spec_min num_spec_max. + +Lemma nat_num_spec (i : Itv.t) (n : nat) : nat_spec i n = num_spec i (n%:R : R). +Proof. +case: i => [//| [l u]]; rewrite /= /Itv.num_sem realn/=; congr (_ && _). +- by case: l => [[] l |//]; rewrite !bnd_simp ?pmulrn ?ler_int ?ltr_int. +- by case: u => [[] u |//]; rewrite !bnd_simp ?pmulrn ?ler_int ?ltr_int. +Qed. + +Definition natmul_itv (i1 i2 : Itv.t) : Itv.t := + match i1, i2 with + | Itv.Top, _ => Itv.Top + | _, Itv.Top => Itv.Real `]-oo, +oo[ + | Itv.Real i1, Itv.Real i2 => Itv.Real (mul i1 i2) + end. +Arguments natmul_itv /. + +Lemma num_spec_natmul (xi ni : Itv.t) (x : num_def R xi) (n : nat_def ni) + (r := natmul_itv xi ni) : + num_spec r (x%:num *+ n%:num). +Proof. +rewrite {}/r; case: xi x ni n => [//| xi] x [| ni] n. + by apply/and3P; case: n%:num => [|?]; rewrite ?mulr0n ?realrMn. +have Pn : num_spec (Itv.Real ni) (n%:num%:R : R). + by case: n => /= n; rewrite [Itv.nat_sem ni n](nat_num_spec (Itv.Real ni)). +rewrite -mulr_natr -[n%:num%:R]/((Itv.Def Pn)%:num). +by rewrite (@num_spec_mul (Itv.Real xi) (Itv.Real ni)). +Qed. + +Canonical natmul_inum (xi ni : Itv.t) (x : num_def R xi) (n : nat_def ni) := + Itv.mk (num_spec_natmul x n). + +Lemma num_spec_int (i : Itv.t) (n : int) : + num_spec i n = num_spec i (n%:~R : R). +Proof. +case: i => [//| [l u]]; rewrite /= /Itv.num_sem num_real realz/=. +congr (andb _ _). +- by case: l => [[] l |//]; rewrite !bnd_simp intz ?ler_int ?ltr_int. +- by case: u => [[] u |//]; rewrite !bnd_simp intz ?ler_int ?ltr_int. +Qed. + +Lemma num_spec_intmul (xi ii : Itv.t) (x : num_def R xi) (i : num_def int ii) + (r := natmul_itv xi ii) : + num_spec r (x%:num *~ i%:num). +Proof. +rewrite {}/r; case: xi x ii i => [//| xi] x [| ii] i. + by apply/and3P; case: i%:inum => [[|n] | n]; rewrite ?mulr0z ?realN ?realrMn. +have Pi : num_spec (Itv.Real ii) (i%:num%:~R : R). + by case: i => /= i; rewrite [Itv.num_sem ii i](num_spec_int (Itv.Real ii)). +rewrite -mulrzr -[i%:num%:~R]/((Itv.Def Pi)%:num). +by rewrite (@num_spec_mul (Itv.Real xi) (Itv.Real ii)). +Qed. + +Canonical intmul_inum (xi ni : Itv.t) (x : num_def R xi) (n : num_def int ni) := + Itv.mk (num_spec_intmul x n). + +Lemma num_itv_bound_keep_pos (op : R -> R) (x : R) b : + {homo op : x / 0 <= x} -> {homo op : x / 0 < x} -> + (num_itv_bound R b <= BLeft x)%O -> + (num_itv_bound R (keep_pos_bound b) <= BLeft (op x))%O. +Proof. +case: b => [[] [] [| b] // | []//] hle hlt; rewrite !bnd_simp. +- exact: hle. +- by move=> blex; apply: le_lt_trans (hlt _ _) => //; apply: lt_le_trans blex. +- exact: hlt. +- by move=> bltx; apply: le_lt_trans (hlt _ _) => //; apply: le_lt_trans bltx. +Qed. + +Lemma num_itv_bound_keep_neg (op : R -> R) (x : R) b : + {homo op : x / x <= 0} -> {homo op : x / x < 0} -> + (BRight x <= num_itv_bound R b)%O -> + (BRight (op x) <= num_itv_bound R (keep_neg_bound b))%O. +Proof. +case: b => [[] [[|//] | b] | []//] hge hgt; rewrite !bnd_simp. +- exact: hgt. +- by move=> xltb; apply: hgt; apply: lt_le_trans xltb _; rewrite lerz0. +- exact: hge. +- by move=> xleb; apply: hgt; apply: le_lt_trans xleb _; rewrite ltrz0. +Qed. + +Lemma num_spec_inv (i : Itv.t) (x : num_def R i) (r := Itv.real1 inv i) : + num_spec r (x%:num^-1). +Proof. +apply: Itv.spec_real1 (Itv.P x). +case: x => x /= _ [l u] /and3P[xr /= lx xu]. +rewrite /Itv.num_sem/= realV xr/=; apply/andP; split. +- apply: num_itv_bound_keep_pos lx. + + by move=> ?; rewrite invr_ge0. + + by move=> ?; rewrite invr_gt0. +- apply: num_itv_bound_keep_neg xu. + + by move=> ?; rewrite invr_le0. + + by move=> ?; rewrite invr_lt0. +Qed. + +Canonical inv_inum (i : Itv.t) (x : num_def R i) := Itv.mk (num_spec_inv x). + +Lemma num_itv_bound_exprn_le1 (x : R) n l u : + (num_itv_bound R l <= BLeft x)%O -> + (BRight x <= num_itv_bound R u)%O -> + (BRight (x ^+ n) <= num_itv_bound R (exprn_le1_bound l u))%O. +Proof. +case: u => [bu [[//|[|//]] |//] | []//]. +rewrite /exprn_le1_bound; case: (leP _ l) => [lge1 /= |//] lx xu. +rewrite bnd_simp; case: n => [| n]; rewrite ?expr0//. +have xN1 : -1 <= x. + case: l lge1 lx => [[] l | []//]; rewrite !bnd_simp -(@ler_int R). + - exact: le_trans. + - by move=> + /ltW; apply: le_trans. +have x1 : x <= 1 by case: bu xu; rewrite bnd_simp// => /ltW. +have xr : x \is Num.real by exact: ler1_real. +case: (real_ge0P xr) => x0; first by rewrite expr_le1. +rewrite -[x]opprK exprNn; apply: le_trans (ler_piMl _ _) _. +- by rewrite exprn_ge0 ?oppr_ge0 1?ltW. +- suff: -1 <= (-1) ^+ n.+1 :> R /\ (-1) ^+ n.+1 <= 1 :> R => [[]//|]. + elim: n => [|n [IHn1 IHn2]]; rewrite ?expr1// ![_ ^+ n.+2]exprS !mulN1r. + by rewrite lerNl opprK lerNl. +- by rewrite expr_le1 ?oppr_ge0 1?lerNl// ltW. +Qed. + +Lemma num_spec_exprn (i : Itv.t) (x : num_def R i) n (r := Itv.real1 exprn i) : + num_spec r (x%:num ^+ n). +Proof. +apply: (@Itv.spec_real1 _ _ (fun x => x^+n) _ _ _ _ (Itv.P x)). +case: x => x /= _ [l u] /and3P[xr /= lx xu]. +rewrite /Itv.num_sem realX//=; apply/andP; split. +- apply: (@num_itv_bound_keep_pos (fun x => x^+n)) lx. + + exact: exprn_ge0. + + exact: exprn_gt0. +- exact: num_itv_bound_exprn_le1 lx xu. +Qed. + +Canonical exprn_inum (i : Itv.t) (x : num_def R i) n := + Itv.mk (num_spec_exprn x n). + +Lemma num_spec_exprz (xi ki : Itv.t) (x : num_def R xi) (k : num_def int ki) + (r := Itv.real2 exprz xi ki) : + num_spec r (x%:num ^ k%:num). +Proof. +rewrite {}/r; case: ki k => [|[lk uk]] k; first by case: xi x. +case: xi x => [//|xi x]; rewrite /Itv.real2. +have P : Itv.num_sem + (let 'Interval l _ := xi in Interval (keep_pos_bound l) +oo) + (x%:num ^ k%:num). + case: xi x => lx ux x; apply/and3P; split=> [||//]. + have xr : x%:num \is Num.real by case: x => x /=/andP[]. + by case: k%:num => n; rewrite ?realV realX. + apply: (@num_itv_bound_keep_pos (fun x => x ^ k%:num)); + [exact: exprz_ge0 | exact: exprz_gt0 |]. + by case: x => x /=/and3P[]. +case: lk k P => [slk [lk | lk] | slk] k P; [|exact: P..]. +case: k P => -[k | k] /= => [_ _|]; rewrite -/(exprn xi); last first. + by move=> /and3P[_ /=]; case: slk; rewrite bnd_simp -pmulrn natz. +exact: (@num_spec_exprn (Itv.Real xi)). +Qed. + +Canonical exprz_inum (xi ki : Itv.t) (x : num_def R xi) (k : num_def int ki) := + Itv.mk (num_spec_exprz x k). + +Lemma num_spec_norm {V : normedZmodType R} (x : V) : + num_spec (Itv.Real `[0, +oo[) `|x|. +Proof. by apply/and3P; split; rewrite //= ?normr_real ?bnd_simp ?normr_ge0. Qed. + +Canonical norm_inum {V : normedZmodType R} (x : V) := Itv.mk (num_spec_norm x). + +End NumDomainInstances. + +Section RcfInstances. +Context {R : rcfType}. + +Definition sqrt_itv (i : Itv.t) : Itv.t := + match i with + | Itv.Top => Itv.Real `[0%Z, +oo[ + | Itv.Real (Interval l u) => + match l with + | BSide b 0%Z => Itv.Real (Interval (BSide b 0%Z) +oo) + | BSide b (Posz (S _)) => Itv.Real `]0%Z, +oo[ + | _ => Itv.Real `[0, +oo[ + end + end. +Arguments sqrt_itv /. + +Lemma num_spec_sqrt (i : Itv.t) (x : num_def R i) (r := sqrt_itv i) : + num_spec r (Num.sqrt x%:num). +Proof. +have: Itv.num_sem `[0%Z, +oo[ (Num.sqrt x%:num). + by apply/and3P; rewrite /= num_real !bnd_simp sqrtr_ge0. +rewrite {}/r; case: i x => [//| [[bl [l |//] |//] u]] [x /= +] _. +case: bl l => -[| l] /and3P[xr /= bx _]; apply/and3P; split=> //=; + move: bx; rewrite !bnd_simp ?sqrtr_ge0// sqrtr_gt0; + [exact: lt_le_trans | exact: le_lt_trans..]. +Qed. + +Canonical sqrt_inum (i : Itv.t) (x : num_def R i) := Itv.mk (num_spec_sqrt x). + +End RcfInstances. + +Section NumClosedFieldInstances. +Context {R : numClosedFieldType}. + +Definition sqrtC_itv (i : Itv.t) : Itv.t := + match i with + | Itv.Top => Itv.Top + | Itv.Real (Interval l u) => + match l with + | BSide b (Posz _) => Itv.Real (Interval (BSide b 0%Z) +oo) + | _ => Itv.Top + end + end. +Arguments sqrtC_itv /. + +Lemma num_spec_sqrtC (i : Itv.t) (x : num_def R i) (r := sqrtC_itv i) : + num_spec r (sqrtC x%:num). +Proof. +rewrite {}/r; case: i x => [//| [l u] [x /=/and3P[xr /= lx xu]]]. +case: l lx => [bl [l |//] |[]//] lx; apply/and3P; split=> //=. + by apply: sqrtC_real; case: bl lx => /[!bnd_simp] [|/ltW]; apply: le_trans. +case: bl lx => /[!bnd_simp] lx. +- by rewrite sqrtC_ge0; apply: le_trans lx. +- by rewrite sqrtC_gt0; apply: le_lt_trans lx. +Qed. + +Canonical sqrtC_inum (i : Itv.t) (x : num_def R i) := Itv.mk (num_spec_sqrtC x). + +End NumClosedFieldInstances. + +Section NatInstances. +Local Open Scope nat_scope. +Implicit Type (n : nat). + +Lemma nat_spec_zero : nat_spec (Itv.Real `[0, 0]%Z) 0. Proof. by []. Qed. + +Canonical zeron_inum := Itv.mk nat_spec_zero. + +Lemma nat_spec_add (xi yi : Itv.t) (x : nat_def xi) (y : nat_def yi) + (r := Itv.real2 add xi yi) : + nat_spec r (x%:num + y%:num). +Proof. +have Px : num_spec xi (x%:num%:R : int). + by case: x => /= x; rewrite (@nat_num_spec int). +have Py : num_spec yi (y%:num%:R : int). + by case: y => /= y; rewrite (@nat_num_spec int). +rewrite (@nat_num_spec int) natrD. +rewrite -[x%:num%:R]/((Itv.Def Px)%:num) -[y%:num%:R]/((Itv.Def Py)%:num). +exact: num_spec_add. +Qed. + +Canonical addn_inum (xi yi : Itv.t) (x : nat_def xi) (y : nat_def yi) := + Itv.mk (nat_spec_add x y). + +Lemma nat_spec_succ (i : Itv.t) (n : nat_def i) + (r := Itv.real2 add i (Itv.Real `[1, 1]%Z)) : + nat_spec r (S n%:num). +Proof. +pose i1 := Itv.Real `[1, 1]%Z; have P1 : nat_spec i1 1 by []. +by rewrite -addn1 -[1%N]/((Itv.Def P1)%:num); apply: nat_spec_add. +Qed. + +Canonical succn_inum (i : Itv.t) (n : nat_def i) := Itv.mk (nat_spec_succ n). + +Lemma nat_spec_double (i : Itv.t) (n : nat_def i) (r := Itv.real2 add i i) : + nat_spec r (n%:num.*2). +Proof. by rewrite -addnn nat_spec_add. Qed. + +Canonical double_inum (i : Itv.t) (x : nat_def i) := Itv.mk (nat_spec_double x). + +Lemma nat_spec_mul (xi yi : Itv.t) (x : nat_def xi) (y : nat_def yi) + (r := Itv.real2 mul xi yi) : + nat_spec r (x%:num * y%:num). +Proof. +have Px : num_spec xi (x%:num%:R : int). + by case: x => /= x; rewrite (@nat_num_spec int). +have Py : num_spec yi (y%:num%:R : int). + by case: y => /= y; rewrite (@nat_num_spec int). +rewrite (@nat_num_spec int) natrM. +rewrite -[x%:num%:R]/((Itv.Def Px)%:num) -[y%:num%:R]/((Itv.Def Py)%:num). +exact: num_spec_mul. +Qed. + +Canonical muln_inum (xi yi : Itv.t) (x : nat_def xi) (y : nat_def yi) := + Itv.mk (nat_spec_mul x y). + +Lemma nat_spec_exp (i : Itv.t) (x : nat_def i) n (r := Itv.real1 exprn i) : + nat_spec r (x%:num ^ n). +Proof. +have Px : num_spec i (x%:num%:R : int). + by case: x => /= x; rewrite (@nat_num_spec int). +rewrite (@nat_num_spec int) natrX -[x%:num%:R]/((Itv.Def Px)%:num). +exact: num_spec_exprn. +Qed. + +Canonical expn_inum (i : Itv.t) (x : nat_def i) n := Itv.mk (nat_spec_exp x n). + +Lemma nat_spec_min (xi yi : Itv.t) (x : nat_def xi) (y : nat_def yi) + (r := Itv.real2 min xi yi) : + nat_spec r (minn x%:num y%:num). +Proof. +have Px : num_spec xi (x%:num%:R : int). + by case: x => /= x; rewrite (@nat_num_spec int). +have Py : num_spec yi (y%:num%:R : int). + by case: y => /= y; rewrite (@nat_num_spec int). +rewrite (@nat_num_spec int) -minEnat natr_min. +rewrite -[x%:num%:R]/((Itv.Def Px)%:num) -[y%:num%:R]/((Itv.Def Py)%:num). +exact: num_spec_min. +Qed. + +Canonical minn_inum (xi yi : Itv.t) (x : nat_def xi) (y : nat_def yi) := + Itv.mk (nat_spec_min x y). + +Lemma nat_spec_max (xi yi : Itv.t) (x : nat_def xi) (y : nat_def yi) + (r := Itv.real2 max xi yi) : + nat_spec r (maxn x%:num y%:num). +Proof. +have Px : num_spec xi (x%:num%:R : int). + by case: x => /= x; rewrite (@nat_num_spec int). +have Py : num_spec yi (y%:num%:R : int). + by case: y => /= y; rewrite (@nat_num_spec int). +rewrite (@nat_num_spec int) -maxEnat natr_max. +rewrite -[x%:num%:R]/((Itv.Def Px)%:num) -[y%:num%:R]/((Itv.Def Py)%:num). +exact: num_spec_max. +Qed. + +Canonical maxn_inum (xi yi : Itv.t) (x : nat_def xi) (y : nat_def yi) := + Itv.mk (nat_spec_max x y). + +Canonical nat_min_max_typ := MinMaxTyp nat_spec_min nat_spec_max. + +Lemma nat_spec_factorial (n : nat) : nat_spec (Itv.Real `[1%Z, +oo[) n`!. +Proof. by apply/andP; rewrite bnd_simp lez_nat fact_gt0. Qed. + +Canonical factorial_inum n := Itv.mk (nat_spec_factorial n). + +End NatInstances. + +Section IntInstances. + +Lemma num_spec_Posz n : num_spec (Itv.Real `[0, +oo[) (Posz n). +Proof. by apply/and3P; rewrite /= num_real !bnd_simp. Qed. + +Canonical Posz_inum n := Itv.mk (num_spec_Posz n). + +Lemma num_spec_Negz n : num_spec (Itv.Real `]-oo, -1]) (Negz n). +Proof. by apply/and3P; rewrite /= num_real !bnd_simp. Qed. + +Canonical Negz_inum n := Itv.mk (num_spec_Negz n). + +End IntInstances. + +End Instances. +Export (canonicals) Instances. + +Section Morph. +Context {R : numDomainType} {i : Itv.t}. +Local Notation nR := (num_def R i). +Implicit Types x y : nR. +Local Notation num := (@num R (@Itv.num_sem R) i). + +Lemma num_eq : {mono num : x y / x == y}. Proof. by []. Qed. +Lemma num_le : {mono num : x y / (x <= y)%O}. Proof. by []. Qed. +Lemma num_lt : {mono num : x y / (x < y)%O}. Proof. by []. Qed. +Lemma num_min : {morph num : x y / Order.min x y}. +Proof. by move=> x y; rewrite !minEle num_le -fun_if. Qed. +Lemma num_max : {morph num : x y / Order.max x y}. +Proof. by move=> x y; rewrite !maxEle num_le -fun_if. Qed. + +End Morph. + +Section MorphNum. +Context {R : numDomainType}. + +Lemma num_abs_eq0 (a : R) : (`|a|%:nng == 0%:nng) = (a == 0). +Proof. by rewrite -normr_eq0. Qed. + +End MorphNum. + +Section MorphReal. +Context {R : numDomainType} {i : interval int}. +Local Notation nR := (num_def R (Itv.Real i)). +Implicit Type x y : nR. +Local Notation num := (@num R (@Itv.num_sem R) i). + +Lemma num_le_max a x y : + a <= Num.max x%:num y%:num = (a <= x%:num) || (a <= y%:num). +Proof. by rewrite -comparable_le_max// real_comparable. Qed. + +Lemma num_ge_max a x y : + Num.max x%:num y%:num <= a = (x%:num <= a) && (y%:num <= a). +Proof. by rewrite -comparable_ge_max// real_comparable. Qed. + +Lemma num_le_min a x y : + a <= Num.min x%:num y%:num = (a <= x%:num) && (a <= y%:num). +Proof. by rewrite -comparable_le_min// real_comparable. Qed. + +Lemma num_ge_min a x y : + Num.min x%:num y%:num <= a = (x%:num <= a) || (y%:num <= a). +Proof. by rewrite -comparable_ge_min// real_comparable. Qed. + +Lemma num_lt_max a x y : + a < Num.max x%:num y%:num = (a < x%:num) || (a < y%:num). +Proof. by rewrite -comparable_lt_max// real_comparable. Qed. + +Lemma num_gt_max a x y : + Num.max x%:num y%:num < a = (x%:num < a) && (y%:num < a). +Proof. by rewrite -comparable_gt_max// real_comparable. Qed. + +Lemma num_lt_min a x y : + a < Num.min x%:num y%:num = (a < x%:num) && (a < y%:num). +Proof. by rewrite -comparable_lt_min// real_comparable. Qed. + +Lemma num_gt_min a x y : + Num.min x%:num y%:num < a = (x%:num < a) || (y%:num < a). +Proof. by rewrite -comparable_gt_min// real_comparable. Qed. + +End MorphReal. + +Section MorphGe0. +Context {R : numDomainType}. +Local Notation nR := (num_def R (Itv.Real `[0%Z, +oo[)). +Implicit Type x y : nR. +Local Notation num := (@num R (@Itv.num_sem R) (Itv.Real `[0%Z, +oo[)). + +Lemma num_abs_le a x : 0 <= a -> (`|a|%:nng <= x) = (a <= x%:num). +Proof. by move=> a0; rewrite -num_le//= ger0_norm. Qed. + +Lemma num_abs_lt a x : 0 <= a -> (`|a|%:nng < x) = (a < x%:num). +Proof. by move=> a0; rewrite -num_lt/= ger0_norm. Qed. +End MorphGe0. + +Section ItvNum. +Context (R : numDomainType). +Context (x : R) (l u : itv_bound int). +Context (x_real : x \in Num.real). +Context (l_le_x : (num_itv_bound R l <= BLeft x)%O). +Context (x_le_u : (BRight x <= num_itv_bound R u)%O). +Lemma itvnum_subdef : num_spec (Itv.Real (Interval l u)) x. +Proof. by apply/and3P. Qed. +Definition ItvNum : num_def R (Itv.Real (Interval l u)) := Itv.mk itvnum_subdef. +End ItvNum. + +Section ItvReal. +Context (R : realDomainType). +Context (x : R) (l u : itv_bound int). +Context (l_le_x : (num_itv_bound R l <= BLeft x)%O). +Context (x_le_u : (BRight x <= num_itv_bound R u)%O). +Lemma itvreal_subdef : num_spec (Itv.Real (Interval l u)) x. +Proof. by apply/and3P; split; first exact: num_real. Qed. +Definition ItvReal : num_def R (Itv.Real (Interval l u)) := + Itv.mk itvreal_subdef. +End ItvReal. + +Section Itv01. +Context (R : numDomainType). +Context (x : R) (x_ge0 : 0 <= x) (x_le1 : x <= 1). +Lemma itv01_subdef : num_spec (Itv.Real `[0%Z, 1%Z]) x. +Proof. by apply/and3P; split; rewrite ?bnd_simp// ger0_real. Qed. +Definition Itv01 : num_def R (Itv.Real `[0%Z, 1%Z]) := Itv.mk itv01_subdef. +End Itv01. + +Section Posnum. +Context (R : numDomainType) (x : R) (x_gt0 : 0 < x). +Lemma posnum_subdef : num_spec (Itv.Real `]0, +oo[) x. +Proof. by apply/and3P; rewrite /= gtr0_real. Qed. +Definition PosNum : {posnum R} := Itv.mk posnum_subdef. +End Posnum. + +Section Nngnum. +Context (R : numDomainType) (x : R) (x_ge0 : 0 <= x). +Lemma nngnum_subdef : num_spec (Itv.Real `[0, +oo[) x. +Proof. by apply/and3P; rewrite /= ger0_real. Qed. +Definition NngNum : {nonneg R} := Itv.mk nngnum_subdef. +End Nngnum. + +Variant posnum_spec (R : numDomainType) (x : R) : + R -> bool -> bool -> bool -> Type := +| IsPosnum (p : {posnum R}) : posnum_spec x (p%:num) false true true. + +Lemma posnumP (R : numDomainType) (x : R) : 0 < x -> + posnum_spec x x (x == 0) (0 <= x) (0 < x). +Proof. +move=> x_gt0; case: real_ltgt0P (x_gt0) => []; rewrite ?gtr0_real // => _ _. +by rewrite -[x]/(PosNum x_gt0)%:num; constructor. +Qed. + +Variant nonneg_spec (R : numDomainType) (x : R) : R -> bool -> Type := +| IsNonneg (p : {nonneg R}) : nonneg_spec x (p%:num) true. + +Lemma nonnegP (R : numDomainType) (x : R) : 0 <= x -> nonneg_spec x x (0 <= x). +Proof. by move=> xge0; rewrite xge0 -[x]/(NngNum xge0)%:num; constructor. Qed. + +Section Test1. + +Variable R : numDomainType. +Variable x : {i01 R}. + +Goal 0%:i01 = 1%:i01 :> {i01 R}. +Proof. +Abort. + +Goal (- x%:num)%:itv = (- x%:num)%:itv :> {itv R & `[-1, 0]}. +Proof. +Abort. + +Goal (1 - x%:num)%:i01 = x. +Proof. +Abort. + +End Test1. + +Section Test2. + +Variable R : realDomainType. +Variable x y : {i01 R}. + +Goal (x%:num * y%:num)%:i01 = x%:num%:i01. +Proof. +Abort. + +End Test2. + +Module Test3. +Section Test3. +Variable R : realDomainType. + +Definition s_of_pq (p q : {i01 R}) : {i01 R} := + (1 - ((1 - p%:num)%:i01%:num * (1 - q%:num)%:i01%:num))%:i01. + +Lemma s_of_p0 (p : {i01 R}) : s_of_pq p 0%:i01 = p. +Proof. by apply/val_inj; rewrite /= subr0 mulr1 subKr. Qed. + +End Test3. +End Test3. diff --git a/theories/.DS_Store b/theories/.DS_Store deleted file mode 100644 index 5008ddfcf53c02e82d7eee2e57c38e5672ef89f6..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 6148 zcmeH~Jr2S!425mzP>H1@V-^m;4Wg<&0T*E43hX&L&p$$qDprKhvt+--jT7}7np#A3 zem<@ulZcFPQ@L2!n>{z**++&mCkOWA81W14cNZlEfg7;MkzE(HCqgga^y>{tEnwC%0;vJ&^%eQ zLs35+`xjp>T0 Monoid_AddLaw; -SemiGroup_ComLaw -> Monoid_AddLaw; -Monoid_Law -> Monoid_AddLaw; -SemiGroup_Law -> Monoid_AddLaw; -choice_Choice -> GRing_Algebra; -eqtype_Equality -> GRing_Algebra; -GRing_LSemiAlgebra -> GRing_Algebra; -GRing_LSemiModule -> GRing_Algebra; -GRing_Lalgebra -> GRing_Algebra; -GRing_Lmodule -> GRing_Algebra; -GRing_Nmodule -> GRing_Algebra; -GRing_NzRing -> GRing_Algebra; -GRing_NzSemiRing -> GRing_Algebra; -GRing_PzRing -> GRing_Algebra; -GRing_PzSemiRing -> GRing_Algebra; -GRing_SemiAlgebra -> GRing_Algebra; -GRing_Zmodule -> GRing_Algebra; -choice_Choice -> AlgebraOfSets; -eqtype_Equality -> AlgebraOfSets; -Pointed -> AlgebraOfSets; -RingOfSets -> AlgebraOfSets; -SemiRingOfSets -> AlgebraOfSets; -Num_ArchiNumDomain -> Num_ArchiClosedField; -Num_ArchiNumField -> Num_ArchiClosedField; -choice_Choice -> Num_ArchiClosedField; -GRing_ClosedField -> Num_ArchiClosedField; -Num_ClosedField -> Num_ArchiClosedField; -GRing_ComNzRing -> Num_ArchiClosedField; -GRing_ComNzSemiRing -> Num_ArchiClosedField; -GRing_ComPzRing -> Num_ArchiClosedField; -GRing_ComPzSemiRing -> Num_ArchiClosedField; -GRing_ComUnitRing -> Num_ArchiClosedField; -GRing_DecidableField -> Num_ArchiClosedField; -eqtype_Equality -> Num_ArchiClosedField; -GRing_Field -> Num_ArchiClosedField; -GRing_IntegralDomain -> Num_ArchiClosedField; -GRing_Nmodule -> Num_ArchiClosedField; -Num_NormedZmodule -> Num_ArchiClosedField; -Num_NumDomain -> Num_ArchiClosedField; -Num_NumField -> Num_ArchiClosedField; -GRing_NzRing -> Num_ArchiClosedField; -GRing_NzSemiRing -> Num_ArchiClosedField; -Order_POrder -> Num_ArchiClosedField; -Num_POrderedZmodule -> Num_ArchiClosedField; -GRing_PzRing -> Num_ArchiClosedField; -GRing_PzSemiRing -> Num_ArchiClosedField; -Num_SemiNormedZmodule -> Num_ArchiClosedField; -GRing_UnitRing -> Num_ArchiClosedField; -GRing_Zmodule -> Num_ArchiClosedField; -choice_Choice -> Num_ArchiNumDomain; -GRing_ComNzRing -> Num_ArchiNumDomain; -GRing_ComNzSemiRing -> Num_ArchiNumDomain; -GRing_ComPzRing -> Num_ArchiNumDomain; -GRing_ComPzSemiRing -> Num_ArchiNumDomain; -GRing_ComUnitRing -> Num_ArchiNumDomain; -eqtype_Equality -> Num_ArchiNumDomain; -GRing_IntegralDomain -> Num_ArchiNumDomain; -GRing_Nmodule -> Num_ArchiNumDomain; -Num_NormedZmodule -> Num_ArchiNumDomain; -Num_NumDomain -> Num_ArchiNumDomain; -GRing_NzRing -> Num_ArchiNumDomain; -GRing_NzSemiRing -> Num_ArchiNumDomain; -Order_POrder -> Num_ArchiNumDomain; -Num_POrderedZmodule -> Num_ArchiNumDomain; -GRing_PzRing -> Num_ArchiNumDomain; -GRing_PzSemiRing -> Num_ArchiNumDomain; -Num_SemiNormedZmodule -> Num_ArchiNumDomain; -GRing_UnitRing -> Num_ArchiNumDomain; -GRing_Zmodule -> Num_ArchiNumDomain; -Num_ArchiNumDomain -> Num_ArchiNumField; -choice_Choice -> Num_ArchiNumField; -GRing_ComNzRing -> Num_ArchiNumField; -GRing_ComNzSemiRing -> Num_ArchiNumField; -GRing_ComPzRing -> Num_ArchiNumField; -GRing_ComPzSemiRing -> Num_ArchiNumField; -GRing_ComUnitRing -> Num_ArchiNumField; -eqtype_Equality -> Num_ArchiNumField; -GRing_Field -> Num_ArchiNumField; -GRing_IntegralDomain -> Num_ArchiNumField; -GRing_Nmodule -> Num_ArchiNumField; -Num_NormedZmodule -> Num_ArchiNumField; -Num_NumDomain -> Num_ArchiNumField; -Num_NumField -> Num_ArchiNumField; -GRing_NzRing -> Num_ArchiNumField; -GRing_NzSemiRing -> Num_ArchiNumField; -Order_POrder -> Num_ArchiNumField; -Num_POrderedZmodule -> Num_ArchiNumField; -GRing_PzRing -> Num_ArchiNumField; -GRing_PzSemiRing -> Num_ArchiNumField; -Num_SemiNormedZmodule -> Num_ArchiNumField; -GRing_UnitRing -> Num_ArchiNumField; -GRing_Zmodule -> Num_ArchiNumField; -Num_ArchiNumDomain -> Num_ArchiRealClosedField; -Num_ArchiNumField -> Num_ArchiRealClosedField; -Num_ArchiRealDomain -> Num_ArchiRealClosedField; -Num_ArchiRealField -> Num_ArchiRealClosedField; -choice_Choice -> Num_ArchiRealClosedField; -GRing_ComNzRing -> Num_ArchiRealClosedField; -GRing_ComNzSemiRing -> Num_ArchiRealClosedField; -GRing_ComPzRing -> Num_ArchiRealClosedField; -GRing_ComPzSemiRing -> Num_ArchiRealClosedField; -GRing_ComUnitRing -> Num_ArchiRealClosedField; -Order_DistrLattice -> Num_ArchiRealClosedField; -eqtype_Equality -> Num_ArchiRealClosedField; -GRing_Field -> Num_ArchiRealClosedField; -GRing_IntegralDomain -> Num_ArchiRealClosedField; -Order_JoinSemilattice -> Num_ArchiRealClosedField; -Order_Lattice -> Num_ArchiRealClosedField; -Order_MeetSemilattice -> Num_ArchiRealClosedField; -GRing_Nmodule -> Num_ArchiRealClosedField; -Num_NormedZmodule -> Num_ArchiRealClosedField; -Num_NumDomain -> Num_ArchiRealClosedField; -Num_NumField -> Num_ArchiRealClosedField; -GRing_NzRing -> Num_ArchiRealClosedField; -GRing_NzSemiRing -> Num_ArchiRealClosedField; -Order_POrder -> Num_ArchiRealClosedField; -Num_POrderedZmodule -> Num_ArchiRealClosedField; -GRing_PzRing -> Num_ArchiRealClosedField; -GRing_PzSemiRing -> Num_ArchiRealClosedField; -Num_RealClosedField -> Num_ArchiRealClosedField; -Num_RealDomain -> Num_ArchiRealClosedField; -Num_RealField -> Num_ArchiRealClosedField; -Num_SemiNormedZmodule -> Num_ArchiRealClosedField; -Order_Total -> Num_ArchiRealClosedField; -GRing_UnitRing -> Num_ArchiRealClosedField; -GRing_Zmodule -> Num_ArchiRealClosedField; -Num_ArchiNumDomain -> Num_ArchiRealDomain; -choice_Choice -> Num_ArchiRealDomain; -GRing_ComNzRing -> Num_ArchiRealDomain; -GRing_ComNzSemiRing -> Num_ArchiRealDomain; -GRing_ComPzRing -> Num_ArchiRealDomain; -GRing_ComPzSemiRing -> Num_ArchiRealDomain; -GRing_ComUnitRing -> Num_ArchiRealDomain; -Order_DistrLattice -> Num_ArchiRealDomain; -eqtype_Equality -> Num_ArchiRealDomain; -GRing_IntegralDomain -> Num_ArchiRealDomain; -Order_JoinSemilattice -> Num_ArchiRealDomain; -Order_Lattice -> Num_ArchiRealDomain; -Order_MeetSemilattice -> Num_ArchiRealDomain; -GRing_Nmodule -> Num_ArchiRealDomain; -Num_NormedZmodule -> Num_ArchiRealDomain; -Num_NumDomain -> Num_ArchiRealDomain; -GRing_NzRing -> Num_ArchiRealDomain; -GRing_NzSemiRing -> Num_ArchiRealDomain; -Order_POrder -> Num_ArchiRealDomain; -Num_POrderedZmodule -> Num_ArchiRealDomain; -GRing_PzRing -> Num_ArchiRealDomain; -GRing_PzSemiRing -> Num_ArchiRealDomain; -Num_RealDomain -> Num_ArchiRealDomain; -Num_SemiNormedZmodule -> Num_ArchiRealDomain; -Order_Total -> Num_ArchiRealDomain; -GRing_UnitRing -> Num_ArchiRealDomain; -GRing_Zmodule -> Num_ArchiRealDomain; -Num_ArchiNumDomain -> Num_ArchiRealField; -Num_ArchiNumField -> Num_ArchiRealField; -Num_ArchiRealDomain -> Num_ArchiRealField; -choice_Choice -> Num_ArchiRealField; -GRing_ComNzRing -> Num_ArchiRealField; -GRing_ComNzSemiRing -> Num_ArchiRealField; -GRing_ComPzRing -> Num_ArchiRealField; -GRing_ComPzSemiRing -> Num_ArchiRealField; -GRing_ComUnitRing -> Num_ArchiRealField; -Order_DistrLattice -> Num_ArchiRealField; -eqtype_Equality -> Num_ArchiRealField; -GRing_Field -> Num_ArchiRealField; -GRing_IntegralDomain -> Num_ArchiRealField; -Order_JoinSemilattice -> Num_ArchiRealField; -Order_Lattice -> Num_ArchiRealField; -Order_MeetSemilattice -> Num_ArchiRealField; -GRing_Nmodule -> Num_ArchiRealField; -Num_NormedZmodule -> Num_ArchiRealField; -Num_NumDomain -> Num_ArchiRealField; -Num_NumField -> Num_ArchiRealField; -GRing_NzRing -> Num_ArchiRealField; -GRing_NzSemiRing -> Num_ArchiRealField; -Order_POrder -> Num_ArchiRealField; -Num_POrderedZmodule -> Num_ArchiRealField; -GRing_PzRing -> Num_ArchiRealField; -GRing_PzSemiRing -> Num_ArchiRealField; -Num_RealDomain -> Num_ArchiRealField; -Num_RealField -> Num_ArchiRealField; -Num_SemiNormedZmodule -> Num_ArchiRealField; -Order_Total -> Num_ArchiRealField; -GRing_UnitRing -> Num_ArchiRealField; -GRing_Zmodule -> Num_ArchiRealField; -Order_BJoinSemilattice -> Order_BDistrLattice; -Order_BLattice -> Order_BDistrLattice; -Order_BMeetSemilattice -> Order_BDistrLattice; -Order_BPOrder -> Order_BDistrLattice; -choice_Choice -> Order_BDistrLattice; -Order_DistrLattice -> Order_BDistrLattice; -eqtype_Equality -> Order_BDistrLattice; -Order_JoinSemilattice -> Order_BDistrLattice; -Order_Lattice -> Order_BDistrLattice; -Order_MeetSemilattice -> Order_BDistrLattice; -Order_POrder -> Order_BDistrLattice; -Order_BLatticeClosed -> Order_BJoinLatticeClosed; -Order_JoinLatticeClosed -> Order_BJoinLatticeClosed; -Order_BPOrder -> Order_BJoinSemilattice; -choice_Choice -> Order_BJoinSemilattice; -eqtype_Equality -> Order_BJoinSemilattice; -Order_JoinSemilattice -> Order_BJoinSemilattice; -Order_POrder -> Order_BJoinSemilattice; -Order_BJoinSemilattice -> Order_BJoinSubLattice; -Order_BLattice -> Order_BJoinSubLattice; -Order_BMeetSemilattice -> Order_BJoinSubLattice; -Order_BPOrder -> Order_BJoinSubLattice; -choice_Choice -> Order_BJoinSubLattice; -eqtype_Equality -> Order_BJoinSubLattice; -Order_JoinSemilattice -> Order_BJoinSubLattice; -Order_JoinSubBLattice -> Order_BJoinSubLattice; -Order_JoinSubLattice -> Order_BJoinSubLattice; -Order_Lattice -> Order_BJoinSubLattice; -Order_MeetSemilattice -> Order_BJoinSubLattice; -Order_POrder -> Order_BJoinSubLattice; -SubChoice -> Order_BJoinSubLattice; -SubEquality -> Order_BJoinSubLattice; -Order_SubPOrder -> Order_BJoinSubLattice; -Order_SubPOrderBLattice -> Order_BJoinSubLattice; -Order_SubPOrderLattice -> Order_BJoinSubLattice; -SubType -> Order_BJoinSubLattice; -Order_BJoinSemilattice -> Order_BJoinSubTLattice; -Order_BJoinSubLattice -> Order_BJoinSubTLattice; -Order_BLattice -> Order_BJoinSubTLattice; -Order_BMeetSemilattice -> Order_BJoinSubTLattice; -Order_BPOrder -> Order_BJoinSubTLattice; -choice_Choice -> Order_BJoinSubTLattice; -eqtype_Equality -> Order_BJoinSubTLattice; -Order_JoinSemilattice -> Order_BJoinSubTLattice; -Order_JoinSubBLattice -> Order_BJoinSubTLattice; -Order_JoinSubLattice -> Order_BJoinSubTLattice; -Order_JoinSubTBLattice -> Order_BJoinSubTLattice; -Order_JoinSubTLattice -> Order_BJoinSubTLattice; -Order_Lattice -> Order_BJoinSubTLattice; -Order_MeetSemilattice -> Order_BJoinSubTLattice; -Order_POrder -> Order_BJoinSubTLattice; -SubChoice -> Order_BJoinSubTLattice; -SubEquality -> Order_BJoinSubTLattice; -Order_SubPOrder -> Order_BJoinSubTLattice; -Order_SubPOrderBLattice -> Order_BJoinSubTLattice; -Order_SubPOrderLattice -> Order_BJoinSubTLattice; -Order_SubPOrderTBLattice -> Order_BJoinSubTLattice; -Order_SubPOrderTLattice -> Order_BJoinSubTLattice; -SubType -> Order_BJoinSubTLattice; -Order_TBJoinSemilattice -> Order_BJoinSubTLattice; -Order_TBLattice -> Order_BJoinSubTLattice; -Order_TBMeetSemilattice -> Order_BJoinSubTLattice; -Order_TBPOrder -> Order_BJoinSubTLattice; -Order_TJoinSemilattice -> Order_BJoinSubTLattice; -Order_TLattice -> Order_BJoinSubTLattice; -Order_TMeetSemilattice -> Order_BJoinSubTLattice; -Order_TPOrder -> Order_BJoinSubTLattice; -Order_BJoinSemilattice -> Order_BLattice; -Order_BMeetSemilattice -> Order_BLattice; -Order_BPOrder -> Order_BLattice; -choice_Choice -> Order_BLattice; -eqtype_Equality -> Order_BLattice; -Order_JoinSemilattice -> Order_BLattice; -Order_Lattice -> Order_BLattice; -Order_MeetSemilattice -> Order_BLattice; -Order_POrder -> Order_BLattice; -Order_BPOrder -> Order_BMeetSemilattice; -choice_Choice -> Order_BMeetSemilattice; -eqtype_Equality -> Order_BMeetSemilattice; -Order_MeetSemilattice -> Order_BMeetSemilattice; -Order_POrder -> Order_BMeetSemilattice; -choice_Choice -> Order_BPOrder; -eqtype_Equality -> Order_BPOrder; -Order_POrder -> Order_BPOrder; -Order_BJoinSemilattice -> Order_BSubLattice; -Order_BJoinSubLattice -> Order_BSubLattice; -Order_BLattice -> Order_BSubLattice; -Order_BMeetSemilattice -> Order_BSubLattice; -Order_BPOrder -> Order_BSubLattice; -choice_Choice -> Order_BSubLattice; -eqtype_Equality -> Order_BSubLattice; -Order_JoinSemilattice -> Order_BSubLattice; -Order_JoinSubBLattice -> Order_BSubLattice; -Order_JoinSubLattice -> Order_BSubLattice; -Order_Lattice -> Order_BSubLattice; -Order_MeetSemilattice -> Order_BSubLattice; -Order_MeetSubBLattice -> Order_BSubLattice; -Order_MeetSubLattice -> Order_BSubLattice; -Order_POrder -> Order_BSubLattice; -Order_SubBLattice -> Order_BSubLattice; -SubChoice -> Order_BSubLattice; -SubEquality -> Order_BSubLattice; -Order_SubLattice -> Order_BSubLattice; -Order_SubPOrder -> Order_BSubLattice; -Order_SubPOrderBLattice -> Order_BSubLattice; -Order_SubPOrderLattice -> Order_BSubLattice; -SubType -> Order_BSubLattice; -Order_BJoinSemilattice -> Order_BSubTLattice; -Order_BJoinSubLattice -> Order_BSubTLattice; -Order_BJoinSubTLattice -> Order_BSubTLattice; -Order_BLattice -> Order_BSubTLattice; -Order_BMeetSemilattice -> Order_BSubTLattice; -Order_BPOrder -> Order_BSubTLattice; -Order_BSubLattice -> Order_BSubTLattice; -choice_Choice -> Order_BSubTLattice; -eqtype_Equality -> Order_BSubTLattice; -Order_JoinSemilattice -> Order_BSubTLattice; -Order_JoinSubBLattice -> Order_BSubTLattice; -Order_JoinSubLattice -> Order_BSubTLattice; -Order_JoinSubTBLattice -> Order_BSubTLattice; -Order_JoinSubTLattice -> Order_BSubTLattice; -Order_Lattice -> Order_BSubTLattice; -Order_MeetSemilattice -> Order_BSubTLattice; -Order_MeetSubBLattice -> Order_BSubTLattice; -Order_MeetSubLattice -> Order_BSubTLattice; -Order_MeetSubTBLattice -> Order_BSubTLattice; -Order_MeetSubTLattice -> Order_BSubTLattice; -Order_POrder -> Order_BSubTLattice; -Order_SubBLattice -> Order_BSubTLattice; -SubChoice -> Order_BSubTLattice; -SubEquality -> Order_BSubTLattice; -Order_SubLattice -> Order_BSubTLattice; -Order_SubPOrder -> Order_BSubTLattice; -Order_SubPOrderBLattice -> Order_BSubTLattice; -Order_SubPOrderLattice -> Order_BSubTLattice; -Order_SubPOrderTBLattice -> Order_BSubTLattice; -Order_SubPOrderTLattice -> Order_BSubTLattice; -Order_SubTBLattice -> Order_BSubTLattice; -Order_SubTLattice -> Order_BSubTLattice; -SubType -> Order_BSubTLattice; -Order_TBJoinSemilattice -> Order_BSubTLattice; -Order_TBLattice -> Order_BSubTLattice; -Order_TBMeetSemilattice -> Order_BSubTLattice; -Order_TBPOrder -> Order_BSubTLattice; -Order_TJoinSemilattice -> Order_BSubTLattice; -Order_TLattice -> Order_BSubTLattice; -Order_TMeetSemilattice -> Order_BSubTLattice; -Order_TPOrder -> Order_BSubTLattice; -Order_BDistrLattice -> Order_BTotal; -Order_BJoinSemilattice -> Order_BTotal; -Order_BLattice -> Order_BTotal; -Order_BMeetSemilattice -> Order_BTotal; -Order_BPOrder -> Order_BTotal; -choice_Choice -> Order_BTotal; -Order_DistrLattice -> Order_BTotal; -eqtype_Equality -> Order_BTotal; -Order_JoinSemilattice -> Order_BTotal; -Order_Lattice -> Order_BTotal; -Order_MeetSemilattice -> Order_BTotal; -Order_POrder -> Order_BTotal; -Order_Total -> Order_BTotal; -choice_Choice -> BaseFinGroup; -Countable -> BaseFinGroup; -eqtype_Equality -> BaseFinGroup; -fintype_Finite -> BaseFinGroup; -choice_Choice -> BiPointed; -eqtype_Equality -> BiPointed; -BiPointed -> BiPointedTopological; -choice_Choice -> BiPointedTopological; -eqtype_Equality -> BiPointedTopological; -Filtered -> BiPointedTopological; -Nbhs -> BiPointedTopological; -Topological -> BiPointedTopological; -Fun -> Bij; -InjFun -> Bij; -Inject -> Bij; -OInvFun -> Bij; -OInversible -> Bij; -SurjFun -> Bij; -Surject -> Bij; -Order_BDistrLattice -> Order_CBDistrLattice; -Order_BJoinSemilattice -> Order_CBDistrLattice; -Order_BLattice -> Order_CBDistrLattice; -Order_BMeetSemilattice -> Order_CBDistrLattice; -Order_BPOrder -> Order_CBDistrLattice; -Order_CDistrLattice -> Order_CBDistrLattice; -choice_Choice -> Order_CBDistrLattice; -Order_DistrLattice -> Order_CBDistrLattice; -eqtype_Equality -> Order_CBDistrLattice; -Order_JoinSemilattice -> Order_CBDistrLattice; -Order_Lattice -> Order_CBDistrLattice; -Order_MeetSemilattice -> Order_CBDistrLattice; -Order_POrder -> Order_CBDistrLattice; -choice_Choice -> Order_CDistrLattice; -Order_DistrLattice -> Order_CDistrLattice; -eqtype_Equality -> Order_CDistrLattice; -Order_JoinSemilattice -> Order_CDistrLattice; -Order_Lattice -> Order_CDistrLattice; -Order_MeetSemilattice -> Order_CDistrLattice; -Order_POrder -> Order_CDistrLattice; -Order_BDistrLattice -> Order_CTBDistrLattice; -Order_BJoinSemilattice -> Order_CTBDistrLattice; -Order_BLattice -> Order_CTBDistrLattice; -Order_BMeetSemilattice -> Order_CTBDistrLattice; -Order_BPOrder -> Order_CTBDistrLattice; -Order_CBDistrLattice -> Order_CTBDistrLattice; -Order_CDistrLattice -> Order_CTBDistrLattice; -Order_CTDistrLattice -> Order_CTBDistrLattice; -choice_Choice -> Order_CTBDistrLattice; -Order_DistrLattice -> Order_CTBDistrLattice; -eqtype_Equality -> Order_CTBDistrLattice; -Order_JoinSemilattice -> Order_CTBDistrLattice; -Order_Lattice -> Order_CTBDistrLattice; -Order_MeetSemilattice -> Order_CTBDistrLattice; -Order_POrder -> Order_CTBDistrLattice; -Order_TBDistrLattice -> Order_CTBDistrLattice; -Order_TBJoinSemilattice -> Order_CTBDistrLattice; -Order_TBLattice -> Order_CTBDistrLattice; -Order_TBMeetSemilattice -> Order_CTBDistrLattice; -Order_TBPOrder -> Order_CTBDistrLattice; -Order_TDistrLattice -> Order_CTBDistrLattice; -Order_TJoinSemilattice -> Order_CTBDistrLattice; -Order_TLattice -> Order_CTBDistrLattice; -Order_TMeetSemilattice -> Order_CTBDistrLattice; -Order_TPOrder -> Order_CTBDistrLattice; -Order_CDistrLattice -> Order_CTDistrLattice; -choice_Choice -> Order_CTDistrLattice; -Order_DistrLattice -> Order_CTDistrLattice; -eqtype_Equality -> Order_CTDistrLattice; -Order_JoinSemilattice -> Order_CTDistrLattice; -Order_Lattice -> Order_CTDistrLattice; -Order_MeetSemilattice -> Order_CTDistrLattice; -Order_POrder -> Order_CTDistrLattice; -Order_TDistrLattice -> Order_CTDistrLattice; -Order_TJoinSemilattice -> Order_CTDistrLattice; -Order_TLattice -> Order_CTDistrLattice; -Order_TMeetSemilattice -> Order_CTDistrLattice; -Order_TPOrder -> Order_CTDistrLattice; -eqtype_Equality -> choice_Choice; -choice_Choice -> GRing_ClosedField; -GRing_ComNzRing -> GRing_ClosedField; -GRing_ComNzSemiRing -> GRing_ClosedField; -GRing_ComPzRing -> GRing_ClosedField; -GRing_ComPzSemiRing -> GRing_ClosedField; -GRing_ComUnitRing -> GRing_ClosedField; -GRing_DecidableField -> GRing_ClosedField; -eqtype_Equality -> GRing_ClosedField; -GRing_Field -> GRing_ClosedField; -GRing_IntegralDomain -> GRing_ClosedField; -GRing_Nmodule -> GRing_ClosedField; -GRing_NzRing -> GRing_ClosedField; -GRing_NzSemiRing -> GRing_ClosedField; -GRing_PzRing -> GRing_ClosedField; -GRing_PzSemiRing -> GRing_ClosedField; -GRing_UnitRing -> GRing_ClosedField; -GRing_Zmodule -> GRing_ClosedField; -choice_Choice -> Num_ClosedField; -GRing_ClosedField -> Num_ClosedField; -GRing_ComNzRing -> Num_ClosedField; -GRing_ComNzSemiRing -> Num_ClosedField; -GRing_ComPzRing -> Num_ClosedField; -GRing_ComPzSemiRing -> Num_ClosedField; -GRing_ComUnitRing -> Num_ClosedField; -GRing_DecidableField -> Num_ClosedField; -eqtype_Equality -> Num_ClosedField; -GRing_Field -> Num_ClosedField; -GRing_IntegralDomain -> Num_ClosedField; -GRing_Nmodule -> Num_ClosedField; -Num_NormedZmodule -> Num_ClosedField; -Num_NumDomain -> Num_ClosedField; -Num_NumField -> Num_ClosedField; -GRing_NzRing -> Num_ClosedField; -GRing_NzSemiRing -> Num_ClosedField; -Order_POrder -> Num_ClosedField; -Num_POrderedZmodule -> Num_ClosedField; -GRing_PzRing -> Num_ClosedField; -GRing_PzSemiRing -> Num_ClosedField; -Num_SemiNormedZmodule -> Num_ClosedField; -GRing_UnitRing -> Num_ClosedField; -GRing_Zmodule -> Num_ClosedField; -GRing_Algebra -> GRing_ComAlgebra; -choice_Choice -> GRing_ComAlgebra; -GRing_ComNzRing -> GRing_ComAlgebra; -GRing_ComNzSemiRing -> GRing_ComAlgebra; -GRing_ComPzRing -> GRing_ComAlgebra; -GRing_ComPzSemiRing -> GRing_ComAlgebra; -GRing_ComSemiAlgebra -> GRing_ComAlgebra; -eqtype_Equality -> GRing_ComAlgebra; -GRing_LSemiAlgebra -> GRing_ComAlgebra; -GRing_LSemiModule -> GRing_ComAlgebra; -GRing_Lalgebra -> GRing_ComAlgebra; -GRing_Lmodule -> GRing_ComAlgebra; -GRing_Nmodule -> GRing_ComAlgebra; -GRing_NzRing -> GRing_ComAlgebra; -GRing_NzSemiRing -> GRing_ComAlgebra; -GRing_PzRing -> GRing_ComAlgebra; -GRing_PzSemiRing -> GRing_ComAlgebra; -GRing_SemiAlgebra -> GRing_ComAlgebra; -GRing_Zmodule -> GRing_ComAlgebra; -SemiGroup_ComLaw -> Monoid_ComLaw; -Monoid_Law -> Monoid_ComLaw; -SemiGroup_Law -> Monoid_ComLaw; -SemiGroup_Law -> SemiGroup_ComLaw; -choice_Choice -> GRing_ComNzRing; -GRing_ComNzSemiRing -> GRing_ComNzRing; -GRing_ComPzRing -> GRing_ComNzRing; -GRing_ComPzSemiRing -> GRing_ComNzRing; -eqtype_Equality -> GRing_ComNzRing; -GRing_Nmodule -> GRing_ComNzRing; -GRing_NzRing -> GRing_ComNzRing; -GRing_NzSemiRing -> GRing_ComNzRing; -GRing_PzRing -> GRing_ComNzRing; -GRing_PzSemiRing -> GRing_ComNzRing; -GRing_Zmodule -> GRing_ComNzRing; -choice_Choice -> GRing_ComNzSemiRing; -GRing_ComPzSemiRing -> GRing_ComNzSemiRing; -eqtype_Equality -> GRing_ComNzSemiRing; -GRing_Nmodule -> GRing_ComNzSemiRing; -GRing_NzSemiRing -> GRing_ComNzSemiRing; -GRing_PzSemiRing -> GRing_ComNzSemiRing; -choice_Choice -> GRing_ComPzRing; -GRing_ComPzSemiRing -> GRing_ComPzRing; -eqtype_Equality -> GRing_ComPzRing; -GRing_Nmodule -> GRing_ComPzRing; -GRing_PzRing -> GRing_ComPzRing; -GRing_PzSemiRing -> GRing_ComPzRing; -GRing_Zmodule -> GRing_ComPzRing; -choice_Choice -> GRing_ComPzSemiRing; -eqtype_Equality -> GRing_ComPzSemiRing; -GRing_Nmodule -> GRing_ComPzSemiRing; -GRing_PzSemiRing -> GRing_ComPzSemiRing; -choice_Choice -> GRing_ComSemiAlgebra; -GRing_ComNzSemiRing -> GRing_ComSemiAlgebra; -GRing_ComPzSemiRing -> GRing_ComSemiAlgebra; -eqtype_Equality -> GRing_ComSemiAlgebra; -GRing_LSemiAlgebra -> GRing_ComSemiAlgebra; -GRing_LSemiModule -> GRing_ComSemiAlgebra; -GRing_Nmodule -> GRing_ComSemiAlgebra; -GRing_NzSemiRing -> GRing_ComSemiAlgebra; -GRing_PzSemiRing -> GRing_ComSemiAlgebra; -GRing_SemiAlgebra -> GRing_ComSemiAlgebra; -GRing_Algebra -> GRing_ComUnitAlgebra; -choice_Choice -> GRing_ComUnitAlgebra; -GRing_ComAlgebra -> GRing_ComUnitAlgebra; -GRing_ComNzRing -> GRing_ComUnitAlgebra; -GRing_ComNzSemiRing -> GRing_ComUnitAlgebra; -GRing_ComPzRing -> GRing_ComUnitAlgebra; -GRing_ComPzSemiRing -> GRing_ComUnitAlgebra; -GRing_ComSemiAlgebra -> GRing_ComUnitAlgebra; -GRing_ComUnitRing -> GRing_ComUnitAlgebra; -eqtype_Equality -> GRing_ComUnitAlgebra; -GRing_LSemiAlgebra -> GRing_ComUnitAlgebra; -GRing_LSemiModule -> GRing_ComUnitAlgebra; -GRing_Lalgebra -> GRing_ComUnitAlgebra; -GRing_Lmodule -> GRing_ComUnitAlgebra; -GRing_Nmodule -> GRing_ComUnitAlgebra; -GRing_NzRing -> GRing_ComUnitAlgebra; -GRing_NzSemiRing -> GRing_ComUnitAlgebra; -GRing_PzRing -> GRing_ComUnitAlgebra; -GRing_PzSemiRing -> GRing_ComUnitAlgebra; -GRing_SemiAlgebra -> GRing_ComUnitAlgebra; -GRing_UnitAlgebra -> GRing_ComUnitAlgebra; -GRing_UnitRing -> GRing_ComUnitAlgebra; -GRing_Zmodule -> GRing_ComUnitAlgebra; -choice_Choice -> GRing_ComUnitRing; -GRing_ComNzRing -> GRing_ComUnitRing; -GRing_ComNzSemiRing -> GRing_ComUnitRing; -GRing_ComPzRing -> GRing_ComUnitRing; -GRing_ComPzSemiRing -> GRing_ComUnitRing; -eqtype_Equality -> GRing_ComUnitRing; -GRing_Nmodule -> GRing_ComUnitRing; -GRing_NzRing -> GRing_ComUnitRing; -GRing_NzSemiRing -> GRing_ComUnitRing; -GRing_PzRing -> GRing_ComUnitRing; -GRing_PzSemiRing -> GRing_ComUnitRing; -GRing_UnitRing -> GRing_ComUnitRing; -GRing_Zmodule -> GRing_ComUnitRing; -choice_Choice -> Complete; -eqtype_Equality -> Complete; -Filtered -> Complete; -Nbhs -> Complete; -Pointed -> Complete; -PointedFiltered -> Complete; -PointedNbhs -> Complete; -PointedTopological -> Complete; -PointedUniform -> Complete; -Topological -> Complete; -Uniform -> Complete; -choice_Choice -> CompleteNormedModule; -Complete -> CompleteNormedModule; -CompletePseudoMetric -> CompleteNormedModule; -eqtype_Equality -> CompleteNormedModule; -Filtered -> CompleteNormedModule; -GRing_LSemiModule -> CompleteNormedModule; -GRing_Lmodule -> CompleteNormedModule; -Nbhs -> CompleteNormedModule; -NbhsLmodule -> CompleteNormedModule; -NbhsNmodule -> CompleteNormedModule; -NbhsZmodule -> CompleteNormedModule; -GRing_Nmodule -> CompleteNormedModule; -NormedModule -> CompleteNormedModule; -Num_NormedZmodule -> CompleteNormedModule; -Pointed -> CompleteNormedModule; -PointedFiltered -> CompleteNormedModule; -PointedNbhs -> CompleteNormedModule; -PointedTopological -> CompleteNormedModule; -PointedUniform -> CompleteNormedModule; -PreTopologicalLmodule -> CompleteNormedModule; -PreTopologicalNmodule -> CompleteNormedModule; -PreTopologicalZmodule -> CompleteNormedModule; -PreUniformLmodule -> CompleteNormedModule; -PreUniformNmodule -> CompleteNormedModule; -PreUniformZmodule -> CompleteNormedModule; -PseudoMetric -> CompleteNormedModule; -PseudoMetricNormedZmod -> CompleteNormedModule; -PseudoPointedMetric -> CompleteNormedModule; -Num_SemiNormedZmodule -> CompleteNormedModule; -Topological -> CompleteNormedModule; -TopologicalLmodule -> CompleteNormedModule; -TopologicalNmodule -> CompleteNormedModule; -TopologicalZmodule -> CompleteNormedModule; -Tvs -> CompleteNormedModule; -Uniform -> CompleteNormedModule; -GRing_Zmodule -> CompleteNormedModule; -choice_Choice -> CompletePseudoMetric; -Complete -> CompletePseudoMetric; -eqtype_Equality -> CompletePseudoMetric; -Filtered -> CompletePseudoMetric; -Nbhs -> CompletePseudoMetric; -Pointed -> CompletePseudoMetric; -PointedFiltered -> CompletePseudoMetric; -PointedNbhs -> CompletePseudoMetric; -PointedTopological -> CompletePseudoMetric; -PointedUniform -> CompletePseudoMetric; -PseudoMetric -> CompletePseudoMetric; -PseudoPointedMetric -> CompletePseudoMetric; -Topological -> CompletePseudoMetric; -Uniform -> CompletePseudoMetric; -Continuous -> ContinuousFun; -Fun -> ContinuousFun; -choice_Choice -> Countable; -eqtype_Equality -> Countable; -choice_Choice -> GRing_DecidableField; -GRing_ComNzRing -> GRing_DecidableField; -GRing_ComNzSemiRing -> GRing_DecidableField; -GRing_ComPzRing -> GRing_DecidableField; -GRing_ComPzSemiRing -> GRing_DecidableField; -GRing_ComUnitRing -> GRing_DecidableField; -eqtype_Equality -> GRing_DecidableField; -GRing_Field -> GRing_DecidableField; -GRing_IntegralDomain -> GRing_DecidableField; -GRing_Nmodule -> GRing_DecidableField; -GRing_NzRing -> GRing_DecidableField; -GRing_NzSemiRing -> GRing_DecidableField; -GRing_PzRing -> GRing_DecidableField; -GRing_PzSemiRing -> GRing_DecidableField; -GRing_UnitRing -> GRing_DecidableField; -GRing_Zmodule -> GRing_DecidableField; -choice_Choice -> DiscreteNbhs; -eqtype_Equality -> DiscreteNbhs; -Filtered -> DiscreteNbhs; -Nbhs -> DiscreteNbhs; -choice_Choice -> DiscreteOrderTopology; -DiscreteNbhs -> DiscreteOrderTopology; -DiscreteTopology -> DiscreteOrderTopology; -Order_DistrLattice -> DiscreteOrderTopology; -eqtype_Equality -> DiscreteOrderTopology; -Filtered -> DiscreteOrderTopology; -Order_JoinSemilattice -> DiscreteOrderTopology; -Order_Lattice -> DiscreteOrderTopology; -Order_MeetSemilattice -> DiscreteOrderTopology; -Nbhs -> DiscreteOrderTopology; -OrderNbhs -> DiscreteOrderTopology; -OrderTopological -> DiscreteOrderTopology; -Order_POrder -> DiscreteOrderTopology; -Topological -> DiscreteOrderTopology; -Order_Total -> DiscreteOrderTopology; -choice_Choice -> DiscretePseudoMetric; -DiscreteNbhs -> DiscretePseudoMetric; -DiscreteTopology -> DiscretePseudoMetric; -DiscreteUniform -> DiscretePseudoMetric; -eqtype_Equality -> DiscretePseudoMetric; -Filtered -> DiscretePseudoMetric; -Nbhs -> DiscretePseudoMetric; -PseudoMetric -> DiscretePseudoMetric; -Topological -> DiscretePseudoMetric; -Uniform -> DiscretePseudoMetric; -choice_Choice -> DiscreteTopology; -DiscreteNbhs -> DiscreteTopology; -eqtype_Equality -> DiscreteTopology; -Filtered -> DiscreteTopology; -Nbhs -> DiscreteTopology; -Topological -> DiscreteTopology; -choice_Choice -> DiscreteUniform; -DiscreteNbhs -> DiscreteUniform; -DiscreteTopology -> DiscreteUniform; -eqtype_Equality -> DiscreteUniform; -Filtered -> DiscreteUniform; -Nbhs -> DiscreteUniform; -Topological -> DiscreteUniform; -Uniform -> DiscreteUniform; -choice_Choice -> Order_DistrLattice; -eqtype_Equality -> Order_DistrLattice; -Order_JoinSemilattice -> Order_DistrLattice; -Order_Lattice -> Order_DistrLattice; -Order_MeetSemilattice -> Order_DistrLattice; -Order_POrder -> Order_DistrLattice; -GRing_Mul2Closed -> GRing_DivClosed; -GRing_MulClosed -> GRing_DivClosed; -GRing_AddClosed -> GRing_DivalgClosed; -GRing_DivClosed -> GRing_DivalgClosed; -GRing_DivringClosed -> GRing_DivalgClosed; -GRing_Mul2Closed -> GRing_DivalgClosed; -GRing_MulClosed -> GRing_DivalgClosed; -GRing_OppClosed -> GRing_DivalgClosed; -GRing_SdivClosed -> GRing_DivalgClosed; -GRing_Semiring2Closed -> GRing_DivalgClosed; -GRing_SemiringClosed -> GRing_DivalgClosed; -GRing_SmulClosed -> GRing_DivalgClosed; -GRing_SubalgClosed -> GRing_DivalgClosed; -GRing_SubmodClosed -> GRing_DivalgClosed; -GRing_SubringClosed -> GRing_DivalgClosed; -GRing_ZmodClosed -> GRing_DivalgClosed; -GRing_AddClosed -> GRing_DivringClosed; -GRing_DivClosed -> GRing_DivringClosed; -GRing_Mul2Closed -> GRing_DivringClosed; -GRing_MulClosed -> GRing_DivringClosed; -GRing_OppClosed -> GRing_DivringClosed; -GRing_SdivClosed -> GRing_DivringClosed; -GRing_Semiring2Closed -> GRing_DivringClosed; -GRing_SemiringClosed -> GRing_DivringClosed; -GRing_SmulClosed -> GRing_DivringClosed; -GRing_SubringClosed -> GRing_DivringClosed; -GRing_ZmodClosed -> GRing_DivringClosed; -choice_Choice -> Empty; -Countable -> Empty; -eqtype_Equality -> Empty; -fintype_Finite -> Empty; -eqtype_Equality -> EqQuotient; -Quotient -> EqQuotient; -choice_Choice -> GRing_Field; -GRing_ComNzRing -> GRing_Field; -GRing_ComNzSemiRing -> GRing_Field; -GRing_ComPzRing -> GRing_Field; -GRing_ComPzSemiRing -> GRing_Field; -GRing_ComUnitRing -> GRing_Field; -eqtype_Equality -> GRing_Field; -GRing_IntegralDomain -> GRing_Field; -GRing_Nmodule -> GRing_Field; -GRing_NzRing -> GRing_Field; -GRing_NzSemiRing -> GRing_Field; -GRing_PzRing -> GRing_Field; -GRing_PzSemiRing -> GRing_Field; -GRing_UnitRing -> GRing_Field; -GRing_Zmodule -> GRing_Field; -choice_Choice -> Filtered; -eqtype_Equality -> Filtered; -Order_BMeetSemilattice -> Order_FinBMeetSemilattice; -Order_BPOrder -> Order_FinBMeetSemilattice; -choice_Choice -> Order_FinBMeetSemilattice; -Countable -> Order_FinBMeetSemilattice; -eqtype_Equality -> Order_FinBMeetSemilattice; -Order_FinBPOrder -> Order_FinBMeetSemilattice; -Order_FinMeetSemilattice -> Order_FinBMeetSemilattice; -Order_FinPOrder -> Order_FinBMeetSemilattice; -fintype_Finite -> Order_FinBMeetSemilattice; -Order_MeetSemilattice -> Order_FinBMeetSemilattice; -Order_POrder -> Order_FinBMeetSemilattice; -Order_BPOrder -> Order_FinBPOrder; -choice_Choice -> Order_FinBPOrder; -Countable -> Order_FinBPOrder; -eqtype_Equality -> Order_FinBPOrder; -Order_FinPOrder -> Order_FinBPOrder; -fintype_Finite -> Order_FinBPOrder; -Order_POrder -> Order_FinBPOrder; -Order_CDistrLattice -> Order_FinCDistrLattice; -choice_Choice -> Order_FinCDistrLattice; -Countable -> Order_FinCDistrLattice; -Order_DistrLattice -> Order_FinCDistrLattice; -eqtype_Equality -> Order_FinCDistrLattice; -Order_FinDistrLattice -> Order_FinCDistrLattice; -Order_FinJoinSemilattice -> Order_FinCDistrLattice; -Order_FinLattice -> Order_FinCDistrLattice; -Order_FinMeetSemilattice -> Order_FinCDistrLattice; -Order_FinPOrder -> Order_FinCDistrLattice; -fintype_Finite -> Order_FinCDistrLattice; -Order_JoinSemilattice -> Order_FinCDistrLattice; -Order_Lattice -> Order_FinCDistrLattice; -Order_MeetSemilattice -> Order_FinCDistrLattice; -Order_POrder -> Order_FinCDistrLattice; -Order_BDistrLattice -> Order_FinCTBDistrLattice; -Order_BJoinSemilattice -> Order_FinCTBDistrLattice; -Order_BLattice -> Order_FinCTBDistrLattice; -Order_BMeetSemilattice -> Order_FinCTBDistrLattice; -Order_BPOrder -> Order_FinCTBDistrLattice; -Order_CBDistrLattice -> Order_FinCTBDistrLattice; -Order_CDistrLattice -> Order_FinCTBDistrLattice; -Order_CTBDistrLattice -> Order_FinCTBDistrLattice; -Order_CTDistrLattice -> Order_FinCTBDistrLattice; -choice_Choice -> Order_FinCTBDistrLattice; -Countable -> Order_FinCTBDistrLattice; -Order_DistrLattice -> Order_FinCTBDistrLattice; -eqtype_Equality -> Order_FinCTBDistrLattice; -Order_FinBMeetSemilattice -> Order_FinCTBDistrLattice; -Order_FinBPOrder -> Order_FinCTBDistrLattice; -Order_FinCDistrLattice -> Order_FinCTBDistrLattice; -Order_FinDistrLattice -> Order_FinCTBDistrLattice; -Order_FinJoinSemilattice -> Order_FinCTBDistrLattice; -Order_FinLattice -> Order_FinCTBDistrLattice; -Order_FinMeetSemilattice -> Order_FinCTBDistrLattice; -Order_FinPOrder -> Order_FinCTBDistrLattice; -Order_FinTBDistrLattice -> Order_FinCTBDistrLattice; -Order_FinTBLattice -> Order_FinCTBDistrLattice; -Order_FinTBPOrder -> Order_FinCTBDistrLattice; -Order_FinTJoinSemilattice -> Order_FinCTBDistrLattice; -Order_FinTPOrder -> Order_FinCTBDistrLattice; -fintype_Finite -> Order_FinCTBDistrLattice; -Order_JoinSemilattice -> Order_FinCTBDistrLattice; -Order_Lattice -> Order_FinCTBDistrLattice; -Order_MeetSemilattice -> Order_FinCTBDistrLattice; -Order_POrder -> Order_FinCTBDistrLattice; -Order_TBDistrLattice -> Order_FinCTBDistrLattice; -Order_TBJoinSemilattice -> Order_FinCTBDistrLattice; -Order_TBLattice -> Order_FinCTBDistrLattice; -Order_TBMeetSemilattice -> Order_FinCTBDistrLattice; -Order_TBPOrder -> Order_FinCTBDistrLattice; -Order_TDistrLattice -> Order_FinCTBDistrLattice; -Order_TJoinSemilattice -> Order_FinCTBDistrLattice; -Order_TLattice -> Order_FinCTBDistrLattice; -Order_TMeetSemilattice -> Order_FinCTBDistrLattice; -Order_TPOrder -> Order_FinCTBDistrLattice; -choice_Choice -> Order_FinDistrLattice; -Countable -> Order_FinDistrLattice; -Order_DistrLattice -> Order_FinDistrLattice; -eqtype_Equality -> Order_FinDistrLattice; -Order_FinJoinSemilattice -> Order_FinDistrLattice; -Order_FinLattice -> Order_FinDistrLattice; -Order_FinMeetSemilattice -> Order_FinDistrLattice; -Order_FinPOrder -> Order_FinDistrLattice; -fintype_Finite -> Order_FinDistrLattice; -Order_JoinSemilattice -> Order_FinDistrLattice; -Order_Lattice -> Order_FinDistrLattice; -Order_MeetSemilattice -> Order_FinDistrLattice; -Order_POrder -> Order_FinDistrLattice; -BaseFinGroup -> FinGroup; -choice_Choice -> FinGroup; -Countable -> FinGroup; -eqtype_Equality -> FinGroup; -fintype_Finite -> FinGroup; -choice_Choice -> Order_FinJoinSemilattice; -Countable -> Order_FinJoinSemilattice; -eqtype_Equality -> Order_FinJoinSemilattice; -Order_FinPOrder -> Order_FinJoinSemilattice; -fintype_Finite -> Order_FinJoinSemilattice; -Order_JoinSemilattice -> Order_FinJoinSemilattice; -Order_POrder -> Order_FinJoinSemilattice; -choice_Choice -> Order_FinLattice; -Countable -> Order_FinLattice; -eqtype_Equality -> Order_FinLattice; -Order_FinJoinSemilattice -> Order_FinLattice; -Order_FinMeetSemilattice -> Order_FinLattice; -Order_FinPOrder -> Order_FinLattice; -fintype_Finite -> Order_FinLattice; -Order_JoinSemilattice -> Order_FinLattice; -Order_Lattice -> Order_FinLattice; -Order_MeetSemilattice -> Order_FinLattice; -Order_POrder -> Order_FinLattice; -choice_Choice -> Order_FinMeetSemilattice; -Countable -> Order_FinMeetSemilattice; -eqtype_Equality -> Order_FinMeetSemilattice; -Order_FinPOrder -> Order_FinMeetSemilattice; -fintype_Finite -> Order_FinMeetSemilattice; -Order_MeetSemilattice -> Order_FinMeetSemilattice; -Order_POrder -> Order_FinMeetSemilattice; -choice_Choice -> Order_FinPOrder; -Countable -> Order_FinPOrder; -eqtype_Equality -> Order_FinPOrder; -fintype_Finite -> Order_FinPOrder; -Order_POrder -> Order_FinPOrder; -Order_BDistrLattice -> Order_FinTBDistrLattice; -Order_BJoinSemilattice -> Order_FinTBDistrLattice; -Order_BLattice -> Order_FinTBDistrLattice; -Order_BMeetSemilattice -> Order_FinTBDistrLattice; -Order_BPOrder -> Order_FinTBDistrLattice; -choice_Choice -> Order_FinTBDistrLattice; -Countable -> Order_FinTBDistrLattice; -Order_DistrLattice -> Order_FinTBDistrLattice; -eqtype_Equality -> Order_FinTBDistrLattice; -Order_FinBMeetSemilattice -> Order_FinTBDistrLattice; -Order_FinBPOrder -> Order_FinTBDistrLattice; -Order_FinDistrLattice -> Order_FinTBDistrLattice; -Order_FinJoinSemilattice -> Order_FinTBDistrLattice; -Order_FinLattice -> Order_FinTBDistrLattice; -Order_FinMeetSemilattice -> Order_FinTBDistrLattice; -Order_FinPOrder -> Order_FinTBDistrLattice; -Order_FinTBLattice -> Order_FinTBDistrLattice; -Order_FinTBPOrder -> Order_FinTBDistrLattice; -Order_FinTJoinSemilattice -> Order_FinTBDistrLattice; -Order_FinTPOrder -> Order_FinTBDistrLattice; -fintype_Finite -> Order_FinTBDistrLattice; -Order_JoinSemilattice -> Order_FinTBDistrLattice; -Order_Lattice -> Order_FinTBDistrLattice; -Order_MeetSemilattice -> Order_FinTBDistrLattice; -Order_POrder -> Order_FinTBDistrLattice; -Order_TBDistrLattice -> Order_FinTBDistrLattice; -Order_TBJoinSemilattice -> Order_FinTBDistrLattice; -Order_TBLattice -> Order_FinTBDistrLattice; -Order_TBMeetSemilattice -> Order_FinTBDistrLattice; -Order_TBPOrder -> Order_FinTBDistrLattice; -Order_TDistrLattice -> Order_FinTBDistrLattice; -Order_TJoinSemilattice -> Order_FinTBDistrLattice; -Order_TLattice -> Order_FinTBDistrLattice; -Order_TMeetSemilattice -> Order_FinTBDistrLattice; -Order_TPOrder -> Order_FinTBDistrLattice; -Order_BJoinSemilattice -> Order_FinTBLattice; -Order_BLattice -> Order_FinTBLattice; -Order_BMeetSemilattice -> Order_FinTBLattice; -Order_BPOrder -> Order_FinTBLattice; -choice_Choice -> Order_FinTBLattice; -Countable -> Order_FinTBLattice; -eqtype_Equality -> Order_FinTBLattice; -Order_FinBMeetSemilattice -> Order_FinTBLattice; -Order_FinBPOrder -> Order_FinTBLattice; -Order_FinJoinSemilattice -> Order_FinTBLattice; -Order_FinLattice -> Order_FinTBLattice; -Order_FinMeetSemilattice -> Order_FinTBLattice; -Order_FinPOrder -> Order_FinTBLattice; -Order_FinTBPOrder -> Order_FinTBLattice; -Order_FinTJoinSemilattice -> Order_FinTBLattice; -Order_FinTPOrder -> Order_FinTBLattice; -fintype_Finite -> Order_FinTBLattice; -Order_JoinSemilattice -> Order_FinTBLattice; -Order_Lattice -> Order_FinTBLattice; -Order_MeetSemilattice -> Order_FinTBLattice; -Order_POrder -> Order_FinTBLattice; -Order_TBJoinSemilattice -> Order_FinTBLattice; -Order_TBLattice -> Order_FinTBLattice; -Order_TBMeetSemilattice -> Order_FinTBLattice; -Order_TBPOrder -> Order_FinTBLattice; -Order_TJoinSemilattice -> Order_FinTBLattice; -Order_TLattice -> Order_FinTBLattice; -Order_TMeetSemilattice -> Order_FinTBLattice; -Order_TPOrder -> Order_FinTBLattice; -Order_BPOrder -> Order_FinTBPOrder; -choice_Choice -> Order_FinTBPOrder; -Countable -> Order_FinTBPOrder; -eqtype_Equality -> Order_FinTBPOrder; -Order_FinBPOrder -> Order_FinTBPOrder; -Order_FinPOrder -> Order_FinTBPOrder; -Order_FinTPOrder -> Order_FinTBPOrder; -fintype_Finite -> Order_FinTBPOrder; -Order_POrder -> Order_FinTBPOrder; -Order_TBPOrder -> Order_FinTBPOrder; -Order_TPOrder -> Order_FinTBPOrder; -Order_BDistrLattice -> Order_FinTBTotal; -Order_BJoinSemilattice -> Order_FinTBTotal; -Order_BLattice -> Order_FinTBTotal; -Order_BMeetSemilattice -> Order_FinTBTotal; -Order_BPOrder -> Order_FinTBTotal; -Order_BTotal -> Order_FinTBTotal; -choice_Choice -> Order_FinTBTotal; -Countable -> Order_FinTBTotal; -Order_DistrLattice -> Order_FinTBTotal; -eqtype_Equality -> Order_FinTBTotal; -Order_FinBMeetSemilattice -> Order_FinTBTotal; -Order_FinBPOrder -> Order_FinTBTotal; -Order_FinDistrLattice -> Order_FinTBTotal; -Order_FinJoinSemilattice -> Order_FinTBTotal; -Order_FinLattice -> Order_FinTBTotal; -Order_FinMeetSemilattice -> Order_FinTBTotal; -Order_FinPOrder -> Order_FinTBTotal; -Order_FinTBDistrLattice -> Order_FinTBTotal; -Order_FinTBLattice -> Order_FinTBTotal; -Order_FinTBPOrder -> Order_FinTBTotal; -Order_FinTJoinSemilattice -> Order_FinTBTotal; -Order_FinTPOrder -> Order_FinTBTotal; -Order_FinTotal -> Order_FinTBTotal; -fintype_Finite -> Order_FinTBTotal; -Order_JoinSemilattice -> Order_FinTBTotal; -Order_Lattice -> Order_FinTBTotal; -Order_MeetSemilattice -> Order_FinTBTotal; -Order_POrder -> Order_FinTBTotal; -Order_TBDistrLattice -> Order_FinTBTotal; -Order_TBJoinSemilattice -> Order_FinTBTotal; -Order_TBLattice -> Order_FinTBTotal; -Order_TBMeetSemilattice -> Order_FinTBTotal; -Order_TBPOrder -> Order_FinTBTotal; -Order_TBTotal -> Order_FinTBTotal; -Order_TDistrLattice -> Order_FinTBTotal; -Order_TJoinSemilattice -> Order_FinTBTotal; -Order_TLattice -> Order_FinTBTotal; -Order_TMeetSemilattice -> Order_FinTBTotal; -Order_TPOrder -> Order_FinTBTotal; -Order_TTotal -> Order_FinTBTotal; -Order_Total -> Order_FinTBTotal; -choice_Choice -> Order_FinTJoinSemilattice; -Countable -> Order_FinTJoinSemilattice; -eqtype_Equality -> Order_FinTJoinSemilattice; -Order_FinJoinSemilattice -> Order_FinTJoinSemilattice; -Order_FinPOrder -> Order_FinTJoinSemilattice; -Order_FinTPOrder -> Order_FinTJoinSemilattice; -fintype_Finite -> Order_FinTJoinSemilattice; -Order_JoinSemilattice -> Order_FinTJoinSemilattice; -Order_POrder -> Order_FinTJoinSemilattice; -Order_TJoinSemilattice -> Order_FinTJoinSemilattice; -Order_TPOrder -> Order_FinTJoinSemilattice; -choice_Choice -> Order_FinTPOrder; -Countable -> Order_FinTPOrder; -eqtype_Equality -> Order_FinTPOrder; -Order_FinPOrder -> Order_FinTPOrder; -fintype_Finite -> Order_FinTPOrder; -Order_POrder -> Order_FinTPOrder; -Order_TPOrder -> Order_FinTPOrder; -choice_Choice -> Order_FinTotal; -Countable -> Order_FinTotal; -Order_DistrLattice -> Order_FinTotal; -eqtype_Equality -> Order_FinTotal; -Order_FinDistrLattice -> Order_FinTotal; -Order_FinJoinSemilattice -> Order_FinTotal; -Order_FinLattice -> Order_FinTotal; -Order_FinMeetSemilattice -> Order_FinTotal; -Order_FinPOrder -> Order_FinTotal; -fintype_Finite -> Order_FinTotal; -Order_JoinSemilattice -> Order_FinTotal; -Order_Lattice -> Order_FinTotal; -Order_MeetSemilattice -> Order_FinTotal; -Order_POrder -> Order_FinTotal; -Order_Total -> Order_FinTotal; -choice_Choice -> fintype_Finite; -Countable -> fintype_Finite; -eqtype_Equality -> fintype_Finite; -Content -> FiniteMeasure; -FinNumFun -> FiniteMeasure; -Measure -> FiniteMeasure; -SFiniteMeasure -> FiniteMeasure; -SigmaFiniteContent -> FiniteMeasure; -SigmaFiniteMeasure -> FiniteMeasure; -Fun -> InjFun; -Inject -> InjFun; -OInvFun -> InjFun; -OInversible -> InjFun; -OInversible -> Inject; -choice_Choice -> GRing_IntegralDomain; -GRing_ComNzRing -> GRing_IntegralDomain; -GRing_ComNzSemiRing -> GRing_IntegralDomain; -GRing_ComPzRing -> GRing_IntegralDomain; -GRing_ComPzSemiRing -> GRing_IntegralDomain; -GRing_ComUnitRing -> GRing_IntegralDomain; -eqtype_Equality -> GRing_IntegralDomain; -GRing_Nmodule -> GRing_IntegralDomain; -GRing_NzRing -> GRing_IntegralDomain; -GRing_NzSemiRing -> GRing_IntegralDomain; -GRing_PzRing -> GRing_IntegralDomain; -GRing_PzSemiRing -> GRing_IntegralDomain; -GRing_UnitRing -> GRing_IntegralDomain; -GRing_Zmodule -> GRing_IntegralDomain; -Fun -> InvFun; -Inversible -> InvFun; -OInvFun -> InvFun; -OInversible -> InvFun; -OInversible -> Inversible; -Order_OrderMorphism -> Order_JoinLatticeMorphism; -choice_Choice -> Order_JoinSemilattice; -eqtype_Equality -> Order_JoinSemilattice; -Order_POrder -> Order_JoinSemilattice; -Order_BJoinSemilattice -> Order_JoinSubBLattice; -Order_BLattice -> Order_JoinSubBLattice; -Order_BMeetSemilattice -> Order_JoinSubBLattice; -Order_BPOrder -> Order_JoinSubBLattice; -choice_Choice -> Order_JoinSubBLattice; -eqtype_Equality -> Order_JoinSubBLattice; -Order_JoinSemilattice -> Order_JoinSubBLattice; -Order_JoinSubLattice -> Order_JoinSubBLattice; -Order_Lattice -> Order_JoinSubBLattice; -Order_MeetSemilattice -> Order_JoinSubBLattice; -Order_POrder -> Order_JoinSubBLattice; -SubChoice -> Order_JoinSubBLattice; -SubEquality -> Order_JoinSubBLattice; -Order_SubPOrder -> Order_JoinSubBLattice; -Order_SubPOrderBLattice -> Order_JoinSubBLattice; -Order_SubPOrderLattice -> Order_JoinSubBLattice; -SubType -> Order_JoinSubBLattice; -choice_Choice -> Order_JoinSubLattice; -eqtype_Equality -> Order_JoinSubLattice; -Order_JoinSemilattice -> Order_JoinSubLattice; -Order_Lattice -> Order_JoinSubLattice; -Order_MeetSemilattice -> Order_JoinSubLattice; -Order_POrder -> Order_JoinSubLattice; -SubChoice -> Order_JoinSubLattice; -SubEquality -> Order_JoinSubLattice; -Order_SubPOrder -> Order_JoinSubLattice; -Order_SubPOrderLattice -> Order_JoinSubLattice; -SubType -> Order_JoinSubLattice; -Order_BJoinSemilattice -> Order_JoinSubTBLattice; -Order_BLattice -> Order_JoinSubTBLattice; -Order_BMeetSemilattice -> Order_JoinSubTBLattice; -Order_BPOrder -> Order_JoinSubTBLattice; -choice_Choice -> Order_JoinSubTBLattice; -eqtype_Equality -> Order_JoinSubTBLattice; -Order_JoinSemilattice -> Order_JoinSubTBLattice; -Order_JoinSubBLattice -> Order_JoinSubTBLattice; -Order_JoinSubLattice -> Order_JoinSubTBLattice; -Order_JoinSubTLattice -> Order_JoinSubTBLattice; -Order_Lattice -> Order_JoinSubTBLattice; -Order_MeetSemilattice -> Order_JoinSubTBLattice; -Order_POrder -> Order_JoinSubTBLattice; -SubChoice -> Order_JoinSubTBLattice; -SubEquality -> Order_JoinSubTBLattice; -Order_SubPOrder -> Order_JoinSubTBLattice; -Order_SubPOrderBLattice -> Order_JoinSubTBLattice; -Order_SubPOrderLattice -> Order_JoinSubTBLattice; -Order_SubPOrderTBLattice -> Order_JoinSubTBLattice; -Order_SubPOrderTLattice -> Order_JoinSubTBLattice; -SubType -> Order_JoinSubTBLattice; -Order_TBJoinSemilattice -> Order_JoinSubTBLattice; -Order_TBLattice -> Order_JoinSubTBLattice; -Order_TBMeetSemilattice -> Order_JoinSubTBLattice; -Order_TBPOrder -> Order_JoinSubTBLattice; -Order_TJoinSemilattice -> Order_JoinSubTBLattice; -Order_TLattice -> Order_JoinSubTBLattice; -Order_TMeetSemilattice -> Order_JoinSubTBLattice; -Order_TPOrder -> Order_JoinSubTBLattice; -choice_Choice -> Order_JoinSubTLattice; -eqtype_Equality -> Order_JoinSubTLattice; -Order_JoinSemilattice -> Order_JoinSubTLattice; -Order_JoinSubLattice -> Order_JoinSubTLattice; -Order_Lattice -> Order_JoinSubTLattice; -Order_MeetSemilattice -> Order_JoinSubTLattice; -Order_POrder -> Order_JoinSubTLattice; -SubChoice -> Order_JoinSubTLattice; -SubEquality -> Order_JoinSubTLattice; -Order_SubPOrder -> Order_JoinSubTLattice; -Order_SubPOrderLattice -> Order_JoinSubTLattice; -Order_SubPOrderTLattice -> Order_JoinSubTLattice; -SubType -> Order_JoinSubTLattice; -Order_TJoinSemilattice -> Order_JoinSubTLattice; -Order_TLattice -> Order_JoinSubTLattice; -Order_TMeetSemilattice -> Order_JoinSubTLattice; -Order_TPOrder -> Order_JoinSubTLattice; -GRing_Additive -> GRing_LRMorphism; -GRing_Linear -> GRing_LRMorphism; -GRing_RMorphism -> GRing_LRMorphism; -choice_Choice -> GRing_LSemiAlgebra; -eqtype_Equality -> GRing_LSemiAlgebra; -GRing_LSemiModule -> GRing_LSemiAlgebra; -GRing_Nmodule -> GRing_LSemiAlgebra; -GRing_NzSemiRing -> GRing_LSemiAlgebra; -GRing_PzSemiRing -> GRing_LSemiAlgebra; -choice_Choice -> GRing_LSemiModule; -eqtype_Equality -> GRing_LSemiModule; -GRing_Nmodule -> GRing_LSemiModule; -choice_Choice -> GRing_Lalgebra; -eqtype_Equality -> GRing_Lalgebra; -GRing_LSemiAlgebra -> GRing_Lalgebra; -GRing_LSemiModule -> GRing_Lalgebra; -GRing_Lmodule -> GRing_Lalgebra; -GRing_Nmodule -> GRing_Lalgebra; -GRing_NzRing -> GRing_Lalgebra; -GRing_NzSemiRing -> GRing_Lalgebra; -GRing_PzRing -> GRing_Lalgebra; -GRing_PzSemiRing -> GRing_Lalgebra; -GRing_Zmodule -> GRing_Lalgebra; -choice_Choice -> Order_Lattice; -eqtype_Equality -> Order_Lattice; -Order_JoinSemilattice -> Order_Lattice; -Order_MeetSemilattice -> Order_Lattice; -Order_POrder -> Order_Lattice; -Order_JoinLatticeClosed -> Order_LatticeClosed; -Order_MeetLatticeClosed -> Order_LatticeClosed; -Order_JoinLatticeMorphism -> Order_LatticeMorphism; -Order_MeetLatticeMorphism -> Order_LatticeMorphism; -Order_OrderMorphism -> Order_LatticeMorphism; -SemiGroup_Law -> Monoid_Law; -GRing_Scale_PreLaw -> GRing_Scale_Law; -GRing_Additive -> GRing_Linear; -choice_Choice -> GRing_Lmodule; -eqtype_Equality -> GRing_Lmodule; -GRing_LSemiModule -> GRing_Lmodule; -GRing_Nmodule -> GRing_Lmodule; -GRing_Zmodule -> GRing_Lmodule; -AlgebraOfSets -> Measurable; -choice_Choice -> Measurable; -eqtype_Equality -> Measurable; -Pointed -> Measurable; -RingOfSets -> Measurable; -SemiRingOfSets -> Measurable; -SigmaRing -> Measurable; -Content -> Measure; -Order_OrderMorphism -> Order_MeetLatticeMorphism; -choice_Choice -> Order_MeetSemilattice; -eqtype_Equality -> Order_MeetSemilattice; -Order_POrder -> Order_MeetSemilattice; -Order_BJoinSemilattice -> Order_MeetSubBLattice; -Order_BLattice -> Order_MeetSubBLattice; -Order_BMeetSemilattice -> Order_MeetSubBLattice; -Order_BPOrder -> Order_MeetSubBLattice; -choice_Choice -> Order_MeetSubBLattice; -eqtype_Equality -> Order_MeetSubBLattice; -Order_JoinSemilattice -> Order_MeetSubBLattice; -Order_Lattice -> Order_MeetSubBLattice; -Order_MeetSemilattice -> Order_MeetSubBLattice; -Order_MeetSubLattice -> Order_MeetSubBLattice; -Order_POrder -> Order_MeetSubBLattice; -SubChoice -> Order_MeetSubBLattice; -SubEquality -> Order_MeetSubBLattice; -Order_SubPOrder -> Order_MeetSubBLattice; -Order_SubPOrderBLattice -> Order_MeetSubBLattice; -Order_SubPOrderLattice -> Order_MeetSubBLattice; -SubType -> Order_MeetSubBLattice; -choice_Choice -> Order_MeetSubLattice; -eqtype_Equality -> Order_MeetSubLattice; -Order_JoinSemilattice -> Order_MeetSubLattice; -Order_Lattice -> Order_MeetSubLattice; -Order_MeetSemilattice -> Order_MeetSubLattice; -Order_POrder -> Order_MeetSubLattice; -SubChoice -> Order_MeetSubLattice; -SubEquality -> Order_MeetSubLattice; -Order_SubPOrder -> Order_MeetSubLattice; -Order_SubPOrderLattice -> Order_MeetSubLattice; -SubType -> Order_MeetSubLattice; -Order_BJoinSemilattice -> Order_MeetSubTBLattice; -Order_BLattice -> Order_MeetSubTBLattice; -Order_BMeetSemilattice -> Order_MeetSubTBLattice; -Order_BPOrder -> Order_MeetSubTBLattice; -choice_Choice -> Order_MeetSubTBLattice; -eqtype_Equality -> Order_MeetSubTBLattice; -Order_JoinSemilattice -> Order_MeetSubTBLattice; -Order_Lattice -> Order_MeetSubTBLattice; -Order_MeetSemilattice -> Order_MeetSubTBLattice; -Order_MeetSubBLattice -> Order_MeetSubTBLattice; -Order_MeetSubLattice -> Order_MeetSubTBLattice; -Order_MeetSubTLattice -> Order_MeetSubTBLattice; -Order_POrder -> Order_MeetSubTBLattice; -SubChoice -> Order_MeetSubTBLattice; -SubEquality -> Order_MeetSubTBLattice; -Order_SubPOrder -> Order_MeetSubTBLattice; -Order_SubPOrderBLattice -> Order_MeetSubTBLattice; -Order_SubPOrderLattice -> Order_MeetSubTBLattice; -Order_SubPOrderTBLattice -> Order_MeetSubTBLattice; -Order_SubPOrderTLattice -> Order_MeetSubTBLattice; -SubType -> Order_MeetSubTBLattice; -Order_TBJoinSemilattice -> Order_MeetSubTBLattice; -Order_TBLattice -> Order_MeetSubTBLattice; -Order_TBMeetSemilattice -> Order_MeetSubTBLattice; -Order_TBPOrder -> Order_MeetSubTBLattice; -Order_TJoinSemilattice -> Order_MeetSubTBLattice; -Order_TLattice -> Order_MeetSubTBLattice; -Order_TMeetSemilattice -> Order_MeetSubTBLattice; -Order_TPOrder -> Order_MeetSubTBLattice; -choice_Choice -> Order_MeetSubTLattice; -eqtype_Equality -> Order_MeetSubTLattice; -Order_JoinSemilattice -> Order_MeetSubTLattice; -Order_Lattice -> Order_MeetSubTLattice; -Order_MeetSemilattice -> Order_MeetSubTLattice; -Order_MeetSubLattice -> Order_MeetSubTLattice; -Order_POrder -> Order_MeetSubTLattice; -SubChoice -> Order_MeetSubTLattice; -SubEquality -> Order_MeetSubTLattice; -Order_SubPOrder -> Order_MeetSubTLattice; -Order_SubPOrderLattice -> Order_MeetSubTLattice; -Order_SubPOrderTLattice -> Order_MeetSubTLattice; -SubType -> Order_MeetSubTLattice; -Order_TJoinSemilattice -> Order_MeetSubTLattice; -Order_TLattice -> Order_MeetSubTLattice; -Order_TMeetSemilattice -> Order_MeetSubTLattice; -Order_TPOrder -> Order_MeetSubTLattice; -GRing_Mul2Closed -> GRing_MulClosed; -choice_Choice -> Nbhs; -eqtype_Equality -> Nbhs; -Filtered -> Nbhs; -choice_Choice -> NbhsLmodule; -eqtype_Equality -> NbhsLmodule; -Filtered -> NbhsLmodule; -GRing_LSemiModule -> NbhsLmodule; -GRing_Lmodule -> NbhsLmodule; -Nbhs -> NbhsLmodule; -NbhsNmodule -> NbhsLmodule; -NbhsZmodule -> NbhsLmodule; -GRing_Nmodule -> NbhsLmodule; -GRing_Zmodule -> NbhsLmodule; -choice_Choice -> NbhsNmodule; -eqtype_Equality -> NbhsNmodule; -Filtered -> NbhsNmodule; -Nbhs -> NbhsNmodule; -GRing_Nmodule -> NbhsNmodule; -choice_Choice -> NbhsZmodule; -eqtype_Equality -> NbhsZmodule; -Filtered -> NbhsZmodule; -Nbhs -> NbhsZmodule; -NbhsNmodule -> NbhsZmodule; -GRing_Nmodule -> NbhsZmodule; -GRing_Zmodule -> NbhsZmodule; -choice_Choice -> GRing_Nmodule; -eqtype_Equality -> GRing_Nmodule; -choice_Choice -> NormedModule; -eqtype_Equality -> NormedModule; -Filtered -> NormedModule; -GRing_LSemiModule -> NormedModule; -GRing_Lmodule -> NormedModule; -Nbhs -> NormedModule; -NbhsLmodule -> NormedModule; -NbhsNmodule -> NormedModule; -NbhsZmodule -> NormedModule; -GRing_Nmodule -> NormedModule; -Num_NormedZmodule -> NormedModule; -Pointed -> NormedModule; -PointedFiltered -> NormedModule; -PointedNbhs -> NormedModule; -PointedTopological -> NormedModule; -PointedUniform -> NormedModule; -PreTopologicalLmodule -> NormedModule; -PreTopologicalNmodule -> NormedModule; -PreTopologicalZmodule -> NormedModule; -PreUniformLmodule -> NormedModule; -PreUniformNmodule -> NormedModule; -PreUniformZmodule -> NormedModule; -PseudoMetric -> NormedModule; -PseudoMetricNormedZmod -> NormedModule; -PseudoPointedMetric -> NormedModule; -Num_SemiNormedZmodule -> NormedModule; -Topological -> NormedModule; -TopologicalLmodule -> NormedModule; -TopologicalNmodule -> NormedModule; -TopologicalZmodule -> NormedModule; -Tvs -> NormedModule; -Uniform -> NormedModule; -GRing_Zmodule -> NormedModule; -choice_Choice -> Num_NormedZmodule; -eqtype_Equality -> Num_NormedZmodule; -GRing_Nmodule -> Num_NormedZmodule; -Num_SemiNormedZmodule -> Num_NormedZmodule; -GRing_Zmodule -> Num_NormedZmodule; -choice_Choice -> Num_NumDomain; -GRing_ComNzRing -> Num_NumDomain; -GRing_ComNzSemiRing -> Num_NumDomain; -GRing_ComPzRing -> Num_NumDomain; -GRing_ComPzSemiRing -> Num_NumDomain; -GRing_ComUnitRing -> Num_NumDomain; -eqtype_Equality -> Num_NumDomain; -GRing_IntegralDomain -> Num_NumDomain; -GRing_Nmodule -> Num_NumDomain; -Num_NormedZmodule -> Num_NumDomain; -GRing_NzRing -> Num_NumDomain; -GRing_NzSemiRing -> Num_NumDomain; -Order_POrder -> Num_NumDomain; -Num_POrderedZmodule -> Num_NumDomain; -GRing_PzRing -> Num_NumDomain; -GRing_PzSemiRing -> Num_NumDomain; -Num_SemiNormedZmodule -> Num_NumDomain; -GRing_UnitRing -> Num_NumDomain; -GRing_Zmodule -> Num_NumDomain; -choice_Choice -> Num_NumField; -GRing_ComNzRing -> Num_NumField; -GRing_ComNzSemiRing -> Num_NumField; -GRing_ComPzRing -> Num_NumField; -GRing_ComPzSemiRing -> Num_NumField; -GRing_ComUnitRing -> Num_NumField; -eqtype_Equality -> Num_NumField; -GRing_Field -> Num_NumField; -GRing_IntegralDomain -> Num_NumField; -GRing_Nmodule -> Num_NumField; -Num_NormedZmodule -> Num_NumField; -Num_NumDomain -> Num_NumField; -GRing_NzRing -> Num_NumField; -GRing_NzSemiRing -> Num_NumField; -Order_POrder -> Num_NumField; -Num_POrderedZmodule -> Num_NumField; -GRing_PzRing -> Num_NumField; -GRing_PzSemiRing -> Num_NumField; -Num_SemiNormedZmodule -> Num_NumField; -GRing_UnitRing -> Num_NumField; -GRing_Zmodule -> Num_NumField; -choice_Choice -> GRing_NzRing; -eqtype_Equality -> GRing_NzRing; -GRing_Nmodule -> GRing_NzRing; -GRing_NzSemiRing -> GRing_NzRing; -GRing_PzRing -> GRing_NzRing; -GRing_PzSemiRing -> GRing_NzRing; -GRing_Zmodule -> GRing_NzRing; -choice_Choice -> GRing_NzSemiRing; -eqtype_Equality -> GRing_NzSemiRing; -GRing_Nmodule -> GRing_NzSemiRing; -GRing_PzSemiRing -> GRing_NzSemiRing; -Fun -> OInvFun; -OInversible -> OInvFun; -choice_Choice -> OrderNbhs; -Order_DistrLattice -> OrderNbhs; -eqtype_Equality -> OrderNbhs; -Filtered -> OrderNbhs; -Order_JoinSemilattice -> OrderNbhs; -Order_Lattice -> OrderNbhs; -Order_MeetSemilattice -> OrderNbhs; -Nbhs -> OrderNbhs; -Order_POrder -> OrderNbhs; -Order_Total -> OrderNbhs; -choice_Choice -> OrderPseudoMetric; -Order_DistrLattice -> OrderPseudoMetric; -eqtype_Equality -> OrderPseudoMetric; -Filtered -> OrderPseudoMetric; -Order_JoinSemilattice -> OrderPseudoMetric; -Order_Lattice -> OrderPseudoMetric; -Order_MeetSemilattice -> OrderPseudoMetric; -Nbhs -> OrderPseudoMetric; -OrderNbhs -> OrderPseudoMetric; -OrderTopological -> OrderPseudoMetric; -OrderUniform -> OrderPseudoMetric; -Order_POrder -> OrderPseudoMetric; -PseudoMetric -> OrderPseudoMetric; -Topological -> OrderPseudoMetric; -Order_Total -> OrderPseudoMetric; -Uniform -> OrderPseudoMetric; -choice_Choice -> OrderTopological; -Order_DistrLattice -> OrderTopological; -eqtype_Equality -> OrderTopological; -Filtered -> OrderTopological; -Order_JoinSemilattice -> OrderTopological; -Order_Lattice -> OrderTopological; -Order_MeetSemilattice -> OrderTopological; -Nbhs -> OrderTopological; -OrderNbhs -> OrderTopological; -Order_POrder -> OrderTopological; -Topological -> OrderTopological; -Order_Total -> OrderTopological; -choice_Choice -> OrderUniform; -Order_DistrLattice -> OrderUniform; -eqtype_Equality -> OrderUniform; -Filtered -> OrderUniform; -Order_JoinSemilattice -> OrderUniform; -Order_Lattice -> OrderUniform; -Order_MeetSemilattice -> OrderUniform; -Nbhs -> OrderUniform; -OrderNbhs -> OrderUniform; -OrderTopological -> OrderUniform; -Order_POrder -> OrderUniform; -Topological -> OrderUniform; -Order_Total -> OrderUniform; -Uniform -> OrderUniform; -choice_Choice -> Order_POrder; -eqtype_Equality -> Order_POrder; -choice_Choice -> Num_POrderedZmodule; -eqtype_Equality -> Num_POrderedZmodule; -GRing_Nmodule -> Num_POrderedZmodule; -Order_POrder -> Num_POrderedZmodule; -GRing_Zmodule -> Num_POrderedZmodule; -choice_Choice -> Pointed; -eqtype_Equality -> Pointed; -choice_Choice -> PointedDiscreteOrderTopology; -DiscreteNbhs -> PointedDiscreteOrderTopology; -DiscreteOrderTopology -> PointedDiscreteOrderTopology; -DiscreteTopology -> PointedDiscreteOrderTopology; -Order_DistrLattice -> PointedDiscreteOrderTopology; -eqtype_Equality -> PointedDiscreteOrderTopology; -Filtered -> PointedDiscreteOrderTopology; -Order_JoinSemilattice -> PointedDiscreteOrderTopology; -Order_Lattice -> PointedDiscreteOrderTopology; -Order_MeetSemilattice -> PointedDiscreteOrderTopology; -Nbhs -> PointedDiscreteOrderTopology; -OrderNbhs -> PointedDiscreteOrderTopology; -OrderTopological -> PointedDiscreteOrderTopology; -Order_POrder -> PointedDiscreteOrderTopology; -Pointed -> PointedDiscreteOrderTopology; -PointedDiscreteTopology -> PointedDiscreteOrderTopology; -PointedFiltered -> PointedDiscreteOrderTopology; -PointedNbhs -> PointedDiscreteOrderTopology; -PointedTopological -> PointedDiscreteOrderTopology; -Topological -> PointedDiscreteOrderTopology; -Order_Total -> PointedDiscreteOrderTopology; -choice_Choice -> PointedDiscreteTopology; -DiscreteNbhs -> PointedDiscreteTopology; -DiscreteTopology -> PointedDiscreteTopology; -eqtype_Equality -> PointedDiscreteTopology; -Filtered -> PointedDiscreteTopology; -Nbhs -> PointedDiscreteTopology; -Pointed -> PointedDiscreteTopology; -PointedFiltered -> PointedDiscreteTopology; -PointedNbhs -> PointedDiscreteTopology; -PointedTopological -> PointedDiscreteTopology; -Topological -> PointedDiscreteTopology; -choice_Choice -> PointedFiltered; -eqtype_Equality -> PointedFiltered; -Filtered -> PointedFiltered; -Pointed -> PointedFiltered; -choice_Choice -> PointedNbhs; -eqtype_Equality -> PointedNbhs; -Filtered -> PointedNbhs; -Nbhs -> PointedNbhs; -Pointed -> PointedNbhs; -PointedFiltered -> PointedNbhs; -choice_Choice -> PointedTopological; -eqtype_Equality -> PointedTopological; -Filtered -> PointedTopological; -Nbhs -> PointedTopological; -Pointed -> PointedTopological; -PointedFiltered -> PointedTopological; -PointedNbhs -> PointedTopological; -Topological -> PointedTopological; -choice_Choice -> PointedUniform; -eqtype_Equality -> PointedUniform; -Filtered -> PointedUniform; -Nbhs -> PointedUniform; -Pointed -> PointedUniform; -PointedFiltered -> PointedUniform; -PointedNbhs -> PointedUniform; -PointedTopological -> PointedUniform; -Topological -> PointedUniform; -Uniform -> PointedUniform; -choice_Choice -> PreTopologicalLmodule; -eqtype_Equality -> PreTopologicalLmodule; -Filtered -> PreTopologicalLmodule; -GRing_LSemiModule -> PreTopologicalLmodule; -GRing_Lmodule -> PreTopologicalLmodule; -Nbhs -> PreTopologicalLmodule; -NbhsLmodule -> PreTopologicalLmodule; -NbhsNmodule -> PreTopologicalLmodule; -NbhsZmodule -> PreTopologicalLmodule; -GRing_Nmodule -> PreTopologicalLmodule; -PreTopologicalNmodule -> PreTopologicalLmodule; -PreTopologicalZmodule -> PreTopologicalLmodule; -Topological -> PreTopologicalLmodule; -GRing_Zmodule -> PreTopologicalLmodule; -choice_Choice -> PreTopologicalNmodule; -eqtype_Equality -> PreTopologicalNmodule; -Filtered -> PreTopologicalNmodule; -Nbhs -> PreTopologicalNmodule; -NbhsNmodule -> PreTopologicalNmodule; -GRing_Nmodule -> PreTopologicalNmodule; -Topological -> PreTopologicalNmodule; -choice_Choice -> PreTopologicalZmodule; -eqtype_Equality -> PreTopologicalZmodule; -Filtered -> PreTopologicalZmodule; -Nbhs -> PreTopologicalZmodule; -NbhsNmodule -> PreTopologicalZmodule; -NbhsZmodule -> PreTopologicalZmodule; -GRing_Nmodule -> PreTopologicalZmodule; -PreTopologicalNmodule -> PreTopologicalZmodule; -Topological -> PreTopologicalZmodule; -GRing_Zmodule -> PreTopologicalZmodule; -choice_Choice -> PreUniformLmodule; -eqtype_Equality -> PreUniformLmodule; -Filtered -> PreUniformLmodule; -GRing_LSemiModule -> PreUniformLmodule; -GRing_Lmodule -> PreUniformLmodule; -Nbhs -> PreUniformLmodule; -NbhsLmodule -> PreUniformLmodule; -NbhsNmodule -> PreUniformLmodule; -NbhsZmodule -> PreUniformLmodule; -GRing_Nmodule -> PreUniformLmodule; -PreTopologicalLmodule -> PreUniformLmodule; -PreTopologicalNmodule -> PreUniformLmodule; -PreTopologicalZmodule -> PreUniformLmodule; -PreUniformNmodule -> PreUniformLmodule; -PreUniformZmodule -> PreUniformLmodule; -Topological -> PreUniformLmodule; -Uniform -> PreUniformLmodule; -GRing_Zmodule -> PreUniformLmodule; -choice_Choice -> PreUniformNmodule; -eqtype_Equality -> PreUniformNmodule; -Filtered -> PreUniformNmodule; -Nbhs -> PreUniformNmodule; -NbhsNmodule -> PreUniformNmodule; -GRing_Nmodule -> PreUniformNmodule; -PreTopologicalNmodule -> PreUniformNmodule; -Topological -> PreUniformNmodule; -Uniform -> PreUniformNmodule; -choice_Choice -> PreUniformZmodule; -eqtype_Equality -> PreUniformZmodule; -Filtered -> PreUniformZmodule; -Nbhs -> PreUniformZmodule; -NbhsNmodule -> PreUniformZmodule; -NbhsZmodule -> PreUniformZmodule; -GRing_Nmodule -> PreUniformZmodule; -PreTopologicalNmodule -> PreUniformZmodule; -PreTopologicalZmodule -> PreUniformZmodule; -PreUniformNmodule -> PreUniformZmodule; -Topological -> PreUniformZmodule; -Uniform -> PreUniformZmodule; -GRing_Zmodule -> PreUniformZmodule; -Content -> Probability; -FinNumFun -> Probability; -FiniteMeasure -> Probability; -Measure -> Probability; -SFiniteMeasure -> Probability; -SigmaFiniteContent -> Probability; -SigmaFiniteMeasure -> Probability; -SubProbability -> Probability; -choice_Choice -> PseudoMetric; -eqtype_Equality -> PseudoMetric; -Filtered -> PseudoMetric; -Nbhs -> PseudoMetric; -Topological -> PseudoMetric; -Uniform -> PseudoMetric; -choice_Choice -> PseudoMetricNormedZmod; -eqtype_Equality -> PseudoMetricNormedZmod; -Filtered -> PseudoMetricNormedZmod; -Nbhs -> PseudoMetricNormedZmod; -NbhsNmodule -> PseudoMetricNormedZmod; -NbhsZmodule -> PseudoMetricNormedZmod; -GRing_Nmodule -> PseudoMetricNormedZmod; -Num_NormedZmodule -> PseudoMetricNormedZmod; -Pointed -> PseudoMetricNormedZmod; -PointedFiltered -> PseudoMetricNormedZmod; -PointedNbhs -> PseudoMetricNormedZmod; -PointedTopological -> PseudoMetricNormedZmod; -PointedUniform -> PseudoMetricNormedZmod; -PreTopologicalNmodule -> PseudoMetricNormedZmod; -PreTopologicalZmodule -> PseudoMetricNormedZmod; -PreUniformNmodule -> PseudoMetricNormedZmod; -PreUniformZmodule -> PseudoMetricNormedZmod; -PseudoMetric -> PseudoMetricNormedZmod; -PseudoPointedMetric -> PseudoMetricNormedZmod; -Num_SemiNormedZmodule -> PseudoMetricNormedZmod; -Topological -> PseudoMetricNormedZmod; -Uniform -> PseudoMetricNormedZmod; -GRing_Zmodule -> PseudoMetricNormedZmod; -choice_Choice -> PseudoPointedMetric; -eqtype_Equality -> PseudoPointedMetric; -Filtered -> PseudoPointedMetric; -Nbhs -> PseudoPointedMetric; -Pointed -> PseudoPointedMetric; -PointedFiltered -> PseudoPointedMetric; -PointedNbhs -> PseudoPointedMetric; -PointedTopological -> PseudoPointedMetric; -PointedUniform -> PseudoPointedMetric; -PseudoMetric -> PseudoPointedMetric; -Topological -> PseudoPointedMetric; -Uniform -> PseudoPointedMetric; -choice_Choice -> GRing_PzRing; -eqtype_Equality -> GRing_PzRing; -GRing_Nmodule -> GRing_PzRing; -GRing_PzSemiRing -> GRing_PzRing; -GRing_Zmodule -> GRing_PzRing; -choice_Choice -> GRing_PzSemiRing; -eqtype_Equality -> GRing_PzSemiRing; -GRing_Nmodule -> GRing_PzSemiRing; -GRing_Additive -> GRing_RMorphism; -Num_ArchiNumDomain -> reals_Real; -Num_ArchiNumField -> reals_Real; -Num_ArchiRealClosedField -> reals_Real; -Num_ArchiRealDomain -> reals_Real; -Num_ArchiRealField -> reals_Real; -choice_Choice -> reals_Real; -GRing_ComNzRing -> reals_Real; -GRing_ComNzSemiRing -> reals_Real; -GRing_ComPzRing -> reals_Real; -GRing_ComPzSemiRing -> reals_Real; -GRing_ComUnitRing -> reals_Real; -Order_DistrLattice -> reals_Real; -eqtype_Equality -> reals_Real; -GRing_Field -> reals_Real; -GRing_IntegralDomain -> reals_Real; -Order_JoinSemilattice -> reals_Real; -Order_Lattice -> reals_Real; -Order_MeetSemilattice -> reals_Real; -GRing_Nmodule -> reals_Real; -Num_NormedZmodule -> reals_Real; -Num_NumDomain -> reals_Real; -Num_NumField -> reals_Real; -GRing_NzRing -> reals_Real; -GRing_NzSemiRing -> reals_Real; -Order_POrder -> reals_Real; -Num_POrderedZmodule -> reals_Real; -GRing_PzRing -> reals_Real; -GRing_PzSemiRing -> reals_Real; -Num_RealClosedField -> reals_Real; -Num_RealDomain -> reals_Real; -Num_RealField -> reals_Real; -Num_SemiNormedZmodule -> reals_Real; -Order_Total -> reals_Real; -GRing_UnitRing -> reals_Real; -GRing_Zmodule -> reals_Real; -choice_Choice -> Num_RealClosedField; -GRing_ComNzRing -> Num_RealClosedField; -GRing_ComNzSemiRing -> Num_RealClosedField; -GRing_ComPzRing -> Num_RealClosedField; -GRing_ComPzSemiRing -> Num_RealClosedField; -GRing_ComUnitRing -> Num_RealClosedField; -Order_DistrLattice -> Num_RealClosedField; -eqtype_Equality -> Num_RealClosedField; -GRing_Field -> Num_RealClosedField; -GRing_IntegralDomain -> Num_RealClosedField; -Order_JoinSemilattice -> Num_RealClosedField; -Order_Lattice -> Num_RealClosedField; -Order_MeetSemilattice -> Num_RealClosedField; -GRing_Nmodule -> Num_RealClosedField; -Num_NormedZmodule -> Num_RealClosedField; -Num_NumDomain -> Num_RealClosedField; -Num_NumField -> Num_RealClosedField; -GRing_NzRing -> Num_RealClosedField; -GRing_NzSemiRing -> Num_RealClosedField; -Order_POrder -> Num_RealClosedField; -Num_POrderedZmodule -> Num_RealClosedField; -GRing_PzRing -> Num_RealClosedField; -GRing_PzSemiRing -> Num_RealClosedField; -Num_RealDomain -> Num_RealClosedField; -Num_RealField -> Num_RealClosedField; -Num_SemiNormedZmodule -> Num_RealClosedField; -Order_Total -> Num_RealClosedField; -GRing_UnitRing -> Num_RealClosedField; -GRing_Zmodule -> Num_RealClosedField; -choice_Choice -> Num_RealDomain; -GRing_ComNzRing -> Num_RealDomain; -GRing_ComNzSemiRing -> Num_RealDomain; -GRing_ComPzRing -> Num_RealDomain; -GRing_ComPzSemiRing -> Num_RealDomain; -GRing_ComUnitRing -> Num_RealDomain; -Order_DistrLattice -> Num_RealDomain; -eqtype_Equality -> Num_RealDomain; -GRing_IntegralDomain -> Num_RealDomain; -Order_JoinSemilattice -> Num_RealDomain; -Order_Lattice -> Num_RealDomain; -Order_MeetSemilattice -> Num_RealDomain; -GRing_Nmodule -> Num_RealDomain; -Num_NormedZmodule -> Num_RealDomain; -Num_NumDomain -> Num_RealDomain; -GRing_NzRing -> Num_RealDomain; -GRing_NzSemiRing -> Num_RealDomain; -Order_POrder -> Num_RealDomain; -Num_POrderedZmodule -> Num_RealDomain; -GRing_PzRing -> Num_RealDomain; -GRing_PzSemiRing -> Num_RealDomain; -Num_SemiNormedZmodule -> Num_RealDomain; -Order_Total -> Num_RealDomain; -GRing_UnitRing -> Num_RealDomain; -GRing_Zmodule -> Num_RealDomain; -choice_Choice -> Num_RealField; -GRing_ComNzRing -> Num_RealField; -GRing_ComNzSemiRing -> Num_RealField; -GRing_ComPzRing -> Num_RealField; -GRing_ComPzSemiRing -> Num_RealField; -GRing_ComUnitRing -> Num_RealField; -Order_DistrLattice -> Num_RealField; -eqtype_Equality -> Num_RealField; -GRing_Field -> Num_RealField; -GRing_IntegralDomain -> Num_RealField; -Order_JoinSemilattice -> Num_RealField; -Order_Lattice -> Num_RealField; -Order_MeetSemilattice -> Num_RealField; -GRing_Nmodule -> Num_RealField; -Num_NormedZmodule -> Num_RealField; -Num_NumDomain -> Num_RealField; -Num_NumField -> Num_RealField; -GRing_NzRing -> Num_RealField; -GRing_NzSemiRing -> Num_RealField; -Order_POrder -> Num_RealField; -Num_POrderedZmodule -> Num_RealField; -GRing_PzRing -> Num_RealField; -GRing_PzSemiRing -> Num_RealField; -Num_RealDomain -> Num_RealField; -Num_SemiNormedZmodule -> Num_RealField; -Order_Total -> Num_RealField; -GRing_UnitRing -> Num_RealField; -GRing_Zmodule -> Num_RealField; -choice_Choice -> RingOfSets; -eqtype_Equality -> RingOfSets; -Pointed -> RingOfSets; -SemiRingOfSets -> RingOfSets; -Content -> SFiniteMeasure; -Measure -> SFiniteMeasure; -GRing_DivClosed -> GRing_SdivClosed; -GRing_Mul2Closed -> GRing_SdivClosed; -GRing_MulClosed -> GRing_SdivClosed; -GRing_OppClosed -> GRing_SdivClosed; -GRing_SmulClosed -> GRing_SdivClosed; -choice_Choice -> GRing_SemiAlgebra; -eqtype_Equality -> GRing_SemiAlgebra; -GRing_LSemiAlgebra -> GRing_SemiAlgebra; -GRing_LSemiModule -> GRing_SemiAlgebra; -GRing_Nmodule -> GRing_SemiAlgebra; -GRing_NzSemiRing -> GRing_SemiAlgebra; -GRing_PzSemiRing -> GRing_SemiAlgebra; -GRing_Scale_PreLaw -> GRing_Scale_SemiLaw; -choice_Choice -> Num_SemiNormedZmodule; -eqtype_Equality -> Num_SemiNormedZmodule; -GRing_Nmodule -> Num_SemiNormedZmodule; -GRing_Zmodule -> Num_SemiNormedZmodule; -choice_Choice -> SemiRingOfSets; -eqtype_Equality -> SemiRingOfSets; -Pointed -> SemiRingOfSets; -GRing_AddClosed -> GRing_Semiring2Closed; -GRing_Mul2Closed -> GRing_Semiring2Closed; -GRing_AddClosed -> GRing_SemiringClosed; -GRing_Mul2Closed -> GRing_SemiringClosed; -GRing_MulClosed -> GRing_SemiringClosed; -GRing_Semiring2Closed -> GRing_SemiringClosed; -Content -> SigmaFiniteContent; -Content -> SigmaFiniteMeasure; -Measure -> SigmaFiniteMeasure; -SFiniteMeasure -> SigmaFiniteMeasure; -SigmaFiniteContent -> SigmaFiniteMeasure; -choice_Choice -> SigmaRing; -eqtype_Equality -> SigmaRing; -Pointed -> SigmaRing; -RingOfSets -> SigmaRing; -SemiRingOfSets -> SigmaRing; -GRing_Mul2Closed -> GRing_SmulClosed; -GRing_MulClosed -> GRing_SmulClosed; -GRing_OppClosed -> GRing_SmulClosed; -Bij -> SplitBij; -Fun -> SplitBij; -InjFun -> SplitBij; -Inject -> SplitBij; -InvFun -> SplitBij; -Inversible -> SplitBij; -OInvFun -> SplitBij; -OInversible -> SplitBij; -SplitInj -> SplitBij; -SplitInjFun -> SplitBij; -SplitSurj -> SplitBij; -SplitSurjFun -> SplitBij; -SurjFun -> SplitBij; -Surject -> SplitBij; -Inject -> SplitInj; -Inversible -> SplitInj; -OInversible -> SplitInj; -Fun -> SplitInjFun; -InjFun -> SplitInjFun; -Inject -> SplitInjFun; -InvFun -> SplitInjFun; -Inversible -> SplitInjFun; -OInvFun -> SplitInjFun; -OInversible -> SplitInjFun; -SplitInj -> SplitInjFun; -Inversible -> SplitSurj; -OInversible -> SplitSurj; -Surject -> SplitSurj; -Fun -> SplitSurjFun; -InvFun -> SplitSurjFun; -Inversible -> SplitSurjFun; -OInvFun -> SplitSurjFun; -OInversible -> SplitSurjFun; -SplitSurj -> SplitSurjFun; -SurjFun -> SplitSurjFun; -Surject -> SplitSurjFun; -GRing_Algebra -> GRing_SubAlgebra; -choice_Choice -> GRing_SubAlgebra; -eqtype_Equality -> GRing_SubAlgebra; -GRing_LSemiAlgebra -> GRing_SubAlgebra; -GRing_LSemiModule -> GRing_SubAlgebra; -GRing_Lalgebra -> GRing_SubAlgebra; -GRing_Lmodule -> GRing_SubAlgebra; -GRing_Nmodule -> GRing_SubAlgebra; -GRing_NzRing -> GRing_SubAlgebra; -GRing_NzSemiRing -> GRing_SubAlgebra; -GRing_PzRing -> GRing_SubAlgebra; -GRing_PzSemiRing -> GRing_SubAlgebra; -GRing_SemiAlgebra -> GRing_SubAlgebra; -SubChoice -> GRing_SubAlgebra; -SubEquality -> GRing_SubAlgebra; -GRing_SubLSemiAlgebra -> GRing_SubAlgebra; -GRing_SubLSemiModule -> GRing_SubAlgebra; -GRing_SubLalgebra -> GRing_SubAlgebra; -GRing_SubLmodule -> GRing_SubAlgebra; -GRing_SubNmodule -> GRing_SubAlgebra; -GRing_SubNzRing -> GRing_SubAlgebra; -GRing_SubNzSemiRing -> GRing_SubAlgebra; -GRing_SubPzRing -> GRing_SubAlgebra; -GRing_SubPzSemiRing -> GRing_SubAlgebra; -GRing_SubSemiAlgebra -> GRing_SubAlgebra; -SubType -> GRing_SubAlgebra; -GRing_SubZmodule -> GRing_SubAlgebra; -GRing_Zmodule -> GRing_SubAlgebra; -Order_BJoinSemilattice -> Order_SubBLattice; -Order_BLattice -> Order_SubBLattice; -Order_BMeetSemilattice -> Order_SubBLattice; -Order_BPOrder -> Order_SubBLattice; -choice_Choice -> Order_SubBLattice; -eqtype_Equality -> Order_SubBLattice; -Order_JoinSemilattice -> Order_SubBLattice; -Order_JoinSubBLattice -> Order_SubBLattice; -Order_JoinSubLattice -> Order_SubBLattice; -Order_Lattice -> Order_SubBLattice; -Order_MeetSemilattice -> Order_SubBLattice; -Order_MeetSubBLattice -> Order_SubBLattice; -Order_MeetSubLattice -> Order_SubBLattice; -Order_POrder -> Order_SubBLattice; -SubChoice -> Order_SubBLattice; -SubEquality -> Order_SubBLattice; -Order_SubLattice -> Order_SubBLattice; -Order_SubPOrder -> Order_SubBLattice; -Order_SubPOrderBLattice -> Order_SubBLattice; -Order_SubPOrderLattice -> Order_SubBLattice; -SubType -> Order_SubBLattice; -choice_Choice -> SubChoice; -eqtype_Equality -> SubChoice; -SubEquality -> SubChoice; -SubType -> SubChoice; -choice_Choice -> GRing_SubComNzRing; -GRing_ComNzRing -> GRing_SubComNzRing; -GRing_ComNzSemiRing -> GRing_SubComNzRing; -GRing_ComPzRing -> GRing_SubComNzRing; -GRing_ComPzSemiRing -> GRing_SubComNzRing; -eqtype_Equality -> GRing_SubComNzRing; -GRing_Nmodule -> GRing_SubComNzRing; -GRing_NzRing -> GRing_SubComNzRing; -GRing_NzSemiRing -> GRing_SubComNzRing; -GRing_PzRing -> GRing_SubComNzRing; -GRing_PzSemiRing -> GRing_SubComNzRing; -SubChoice -> GRing_SubComNzRing; -GRing_SubComNzSemiRing -> GRing_SubComNzRing; -GRing_SubComPzRing -> GRing_SubComNzRing; -GRing_SubComPzSemiRing -> GRing_SubComNzRing; -SubEquality -> GRing_SubComNzRing; -GRing_SubNmodule -> GRing_SubComNzRing; -GRing_SubNzRing -> GRing_SubComNzRing; -GRing_SubNzSemiRing -> GRing_SubComNzRing; -GRing_SubPzRing -> GRing_SubComNzRing; -GRing_SubPzSemiRing -> GRing_SubComNzRing; -SubType -> GRing_SubComNzRing; -GRing_SubZmodule -> GRing_SubComNzRing; -GRing_Zmodule -> GRing_SubComNzRing; -choice_Choice -> GRing_SubComNzSemiRing; -GRing_ComNzSemiRing -> GRing_SubComNzSemiRing; -GRing_ComPzSemiRing -> GRing_SubComNzSemiRing; -eqtype_Equality -> GRing_SubComNzSemiRing; -GRing_Nmodule -> GRing_SubComNzSemiRing; -GRing_NzSemiRing -> GRing_SubComNzSemiRing; -GRing_PzSemiRing -> GRing_SubComNzSemiRing; -SubChoice -> GRing_SubComNzSemiRing; -GRing_SubComPzSemiRing -> GRing_SubComNzSemiRing; -SubEquality -> GRing_SubComNzSemiRing; -GRing_SubNmodule -> GRing_SubComNzSemiRing; -GRing_SubNzSemiRing -> GRing_SubComNzSemiRing; -GRing_SubPzSemiRing -> GRing_SubComNzSemiRing; -SubType -> GRing_SubComNzSemiRing; -choice_Choice -> GRing_SubComPzRing; -GRing_ComPzRing -> GRing_SubComPzRing; -GRing_ComPzSemiRing -> GRing_SubComPzRing; -eqtype_Equality -> GRing_SubComPzRing; -GRing_Nmodule -> GRing_SubComPzRing; -GRing_PzRing -> GRing_SubComPzRing; -GRing_PzSemiRing -> GRing_SubComPzRing; -SubChoice -> GRing_SubComPzRing; -GRing_SubComPzSemiRing -> GRing_SubComPzRing; -SubEquality -> GRing_SubComPzRing; -GRing_SubNmodule -> GRing_SubComPzRing; -GRing_SubPzRing -> GRing_SubComPzRing; -GRing_SubPzSemiRing -> GRing_SubComPzRing; -SubType -> GRing_SubComPzRing; -GRing_SubZmodule -> GRing_SubComPzRing; -GRing_Zmodule -> GRing_SubComPzRing; -choice_Choice -> GRing_SubComPzSemiRing; -GRing_ComPzSemiRing -> GRing_SubComPzSemiRing; -eqtype_Equality -> GRing_SubComPzSemiRing; -GRing_Nmodule -> GRing_SubComPzSemiRing; -GRing_PzSemiRing -> GRing_SubComPzSemiRing; -SubChoice -> GRing_SubComPzSemiRing; -SubEquality -> GRing_SubComPzSemiRing; -GRing_SubNmodule -> GRing_SubComPzSemiRing; -GRing_SubPzSemiRing -> GRing_SubComPzSemiRing; -SubType -> GRing_SubComPzSemiRing; -choice_Choice -> GRing_SubComUnitRing; -GRing_ComNzRing -> GRing_SubComUnitRing; -GRing_ComNzSemiRing -> GRing_SubComUnitRing; -GRing_ComPzRing -> GRing_SubComUnitRing; -GRing_ComPzSemiRing -> GRing_SubComUnitRing; -GRing_ComUnitRing -> GRing_SubComUnitRing; -eqtype_Equality -> GRing_SubComUnitRing; -GRing_Nmodule -> GRing_SubComUnitRing; -GRing_NzRing -> GRing_SubComUnitRing; -GRing_NzSemiRing -> GRing_SubComUnitRing; -GRing_PzRing -> GRing_SubComUnitRing; -GRing_PzSemiRing -> GRing_SubComUnitRing; -SubChoice -> GRing_SubComUnitRing; -GRing_SubComNzRing -> GRing_SubComUnitRing; -GRing_SubComNzSemiRing -> GRing_SubComUnitRing; -GRing_SubComPzRing -> GRing_SubComUnitRing; -GRing_SubComPzSemiRing -> GRing_SubComUnitRing; -SubEquality -> GRing_SubComUnitRing; -GRing_SubNmodule -> GRing_SubComUnitRing; -GRing_SubNzRing -> GRing_SubComUnitRing; -GRing_SubNzSemiRing -> GRing_SubComUnitRing; -GRing_SubPzRing -> GRing_SubComUnitRing; -GRing_SubPzSemiRing -> GRing_SubComUnitRing; -SubType -> GRing_SubComUnitRing; -GRing_SubUnitRing -> GRing_SubComUnitRing; -GRing_SubZmodule -> GRing_SubComUnitRing; -GRing_UnitRing -> GRing_SubComUnitRing; -GRing_Zmodule -> GRing_SubComUnitRing; -choice_Choice -> SubCountable; -Countable -> SubCountable; -eqtype_Equality -> SubCountable; -SubChoice -> SubCountable; -SubEquality -> SubCountable; -SubType -> SubCountable; -eqtype_Equality -> SubEquality; -SubType -> SubEquality; -choice_Choice -> GRing_SubField; -GRing_ComNzRing -> GRing_SubField; -GRing_ComNzSemiRing -> GRing_SubField; -GRing_ComPzRing -> GRing_SubField; -GRing_ComPzSemiRing -> GRing_SubField; -GRing_ComUnitRing -> GRing_SubField; -eqtype_Equality -> GRing_SubField; -GRing_Field -> GRing_SubField; -GRing_IntegralDomain -> GRing_SubField; -GRing_Nmodule -> GRing_SubField; -GRing_NzRing -> GRing_SubField; -GRing_NzSemiRing -> GRing_SubField; -GRing_PzRing -> GRing_SubField; -GRing_PzSemiRing -> GRing_SubField; -SubChoice -> GRing_SubField; -GRing_SubComNzRing -> GRing_SubField; -GRing_SubComNzSemiRing -> GRing_SubField; -GRing_SubComPzRing -> GRing_SubField; -GRing_SubComPzSemiRing -> GRing_SubField; -GRing_SubComUnitRing -> GRing_SubField; -SubEquality -> GRing_SubField; -GRing_SubIntegralDomain -> GRing_SubField; -GRing_SubNmodule -> GRing_SubField; -GRing_SubNzRing -> GRing_SubField; -GRing_SubNzSemiRing -> GRing_SubField; -GRing_SubPzRing -> GRing_SubField; -GRing_SubPzSemiRing -> GRing_SubField; -SubType -> GRing_SubField; -GRing_SubUnitRing -> GRing_SubField; -GRing_SubZmodule -> GRing_SubField; -GRing_UnitRing -> GRing_SubField; -GRing_Zmodule -> GRing_SubField; -choice_Choice -> SubFinite; -Countable -> SubFinite; -eqtype_Equality -> SubFinite; -fintype_Finite -> SubFinite; -SubChoice -> SubFinite; -SubCountable -> SubFinite; -SubEquality -> SubFinite; -SubType -> SubFinite; -choice_Choice -> GRing_SubIntegralDomain; -GRing_ComNzRing -> GRing_SubIntegralDomain; -GRing_ComNzSemiRing -> GRing_SubIntegralDomain; -GRing_ComPzRing -> GRing_SubIntegralDomain; -GRing_ComPzSemiRing -> GRing_SubIntegralDomain; -GRing_ComUnitRing -> GRing_SubIntegralDomain; -eqtype_Equality -> GRing_SubIntegralDomain; -GRing_IntegralDomain -> GRing_SubIntegralDomain; -GRing_Nmodule -> GRing_SubIntegralDomain; -GRing_NzRing -> GRing_SubIntegralDomain; -GRing_NzSemiRing -> GRing_SubIntegralDomain; -GRing_PzRing -> GRing_SubIntegralDomain; -GRing_PzSemiRing -> GRing_SubIntegralDomain; -SubChoice -> GRing_SubIntegralDomain; -GRing_SubComNzRing -> GRing_SubIntegralDomain; -GRing_SubComNzSemiRing -> GRing_SubIntegralDomain; -GRing_SubComPzRing -> GRing_SubIntegralDomain; -GRing_SubComPzSemiRing -> GRing_SubIntegralDomain; -GRing_SubComUnitRing -> GRing_SubIntegralDomain; -SubEquality -> GRing_SubIntegralDomain; -GRing_SubNmodule -> GRing_SubIntegralDomain; -GRing_SubNzRing -> GRing_SubIntegralDomain; -GRing_SubNzSemiRing -> GRing_SubIntegralDomain; -GRing_SubPzRing -> GRing_SubIntegralDomain; -GRing_SubPzSemiRing -> GRing_SubIntegralDomain; -SubType -> GRing_SubIntegralDomain; -GRing_SubUnitRing -> GRing_SubIntegralDomain; -GRing_SubZmodule -> GRing_SubIntegralDomain; -GRing_UnitRing -> GRing_SubIntegralDomain; -GRing_Zmodule -> GRing_SubIntegralDomain; -choice_Choice -> GRing_SubLSemiAlgebra; -eqtype_Equality -> GRing_SubLSemiAlgebra; -GRing_LSemiAlgebra -> GRing_SubLSemiAlgebra; -GRing_LSemiModule -> GRing_SubLSemiAlgebra; -GRing_Nmodule -> GRing_SubLSemiAlgebra; -GRing_NzSemiRing -> GRing_SubLSemiAlgebra; -GRing_PzSemiRing -> GRing_SubLSemiAlgebra; -SubChoice -> GRing_SubLSemiAlgebra; -SubEquality -> GRing_SubLSemiAlgebra; -GRing_SubLSemiModule -> GRing_SubLSemiAlgebra; -GRing_SubNmodule -> GRing_SubLSemiAlgebra; -GRing_SubNzSemiRing -> GRing_SubLSemiAlgebra; -GRing_SubPzSemiRing -> GRing_SubLSemiAlgebra; -SubType -> GRing_SubLSemiAlgebra; -choice_Choice -> GRing_SubLSemiModule; -eqtype_Equality -> GRing_SubLSemiModule; -GRing_LSemiModule -> GRing_SubLSemiModule; -GRing_Nmodule -> GRing_SubLSemiModule; -SubChoice -> GRing_SubLSemiModule; -SubEquality -> GRing_SubLSemiModule; -GRing_SubNmodule -> GRing_SubLSemiModule; -SubType -> GRing_SubLSemiModule; -choice_Choice -> GRing_SubLalgebra; -eqtype_Equality -> GRing_SubLalgebra; -GRing_LSemiAlgebra -> GRing_SubLalgebra; -GRing_LSemiModule -> GRing_SubLalgebra; -GRing_Lalgebra -> GRing_SubLalgebra; -GRing_Lmodule -> GRing_SubLalgebra; -GRing_Nmodule -> GRing_SubLalgebra; -GRing_NzRing -> GRing_SubLalgebra; -GRing_NzSemiRing -> GRing_SubLalgebra; -GRing_PzRing -> GRing_SubLalgebra; -GRing_PzSemiRing -> GRing_SubLalgebra; -SubChoice -> GRing_SubLalgebra; -SubEquality -> GRing_SubLalgebra; -GRing_SubLSemiAlgebra -> GRing_SubLalgebra; -GRing_SubLSemiModule -> GRing_SubLalgebra; -GRing_SubLmodule -> GRing_SubLalgebra; -GRing_SubNmodule -> GRing_SubLalgebra; -GRing_SubNzRing -> GRing_SubLalgebra; -GRing_SubNzSemiRing -> GRing_SubLalgebra; -GRing_SubPzRing -> GRing_SubLalgebra; -GRing_SubPzSemiRing -> GRing_SubLalgebra; -SubType -> GRing_SubLalgebra; -GRing_SubZmodule -> GRing_SubLalgebra; -GRing_Zmodule -> GRing_SubLalgebra; -choice_Choice -> Order_SubLattice; -eqtype_Equality -> Order_SubLattice; -Order_JoinSemilattice -> Order_SubLattice; -Order_JoinSubLattice -> Order_SubLattice; -Order_Lattice -> Order_SubLattice; -Order_MeetSemilattice -> Order_SubLattice; -Order_MeetSubLattice -> Order_SubLattice; -Order_POrder -> Order_SubLattice; -SubChoice -> Order_SubLattice; -SubEquality -> Order_SubLattice; -Order_SubPOrder -> Order_SubLattice; -Order_SubPOrderLattice -> Order_SubLattice; -SubType -> Order_SubLattice; -choice_Choice -> GRing_SubLmodule; -eqtype_Equality -> GRing_SubLmodule; -GRing_LSemiModule -> GRing_SubLmodule; -GRing_Lmodule -> GRing_SubLmodule; -GRing_Nmodule -> GRing_SubLmodule; -SubChoice -> GRing_SubLmodule; -SubEquality -> GRing_SubLmodule; -GRing_SubLSemiModule -> GRing_SubLmodule; -GRing_SubNmodule -> GRing_SubLmodule; -SubType -> GRing_SubLmodule; -GRing_SubZmodule -> GRing_SubLmodule; -GRing_Zmodule -> GRing_SubLmodule; -choice_Choice -> GRing_SubNmodule; -eqtype_Equality -> GRing_SubNmodule; -GRing_Nmodule -> GRing_SubNmodule; -SubChoice -> GRing_SubNmodule; -SubEquality -> GRing_SubNmodule; -SubType -> GRing_SubNmodule; -choice_Choice -> GRing_SubNzRing; -eqtype_Equality -> GRing_SubNzRing; -GRing_Nmodule -> GRing_SubNzRing; -GRing_NzRing -> GRing_SubNzRing; -GRing_NzSemiRing -> GRing_SubNzRing; -GRing_PzRing -> GRing_SubNzRing; -GRing_PzSemiRing -> GRing_SubNzRing; -SubChoice -> GRing_SubNzRing; -SubEquality -> GRing_SubNzRing; -GRing_SubNmodule -> GRing_SubNzRing; -GRing_SubNzSemiRing -> GRing_SubNzRing; -GRing_SubPzRing -> GRing_SubNzRing; -GRing_SubPzSemiRing -> GRing_SubNzRing; -SubType -> GRing_SubNzRing; -GRing_SubZmodule -> GRing_SubNzRing; -GRing_Zmodule -> GRing_SubNzRing; -choice_Choice -> GRing_SubNzSemiRing; -eqtype_Equality -> GRing_SubNzSemiRing; -GRing_Nmodule -> GRing_SubNzSemiRing; -GRing_NzSemiRing -> GRing_SubNzSemiRing; -GRing_PzSemiRing -> GRing_SubNzSemiRing; -SubChoice -> GRing_SubNzSemiRing; -SubEquality -> GRing_SubNzSemiRing; -GRing_SubNmodule -> GRing_SubNzSemiRing; -GRing_SubPzSemiRing -> GRing_SubNzSemiRing; -SubType -> GRing_SubNzSemiRing; -choice_Choice -> Order_SubOrder; -Order_DistrLattice -> Order_SubOrder; -eqtype_Equality -> Order_SubOrder; -Order_JoinSemilattice -> Order_SubOrder; -Order_JoinSubLattice -> Order_SubOrder; -Order_Lattice -> Order_SubOrder; -Order_MeetSemilattice -> Order_SubOrder; -Order_MeetSubLattice -> Order_SubOrder; -Order_POrder -> Order_SubOrder; -SubChoice -> Order_SubOrder; -SubEquality -> Order_SubOrder; -Order_SubLattice -> Order_SubOrder; -Order_SubPOrder -> Order_SubOrder; -Order_SubPOrderLattice -> Order_SubOrder; -SubType -> Order_SubOrder; -Order_Total -> Order_SubOrder; -choice_Choice -> Order_SubPOrder; -eqtype_Equality -> Order_SubPOrder; -Order_POrder -> Order_SubPOrder; -SubChoice -> Order_SubPOrder; -SubEquality -> Order_SubPOrder; -SubType -> Order_SubPOrder; -Order_BJoinSemilattice -> Order_SubPOrderBLattice; -Order_BLattice -> Order_SubPOrderBLattice; -Order_BMeetSemilattice -> Order_SubPOrderBLattice; -Order_BPOrder -> Order_SubPOrderBLattice; -choice_Choice -> Order_SubPOrderBLattice; -eqtype_Equality -> Order_SubPOrderBLattice; -Order_JoinSemilattice -> Order_SubPOrderBLattice; -Order_Lattice -> Order_SubPOrderBLattice; -Order_MeetSemilattice -> Order_SubPOrderBLattice; -Order_POrder -> Order_SubPOrderBLattice; -SubChoice -> Order_SubPOrderBLattice; -SubEquality -> Order_SubPOrderBLattice; -Order_SubPOrder -> Order_SubPOrderBLattice; -Order_SubPOrderLattice -> Order_SubPOrderBLattice; -SubType -> Order_SubPOrderBLattice; -choice_Choice -> Order_SubPOrderLattice; -eqtype_Equality -> Order_SubPOrderLattice; -Order_JoinSemilattice -> Order_SubPOrderLattice; -Order_Lattice -> Order_SubPOrderLattice; -Order_MeetSemilattice -> Order_SubPOrderLattice; -Order_POrder -> Order_SubPOrderLattice; -SubChoice -> Order_SubPOrderLattice; -SubEquality -> Order_SubPOrderLattice; -Order_SubPOrder -> Order_SubPOrderLattice; -SubType -> Order_SubPOrderLattice; -Order_BJoinSemilattice -> Order_SubPOrderTBLattice; -Order_BLattice -> Order_SubPOrderTBLattice; -Order_BMeetSemilattice -> Order_SubPOrderTBLattice; -Order_BPOrder -> Order_SubPOrderTBLattice; -choice_Choice -> Order_SubPOrderTBLattice; -eqtype_Equality -> Order_SubPOrderTBLattice; -Order_JoinSemilattice -> Order_SubPOrderTBLattice; -Order_Lattice -> Order_SubPOrderTBLattice; -Order_MeetSemilattice -> Order_SubPOrderTBLattice; -Order_POrder -> Order_SubPOrderTBLattice; -SubChoice -> Order_SubPOrderTBLattice; -SubEquality -> Order_SubPOrderTBLattice; -Order_SubPOrder -> Order_SubPOrderTBLattice; -Order_SubPOrderBLattice -> Order_SubPOrderTBLattice; -Order_SubPOrderLattice -> Order_SubPOrderTBLattice; -Order_SubPOrderTLattice -> Order_SubPOrderTBLattice; -SubType -> Order_SubPOrderTBLattice; -Order_TBJoinSemilattice -> Order_SubPOrderTBLattice; -Order_TBLattice -> Order_SubPOrderTBLattice; -Order_TBMeetSemilattice -> Order_SubPOrderTBLattice; -Order_TBPOrder -> Order_SubPOrderTBLattice; -Order_TJoinSemilattice -> Order_SubPOrderTBLattice; -Order_TLattice -> Order_SubPOrderTBLattice; -Order_TMeetSemilattice -> Order_SubPOrderTBLattice; -Order_TPOrder -> Order_SubPOrderTBLattice; -choice_Choice -> Order_SubPOrderTLattice; -eqtype_Equality -> Order_SubPOrderTLattice; -Order_JoinSemilattice -> Order_SubPOrderTLattice; -Order_Lattice -> Order_SubPOrderTLattice; -Order_MeetSemilattice -> Order_SubPOrderTLattice; -Order_POrder -> Order_SubPOrderTLattice; -SubChoice -> Order_SubPOrderTLattice; -SubEquality -> Order_SubPOrderTLattice; -Order_SubPOrder -> Order_SubPOrderTLattice; -Order_SubPOrderLattice -> Order_SubPOrderTLattice; -SubType -> Order_SubPOrderTLattice; -Order_TJoinSemilattice -> Order_SubPOrderTLattice; -Order_TLattice -> Order_SubPOrderTLattice; -Order_TMeetSemilattice -> Order_SubPOrderTLattice; -Order_TPOrder -> Order_SubPOrderTLattice; -Content -> SubProbability; -FinNumFun -> SubProbability; -FiniteMeasure -> SubProbability; -Measure -> SubProbability; -SFiniteMeasure -> SubProbability; -SigmaFiniteContent -> SubProbability; -SigmaFiniteMeasure -> SubProbability; -choice_Choice -> GRing_SubPzRing; -eqtype_Equality -> GRing_SubPzRing; -GRing_Nmodule -> GRing_SubPzRing; -GRing_PzRing -> GRing_SubPzRing; -GRing_PzSemiRing -> GRing_SubPzRing; -SubChoice -> GRing_SubPzRing; -SubEquality -> GRing_SubPzRing; -GRing_SubNmodule -> GRing_SubPzRing; -GRing_SubPzSemiRing -> GRing_SubPzRing; -SubType -> GRing_SubPzRing; -GRing_SubZmodule -> GRing_SubPzRing; -GRing_Zmodule -> GRing_SubPzRing; -choice_Choice -> GRing_SubPzSemiRing; -eqtype_Equality -> GRing_SubPzSemiRing; -GRing_Nmodule -> GRing_SubPzSemiRing; -GRing_PzSemiRing -> GRing_SubPzSemiRing; -SubChoice -> GRing_SubPzSemiRing; -SubEquality -> GRing_SubPzSemiRing; -GRing_SubNmodule -> GRing_SubPzSemiRing; -SubType -> GRing_SubPzSemiRing; -choice_Choice -> GRing_SubSemiAlgebra; -eqtype_Equality -> GRing_SubSemiAlgebra; -GRing_LSemiAlgebra -> GRing_SubSemiAlgebra; -GRing_LSemiModule -> GRing_SubSemiAlgebra; -GRing_Nmodule -> GRing_SubSemiAlgebra; -GRing_NzSemiRing -> GRing_SubSemiAlgebra; -GRing_PzSemiRing -> GRing_SubSemiAlgebra; -GRing_SemiAlgebra -> GRing_SubSemiAlgebra; -SubChoice -> GRing_SubSemiAlgebra; -SubEquality -> GRing_SubSemiAlgebra; -GRing_SubLSemiAlgebra -> GRing_SubSemiAlgebra; -GRing_SubLSemiModule -> GRing_SubSemiAlgebra; -GRing_SubNmodule -> GRing_SubSemiAlgebra; -GRing_SubNzSemiRing -> GRing_SubSemiAlgebra; -GRing_SubPzSemiRing -> GRing_SubSemiAlgebra; -SubType -> GRing_SubSemiAlgebra; -Order_BJoinSemilattice -> Order_SubTBLattice; -Order_BLattice -> Order_SubTBLattice; -Order_BMeetSemilattice -> Order_SubTBLattice; -Order_BPOrder -> Order_SubTBLattice; -choice_Choice -> Order_SubTBLattice; -eqtype_Equality -> Order_SubTBLattice; -Order_JoinSemilattice -> Order_SubTBLattice; -Order_JoinSubBLattice -> Order_SubTBLattice; -Order_JoinSubLattice -> Order_SubTBLattice; -Order_JoinSubTBLattice -> Order_SubTBLattice; -Order_JoinSubTLattice -> Order_SubTBLattice; -Order_Lattice -> Order_SubTBLattice; -Order_MeetSemilattice -> Order_SubTBLattice; -Order_MeetSubBLattice -> Order_SubTBLattice; -Order_MeetSubLattice -> Order_SubTBLattice; -Order_MeetSubTBLattice -> Order_SubTBLattice; -Order_MeetSubTLattice -> Order_SubTBLattice; -Order_POrder -> Order_SubTBLattice; -Order_SubBLattice -> Order_SubTBLattice; -SubChoice -> Order_SubTBLattice; -SubEquality -> Order_SubTBLattice; -Order_SubLattice -> Order_SubTBLattice; -Order_SubPOrder -> Order_SubTBLattice; -Order_SubPOrderBLattice -> Order_SubTBLattice; -Order_SubPOrderLattice -> Order_SubTBLattice; -Order_SubPOrderTBLattice -> Order_SubTBLattice; -Order_SubPOrderTLattice -> Order_SubTBLattice; -Order_SubTLattice -> Order_SubTBLattice; -SubType -> Order_SubTBLattice; -Order_TBJoinSemilattice -> Order_SubTBLattice; -Order_TBLattice -> Order_SubTBLattice; -Order_TBMeetSemilattice -> Order_SubTBLattice; -Order_TBPOrder -> Order_SubTBLattice; -Order_TJoinSemilattice -> Order_SubTBLattice; -Order_TLattice -> Order_SubTBLattice; -Order_TMeetSemilattice -> Order_SubTBLattice; -Order_TPOrder -> Order_SubTBLattice; -choice_Choice -> Order_SubTLattice; -eqtype_Equality -> Order_SubTLattice; -Order_JoinSemilattice -> Order_SubTLattice; -Order_JoinSubLattice -> Order_SubTLattice; -Order_JoinSubTLattice -> Order_SubTLattice; -Order_Lattice -> Order_SubTLattice; -Order_MeetSemilattice -> Order_SubTLattice; -Order_MeetSubLattice -> Order_SubTLattice; -Order_MeetSubTLattice -> Order_SubTLattice; -Order_POrder -> Order_SubTLattice; -SubChoice -> Order_SubTLattice; -SubEquality -> Order_SubTLattice; -Order_SubLattice -> Order_SubTLattice; -Order_SubPOrder -> Order_SubTLattice; -Order_SubPOrderLattice -> Order_SubTLattice; -Order_SubPOrderTLattice -> Order_SubTLattice; -SubType -> Order_SubTLattice; -Order_TJoinSemilattice -> Order_SubTLattice; -Order_TLattice -> Order_SubTLattice; -Order_TMeetSemilattice -> Order_SubTLattice; -Order_TPOrder -> Order_SubTLattice; -choice_Choice -> GRing_SubUnitRing; -eqtype_Equality -> GRing_SubUnitRing; -GRing_Nmodule -> GRing_SubUnitRing; -GRing_NzRing -> GRing_SubUnitRing; -GRing_NzSemiRing -> GRing_SubUnitRing; -GRing_PzRing -> GRing_SubUnitRing; -GRing_PzSemiRing -> GRing_SubUnitRing; -SubChoice -> GRing_SubUnitRing; -SubEquality -> GRing_SubUnitRing; -GRing_SubNmodule -> GRing_SubUnitRing; -GRing_SubNzRing -> GRing_SubUnitRing; -GRing_SubNzSemiRing -> GRing_SubUnitRing; -GRing_SubPzRing -> GRing_SubUnitRing; -GRing_SubPzSemiRing -> GRing_SubUnitRing; -SubType -> GRing_SubUnitRing; -GRing_SubZmodule -> GRing_SubUnitRing; -GRing_UnitRing -> GRing_SubUnitRing; -GRing_Zmodule -> GRing_SubUnitRing; -choice_Choice -> GRing_SubZmodule; -eqtype_Equality -> GRing_SubZmodule; -GRing_Nmodule -> GRing_SubZmodule; -SubChoice -> GRing_SubZmodule; -SubEquality -> GRing_SubZmodule; -GRing_SubNmodule -> GRing_SubZmodule; -SubType -> GRing_SubZmodule; -GRing_Zmodule -> GRing_SubZmodule; -GRing_AddClosed -> GRing_SubalgClosed; -GRing_Mul2Closed -> GRing_SubalgClosed; -GRing_MulClosed -> GRing_SubalgClosed; -GRing_Semiring2Closed -> GRing_SubalgClosed; -GRing_SemiringClosed -> GRing_SubalgClosed; -GRing_SubmodClosed -> GRing_SubalgClosed; -GRing_AddClosed -> GRing_SubmodClosed; -GRing_AddClosed -> GRing_SubringClosed; -GRing_Mul2Closed -> GRing_SubringClosed; -GRing_MulClosed -> GRing_SubringClosed; -GRing_OppClosed -> GRing_SubringClosed; -GRing_Semiring2Closed -> GRing_SubringClosed; -GRing_SemiringClosed -> GRing_SubringClosed; -GRing_SmulClosed -> GRing_SubringClosed; -GRing_ZmodClosed -> GRing_SubringClosed; -Fun -> SurjFun; -OInvFun -> SurjFun; -OInversible -> SurjFun; -Surject -> SurjFun; -OInversible -> Surject; -Order_BDistrLattice -> Order_TBDistrLattice; -Order_BJoinSemilattice -> Order_TBDistrLattice; -Order_BLattice -> Order_TBDistrLattice; -Order_BMeetSemilattice -> Order_TBDistrLattice; -Order_BPOrder -> Order_TBDistrLattice; -choice_Choice -> Order_TBDistrLattice; -Order_DistrLattice -> Order_TBDistrLattice; -eqtype_Equality -> Order_TBDistrLattice; -Order_JoinSemilattice -> Order_TBDistrLattice; -Order_Lattice -> Order_TBDistrLattice; -Order_MeetSemilattice -> Order_TBDistrLattice; -Order_POrder -> Order_TBDistrLattice; -Order_TBJoinSemilattice -> Order_TBDistrLattice; -Order_TBLattice -> Order_TBDistrLattice; -Order_TBMeetSemilattice -> Order_TBDistrLattice; -Order_TBPOrder -> Order_TBDistrLattice; -Order_TDistrLattice -> Order_TBDistrLattice; -Order_TJoinSemilattice -> Order_TBDistrLattice; -Order_TLattice -> Order_TBDistrLattice; -Order_TMeetSemilattice -> Order_TBDistrLattice; -Order_TPOrder -> Order_TBDistrLattice; -Order_BJoinSemilattice -> Order_TBJoinSemilattice; -Order_BPOrder -> Order_TBJoinSemilattice; -choice_Choice -> Order_TBJoinSemilattice; -eqtype_Equality -> Order_TBJoinSemilattice; -Order_JoinSemilattice -> Order_TBJoinSemilattice; -Order_POrder -> Order_TBJoinSemilattice; -Order_TBPOrder -> Order_TBJoinSemilattice; -Order_TJoinSemilattice -> Order_TBJoinSemilattice; -Order_TPOrder -> Order_TBJoinSemilattice; -Order_BJoinSemilattice -> Order_TBLattice; -Order_BLattice -> Order_TBLattice; -Order_BMeetSemilattice -> Order_TBLattice; -Order_BPOrder -> Order_TBLattice; -choice_Choice -> Order_TBLattice; -eqtype_Equality -> Order_TBLattice; -Order_JoinSemilattice -> Order_TBLattice; -Order_Lattice -> Order_TBLattice; -Order_MeetSemilattice -> Order_TBLattice; -Order_POrder -> Order_TBLattice; -Order_TBJoinSemilattice -> Order_TBLattice; -Order_TBMeetSemilattice -> Order_TBLattice; -Order_TBPOrder -> Order_TBLattice; -Order_TJoinSemilattice -> Order_TBLattice; -Order_TLattice -> Order_TBLattice; -Order_TMeetSemilattice -> Order_TBLattice; -Order_TPOrder -> Order_TBLattice; -Order_BLatticeClosed -> Order_TBLatticeClosed; -Order_TLatticeClosed -> Order_TBLatticeClosed; -Order_BLatticeMorphism -> Order_TBLatticeMorphism; -Order_TLatticeMorphism -> Order_TBLatticeMorphism; -Order_BMeetSemilattice -> Order_TBMeetSemilattice; -Order_BPOrder -> Order_TBMeetSemilattice; -choice_Choice -> Order_TBMeetSemilattice; -eqtype_Equality -> Order_TBMeetSemilattice; -Order_MeetSemilattice -> Order_TBMeetSemilattice; -Order_POrder -> Order_TBMeetSemilattice; -Order_TBPOrder -> Order_TBMeetSemilattice; -Order_TMeetSemilattice -> Order_TBMeetSemilattice; -Order_TPOrder -> Order_TBMeetSemilattice; -Order_BPOrder -> Order_TBPOrder; -choice_Choice -> Order_TBPOrder; -eqtype_Equality -> Order_TBPOrder; -Order_POrder -> Order_TBPOrder; -Order_TPOrder -> Order_TBPOrder; -Order_BJoinSemilattice -> Order_TBSubLattice; -Order_BJoinSubLattice -> Order_TBSubLattice; -Order_BJoinSubTLattice -> Order_TBSubLattice; -Order_BLattice -> Order_TBSubLattice; -Order_BMeetSemilattice -> Order_TBSubLattice; -Order_BPOrder -> Order_TBSubLattice; -Order_BSubLattice -> Order_TBSubLattice; -Order_BSubTLattice -> Order_TBSubLattice; -choice_Choice -> Order_TBSubLattice; -eqtype_Equality -> Order_TBSubLattice; -Order_JoinSemilattice -> Order_TBSubLattice; -Order_JoinSubBLattice -> Order_TBSubLattice; -Order_JoinSubLattice -> Order_TBSubLattice; -Order_JoinSubTBLattice -> Order_TBSubLattice; -Order_JoinSubTLattice -> Order_TBSubLattice; -Order_Lattice -> Order_TBSubLattice; -Order_MeetSemilattice -> Order_TBSubLattice; -Order_MeetSubBLattice -> Order_TBSubLattice; -Order_MeetSubLattice -> Order_TBSubLattice; -Order_MeetSubTBLattice -> Order_TBSubLattice; -Order_MeetSubTLattice -> Order_TBSubLattice; -Order_POrder -> Order_TBSubLattice; -Order_SubBLattice -> Order_TBSubLattice; -SubChoice -> Order_TBSubLattice; -SubEquality -> Order_TBSubLattice; -Order_SubLattice -> Order_TBSubLattice; -Order_SubPOrder -> Order_TBSubLattice; -Order_SubPOrderBLattice -> Order_TBSubLattice; -Order_SubPOrderLattice -> Order_TBSubLattice; -Order_SubPOrderTBLattice -> Order_TBSubLattice; -Order_SubPOrderTLattice -> Order_TBSubLattice; -Order_SubTBLattice -> Order_TBSubLattice; -Order_SubTLattice -> Order_TBSubLattice; -SubType -> Order_TBSubLattice; -Order_TBJoinSemilattice -> Order_TBSubLattice; -Order_TBLattice -> Order_TBSubLattice; -Order_TBMeetSemilattice -> Order_TBSubLattice; -Order_TBPOrder -> Order_TBSubLattice; -Order_TJoinSemilattice -> Order_TBSubLattice; -Order_TLattice -> Order_TBSubLattice; -Order_TMeetSemilattice -> Order_TBSubLattice; -Order_TMeetSubBLattice -> Order_TBSubLattice; -Order_TMeetSubLattice -> Order_TBSubLattice; -Order_TPOrder -> Order_TBSubLattice; -Order_TSubBLattice -> Order_TBSubLattice; -Order_TSubLattice -> Order_TBSubLattice; -Order_BDistrLattice -> Order_TBTotal; -Order_BJoinSemilattice -> Order_TBTotal; -Order_BLattice -> Order_TBTotal; -Order_BMeetSemilattice -> Order_TBTotal; -Order_BPOrder -> Order_TBTotal; -Order_BTotal -> Order_TBTotal; -choice_Choice -> Order_TBTotal; -Order_DistrLattice -> Order_TBTotal; -eqtype_Equality -> Order_TBTotal; -Order_JoinSemilattice -> Order_TBTotal; -Order_Lattice -> Order_TBTotal; -Order_MeetSemilattice -> Order_TBTotal; -Order_POrder -> Order_TBTotal; -Order_TBDistrLattice -> Order_TBTotal; -Order_TBJoinSemilattice -> Order_TBTotal; -Order_TBLattice -> Order_TBTotal; -Order_TBMeetSemilattice -> Order_TBTotal; -Order_TBPOrder -> Order_TBTotal; -Order_TDistrLattice -> Order_TBTotal; -Order_TJoinSemilattice -> Order_TBTotal; -Order_TLattice -> Order_TBTotal; -Order_TMeetSemilattice -> Order_TBTotal; -Order_TPOrder -> Order_TBTotal; -Order_TTotal -> Order_TBTotal; -Order_Total -> Order_TBTotal; -choice_Choice -> Order_TDistrLattice; -Order_DistrLattice -> Order_TDistrLattice; -eqtype_Equality -> Order_TDistrLattice; -Order_JoinSemilattice -> Order_TDistrLattice; -Order_Lattice -> Order_TDistrLattice; -Order_MeetSemilattice -> Order_TDistrLattice; -Order_POrder -> Order_TDistrLattice; -Order_TJoinSemilattice -> Order_TDistrLattice; -Order_TLattice -> Order_TDistrLattice; -Order_TMeetSemilattice -> Order_TDistrLattice; -Order_TPOrder -> Order_TDistrLattice; -choice_Choice -> Order_TJoinSemilattice; -eqtype_Equality -> Order_TJoinSemilattice; -Order_JoinSemilattice -> Order_TJoinSemilattice; -Order_POrder -> Order_TJoinSemilattice; -Order_TPOrder -> Order_TJoinSemilattice; -choice_Choice -> Order_TLattice; -eqtype_Equality -> Order_TLattice; -Order_JoinSemilattice -> Order_TLattice; -Order_Lattice -> Order_TLattice; -Order_MeetSemilattice -> Order_TLattice; -Order_POrder -> Order_TLattice; -Order_TJoinSemilattice -> Order_TLattice; -Order_TMeetSemilattice -> Order_TLattice; -Order_TPOrder -> Order_TLattice; -Order_MeetLatticeClosed -> Order_TMeetLatticeClosed; -Order_TLatticeClosed -> Order_TMeetLatticeClosed; -choice_Choice -> Order_TMeetSemilattice; -eqtype_Equality -> Order_TMeetSemilattice; -Order_MeetSemilattice -> Order_TMeetSemilattice; -Order_POrder -> Order_TMeetSemilattice; -Order_TPOrder -> Order_TMeetSemilattice; -Order_BJoinSemilattice -> Order_TMeetSubBLattice; -Order_BLattice -> Order_TMeetSubBLattice; -Order_BMeetSemilattice -> Order_TMeetSubBLattice; -Order_BPOrder -> Order_TMeetSubBLattice; -choice_Choice -> Order_TMeetSubBLattice; -eqtype_Equality -> Order_TMeetSubBLattice; -Order_JoinSemilattice -> Order_TMeetSubBLattice; -Order_Lattice -> Order_TMeetSubBLattice; -Order_MeetSemilattice -> Order_TMeetSubBLattice; -Order_MeetSubBLattice -> Order_TMeetSubBLattice; -Order_MeetSubLattice -> Order_TMeetSubBLattice; -Order_MeetSubTBLattice -> Order_TMeetSubBLattice; -Order_MeetSubTLattice -> Order_TMeetSubBLattice; -Order_POrder -> Order_TMeetSubBLattice; -SubChoice -> Order_TMeetSubBLattice; -SubEquality -> Order_TMeetSubBLattice; -Order_SubPOrder -> Order_TMeetSubBLattice; -Order_SubPOrderBLattice -> Order_TMeetSubBLattice; -Order_SubPOrderLattice -> Order_TMeetSubBLattice; -Order_SubPOrderTBLattice -> Order_TMeetSubBLattice; -Order_SubPOrderTLattice -> Order_TMeetSubBLattice; -SubType -> Order_TMeetSubBLattice; -Order_TBJoinSemilattice -> Order_TMeetSubBLattice; -Order_TBLattice -> Order_TMeetSubBLattice; -Order_TBMeetSemilattice -> Order_TMeetSubBLattice; -Order_TBPOrder -> Order_TMeetSubBLattice; -Order_TJoinSemilattice -> Order_TMeetSubBLattice; -Order_TLattice -> Order_TMeetSubBLattice; -Order_TMeetSemilattice -> Order_TMeetSubBLattice; -Order_TMeetSubLattice -> Order_TMeetSubBLattice; -Order_TPOrder -> Order_TMeetSubBLattice; -choice_Choice -> Order_TMeetSubLattice; -eqtype_Equality -> Order_TMeetSubLattice; -Order_JoinSemilattice -> Order_TMeetSubLattice; -Order_Lattice -> Order_TMeetSubLattice; -Order_MeetSemilattice -> Order_TMeetSubLattice; -Order_MeetSubLattice -> Order_TMeetSubLattice; -Order_MeetSubTLattice -> Order_TMeetSubLattice; -Order_POrder -> Order_TMeetSubLattice; -SubChoice -> Order_TMeetSubLattice; -SubEquality -> Order_TMeetSubLattice; -Order_SubPOrder -> Order_TMeetSubLattice; -Order_SubPOrderLattice -> Order_TMeetSubLattice; -Order_SubPOrderTLattice -> Order_TMeetSubLattice; -SubType -> Order_TMeetSubLattice; -Order_TJoinSemilattice -> Order_TMeetSubLattice; -Order_TLattice -> Order_TMeetSubLattice; -Order_TMeetSemilattice -> Order_TMeetSubLattice; -Order_TPOrder -> Order_TMeetSubLattice; -choice_Choice -> Order_TPOrder; -eqtype_Equality -> Order_TPOrder; -Order_POrder -> Order_TPOrder; -Order_BJoinSemilattice -> Order_TSubBLattice; -Order_BLattice -> Order_TSubBLattice; -Order_BMeetSemilattice -> Order_TSubBLattice; -Order_BPOrder -> Order_TSubBLattice; -choice_Choice -> Order_TSubBLattice; -eqtype_Equality -> Order_TSubBLattice; -Order_JoinSemilattice -> Order_TSubBLattice; -Order_JoinSubBLattice -> Order_TSubBLattice; -Order_JoinSubLattice -> Order_TSubBLattice; -Order_JoinSubTBLattice -> Order_TSubBLattice; -Order_JoinSubTLattice -> Order_TSubBLattice; -Order_Lattice -> Order_TSubBLattice; -Order_MeetSemilattice -> Order_TSubBLattice; -Order_MeetSubBLattice -> Order_TSubBLattice; -Order_MeetSubLattice -> Order_TSubBLattice; -Order_MeetSubTBLattice -> Order_TSubBLattice; -Order_MeetSubTLattice -> Order_TSubBLattice; -Order_POrder -> Order_TSubBLattice; -Order_SubBLattice -> Order_TSubBLattice; -SubChoice -> Order_TSubBLattice; -SubEquality -> Order_TSubBLattice; -Order_SubLattice -> Order_TSubBLattice; -Order_SubPOrder -> Order_TSubBLattice; -Order_SubPOrderBLattice -> Order_TSubBLattice; -Order_SubPOrderLattice -> Order_TSubBLattice; -Order_SubPOrderTBLattice -> Order_TSubBLattice; -Order_SubPOrderTLattice -> Order_TSubBLattice; -Order_SubTBLattice -> Order_TSubBLattice; -Order_SubTLattice -> Order_TSubBLattice; -SubType -> Order_TSubBLattice; -Order_TBJoinSemilattice -> Order_TSubBLattice; -Order_TBLattice -> Order_TSubBLattice; -Order_TBMeetSemilattice -> Order_TSubBLattice; -Order_TBPOrder -> Order_TSubBLattice; -Order_TJoinSemilattice -> Order_TSubBLattice; -Order_TLattice -> Order_TSubBLattice; -Order_TMeetSemilattice -> Order_TSubBLattice; -Order_TMeetSubBLattice -> Order_TSubBLattice; -Order_TMeetSubLattice -> Order_TSubBLattice; -Order_TPOrder -> Order_TSubBLattice; -Order_TSubLattice -> Order_TSubBLattice; -choice_Choice -> Order_TSubLattice; -eqtype_Equality -> Order_TSubLattice; -Order_JoinSemilattice -> Order_TSubLattice; -Order_JoinSubLattice -> Order_TSubLattice; -Order_JoinSubTLattice -> Order_TSubLattice; -Order_Lattice -> Order_TSubLattice; -Order_MeetSemilattice -> Order_TSubLattice; -Order_MeetSubLattice -> Order_TSubLattice; -Order_MeetSubTLattice -> Order_TSubLattice; -Order_POrder -> Order_TSubLattice; -SubChoice -> Order_TSubLattice; -SubEquality -> Order_TSubLattice; -Order_SubLattice -> Order_TSubLattice; -Order_SubPOrder -> Order_TSubLattice; -Order_SubPOrderLattice -> Order_TSubLattice; -Order_SubPOrderTLattice -> Order_TSubLattice; -Order_SubTLattice -> Order_TSubLattice; -SubType -> Order_TSubLattice; -Order_TJoinSemilattice -> Order_TSubLattice; -Order_TLattice -> Order_TSubLattice; -Order_TMeetSemilattice -> Order_TSubLattice; -Order_TMeetSubLattice -> Order_TSubLattice; -Order_TPOrder -> Order_TSubLattice; -choice_Choice -> Order_TTotal; -Order_DistrLattice -> Order_TTotal; -eqtype_Equality -> Order_TTotal; -Order_JoinSemilattice -> Order_TTotal; -Order_Lattice -> Order_TTotal; -Order_MeetSemilattice -> Order_TTotal; -Order_POrder -> Order_TTotal; -Order_TDistrLattice -> Order_TTotal; -Order_TJoinSemilattice -> Order_TTotal; -Order_TLattice -> Order_TTotal; -Order_TMeetSemilattice -> Order_TTotal; -Order_TPOrder -> Order_TTotal; -Order_Total -> Order_TTotal; -choice_Choice -> Topological; -eqtype_Equality -> Topological; -Filtered -> Topological; -Nbhs -> Topological; -choice_Choice -> TopologicalLmodule; -eqtype_Equality -> TopologicalLmodule; -Filtered -> TopologicalLmodule; -GRing_LSemiModule -> TopologicalLmodule; -GRing_Lmodule -> TopologicalLmodule; -Nbhs -> TopologicalLmodule; -NbhsLmodule -> TopologicalLmodule; -NbhsNmodule -> TopologicalLmodule; -NbhsZmodule -> TopologicalLmodule; -GRing_Nmodule -> TopologicalLmodule; -PreTopologicalLmodule -> TopologicalLmodule; -PreTopologicalNmodule -> TopologicalLmodule; -PreTopologicalZmodule -> TopologicalLmodule; -Topological -> TopologicalLmodule; -TopologicalNmodule -> TopologicalLmodule; -TopologicalZmodule -> TopologicalLmodule; -GRing_Zmodule -> TopologicalLmodule; -choice_Choice -> TopologicalNmodule; -eqtype_Equality -> TopologicalNmodule; -Filtered -> TopologicalNmodule; -Nbhs -> TopologicalNmodule; -NbhsNmodule -> TopologicalNmodule; -GRing_Nmodule -> TopologicalNmodule; -PreTopologicalNmodule -> TopologicalNmodule; -Topological -> TopologicalNmodule; -choice_Choice -> TopologicalZmodule; -eqtype_Equality -> TopologicalZmodule; -Filtered -> TopologicalZmodule; -Nbhs -> TopologicalZmodule; -NbhsNmodule -> TopologicalZmodule; -NbhsZmodule -> TopologicalZmodule; -GRing_Nmodule -> TopologicalZmodule; -PreTopologicalNmodule -> TopologicalZmodule; -PreTopologicalZmodule -> TopologicalZmodule; -Topological -> TopologicalZmodule; -TopologicalNmodule -> TopologicalZmodule; -GRing_Zmodule -> TopologicalZmodule; -choice_Choice -> Order_Total; -Order_DistrLattice -> Order_Total; -eqtype_Equality -> Order_Total; -Order_JoinSemilattice -> Order_Total; -Order_Lattice -> Order_Total; -Order_MeetSemilattice -> Order_Total; -Order_POrder -> Order_Total; -choice_Choice -> Tvs; -eqtype_Equality -> Tvs; -Filtered -> Tvs; -GRing_LSemiModule -> Tvs; -GRing_Lmodule -> Tvs; -Nbhs -> Tvs; -NbhsLmodule -> Tvs; -NbhsNmodule -> Tvs; -NbhsZmodule -> Tvs; -GRing_Nmodule -> Tvs; -PreTopologicalLmodule -> Tvs; -PreTopologicalNmodule -> Tvs; -PreTopologicalZmodule -> Tvs; -PreUniformLmodule -> Tvs; -PreUniformNmodule -> Tvs; -PreUniformZmodule -> Tvs; -Topological -> Tvs; -TopologicalLmodule -> Tvs; -TopologicalNmodule -> Tvs; -TopologicalZmodule -> Tvs; -Uniform -> Tvs; -GRing_Zmodule -> Tvs; -choice_Choice -> Uniform; -eqtype_Equality -> Uniform; -Filtered -> Uniform; -Nbhs -> Uniform; -Topological -> Uniform; -choice_Choice -> UniformLmodule; -eqtype_Equality -> UniformLmodule; -Filtered -> UniformLmodule; -GRing_LSemiModule -> UniformLmodule; -GRing_Lmodule -> UniformLmodule; -Nbhs -> UniformLmodule; -NbhsLmodule -> UniformLmodule; -NbhsNmodule -> UniformLmodule; -NbhsZmodule -> UniformLmodule; -GRing_Nmodule -> UniformLmodule; -PreTopologicalLmodule -> UniformLmodule; -PreTopologicalNmodule -> UniformLmodule; -PreTopologicalZmodule -> UniformLmodule; -PreUniformLmodule -> UniformLmodule; -PreUniformNmodule -> UniformLmodule; -PreUniformZmodule -> UniformLmodule; -Topological -> UniformLmodule; -Uniform -> UniformLmodule; -UniformNmodule -> UniformLmodule; -UniformZmodule -> UniformLmodule; -GRing_Zmodule -> UniformLmodule; -choice_Choice -> UniformNmodule; -eqtype_Equality -> UniformNmodule; -Filtered -> UniformNmodule; -Nbhs -> UniformNmodule; -NbhsNmodule -> UniformNmodule; -GRing_Nmodule -> UniformNmodule; -PreTopologicalNmodule -> UniformNmodule; -PreUniformNmodule -> UniformNmodule; -Topological -> UniformNmodule; -Uniform -> UniformNmodule; -choice_Choice -> UniformZmodule; -eqtype_Equality -> UniformZmodule; -Filtered -> UniformZmodule; -Nbhs -> UniformZmodule; -NbhsNmodule -> UniformZmodule; -NbhsZmodule -> UniformZmodule; -GRing_Nmodule -> UniformZmodule; -PreTopologicalNmodule -> UniformZmodule; -PreTopologicalZmodule -> UniformZmodule; -PreUniformNmodule -> UniformZmodule; -PreUniformZmodule -> UniformZmodule; -Topological -> UniformZmodule; -Uniform -> UniformZmodule; -UniformNmodule -> UniformZmodule; -GRing_Zmodule -> UniformZmodule; -GRing_Algebra -> GRing_UnitAlgebra; -choice_Choice -> GRing_UnitAlgebra; -eqtype_Equality -> GRing_UnitAlgebra; -GRing_LSemiAlgebra -> GRing_UnitAlgebra; -GRing_LSemiModule -> GRing_UnitAlgebra; -GRing_Lalgebra -> GRing_UnitAlgebra; -GRing_Lmodule -> GRing_UnitAlgebra; -GRing_Nmodule -> GRing_UnitAlgebra; -GRing_NzRing -> GRing_UnitAlgebra; -GRing_NzSemiRing -> GRing_UnitAlgebra; -GRing_PzRing -> GRing_UnitAlgebra; -GRing_PzSemiRing -> GRing_UnitAlgebra; -GRing_SemiAlgebra -> GRing_UnitAlgebra; -GRing_UnitRing -> GRing_UnitAlgebra; -GRing_Zmodule -> GRing_UnitAlgebra; -choice_Choice -> GRing_UnitRing; -eqtype_Equality -> GRing_UnitRing; -GRing_Nmodule -> GRing_UnitRing; -GRing_NzRing -> GRing_UnitRing; -GRing_NzSemiRing -> GRing_UnitRing; -GRing_PzRing -> GRing_UnitRing; -GRing_PzSemiRing -> GRing_UnitRing; -GRing_Zmodule -> GRing_UnitRing; -GRing_AddClosed -> GRing_ZmodClosed; -GRing_OppClosed -> GRing_ZmodClosed; -choice_Choice -> GRing_Zmodule; -eqtype_Equality -> GRing_Zmodule; -GRing_Nmodule -> GRing_Zmodule; -} \ No newline at end of file diff --git a/theories/cumulative_1.txt b/theories/cumulative_1.txt deleted file mode 100644 index e05b7e6d8a..0000000000 --- a/theories/cumulative_1.txt +++ /dev/null @@ -1,86 +0,0 @@ -(* mathcomp analysis (c) 2017 Inria and AIST. License: CeCILL-C. *) -From mathcomp Require Import all_ssreflect ssralg ssrnum ssrint interval. -From mathcomp Require Import finmap fingroup perm rat archimedean. -From HB Require Import structures. -From mathcomp Require Import mathcomp_extra unstable boolp classical_sets. -From mathcomp Require Import functions fsbigop cardinality. -From mathcomp Require Import reals ereal interval_inference topology numfun. -From mathcomp Require Import normedtype sequences esum real_interval measure. -From mathcomp Require Import realfun. - -(**md**************************************************************************) -(* # Lebesgue Stieltjes Measure *) -(* *) -(* This file contains a formalization of the Lebesgue-Stieltjes measure using *) -(* the Measure Extension theorem from measure.v. *) -(* *) -(* References: *) -(* - Achim Klenke. Probability Theory 2nd edition. 2014 *) -(* - Y. Ishiguro, R. Affeldt. The Radon-Nikodym Theorem and the Lebesgue- *) -(* Stieltjes measure in Coq. Computer Software 41(2).2024 *) -(* *) -(* ``` *) -(* right_continuous f == the function f is right-continuous *) -(* cumulative R == type of non-decreasing, right-continuous *) -(* functions (with R : numFieldType) *) -(* The HB class is Cumulative. *) -(* instance: idfun *) -(* ocitv_type R == alias for R : realType *) -(* ocitv == set of open-closed intervals ]x, y] where *) -(* x and y are real numbers *) -(* R.-ocitv == display for ocitv_type R *) -(* R.-ocitv.-measurable == semiring of sets of open-closed intervals *) -(* wlength f A := f b - f a with the hull of the set of real *) -(* numbers A being delimited by a and b *) -(* lebesgue_stieltjes_measure f == Lebesgue-Stieltjes measure for f *) -(* f is a cumulative function. *) -(* completed_lebesgue_stieltjes_measure f == the completed Lebesgue-Stieltjes *) -(* measure *) -(* ``` *) -(* *) -(******************************************************************************) - -Set Implicit Arguments. -Unset Strict Implicit. -Unset Printing Implicit Defensive. -Import Order.TTheory GRing.Theory Num.Def Num.Theory. -Import numFieldTopology.Exports. - -Local Open Scope classical_set_scope. -Local Open Scope ring_scope. - -Reserved Notation "R .-ocitv" (at level 1, format "R .-ocitv"). -Reserved Notation "R .-ocitv.-measurable" - (at level 2, format "R .-ocitv.-measurable"). - -(* TODO: move? *) -Notation right_continuous f := - (forall x, f%function @ at_right x --> f%function x). - -Lemma right_continuousW (R : numFieldType) {d} (U : orderTopologicalType d) - (f : R -> U) : continuous f -> right_continuous f. -Proof. by move=> cf x; apply: cvg_within_filter; exact/cf. Qed. - -HB.mixin Record isCumulative (R : numFieldType) {d} (U : orderTopologicalType d) - (f : R -> U) := { - cumulative_is_nondecreasing : nondecreasing f ; - cumulative_is_right_continuous : right_continuous f }. - -#[short(type=cumulative)] -HB.structure Definition Cumulative - (R : numFieldType) {d} (U : orderTopologicalType d) := { f of isCumulative R d U f }. - -Arguments cumulative_is_nondecreasing {R d U} _. -Arguments cumulative_is_right_continuous {R d U} _. - -Section id_is_cumulative. -Variable R : realType. - -Let id_nd : {homo @idfun R : x y / x <= y}. -Proof. by []. Qed. - -Let id_rc : right_continuous (@idfun R). -Proof. apply: right_continuousW=> x; exact: cvg_id. Qed. (* fail *) - -HB.instance Definition _ := isCumulative.Build R _ R idfun id_nd id_rc. -End id_is_cumulative. diff --git a/theories/cumulative_1.v b/theories/cumulative_1.v deleted file mode 100644 index e05b7e6d8a..0000000000 --- a/theories/cumulative_1.v +++ /dev/null @@ -1,86 +0,0 @@ -(* mathcomp analysis (c) 2017 Inria and AIST. License: CeCILL-C. *) -From mathcomp Require Import all_ssreflect ssralg ssrnum ssrint interval. -From mathcomp Require Import finmap fingroup perm rat archimedean. -From HB Require Import structures. -From mathcomp Require Import mathcomp_extra unstable boolp classical_sets. -From mathcomp Require Import functions fsbigop cardinality. -From mathcomp Require Import reals ereal interval_inference topology numfun. -From mathcomp Require Import normedtype sequences esum real_interval measure. -From mathcomp Require Import realfun. - -(**md**************************************************************************) -(* # Lebesgue Stieltjes Measure *) -(* *) -(* This file contains a formalization of the Lebesgue-Stieltjes measure using *) -(* the Measure Extension theorem from measure.v. *) -(* *) -(* References: *) -(* - Achim Klenke. Probability Theory 2nd edition. 2014 *) -(* - Y. Ishiguro, R. Affeldt. The Radon-Nikodym Theorem and the Lebesgue- *) -(* Stieltjes measure in Coq. Computer Software 41(2).2024 *) -(* *) -(* ``` *) -(* right_continuous f == the function f is right-continuous *) -(* cumulative R == type of non-decreasing, right-continuous *) -(* functions (with R : numFieldType) *) -(* The HB class is Cumulative. *) -(* instance: idfun *) -(* ocitv_type R == alias for R : realType *) -(* ocitv == set of open-closed intervals ]x, y] where *) -(* x and y are real numbers *) -(* R.-ocitv == display for ocitv_type R *) -(* R.-ocitv.-measurable == semiring of sets of open-closed intervals *) -(* wlength f A := f b - f a with the hull of the set of real *) -(* numbers A being delimited by a and b *) -(* lebesgue_stieltjes_measure f == Lebesgue-Stieltjes measure for f *) -(* f is a cumulative function. *) -(* completed_lebesgue_stieltjes_measure f == the completed Lebesgue-Stieltjes *) -(* measure *) -(* ``` *) -(* *) -(******************************************************************************) - -Set Implicit Arguments. -Unset Strict Implicit. -Unset Printing Implicit Defensive. -Import Order.TTheory GRing.Theory Num.Def Num.Theory. -Import numFieldTopology.Exports. - -Local Open Scope classical_set_scope. -Local Open Scope ring_scope. - -Reserved Notation "R .-ocitv" (at level 1, format "R .-ocitv"). -Reserved Notation "R .-ocitv.-measurable" - (at level 2, format "R .-ocitv.-measurable"). - -(* TODO: move? *) -Notation right_continuous f := - (forall x, f%function @ at_right x --> f%function x). - -Lemma right_continuousW (R : numFieldType) {d} (U : orderTopologicalType d) - (f : R -> U) : continuous f -> right_continuous f. -Proof. by move=> cf x; apply: cvg_within_filter; exact/cf. Qed. - -HB.mixin Record isCumulative (R : numFieldType) {d} (U : orderTopologicalType d) - (f : R -> U) := { - cumulative_is_nondecreasing : nondecreasing f ; - cumulative_is_right_continuous : right_continuous f }. - -#[short(type=cumulative)] -HB.structure Definition Cumulative - (R : numFieldType) {d} (U : orderTopologicalType d) := { f of isCumulative R d U f }. - -Arguments cumulative_is_nondecreasing {R d U} _. -Arguments cumulative_is_right_continuous {R d U} _. - -Section id_is_cumulative. -Variable R : realType. - -Let id_nd : {homo @idfun R : x y / x <= y}. -Proof. by []. Qed. - -Let id_rc : right_continuous (@idfun R). -Proof. apply: right_continuousW=> x; exact: cvg_id. Qed. (* fail *) - -HB.instance Definition _ := isCumulative.Build R _ R idfun id_nd id_rc. -End id_is_cumulative. diff --git a/theories/cumulative_2.txt b/theories/cumulative_2.txt deleted file mode 100644 index 302d7d8302..0000000000 --- a/theories/cumulative_2.txt +++ /dev/null @@ -1,86 +0,0 @@ -(* mathcomp analysis (c) 2017 Inria and AIST. License: CeCILL-C. *) -From mathcomp Require Import all_ssreflect ssralg ssrnum ssrint interval. -From mathcomp Require Import finmap fingroup perm rat archimedean. -From HB Require Import structures. -From mathcomp Require Import mathcomp_extra unstable boolp classical_sets. -From mathcomp Require Import functions fsbigop cardinality. -From mathcomp Require Import reals ereal interval_inference topology numfun. -From mathcomp Require Import normedtype sequences esum real_interval measure. -From mathcomp Require Import realfun. - -(**md**************************************************************************) -(* # Lebesgue Stieltjes Measure *) -(* *) -(* This file contains a formalization of the Lebesgue-Stieltjes measure using *) -(* the Measure Extension theorem from measure.v. *) -(* *) -(* References: *) -(* - Achim Klenke. Probability Theory 2nd edition. 2014 *) -(* - Y. Ishiguro, R. Affeldt. The Radon-Nikodym Theorem and the Lebesgue- *) -(* Stieltjes measure in Coq. Computer Software 41(2).2024 *) -(* *) -(* ``` *) -(* right_continuous f == the function f is right-continuous *) -(* cumulative R == type of non-decreasing, right-continuous *) -(* functions (with R : numFieldType) *) -(* The HB class is Cumulative. *) -(* instance: idfun *) -(* ocitv_type R == alias for R : realType *) -(* ocitv == set of open-closed intervals ]x, y] where *) -(* x and y are real numbers *) -(* R.-ocitv == display for ocitv_type R *) -(* R.-ocitv.-measurable == semiring of sets of open-closed intervals *) -(* wlength f A := f b - f a with the hull of the set of real *) -(* numbers A being delimited by a and b *) -(* lebesgue_stieltjes_measure f == Lebesgue-Stieltjes measure for f *) -(* f is a cumulative function. *) -(* completed_lebesgue_stieltjes_measure f == the completed Lebesgue-Stieltjes *) -(* measure *) -(* ``` *) -(* *) -(******************************************************************************) - -Set Implicit Arguments. -Unset Strict Implicit. -Unset Printing Implicit Defensive. -Import Order.TTheory GRing.Theory Num.Def Num.Theory. -Import numFieldTopology.Exports. - -Local Open Scope classical_set_scope. -Local Open Scope ring_scope. - -Reserved Notation "R .-ocitv" (at level 1, format "R .-ocitv"). -Reserved Notation "R .-ocitv.-measurable" - (at level 2, format "R .-ocitv.-measurable"). - -(* TODO: move? *) -Notation right_continuous f := - (forall x, f%function @ at_right x --> f%function x). - -Lemma right_continuousW (R : numFieldType) {d} (U : orderTopologicalType d) - (f : R -> U) : continuous f -> right_continuous f. -Proof. by move=> cf x; apply: cvg_within_filter; exact/cf. Qed. - -HB.mixin Record isCumulative (R : numFieldType) {d} (U : orderTopologicalType d) - (f : R -> U) := { - cumulative_is_nondecreasing : nondecreasing f ; - cumulative_is_right_continuous : right_continuous f }. - -#[short(type=cumulative)] -HB.structure Definition Cumulative - (R : numFieldType) {d} (U : orderTopologicalType d) := { f of isCumulative R d U f }. - -Arguments cumulative_is_nondecreasing {R d U} _. -Arguments cumulative_is_right_continuous {R d U} _. - -Section id_is_cumulative. -Variable R : realFieldType. - -Let id_nd : {homo @idfun R : x y / x <= y}. -Proof. by []. Qed. - -Let id_rc : right_continuous (@idfun R). -Proof. apply: right_continuousW=> x; exact: cvg_id. Qed. (* succeed *) - -HB.instance Definition _ := isCumulative.Build R _ R idfun id_nd id_rc. -End id_is_cumulative. diff --git a/theories/cumulative_2.v b/theories/cumulative_2.v deleted file mode 100644 index 302d7d8302..0000000000 --- a/theories/cumulative_2.v +++ /dev/null @@ -1,86 +0,0 @@ -(* mathcomp analysis (c) 2017 Inria and AIST. License: CeCILL-C. *) -From mathcomp Require Import all_ssreflect ssralg ssrnum ssrint interval. -From mathcomp Require Import finmap fingroup perm rat archimedean. -From HB Require Import structures. -From mathcomp Require Import mathcomp_extra unstable boolp classical_sets. -From mathcomp Require Import functions fsbigop cardinality. -From mathcomp Require Import reals ereal interval_inference topology numfun. -From mathcomp Require Import normedtype sequences esum real_interval measure. -From mathcomp Require Import realfun. - -(**md**************************************************************************) -(* # Lebesgue Stieltjes Measure *) -(* *) -(* This file contains a formalization of the Lebesgue-Stieltjes measure using *) -(* the Measure Extension theorem from measure.v. *) -(* *) -(* References: *) -(* - Achim Klenke. Probability Theory 2nd edition. 2014 *) -(* - Y. Ishiguro, R. Affeldt. The Radon-Nikodym Theorem and the Lebesgue- *) -(* Stieltjes measure in Coq. Computer Software 41(2).2024 *) -(* *) -(* ``` *) -(* right_continuous f == the function f is right-continuous *) -(* cumulative R == type of non-decreasing, right-continuous *) -(* functions (with R : numFieldType) *) -(* The HB class is Cumulative. *) -(* instance: idfun *) -(* ocitv_type R == alias for R : realType *) -(* ocitv == set of open-closed intervals ]x, y] where *) -(* x and y are real numbers *) -(* R.-ocitv == display for ocitv_type R *) -(* R.-ocitv.-measurable == semiring of sets of open-closed intervals *) -(* wlength f A := f b - f a with the hull of the set of real *) -(* numbers A being delimited by a and b *) -(* lebesgue_stieltjes_measure f == Lebesgue-Stieltjes measure for f *) -(* f is a cumulative function. *) -(* completed_lebesgue_stieltjes_measure f == the completed Lebesgue-Stieltjes *) -(* measure *) -(* ``` *) -(* *) -(******************************************************************************) - -Set Implicit Arguments. -Unset Strict Implicit. -Unset Printing Implicit Defensive. -Import Order.TTheory GRing.Theory Num.Def Num.Theory. -Import numFieldTopology.Exports. - -Local Open Scope classical_set_scope. -Local Open Scope ring_scope. - -Reserved Notation "R .-ocitv" (at level 1, format "R .-ocitv"). -Reserved Notation "R .-ocitv.-measurable" - (at level 2, format "R .-ocitv.-measurable"). - -(* TODO: move? *) -Notation right_continuous f := - (forall x, f%function @ at_right x --> f%function x). - -Lemma right_continuousW (R : numFieldType) {d} (U : orderTopologicalType d) - (f : R -> U) : continuous f -> right_continuous f. -Proof. by move=> cf x; apply: cvg_within_filter; exact/cf. Qed. - -HB.mixin Record isCumulative (R : numFieldType) {d} (U : orderTopologicalType d) - (f : R -> U) := { - cumulative_is_nondecreasing : nondecreasing f ; - cumulative_is_right_continuous : right_continuous f }. - -#[short(type=cumulative)] -HB.structure Definition Cumulative - (R : numFieldType) {d} (U : orderTopologicalType d) := { f of isCumulative R d U f }. - -Arguments cumulative_is_nondecreasing {R d U} _. -Arguments cumulative_is_right_continuous {R d U} _. - -Section id_is_cumulative. -Variable R : realFieldType. - -Let id_nd : {homo @idfun R : x y / x <= y}. -Proof. by []. Qed. - -Let id_rc : right_continuous (@idfun R). -Proof. apply: right_continuousW=> x; exact: cvg_id. Qed. (* succeed *) - -HB.instance Definition _ := isCumulative.Build R _ R idfun id_nd id_rc. -End id_is_cumulative. diff --git a/theories/cumulative_3.txt b/theories/cumulative_3.txt deleted file mode 100644 index b5a840e047..0000000000 --- a/theories/cumulative_3.txt +++ /dev/null @@ -1,90 +0,0 @@ -(* mathcomp analysis (c) 2017 Inria and AIST. License: CeCILL-C. *) -From mathcomp Require Import all_ssreflect ssralg ssrnum ssrint interval. -From mathcomp Require Import finmap fingroup perm rat archimedean. -From HB Require Import structures. -From mathcomp Require Import mathcomp_extra unstable boolp classical_sets. -From mathcomp Require Import functions fsbigop cardinality. -From mathcomp Require Import reals ereal interval_inference topology numfun. -From mathcomp Require Import normedtype sequences esum real_interval measure. -From mathcomp Require Import realfun. - -(**md**************************************************************************) -(* # Lebesgue Stieltjes Measure *) -(* *) -(* This file contains a formalization of the Lebesgue-Stieltjes measure using *) -(* the Measure Extension theorem from measure.v. *) -(* *) -(* References: *) -(* - Achim Klenke. Probability Theory 2nd edition. 2014 *) -(* - Y. Ishiguro, R. Affeldt. The Radon-Nikodym Theorem and the Lebesgue- *) -(* Stieltjes measure in Coq. Computer Software 41(2).2024 *) -(* *) -(* ``` *) -(* right_continuous f == the function f is right-continuous *) -(* cumulative R == type of non-decreasing, right-continuous *) -(* functions (with R : numFieldType) *) -(* The HB class is Cumulative. *) -(* instance: idfun *) -(* ocitv_type R == alias for R : realType *) -(* ocitv == set of open-closed intervals ]x, y] where *) -(* x and y are real numbers *) -(* R.-ocitv == display for ocitv_type R *) -(* R.-ocitv.-measurable == semiring of sets of open-closed intervals *) -(* wlength f A := f b - f a with the hull of the set of real *) -(* numbers A being delimited by a and b *) -(* lebesgue_stieltjes_measure f == Lebesgue-Stieltjes measure for f *) -(* f is a cumulative function. *) -(* completed_lebesgue_stieltjes_measure f == the completed Lebesgue-Stieltjes *) -(* measure *) -(* ``` *) -(* *) -(******************************************************************************) - -Set Implicit Arguments. -Unset Strict Implicit. -Unset Printing Implicit Defensive. -Import Order.TTheory GRing.Theory Num.Def Num.Theory. -Import numFieldTopology.Exports. - -Local Open Scope classical_set_scope. -Local Open Scope ring_scope. - -Reserved Notation "R .-ocitv" (at level 1, format "R .-ocitv"). -Reserved Notation "R .-ocitv.-measurable" - (at level 2, format "R .-ocitv.-measurable"). - -(* TODO: move? *) -Notation right_continuous f := - (forall x, f%function @ at_right x --> f%function x). - -Lemma right_continuousW (R : numFieldType) {d} (U : orderTopologicalType d) - (f : R -> U) : continuous f -> right_continuous f. -Proof. by move=> cf x; apply: cvg_within_filter; exact/cf. Qed. - -HB.mixin Record isCumulative (R : numFieldType) {d} (U : orderTopologicalType d) - (f : R -> U) := { - cumulative_is_nondecreasing : nondecreasing f ; - cumulative_is_right_continuous : right_continuous f }. - -#[short(type=cumulative)] -HB.structure Definition Cumulative - (R : numFieldType) {d} (U : orderTopologicalType d) := { f of isCumulative R d U f }. - -Arguments cumulative_is_nondecreasing {R d U} _. -Arguments cumulative_is_right_continuous {R d U} _. - -#[export, non_forgetful_inheritance] -HB.instance Definition _ (R : realType) := - Order_isNbhs.Build _ R (@real_order_nbhsE R). - -Section id_is_cumulative. -Variable R : realType. - -Let id_nd : {homo @idfun R : x y / x <= y}. -Proof. by []. Qed. - -Let id_rc : right_continuous (@idfun R). -Proof. apply: right_continuousW=> x; exact: cvg_id. Qed. (* succeed *) - -HB.instance Definition _ := isCumulative.Build R _ R idfun id_nd id_rc. -End id_is_cumulative. diff --git a/theories/cumulative_3.v b/theories/cumulative_3.v deleted file mode 100644 index b5a840e047..0000000000 --- a/theories/cumulative_3.v +++ /dev/null @@ -1,90 +0,0 @@ -(* mathcomp analysis (c) 2017 Inria and AIST. License: CeCILL-C. *) -From mathcomp Require Import all_ssreflect ssralg ssrnum ssrint interval. -From mathcomp Require Import finmap fingroup perm rat archimedean. -From HB Require Import structures. -From mathcomp Require Import mathcomp_extra unstable boolp classical_sets. -From mathcomp Require Import functions fsbigop cardinality. -From mathcomp Require Import reals ereal interval_inference topology numfun. -From mathcomp Require Import normedtype sequences esum real_interval measure. -From mathcomp Require Import realfun. - -(**md**************************************************************************) -(* # Lebesgue Stieltjes Measure *) -(* *) -(* This file contains a formalization of the Lebesgue-Stieltjes measure using *) -(* the Measure Extension theorem from measure.v. *) -(* *) -(* References: *) -(* - Achim Klenke. Probability Theory 2nd edition. 2014 *) -(* - Y. Ishiguro, R. Affeldt. The Radon-Nikodym Theorem and the Lebesgue- *) -(* Stieltjes measure in Coq. Computer Software 41(2).2024 *) -(* *) -(* ``` *) -(* right_continuous f == the function f is right-continuous *) -(* cumulative R == type of non-decreasing, right-continuous *) -(* functions (with R : numFieldType) *) -(* The HB class is Cumulative. *) -(* instance: idfun *) -(* ocitv_type R == alias for R : realType *) -(* ocitv == set of open-closed intervals ]x, y] where *) -(* x and y are real numbers *) -(* R.-ocitv == display for ocitv_type R *) -(* R.-ocitv.-measurable == semiring of sets of open-closed intervals *) -(* wlength f A := f b - f a with the hull of the set of real *) -(* numbers A being delimited by a and b *) -(* lebesgue_stieltjes_measure f == Lebesgue-Stieltjes measure for f *) -(* f is a cumulative function. *) -(* completed_lebesgue_stieltjes_measure f == the completed Lebesgue-Stieltjes *) -(* measure *) -(* ``` *) -(* *) -(******************************************************************************) - -Set Implicit Arguments. -Unset Strict Implicit. -Unset Printing Implicit Defensive. -Import Order.TTheory GRing.Theory Num.Def Num.Theory. -Import numFieldTopology.Exports. - -Local Open Scope classical_set_scope. -Local Open Scope ring_scope. - -Reserved Notation "R .-ocitv" (at level 1, format "R .-ocitv"). -Reserved Notation "R .-ocitv.-measurable" - (at level 2, format "R .-ocitv.-measurable"). - -(* TODO: move? *) -Notation right_continuous f := - (forall x, f%function @ at_right x --> f%function x). - -Lemma right_continuousW (R : numFieldType) {d} (U : orderTopologicalType d) - (f : R -> U) : continuous f -> right_continuous f. -Proof. by move=> cf x; apply: cvg_within_filter; exact/cf. Qed. - -HB.mixin Record isCumulative (R : numFieldType) {d} (U : orderTopologicalType d) - (f : R -> U) := { - cumulative_is_nondecreasing : nondecreasing f ; - cumulative_is_right_continuous : right_continuous f }. - -#[short(type=cumulative)] -HB.structure Definition Cumulative - (R : numFieldType) {d} (U : orderTopologicalType d) := { f of isCumulative R d U f }. - -Arguments cumulative_is_nondecreasing {R d U} _. -Arguments cumulative_is_right_continuous {R d U} _. - -#[export, non_forgetful_inheritance] -HB.instance Definition _ (R : realType) := - Order_isNbhs.Build _ R (@real_order_nbhsE R). - -Section id_is_cumulative. -Variable R : realType. - -Let id_nd : {homo @idfun R : x y / x <= y}. -Proof. by []. Qed. - -Let id_rc : right_continuous (@idfun R). -Proof. apply: right_continuousW=> x; exact: cvg_id. Qed. (* succeed *) - -HB.instance Definition _ := isCumulative.Build R _ R idfun id_nd id_rc. -End id_is_cumulative. diff --git a/theories/lebesgue_integral_theory/.DS_Store b/theories/lebesgue_integral_theory/.DS_Store deleted file mode 100644 index 5008ddfcf53c02e82d7eee2e57c38e5672ef89f6..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 6148 zcmeH~Jr2S!425mzP>H1@V-^m;4Wg<&0T*E43hX&L&p$$qDprKhvt+--jT7}7np#A3 zem<@ulZcFPQ@L2!n>{z**++&mCkOWA81W14cNZlEfg7;MkzE(HCqgga^y>{tEnwC%0;vJ&^%eQ zLs35+`xjp>T0-> T'} == random variable: a measurable function to the *) -(* measurableType T' from the measured space *) -(* characterized by the probability P *) -(* distribution P X == measure image of the probability measure P by the *) -(* random variable X : {RV P -> T'} *) -(* P as type probability T R with T of type *) -(* measurableType. *) -(* Declared as an instance of probability measure. *) -(* 'E_P[X] == expectation of the real measurable function X *) -(* covariance X Y == covariance between real random variable X and Y *) -(* 'V_P[X] == variance of the real random variable X *) -(* 'M_P X == moment generating function of the random variable X *) -(* with sample space corresponding to the probability *) -(* measure P *) -(* {dmfun T >-> R} == type of discrete real-valued measurable functions *) -(* {dRV P >-> R} == real-valued discrete random variable *) -(* dRV_dom X == domain of the discrete random variable X *) -(* dRV_enum X == bijection between the domain and the range of X *) -(* pmf X r := fine (P (X @^-1` [set r])) *) -(* cdf X r == cumulative distribution function of X *) -(* := distribution P X `]-oo, r] *) -(* enum_prob X k == probability of the kth value in the range of X *) -(* ``` *) -(* *) -(* ``` *) -(* bernoulli_pmf p == Bernoulli pmf with parameter p : R *) -(* bernoulli p == Bernoulli probability measure when 0 <= p <= 1 *) -(* and \d_false otherwise *) -(* binomial_pmf n p == binomial pmf with parameters n : nat and p : R *) -(* binomial_prob n p == binomial probability measure when 0 <= p <= 1 *) -(* and \d_0%N otherwise *) -(* bin_prob n k p == $\binom{n}{k}p^k (1-p)^(n-k)$ *) -(* Computes a binomial distribution term for *) -(* k successes in n trials with success rate p *) -(* uniform_pdf a b == uniform pdf over the interval [a,b] *) -(* uniform_prob a b ab == uniform probability over the interval [a,b] *) -(* where ab0 a proof that 0 < b - a *) -(* normal_peak s := (sqrtr (s ^+ 2 * pi *+ 2))^-1 *) -(* normal_fun m s x := expR (- (x - m) ^+ 2 / (s ^+ 2 *+ 2)) *) -(* normal_pdf m s == pdf of the normal distribution with mean m and *) -(* standard deviation s *) -(* Using normal_peak and normal_pdf. *) -(* normal_prob m s == normal probability measure *) -(* exponential_pdf r == pdf of the exponential distribution with rate r *) -(* exponential_prob r == exponential probability measure *) -(* ``` *) -(* *) -(******************************************************************************) - -Reserved Notation "'{' 'RV' P >-> R '}'" - (at level 0, format "'{' 'RV' P '>->' R '}'"). -Reserved Notation "''E_' P [ X ]" (format "''E_' P [ X ]"). -Reserved Notation "''V_' P [ X ]" (format "''V_' P [ X ]"). -Reserved Notation "'M_ P X" (at level 5, P, X at level 4, format "''M_' P X"). -Reserved Notation "{ 'dmfun' aT >-> T }" (format "{ 'dmfun' aT >-> T }"). -Reserved Notation "'{' 'dRV' P >-> R '}'" (format "'{' 'dRV' P '>->' R '}'"). - -Set Implicit Arguments. -Unset Strict Implicit. -Unset Printing Implicit Defensive. - -Import Order.TTheory GRing.Theory Num.Def Num.Theory. -Import numFieldTopology.Exports. - -Local Open Scope classical_set_scope. -Local Open Scope ring_scope. - -Definition random_variable d d' (T : measurableType d) (T' : measurableType d') - (R : realType) (P : probability T R) := {mfun T >-> T'}. - -Notation "{ 'RV' P >-> T' }" := (@random_variable _ _ _ T' _ P) : form_scope. - -Lemma notin_range_measure d d' (T : measurableType d) (T' : measurableType d') - (R : realType) (P : {measure set T -> \bar R}) (X : T -> R) r : - r \notin range X -> P (X @^-1` [set r]) = 0%E. -Proof. by rewrite notin_setE => hr; rewrite preimage10. Qed. - -Lemma probability_range d d' (T : measurableType d) (T' : measurableType d') - (R : realType) (P : probability T R) (X : {RV P >-> R}) : - P (X @^-1` range X) = 1%E. -Proof. by rewrite preimage_range probability_setT. Qed. - -Definition distribution d d' (T : measurableType d) (T' : measurableType d') - (R : realType) (P : probability T R) (X : {mfun T >-> T'}) := - pushforward P X. - -Section distribution_is_probability. -Context d d' {T : measurableType d} {T' : measurableType d'} {R : realType} - {P : probability T R}. -Variable X : {mfun T >-> T'}. - -Let distribution0 : distribution P X set0 = 0%E. -Proof. exact: measure0. Qed. - -Let distribution_ge0 A : (0 <= distribution P X A)%E. -Proof. exact: measure_ge0. Qed. - -Let distribution_sigma_additive : semi_sigma_additive (distribution P X). -Proof. exact: measure_semi_sigma_additive. Qed. - -HB.instance Definition _ := isMeasure.Build _ _ _ (distribution P X) - distribution0 distribution_ge0 distribution_sigma_additive. - -Let distribution_is_probability : distribution P X [set: _] = 1%:E. -Proof. -by rewrite /distribution /= /pushforward /= preimage_setT probability_setT. -Qed. - -HB.instance Definition _ := Measure_isProbability.Build _ _ _ - (distribution P X) distribution_is_probability. - -End distribution_is_probability. - -Section transfer_probability. -Local Open Scope ereal_scope. -Context d d' {T : measurableType d} {T' : measurableType d'} {R : realType} - (P : probability T R). - -Lemma probability_distribution (X : {RV P >-> T'}) r : - P [set x | X x = r] = distribution P X [set r]. -Proof. by []. Qed. - -Lemma ge0_integral_distribution (X : {RV P >-> T'}) (f : T' -> \bar R) : - measurable_fun [set: T'] f -> (forall y, 0 <= f y) -> - \int[distribution P X]_y f y = \int[P]_x (f \o X) x. -Proof. by move=> mf f0; rewrite ge0_integral_pushforward. Qed. - -Lemma integral_distribution (X : {RV P >-> T'}) (f : T' -> \bar R) : - measurable_fun [set: T'] f -> P.-integrable [set: T] (f \o X) -> - \int[distribution P X]_y f y = \int[P]_x (f \o X) x. -Proof. by move=> mf intf; rewrite integral_pushforward. Qed. - -End transfer_probability. - -Definition cdf d (T : measurableType d) (R : realType) (P : probability T R) - (X : {RV P >-> R}) (r : R) := distribution P X `]-oo, r]. - -Section cumulative_distribution_function. -Context d {T : measurableType d} {R : realType} (P : probability T R). -Variable X : {RV P >-> R}. -Local Open Scope ereal_scope. - -Lemma cdf_ge0 r : 0 <= cdf X r. Proof. by []. Qed. - -Lemma cdf_le1 r : cdf X r <= 1. Proof. exact: probability_le1. Qed. - -Lemma cdf_nondecreasing : nondecreasing_fun (cdf X). -Proof. by move=> r s rs; rewrite le_measure ?inE//; exact: subitvPr. Qed. - -Lemma cvg_cdfy1 : cdf X @ +oo%R --> 1. -Proof. -pose s : \bar R := ereal_sup (range (cdf X)). -have cdf_s : cdf X r @[r --> +oo%R] --> s. - exact: nondecreasing_cvge cdf_nondecreasing. -have cdf_ns : cdf X n%:R @[n --> \oo%R] --> s. - by move/cvge_pinftyP : cdf_s; apply; exact/cvgryPge/nbhs_infty_ger. -have cdf_n1 : cdf X n%:R @[n --> \oo] --> 1. - rewrite -(probability_setT P). - pose F n := X @^-1` `]-oo, n%:R]. - have <- : \bigcup_n F n = setT. - rewrite -preimage_bigcup -subTset => t _/=. - by exists (trunc (X t)).+1 => //=; rewrite in_itv/= ltW// truncnS_gt. - apply: nondecreasing_cvg_mu => //; first exact: bigcup_measurable. - move=> n m nm; apply/subsetPset => x/=; rewrite !in_itv/= => /le_trans. - by apply; rewrite ler_nat. -by rewrite -(cvg_unique _ cdf_ns cdf_n1). -Qed. - -Lemma cvg_cdfNy0 : cdf X @ -oo%R --> 0. -Proof. -rewrite cvgNy_compNP. -have cdf_opp_noninc : {homo cdf X \o -%R : q r / (q <= r)%R >-> q >= r}. - by move=> q r; rewrite -lterN2; exact: cdf_nondecreasing. -pose s := ereal_inf (range (cdf X \o -%R)). -have cdf_opp_s : (cdf X \o -%R) r @[r --> +oo%R] --> s. - exact: nonincreasing_cvge cdf_opp_noninc. -have cdf_opp_ns : (cdf X \o -%R) n%:R @[n --> \oo] --> s. - by move/cvge_pinftyP : cdf_opp_s; apply; exact/cvgryPge/nbhs_infty_ger. -have cdf_opp_n0 : (cdf X \o -%R) n%:R @[n --> \oo] --> 0. - rewrite -(measure0 P). - pose F n := X @^-1` `]-oo, (- n%:R)%R]. - have <- : \bigcap_n F n = set0. - rewrite -subset0 => t. - set m := (trunc `|X t|).+1. - move=> /(_ m I); rewrite /F/= in_itv/= leNgt => /negP; apply. - by rewrite ltrNl /m (le_lt_trans (ler_norm _))// normrN truncnS_gt. - apply: nonincreasing_cvg_mu => //=. - + by rewrite (le_lt_trans (probability_le1 _ _)) ?ltry. - + exact: bigcap_measurable. - + move=> m n mn; apply/subsetPset => x/=; rewrite !in_itv => /le_trans; apply. - by rewrite lerN2 ler_nat. -by rewrite (_ : 0%E = s)// (cvg_unique _ cdf_opp_ns cdf_opp_n0). -Qed. - -Lemma cdf_right_continuous : right_continuous (cdf X). -Proof. -move=> a. -pose s := fine (ereal_inf (cdf X @` `]a, a + 1%R]%classic)). -have cdf_s : cdf X r @[r --> a^'+] --> s%:E. - rewrite /s fineK. - - apply: nondecreasing_at_right_cvge; first by rewrite ltBSide /= ?ltrDl. - by move=> *; exact: cdf_nondecreasing. - - apply/fin_numPlt/andP; split=>//. - + by rewrite (lt_le_trans (ltNyr 0%R)) ?lb_ereal_inf//= => l[? _] <-. - + rewrite (le_lt_trans _ (ltry 1%R))// ereal_inf_le//=. - exists (cdf X (a + 1)); last exact: cdf_le1. - by exists (a + 1%R) => //; rewrite in_itv /=; apply/andP; rewrite ltrDl. -have cdf_ns : cdf X (a + n.+1%:R^-1) @[n --> \oo] --> s%:E. - move/cvge_at_rightP : cdf_s; apply; split=> [n|]; rewrite ?ltrDl //. - rewrite -[X in _ --> X]addr0; apply: (@cvgD _ R^o); first exact: cvg_cst. - by rewrite gtr0_cvgV0 ?cvg_shiftS; [exact: cvgr_idn | near=> n]. -have cdf_na : cdf X (a + n.+1%:R^-1) @[n --> \oo] --> cdf X a. - pose F n := X @^-1` `]-oo, a + n.+1%:R^-1%R]. - suff : P (F n) @[n --> \oo] --> P (\bigcap_n F n). - by rewrite [in X in _ --> X -> _]/F -preimage_bigcap -itvNycEbigcap. - apply: nonincreasing_cvg_mu => [| | |m n mn]. - - by rewrite -ge0_fin_numE// fin_num_measure//; exact: measurable_sfunP. - - by move=> ?; exact: measurable_sfunP. - - by apply: bigcap_measurable => // ? _; exact: measurable_sfunP. - - apply/subsetPset; apply: preimage_subset; apply: subset_itvl. - by rewrite bnd_simp lerD2l lef_pV2 ?posrE// ler_nat. -by rewrite -(cvg_unique _ cdf_ns cdf_na). -Unshelve. all: by end_near. Qed. - -Lemma gte_lte_real (x a b : \bar R) : - (a < x < b) -> x \is a fin_num. -Proof. -case/andP => [ax xb]; apply/fin_numPlt/andP; split. - exact: (le_lt_trans (leNye a) ax). -exact: (lt_le_trans xb (leey b)). -Qed. - -Lemma ereal_order_nbhsE : forall x : (\bar R), nbhs x = filter_from - (fun i => itv_open_ends i /\ x \in i) (fun i => [set` i]). -Proof. -move=> x; apply/seteqP; split=> A. - rewrite /nbhs/=/ereal_nbhs/=; case x =>[r||]. - - rewrite /nbhs/=/nbhs_ball_/filter_from/=; case=> e e_pos ball_re. - exists `](r - e)%:E, (r + e)%:E[ =>[|y/=]. - split; first by rewrite/itv_open_ends/=; right. - rewrite in_itv/= EFinB gte_subl// EFinD lteDl//; exact/andP. - rewrite in_itv/= => /[dup]/gte_lte_real/fineK<-. - rewrite !lte_fin => fy; apply: ball_re. - by rewrite /ball_/= -opprB normrN ltr_norml ltrBrDl (ltrBlDl _ r). - - case=> M [? MA]; rewrite /filter_from/=. - exists `]M%:E, +oo[ =>[|y/=]; rewrite in_itv/= andbT; last exact: MA. - by split; first by rewrite/itv_open_ends; left. - - case=> M [? MA]; rewrite /filter_from/=. - exists `]-oo, M%:E[ =>[|y/=]; rewrite in_itv/=; last exact: MA. - by split; first by rewrite /itv_open_ends; left. -rewrite /filter_from/= => [][][][[]r|[]][[]s|[]][][]; - rewrite /itv_is_ray/itv_is_bd_open// in_itv/= =>_. - - rewrite /nbhs/=/ereal_nbhs/= => /[dup]/gte_lte_real/fineK<-. - case/andP=> rx sx rsA; apply: (nbhs_interval rx sx) => *. - by apply: rsA =>/=; rewrite in_itv/=; apply/andP. - - rewrite nbhsE/= => rx ?; exists (`]r, +oo[)%classic; rewrite /open_nbhs//. - by split; [rewrite set_itvE; exact: open_ereal_gt_ereal | exact: rx]. - - rewrite nbhsE/= => xs ?; exists (`]-oo, s[)%classic; rewrite /open_nbhs//. - by split; [rewrite set_itvE; exact: open_ereal_lt_ereal | exact: xs]. - - by rewrite set_itvE/= subTset => _ ->; exact: filter_nbhsT. -Qed. - -HB.instance Definition _ := Order_isNbhs.Build _ (\bar R) ereal_order_nbhsE. - -HB.instance Definition _ := isCumulative.Build R _ (\bar R) (cdf X) - cdf_nondecreasing cdf_right_continuous. - -End cumulative_distribution_function. - -Section cdf_of_lebesgue_stieltjes_mesure. -Context {R : realType} (f : cumulativeBounded (0:R) (1:R)). -Local Open Scope measure_display_scope. - -Let T := g_sigma_algebraType R.-ocitv.-measurable. -Let lsf := lebesgue_stieltjes_measure f. - -Let idTR : T -> R := idfun. - -#[local] HB.instance Definition _ := - @isMeasurableFun.Build _ _ T R idTR (@measurable_id _ _ setT). - -Lemma cdf_lebesgue_stieltjes_id r : cdf (idTR : {RV lsf >-> R}) r = (f r)%:E. -Proof. -rewrite /= preimage_id itvNybndEbigcup. -have : lsf `]-n%:R, r] @[n --> \oo] --> (f r)%:E. - suff : ((f r)%:E - (f (-n%:R))%:E)%E @[n --> \oo] --> (f r)%:E. - apply: cvg_trans; apply: near_eq_cvg; near=> n. - rewrite /lsf /lebesgue_stieltjes_measure /measure_extension/=. - rewrite measurable_mu_extE/= ?wlength_itv_bnd//; last exact: is_ocitv. - by rewrite lerNl; near: n; exact: nbhs_infty_ger. - rewrite -[X in _ --> X](sube0 (f r)%:E); apply: (cvgeB _ (cvg_cst _ )) => //. - apply: (cvg_comp _ _ (cvg_comp _ _ _ (cumulativeNy f))) => //. - by apply: (cvg_comp _ _ cvgr_idn); rewrite ninfty. -have : lsf `]- n%:R, r] @[n --> \oo] --> lsf (\bigcup_n `]-n%:R, r]%classic). - apply: nondecreasing_cvg_mu; rewrite /I//; first exact: bigcup_measurable. - by move=> *; apply/subsetPset/subset_itv; rewrite leBSide//= lerN2 ler_nat. -exact: cvg_unique. -Unshelve. all: by end_near. Qed. - -End cdf_of_lebesgue_stieltjes_mesure. - -HB.lock Definition expectation {d} {T : measurableType d} {R : realType} - (P : probability T R) (X : T -> R) := (\int[P]_w (X w)%:E)%E. -Canonical expectation_unlockable := Unlockable expectation.unlock. -Arguments expectation {d T R} P _%_R. -Notation "''E_' P [ X ]" := (@expectation _ _ _ P X) : ereal_scope. - -Section expectation_lemmas. -Local Open Scope ereal_scope. -Context d (T : measurableType d) (R : realType) (P : probability T R). - -Lemma expectation_def (X : {RV P >-> R}) : 'E_P[X] = (\int[P]_w (X w)%:E)%E. -Proof. by rewrite unlock. Qed. - -Lemma expectation_fin_num (X : T -> R) : X \in Lfun P 1 -> - 'E_P[X] \is a fin_num. -Proof. -by move=> ?; rewrite unlock integrable_fin_num//; exact/Lfun1_integrable. -Qed. - -Lemma expectation_cst r : 'E_P[cst r] = r%:E. -Proof. by rewrite unlock/= integral_cst//= probability_setT mule1. Qed. - -Lemma expectation_indic (A : set T) (mA : measurable A) : 'E_P[\1_A] = P A. -Proof. by rewrite unlock integral_indic// setIT. Qed. - -Lemma integrable_expectation (X : {RV P >-> R}) - (iX : P.-integrable [set: T] (EFin \o X)) : `| 'E_P[X] | < +oo. -Proof. -move: iX => /integrableP[? Xoo]; rewrite (le_lt_trans _ Xoo)// unlock. -exact: le_trans (le_abse_integral _ _ _). -Qed. - -Lemma expectationZl (X : T -> R) (k : R) : X \in Lfun P 1 -> - 'E_P[k \o* X] = k%:E * 'E_P [X]. -Proof. -by move=> ?; rewrite unlock muleC -integralZr//; exact/Lfun1_integrable. -Qed. - -Lemma expectation_ge0 (X : T -> R) : (forall x, 0 <= X x)%R -> - 0 <= 'E_P[X]. -Proof. -by move=> ?; rewrite unlock integral_ge0// => x _; rewrite lee_fin. -Qed. - -Lemma expectation_le (X Y : T -> R) : - measurable_fun [set: T] X -> measurable_fun [set: T] Y -> - (forall x, 0 <= X x)%R -> (forall x, 0 <= Y x)%R -> - {ae P, (forall x, X x <= Y x)%R} -> 'E_P[X] <= 'E_P[Y]. -Proof. -move=> mX mY X0 Y0 XY; rewrite unlock ae_ge0_le_integral => //. -- by move=> t _; apply: X0. -- exact/measurable_EFinP. -- by move=> t _; apply: Y0. -- exact/measurable_EFinP. -- move: XY => [N [mN PN XYN]]; exists N; split => // t /= h. - by apply: XYN => /=; apply: contra_not h; rewrite lee_fin. -Qed. - -Lemma expectationD (X Y : T -> R) : X \in Lfun P 1 -> Y \in Lfun P 1 -> - 'E_P[X \+ Y] = 'E_P[X] + 'E_P[Y]. -Proof. -by move=> ? ?; rewrite unlock integralD_EFin//; exact/Lfun1_integrable. -Qed. - -Lemma expectationB (X Y : T -> R) : X \in Lfun P 1 -> Y \in Lfun P 1 -> - 'E_P[X \- Y] = 'E_P[X] - 'E_P[Y]. -Proof. -by move=> ? ?; rewrite unlock integralB_EFin//; exact/Lfun1_integrable. -Qed. - -Lemma expectation_sum (X : seq (T -> R)) : - (forall Xi, Xi \in X -> Xi \in Lfun P 1) -> - 'E_P[\sum_(Xi <- X) Xi] = \sum_(Xi <- X) 'E_P[Xi]. -Proof. -elim: X => [|X0 X IHX] intX; first by rewrite !big_nil expectation_cst. -rewrite !big_cons expectationD; last 2 first. - by rewrite intX// mem_head. - by rewrite big_seq rpred_sum// => Y YX/=; rewrite intX// inE YX orbT. -by rewrite IHX//= => Xi XiX; rewrite intX// inE XiX orbT. -Qed. - -End expectation_lemmas. -#[deprecated(since="mathcomp-analysis 1.8.0", note="renamed to `expectationZl`")] -Notation expectationM := expectationZl (only parsing). - -HB.lock Definition covariance {d} {T : measurableType d} {R : realType} - (P : probability T R) (X Y : T -> R) := - 'E_P[(X \- cst (fine 'E_P[X])) * (Y \- cst (fine 'E_P[Y]))]%E. -Canonical covariance_unlockable := Unlockable covariance.unlock. -Arguments covariance {d T R} P _%_R _%_R. - -Hint Extern 0 (fin_num_fun _) => - (apply: fin_num_measure) : core. - -Section covariance_lemmas. -Local Open Scope ereal_scope. -Context d (T : measurableType d) (R : realType) (P : probability T R). - -Lemma covarianceE (X Y : T -> R) : - X \in Lfun P 1 -> Y \in Lfun P 1 -> - (X * Y)%R \in Lfun P 1 -> - covariance P X Y = 'E_P[X * Y] - 'E_P[X] * 'E_P[Y]. -Proof. -move=> l1X l1Y l1XY. -rewrite unlock [X in 'E_P[X]](_ : _ = (X \* Y \- fine 'E_P[X] \o* Y - \- fine 'E_P[Y] \o* X \+ fine ('E_P[X] * 'E_P[Y]) \o* cst 1)%R); last first. - apply/funeqP => x /=; rewrite mulrDr !mulrDl/= mul1r. - rewrite fineM ?expectation_fin_num// mulrNN addrA. - by rewrite mulrN mulNr [Z in (X x * Y x - Z)%R]mulrC. -rewrite expectationD/= ?rpredB//= ?Lfun_scale ?Lfun_cst//. -rewrite 2?expectationB//= ?rpredB ?Lfun_scale// 3?expectationZl//= ?Lfun_cst//. -rewrite expectation_cst mule1 fineM ?expectation_fin_num// EFinM. -rewrite !fineK ?expectation_fin_num//. -by rewrite muleC subeK ?fin_numM ?expectation_fin_num. -Qed. - -Lemma covarianceC (X Y : T -> R) : covariance P X Y = covariance P Y X. -Proof. -by rewrite unlock; congr expectation; apply/funeqP => x /=; rewrite mulrC. -Qed. - -Lemma covariance_fin_num (X Y : T -> R) : - X \in Lfun P 1 -> Y \in Lfun P 1 -> - (X * Y)%R \in Lfun P 1 -> - covariance P X Y \is a fin_num. -Proof. -by move=> ? ? ?; rewrite covarianceE// fin_numB fin_numM expectation_fin_num. -Qed. - -Lemma covariance_cst_l c (X : T -> R) : covariance P (cst c) X = 0. -Proof. -rewrite unlock expectation_cst/=. -rewrite [X in 'E_P[X]](_ : _ = cst 0%R) ?expectation_cst//. -by apply/funeqP => x; rewrite /GRing.mul/= subrr mul0r. -Qed. - -Lemma covariance_cst_r (X : T -> R) c : covariance P X (cst c) = 0. -Proof. by rewrite covarianceC covariance_cst_l. Qed. - -Lemma covarianceZl a (X Y : T -> R) : - X \in Lfun P 1 -> Y \in Lfun P 1 -> - (X * Y)%R \in Lfun P 1 -> - covariance P (a \o* X)%R Y = a%:E * covariance P X Y. -Proof. -move=> X1 Y1 XY1. -have aXY : (a \o* X * Y = a \o* (X * Y))%R by apply/funeqP => x; rewrite mulrAC. -rewrite [LHS]covarianceE => [||//|] //=; last 2 first. -- by rewrite Lfun_scale. -- by rewrite aXY Lfun_scale. -rewrite covarianceE// aXY !expectationZl//. -by rewrite -muleA -muleBr// fin_num_adde_defr// expectation_fin_num. -Qed. - -Lemma covarianceZr a (X Y : T -> R) : X \in Lfun P 1 -> Y \in Lfun P 1 -> - (X * Y)%R \in Lfun P 1 -> - covariance P X (a \o* Y)%R = a%:E * covariance P X Y. -Proof. -move=> X1 Y1 XY1. -by rewrite [in RHS]covarianceC covarianceC covarianceZl; last rewrite mulrC. -Qed. - -Lemma covarianceNl (X Y : T -> R) : X \in Lfun P 1 -> Y \in Lfun P 1 -> - (X * Y)%R \in Lfun P 1 -> - covariance P (\- X)%R Y = - covariance P X Y. -Proof. -move=> X1 Y1 XY1. -have -> : (\- X = -1 \o* X)%R by apply/funeqP => x /=; rewrite mulrN mulr1. -by rewrite covarianceZl// EFinN mulNe mul1e. -Qed. - -Lemma covarianceNr (X Y : T -> R) : X \in Lfun P 1 -> Y \in Lfun P 1 -> - (X * Y)%R \in Lfun P 1 -> - covariance P X (\- Y)%R = - covariance P X Y. -Proof. by move=> X1 Y1 XY1; rewrite !(covarianceC X) covarianceNl 1?mulrC. Qed. - -Lemma covarianceNN (X Y : T -> R) : X \in Lfun P 1 -> Y \in Lfun P 1 -> - (X * Y)%R \in Lfun P 1 -> - covariance P (\- X)%R (\- Y)%R = covariance P X Y. -Proof. -by move=> ? ? ?; rewrite covarianceNl//= ?covarianceNr ?oppeK ?mulrN//= ?rpredN. -Qed. - -Lemma covarianceDl (X Y Z : T -> R) : - X \in Lfun P 2%:E -> Y \in Lfun P 2%:E -> Z \in Lfun P 2%:E -> - covariance P (X \+ Y)%R Z = covariance P X Z + covariance P Y Z. -Proof. -move=> X2 Y2 Z2. -have Pfin : P setT \is a fin_num := fin_num_measure P _ measurableT. -have X1 := Lfun_subset12 Pfin X2. -have Y1 := Lfun_subset12 Pfin Y2. -have Z1 := Lfun_subset12 Pfin Z2. -have XY1 := Lfun2_mul_Lfun1 X2 Y2. -have YZ1 := Lfun2_mul_Lfun1 Y2 Z2. -have XZ1 := Lfun2_mul_Lfun1 X2 Z2. -rewrite [LHS]covarianceE//= ?mulrDl ?compreDr ?rpredD//= 2?expectationD//=. -rewrite muleDl ?fin_num_adde_defr ?expectation_fin_num//. -rewrite oppeD ?fin_num_adde_defr ?fin_numM ?expectation_fin_num//. -by rewrite addeACA 2?covarianceE. -Qed. - -Lemma covarianceDr (X Y Z : T -> R) : - X \in Lfun P 2%:E -> Y \in Lfun P 2%:E -> Z \in Lfun P 2%:E -> - covariance P X (Y \+ Z)%R = covariance P X Y + covariance P X Z. -Proof. -by move=> X2 Y2 Z2; rewrite covarianceC covarianceDl ?(covarianceC X) 1?mulrC. -Qed. - -Lemma covarianceBl (X Y Z : T -> R) : - X \in Lfun P 2%:E -> Y \in Lfun P 2%:E -> Z \in Lfun P 2%:E -> - covariance P (X \- Y)%R Z = covariance P X Z - covariance P Y Z. -Proof. -move=> X2 Y2 Z2. -have Pfin : P setT \is a fin_num := fin_num_measure P _ measurableT. -have Y1 := Lfun_subset12 Pfin Y2. -have Z1 := Lfun_subset12 Pfin Z2. -have YZ1 := Lfun2_mul_Lfun1 Y2 Z2. -by rewrite -[(X \- Y)%R]/(X \+ (\- Y))%R covarianceDl ?covarianceNl ?rpredN. -Qed. - -Lemma covarianceBr (X Y Z : T -> R) : - X \in Lfun P 2%:E -> Y \in Lfun P 2%:E -> Z \in Lfun P 2%:E -> - covariance P X (Y \- Z)%R = covariance P X Y - covariance P X Z. -Proof. -move=> X2 Y2 Z2. -have Pfin : P setT \is a fin_num := fin_num_measure P _ measurableT. -have Y1 := Lfun_subset12 Pfin Y2. -have Z1 := Lfun_subset12 Pfin Z2. -have YZ1 := Lfun2_mul_Lfun1 Y2 Z2. -by rewrite !(covarianceC X) covarianceBl 1?(mulrC _ X). -Qed. - -End covariance_lemmas. - -Section variance. -Local Open Scope ereal_scope. -Context d (T : measurableType d) (R : realType) (P : probability T R). - -Definition variance (X : T -> R) := covariance P X X. -Local Notation "''V_' P [ X ]" := (variance X). - -Lemma varianceE (X : T -> R) : X \in Lfun P 2%:E -> - 'V_P[X] = 'E_P[X ^+ 2] - ('E_P[X]) ^+ 2. -Proof. -move=> X2; rewrite /variance. -by rewrite covarianceE ?Lfun2_mul_Lfun1// Lfun_subset12 ?fin_num_measure. -Qed. - -Lemma variance_fin_num (X : T -> R) : X \in Lfun P 2%:E -> - 'V_P[X] \is a fin_num. -Proof. -move=> X2. -by rewrite covariance_fin_num ?Lfun2_mul_Lfun1// Lfun_subset12 ?fin_num_measure. -Qed. - -Lemma variance_ge0 (X : T -> R) : 0 <= 'V_P[X]. -Proof. -by rewrite /variance unlock; apply: expectation_ge0 => x; exact: sqr_ge0. -Qed. - -Lemma variance_cst r : 'V_P[cst r] = 0%E. -Proof. -rewrite /variance unlock expectation_cst/=. -rewrite [X in 'E_P[X]](_ : _ = cst 0%R) ?expectation_cst//. -by apply/funext => x; rewrite /GRing.exp/GRing.mul/= subrr mulr0. -Qed. - -Lemma varianceZ a (X : T -> R) : X \in Lfun P 2%:E -> - 'V_P[(a \o* X)%R] = (a ^+ 2)%:E * 'V_P[X]. -Proof. -move=> X2. -have Pfin : P setT \is a fin_num := fin_num_measure P _ measurableT. -have X1 := Lfun_subset12 Pfin X2. -rewrite /variance covarianceZl//=. -- by rewrite covarianceZr// ?muleA ?EFinM// Lfun2_mul_Lfun1. -- by rewrite Lfun_scale. -- by rewrite Lfun2_mul_Lfun1// Lfun_scale// ler1n. -Qed. - -Lemma varianceN (X : T -> R) : X \in Lfun P 2%:E -> 'V_P[(\- X)%R] = 'V_P[X]. -Proof. -move=> X2; rewrite /variance. -by rewrite covarianceNN ?Lfun2_mul_Lfun1 ?Lfun_subset12 ?fin_num_measure. -Qed. - -Lemma varianceD (X Y : T -> R) : X \in Lfun P 2%:E -> Y \in Lfun P 2%:E -> - 'V_P[X \+ Y]%R = 'V_P[X] + 'V_P[Y] + 2%:E * covariance P X Y. -Proof. -move=> X2 Y2. -have Pfin : P setT \is a fin_num := fin_num_measure P _ measurableT. -have X1 := Lfun_subset12 Pfin X2. -have Y1 := Lfun_subset12 Pfin Y2. -have XY1 := Lfun2_mul_Lfun1 X2 Y2. -rewrite -['V_P[_]]/(covariance P (X \+ Y)%R (X \+ Y)%R). -rewrite covarianceDl ?rpredD ?lee1n//= covarianceDr// covarianceDr//. -rewrite (covarianceC P Y X) [LHS]addeA [LHS](ACl (1*4*(2*3)))/=. -by rewrite -[2%R]/(1 + 1)%R EFinD muleDl ?mul1e// covariance_fin_num. -Qed. - -Lemma varianceB (X Y : T -> R) : X \in Lfun P 2%:E -> Y \in Lfun P 2%:E -> - 'V_P[(X \- Y)%R] = 'V_P[X] + 'V_P[Y] - 2%:E * covariance P X Y. -Proof. -move=> X2 Y2. -have Pfin : P setT \is a fin_num := fin_num_measure P _ measurableT. -have X1 := Lfun_subset12 Pfin X2. -have Y1 := Lfun_subset12 Pfin Y2. -have XY1 := Lfun2_mul_Lfun1 X2 Y2. -rewrite -[(X \- Y)%R]/(X \+ (\- Y))%R. -by rewrite varianceD/= ?varianceN ?covarianceNr ?muleN ?rpredN. -Qed. - -Lemma varianceD_cst_l c (X : T -> R) : X \in Lfun P 2%:E -> - 'V_P[(cst c \+ X)%R] = 'V_P[X]. -Proof. -move=> X2. -by rewrite varianceD ?Lfun_cst// variance_cst add0e covariance_cst_l mule0 adde0. -Qed. - -Lemma varianceD_cst_r (X : T -> R) c : X \in Lfun P 2%:E -> - 'V_P[(X \+ cst c)%R] = 'V_P[X]. -Proof. -move=> X2. -have -> : (X \+ cst c = cst c \+ X)%R by apply/funeqP => x /=; rewrite addrC. -exact: varianceD_cst_l. -Qed. - -Lemma varianceB_cst_l c (X : T -> R) : X \in Lfun P 2%:E -> - 'V_P[(cst c \- X)%R] = 'V_P[X]. -Proof. -move=> X2; rewrite -[(cst c \- X)%R]/(cst c \+ (\- X))%R. -by rewrite varianceD_cst_l/= ?rpredN// varianceN. -Qed. - -Lemma varianceB_cst_r (X : T -> R) c : X \in Lfun P 2%:E -> - 'V_P[(X \- cst c)%R] = 'V_P[X]. -Proof. -by move=> X2; rewrite -[(X \- cst c)%R]/(X \+ (cst (- c)))%R varianceD_cst_r. -Qed. - -Lemma covariance_le (X Y : T -> R) : X \in Lfun P 2%:E -> Y \in Lfun P 2%:E -> - covariance P X Y <= sqrte 'V_P[X] * sqrte 'V_P[Y]. -Proof. -move=> X2 Y2. -have Pfin : P setT \is a fin_num := fin_num_measure P _ measurableT. -have X1 := Lfun_subset12 Pfin X2. -have Y1 := Lfun_subset12 Pfin Y2. -have XY1 := Lfun2_mul_Lfun1 X2 Y2. -rewrite -sqrteM ?variance_ge0//. -rewrite lee_sqrE ?sqrte_ge0// sqr_sqrte ?mule_ge0 ?variance_ge0//. -rewrite -(fineK (variance_fin_num X2)) -(fineK (variance_fin_num Y2)). -rewrite -(fineK (covariance_fin_num X1 Y1 XY1)). -rewrite -EFin_expe -EFinM lee_fin -(@ler_pM2l _ 4) ?ltr0n// [leRHS]mulrA. -rewrite [in leLHS](_ : 4 = 2 * 2)%R -natrM// [in leLHS]natrM mulrACA -expr2. -rewrite -subr_le0. -set a := fine (variance X). -set b := (2 * fine (covariance P X Y))%R. -set c := fine (variance Y). -pose p := Poly [:: c; b; a]. -have -> : a = p`_2 by rewrite !coefE. -have -> : b = p`_1 by rewrite !coefE. -have -> : c = p`_0 by rewrite !coefE. -rewrite deg_le2_poly_ge0 ?size_Poly// => r. -rewrite horner_Poly/= mul0r add0r mulrDl -mulrA -expr2. -rewrite -lee_fin !EFinD EFinM fineK ?variance_fin_num// muleC -varianceZ//. -rewrite 2!EFinM ?fineK ?variance_fin_num// ?covariance_fin_num//. -rewrite -muleA [_ * r%:E]muleC -covarianceZl//. -rewrite addeAC -varianceD ?variance_ge0//=. -by rewrite Lfun_scale// ler1n. -Qed. - -End variance. -Notation "'V_ P [ X ]" := (variance P X). - -Definition mmt_gen_fun d (T : measurableType d) (R : realType) - (P : probability T R) (X : T -> R) (t : R) := ('E_P[expR \o t \o* X])%E. -Notation "'M_ P X" := (@mmt_gen_fun _ _ _ P X). - -Section markov_chebyshev_cantelli. -Local Open Scope ereal_scope. -Context d (T : measurableType d) (R : realType) (P : probability T R). - -Lemma markov (X : {RV P >-> R}) (f : R -> R) (eps : R) : (0 < eps)%R -> - measurable_fun [set: R] f -> (forall r, 0 <= r -> 0 <= f r)%R -> - {in Num.nneg &, {homo f : x y / x <= y}}%R -> - (f eps)%:E * P [set x | eps%:E <= `| (X x)%:E | ] <= - 'E_P[f \o (fun x => `| x |%R) \o X]. -Proof. -move=> e0 mf f0 f_nd; rewrite -(setTI [set _ | _]). -apply: (le_trans (@le_integral_comp_abse _ _ _ P _ measurableT (EFin \o X) - eps (er_map f) _ _ _ _ e0)) => //=. -- exact: measurable_er_map. -- by case => //= r _; exact: f0. -- move=> [x| |] [y| |]; rewrite !inE/= !in_itv/= ?andbT ?lee_fin ?leey//. - by move=> ? ? ?; rewrite f_nd. -- exact/measurable_EFinP. -- by rewrite unlock. -Qed. - -Lemma chernoff (X : {RV P >-> R}) (r a : R) : (0 < r)%R -> - P [set x | X x >= a]%R <= 'M_P X r * (expR (- (r * a)))%:E. -Proof. -move=> t0; rewrite /mmt_gen_fun. -have -> : expR \o r \o* X = (normr \o normr) \o (expR \o r \o* X). - by apply: funext => t /=; rewrite normr_id ger0_norm ?expR_ge0. -rewrite expRN lee_pdivlMr ?expR_gt0//. -rewrite (le_trans _ (markov _ (expR_gt0 (r * a)) _ _ _))//; last first. - exact: (monoW_in (@ger0_le_norm _)). -rewrite ger0_norm ?expR_ge0// muleC lee_pmul2l// ?lte_fin ?expR_gt0//. -rewrite [X in _ <= P X](_ : _ = [set x | a <= X x]%R)//; apply: eq_set => t/=. -by rewrite ger0_norm ?expR_ge0// lee_fin ler_expR mulrC ler_pM2r. -Qed. - -Lemma chebyshev (X : {RV P >-> R}) (eps : R) : (0 < eps)%R -> - P [set x | (eps <= `| X x - fine ('E_P[X])|)%R ] <= (eps ^- 2)%:E * 'V_P[X]. -Proof. -move => heps; have [->|hv] := eqVneq 'V_P[X] +oo. - by rewrite mulr_infty gtr0_sg ?mul1e// ?leey// invr_gt0// exprn_gt0. -have h (Y : {RV P >-> R}) : - P [set x | (eps <= `|Y x|)%R] <= (eps ^- 2)%:E * 'E_P[Y ^+ 2]. - rewrite -lee_pdivrMl; last by rewrite invr_gt0// exprn_gt0. - rewrite exprnN expfV exprz_inv opprK -exprnP. - apply: (@le_trans _ _ ('E_P[(@GRing.exp R ^~ 2%N \o normr) \o Y])). - apply: (@markov Y (@GRing.exp R ^~ 2%N)) => //. - - by move=> r _; exact: sqr_ge0. - - move=> x y; rewrite !nnegrE => x0 y0. - by rewrite ler_sqr. - apply: expectation_le. - - by apply: measurableT_comp => //; exact: measurableT_comp. - - by []. - - by move=> x /=; exact: sqr_ge0. - - by move=> x /=; exact: sqr_ge0. - - by apply/aeW => t /=; rewrite real_normK// num_real. -have := h (X \- cst (fine ('E_P[X])))%R. -by move=> /le_trans; apply; rewrite /variance [in leRHS]unlock. -Qed. - -Lemma cantelli (X : {RV P >-> R}) (lambda : R) : - (X : T -> R) \in Lfun P 2%:E -> (0 < lambda)%R -> - P [set x | lambda%:E <= (X x)%:E - 'E_P[X]] - <= (fine 'V_P[X] / (fine 'V_P[X] + lambda^2))%:E. -Proof. -move=> /[dup] X2. -move=> /(Lfun_subset12 (fin_num_measure P _ measurableT)) X1 lambda_gt0. -have finEK : (fine 'E_P[X])%:E = 'E_P[X] by rewrite fineK ?expectation_fin_num. -have finVK : (fine 'V_P[X])%:E = 'V_P[X] by rewrite fineK ?variance_fin_num. -pose Y := (X \- cst (fine 'E_P[X]))%R. -have Y2 : (Y : T -> R) \in Lfun P 2%:E. - by rewrite /Y rpredB ?lee1n//= => _; rewrite Lfun_cst. -have EY : 'E_P[Y] = 0. - rewrite expectationB ?Lfun_cst//= expectation_cst. - by rewrite finEK subee// expectation_fin_num. -have VY : 'V_P[Y] = 'V_P[X] by rewrite varianceB_cst_r. -have le (u : R) : (0 <= u)%R -> - P [set x | lambda%:E <= (X x)%:E - 'E_P[X]] - <= ((fine 'V_P[X] + u^2) / (lambda + u)^2)%:E. - move=> uge0; rewrite EFinM. - have -> : (fine 'V_P[X] + u^2)%:E = 'E_P[(Y \+ cst u)^+2]%R. - rewrite -VY -[RHS](@subeK _ _ (('E_P[(Y \+ cst u)%R])^+2)); last first. - rewrite fin_numX// expectation_fin_num//= rpredD ?Lfun_cst//. - by rewrite rpredB// Lfun_cst. - rewrite -varianceE/=; last first. - by rewrite rpredD ?lee1n//= => _; rewrite Lfun_cst. - rewrite -expe2 expectationD/= ?Lfun_cst//; last by rewrite rpredB ?Lfun_cst. - rewrite EY// add0e expectation_cst -EFinM. - by rewrite (varianceD_cst_r _ Y2) EFinD fineK ?variance_fin_num. - have le : [set x | lambda%:E <= (X x)%:E - 'E_P[X]] - `<=` [set x | ((lambda + u)^2)%:E <= ((Y x + u)^+2)%:E]. - move=> x /= le; rewrite lee_fin; apply: lerXn2r. - - exact: addr_ge0 (ltW lambda_gt0) _. - - apply/(addr_ge0 _ uge0)/(le_trans (ltW lambda_gt0) _). - by rewrite -lee_fin EFinB finEK. - - by rewrite lerD2r -lee_fin EFinB finEK. - apply: (le_trans (le_measure _ _ _ le)). - - rewrite -[[set _ | _]]setTI inE; apply: emeasurable_fun_c_infty => [//|]. - apply: emeasurable_funB=> //. - by move/Lfun1_integrable : X1 => /measurable_int. - - rewrite -[[set _ | _]]setTI inE; apply: emeasurable_fun_c_infty => [//|]. - rewrite measurable_EFinP [X in measurable_fun _ X](_ : _ = - (fun x => x ^+ 2) \o (fun x => Y x + u))%R//. - by apply/measurableT_comp => //; exact/measurable_funD. - set eps := ((lambda + u) ^ 2)%R. - have peps : (0 < eps)%R by rewrite exprz_gt0 ?ltr_wpDr. - rewrite (lee_pdivlMr _ _ peps) muleC. - under eq_set => x. - rewrite -[leRHS]gee0_abs ?lee_fin ?sqr_ge0 -?lee_fin => [|//]. - rewrite -[(_ ^+ 2)%R]/(((Y \+ cst u) ^+ 2) x)%R; over. - rewrite -[X in X%:E * _]gtr0_norm => [|//]. - apply: (le_trans (markov _ peps _ _ _)) => //=. - by move=> x y /[!nnegrE] /ger0_norm-> /ger0_norm->. - rewrite -/Y le_eqVlt; apply/orP; left; apply/eqP; congr expectation. - by apply/funeqP => x /=; rewrite -expr2 normr_id ger0_norm ?sqr_ge0. -pose u0 := (fine 'V_P[X] / lambda)%R. -have u0ge0 : (0 <= u0)%R. - by apply: divr_ge0 (ltW lambda_gt0); rewrite -lee_fin finVK variance_ge0. -apply: le_trans (le _ u0ge0) _; rewrite lee_fin le_eqVlt; apply/orP; left. -rewrite eqr_div; [|apply: lt0r_neq0..]; last 2 first. -- by rewrite exprz_gt0 -1?[ltLHS]addr0 ?ltr_leD. -- by rewrite ltr_wpDl ?fine_ge0 ?variance_ge0 ?exprz_gt0. -apply/eqP; have -> : fine 'V_P[X] = (u0 * lambda)%R. - by rewrite /u0 -mulrA mulVf ?mulr1 ?gt_eqF. -by rewrite -mulrDl -mulrDr (addrC u0) [in RHS](mulrAC u0) -exprnP expr2 !mulrA. -Qed. - -End markov_chebyshev_cantelli. - -HB.mixin Record MeasurableFun_isDiscrete d d' (T : measurableType d) - (T' : measurableType d') (X : T -> T') of @MeasurableFun d d' T T' X := { - countable_range : countable (range X) -}. - -HB.structure Definition discreteMeasurableFun d d' (T : measurableType d) - (T' : measurableType d') := { - X of isMeasurableFun d d' T T' X & MeasurableFun_isDiscrete d d' T T' X -}. - -Notation "{ 'dmfun' aT >-> T }" := - (@discreteMeasurableFun.type _ _ aT T) : form_scope. - -Definition discrete_random_variable d d' (T : measurableType d) - (T' : measurableType d') (R : realType) (P : probability T R) := - {dmfun T >-> T'}. - -Notation "{ 'dRV' P >-> T }" := - (@discrete_random_variable _ _ _ T _ P) : form_scope. - -Section dRV_definitions. -Context {d} {d'} {T : measurableType d} {T' : measurableType d'} {R : realType} - (P : probability T R). - -Lemma dRV_dom_enum (X : {dRV P >-> T'}) : - { B : set nat & {splitbij B >-> range X}}. -Proof. -have /countable_bijP/cid[B] := @countable_range _ _ _ _ X. -move/card_esym/ppcard_eqP/unsquash => f. -exists B; exact: f. -Qed. - -Definition dRV_dom (X : {dRV P >-> T'}) : set nat := projT1 (dRV_dom_enum X). - -Definition dRV_enum (X : {dRV P >-> T'}) : {splitbij (dRV_dom X) >-> range X} := - projT2 (dRV_dom_enum X). - -Definition enum_prob (X : {dRV P >-> T'}) := - (fun k => P (X @^-1` [set dRV_enum X k])) \_ (dRV_dom X). - -End dRV_definitions. - -Section distribution_dRV. -Local Open Scope ereal_scope. -Context d d' (T : measurableType d) (T' : measurableType d') (R : realType) - (P : probability T R). -Variable X : {dRV P >-> T'}. - -Lemma distribution_dRV_enum (n : nat) : n \in dRV_dom X -> - distribution P X [set dRV_enum X n] = enum_prob X n. -Proof. -by move=> nX; rewrite /distribution/= /enum_prob/= patchE nX. -Qed. - -Hypothesis measurable_set1T' : forall x : T', measurable [set x]. - -Lemma distribution_dRV A : measurable A -> - distribution P X A = \sum_(k mA; rewrite /distribution /pushforward. -have mAX i : dRV_dom X i -> measurable (X @^-1` (A `&` [set dRV_enum X i])). - move=> domXi; rewrite preimage_setI. - by apply: measurableI; rewrite //-[X in _ X]setTI; exact/measurable_funP. -have tAX : trivIset (dRV_dom X) (fun k => X @^-1` (A `&` [set dRV_enum X k])). - under eq_fun do rewrite preimage_setI; rewrite -/(trivIset _ _). - apply: trivIset_setIl; apply/trivIsetP => i j iX jX /eqP ij. - rewrite -preimage_setI (_ : _ `&` _ = set0)//. - by apply/seteqP; split => //= x [] -> {x} /inj; rewrite inE inE => /(_ iX jX). -have := measure_bigcup P _ (fun k => X @^-1` (A `&` [set dRV_enum X k])) mAX tAX. -rewrite -preimage_bigcup => {mAX tAX}PXU. -rewrite -{1}(setIT A) -(setUv (\bigcup_(i in dRV_dom X) [set dRV_enum X i])). -rewrite setIUr preimage_setU measureU; last 3 first. - - by rewrite preimage_setI; apply: measurableI; rewrite //-[X in _ X]setTI; - apply/measurable_funP => //; exact: bigcup_measurable. - - by rewrite preimage_setI; apply: measurableI; rewrite //-[X in _ X]setTI; - apply/measurable_funP => //; apply: measurableC; exact: bigcup_measurable. - - by rewrite -preimage_setI -setIIr setIA setICK preimage_set0. -rewrite [X in _ + X = _](_ : _ = 0) ?adde0; last first. - rewrite (_ : _ @^-1` _ = set0) ?measure0//; apply/disjoints_subset => x AXx. - rewrite setCK /bigcup /=; exists ((dRV_enum X)^-1 (X x))%function. - exact: funS. - by rewrite invK// inE. -rewrite setI_bigcupr; etransitivity; first exact: PXU. -rewrite eseries_mkcond; apply: eq_eseriesr => k _. -rewrite /enum_prob patchE; case: ifPn => nX; rewrite ?mul0e//. -rewrite diracE; have [kA|] := boolP (_ \in A). - by rewrite mule1 setIidr// => _ /= ->; exact: set_mem. -rewrite notin_setE => kA. -rewrite mule0 (disjoints_subset _ _).2 ?preimage_set0 ?measure0//. -by apply: subsetCr; rewrite sub1set inE. -Qed. - -Lemma sum_enum_prob : \sum_(n /esym; apply: eq_trans. -by rewrite [RHS]eseries_mkcond; apply: eq_eseriesr => k _; rewrite diracT mule1. -Qed. - -End distribution_dRV. - -Section discrete_distribution. -Local Open Scope ereal_scope. -Context d (T : measurableType d) (R : realType) (P : probability T R). - -Lemma dRV_expectation (X : {dRV P >-> R}) : - P.-integrable [set: T] (EFin \o X) -> - 'E_P[X] = \sum_(n ix; rewrite unlock. -rewrite -[in LHS](_ : \bigcup_k (if k \in dRV_dom X then - X @^-1` [set dRV_enum X k] else set0) = setT); last first. - apply/seteqP; split => // t _. - exists ((dRV_enum X)^-1%function (X t)) => //. - case: ifPn=> [_|]. - by rewrite invK// inE. - by rewrite notin_setE/=; apply; apply: funS. -have tA : trivIset (dRV_dom X) (fun k => [set dRV_enum X k]). - by move=> i j iX jX [r [/= ->{r}]] /inj; rewrite !inE; exact. -have {tA}/trivIset_mkcond tXA : - trivIset (dRV_dom X) (fun k => X @^-1` [set dRV_enum X k]). - apply/trivIsetP => /= i j iX jX ij. - move/trivIsetP : tA => /(_ i j iX jX) Aij. - by rewrite -preimage_setI Aij ?preimage_set0. -rewrite integral_bigcup //; last 2 first. - - by move=> k; case: ifPn. - - apply: (integrableS measurableT) => //. - by rewrite -bigcup_mkcond; exact: bigcup_measurable. -transitivity (\sum_(i i _; case: ifPn => iX. - by apply: eq_integral => t; rewrite in_setE/= => ->. - by rewrite !integral_set0. -transitivity (\sum_(i i _; rewrite -integralZl//; last 2 first. - - by case: ifPn. - - apply/integrableP; split => //. - rewrite (eq_integral (cst 1%E)); last by move=> x _; rewrite abse1. - rewrite integral_cst//; last by case: ifPn. - rewrite mul1e (@le_lt_trans _ _ 1%E) ?ltey//. - by case: ifPn => // _; exact: probability_le1. - by apply: eq_integral => y _; rewrite mule1. -apply: eq_eseriesr => k _; case: ifPn => kX. - rewrite /= integral_cst//= mul1e probability_distribution muleC. - by rewrite distribution_dRV_enum. -by rewrite integral_set0 mule0 /enum_prob patchE (negbTE kX) mul0e. -Qed. - -Definition pmf (X : {RV P >-> R}) (r : R) : R := fine (P (X @^-1` [set r])). - -Lemma expectation_pmf (X : {dRV P >-> R}) : - P.-integrable [set: T] (EFin \o X) -> 'E_P[X] = - \sum_(n iX; rewrite dRV_expectation// [in RHS]eseries_mkcond. -apply: eq_eseriesr => k _. -rewrite /enum_prob patchE; case: ifPn => kX; last by rewrite mul0e. -by rewrite /pmf fineK// fin_num_measure. -Qed. - -End discrete_distribution. - -Section bernoulli_pmf. -Context {R : realType} (p : R). -Local Open Scope ring_scope. - -Definition bernoulli_pmf b := if b then p else 1 - p. - -Lemma bernoulli_pmf_ge0 (p01 : 0 <= p <= 1) b : 0 <= bernoulli_pmf b. -Proof. -rewrite /bernoulli_pmf. -by move: p01 => /andP[p0 p1]; case: ifPn => // _; rewrite subr_ge0. -Qed. - -Lemma bernoulli_pmf1 (p01 : 0 <= p <= 1) : - \sum_(i \in [set: bool]) (bernoulli_pmf i)%:E = 1%E. -Proof. -rewrite setT_bool fsbigU//=; last by move=> x [/= ->]. -by rewrite !fsbig_set1/= -EFinD addrCA subrr addr0. -Qed. - -End bernoulli_pmf. - -Lemma measurable_bernoulli_pmf {R : realType} D n : - measurable_fun D (@bernoulli_pmf R ^~ n). -Proof. -by apply/measurable_funTS/measurable_fun_if => //=; exact: measurable_funB. -Qed. - -Definition bernoulli {R : realType} (p : R) : set bool -> \bar R := fun A => - if (0 <= p <= 1)%R then \sum_(b \in A) (bernoulli_pmf p b)%:E else \d_false A. - -Section bernoulli. -Context {R : realType} (p : R). - -Local Notation bernoulli := (bernoulli p). - -Let bernoulli0 : bernoulli set0 = 0. -Proof. -by rewrite /bernoulli; case: ifPn => // p01; rewrite fsbig_set0. -Qed. - -Let bernoulli_ge0 U : (0 <= bernoulli U)%E. -Proof. -rewrite /bernoulli; case: ifPn => // p01. -rewrite fsbig_finite//= sumEFin lee_fin. -by apply: sumr_ge0 => /= b _; exact: bernoulli_pmf_ge0. -Qed. - -Let bernoulli_sigma_additive : semi_sigma_additive bernoulli. -Proof. -move=> F mF tF mUF; rewrite /bernoulli; case: ifPn => p01; last first. - exact: measure_semi_sigma_additive. -apply: cvg_toP. - apply: ereal_nondecreasing_is_cvgn => m n mn. - apply: lee_sum_nneg_natr => // k _ _. - rewrite fsbig_finite//= sumEFin lee_fin. - by apply: sumr_ge0 => /= b _; exact: bernoulli_pmf_ge0. -transitivity (\sum_(0 <= i k _; rewrite esum_fset//= => b _. - by rewrite lee_fin bernoulli_pmf_ge0. -rewrite -nneseries_sum_bigcup//=; last first. - by move=> b; rewrite lee_fin bernoulli_pmf_ge0. -by rewrite esum_fset//= => b _; rewrite lee_fin bernoulli_pmf_ge0. -Qed. - -HB.instance Definition _ := isMeasure.Build _ _ _ bernoulli - bernoulli0 bernoulli_ge0 bernoulli_sigma_additive. - -Let bernoulli_setT : bernoulli [set: _] = 1%E. -Proof. -rewrite /bernoulli/=; case: ifPn => p01; last by rewrite probability_setT. -by rewrite bernoulli_pmf1. -Qed. - -HB.instance Definition _ := - @Measure_isProbability.Build _ _ R bernoulli bernoulli_setT. - -Lemma eq_bernoulli (P : probability bool R) : - P [set true] = p%:E -> P =1 bernoulli. -Proof. -move=> Ptrue sb; rewrite /bernoulli /bernoulli_pmf. -have Pfalse: P [set false] = (1 - p%:E)%E. - rewrite -Ptrue -(probability_setT P) setT_bool measureU//; last first. - by rewrite disjoints_subset => -[]//. - by rewrite addeAC subee ?add0e//= Ptrue. -have: (0 <= p%:E <= 1)%E by rewrite -Ptrue measure_ge0 probability_le1. -rewrite !lee_fin => ->. -have eq_sb := etrans (bigcup_imset1 (_ : set bool) id) (image_id _). -rewrite -[in LHS](eq_sb sb)/= measure_fin_bigcup//; last 2 first. -- exact: finite_finset. -- by move=> [] [] _ _ [[]]//= []. -- by apply: eq_fsbigr => /= -[]. -Qed. - -End bernoulli. - -Section bernoulli_measure. -Context {R : realType}. -Variables (p : R) (p0 : (0 <= p)%R) (p1 : ((NngNum p0)%:num <= 1)%R). - -Lemma bernoulli_dirac : bernoulli p = measure_add - (mscale (NngNum p0) \d_true) (mscale (1 - (Itv01 p0 p1)%:num)%:nng \d_false). -Proof. -apply/funext => U; rewrite /bernoulli; case: ifPn => [p01|]; last first. - by rewrite p0/= p1. -rewrite measure_addE/= /mscale/=. -have := @subsetT _ U; rewrite setT_bool => UT. -have [->|->|->|->] /= := subset_set2 UT. -- rewrite -esum_fset//=; last by move=> b; rewrite lee_fin bernoulli_pmf_ge0. - by rewrite esum_set0 2!measure0 2!mule0 adde0. -- rewrite -esum_fset//=; last by move=> b; rewrite lee_fin bernoulli_pmf_ge0. - rewrite esum_set1/= ?lee_fin// 2!diracE mem_set//= memNset//= mule0 adde0. - by rewrite mule1. -- rewrite -esum_fset//=; last by move=> b; rewrite lee_fin bernoulli_pmf_ge0. - rewrite esum_set1/= ?lee_fin ?subr_ge0// 2!diracE memNset//= mem_set//=. - by rewrite mule0 add0e mule1. -- rewrite fsbigU//=; last by move=> x [->]. - by rewrite 2!fsbig_set1/= -setT_bool 2!diracT !mule1. -Qed. - -End bernoulli_measure. -Arguments bernoulli {R}. - -Lemma eq_bernoulliV2 {R : realType} (P : probability bool R) : - P [set true] = P [set false] -> P =1 bernoulli 2^-1. -Proof. -move=> Ptrue_eq_false; apply/eq_bernoulli. -have : P [set: bool] = 1%E := probability_setT P. -rewrite setT_bool measureU//=; last first. - by rewrite disjoints_subset => -[]//. -rewrite Ptrue_eq_false -mule2n; move/esym/eqP. -by rewrite -mule_natl -eqe_pdivrMl// mule1 => /eqP<-. -Qed. - -Section integral_bernoulli. -Context {R : realType}. -Variables (p : R) (p01 : (0 <= p <= 1)%R). -Local Open Scope ereal_scope. - -Lemma bernoulliE A : bernoulli p A = p%:E * \d_true A + (`1-p)%:E * \d_false A. -Proof. by case/andP : p01 => p0 p1; rewrite bernoulli_dirac// measure_addE. Qed. - -Lemma integral_bernoulli (f : bool -> \bar R) : (forall x, 0 <= f x) -> - \int[bernoulli p]_y (f y) = p%:E * f true + (`1-p)%:E * f false. -Proof. -move=> f0; case/andP : p01 => p0 p1; rewrite bernoulli_dirac/=. -rewrite ge0_integral_measure_sum// 2!big_ord_recl/= big_ord0 adde0/=. -by rewrite !ge0_integral_mscale//= !integral_dirac//= !diracT !mul1e. -Qed. - -End integral_bernoulli. - -Section measurable_bernoulli. -Local Open Scope ring_scope. -Variable R : realType. -Implicit Type p : R. - -Lemma measurable_bernoulli : - measurable_fun setT (bernoulli : R -> pprobability bool R). -Proof. -apply: (measurability (@pset _ _ _ : set (set (pprobability _ R)))) => //. -move=> _ -[_ [r r01] [Ys mYs <-]] <-; apply: emeasurable_fun_infty_o => //=. -apply: measurable_fun_if => //=. - by apply: measurable_and => //; exact: measurable_fun_ler. -apply: (eq_measurable_fun (fun t => - \sum_(b <- fset_set Ys) (bernoulli_pmf t b)%:E)). - move=> x /set_mem[_/= x01]. - by rewrite fsbig_finite//=. -apply: emeasurable_sum => n; move=> k Ysk; apply/measurableT_comp => //. -exact: measurable_bernoulli_pmf. -Qed. - -Lemma measurable_bernoulli2 U : measurable U -> - measurable_fun setT (bernoulli ^~ U : R -> \bar R). -Proof. -by move=> ?; exact: (measurable_kernel (kprobability measurable_bernoulli)). -Qed. - -End measurable_bernoulli. -Arguments measurable_bernoulli {R}. - -Section binomial_pmf. -Local Open Scope ring_scope. -Context {R : realType} (n : nat) (p : R). - -Definition binomial_pmf k := p ^+ k * (`1-p) ^+ (n - k) *+ 'C(n, k). - -Lemma binomial_pmf_ge0 k (p01 : (0 <= p <= 1)%R) : 0 <= binomial_pmf k. -Proof. -move: p01 => /andP[p0 p1]; rewrite mulrn_wge0// mulr_ge0// ?exprn_ge0//. -exact: onem_ge0. -Qed. - -End binomial_pmf. - -Lemma measurable_binomial_pmf {R : realType} D n k : - measurable_fun D (@binomial_pmf R n ^~ k). -Proof. -apply: (@measurableT_comp _ _ _ _ _ _ (fun x : R => x *+ 'C(n, k))%R) => /=. - exact: natmul_measurable. -by apply: measurable_funM => //; apply: measurable_funX; exact: measurable_funB. -Qed. - -Definition binomial_prob {R : realType} (n : nat) (p : R) : set nat -> \bar R := - fun U => if (0 <= p <= 1)%R then - \esum_(k in U) (binomial_pmf n p k)%:E else \d_0%N U. - -Section binomial. -Context {R : realType} (n : nat) (p : R). -Local Open Scope ereal_scope. - -Local Notation binomial := (binomial_prob n p). - -Let binomial0 : binomial set0 = 0. -Proof. by rewrite /binomial measure0; case: ifPn => //; rewrite esum_set0. Qed. - -Let binomial_ge0 U : 0 <= binomial U. -Proof. -rewrite /binomial; case: ifPn => // p01; apply: esum_ge0 => /= k Uk. -by rewrite lee_fin binomial_pmf_ge0. -Qed. - -Let binomial_sigma_additive : semi_sigma_additive binomial. -Proof. -move=> F mF tF mUF; rewrite /binomial; case: ifPn => p01; last first. - exact: measure_semi_sigma_additive. -apply: cvg_toP. - apply: ereal_nondecreasing_is_cvgn => a b ab. - apply: lee_sum_nneg_natr => // k _ _. - by apply: esum_ge0 => /= ? _; exact: binomial_pmf_ge0. -by rewrite nneseries_sum_bigcup// => i; rewrite lee_fin binomial_pmf_ge0. -Qed. - -HB.instance Definition _ := isMeasure.Build _ _ _ binomial - binomial0 binomial_ge0 binomial_sigma_additive. - -Let binomial_setT : binomial [set: _] = 1. -Proof. -rewrite /binomial; case: ifPn; last by move=> _; rewrite probability_setT. -move=> p01; rewrite /binomial_pmf. -have pkn k : 0%R <= (p ^+ k * `1-p ^+ (n - k) *+ 'C(n, k))%:E. - case/andP : p01 => p0 p1. - by rewrite lee_fin mulrn_wge0// mulr_ge0 ?exprn_ge0 ?subr_ge0. -rewrite (esumID `I_n.+1)// [X in _ + X]esum1 ?adde0; last first. - by move=> /= k [_ /negP]; rewrite -leqNgt => nk; rewrite bin_small. -rewrite setTI esum_fset// -fsbig_ord//=. -under eq_bigr do rewrite mulrC. -rewrite sumEFin -exprDn_comm; last exact: mulrC. -by rewrite addrC add_onemK expr1n. -Qed. - -HB.instance Definition _ := - @Measure_isProbability.Build _ _ R binomial binomial_setT. - -End binomial. - -Section binomial_probability. -Local Open Scope ring_scope. -Context {R : realType} (n : nat) (p : R) - (p0 : (0 <= p)%R) (p1 : ((NngNum p0)%:num <= 1)%R). - -Definition bin_prob (k : nat) : {nonneg R} := - ((NngNum p0)%:num ^+ k * (NngNum (onem_ge0 p1))%:num ^+ (n - k)%N *+ 'C(n, k))%:nng. - -Lemma bin_prob0 : bin_prob 0 = ((NngNum (onem_ge0 p1))%:num^+n)%:nng. -Proof. -rewrite /bin_prob bin0 subn0/=; apply/val_inj => /=. -by rewrite expr0 mul1r mulr1n. -Qed. - -Lemma bin_prob1 : bin_prob 1 = - ((NngNum p0)%:num * (NngNum (onem_ge0 p1))%:num ^+ n.-1 *+ n)%:nng. -Proof. -by rewrite /bin_prob bin1/=; apply/val_inj => /=; rewrite expr1 subn1. -Qed. - -Lemma binomial_msum : - binomial_prob n p = msum (fun k => mscale (bin_prob k) \d_k) n.+1. -Proof. -apply/funext => U. -rewrite /binomial_prob; case: ifPn => [_|]; last by rewrite p1 p0. -rewrite /msum/= /mscale/= /binomial_pmf. -have pkn k : (0%R <= (p ^+ k * `1-p ^+ (n - k) *+ 'C(n, k))%:E)%E. - by rewrite lee_fin mulrn_wge0// mulr_ge0 ?exprn_ge0 ?subr_ge0. -rewrite (esumID `I_n.+1)//= [X in _ + X]esum1 ?adde0; last first. - by move=> /= k [_ /negP]; rewrite -leqNgt => nk; rewrite bin_small. -rewrite esum_mkcondl esum_fset//; last by move=> i /= _; case: ifPn. -rewrite -fsbig_ord//=; apply: eq_bigr => i _. -by rewrite diracE; case: ifPn => /= iU; [rewrite mule1|rewrite mule0]. -Qed. - -Lemma binomial_probE U : binomial_prob n p U = - (\sum_(k < n.+1) (bin_prob k)%:num%:E * (\d_(nat_of_ord k) U))%E. -Proof. by rewrite binomial_msum. Qed. - -Lemma integral_binomial (f : nat -> \bar R) : (forall x, 0 <= f x)%E -> - (\int[binomial_prob n p]_y (f y) = - \sum_(k < n.+1) (bin_prob k)%:num%:E * f k)%E. -Proof. -move=> f0; rewrite binomial_msum ge0_integral_measure_sum//=. -apply: eq_bigr => i _. -by rewrite ge0_integral_mscale//= integral_dirac//= diracT mul1e. -Qed. - -End binomial_probability. - -Lemma integral_binomial_prob (R : realType) n p U : (0 <= p <= 1)%R -> - (\int[binomial_prob n p]_y \d_(0 < y)%N U = - bernoulli (1 - `1-p ^+ n) U :> \bar R)%E. -Proof. -move=> /andP[p0 p1]; rewrite bernoulliE//=; last first. - rewrite subr_ge0 exprn_ile1//=; [|exact/onem_ge0|exact/onem_le1]. - by rewrite lerBlDr addrC -lerBlDr subrr; exact/exprn_ge0/onem_ge0. -rewrite (@integral_binomial _ n p _ _ (fun y => \d_(1 <= y)%N U))//. -rewrite !big_ord_recl/=. -rewrite expr0 mul1r subn0 bin0 ltnn mulr1n addrC. -rewrite onemD opprK onem1 add0r; congr +%E. -rewrite /bump; under eq_bigr do rewrite leq0n add1n ltnS leq0n. -rewrite -ge0_sume_distrl; last first. - move=> i _. - by apply/mulrn_wge0/mulr_ge0; apply/exprn_ge0 => //; exact/onem_ge0. -congr *%E. -transitivity (\sum_(i < n.+1) (`1-p ^+ (n - i) * p ^+ i *+ 'C(n, i))%:E - - (`1-p ^+ n)%:E)%E. - rewrite big_ord_recl/=. - rewrite expr0 mulr1 subn0 bin0 mulr1n addrAC -EFinD subrr add0e. - by rewrite /bump; under [RHS]eq_bigr do rewrite leq0n add1n mulrC. -rewrite sumEFin -(@exprDn_comm _ `1-p p n)//. - by rewrite subrK expr1n. -by rewrite /GRing.comm/onem mulrC. -Qed. - -Lemma measurable_binomial_prob (R : realType) (n : nat) : - measurable_fun setT (binomial_prob n : R -> pprobability _ _). -Proof. -apply: (measurability (@pset _ _ _ : set (set (pprobability _ R)))) => //. -move=> _ -[_ [r r01] [Ys mYs <-]] <-; apply: emeasurable_fun_infty_o => //=. -apply: measurable_fun_if => //=. - by apply: measurable_and => //; exact: measurable_fun_ler. -apply: (eq_measurable_fun (fun t => - \sum_(k x /set_mem[_/= x01]. - rewrite nneseries_esum//; last by move=> *; rewrite lee_fin binomial_pmf_ge0. - by rewrite set_mem_set. -apply: ge0_emeasurable_sum. - by move=> k x/= [_ x01] _; rewrite lee_fin binomial_pmf_ge0. -by move=> k Ysk; apply/measurableT_comp => //; exact: measurable_binomial_pmf. -Qed. - -Section uniform_probability. -Local Open Scope ring_scope. -Context (R : realType) (a b : R). - -Definition uniform_pdf x := if a <= x <= b then (b - a)^-1 else 0. - -Lemma uniform_pdf_ge0 x : a < b -> 0 <= uniform_pdf x. -Proof. -move=> ab; rewrite /uniform_pdf; case: ifPn => // axb. -by rewrite invr_ge0// ltW// subr_gt0. -Qed. - -Lemma measurable_uniform_pdf : measurable_fun setT uniform_pdf. -Proof. -rewrite /uniform_pdf /=; apply: measurable_fun_if => //=. -by apply: measurable_and => //; exact: measurable_fun_ler. -Qed. - -Local Notation mu := lebesgue_measure. - -Lemma integral_uniform_pdf U : - (\int[mu]_(x in U) (uniform_pdf x)%:E = - \int[mu]_(x in U `&` `[a, b]) (uniform_pdf x)%:E)%E. -Proof. -rewrite [RHS]integral_mkcondr/=; apply: eq_integral => x xU. -rewrite patchE; case: ifPn => //. -rewrite notin_setE/= in_itv/= => /negP/negbTE xab. -by rewrite /uniform_pdf xab. -Qed. - -Lemma integral_uniform_pdf1 A (ab : a < b) : `[a, b] `<=` A -> - (\int[mu]_(x in A) (uniform_pdf x)%:E = 1)%E. -Proof. -move=> abA; rewrite integral_uniform_pdf setIidr//. -rewrite (eq_integral (fun=> (b - a)^-1%:E)); last first. - by move=> x; rewrite inE/= in_itv/= /uniform_pdf => ->. -rewrite integral_cst//= lebesgue_measure_itv/= lte_fin. -by rewrite ab -EFinD -EFinM mulVf// gt_eqF// subr_gt0. -Qed. - -Definition uniform_prob (ab : a < b) : set _ -> \bar R := - fun U => (\int[mu]_(x in U) (uniform_pdf x)%:E)%E. - -Hypothesis ab : (a < b)%R. - -Let uniform0 : uniform_prob ab set0 = 0. -Proof. by rewrite /uniform_prob integral_set0. Qed. - -Let uniform_ge0 U : (0 <= uniform_prob ab U)%E. -Proof. -by apply: integral_ge0 => /= x Ux; rewrite lee_fin uniform_pdf_ge0. -Qed. - -Lemma integrable_uniform_pdf : - mu.-integrable setT (fun x => (uniform_pdf x)%:E). -Proof. -apply/integrableP; split. - by apply: measurableT_comp => //; exact: measurable_uniform_pdf. -under eq_integral. - move=> x _; rewrite gee0_abs//; last by rewrite lee_fin uniform_pdf_ge0. - over. -by rewrite /= integral_uniform_pdf1 ?ltry// -subr_gt0. -Qed. - -Let uniform_sigma_additive : semi_sigma_additive (uniform_prob ab). -Proof. -move=> /= F mF tF mUF; rewrite /uniform_prob; apply: cvg_toP. - apply: ereal_nondecreasing_is_cvgn => m n mn. - apply: lee_sum_nneg_natr => // k _ _. - by apply: integral_ge0 => /= x Fkx; rewrite lee_fin uniform_pdf_ge0. -rewrite ge0_integral_bigcup//=. -- apply: measurable_funTS; apply: measurableT_comp => //. - exact: measurable_uniform_pdf. -- by move=> x _; rewrite lee_fin uniform_pdf_ge0. -Qed. - -HB.instance Definition _ := isMeasure.Build _ _ _ (uniform_prob ab) - uniform0 uniform_ge0 uniform_sigma_additive. - -Let uniform_setT : uniform_prob ab [set: _] = 1%:E. -Proof. by rewrite /uniform_prob /mscale/= integral_uniform_pdf1. Qed. - -HB.instance Definition _ := @Measure_isProbability.Build _ _ R - (uniform_prob ab) uniform_setT. - -Lemma dominates_uniform_prob : uniform_prob ab `<< mu. -Proof. -move=> A mA muA0; rewrite /uniform_prob integral_uniform_pdf. -apply/eqP; rewrite eq_le; apply/andP; split; last first. - apply: integral_ge0 => x [Ax /=]; rewrite in_itv /= => xab. - by rewrite lee_fin uniform_pdf_ge0. -apply: (@le_trans _ _ - (\int[mu]_(x in A `&` `[a, b]%classic) (b - a)^-1%:E))%E; last first. - rewrite integral_cst//= ?mul1e//. - by rewrite pmule_rle0 ?lte_fin ?invr_gt0// ?subr_gt0// -muA0 measureIl. - exact: measurableI. -apply: ge0_le_integral => //=. -- exact: measurableI. -- by move=> x [Ax]; rewrite /= in_itv/= => axb; rewrite lee_fin uniform_pdf_ge0. -- by apply/measurable_EFinP/measurable_funTS; exact: measurable_uniform_pdf. -- by move=> x [Ax _]; rewrite lee_fin invr_ge0// ltW// subr_gt0. -- by move=> x [Ax]; rewrite in_itv/= /uniform_pdf => ->. -Qed. - -Let integral_uniform_indic E : measurable E -> - (\int[uniform_prob ab]_x (\1_E x)%:E = - (b - a)^-1%:E * \int[mu]_(x in `[a, b]) (\1_E x)%:E)%E. -Proof. -move=> mE; rewrite integral_indic//= /uniform_prob setIT -ge0_integralZl//=. -- rewrite [LHS]integral_mkcond/= [RHS]integral_mkcond/=. - apply: eq_integral => x _; rewrite !patchE; case: ifPn => xE. - case: ifPn. - rewrite inE/= in_itv/= => xab. - by rewrite /uniform_pdf xab indicE xE mule1. - by rewrite notin_setE/= in_itv/= => /negP/negbTE; rewrite /uniform_pdf => ->. - case: ifPn => //. - by rewrite inE/= in_itv/= => axb; rewrite indicE (negbTE xE) mule0. -- exact/measurable_EFinP/measurable_indic. -- by rewrite lee_fin invr_ge0// ltW// subr_gt0. -Qed. - -Import HBNNSimple. - -Let integral_uniform_nnsfun (f : {nnsfun _ >-> R}) : - (\int[uniform_prob ab]_x (f x)%:E = - (b - a)^-1%:E * \int[mu]_(x in `[a, b]) (f x)%:E)%E. -Proof. -under [LHS]eq_integral do rewrite fimfunE -fsumEFin//. -rewrite [LHS]ge0_integral_fsum//; last 2 first. - - by move=> r; exact/measurable_EFinP/measurableT_comp. - - by move=> n x _; rewrite EFinM nnfun_muleindic_ge0. -rewrite -[RHS]ge0_integralZl//; last 3 first. - - exact/measurable_EFinP/measurable_funTS. - - by move=> x _; rewrite lee_fin. - - by rewrite lee_fin invr_ge0// ltW// subr_gt0. -under [RHS]eq_integral. - move=> x xD; rewrite fimfunE -fsumEFin// ge0_mule_fsumr; last first. - by move=> r; rewrite EFinM nnfun_muleindic_ge0. - over. -rewrite [RHS]ge0_integral_fsum//; last 2 first. - - by move=> r; apply/measurable_EFinP; do 2 apply/measurableT_comp => //. - - move=> n x _; rewrite EFinM mule_ge0//; last by rewrite nnfun_muleindic_ge0. - by rewrite lee_fin invr_ge0// ltW// subr_gt0. -apply: eq_fsbigr => r _; rewrite ge0_integralZl//. -- by rewrite !integralZl_indic_nnsfun//= integral_uniform_indic// muleCA. -- exact/measurable_EFinP/measurableT_comp. -- by move=> t _; rewrite nnfun_muleindic_ge0. -- by rewrite lee_fin invr_ge0// ltW// subr_gt0. -Qed. - -Lemma integral_uniform (f : _ -> \bar R) : - measurable_fun setT f -> (forall x, 0 <= f x)%E -> - (\int[uniform_prob ab]_x f x = (b - a)^-1%:E * \int[mu]_(x in `[a, b]) f x)%E. -Proof. -move=> mf f0. -pose f_ := nnsfun_approx measurableT mf. -transitivity (lim (\int[uniform_prob ab]_x (f_ n x)%:E @[n --> \oo])%E). - rewrite -monotone_convergence//=. - - apply: eq_integral => ? /[!inE] xD; apply/esym/cvg_lim => //=. - exact: cvg_nnsfun_approx. - - by move=> n; exact/measurable_EFinP/measurable_funTS. - - by move=> n ? _; rewrite lee_fin. - - by move=> ? _ ? ? mn; rewrite lee_fin; exact/lefP/nd_nnsfun_approx. -rewrite [X in _ = (_ * X)%E](_ : _ = lim - (\int[mu]_(x in `[a, b]) (f_ n x)%:E @[n --> \oo])%E); last first. - rewrite -monotone_convergence//=. - - apply: eq_integral => ? /[!inE] xD; apply/esym/cvg_lim => //. - exact: cvg_nnsfun_approx. - - by move=> n; exact/measurable_EFinP/measurable_funTS. - - by move=> n ? _; rewrite lee_fin. - - by move=> ? _ ? ? ?; rewrite lee_fin; exact/lefP/nd_nnsfun_approx. -rewrite -limeMl//. - by apply: congr_lim; apply/funext => n /=; exact: integral_uniform_nnsfun. -apply/ereal_nondecreasing_is_cvgn => x y xy; apply: ge0_le_integral => //=. -- by move=> ? _; rewrite lee_fin. -- exact/measurable_EFinP/measurable_funTS. -- by move=> ? _; rewrite lee_fin. -- exact/measurable_EFinP/measurable_funTS. -- by move=> ? _; rewrite lee_fin; exact/lefP/nd_nnsfun_approx. -Qed. - -End uniform_probability. - -Section normal_density. -Context {R : realType}. -Local Open Scope ring_scope. -Local Import Num.ExtraDef. -Implicit Types m s x : R. - -Definition normal_fun m s x := expR (- (x - m) ^+ 2 / (s ^+ 2 *+ 2)). - -Lemma measurable_normal_fun m s : measurable_fun [set :R] (normal_fun m s). -Proof. -apply: measurableT_comp => //=; apply: measurable_funM => //=. -apply: measurableT_comp => //=; apply: measurable_funX => //=. -exact: measurable_funB. -Qed. - -Lemma normal_fun_ge0 m s x : 0 <= normal_fun m s x. -Proof. exact: expR_ge0. Qed. - -Lemma normal_fun_center m s : normal_fun m s = normal_fun 0 s \o center m. -Proof. by apply/funext => x/=; rewrite /normal_fun/= subr0. Qed. - -Definition normal_peak s := (sqrtr (s ^+ 2 * pi *+ 2))^-1. - -Lemma normal_peak_ge0 s : 0 <= normal_peak s. Proof. by rewrite invr_ge0. Qed. - -Lemma normal_peak_gt0 s : s != 0 -> 0 < normal_peak s. -Proof. -move=> s0; rewrite invr_gt0// sqrtr_gt0. -by rewrite pmulrn_rgt0// mulr_gt0 ?pi_gt0// exprn_even_gt0/=. -Qed. - -Let normal_pdf0 m s x : R := normal_peak s * normal_fun m s x. - -Definition normal_pdf m s x := - if s == 0 then \1_`[0, 1] x else normal_pdf0 m s x. - -Lemma normal_pdfE m s : s != 0 -> normal_pdf m s = normal_pdf0 m s. -Proof. by rewrite /normal_pdf; have [_|s0] := eqVneq s 0. Qed. - -Let normal_pdf0_center m s : normal_pdf0 m s = normal_pdf0 0 s \o center m. -Proof. by rewrite /normal_pdf0 normal_fun_center. Qed. - -Let normal_pdf0_ge0 m s x : 0 <= normal_pdf0 m s x. -Proof. by rewrite mulr_ge0 ?normal_peak_ge0 ?expR_ge0. Qed. - -Let normal_pdf0_gt0 m s x : s != 0 -> 0 < normal_pdf0 m s x. -Proof. by move=> s0; rewrite mulr_gt0 ?expR_gt0// normal_peak_gt0. Qed. - -Let measurable_normal_pdf0 m s : measurable_fun setT (normal_pdf0 m s). -Proof. by apply: measurable_funM => //=; exact: measurable_normal_fun. Qed. - -Lemma measurable_normal_pdf m s : measurable_fun setT (normal_pdf m s). -Proof. -by rewrite /normal_pdf; have [_|] := eqVneq s 0; first exact: measurable_indic. -Qed. - -Let continuous_normal_pdf0 m s : continuous (normal_pdf0 m s). -Proof. -move=> x; apply: cvgM; first exact: cvg_cst. -apply: (cvg_comp _ expR); last exact: continuous_expR. -apply: cvgM; last exact: cvg_cst. -apply: (@cvgN _ R^o). -apply: (cvg_comp (fun x => x - m) (fun x => x ^+ 2)). - by apply: (@cvgB _ R^o) => //; [exact: cvg_id|exact: cvg_cst]. -exact: sqr_continuous. -Qed. - -Let normal_pdf0_ub m s x : normal_pdf0 m s x <= normal_peak s. -Proof. -rewrite /normal_pdf0 ler_piMr ?normal_peak_ge0//. -rewrite -[leRHS]expR0 ler_expR mulNr oppr_le0 mulr_ge0// ?sqr_ge0//. -by rewrite invr_ge0 mulrn_wge0// sqr_ge0. -Qed. - -Lemma normal_pdf_ge0 m s x : 0 <= normal_pdf m s x. -Proof. by rewrite /normal_pdf; case: ifP. Qed. - -Lemma continuous_normal_pdf m s : s != 0 -> continuous (normal_pdf m s). -Proof. by rewrite /normal_pdf; have [|] := eqVneq s 0. Qed. - -Lemma normal_pdf_ub m s x : s != 0 -> normal_pdf m s x <= normal_peak s. -Proof. by rewrite /normal_pdf; have [|] := eqVneq s 0. Qed. - -End normal_density. - -Definition normal_prob {R : realType} (m : R) (s : R) : set _ -> \bar R := - fun V => (\int[lebesgue_measure]_(x in V) (normal_pdf m s x)%:E)%E. - -Section normal_probability. -Variables (R : realType) (m sigma : R). -Local Open Scope ring_scope. -Notation mu := lebesgue_measure. - -Local Notation normal_peak := (normal_peak sigma). -Local Notation normal_fun := (normal_fun m sigma). - -Let F (x : R^o) := (x - m) / (Num.sqrt (sigma ^+ 2 *+ 2)). - -Let normal_gauss_fun x : normal_fun x = gauss_fun (F x). -Proof. -congr expR; rewrite mulNr exprMn exprVn; congr (- (_ * _^-1)%R). -by rewrite sqr_sqrtr// pmulrn_lge0// sqr_ge0. -Qed. - -Let F'E : F^`()%classic = cst (Num.sqrt (sigma ^+ 2 *+ 2))^-1. -Proof. -apply/funext => x; rewrite /F derive1E deriveM// deriveD// derive_cst scaler0. -by rewrite add0r derive_id derive_cst addr0 scaler1. -Qed. - -Let integral_gaussFF' : sigma != 0 -> - (\int[mu]_x ((((gauss_fun \o F) * - (F^`())%classic) x)%:E * (Num.sqrt (sigma ^+ 2 *+ 2))%:E))%E = - normal_peak^-1%:E. -Proof. -move=> s0; rewrite /normal_peak invrK. -rewrite -mulrnAr -[in RHS]mulr_natr sqrtrM ?(sqrtrM 2) ?sqr_ge0 ?pi_ge0// !EFinM. -rewrite muleCA ge0_integralZr//=; first last. - by move=> x _; rewrite lee_fin mulr_ge0//= ?gauss_fun_ge0// F'E/= invr_ge0. - rewrite F'E; apply/measurable_EFinP/measurable_funM => //. - apply/measurableT_comp => //; first exact: measurable_gauss_fun. - by apply: measurable_funM => //; exact: measurable_funD. -congr *%E; last by rewrite -(mulr_natr (_ ^+ 2)) sqrtrM ?sqr_ge0. -rewrite -increasing_ge0_integration_by_substitutionT//. -- exact: integralT_gauss. -- move=> x y xy; rewrite /F ltr_pM2r ?ltr_leB ?gt_eqF//. - by rewrite invr_gt0 ?sqrtr_gt0 ?pmulrn_lgt0 ?exprn_even_gt0. -- by rewrite F'E => ?; exact: cvg_cst. -- by rewrite F'E; exact: is_cvg_cst. -- by rewrite F'E; exact: is_cvg_cst. -- apply/gt0_cvgMlNy; last exact: cvg_addrr_Ny. - by rewrite invr_gt0// sqrtr_gt0 -mulr_natr mulr_gt0// exprn_even_gt0. -- apply/gt0_cvgMly; last exact: cvg_addrr. - by rewrite invr_gt0// sqrtr_gt0 -mulr_natr mulr_gt0// exprn_even_gt0. -- exact: continuous_gauss_fun. -- by move=> x; rewrite gauss_fun_ge0. -Qed. - -Let integral_normal_fun : sigma != 0 -> - (\int[mu]_x (normal_fun x)%:E)%E = normal_peak^-1%:E. -Proof. -move=> s0; rewrite -integral_gaussFF'//; apply: eq_integral => /= x _. -rewrite F'E !fctE/= EFinM -muleA -EFinM mulVf ?mulr1 ?mule1. - by rewrite normal_gauss_fun. -by rewrite gt_eqF// sqrtr_gt0 pmulrn_lgt0// exprn_even_gt0. -Qed. - -Let integrable_normal_fun : sigma != 0 -> - mu.-integrable [set: R] (EFin \o normal_fun). -Proof. -move=> s0; apply/integrableP; split. - by apply/measurable_EFinP; exact: measurable_normal_fun. -under eq_integral do rewrite /= ger0_norm ?expR_ge0//. -by rewrite /= integral_normal_fun// ltry. -Qed. - -Lemma integral_normal_pdf : (\int[mu]_x (normal_pdf m sigma x)%:E = 1%E)%E. -Proof. -rewrite /normal_pdf; have [_|s0] := eqVneq sigma 0. - by rewrite integral_indic//= setIT lebesgue_measure_itv/= lte01 oppr0 adde0. -under eq_integral do rewrite EFinM. -rewrite integralZl//=; last exact: integrable_normal_fun. -by rewrite integral_normal_fun// -EFinM divff// gt_eqF// normal_peak_gt0. -Qed. - -Lemma integrable_normal_pdf : mu.-integrable [set: R] - (fun x => (normal_pdf m sigma x)%:E). -Proof. -apply/integrableP; split. - by apply/measurable_EFinP; exact: measurable_normal_pdf. -apply/abse_integralP => //=; last by rewrite integral_normal_pdf abse1 ltry. -by apply/measurable_EFinP; exact: measurable_normal_pdf. -Qed. - -Local Notation normal_pdf := (normal_pdf m sigma). -Local Notation normal_prob := (normal_prob m sigma). - -Let normal0 : normal_prob set0 = 0%E. -Proof. by rewrite /normal_prob integral_set0. Qed. - -Let normal_ge0 A : (0 <= normal_prob A)%E. -Proof. -rewrite /normal_prob integral_ge0//= => x _. -by rewrite lee_fin normal_pdf_ge0 ?ltW. -Qed. - -Let normal_sigma_additive : semi_sigma_additive normal_prob. -Proof. -move=> /= A mA tA mUA. -rewrite /normal_prob/= integral_bigcup//=; last first. - by apply: (integrableS _ _ (subsetT _)) => //; exact: integrable_normal_pdf. -apply: is_cvg_ereal_nneg_natsum_cond => n _ _. -by apply: integral_ge0 => /= x ?; rewrite lee_fin normal_pdf_ge0 ?ltW. -Qed. - -HB.instance Definition _ := isMeasure.Build _ _ _ - normal_prob normal0 normal_ge0 normal_sigma_additive. - -Let normal_setT : normal_prob [set: _] = 1%E. -Proof. by rewrite /normal_prob integral_normal_pdf. Qed. - -HB.instance Definition _ := - @Measure_isProbability.Build _ _ R normal_prob normal_setT. - -Lemma normal_prob_dominates : normal_prob `<< mu. -Proof. -move=> A mA muA0; rewrite /normal_prob /normal_pdf. -have [s0|s0] := eqVneq sigma 0. - apply: null_set_integral => //=; apply: (integrableS measurableT) => //=. - exact: integrable_indic_itv. -apply/eqP; rewrite eq_le; apply/andP; split; last first. - apply: integral_ge0 => x _. - by rewrite lee_fin mulr_ge0 ?normal_peak_ge0 ?normal_fun_ge0. -apply: (@le_trans _ _ (\int[mu]_(x in A) (normal_peak)%:E))%E; last first. - by rewrite integral_cst//= muA0 mule0. -apply: ge0_le_integral => //=. -- by move=> x _; rewrite lee_fin mulr_ge0 ?normal_peak_ge0 ?normal_fun_ge0. -- apply/measurable_funTS/measurableT_comp => //=. - by apply: measurable_funM => //; exact: measurable_normal_fun. -- by move=> x _; rewrite lee_fin normal_peak_ge0. -- by move=> x _; have := normal_pdf_ub m x s0; rewrite /normal_pdf (negbTE s0). -Qed. - -End normal_probability. - -Section exponential_pdf. -Context {R : realType}. -Notation mu := lebesgue_measure. -Variable rate : R. -Hypothesis rate_gt0 : 0 < rate. - -Let exponential_pdfT x := rate * expR (- rate * x). -Definition exponential_pdf := exponential_pdfT \_ `[0%R, +oo[. - -Lemma exponential_pdf_ge0 x : 0 <= exponential_pdf x. -Proof. -by apply: restrict_ge0 => {}x _; apply: mulr_ge0; [exact: ltW|exact: expR_ge0]. -Qed. - -Lemma lt0_exponential_pdf x : x < 0 -> exponential_pdf x = 0. -Proof. -move=> x0; rewrite /exponential_pdf patchE ifF//. -by apply/negP; rewrite inE/= in_itv/= andbT; apply/negP; rewrite -ltNge. -Qed. - -Let continuous_exponential_pdfT : continuous exponential_pdfT. -Proof. -move=> x. -apply: (@continuousM _ R^o (fun=> rate) (fun x => expR (- rate * x))). - exact: cst_continuous. -apply: continuous_comp; last exact: continuous_expR. -by apply: continuousM => //; apply: (@continuousN _ R^o); exact: cst_continuous. -Qed. - -Lemma measurable_exponential_pdf : measurable_fun [set: R] exponential_pdf. -Proof. -apply/measurable_restrict => //; apply: measurable_funTS. -exact: continuous_measurable_fun. -Qed. - -Lemma exponential_pdfE x : 0 <= x -> exponential_pdf x = exponential_pdfT x. -Proof. -by move=> x0; rewrite /exponential_pdf patchE ifT// inE/= in_itv/= x0. -Qed. - -Lemma in_continuous_exponential_pdf : - {in `]0, +oo[%R, continuous exponential_pdf}. -Proof. -move=> x; rewrite in_itv/= andbT => x0. -apply/(@cvgrPdist_lt _ R^o) => e e0; near=> y. -rewrite 2?(exponential_pdfE (ltW _))//; last by near: y; exact: lt_nbhsr. -near: y; move: e e0; apply/(@cvgrPdist_lt _ R^o). -by apply: continuous_comp => //; exact: continuous_exponential_pdfT. -Unshelve. end_near. Qed. - -Lemma within_continuous_exponential_pdf : - {within [set` `[0, +oo[%R], continuous exponential_pdf}. -Proof. -apply/continuous_within_itvcyP; split. - exact: in_continuous_exponential_pdf. -apply/(@cvgrPdist_le _ R^o) => e e0; near=> t. -rewrite 2?exponential_pdfE//. -near: t; move: e e0; apply/cvgrPdist_le. -by apply: cvg_at_right_filter; exact: continuous_exponential_pdfT. -Unshelve. end_near. Qed. - -End exponential_pdf. - -Definition exponential_prob {R : realType} (rate : R) := - fun V => (\int[lebesgue_measure]_(x in V) (exponential_pdf rate x)%:E)%E. - -Section exponential_prob. -Context {R : realType}. -Local Open Scope ring_scope. -Notation mu := lebesgue_measure. -Variable rate : R. -Hypothesis rate_gt0 : 0 < rate. - -Lemma derive1_exponential_pdf : - {in `]0, +oo[%R, (fun x => - (expR : R^o -> R^o) (- rate * x))^`()%classic - =1 exponential_pdf rate}. -Proof. -move=> z; rewrite in_itv/= andbT => z0. -rewrite derive1_comp// derive1N// derive1_id mulN1r derive1_comp// derive1E. -have/funeqP -> := @derive_expR R. -by rewrite derive1Ml// derive1_id mulr1 mulrN opprK mulrC exponential_pdfE ?ltW. -Qed. - -Let cexpNM : continuous (fun z : R^o => expR (- rate * z)). -Proof. -move=> z; apply: continuous_comp; last exact: continuous_expR. -by apply: continuousM => //; apply: (@continuousN _ R^o); exact: cst_continuous. -Qed. - -Lemma exponential_prob_itv0c (x : R) : 0 < x -> - exponential_prob rate `[0, x] = (1 - (expR (- rate * x))%:E)%E. -Proof. -move=> x0. -rewrite (_: 1 = - (- expR (- rate * 0))%:E)%E; last first. - by rewrite mulr0 expR0 EFinN oppeK. -rewrite addeC. -apply: (@continuous_FTC2 _ _ (fun x => - expR (- rate * x))) => //. -- apply: (@continuous_subspaceW R^o _ _ [set` `[0, +oo[%R]). - + exact: subset_itvl. - + exact: within_continuous_exponential_pdf. -- split. - + by move=> z _; exact: ex_derive. - + by apply/cvg_at_right_filter; apply: cvgN; exact: cexpNM. - + by apply/cvg_at_left_filter; apply: cvgN; exact: cexpNM. -- move=> z; rewrite in_itv/= => /andP[z0 _]. - by apply: derive1_exponential_pdf; rewrite in_itv/= andbT. -Qed. - -Lemma integral_exponential_pdf : (\int[mu]_x (exponential_pdf rate x)%:E = 1)%E. -Proof. -have mEex : measurable_fun setT (EFin \o exponential_pdf rate). - by apply/measurable_EFinP; exact: measurable_exponential_pdf. -rewrite -(setUv `[0, +oo[%classic) ge0_integral_setU//=; last 4 first. - exact: measurableC. - by rewrite setUv. - by move=> x _; rewrite lee_fin exponential_pdf_ge0. - exact/disj_setPCl. -rewrite [X in _ + X]integral0_eq ?adde0; last first. - by move=> x x0; rewrite /exponential_pdf patchE ifF// memNset. -rewrite (@ge0_continuous_FTC2y _ _ - (fun x => - (expR (- rate * x))) _ 0)//. -- by rewrite mulr0 expR0 EFinN oppeK add0e. -- by move=> x _; apply: exponential_pdf_ge0. -- exact: within_continuous_exponential_pdf. -- rewrite -oppr0; apply: (@cvgN _ R^o). - rewrite (_ : (fun x => expR (- rate * x)) = - (fun z => expR (- z)) \o (fun z => rate * z)); last first. - by apply: eq_fun => x; rewrite mulNr. - apply: (@cvg_comp _ R^o _ _ _ _ (pinfty_nbhs R)); last exact: cvgr_expR. - exact: gt0_cvgMry. -- by apply: (@cvgN _ R^o); apply: cvg_at_right_filter; exact: cexpNM. -- exact: derive1_exponential_pdf. -Qed. - -Lemma integrable_exponential_pdf : - mu.-integrable setT (EFin \o (exponential_pdf rate)). -Proof. -have mEex : measurable_fun setT (EFin \o exponential_pdf rate). - by apply/measurable_EFinP; exact: measurable_exponential_pdf. -apply/integrableP; split => //. -under eq_integral do rewrite /= ger0_norm ?exponential_pdf_ge0//. -by rewrite /= integral_exponential_pdf ltry. -Qed. - -Local Notation exponential := (exponential_prob rate). - -Let exponential0 : exponential set0 = 0%E. -Proof. by rewrite /exponential integral_set0. Qed. - -Let exponential_ge0 A : (0 <= exponential A)%E. -Proof. -rewrite /exponential integral_ge0//= => x _. -by rewrite lee_fin exponential_pdf_ge0. -Qed. - -Let exponential_sigma_additive : semi_sigma_additive exponential. -Proof. -move=> /= F mF tF mUF; rewrite /exponential; apply: cvg_toP. - apply: ereal_nondecreasing_is_cvgn => m n mn. - apply: lee_sum_nneg_natr => // k _ _; apply: integral_ge0 => /= x Fkx. - by rewrite lee_fin; apply: exponential_pdf_ge0. -rewrite ge0_integral_bigcup//=. -- apply/measurable_funTS/measurableT_comp => //. - exact: measurable_exponential_pdf. -- by move=> x _; rewrite lee_fin exponential_pdf_ge0. -Qed. - -HB.instance Definition _ := isMeasure.Build _ _ _ - exponential exponential0 exponential_ge0 exponential_sigma_additive. - -Let exponential_setT : exponential [set: R] = 1%E. -Proof. by rewrite /exponential integral_exponential_pdf. Qed. - -HB.instance Definition _ := - @Measure_isProbability.Build _ _ R exponential exponential_setT. - -End exponential_prob. - -Section poisson_pmf. -Local Open Scope ring_scope. -Context {R : realType}. -Implicit Types (rate : R) (k : nat). - -Definition poisson_pmf rate k : R := - (rate ^+ k) * k`!%:R^-1 * expR (- rate). - -Lemma poisson_pmf_ge0 rate k : 0 <= rate -> 0 <= poisson_pmf rate k. -Proof. by move=> r0; rewrite /poisson_pmf 2?mulr_ge0// exprn_ge0. Qed. - -End poisson_pmf. - -Lemma measurable_poisson_pmf {R : realType} D (rate : R) k : - measurable_fun D (@poisson_pmf R ^~ k). -Proof. -apply: measurable_funM; first exact: measurable_funM. -by apply: measurable_funTS; exact: measurableT_comp. -Qed. - -Definition poisson_prob {R : realType} (rate : R) (k : nat) - : set nat -> \bar R := - fun U => if 0 <= rate then - \esum_(k in U) (poisson_pmf rate k)%:E else \d_0%N U. - -Section poisson. -Context {R : realType} (rate : R) (k : nat). -Local Open Scope ereal_scope. - -Local Notation poisson := (poisson_prob rate k). - -Let poisson0 : poisson set0 = 0. -Proof. by rewrite /poisson measure0; case: ifPn => //; rewrite esum_set0. Qed. - -Let poisson_ge0 U : 0 <= poisson U. -Proof. -rewrite /poisson; case: ifPn => // rate0; apply: esum_ge0 => /= n Un. -by rewrite lee_fin poisson_pmf_ge0. -Qed. - -Let poisson_sigma_additive : semi_sigma_additive poisson. -Proof. -move=> F mF tF mUF; rewrite /poisson; case: ifPn => rate0; last first. - exact: measure_semi_sigma_additive. -apply: cvg_toP. - apply: ereal_nondecreasing_is_cvgn => a b ab. - apply: lee_sum_nneg_natr => // n _ _. - by apply: esum_ge0 => /= ? _; exact: poisson_pmf_ge0. -by rewrite nneseries_sum_bigcup// => i; rewrite lee_fin poisson_pmf_ge0. -Qed. - -HB.instance Definition _ := isMeasure.Build _ _ _ poisson - poisson0 poisson_ge0 poisson_sigma_additive. - -Let poisson_setT : poisson [set: nat] = 1. -Proof. -rewrite /poisson; case: ifPn => [rate0|_]; last by rewrite probability_setT. -rewrite [RHS](_ : _ = (expR (- rate))%:E * (expR rate)%:E); last first. - by rewrite -EFinM expRN mulVf ?gt_eqF ?expR_gt0. -rewrite -nneseries_esumT; last by move=> *; rewrite lee_fin poisson_pmf_ge0. -under eq_eseriesr do rewrite EFinM muleC. -rewrite nneseriesZl/=; last by move=> *; rewrite lee_fin divr_ge0// exprn_ge0. -congr *%E; rewrite expRE -EFin_lim; last first. - rewrite /pseries/=; under eq_fun do rewrite mulrC. - exact: is_cvg_series_exp_coeff. -apply/congr_lim/funext => n/=; rewrite /pseries/= /series/= -sumEFin//. -by under eq_bigr do rewrite mulrC. -Qed. - -HB.instance Definition _ := - @Measure_isProbability.Build _ _ R poisson poisson_setT. - -End poisson. - -Lemma measurable_poisson_prob {R : realType} n : - measurable_fun setT (poisson_prob ^~ n : R -> pprobability _ _). -Proof. -apply: (measurability (@pset _ _ _ : set (set (pprobability _ R)))) => //. -move=> _ -[_ [r r01] [Ys mYs <-]] <-; apply: emeasurable_fun_infty_o => //=. -apply: measurable_fun_if => //=; first exact: measurable_fun_ler. -apply: (eq_measurable_fun (fun t => - \sum_(k x /set_mem[_/= x01]. - by rewrite nneseries_esum ?set_mem_set// =>*; rewrite lee_fin poisson_pmf_ge0. -apply: ge0_emeasurable_sum. - by move=> k x/= [_ x01] _; rewrite lee_fin poisson_pmf_ge0. -by move=> k Ysk; apply/measurableT_comp => //; exact: measurable_poisson_pmf. -Qed. diff --git a/theories/probability_lscdf_20250703.v b/theories/probability_lscdf_20250703.v deleted file mode 100644 index fe44df0ad1..0000000000 --- a/theories/probability_lscdf_20250703.v +++ /dev/null @@ -1,1929 +0,0 @@ -(* mathcomp analysis (c) 2025 Inria and AIST. License: CeCILL-C. *) -From HB Require Import structures. -From mathcomp Require Import all_ssreflect ssralg. -From mathcomp Require Import poly ssrnum ssrint interval archimedean finmap. -From mathcomp Require Import mathcomp_extra unstable boolp classical_sets. -From mathcomp Require Import functions cardinality fsbigop. -From mathcomp Require Import exp numfun lebesgue_measure lebesgue_integral. -From mathcomp Require Import reals interval_inference ereal topology normedtype. -From mathcomp Require Import sequences derive esum measure exp trigo realfun. -From mathcomp Require Import numfun lebesgue_measure lebesgue_integral kernel. -From mathcomp Require Import ftc gauss_integral hoelder. - -(**md**************************************************************************) -(* # Probability *) -(* *) -(* This file provides basic notions of probability theory. See measure.v for *) -(* the type probability T R (a measure that sums to 1). *) -(* *) -(* About integrability: as a rule of thumb, in this file, we favor the use *) -(* of `Lfun P n` hypotheses instead of the `integrable` predicate from *) -(* `lebesgue_integral.v`. *) -(* *) -(* ``` *) -(* {RV P >-> T'} == random variable: a measurable function to the *) -(* measurableType T' from the measured space *) -(* characterized by the probability P *) -(* distribution P X == measure image of the probability measure P by the *) -(* random variable X : {RV P -> T'} *) -(* P as type probability T R with T of type *) -(* measurableType. *) -(* Declared as an instance of probability measure. *) -(* 'E_P[X] == expectation of the real measurable function X *) -(* covariance X Y == covariance between real random variable X and Y *) -(* 'V_P[X] == variance of the real random variable X *) -(* 'M_P X == moment generating function of the random variable X *) -(* with sample space corresponding to the probability *) -(* measure P *) -(* {dmfun T >-> R} == type of discrete real-valued measurable functions *) -(* {dRV P >-> R} == real-valued discrete random variable *) -(* dRV_dom X == domain of the discrete random variable X *) -(* dRV_enum X == bijection between the domain and the range of X *) -(* pmf X r := fine (P (X @^-1` [set r])) *) -(* cdf X r == cumulative distribution function of X *) -(* := distribution P X `]-oo, r] *) -(* enum_prob X k == probability of the kth value in the range of X *) -(* ``` *) -(* *) -(* ``` *) -(* bernoulli_pmf p == Bernoulli pmf with parameter p : R *) -(* bernoulli p == Bernoulli probability measure when 0 <= p <= 1 *) -(* and \d_false otherwise *) -(* binomial_pmf n p == binomial pmf with parameters n : nat and p : R *) -(* binomial_prob n p == binomial probability measure when 0 <= p <= 1 *) -(* and \d_0%N otherwise *) -(* bin_prob n k p == $\binom{n}{k}p^k (1-p)^(n-k)$ *) -(* Computes a binomial distribution term for *) -(* k successes in n trials with success rate p *) -(* uniform_pdf a b == uniform pdf over the interval [a,b] *) -(* uniform_prob a b ab == uniform probability over the interval [a,b] *) -(* where ab0 a proof that 0 < b - a *) -(* normal_peak s := (sqrtr (s ^+ 2 * pi *+ 2))^-1 *) -(* normal_fun m s x := expR (- (x - m) ^+ 2 / (s ^+ 2 *+ 2)) *) -(* normal_pdf m s == pdf of the normal distribution with mean m and *) -(* standard deviation s *) -(* Using normal_peak and normal_pdf. *) -(* normal_prob m s == normal probability measure *) -(* exponential_pdf r == pdf of the exponential distribution with rate r *) -(* exponential_prob r == exponential probability measure *) -(* ``` *) -(* *) -(******************************************************************************) - -Reserved Notation "'{' 'RV' P >-> R '}'" - (at level 0, format "'{' 'RV' P '>->' R '}'"). -Reserved Notation "''E_' P [ X ]" (format "''E_' P [ X ]"). -Reserved Notation "''V_' P [ X ]" (format "''V_' P [ X ]"). -Reserved Notation "'M_ P X" (at level 5, P, X at level 4, format "''M_' P X"). -Reserved Notation "{ 'dmfun' aT >-> T }" (format "{ 'dmfun' aT >-> T }"). -Reserved Notation "'{' 'dRV' P >-> R '}'" (format "'{' 'dRV' P '>->' R '}'"). - -Set Implicit Arguments. -Unset Strict Implicit. -Unset Printing Implicit Defensive. - -Import Order.TTheory GRing.Theory Num.Def Num.Theory. -Import numFieldTopology.Exports. - -Local Open Scope classical_set_scope. -Local Open Scope ring_scope. - -Definition random_variable d d' (T : measurableType d) (T' : measurableType d') - (R : realType) (P : probability T R) := {mfun T >-> T'}. - -Notation "{ 'RV' P >-> T' }" := (@random_variable _ _ _ T' _ P) : form_scope. - -Lemma notin_range_measure d d' (T : measurableType d) (T' : measurableType d') - (R : realType) (P : {measure set T -> \bar R}) (X : T -> R) r : - r \notin range X -> P (X @^-1` [set r]) = 0%E. -Proof. by rewrite notin_setE => hr; rewrite preimage10. Qed. - -Lemma probability_range d d' (T : measurableType d) (T' : measurableType d') - (R : realType) (P : probability T R) (X : {RV P >-> R}) : - P (X @^-1` range X) = 1%E. -Proof. by rewrite preimage_range probability_setT. Qed. - -Definition distribution d d' (T : measurableType d) (T' : measurableType d') - (R : realType) (P : probability T R) (X : {mfun T >-> T'}) := - pushforward P X. - -Section distribution_is_probability. -Context d d' {T : measurableType d} {T' : measurableType d'} {R : realType} - {P : probability T R}. -Variable X : {mfun T >-> T'}. - -Let distribution0 : distribution P X set0 = 0%E. -Proof. exact: measure0. Qed. - -Let distribution_ge0 A : (0 <= distribution P X A)%E. -Proof. exact: measure_ge0. Qed. - -Let distribution_sigma_additive : semi_sigma_additive (distribution P X). -Proof. exact: measure_semi_sigma_additive. Qed. - -HB.instance Definition _ := isMeasure.Build _ _ _ (distribution P X) - distribution0 distribution_ge0 distribution_sigma_additive. - -Let distribution_is_probability : distribution P X [set: _] = 1%:E. -Proof. -by rewrite /distribution /= /pushforward /= preimage_setT probability_setT. -Qed. - -HB.instance Definition _ := Measure_isProbability.Build _ _ _ - (distribution P X) distribution_is_probability. - -End distribution_is_probability. - -Section transfer_probability. -Local Open Scope ereal_scope. -Context d d' {T : measurableType d} {T' : measurableType d'} {R : realType} - (P : probability T R). - -Lemma probability_distribution (X : {RV P >-> T'}) r : - P [set x | X x = r] = distribution P X [set r]. -Proof. by []. Qed. - -Lemma ge0_integral_distribution (X : {RV P >-> T'}) (f : T' -> \bar R) : - measurable_fun [set: T'] f -> (forall y, 0 <= f y) -> - \int[distribution P X]_y f y = \int[P]_x (f \o X) x. -Proof. by move=> mf f0; rewrite ge0_integral_pushforward. Qed. - -Lemma integral_distribution (X : {RV P >-> T'}) (f : T' -> \bar R) : - measurable_fun [set: T'] f -> P.-integrable [set: T] (f \o X) -> - \int[distribution P X]_y f y = \int[P]_x (f \o X) x. -Proof. by move=> mf intf; rewrite integral_pushforward. Qed. - -End transfer_probability. - -Definition cdf d (T : measurableType d) (R : realType) (P : probability T R) - (X : {RV P >-> R}) (r : R) := distribution P X `]-oo, r]. - -Section cumulative_distribution_function. -Context d {T : measurableType d} {R : realType} (P : probability T R). -Variable X : {RV P >-> R}. -Local Open Scope ereal_scope. - -Lemma cdf_ge0 r : 0 <= cdf X r. Proof. by []. Qed. - -Lemma cdf_le1 r : cdf X r <= 1. Proof. exact: probability_le1. Qed. - -Lemma cdf_nondecreasing : nondecreasing_fun (cdf X). -Proof. by move=> r s rs; rewrite le_measure ?inE//; exact: subitvPr. Qed. - -Lemma cvg_cdfy1 : cdf X @ +oo%R --> 1. -Proof. -pose s : \bar R := ereal_sup (range (cdf X)). -have cdf_s : cdf X r @[r --> +oo%R] --> s. - exact: nondecreasing_cvge cdf_nondecreasing. -have cdf_ns : cdf X n%:R @[n --> \oo%R] --> s. - by move/cvge_pinftyP : cdf_s; apply; exact/cvgryPge/nbhs_infty_ger. -have cdf_n1 : cdf X n%:R @[n --> \oo] --> 1. - rewrite -(probability_setT P). - pose F n := X @^-1` `]-oo, n%:R]. - have <- : \bigcup_n F n = setT. - rewrite -preimage_bigcup -subTset => t _/=. - by exists (trunc (X t)).+1 => //=; rewrite in_itv/= ltW// truncnS_gt. - apply: nondecreasing_cvg_mu => //; first exact: bigcup_measurable. - move=> n m nm; apply/subsetPset => x/=; rewrite !in_itv/= => /le_trans. - by apply; rewrite ler_nat. -by rewrite -(cvg_unique _ cdf_ns cdf_n1). -Qed. - -Lemma cvg_cdfNy0 : cdf X @ -oo%R --> 0. -Proof. -rewrite cvgNy_compNP. -have cdf_opp_noninc : {homo cdf X \o -%R : q r / (q <= r)%R >-> q >= r}. - by move=> q r; rewrite -lterN2; exact: cdf_nondecreasing. -pose s := ereal_inf (range (cdf X \o -%R)). -have cdf_opp_s : (cdf X \o -%R) r @[r --> +oo%R] --> s. - exact: nonincreasing_cvge cdf_opp_noninc. -have cdf_opp_ns : (cdf X \o -%R) n%:R @[n --> \oo] --> s. - by move/cvge_pinftyP : cdf_opp_s; apply; exact/cvgryPge/nbhs_infty_ger. -have cdf_opp_n0 : (cdf X \o -%R) n%:R @[n --> \oo] --> 0. - rewrite -(measure0 P). - pose F n := X @^-1` `]-oo, (- n%:R)%R]. - have <- : \bigcap_n F n = set0. - rewrite -subset0 => t. - set m := (trunc `|X t|).+1. - move=> /(_ m I); rewrite /F/= in_itv/= leNgt => /negP; apply. - by rewrite ltrNl /m (le_lt_trans (ler_norm _))// normrN truncnS_gt. - apply: nonincreasing_cvg_mu => //=. - + by rewrite (le_lt_trans (probability_le1 _ _)) ?ltry. - + exact: bigcap_measurable. - + move=> m n mn; apply/subsetPset => x/=; rewrite !in_itv => /le_trans; apply. - by rewrite lerN2 ler_nat. -by rewrite (_ : 0%E = s)// (cvg_unique _ cdf_opp_ns cdf_opp_n0). -Qed. - -Lemma cdf_right_continuous : right_continuous (cdf X). -Proof. -move=> a. -pose s := fine (ereal_inf (cdf X @` `]a, a + 1%R]%classic)). -have cdf_s : cdf X r @[r --> a^'+] --> s%:E. - rewrite /s fineK. - - apply: nondecreasing_at_right_cvge; first by rewrite ltBSide /= ?ltrDl. - by move=> *; exact: cdf_nondecreasing. - - apply/fin_numPlt/andP; split=>//. - + by rewrite (lt_le_trans (ltNyr 0%R)) ?lb_ereal_inf//= => l[? _] <-. - + rewrite (le_lt_trans _ (ltry 1%R))// ereal_inf_le//=. - exists (cdf X (a + 1)); last exact: cdf_le1. - by exists (a + 1%R) => //; rewrite in_itv /=; apply/andP; rewrite ltrDl. -have cdf_ns : cdf X (a + n.+1%:R^-1) @[n --> \oo] --> s%:E. - move/cvge_at_rightP : cdf_s; apply; split=> [n|]; rewrite ?ltrDl //. - rewrite -[X in _ --> X]addr0; apply: (@cvgD _ R^o); first exact: cvg_cst. - by rewrite gtr0_cvgV0 ?cvg_shiftS; [exact: cvgr_idn | near=> n]. -have cdf_na : cdf X (a + n.+1%:R^-1) @[n --> \oo] --> cdf X a. - pose F n := X @^-1` `]-oo, a + n.+1%:R^-1%R]. - suff : P (F n) @[n --> \oo] --> P (\bigcap_n F n). - by rewrite [in X in _ --> X -> _]/F -preimage_bigcap -itvNycEbigcap. - apply: nonincreasing_cvg_mu => [| | |m n mn]. - - by rewrite -ge0_fin_numE// fin_num_measure//; exact: measurable_sfunP. - - by move=> ?; exact: measurable_sfunP. - - by apply: bigcap_measurable => // ? _; exact: measurable_sfunP. - - apply/subsetPset; apply: preimage_subset; apply: subset_itvl. - by rewrite bnd_simp lerD2l lef_pV2 ?posrE// ler_nat. -by rewrite -(cvg_unique _ cdf_ns cdf_na). -Unshelve. all: by end_near. Qed. - -End cumulative_distribution_function. - -Section cdf_of_lebesgue_stieltjes_mesure. -Context {R : realType} (f : cumulative R) - (f_y1 : f @ +oo --> (1:R)) (f_Ny0 : f @ -oo --> (0:R)). -Local Open Scope measure_display_scope. - -Let T := g_sigma_algebraType R.-ocitv.-measurable. -Let lsf := lebesgue_stieltjes_measure f. - -Let lebesgue_stieltjes_setT : lsf setT = 1%E. -Proof. -pose I n := `]-(n%:R):R, n%:R]%classic. -have <- : \bigcup_n I n = setT. - rewrite -subTset=> x _; rewrite /bigcup/=; exists (truncn`|x|).+1=>//. - by rewrite /I/= subset_itv_oo_oc// in_itv/= -real_ltr_norml//= truncnS_gt. -have cvg_cup : (lsf \o I) n @[n --> \oo] --> lsf (\bigcup_n I n). - apply: nondecreasing_cvg_mu; rewrite /I//; first exact: bigcup_measurable. - by move=> *; apply/subsetPset/subset_itv; rewrite leBSide/= ?lerN2 ler_nat. -have cvg_1 : (lsf \o I) n @[n --> \oo] --> 1%E. - rewrite /comp/I/lsf/lebesgue_stieltjes_measure/measure_extension/=. - suff : ((f n%:R)%:E - (f (1 *- n))%:E)%E @[n --> \oo] --> 1%E => ?. - under eq_cvg=> n. - rewrite measurable_mu_extE/=; last exact: is_ocitv. - rewrite wlength_itv_bnd; last exact: (le_trans _ (ler0n R n)). - over. - assumption. - rewrite -(sube0 1); apply: cvgeB=>//; apply: cvg_EFin; try by near=> F. - by rewrite /comp; apply/(cvg_comp _ _ (@cvgr_idn R))/f_y1. - rewrite /comp/=; apply: ((iffLR (cvg_ninftyP _ _)) f_Ny0). - by apply: (cvg_comp _ _ (@cvgr_idn R)); rewrite ninfty. -by rewrite -(cvg_unique _ cvg_cup cvg_1). -Unshelve. all: end_near. Qed. - -HB.instance Definition _ := @Measure_isProbability.Build _ _ _ - (lebesgue_stieltjes_measure f) lebesgue_stieltjes_setT. - -Let idTR : T -> R := (fun x => x). - -Lemma measurable_idTR : measurable_fun setT idTR. -Proof. by apply: measurable_id. Qed. - -#[local] HB.instance Definition _ := - @isMeasurableFun.Build _ _ T R idTR measurable_idTR. - -Let Xid : {RV lsf >-> R} := idTR. - -Lemma cdf_lebesgue_stieltjes_id r : cdf Xid r = EFin (f r). -Proof. -rewrite /= preimage_id. -have <- : (\bigcup_n `]-n%:R, r]%classic) = `]-oo, r]%classic. - apply/seteqP; split=> x/=; first by case=> n _/=; rewrite !in_itv/=; case/andP. - rewrite in_itv/= => xr; exists (truncn`|x|).+1=>//=; rewrite in_itv/=. - apply/andP; split=>//; rewrite ltrNl -normrN. - apply: le_lt_trans; [exact: ler_norm | exact: truncnS_gt]. -have cvg_cup : (lsf `]-n%:R, r])@[n --> \oo] --> - lsf (\bigcup_n `]-n%:R, r]%classic). - apply: nondecreasing_cvg_mu; rewrite /I//; first exact: bigcup_measurable. - by move=> *; apply/subsetPset/subset_itv; rewrite leBSide//= lerN2 ler_nat//. -have cvg_fr : (lsf `]-n%:R, r])@[n --> \oo] --> (f r)%:E. - suff : ((f r)%:E - (f (-n%:R))%:E)%E@[n --> \oo] --> (f r)%:E. - apply: cvg_trans; apply: near_eq_cvg; near=> n. - rewrite /lsf/lebesgue_stieltjes_measure/measure_extension/=. - rewrite measurable_mu_extE/= ?wlength_itv_bnd//; last exact: is_ocitv. - near: n; exists (truncn`|r|).+1=>// n/=; rewrite truncn_lt_nat// lerNl. - by move/ltW; apply /le_trans; rewrite -normrN ler_norm. - rewrite -[X in _ --> X](sube0 (f r)%:E). - apply: cvgeB=>//; first exact: cvg_cst. - apply: cvg_comp; [apply: cvg_comp; last exact: f_Ny0 | by[]]. - by apply: cvg_comp; [exact: cvgr_idn | rewrite ninfty]. -by rewrite -(cvg_unique _ cvg_cup cvg_fr). -Unshelve. all: by end_near. Qed. - -End cdf_of_lebesgue_stieltjes_mesure. - -HB.lock Definition expectation {d} {T : measurableType d} {R : realType} - (P : probability T R) (X : T -> R) := (\int[P]_w (X w)%:E)%E. -Canonical expectation_unlockable := Unlockable expectation.unlock. -Arguments expectation {d T R} P _%_R. -Notation "''E_' P [ X ]" := (@expectation _ _ _ P X) : ereal_scope. - -Section expectation_lemmas. -Local Open Scope ereal_scope. -Context d (T : measurableType d) (R : realType) (P : probability T R). - -Lemma expectation_def (X : {RV P >-> R}) : 'E_P[X] = (\int[P]_w (X w)%:E)%E. -Proof. by rewrite unlock. Qed. - -Lemma expectation_fin_num (X : T -> R) : X \in Lfun P 1 -> - 'E_P[X] \is a fin_num. -Proof. -by move=> ?; rewrite unlock integral_fune_fin_num//; exact/Lfun1_integrable. -Qed. - -Lemma expectation_cst r : 'E_P[cst r] = r%:E. -Proof. by rewrite unlock/= integral_cst//= probability_setT mule1. Qed. - -Lemma expectation_indic (A : set T) (mA : measurable A) : 'E_P[\1_A] = P A. -Proof. by rewrite unlock integral_indic// setIT. Qed. - -Lemma integrable_expectation (X : {RV P >-> R}) - (iX : P.-integrable [set: T] (EFin \o X)) : `| 'E_P[X] | < +oo. -Proof. -move: iX => /integrableP[? Xoo]; rewrite (le_lt_trans _ Xoo)// unlock. -exact: le_trans (le_abse_integral _ _ _). -Qed. - -Lemma expectationZl (X : T -> R) (k : R) : X \in Lfun P 1 -> - 'E_P[k \o* X] = k%:E * 'E_P [X]. -Proof. -by move=> ?; rewrite unlock muleC -integralZr//; exact/Lfun1_integrable. -Qed. - -Lemma expectation_ge0 (X : T -> R) : (forall x, 0 <= X x)%R -> - 0 <= 'E_P[X]. -Proof. -by move=> ?; rewrite unlock integral_ge0// => x _; rewrite lee_fin. -Qed. - -Lemma expectation_le (X Y : T -> R) : - measurable_fun [set: T] X -> measurable_fun [set: T] Y -> - (forall x, 0 <= X x)%R -> (forall x, 0 <= Y x)%R -> - {ae P, (forall x, X x <= Y x)%R} -> 'E_P[X] <= 'E_P[Y]. -Proof. -move=> mX mY X0 Y0 XY; rewrite unlock ae_ge0_le_integral => //. -- by move=> t _; apply: X0. -- exact/measurable_EFinP. -- by move=> t _; apply: Y0. -- exact/measurable_EFinP. -- move: XY => [N [mN PN XYN]]; exists N; split => // t /= h. - by apply: XYN => /=; apply: contra_not h; rewrite lee_fin. -Qed. - -Lemma expectationD (X Y : T -> R) : X \in Lfun P 1 -> Y \in Lfun P 1 -> - 'E_P[X \+ Y] = 'E_P[X] + 'E_P[Y]. -Proof. -by move=> ? ?; rewrite unlock integralD_EFin//; exact/Lfun1_integrable. -Qed. - -Lemma expectationB (X Y : T -> R) : X \in Lfun P 1 -> Y \in Lfun P 1 -> - 'E_P[X \- Y] = 'E_P[X] - 'E_P[Y]. -Proof. -by move=> ? ?; rewrite unlock integralB_EFin//; exact/Lfun1_integrable. -Qed. - -Lemma expectation_sum (X : seq (T -> R)) : - (forall Xi, Xi \in X -> Xi \in Lfun P 1) -> - 'E_P[\sum_(Xi <- X) Xi] = \sum_(Xi <- X) 'E_P[Xi]. -Proof. -elim: X => [|X0 X IHX] intX; first by rewrite !big_nil expectation_cst. -rewrite !big_cons expectationD; last 2 first. - by rewrite intX// mem_head. - by rewrite big_seq rpred_sum// => Y YX/=; rewrite intX// inE YX orbT. -by rewrite IHX//= => Xi XiX; rewrite intX// inE XiX orbT. -Qed. - -End expectation_lemmas. -#[deprecated(since="mathcomp-analysis 1.8.0", note="renamed to `expectationZl`")] -Notation expectationM := expectationZl (only parsing). - -HB.lock Definition covariance {d} {T : measurableType d} {R : realType} - (P : probability T R) (X Y : T -> R) := - 'E_P[(X \- cst (fine 'E_P[X])) * (Y \- cst (fine 'E_P[Y]))]%E. -Canonical covariance_unlockable := Unlockable covariance.unlock. -Arguments covariance {d T R} P _%_R _%_R. - -Hint Extern 0 (fin_num_fun _) => - (apply: fin_num_measure) : core. - -Section covariance_lemmas. -Local Open Scope ereal_scope. -Context d (T : measurableType d) (R : realType) (P : probability T R). - -Lemma covarianceE (X Y : T -> R) : - X \in Lfun P 1 -> Y \in Lfun P 1 -> - (X * Y)%R \in Lfun P 1 -> - covariance P X Y = 'E_P[X * Y] - 'E_P[X] * 'E_P[Y]. -Proof. -move=> l1X l1Y l1XY. -rewrite unlock [X in 'E_P[X]](_ : _ = (X \* Y \- fine 'E_P[X] \o* Y - \- fine 'E_P[Y] \o* X \+ fine ('E_P[X] * 'E_P[Y]) \o* cst 1)%R); last first. - apply/funeqP => x /=; rewrite mulrDr !mulrDl/= mul1r. - rewrite fineM ?expectation_fin_num// mulrNN addrA. - by rewrite mulrN mulNr [Z in (X x * Y x - Z)%R]mulrC. -rewrite expectationD/= ?rpredB//= ?Lfun_scale ?Lfun_cst//. -rewrite 2?expectationB//= ?rpredB ?Lfun_scale// 3?expectationZl//= ?Lfun_cst//. -rewrite expectation_cst mule1 fineM ?expectation_fin_num// EFinM. -rewrite !fineK ?expectation_fin_num//. -by rewrite muleC subeK ?fin_numM ?expectation_fin_num. -Qed. - -Lemma covarianceC (X Y : T -> R) : covariance P X Y = covariance P Y X. -Proof. -by rewrite unlock; congr expectation; apply/funeqP => x /=; rewrite mulrC. -Qed. - -Lemma covariance_fin_num (X Y : T -> R) : - X \in Lfun P 1 -> Y \in Lfun P 1 -> - (X * Y)%R \in Lfun P 1 -> - covariance P X Y \is a fin_num. -Proof. -by move=> ? ? ?; rewrite covarianceE// fin_numB fin_numM expectation_fin_num. -Qed. - -Lemma covariance_cst_l c (X : T -> R) : covariance P (cst c) X = 0. -Proof. -rewrite unlock expectation_cst/=. -rewrite [X in 'E_P[X]](_ : _ = cst 0%R) ?expectation_cst//. -by apply/funeqP => x; rewrite /GRing.mul/= subrr mul0r. -Qed. - -Lemma covariance_cst_r (X : T -> R) c : covariance P X (cst c) = 0. -Proof. by rewrite covarianceC covariance_cst_l. Qed. - -Lemma covarianceZl a (X Y : T -> R) : - X \in Lfun P 1 -> Y \in Lfun P 1 -> - (X * Y)%R \in Lfun P 1 -> - covariance P (a \o* X)%R Y = a%:E * covariance P X Y. -Proof. -move=> X1 Y1 XY1. -have aXY : (a \o* X * Y = a \o* (X * Y))%R by apply/funeqP => x; rewrite mulrAC. -rewrite [LHS]covarianceE => [||//|] //=; last 2 first. -- by rewrite Lfun_scale. -- by rewrite aXY Lfun_scale. -rewrite covarianceE// aXY !expectationZl//. -by rewrite -muleA -muleBr// fin_num_adde_defr// expectation_fin_num. -Qed. - -Lemma covarianceZr a (X Y : T -> R) : X \in Lfun P 1 -> Y \in Lfun P 1 -> - (X * Y)%R \in Lfun P 1 -> - covariance P X (a \o* Y)%R = a%:E * covariance P X Y. -Proof. -move=> X1 Y1 XY1. -by rewrite [in RHS]covarianceC covarianceC covarianceZl; last rewrite mulrC. -Qed. - -Lemma covarianceNl (X Y : T -> R) : X \in Lfun P 1 -> Y \in Lfun P 1 -> - (X * Y)%R \in Lfun P 1 -> - covariance P (\- X)%R Y = - covariance P X Y. -Proof. -move=> X1 Y1 XY1. -have -> : (\- X = -1 \o* X)%R by apply/funeqP => x /=; rewrite mulrN mulr1. -by rewrite covarianceZl// EFinN mulNe mul1e. -Qed. - -Lemma covarianceNr (X Y : T -> R) : X \in Lfun P 1 -> Y \in Lfun P 1 -> - (X * Y)%R \in Lfun P 1 -> - covariance P X (\- Y)%R = - covariance P X Y. -Proof. by move=> X1 Y1 XY1; rewrite !(covarianceC X) covarianceNl 1?mulrC. Qed. - -Lemma covarianceNN (X Y : T -> R) : X \in Lfun P 1 -> Y \in Lfun P 1 -> - (X * Y)%R \in Lfun P 1 -> - covariance P (\- X)%R (\- Y)%R = covariance P X Y. -Proof. -by move=> ? ? ?; rewrite covarianceNl//= ?covarianceNr ?oppeK ?mulrN//= ?rpredN. -Qed. - -Lemma covarianceDl (X Y Z : T -> R) : - X \in Lfun P 2%:E -> Y \in Lfun P 2%:E -> Z \in Lfun P 2%:E -> - covariance P (X \+ Y)%R Z = covariance P X Z + covariance P Y Z. -Proof. -move=> X2 Y2 Z2. -have Pfin : P setT \is a fin_num := fin_num_measure P _ measurableT. -have X1 := Lfun_subset12 Pfin X2. -have Y1 := Lfun_subset12 Pfin Y2. -have Z1 := Lfun_subset12 Pfin Z2. -have XY1 := Lfun2_mul_Lfun1 X2 Y2. -have YZ1 := Lfun2_mul_Lfun1 Y2 Z2. -have XZ1 := Lfun2_mul_Lfun1 X2 Z2. -rewrite [LHS]covarianceE//= ?mulrDl ?compreDr ?rpredD//= 2?expectationD//=. -rewrite muleDl ?fin_num_adde_defr ?expectation_fin_num//. -rewrite oppeD ?fin_num_adde_defr ?fin_numM ?expectation_fin_num//. -by rewrite addeACA 2?covarianceE. -Qed. - -Lemma covarianceDr (X Y Z : T -> R) : - X \in Lfun P 2%:E -> Y \in Lfun P 2%:E -> Z \in Lfun P 2%:E -> - covariance P X (Y \+ Z)%R = covariance P X Y + covariance P X Z. -Proof. -by move=> X2 Y2 Z2; rewrite covarianceC covarianceDl ?(covarianceC X) 1?mulrC. -Qed. - -Lemma covarianceBl (X Y Z : T -> R) : - X \in Lfun P 2%:E -> Y \in Lfun P 2%:E -> Z \in Lfun P 2%:E -> - covariance P (X \- Y)%R Z = covariance P X Z - covariance P Y Z. -Proof. -move=> X2 Y2 Z2. -have Pfin : P setT \is a fin_num := fin_num_measure P _ measurableT. -have Y1 := Lfun_subset12 Pfin Y2. -have Z1 := Lfun_subset12 Pfin Z2. -have YZ1 := Lfun2_mul_Lfun1 Y2 Z2. -by rewrite -[(X \- Y)%R]/(X \+ (\- Y))%R covarianceDl ?covarianceNl ?rpredN. -Qed. - -Lemma covarianceBr (X Y Z : T -> R) : - X \in Lfun P 2%:E -> Y \in Lfun P 2%:E -> Z \in Lfun P 2%:E -> - covariance P X (Y \- Z)%R = covariance P X Y - covariance P X Z. -Proof. -move=> X2 Y2 Z2. -have Pfin : P setT \is a fin_num := fin_num_measure P _ measurableT. -have Y1 := Lfun_subset12 Pfin Y2. -have Z1 := Lfun_subset12 Pfin Z2. -have YZ1 := Lfun2_mul_Lfun1 Y2 Z2. -by rewrite !(covarianceC X) covarianceBl 1?(mulrC _ X). -Qed. - -End covariance_lemmas. - -Section variance. -Local Open Scope ereal_scope. -Context d (T : measurableType d) (R : realType) (P : probability T R). - -Definition variance (X : T -> R) := covariance P X X. -Local Notation "''V_' P [ X ]" := (variance X). - -Lemma varianceE (X : T -> R) : X \in Lfun P 2%:E -> - 'V_P[X] = 'E_P[X ^+ 2] - ('E_P[X]) ^+ 2. -Proof. -move=> X2; rewrite /variance. -by rewrite covarianceE ?Lfun2_mul_Lfun1// Lfun_subset12 ?fin_num_measure. -Qed. - -Lemma variance_fin_num (X : T -> R) : X \in Lfun P 2%:E -> - 'V_P[X] \is a fin_num. -Proof. -move=> X2. -by rewrite covariance_fin_num ?Lfun2_mul_Lfun1// Lfun_subset12 ?fin_num_measure. -Qed. - -Lemma variance_ge0 (X : T -> R) : 0 <= 'V_P[X]. -Proof. -by rewrite /variance unlock; apply: expectation_ge0 => x; exact: sqr_ge0. -Qed. - -Lemma variance_cst r : 'V_P[cst r] = 0%E. -Proof. -rewrite /variance unlock expectation_cst/=. -rewrite [X in 'E_P[X]](_ : _ = cst 0%R) ?expectation_cst//. -by apply/funext => x; rewrite /GRing.exp/GRing.mul/= subrr mulr0. -Qed. - -Lemma varianceZ a (X : T -> R) : X \in Lfun P 2%:E -> - 'V_P[(a \o* X)%R] = (a ^+ 2)%:E * 'V_P[X]. -Proof. -move=> X2. -have Pfin : P setT \is a fin_num := fin_num_measure P _ measurableT. -have X1 := Lfun_subset12 Pfin X2. -rewrite /variance covarianceZl//=. -- by rewrite covarianceZr// ?muleA ?EFinM// Lfun2_mul_Lfun1. -- by rewrite Lfun_scale. -- by rewrite Lfun2_mul_Lfun1// Lfun_scale// ler1n. -Qed. - -Lemma varianceN (X : T -> R) : X \in Lfun P 2%:E -> 'V_P[(\- X)%R] = 'V_P[X]. -Proof. -move=> X2; rewrite /variance. -by rewrite covarianceNN ?Lfun2_mul_Lfun1 ?Lfun_subset12 ?fin_num_measure. -Qed. - -Lemma varianceD (X Y : T -> R) : X \in Lfun P 2%:E -> Y \in Lfun P 2%:E -> - 'V_P[X \+ Y]%R = 'V_P[X] + 'V_P[Y] + 2%:E * covariance P X Y. -Proof. -move=> X2 Y2. -have Pfin : P setT \is a fin_num := fin_num_measure P _ measurableT. -have X1 := Lfun_subset12 Pfin X2. -have Y1 := Lfun_subset12 Pfin Y2. -have XY1 := Lfun2_mul_Lfun1 X2 Y2. -rewrite -['V_P[_]]/(covariance P (X \+ Y)%R (X \+ Y)%R). -rewrite covarianceDl ?rpredD ?lee1n//= covarianceDr// covarianceDr//. -rewrite (covarianceC P Y X) [LHS]addeA [LHS](ACl (1*4*(2*3)))/=. -by rewrite -[2%R]/(1 + 1)%R EFinD muleDl ?mul1e// covariance_fin_num. -Qed. - -Lemma varianceB (X Y : T -> R) : X \in Lfun P 2%:E -> Y \in Lfun P 2%:E -> - 'V_P[(X \- Y)%R] = 'V_P[X] + 'V_P[Y] - 2%:E * covariance P X Y. -Proof. -move=> X2 Y2. -have Pfin : P setT \is a fin_num := fin_num_measure P _ measurableT. -have X1 := Lfun_subset12 Pfin X2. -have Y1 := Lfun_subset12 Pfin Y2. -have XY1 := Lfun2_mul_Lfun1 X2 Y2. -rewrite -[(X \- Y)%R]/(X \+ (\- Y))%R. -by rewrite varianceD/= ?varianceN ?covarianceNr ?muleN ?rpredN. -Qed. - -Lemma varianceD_cst_l c (X : T -> R) : X \in Lfun P 2%:E -> - 'V_P[(cst c \+ X)%R] = 'V_P[X]. -Proof. -move=> X2. -by rewrite varianceD ?Lfun_cst// variance_cst add0e covariance_cst_l mule0 adde0. -Qed. - -Lemma varianceD_cst_r (X : T -> R) c : X \in Lfun P 2%:E -> - 'V_P[(X \+ cst c)%R] = 'V_P[X]. -Proof. -move=> X2. -have -> : (X \+ cst c = cst c \+ X)%R by apply/funeqP => x /=; rewrite addrC. -exact: varianceD_cst_l. -Qed. - -Lemma varianceB_cst_l c (X : T -> R) : X \in Lfun P 2%:E -> - 'V_P[(cst c \- X)%R] = 'V_P[X]. -Proof. -move=> X2; rewrite -[(cst c \- X)%R]/(cst c \+ (\- X))%R. -by rewrite varianceD_cst_l/= ?rpredN// varianceN. -Qed. - -Lemma varianceB_cst_r (X : T -> R) c : X \in Lfun P 2%:E -> - 'V_P[(X \- cst c)%R] = 'V_P[X]. -Proof. -by move=> X2; rewrite -[(X \- cst c)%R]/(X \+ (cst (- c)))%R varianceD_cst_r. -Qed. - -Lemma covariance_le (X Y : T -> R) : X \in Lfun P 2%:E -> Y \in Lfun P 2%:E -> - covariance P X Y <= sqrte 'V_P[X] * sqrte 'V_P[Y]. -Proof. -move=> X2 Y2. -have Pfin : P setT \is a fin_num := fin_num_measure P _ measurableT. -have X1 := Lfun_subset12 Pfin X2. -have Y1 := Lfun_subset12 Pfin Y2. -have XY1 := Lfun2_mul_Lfun1 X2 Y2. -rewrite -sqrteM ?variance_ge0//. -rewrite lee_sqrE ?sqrte_ge0// sqr_sqrte ?mule_ge0 ?variance_ge0//. -rewrite -(fineK (variance_fin_num X2)) -(fineK (variance_fin_num Y2)). -rewrite -(fineK (covariance_fin_num X1 Y1 XY1)). -rewrite -EFin_expe -EFinM lee_fin -(@ler_pM2l _ 4) ?ltr0n// [leRHS]mulrA. -rewrite [in leLHS](_ : 4 = 2 * 2)%R -natrM// [in leLHS]natrM mulrACA -expr2. -rewrite -subr_le0. -set a := fine (variance X). -set b := (2 * fine (covariance P X Y))%R. -set c := fine (variance Y). -pose p := Poly [:: c; b; a]. -have -> : a = p`_2 by rewrite !coefE. -have -> : b = p`_1 by rewrite !coefE. -have -> : c = p`_0 by rewrite !coefE. -rewrite deg_le2_poly_ge0 ?size_Poly// => r. -rewrite horner_Poly/= mul0r add0r mulrDl -mulrA -expr2. -rewrite -lee_fin !EFinD EFinM fineK ?variance_fin_num// muleC -varianceZ//. -rewrite 2!EFinM ?fineK ?variance_fin_num// ?covariance_fin_num//. -rewrite -muleA [_ * r%:E]muleC -covarianceZl//. -rewrite addeAC -varianceD ?variance_ge0//=. -by rewrite Lfun_scale// ler1n. -Qed. - -End variance. -Notation "'V_ P [ X ]" := (variance P X). - -Definition mmt_gen_fun d (T : measurableType d) (R : realType) - (P : probability T R) (X : T -> R) (t : R) := ('E_P[expR \o t \o* X])%E. -Notation "'M_ P X" := (@mmt_gen_fun _ _ _ P X). - -Section markov_chebyshev_cantelli. -Local Open Scope ereal_scope. -Context d (T : measurableType d) (R : realType) (P : probability T R). - -Lemma markov (X : {RV P >-> R}) (f : R -> R) (eps : R) : (0 < eps)%R -> - measurable_fun [set: R] f -> (forall r, 0 <= r -> 0 <= f r)%R -> - {in Num.nneg &, {homo f : x y / x <= y}}%R -> - (f eps)%:E * P [set x | eps%:E <= `| (X x)%:E | ] <= - 'E_P[f \o (fun x => `| x |%R) \o X]. -Proof. -move=> e0 mf f0 f_nd; rewrite -(setTI [set _ | _]). -apply: (le_trans (@le_integral_comp_abse _ _ _ P _ measurableT (EFin \o X) - eps (er_map f) _ _ _ _ e0)) => //=. -- exact: measurable_er_map. -- by case => //= r _; exact: f0. -- move=> [x| |] [y| |]; rewrite !inE/= !in_itv/= ?andbT ?lee_fin ?leey//. - by move=> ? ? ?; rewrite f_nd. -- exact/measurable_EFinP. -- by rewrite unlock. -Qed. - -Lemma chernoff (X : {RV P >-> R}) (r a : R) : (0 < r)%R -> - P [set x | X x >= a]%R <= 'M_P X r * (expR (- (r * a)))%:E. -Proof. -move=> t0; rewrite /mmt_gen_fun. -have -> : expR \o r \o* X = (normr \o normr) \o (expR \o r \o* X). - by apply: funext => t /=; rewrite normr_id ger0_norm ?expR_ge0. -rewrite expRN lee_pdivlMr ?expR_gt0//. -rewrite (le_trans _ (markov _ (expR_gt0 (r * a)) _ _ _))//; last first. - exact: (monoW_in (@ger0_le_norm _)). -rewrite ger0_norm ?expR_ge0// muleC lee_pmul2l// ?lte_fin ?expR_gt0//. -rewrite [X in _ <= P X](_ : _ = [set x | a <= X x]%R)//; apply: eq_set => t/=. -by rewrite ger0_norm ?expR_ge0// lee_fin ler_expR mulrC ler_pM2r. -Qed. - -Lemma chebyshev (X : {RV P >-> R}) (eps : R) : (0 < eps)%R -> - P [set x | (eps <= `| X x - fine ('E_P[X])|)%R ] <= (eps ^- 2)%:E * 'V_P[X]. -Proof. -move => heps; have [->|hv] := eqVneq 'V_P[X] +oo. - by rewrite mulr_infty gtr0_sg ?mul1e// ?leey// invr_gt0// exprn_gt0. -have h (Y : {RV P >-> R}) : - P [set x | (eps <= `|Y x|)%R] <= (eps ^- 2)%:E * 'E_P[Y ^+ 2]. - rewrite -lee_pdivrMl; last by rewrite invr_gt0// exprn_gt0. - rewrite exprnN expfV exprz_inv opprK -exprnP. - apply: (@le_trans _ _ ('E_P[(@GRing.exp R ^~ 2%N \o normr) \o Y])). - apply: (@markov Y (@GRing.exp R ^~ 2%N)) => //. - - by move=> r _; exact: sqr_ge0. - - move=> x y; rewrite !nnegrE => x0 y0. - by rewrite ler_sqr. - apply: expectation_le. - - by apply: measurableT_comp => //; exact: measurableT_comp. - - by []. - - by move=> x /=; exact: sqr_ge0. - - by move=> x /=; exact: sqr_ge0. - - by apply/aeW => t /=; rewrite real_normK// num_real. -have := h (X \- cst (fine ('E_P[X])))%R. -by move=> /le_trans; apply; rewrite /variance [in leRHS]unlock. -Qed. - -Lemma cantelli (X : {RV P >-> R}) (lambda : R) : - (X : T -> R) \in Lfun P 2%:E -> (0 < lambda)%R -> - P [set x | lambda%:E <= (X x)%:E - 'E_P[X]] - <= (fine 'V_P[X] / (fine 'V_P[X] + lambda^2))%:E. -Proof. -move=> /[dup] X2. -move=> /(Lfun_subset12 (fin_num_measure P _ measurableT)) X1 lambda_gt0. -have finEK : (fine 'E_P[X])%:E = 'E_P[X] by rewrite fineK ?expectation_fin_num. -have finVK : (fine 'V_P[X])%:E = 'V_P[X] by rewrite fineK ?variance_fin_num. -pose Y := (X \- cst (fine 'E_P[X]))%R. -have Y2 : (Y : T -> R) \in Lfun P 2%:E. - by rewrite /Y rpredB ?lee1n//= => _; rewrite Lfun_cst. -have EY : 'E_P[Y] = 0. - rewrite expectationB ?Lfun_cst//= expectation_cst. - by rewrite finEK subee// expectation_fin_num. -have VY : 'V_P[Y] = 'V_P[X] by rewrite varianceB_cst_r. -have le (u : R) : (0 <= u)%R -> - P [set x | lambda%:E <= (X x)%:E - 'E_P[X]] - <= ((fine 'V_P[X] + u^2) / (lambda + u)^2)%:E. - move=> uge0; rewrite EFinM. - have -> : (fine 'V_P[X] + u^2)%:E = 'E_P[(Y \+ cst u)^+2]%R. - rewrite -VY -[RHS](@subeK _ _ (('E_P[(Y \+ cst u)%R])^+2)); last first. - rewrite fin_numX// expectation_fin_num//= rpredD ?Lfun_cst//. - by rewrite rpredB// Lfun_cst. - rewrite -varianceE/=; last first. - by rewrite rpredD ?lee1n//= => _; rewrite Lfun_cst. - rewrite -expe2 expectationD/= ?Lfun_cst//; last by rewrite rpredB ?Lfun_cst. - rewrite EY// add0e expectation_cst -EFinM. - by rewrite (varianceD_cst_r _ Y2) EFinD fineK ?variance_fin_num. - have le : [set x | lambda%:E <= (X x)%:E - 'E_P[X]] - `<=` [set x | ((lambda + u)^2)%:E <= ((Y x + u)^+2)%:E]. - move=> x /= le; rewrite lee_fin; apply: lerXn2r. - - exact: addr_ge0 (ltW lambda_gt0) _. - - apply/(addr_ge0 _ uge0)/(le_trans (ltW lambda_gt0) _). - by rewrite -lee_fin EFinB finEK. - - by rewrite lerD2r -lee_fin EFinB finEK. - apply: (le_trans (le_measure _ _ _ le)). - - rewrite -[[set _ | _]]setTI inE; apply: emeasurable_fun_c_infty => [//|]. - apply: emeasurable_funB=> //. - by move/Lfun1_integrable : X1 => /measurable_int. - - rewrite -[[set _ | _]]setTI inE; apply: emeasurable_fun_c_infty => [//|]. - rewrite measurable_EFinP [X in measurable_fun _ X](_ : _ = - (fun x => x ^+ 2) \o (fun x => Y x + u))%R//. - by apply/measurableT_comp => //; exact/measurable_funD. - set eps := ((lambda + u) ^ 2)%R. - have peps : (0 < eps)%R by rewrite exprz_gt0 ?ltr_wpDr. - rewrite (lee_pdivlMr _ _ peps) muleC. - under eq_set => x. - rewrite -[leRHS]gee0_abs ?lee_fin ?sqr_ge0 -?lee_fin => [|//]. - rewrite -[(_ ^+ 2)%R]/(((Y \+ cst u) ^+ 2) x)%R; over. - rewrite -[X in X%:E * _]gtr0_norm => [|//]. - apply: (le_trans (markov _ peps _ _ _)) => //=. - by move=> x y /[!nnegrE] /ger0_norm-> /ger0_norm->. - rewrite -/Y le_eqVlt; apply/orP; left; apply/eqP; congr expectation. - by apply/funeqP => x /=; rewrite -expr2 normr_id ger0_norm ?sqr_ge0. -pose u0 := (fine 'V_P[X] / lambda)%R. -have u0ge0 : (0 <= u0)%R. - by apply: divr_ge0 (ltW lambda_gt0); rewrite -lee_fin finVK variance_ge0. -apply: le_trans (le _ u0ge0) _; rewrite lee_fin le_eqVlt; apply/orP; left. -rewrite eqr_div; [|apply: lt0r_neq0..]; last 2 first. -- by rewrite exprz_gt0 -1?[ltLHS]addr0 ?ltr_leD. -- by rewrite ltr_wpDl ?fine_ge0 ?variance_ge0 ?exprz_gt0. -apply/eqP; have -> : fine 'V_P[X] = (u0 * lambda)%R. - by rewrite /u0 -mulrA mulVr ?mulr1 ?unitfE ?gt_eqF. -by rewrite -mulrDl -mulrDr (addrC u0) [in RHS](mulrAC u0) -exprnP expr2 !mulrA. -Qed. - -End markov_chebyshev_cantelli. - -HB.mixin Record MeasurableFun_isDiscrete d d' (T : measurableType d) - (T' : measurableType d') (X : T -> T') of @MeasurableFun d d' T T' X := { - countable_range : countable (range X) -}. - -HB.structure Definition discreteMeasurableFun d d' (T : measurableType d) - (T' : measurableType d') := { - X of isMeasurableFun d d' T T' X & MeasurableFun_isDiscrete d d' T T' X -}. - -Notation "{ 'dmfun' aT >-> T }" := - (@discreteMeasurableFun.type _ _ aT T) : form_scope. - -Definition discrete_random_variable d d' (T : measurableType d) - (T' : measurableType d') (R : realType) (P : probability T R) := - {dmfun T >-> T'}. - -Notation "{ 'dRV' P >-> T }" := - (@discrete_random_variable _ _ _ T _ P) : form_scope. - -Section dRV_definitions. -Context {d} {d'} {T : measurableType d} {T' : measurableType d'} {R : realType} - (P : probability T R). - -Lemma dRV_dom_enum (X : {dRV P >-> T'}) : - { B : set nat & {splitbij B >-> range X}}. -Proof. -have /countable_bijP/cid[B] := @countable_range _ _ _ _ X. -move/card_esym/ppcard_eqP/unsquash => f. -exists B; exact: f. -Qed. - -Definition dRV_dom (X : {dRV P >-> T'}) : set nat := projT1 (dRV_dom_enum X). - -Definition dRV_enum (X : {dRV P >-> T'}) : {splitbij (dRV_dom X) >-> range X} := - projT2 (dRV_dom_enum X). - -Definition enum_prob (X : {dRV P >-> T'}) := - (fun k => P (X @^-1` [set dRV_enum X k])) \_ (dRV_dom X). - -End dRV_definitions. - -Section distribution_dRV. -Local Open Scope ereal_scope. -Context d d' (T : measurableType d) (T' : measurableType d') (R : realType) - (P : probability T R). -Variable X : {dRV P >-> T'}. - -Lemma distribution_dRV_enum (n : nat) : n \in dRV_dom X -> - distribution P X [set dRV_enum X n] = enum_prob X n. -Proof. -by move=> nX; rewrite /distribution/= /enum_prob/= patchE nX. -Qed. - -Hypothesis measurable_set1T' : forall x : T', measurable [set x]. - -Lemma distribution_dRV A : measurable A -> - distribution P X A = \sum_(k mA; rewrite /distribution /pushforward. -have mAX i : dRV_dom X i -> measurable (X @^-1` (A `&` [set dRV_enum X i])). - move=> domXi; rewrite preimage_setI. - by apply: measurableI; rewrite //-[X in _ X]setTI; exact/measurable_funP. -have tAX : trivIset (dRV_dom X) (fun k => X @^-1` (A `&` [set dRV_enum X k])). - under eq_fun do rewrite preimage_setI; rewrite -/(trivIset _ _). - apply: trivIset_setIl; apply/trivIsetP => i j iX jX /eqP ij. - rewrite -preimage_setI (_ : _ `&` _ = set0)//. - by apply/seteqP; split => //= x [] -> {x} /inj; rewrite inE inE => /(_ iX jX). -have := measure_bigcup P _ (fun k => X @^-1` (A `&` [set dRV_enum X k])) mAX tAX. -rewrite -preimage_bigcup => {mAX tAX}PXU. -rewrite -{1}(setIT A) -(setUv (\bigcup_(i in dRV_dom X) [set dRV_enum X i])). -rewrite setIUr preimage_setU measureU; last 3 first. - - by rewrite preimage_setI; apply: measurableI; rewrite //-[X in _ X]setTI; - apply/measurable_funP => //; exact: bigcup_measurable. - - by rewrite preimage_setI; apply: measurableI; rewrite //-[X in _ X]setTI; - apply/measurable_funP => //; apply: measurableC; exact: bigcup_measurable. - - by rewrite -preimage_setI -setIIr setIA setICK preimage_set0. -rewrite [X in _ + X = _](_ : _ = 0) ?adde0; last first. - rewrite (_ : _ @^-1` _ = set0) ?measure0//; apply/disjoints_subset => x AXx. - rewrite setCK /bigcup /=; exists ((dRV_enum X)^-1 (X x))%function. - exact: funS. - by rewrite invK// inE. -rewrite setI_bigcupr; etransitivity; first exact: PXU. -rewrite eseries_mkcond; apply: eq_eseriesr => k _. -rewrite /enum_prob patchE; case: ifPn => nX; rewrite ?mul0e//. -rewrite diracE; have [kA|] := boolP (_ \in A). - by rewrite mule1 setIidr// => _ /= ->; exact: set_mem. -rewrite notin_setE => kA. -rewrite mule0 (disjoints_subset _ _).2 ?preimage_set0 ?measure0//. -by apply: subsetCr; rewrite sub1set inE. -Qed. - -Lemma sum_enum_prob : \sum_(n /esym; apply: eq_trans. -by rewrite [RHS]eseries_mkcond; apply: eq_eseriesr => k _; rewrite diracT mule1. -Qed. - -End distribution_dRV. - -Section discrete_distribution. -Local Open Scope ereal_scope. -Context d (T : measurableType d) (R : realType) (P : probability T R). - -Lemma dRV_expectation (X : {dRV P >-> R}) : - P.-integrable [set: T] (EFin \o X) -> - 'E_P[X] = \sum_(n ix; rewrite unlock. -rewrite -[in LHS](_ : \bigcup_k (if k \in dRV_dom X then - X @^-1` [set dRV_enum X k] else set0) = setT); last first. - apply/seteqP; split => // t _. - exists ((dRV_enum X)^-1%function (X t)) => //. - case: ifPn=> [_|]. - by rewrite invK// inE. - by rewrite notin_setE/=; apply; apply: funS. -have tA : trivIset (dRV_dom X) (fun k => [set dRV_enum X k]). - by move=> i j iX jX [r [/= ->{r}]] /inj; rewrite !inE; exact. -have {tA}/trivIset_mkcond tXA : - trivIset (dRV_dom X) (fun k => X @^-1` [set dRV_enum X k]). - apply/trivIsetP => /= i j iX jX ij. - move/trivIsetP : tA => /(_ i j iX jX) Aij. - by rewrite -preimage_setI Aij ?preimage_set0. -rewrite integral_bigcup //; last 2 first. - - by move=> k; case: ifPn. - - apply: (integrableS measurableT) => //. - by rewrite -bigcup_mkcond; exact: bigcup_measurable. -transitivity (\sum_(i i _; case: ifPn => iX. - by apply: eq_integral => t; rewrite in_setE/= => ->. - by rewrite !integral_set0. -transitivity (\sum_(i i _; rewrite -integralZl//; last 2 first. - - by case: ifPn. - - apply/integrableP; split => //. - rewrite (eq_integral (cst 1%E)); last by move=> x _; rewrite abse1. - rewrite integral_cst//; last by case: ifPn. - rewrite mul1e (@le_lt_trans _ _ 1%E) ?ltey//. - by case: ifPn => // _; exact: probability_le1. - by apply: eq_integral => y _; rewrite mule1. -apply: eq_eseriesr => k _; case: ifPn => kX. - rewrite /= integral_cst//= mul1e probability_distribution muleC. - by rewrite distribution_dRV_enum. -by rewrite integral_set0 mule0 /enum_prob patchE (negbTE kX) mul0e. -Qed. - -Definition pmf (X : {RV P >-> R}) (r : R) : R := fine (P (X @^-1` [set r])). - -Lemma expectation_pmf (X : {dRV P >-> R}) : - P.-integrable [set: T] (EFin \o X) -> 'E_P[X] = - \sum_(n iX; rewrite dRV_expectation// [in RHS]eseries_mkcond. -apply: eq_eseriesr => k _. -rewrite /enum_prob patchE; case: ifPn => kX; last by rewrite mul0e. -by rewrite /pmf fineK// fin_num_measure. -Qed. - -End discrete_distribution. - -Section bernoulli_pmf. -Context {R : realType} (p : R). -Local Open Scope ring_scope. - -Definition bernoulli_pmf b := if b then p else 1 - p. - -Lemma bernoulli_pmf_ge0 (p01 : 0 <= p <= 1) b : 0 <= bernoulli_pmf b. -Proof. -rewrite /bernoulli_pmf. -by move: p01 => /andP[p0 p1]; case: ifPn => // _; rewrite subr_ge0. -Qed. - -Lemma bernoulli_pmf1 (p01 : 0 <= p <= 1) : - \sum_(i \in [set: bool]) (bernoulli_pmf i)%:E = 1%E. -Proof. -rewrite setT_bool fsbigU//=; last by move=> x [/= ->]. -by rewrite !fsbig_set1/= -EFinD addrCA subrr addr0. -Qed. - -End bernoulli_pmf. - -Lemma measurable_bernoulli_pmf {R : realType} D n : - measurable_fun D (@bernoulli_pmf R ^~ n). -Proof. -by apply/measurable_funTS/measurable_fun_if => //=; exact: measurable_funB. -Qed. - -Definition bernoulli {R : realType} (p : R) : set bool -> \bar R := fun A => - if (0 <= p <= 1)%R then \sum_(b \in A) (bernoulli_pmf p b)%:E else \d_false A. - -Section bernoulli. -Context {R : realType} (p : R). - -Local Notation bernoulli := (bernoulli p). - -Let bernoulli0 : bernoulli set0 = 0. -Proof. -by rewrite /bernoulli; case: ifPn => // p01; rewrite fsbig_set0. -Qed. - -Let bernoulli_ge0 U : (0 <= bernoulli U)%E. -Proof. -rewrite /bernoulli; case: ifPn => // p01. -rewrite fsbig_finite//= sumEFin lee_fin. -by apply: sumr_ge0 => /= b _; exact: bernoulli_pmf_ge0. -Qed. - -Let bernoulli_sigma_additive : semi_sigma_additive bernoulli. -Proof. -move=> F mF tF mUF; rewrite /bernoulli; case: ifPn => p01; last first. - exact: measure_semi_sigma_additive. -apply: cvg_toP. - apply: ereal_nondecreasing_is_cvgn => m n mn. - apply: lee_sum_nneg_natr => // k _ _. - rewrite fsbig_finite//= sumEFin lee_fin. - by apply: sumr_ge0 => /= b _; exact: bernoulli_pmf_ge0. -transitivity (\sum_(0 <= i k _; rewrite esum_fset//= => b _. - by rewrite lee_fin bernoulli_pmf_ge0. -rewrite -nneseries_sum_bigcup//=; last first. - by move=> b; rewrite lee_fin bernoulli_pmf_ge0. -by rewrite esum_fset//= => b _; rewrite lee_fin bernoulli_pmf_ge0. -Qed. - -HB.instance Definition _ := isMeasure.Build _ _ _ bernoulli - bernoulli0 bernoulli_ge0 bernoulli_sigma_additive. - -Let bernoulli_setT : bernoulli [set: _] = 1%E. -Proof. -rewrite /bernoulli/=; case: ifPn => p01; last by rewrite probability_setT. -by rewrite bernoulli_pmf1. -Qed. - -HB.instance Definition _ := - @Measure_isProbability.Build _ _ R bernoulli bernoulli_setT. - -Lemma eq_bernoulli (P : probability bool R) : - P [set true] = p%:E -> P =1 bernoulli. -Proof. -move=> Ptrue sb; rewrite /bernoulli /bernoulli_pmf. -have Pfalse: P [set false] = (1 - p%:E)%E. - rewrite -Ptrue -(probability_setT P) setT_bool measureU//; last first. - by rewrite disjoints_subset => -[]//. - by rewrite addeAC subee ?add0e//= Ptrue. -have: (0 <= p%:E <= 1)%E by rewrite -Ptrue measure_ge0 probability_le1. -rewrite !lee_fin => ->. -have eq_sb := etrans (bigcup_imset1 (_ : set bool) id) (image_id _). -rewrite -[in LHS](eq_sb sb)/= measure_fin_bigcup//; last 2 first. -- exact: finite_finset. -- by move=> [] [] _ _ [[]]//= []. -- by apply: eq_fsbigr => /= -[]. -Qed. - -End bernoulli. - -Section bernoulli_measure. -Context {R : realType}. -Variables (p : R) (p0 : (0 <= p)%R) (p1 : ((NngNum p0)%:num <= 1)%R). - -Lemma bernoulli_dirac : bernoulli p = measure_add - (mscale (NngNum p0) \d_true) (mscale (1 - (Itv01 p0 p1)%:num)%:nng \d_false). -Proof. -apply/funext => U; rewrite /bernoulli; case: ifPn => [p01|]; last first. - by rewrite p0/= p1. -rewrite measure_addE/= /mscale/=. -have := @subsetT _ U; rewrite setT_bool => UT. -have [->|->|->|->] /= := subset_set2 UT. -- rewrite -esum_fset//=; last by move=> b; rewrite lee_fin bernoulli_pmf_ge0. - by rewrite esum_set0 2!measure0 2!mule0 adde0. -- rewrite -esum_fset//=; last by move=> b; rewrite lee_fin bernoulli_pmf_ge0. - rewrite esum_set1/= ?lee_fin// 2!diracE mem_set//= memNset//= mule0 adde0. - by rewrite mule1. -- rewrite -esum_fset//=; last by move=> b; rewrite lee_fin bernoulli_pmf_ge0. - rewrite esum_set1/= ?lee_fin ?subr_ge0// 2!diracE memNset//= mem_set//=. - by rewrite mule0 add0e mule1. -- rewrite fsbigU//=; last by move=> x [->]. - by rewrite 2!fsbig_set1/= -setT_bool 2!diracT !mule1. -Qed. - -End bernoulli_measure. -Arguments bernoulli {R}. - -Lemma eq_bernoulliV2 {R : realType} (P : probability bool R) : - P [set true] = P [set false] -> P =1 bernoulli 2^-1. -Proof. -move=> Ptrue_eq_false; apply/eq_bernoulli. -have : P [set: bool] = 1%E := probability_setT P. -rewrite setT_bool measureU//=; last first. - by rewrite disjoints_subset => -[]//. -rewrite Ptrue_eq_false -mule2n; move/esym/eqP. -by rewrite -mule_natl -eqe_pdivrMl// mule1 => /eqP<-. -Qed. - -Section integral_bernoulli. -Context {R : realType}. -Variables (p : R) (p01 : (0 <= p <= 1)%R). -Local Open Scope ereal_scope. - -Lemma bernoulliE A : bernoulli p A = p%:E * \d_true A + (`1-p)%:E * \d_false A. -Proof. by case/andP : p01 => p0 p1; rewrite bernoulli_dirac// measure_addE. Qed. - -Lemma integral_bernoulli (f : bool -> \bar R) : (forall x, 0 <= f x) -> - \int[bernoulli p]_y (f y) = p%:E * f true + (`1-p)%:E * f false. -Proof. -move=> f0; case/andP : p01 => p0 p1; rewrite bernoulli_dirac/=. -rewrite ge0_integral_measure_sum// 2!big_ord_recl/= big_ord0 adde0/=. -by rewrite !ge0_integral_mscale//= !integral_dirac//= !diracT !mul1e. -Qed. - -End integral_bernoulli. - -Section measurable_bernoulli. -Local Open Scope ring_scope. -Variable R : realType. -Implicit Type p : R. - -Lemma measurable_bernoulli : - measurable_fun setT (bernoulli : R -> pprobability bool R). -Proof. -apply: (@measurability _ _ _ _ _ _ - (@pset _ _ _ : set (set (pprobability _ R)))) => //. -move=> _ -[_ [r r01] [Ys mYs <-]] <-; apply: emeasurable_fun_infty_o => //=. -apply: measurable_fun_if => //=. - by apply: measurable_and => //; exact: measurable_fun_ler. -apply: (eq_measurable_fun (fun t => - \sum_(b <- fset_set Ys) (bernoulli_pmf t b)%:E)). - move=> x /set_mem[_/= x01]. - by rewrite fsbig_finite//=. -apply: emeasurable_sum => n; move=> k Ysk; apply/measurableT_comp => //. -exact: measurable_bernoulli_pmf. -Qed. - -Lemma measurable_bernoulli2 U : measurable U -> - measurable_fun setT (bernoulli ^~ U : R -> \bar R). -Proof. -by move=> ?; exact: (measurable_kernel (kprobability measurable_bernoulli)). -Qed. - -End measurable_bernoulli. -Arguments measurable_bernoulli {R}. - -Section binomial_pmf. -Local Open Scope ring_scope. -Context {R : realType} (n : nat) (p : R). - -Definition binomial_pmf k := p ^+ k * (`1-p) ^+ (n - k) *+ 'C(n, k). - -Lemma binomial_pmf_ge0 k (p01 : (0 <= p <= 1)%R) : 0 <= binomial_pmf k. -Proof. -move: p01 => /andP[p0 p1]; rewrite mulrn_wge0// mulr_ge0// ?exprn_ge0//. -exact: onem_ge0. -Qed. - -End binomial_pmf. - -Lemma measurable_binomial_pmf {R : realType} D n k : - measurable_fun D (@binomial_pmf R n ^~ k). -Proof. -apply: (@measurableT_comp _ _ _ _ _ _ (fun x : R => x *+ 'C(n, k))%R) => /=. - exact: natmul_measurable. -by apply: measurable_funM => //; apply: measurable_funX; exact: measurable_funB. -Qed. - -Definition binomial_prob {R : realType} (n : nat) (p : R) : set nat -> \bar R := - fun U => if (0 <= p <= 1)%R then - \esum_(k in U) (binomial_pmf n p k)%:E else \d_0%N U. - -Section binomial. -Context {R : realType} (n : nat) (p : R). -Local Open Scope ereal_scope. - -Local Notation binomial := (binomial_prob n p). - -Let binomial0 : binomial set0 = 0. -Proof. by rewrite /binomial measure0; case: ifPn => //; rewrite esum_set0. Qed. - -Let binomial_ge0 U : 0 <= binomial U. -Proof. -rewrite /binomial; case: ifPn => // p01; apply: esum_ge0 => /= k Uk. -by rewrite lee_fin binomial_pmf_ge0. -Qed. - -Let binomial_sigma_additive : semi_sigma_additive binomial. -Proof. -move=> F mF tF mUF; rewrite /binomial; case: ifPn => p01; last first. - exact: measure_semi_sigma_additive. -apply: cvg_toP. - apply: ereal_nondecreasing_is_cvgn => a b ab. - apply: lee_sum_nneg_natr => // k _ _. - by apply: esum_ge0 => /= ? _; exact: binomial_pmf_ge0. -by rewrite nneseries_sum_bigcup// => i; rewrite lee_fin binomial_pmf_ge0. -Qed. - -HB.instance Definition _ := isMeasure.Build _ _ _ binomial - binomial0 binomial_ge0 binomial_sigma_additive. - -Let binomial_setT : binomial [set: _] = 1. -Proof. -rewrite /binomial; case: ifPn; last by move=> _; rewrite probability_setT. -move=> p01; rewrite /binomial_pmf. -have pkn k : 0%R <= (p ^+ k * `1-p ^+ (n - k) *+ 'C(n, k))%:E. - case/andP : p01 => p0 p1. - by rewrite lee_fin mulrn_wge0// mulr_ge0 ?exprn_ge0 ?subr_ge0. -rewrite (esumID `I_n.+1)// [X in _ + X]esum1 ?adde0; last first. - by move=> /= k [_ /negP]; rewrite -leqNgt => nk; rewrite bin_small. -rewrite setTI esum_fset// -fsbig_ord//=. -under eq_bigr do rewrite mulrC. -rewrite sumEFin -exprDn_comm; last exact: mulrC. -by rewrite addrC add_onemK expr1n. -Qed. - -HB.instance Definition _ := - @Measure_isProbability.Build _ _ R binomial binomial_setT. - -End binomial. - -Section binomial_probability. -Local Open Scope ring_scope. -Context {R : realType} (n : nat) (p : R) - (p0 : (0 <= p)%R) (p1 : ((NngNum p0)%:num <= 1)%R). - -Definition bin_prob (k : nat) : {nonneg R} := - ((NngNum p0)%:num ^+ k * (NngNum (onem_ge0 p1))%:num ^+ (n - k)%N *+ 'C(n, k))%:nng. - -Lemma bin_prob0 : bin_prob 0 = ((NngNum (onem_ge0 p1))%:num^+n)%:nng. -Proof. -rewrite /bin_prob bin0 subn0/=; apply/val_inj => /=. -by rewrite expr0 mul1r mulr1n. -Qed. - -Lemma bin_prob1 : bin_prob 1 = - ((NngNum p0)%:num * (NngNum (onem_ge0 p1))%:num ^+ n.-1 *+ n)%:nng. -Proof. -by rewrite /bin_prob bin1/=; apply/val_inj => /=; rewrite expr1 subn1. -Qed. - -Lemma binomial_msum : - binomial_prob n p = msum (fun k => mscale (bin_prob k) \d_k) n.+1. -Proof. -apply/funext => U. -rewrite /binomial_prob; case: ifPn => [_|]; last by rewrite p1 p0. -rewrite /msum/= /mscale/= /binomial_pmf. -have pkn k : (0%R <= (p ^+ k * `1-p ^+ (n - k) *+ 'C(n, k))%:E)%E. - by rewrite lee_fin mulrn_wge0// mulr_ge0 ?exprn_ge0 ?subr_ge0. -rewrite (esumID `I_n.+1)//= [X in _ + X]esum1 ?adde0; last first. - by move=> /= k [_ /negP]; rewrite -leqNgt => nk; rewrite bin_small. -rewrite esum_mkcondl esum_fset//; last by move=> i /= _; case: ifPn. -rewrite -fsbig_ord//=; apply: eq_bigr => i _. -by rewrite diracE; case: ifPn => /= iU; [rewrite mule1|rewrite mule0]. -Qed. - -Lemma binomial_probE U : binomial_prob n p U = - (\sum_(k < n.+1) (bin_prob k)%:num%:E * (\d_(nat_of_ord k) U))%E. -Proof. by rewrite binomial_msum. Qed. - -Lemma integral_binomial (f : nat -> \bar R) : (forall x, 0 <= f x)%E -> - (\int[binomial_prob n p]_y (f y) = - \sum_(k < n.+1) (bin_prob k)%:num%:E * f k)%E. -Proof. -move=> f0; rewrite binomial_msum ge0_integral_measure_sum//=. -apply: eq_bigr => i _. -by rewrite ge0_integral_mscale//= integral_dirac//= diracT mul1e. -Qed. - -End binomial_probability. - -Lemma integral_binomial_prob (R : realType) n p U : (0 <= p <= 1)%R -> - (\int[binomial_prob n p]_y \d_(0 < y)%N U = - bernoulli (1 - `1-p ^+ n) U :> \bar R)%E. -Proof. -move=> /andP[p0 p1]; rewrite bernoulliE//=; last first. - rewrite subr_ge0 exprn_ile1//=; [|exact/onem_ge0|exact/onem_le1]. - by rewrite lerBlDr addrC -lerBlDr subrr; exact/exprn_ge0/onem_ge0. -rewrite (@integral_binomial _ n p _ _ (fun y => \d_(1 <= y)%N U))//. -rewrite !big_ord_recl/=. -rewrite expr0 mul1r subn0 bin0 ltnn mulr1n addrC. -rewrite onemD opprK onem1 add0r; congr +%E. -rewrite /bump; under eq_bigr do rewrite leq0n add1n ltnS leq0n. -rewrite -ge0_sume_distrl; last first. - move=> i _. - by apply/mulrn_wge0/mulr_ge0; apply/exprn_ge0 => //; exact/onem_ge0. -congr *%E. -transitivity (\sum_(i < n.+1) (`1-p ^+ (n - i) * p ^+ i *+ 'C(n, i))%:E - - (`1-p ^+ n)%:E)%E. - rewrite big_ord_recl/=. - rewrite expr0 mulr1 subn0 bin0 mulr1n addrAC -EFinD subrr add0e. - by rewrite /bump; under [RHS]eq_bigr do rewrite leq0n add1n mulrC. -rewrite sumEFin -(@exprDn_comm _ `1-p p n)//. - by rewrite subrK expr1n. -by rewrite /GRing.comm/onem mulrC. -Qed. - -Lemma measurable_binomial_prob (R : realType) (n : nat) : - measurable_fun setT (binomial_prob n : R -> pprobability _ _). -Proof. -apply: (@measurability _ _ _ _ _ _ - (@pset _ _ _ : set (set (pprobability _ R)))) => //. -move=> _ -[_ [r r01] [Ys mYs <-]] <-; apply: emeasurable_fun_infty_o => //=. -rewrite /binomial_prob/=. -set f := (X in measurable_fun _ X). -apply: measurable_fun_if => //=. - by apply: measurable_and => //; exact: measurable_fun_ler. -apply: (eq_measurable_fun (fun t => - \sum_(k x /set_mem[_/= x01]. - rewrite nneseries_esum// -1?[in RHS](set_mem_set Ys)// => k kYs. - by rewrite lee_fin binomial_pmf_ge0. -apply: ge0_emeasurable_sum. - by move=> k x/= [_ x01] _; rewrite lee_fin binomial_pmf_ge0. -move=> k Ysk; apply/measurableT_comp => //. -exact: measurable_binomial_pmf. -Qed. - -Section uniform_probability. -Local Open Scope ring_scope. -Context (R : realType) (a b : R). - -Definition uniform_pdf x := if a <= x <= b then (b - a)^-1 else 0. - -Lemma uniform_pdf_ge0 x : a < b -> 0 <= uniform_pdf x. -Proof. -move=> ab; rewrite /uniform_pdf; case: ifPn => // axb. -by rewrite invr_ge0// ltW// subr_gt0. -Qed. - -Lemma measurable_uniform_pdf : measurable_fun setT uniform_pdf. -Proof. -rewrite /uniform_pdf /=; apply: measurable_fun_if => //=. -by apply: measurable_and => //; exact: measurable_fun_ler. -Qed. - -Local Notation mu := lebesgue_measure. - -Lemma integral_uniform_pdf U : - (\int[mu]_(x in U) (uniform_pdf x)%:E = - \int[mu]_(x in U `&` `[a, b]) (uniform_pdf x)%:E)%E. -Proof. -rewrite [RHS]integral_mkcondr/=; apply: eq_integral => x xU. -rewrite patchE; case: ifPn => //. -rewrite notin_setE/= in_itv/= => /negP/negbTE xab. -by rewrite /uniform_pdf xab. -Qed. - -Lemma integral_uniform_pdf1 A (ab : a < b) : `[a, b] `<=` A -> - (\int[mu]_(x in A) (uniform_pdf x)%:E = 1)%E. -Proof. -move=> abA; rewrite integral_uniform_pdf setIidr//. -rewrite (eq_integral (fun=> (b - a)^-1%:E)); last first. - by move=> x; rewrite inE/= in_itv/= /uniform_pdf => ->. -rewrite integral_cst//= lebesgue_measure_itv/= lte_fin. -by rewrite ab -EFinD -EFinM mulVf// gt_eqF// subr_gt0. -Qed. - -Definition uniform_prob (ab : a < b) : set _ -> \bar R := - fun U => (\int[mu]_(x in U) (uniform_pdf x)%:E)%E. - -Hypothesis ab : (a < b)%R. - -Let uniform0 : uniform_prob ab set0 = 0. -Proof. by rewrite /uniform_prob integral_set0. Qed. - -Let uniform_ge0 U : (0 <= uniform_prob ab U)%E. -Proof. -by apply: integral_ge0 => /= x Ux; rewrite lee_fin uniform_pdf_ge0. -Qed. - -Lemma integrable_uniform_pdf : - mu.-integrable setT (fun x => (uniform_pdf x)%:E). -Proof. -apply/integrableP; split. - by apply: measurableT_comp => //; exact: measurable_uniform_pdf. -under eq_integral. - move=> x _; rewrite gee0_abs//; last by rewrite lee_fin uniform_pdf_ge0. - over. -by rewrite /= integral_uniform_pdf1 ?ltry// -subr_gt0. -Qed. - -Let uniform_sigma_additive : semi_sigma_additive (uniform_prob ab). -Proof. -move=> /= F mF tF mUF; rewrite /uniform_prob; apply: cvg_toP. - apply: ereal_nondecreasing_is_cvgn => m n mn. - apply: lee_sum_nneg_natr => // k _ _. - by apply: integral_ge0 => /= x Fkx; rewrite lee_fin uniform_pdf_ge0. -rewrite ge0_integral_bigcup//=. -- apply: measurable_funTS; apply: measurableT_comp => //. - exact: measurable_uniform_pdf. -- by move=> x _; rewrite lee_fin uniform_pdf_ge0. -Qed. - -HB.instance Definition _ := isMeasure.Build _ _ _ (uniform_prob ab) - uniform0 uniform_ge0 uniform_sigma_additive. - -Let uniform_setT : uniform_prob ab [set: _] = 1%:E. -Proof. by rewrite /uniform_prob /mscale/= integral_uniform_pdf1. Qed. - -HB.instance Definition _ := @Measure_isProbability.Build _ _ R - (uniform_prob ab) uniform_setT. - -Lemma dominates_uniform_prob : uniform_prob ab `<< mu. -Proof. -move=> A mA muA0; rewrite /uniform_prob integral_uniform_pdf. -apply/eqP; rewrite eq_le; apply/andP; split; last first. - apply: integral_ge0 => x [Ax /=]; rewrite in_itv /= => xab. - by rewrite lee_fin uniform_pdf_ge0. -apply: (@le_trans _ _ - (\int[mu]_(x in A `&` `[a, b]%classic) (b - a)^-1%:E))%E; last first. - rewrite integral_cst//= ?mul1e//. - by rewrite pmule_rle0 ?lte_fin ?invr_gt0// ?subr_gt0// -muA0 measureIl. - exact: measurableI. -apply: ge0_le_integral => //=. -- exact: measurableI. -- by move=> x [Ax]; rewrite /= in_itv/= => axb; rewrite lee_fin uniform_pdf_ge0. -- by apply/measurable_EFinP/measurable_funTS; exact: measurable_uniform_pdf. -- by move=> x [Ax _]; rewrite lee_fin invr_ge0// ltW// subr_gt0. -- by move=> x [Ax]; rewrite in_itv/= /uniform_pdf => ->. -Qed. - -Let integral_uniform_indic E : measurable E -> - (\int[uniform_prob ab]_x (\1_E x)%:E = - (b - a)^-1%:E * \int[mu]_(x in `[a, b]) (\1_E x)%:E)%E. -Proof. -move=> mE; rewrite integral_indic//= /uniform_prob setIT -ge0_integralZl//=. -- rewrite [LHS]integral_mkcond/= [RHS]integral_mkcond/=. - apply: eq_integral => x _; rewrite !patchE; case: ifPn => xE. - case: ifPn. - rewrite inE/= in_itv/= => xab. - by rewrite /uniform_pdf xab indicE xE mule1. - by rewrite notin_setE/= in_itv/= => /negP/negbTE; rewrite /uniform_pdf => ->. - case: ifPn => //. - by rewrite inE/= in_itv/= => axb; rewrite indicE (negbTE xE) mule0. -- exact/measurable_EFinP/measurable_indic. -- by rewrite lee_fin invr_ge0// ltW// subr_gt0. -Qed. - -Import HBNNSimple. - -Let integral_uniform_nnsfun (f : {nnsfun _ >-> R}) : - (\int[uniform_prob ab]_x (f x)%:E = - (b - a)^-1%:E * \int[mu]_(x in `[a, b]) (f x)%:E)%E. -Proof. -under [LHS]eq_integral do rewrite fimfunE -fsumEFin//. -rewrite [LHS]ge0_integral_fsum//; last 2 first. - - by move=> r; exact/measurable_EFinP/measurableT_comp. - - by move=> n x _; rewrite EFinM nnfun_muleindic_ge0. -rewrite -[RHS]ge0_integralZl//; last 3 first. - - exact/measurable_EFinP/measurable_funTS. - - by move=> x _; rewrite lee_fin. - - by rewrite lee_fin invr_ge0// ltW// subr_gt0. -under [RHS]eq_integral. - move=> x xD; rewrite fimfunE -fsumEFin// ge0_mule_fsumr; last first. - by move=> r; rewrite EFinM nnfun_muleindic_ge0. - over. -rewrite [RHS]ge0_integral_fsum//; last 2 first. - - by move=> r; apply/measurable_EFinP; do 2 apply/measurableT_comp => //. - - move=> n x _; rewrite EFinM mule_ge0//; last by rewrite nnfun_muleindic_ge0. - by rewrite lee_fin invr_ge0// ltW// subr_gt0. -apply: eq_fsbigr => r _; rewrite ge0_integralZl//. -- by rewrite !integralZl_indic_nnsfun//= integral_uniform_indic// muleCA. -- exact/measurable_EFinP/measurableT_comp. -- by move=> t _; rewrite nnfun_muleindic_ge0. -- by rewrite lee_fin invr_ge0// ltW// subr_gt0. -Qed. - -Lemma integral_uniform (f : _ -> \bar R) : - measurable_fun setT f -> (forall x, 0 <= f x)%E -> - (\int[uniform_prob ab]_x f x = (b - a)^-1%:E * \int[mu]_(x in `[a, b]) f x)%E. -Proof. -move=> mf f0. -pose f_ := nnsfun_approx measurableT mf. -transitivity (lim (\int[uniform_prob ab]_x (f_ n x)%:E @[n --> \oo])%E). - rewrite -monotone_convergence//=. - - apply: eq_integral => ? /[!inE] xD; apply/esym/cvg_lim => //=. - exact: cvg_nnsfun_approx. - - by move=> n; exact/measurable_EFinP/measurable_funTS. - - by move=> n ? _; rewrite lee_fin. - - by move=> ? _ ? ? mn; rewrite lee_fin; exact/lefP/nd_nnsfun_approx. -rewrite [X in _ = (_ * X)%E](_ : _ = lim - (\int[mu]_(x in `[a, b]) (f_ n x)%:E @[n --> \oo])%E); last first. - rewrite -monotone_convergence//=. - - apply: eq_integral => ? /[!inE] xD; apply/esym/cvg_lim => //. - exact: cvg_nnsfun_approx. - - by move=> n; exact/measurable_EFinP/measurable_funTS. - - by move=> n ? _; rewrite lee_fin. - - by move=> ? _ ? ? ?; rewrite lee_fin; exact/lefP/nd_nnsfun_approx. -rewrite -limeMl//. - by apply: congr_lim; apply/funext => n /=; exact: integral_uniform_nnsfun. -apply/ereal_nondecreasing_is_cvgn => x y xy; apply: ge0_le_integral => //=. -- by move=> ? _; rewrite lee_fin. -- exact/measurable_EFinP/measurable_funTS. -- by move=> ? _; rewrite lee_fin. -- exact/measurable_EFinP/measurable_funTS. -- by move=> ? _; rewrite lee_fin; exact/lefP/nd_nnsfun_approx. -Qed. - -End uniform_probability. - -Section normal_density. -Context {R : realType}. -Local Open Scope ring_scope. -Local Import Num.ExtraDef. -Implicit Types m s x : R. - -Definition normal_fun m s x := expR (- (x - m) ^+ 2 / (s ^+ 2 *+ 2)). - -Lemma measurable_normal_fun m s : measurable_fun [set :R] (normal_fun m s). -Proof. -apply: measurableT_comp => //=; apply: measurable_funM => //=. -apply: measurableT_comp => //=; apply: measurable_funX => //=. -exact: measurable_funB. -Qed. - -Lemma normal_fun_ge0 m s x : 0 <= normal_fun m s x. -Proof. exact: expR_ge0. Qed. - -Lemma normal_fun_center m s : normal_fun m s = normal_fun 0 s \o center m. -Proof. by apply/funext => x/=; rewrite /normal_fun/= subr0. Qed. - -Definition normal_peak s := (sqrtr (s ^+ 2 * pi *+ 2))^-1. - -Lemma normal_peak_ge0 s : 0 <= normal_peak s. Proof. by rewrite invr_ge0. Qed. - -Lemma normal_peak_gt0 s : s != 0 -> 0 < normal_peak s. -Proof. -move=> s0; rewrite invr_gt0// sqrtr_gt0. -by rewrite pmulrn_rgt0// mulr_gt0 ?pi_gt0// exprn_even_gt0/=. -Qed. - -Let normal_pdf0 m s x : R := normal_peak s * normal_fun m s x. - -Definition normal_pdf m s x := - if s == 0 then \1_`[0, 1] x else normal_pdf0 m s x. - -Lemma normal_pdfE m s : s != 0 -> normal_pdf m s = normal_pdf0 m s. -Proof. by rewrite /normal_pdf; have [_|s0] := eqVneq s 0. Qed. - -Let normal_pdf0_center m s : normal_pdf0 m s = normal_pdf0 0 s \o center m. -Proof. by rewrite /normal_pdf0 normal_fun_center. Qed. - -Let normal_pdf0_ge0 m s x : 0 <= normal_pdf0 m s x. -Proof. by rewrite mulr_ge0 ?normal_peak_ge0 ?expR_ge0. Qed. - -Let normal_pdf0_gt0 m s x : s != 0 -> 0 < normal_pdf0 m s x. -Proof. by move=> s0; rewrite mulr_gt0 ?expR_gt0// normal_peak_gt0. Qed. - -Let measurable_normal_pdf0 m s : measurable_fun setT (normal_pdf0 m s). -Proof. by apply: measurable_funM => //=; exact: measurable_normal_fun. Qed. - -Lemma measurable_normal_pdf m s : measurable_fun setT (normal_pdf m s). -Proof. -by rewrite /normal_pdf; have [_|] := eqVneq s 0; first exact: measurable_indic. -Qed. - -Let continuous_normal_pdf0 m s : continuous (normal_pdf0 m s). -Proof. -move=> x; apply: cvgM; first exact: cvg_cst. -apply: (cvg_comp _ expR); last exact: continuous_expR. -apply: cvgM; last exact: cvg_cst. -apply: (@cvgN _ R^o). -apply: (cvg_comp (fun x => x - m) (fun x => x ^+ 2)). - by apply: (@cvgB _ R^o) => //; [exact: cvg_id|exact: cvg_cst]. -exact: sqr_continuous. -Qed. - -Let normal_pdf0_ub m s x : normal_pdf0 m s x <= normal_peak s. -Proof. -rewrite /normal_pdf0 ler_piMr ?normal_peak_ge0//. -rewrite -[leRHS]expR0 ler_expR mulNr oppr_le0 mulr_ge0// ?sqr_ge0//. -by rewrite invr_ge0 mulrn_wge0// sqr_ge0. -Qed. - -Lemma normal_pdf_ge0 m s x : 0 <= normal_pdf m s x. -Proof. by rewrite /normal_pdf; case: ifP. Qed. - -Lemma continuous_normal_pdf m s : s != 0 -> continuous (normal_pdf m s). -Proof. by rewrite /normal_pdf; have [|] := eqVneq s 0. Qed. - -Lemma normal_pdf_ub m s x : s != 0 -> normal_pdf m s x <= normal_peak s. -Proof. by rewrite /normal_pdf; have [|] := eqVneq s 0. Qed. - -End normal_density. - -Definition normal_prob {R : realType} (m : R) (s : R) : set _ -> \bar R := - fun V => (\int[lebesgue_measure]_(x in V) (normal_pdf m s x)%:E)%E. - -Section normal_probability. -Variables (R : realType) (m sigma : R). -Local Open Scope ring_scope. -Notation mu := lebesgue_measure. - -Local Notation normal_peak := (normal_peak sigma). -Local Notation normal_fun := (normal_fun m sigma). - -Let F (x : R^o) := (x - m) / (Num.sqrt (sigma ^+ 2 *+ 2)). - -Let normal_gauss_fun x : normal_fun x = gauss_fun (F x). -Proof. -congr expR; rewrite mulNr exprMn exprVn; congr (- (_ * _^-1)%R). -by rewrite sqr_sqrtr// pmulrn_lge0// sqr_ge0. -Qed. - -Let F'E : F^`()%classic = cst (Num.sqrt (sigma ^+ 2 *+ 2))^-1. -Proof. -apply/funext => x; rewrite /F derive1E deriveM// deriveD// derive_cst scaler0. -by rewrite add0r derive_id derive_cst addr0 scaler1. -Qed. - -Let integral_gaussFF' : sigma != 0 -> - (\int[mu]_x ((((gauss_fun \o F) * - (F^`())%classic) x)%:E * (Num.sqrt (sigma ^+ 2 *+ 2))%:E))%E = - normal_peak^-1%:E. -Proof. -move=> s0; rewrite /normal_peak invrK. -rewrite -mulrnAr -[in RHS]mulr_natr sqrtrM ?(sqrtrM 2) ?sqr_ge0 ?pi_ge0// !EFinM. -rewrite muleCA ge0_integralZr//=; first last. - by move=> x _; rewrite lee_fin mulr_ge0//= ?gauss_fun_ge0// F'E/= invr_ge0. - rewrite F'E; apply/measurable_EFinP/measurable_funM => //. - apply/measurableT_comp => //; first exact: measurable_gauss_fun. - by apply: measurable_funM => //; exact: measurable_funD. -congr *%E; last by rewrite -(mulr_natr (_ ^+ 2)) sqrtrM ?sqr_ge0. -rewrite -increasing_ge0_integration_by_substitutionT//. -- exact: integralT_gauss. -- move=> x y xy; rewrite /F ltr_pM2r ?ltr_leB ?gt_eqF//. - by rewrite invr_gt0 ?sqrtr_gt0 ?pmulrn_lgt0 ?exprn_even_gt0. -- by rewrite F'E => ?; exact: cvg_cst. -- by rewrite F'E; exact: is_cvg_cst. -- by rewrite F'E; exact: is_cvg_cst. -- apply/gt0_cvgMlNy; last exact: cvg_addrr_Ny. - by rewrite invr_gt0// sqrtr_gt0 -mulr_natr mulr_gt0// exprn_even_gt0. -- apply/gt0_cvgMly; last exact: cvg_addrr. - by rewrite invr_gt0// sqrtr_gt0 -mulr_natr mulr_gt0// exprn_even_gt0. -- exact: continuous_gauss_fun. -- by move=> x; rewrite gauss_fun_ge0. -Qed. - -Let integral_normal_fun : sigma != 0 -> - (\int[mu]_x (normal_fun x)%:E)%E = normal_peak^-1%:E. -Proof. -move=> s0; rewrite -integral_gaussFF'//; apply: eq_integral => /= x _. -rewrite F'E !fctE/= EFinM -muleA -EFinM mulVf ?mulr1 ?mule1. - by rewrite normal_gauss_fun. -by rewrite gt_eqF// sqrtr_gt0 pmulrn_lgt0// exprn_even_gt0. -Qed. - -Let integrable_normal_fun : sigma != 0 -> - mu.-integrable [set: R] (EFin \o normal_fun). -Proof. -move=> s0; apply/integrableP; split. - by apply/measurable_EFinP; exact: measurable_normal_fun. -under eq_integral do rewrite /= ger0_norm ?expR_ge0//. -by rewrite /= integral_normal_fun// ltry. -Qed. - -Lemma integral_normal_pdf : (\int[mu]_x (normal_pdf m sigma x)%:E = 1%E)%E. -Proof. -rewrite /normal_pdf; have [_|s0] := eqVneq sigma 0. - by rewrite integral_indic//= setIT lebesgue_measure_itv/= lte01 oppr0 adde0. -under eq_integral do rewrite EFinM. -rewrite integralZl//=; last exact: integrable_normal_fun. -by rewrite integral_normal_fun// -EFinM divff// gt_eqF// normal_peak_gt0. -Qed. - -Lemma integrable_normal_pdf : mu.-integrable [set: R] - (fun x => (normal_pdf m sigma x)%:E). -Proof. -apply/integrableP; split. - by apply/measurable_EFinP; exact: measurable_normal_pdf. -apply/abse_integralP => //=; last by rewrite integral_normal_pdf abse1 ltry. -by apply/measurable_EFinP; exact: measurable_normal_pdf. -Qed. - -Local Notation normal_pdf := (normal_pdf m sigma). -Local Notation normal_prob := (normal_prob m sigma). - -Let normal0 : normal_prob set0 = 0%E. -Proof. by rewrite /normal_prob integral_set0. Qed. - -Let normal_ge0 A : (0 <= normal_prob A)%E. -Proof. -rewrite /normal_prob integral_ge0//= => x _. -by rewrite lee_fin normal_pdf_ge0 ?ltW. -Qed. - -Let normal_sigma_additive : semi_sigma_additive normal_prob. -Proof. -move=> /= A mA tA mUA. -rewrite /normal_prob/= integral_bigcup//=; last first. - by apply: (integrableS _ _ (subsetT _)) => //; exact: integrable_normal_pdf. -apply: is_cvg_ereal_nneg_natsum_cond => n _ _. -by apply: integral_ge0 => /= x ?; rewrite lee_fin normal_pdf_ge0 ?ltW. -Qed. - -HB.instance Definition _ := isMeasure.Build _ _ _ - normal_prob normal0 normal_ge0 normal_sigma_additive. - -Let normal_setT : normal_prob [set: _] = 1%E. -Proof. by rewrite /normal_prob integral_normal_pdf. Qed. - -HB.instance Definition _ := - @Measure_isProbability.Build _ _ R normal_prob normal_setT. - -Lemma normal_prob_dominates : normal_prob `<< mu. -Proof. -move=> A mA muA0; rewrite /normal_prob /normal_pdf. -have [s0|s0] := eqVneq sigma 0. - apply: null_set_integral => //=; apply: (integrableS measurableT) => //=. - exact: integrable_indic_itv. -apply/eqP; rewrite eq_le; apply/andP; split; last first. - apply: integral_ge0 => x _. - by rewrite lee_fin mulr_ge0 ?normal_peak_ge0 ?normal_fun_ge0. -apply: (@le_trans _ _ (\int[mu]_(x in A) (normal_peak)%:E))%E; last first. - by rewrite integral_cst//= muA0 mule0. -apply: ge0_le_integral => //=. -- by move=> x _; rewrite lee_fin mulr_ge0 ?normal_peak_ge0 ?normal_fun_ge0. -- apply/measurable_funTS/measurableT_comp => //=. - by apply: measurable_funM => //; exact: measurable_normal_fun. -- by move=> x _; rewrite lee_fin normal_peak_ge0. -- by move=> x _; have := normal_pdf_ub m x s0; rewrite /normal_pdf (negbTE s0). -Qed. - -End normal_probability. - -Section exponential_pdf. -Context {R : realType}. -Notation mu := lebesgue_measure. -Variable rate : R. -Hypothesis rate_gt0 : 0 < rate. - -Let exponential_pdfT x := rate * expR (- rate * x). -Definition exponential_pdf := exponential_pdfT \_ `[0%R, +oo[. - -Lemma exponential_pdf_ge0 x : 0 <= exponential_pdf x. -Proof. -by apply: restrict_ge0 => {}x _; apply: mulr_ge0; [exact: ltW|exact: expR_ge0]. -Qed. - -Lemma lt0_exponential_pdf x : x < 0 -> exponential_pdf x = 0. -Proof. -move=> x0; rewrite /exponential_pdf patchE ifF//. -by apply/negP; rewrite inE/= in_itv/= andbT; apply/negP; rewrite -ltNge. -Qed. - -Let continuous_exponential_pdfT : continuous exponential_pdfT. -Proof. -move=> x. -apply: (@continuousM _ R^o (fun=> rate) (fun x => expR (- rate * x))). - exact: cst_continuous. -apply: continuous_comp; last exact: continuous_expR. -by apply: continuousM => //; apply: (@continuousN _ R^o); exact: cst_continuous. -Qed. - -Lemma measurable_exponential_pdf : measurable_fun [set: R] exponential_pdf. -Proof. -apply/measurable_restrict => //; apply: measurable_funTS. -exact: continuous_measurable_fun. -Qed. - -Lemma exponential_pdfE x : 0 <= x -> exponential_pdf x = exponential_pdfT x. -Proof. -by move=> x0; rewrite /exponential_pdf patchE ifT// inE/= in_itv/= x0. -Qed. - -Lemma in_continuous_exponential_pdf : - {in `]0, +oo[%R, continuous exponential_pdf}. -Proof. -move=> x; rewrite in_itv/= andbT => x0. -apply/(@cvgrPdist_lt _ R^o) => e e0; near=> y. -rewrite 2?(exponential_pdfE (ltW _))//; last by near: y; exact: lt_nbhsr. -near: y; move: e e0; apply/(@cvgrPdist_lt _ R^o). -by apply: continuous_comp => //; exact: continuous_exponential_pdfT. -Unshelve. end_near. Qed. - -Lemma within_continuous_exponential_pdf : - {within [set` `[0, +oo[%R], continuous exponential_pdf}. -Proof. -apply/continuous_within_itvcyP; split. - exact: in_continuous_exponential_pdf. -apply/(@cvgrPdist_le _ R^o) => e e0; near=> t. -rewrite 2?exponential_pdfE//. -near: t; move: e e0; apply/cvgrPdist_le. -by apply: cvg_at_right_filter; exact: continuous_exponential_pdfT. -Unshelve. end_near. Qed. - -End exponential_pdf. - -Definition exponential_prob {R : realType} (rate : R) := - fun V => (\int[lebesgue_measure]_(x in V) (exponential_pdf rate x)%:E)%E. - -Section exponential_prob. -Context {R : realType}. -Local Open Scope ring_scope. -Notation mu := lebesgue_measure. -Variable rate : R. -Hypothesis rate_gt0 : 0 < rate. - -Lemma derive1_exponential_pdf : - {in `]0, +oo[%R, (fun x => - (expR : R^o -> R^o) (- rate * x))^`()%classic - =1 exponential_pdf rate}. -Proof. -move=> z; rewrite in_itv/= andbT => z0. -rewrite derive1_comp// derive1N// derive1_id mulN1r derive1_comp// derive1E. -have/funeqP -> := @derive_expR R. -by rewrite derive1Ml// derive1_id mulr1 mulrN opprK mulrC exponential_pdfE ?ltW. -Qed. - -Let cexpNM : continuous (fun z : R^o => expR (- rate * z)). -Proof. -move=> z; apply: continuous_comp; last exact: continuous_expR. -by apply: continuousM => //; apply: (@continuousN _ R^o); exact: cst_continuous. -Qed. - -Lemma exponential_prob_itv0c (x : R) : 0 < x -> - exponential_prob rate `[0, x] = (1 - (expR (- rate * x))%:E)%E. -Proof. -move=> x0. -rewrite (_: 1 = - (- expR (- rate * 0))%:E)%E; last first. - by rewrite mulr0 expR0 EFinN oppeK. -rewrite addeC. -apply: (@continuous_FTC2 _ _ (fun x => - expR (- rate * x))) => //. -- apply: (@continuous_subspaceW R^o _ _ [set` `[0, +oo[%R]). - + exact: subset_itvl. - + exact: within_continuous_exponential_pdf. -- split. - + by move=> z _; exact: ex_derive. - + by apply/cvg_at_right_filter; apply: cvgN; exact: cexpNM. - + by apply/cvg_at_left_filter; apply: cvgN; exact: cexpNM. -- move=> z; rewrite in_itv/= => /andP[z0 _]. - by apply: derive1_exponential_pdf; rewrite in_itv/= andbT. -Qed. - -Lemma integral_exponential_pdf : (\int[mu]_x (exponential_pdf rate x)%:E = 1)%E. -Proof. -have mEex : measurable_fun setT (EFin \o exponential_pdf rate). - by apply/measurable_EFinP; exact: measurable_exponential_pdf. -rewrite -(setUv `[0, +oo[%classic) ge0_integral_setU//=; last 4 first. - exact: measurableC. - by rewrite setUv. - by move=> x _; rewrite lee_fin exponential_pdf_ge0. - exact/disj_setPCl. -rewrite [X in _ + X]integral0_eq ?adde0; last first. - by move=> x x0; rewrite /exponential_pdf patchE ifF// memNset. -rewrite (@ge0_continuous_FTC2y _ _ - (fun x => - (expR (- rate * x))) _ 0)//. -- by rewrite mulr0 expR0 EFinN oppeK add0e. -- by move=> x _; apply: exponential_pdf_ge0. -- exact: within_continuous_exponential_pdf. -- rewrite -oppr0; apply: (@cvgN _ R^o). - rewrite (_ : (fun x => expR (- rate * x)) = - (fun z => expR (- z)) \o (fun z => rate * z)); last first. - by apply: eq_fun => x; rewrite mulNr. - apply: (@cvg_comp _ R^o _ _ _ _ (pinfty_nbhs R)); last exact: cvgr_expR. - exact: gt0_cvgMry. -- by apply: (@cvgN _ R^o); apply: cvg_at_right_filter; exact: cexpNM. -- exact: derive1_exponential_pdf. -Qed. - -Lemma integrable_exponential_pdf : - mu.-integrable setT (EFin \o (exponential_pdf rate)). -Proof. -have mEex : measurable_fun setT (EFin \o exponential_pdf rate). - by apply/measurable_EFinP; exact: measurable_exponential_pdf. -apply/integrableP; split => //. -under eq_integral do rewrite /= ger0_norm ?exponential_pdf_ge0//. -by rewrite /= integral_exponential_pdf ltry. -Qed. - -Local Notation exponential := (exponential_prob rate). - -Let exponential0 : exponential set0 = 0%E. -Proof. by rewrite /exponential integral_set0. Qed. - -Let exponential_ge0 A : (0 <= exponential A)%E. -Proof. -rewrite /exponential integral_ge0//= => x _. -by rewrite lee_fin exponential_pdf_ge0. -Qed. - -Let exponential_sigma_additive : semi_sigma_additive exponential. -Proof. -move=> /= F mF tF mUF; rewrite /exponential; apply: cvg_toP. - apply: ereal_nondecreasing_is_cvgn => m n mn. - apply: lee_sum_nneg_natr => // k _ _; apply: integral_ge0 => /= x Fkx. - by rewrite lee_fin; apply: exponential_pdf_ge0. -rewrite ge0_integral_bigcup//=. -- apply/measurable_funTS/measurableT_comp => //. - exact: measurable_exponential_pdf. -- by move=> x _; rewrite lee_fin exponential_pdf_ge0. -Qed. - -HB.instance Definition _ := isMeasure.Build _ _ _ - exponential exponential0 exponential_ge0 exponential_sigma_additive. - -Let exponential_setT : exponential [set: R] = 1%E. -Proof. by rewrite /exponential integral_exponential_pdf. Qed. - -HB.instance Definition _ := - @Measure_isProbability.Build _ _ R exponential exponential_setT. - -End exponential_prob. diff --git a/theories/topology_theory/.DS_Store b/theories/topology_theory/.DS_Store deleted file mode 100644 index 5008ddfcf53c02e82d7eee2e57c38e5672ef89f6..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 6148 zcmeH~Jr2S!425mzP>H1@V-^m;4Wg<&0T*E43hX&L&p$$qDprKhvt+--jT7}7np#A3 zem<@ulZcFPQ@L2!n>{z**++&mCkOWA81W14cNZlEfg7;MkzE(HCqgga^y>{tEnwC%0;vJ&^%eQ zLs35+`xjp>T0 Date: Sun, 13 Jul 2025 14:36:22 +0900 Subject: [PATCH 05/10] generalize cumulative --- theories/topology_theory/num_topology.v | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/theories/topology_theory/num_topology.v b/theories/topology_theory/num_topology.v index 28d54db18e..8efbaf4b69 100644 --- a/theories/topology_theory/num_topology.v +++ b/theories/topology_theory/num_topology.v @@ -138,6 +138,10 @@ HB.instance Definition _ (R : realFieldType) := #[export, non_forgetful_inheritance] HB.instance Definition _ (R : numFieldType) := PseudoPointedMetric.copy R R^o. +#[export, non_forgetful_inheritance] +HB.instance Definition _ (R : realType) := + Order_isNbhs.Build _ R (@real_order_nbhsE R). + Module Exports. HB.reexport. End Exports. End numFieldTopology. From f8539f2880886bf9b0dcb47272b21d0179dc619f Mon Sep 17 00:00:00 2001 From: Yosuke-Ito-345 Date: Sun, 13 Jul 2025 15:25:40 +0900 Subject: [PATCH 06/10] move HB ereal_OrderNbhs --- theories/ereal.v | 40 +++++++++++++++++++ theories/normedtype_theory/ereal_normedtype.v | 37 +++++++++++++++++ theories/probability.v | 32 --------------- 3 files changed, 77 insertions(+), 32 deletions(-) diff --git a/theories/ereal.v b/theories/ereal.v index f2401270d2..7491d2d756 100644 --- a/theories/ereal.v +++ b/theories/ereal.v @@ -1557,3 +1557,43 @@ rewrite /= opprD addrA subrr distrC subr0 gtr0_norm; last by rewrite invr_gt0. rewrite -[ltLHS]mulr1 ltr_pdivrMl // -ltr_pdivrMr // div1r. by rewrite (lt_le_trans (floorD1_gt _))// Nfloor !natr1 mulrz_nat ler_nat. Qed. +(* +Section ereal_OrderNbhs. +Variable R : realFieldType. + +Open Scope ring_scope. + +Lemma ereal_order_nbhsE (x : \bar R) : + nbhs x = filter_from (fun i => itv_open_ends i /\ x \in i) (fun i => [set` i]). +Proof. +apply/seteqP; split=> A. + rewrite /nbhs/=/ereal_nbhs/=; case x =>[r||]. + - rewrite /nbhs/=/nbhs_ball_/filter_from/=; case=> e e_pos ball_re. + exists `](r - e)%:E, (r + e)%:E[ =>[|y/=]. + split; first by rewrite/itv_open_ends/=; right. + rewrite in_itv/= EFinB gte_subl// EFinD lteDl//; exact/andP. + rewrite in_itv/= => /[dup]/gte_lte_real/fineK<-. + rewrite !lte_fin => fy; apply: ball_re. + by rewrite /ball_/= -opprB normrN ltr_norml ltrBrDl (ltrBlDl _ r). + - case=> M [? MA]; rewrite /filter_from/=. + exists `]M%:E, +oo[ =>[|y/=]; rewrite in_itv/= andbT; last exact: MA. + by split; first by rewrite/itv_open_ends; left. + - case=> M [? MA]; rewrite /filter_from/=. + exists `]-oo, M%:E[ =>[|y/=]; rewrite in_itv/=; last exact: MA. + by split; first by rewrite /itv_open_ends; left. +rewrite /filter_from/= => [][][][[]r|[]][[]s|[]][][]; + rewrite /itv_is_ray/itv_is_bd_open// in_itv/= =>_. + - rewrite /nbhs/=/ereal_nbhs/= => /[dup]/gte_lte_real/fineK<-. + case/andP=> rx sx rsA; apply: (nbhs_interval rx sx) => *. + by apply: rsA =>/=; rewrite in_itv/=; apply/andP. + - rewrite nbhsE/= => rx ?; exists (`]r, +oo[)%classic; rewrite /open_nbhs//. + by split; [rewrite set_itvE; exact: open_ereal_gt_ereal | exact: rx]. + - rewrite nbhsE/= => xs ?; exists (`]-oo, s[)%classic; rewrite /open_nbhs//. + by split; [rewrite set_itvE; exact: open_ereal_lt_ereal | exact: xs]. + - by rewrite set_itvE/= subTset => _ ->; exact: filter_nbhsT. +Qed. + +HB.instance Definition _ := Order_isNbhs.Build _ (\bar R) ereal_order_nbhsE. + +End ereal_OrderNbhs. +*) diff --git a/theories/normedtype_theory/ereal_normedtype.v b/theories/normedtype_theory/ereal_normedtype.v index 016d59aad5..80edce33f2 100644 --- a/theories/normedtype_theory/ereal_normedtype.v +++ b/theories/normedtype_theory/ereal_normedtype.v @@ -482,3 +482,40 @@ split=> [|[Py]] [x [xr Px]]; last by exists x; split=> // -[y||]//; apply: Px. by split; [|exists x; split=> // y xy]; apply: Px. Qed. End nbhs_ereal. + +Section ereal_OrderNbhs. +Variable R : realFieldType. + +Lemma ereal_order_nbhsE (x : \bar R) : + nbhs x = filter_from (fun i => itv_open_ends i /\ x \in i) (fun i => [set` i]). +Proof. +apply/seteqP; split=> A. + rewrite /nbhs/=/ereal_nbhs/=; case x =>[r||]. + - rewrite /nbhs/=/nbhs_ball_/filter_from/=; case=> e e_pos ball_re. + exists `](r - e)%:E, (r + e)%:E[ =>[|y/=]. + split; first by rewrite/itv_open_ends/=; right. + rewrite in_itv/= EFinB gte_subl// EFinD lteDl//; exact/andP. + rewrite in_itv/= => /[dup]/gte_lte_real/fineK<-. + rewrite !lte_fin => fy; apply: ball_re. + by rewrite /ball_/= -opprB normrN ltr_norml ltrBrDl (ltrBlDl _ r). + - case=> M [? MA]; rewrite /filter_from/=. + exists `]M%:E, +oo[ =>[|y/=]; rewrite in_itv/= andbT; last exact: MA. + by split; first by rewrite/itv_open_ends; left. + - case=> M [? MA]; rewrite /filter_from/=. + exists `]-oo, M%:E[ =>[|y/=]; rewrite in_itv/=; last exact: MA. + by split; first by rewrite /itv_open_ends; left. +rewrite /filter_from/= => [][][][[]r|[]][[]s|[]][][]; + rewrite /itv_is_ray/itv_is_bd_open// in_itv/= =>_. + - rewrite /nbhs/=/ereal_nbhs/= => /[dup]/gte_lte_real/fineK<-. + case/andP=> rx sx rsA; apply: (nbhs_interval rx sx) => *. + by apply: rsA =>/=; rewrite in_itv/=; apply/andP. + - rewrite nbhsE/= => rx ?; exists (`]r, +oo[)%classic; rewrite /open_nbhs//. + by split; [rewrite set_itvE; exact: open_ereal_gt_ereal | exact: rx]. + - rewrite nbhsE/= => xs ?; exists (`]-oo, s[)%classic; rewrite /open_nbhs//. + by split; [rewrite set_itvE; exact: open_ereal_lt_ereal | exact: xs]. + - by rewrite set_itvE/= subTset => _ ->; exact: filter_nbhsT. +Qed. + +HB.instance Definition _ := Order_isNbhs.Build _ (\bar R) ereal_order_nbhsE. + +End ereal_OrderNbhs. diff --git a/theories/probability.v b/theories/probability.v index 77d3c1ec28..06fed1326a 100644 --- a/theories/probability.v +++ b/theories/probability.v @@ -247,38 +247,6 @@ have cdf_na : cdf X (a + n.+1%:R^-1) @[n --> \oo] --> cdf X a. by rewrite -(cvg_unique _ cdf_ns cdf_na). Unshelve. all: by end_near. Qed. -Lemma ereal_order_nbhsE : forall x : (\bar R), nbhs x = filter_from - (fun i => itv_open_ends i /\ x \in i) (fun i => [set` i]). -Proof. -move=> x; apply/seteqP; split=> A. - rewrite /nbhs/=/ereal_nbhs/=; case x =>[r||]. - - rewrite /nbhs/=/nbhs_ball_/filter_from/=; case=> e e_pos ball_re. - exists `](r - e)%:E, (r + e)%:E[ =>[|y/=]. - split; first by rewrite/itv_open_ends/=; right. - rewrite in_itv/= EFinB gte_subl// EFinD lteDl//; exact/andP. - rewrite in_itv/= => /[dup]/gte_lte_real/fineK<-. - rewrite !lte_fin => fy; apply: ball_re. - by rewrite /ball_/= -opprB normrN ltr_norml ltrBrDl (ltrBlDl _ r). - - case=> M [? MA]; rewrite /filter_from/=. - exists `]M%:E, +oo[ =>[|y/=]; rewrite in_itv/= andbT; last exact: MA. - by split; first by rewrite/itv_open_ends; left. - - case=> M [? MA]; rewrite /filter_from/=. - exists `]-oo, M%:E[ =>[|y/=]; rewrite in_itv/=; last exact: MA. - by split; first by rewrite /itv_open_ends; left. -rewrite /filter_from/= => [][][][[]r|[]][[]s|[]][][]; - rewrite /itv_is_ray/itv_is_bd_open// in_itv/= =>_. - - rewrite /nbhs/=/ereal_nbhs/= => /[dup]/gte_lte_real/fineK<-. - case/andP=> rx sx rsA; apply: (nbhs_interval rx sx) => *. - by apply: rsA =>/=; rewrite in_itv/=; apply/andP. - - rewrite nbhsE/= => rx ?; exists (`]r, +oo[)%classic; rewrite /open_nbhs//. - by split; [rewrite set_itvE; exact: open_ereal_gt_ereal | exact: rx]. - - rewrite nbhsE/= => xs ?; exists (`]-oo, s[)%classic; rewrite /open_nbhs//. - by split; [rewrite set_itvE; exact: open_ereal_lt_ereal | exact: xs]. - - by rewrite set_itvE/= subTset => _ ->; exact: filter_nbhsT. -Qed. - -HB.instance Definition _ := Order_isNbhs.Build _ (\bar R) ereal_order_nbhsE. - HB.instance Definition _ := isCumulative.Build R _ (\bar R) (cdf X) cdf_nondecreasing cdf_right_continuous. From 9968568b740647a1f34d74b1efec805d3a654296 Mon Sep 17 00:00:00 2001 From: Yosuke-Ito-345 Date: Sun, 13 Jul 2025 15:52:08 +0900 Subject: [PATCH 07/10] delete unnecessary comment --- theories/ereal.v | 40 ---------------------------------------- 1 file changed, 40 deletions(-) diff --git a/theories/ereal.v b/theories/ereal.v index 7491d2d756..f2401270d2 100644 --- a/theories/ereal.v +++ b/theories/ereal.v @@ -1557,43 +1557,3 @@ rewrite /= opprD addrA subrr distrC subr0 gtr0_norm; last by rewrite invr_gt0. rewrite -[ltLHS]mulr1 ltr_pdivrMl // -ltr_pdivrMr // div1r. by rewrite (lt_le_trans (floorD1_gt _))// Nfloor !natr1 mulrz_nat ler_nat. Qed. -(* -Section ereal_OrderNbhs. -Variable R : realFieldType. - -Open Scope ring_scope. - -Lemma ereal_order_nbhsE (x : \bar R) : - nbhs x = filter_from (fun i => itv_open_ends i /\ x \in i) (fun i => [set` i]). -Proof. -apply/seteqP; split=> A. - rewrite /nbhs/=/ereal_nbhs/=; case x =>[r||]. - - rewrite /nbhs/=/nbhs_ball_/filter_from/=; case=> e e_pos ball_re. - exists `](r - e)%:E, (r + e)%:E[ =>[|y/=]. - split; first by rewrite/itv_open_ends/=; right. - rewrite in_itv/= EFinB gte_subl// EFinD lteDl//; exact/andP. - rewrite in_itv/= => /[dup]/gte_lte_real/fineK<-. - rewrite !lte_fin => fy; apply: ball_re. - by rewrite /ball_/= -opprB normrN ltr_norml ltrBrDl (ltrBlDl _ r). - - case=> M [? MA]; rewrite /filter_from/=. - exists `]M%:E, +oo[ =>[|y/=]; rewrite in_itv/= andbT; last exact: MA. - by split; first by rewrite/itv_open_ends; left. - - case=> M [? MA]; rewrite /filter_from/=. - exists `]-oo, M%:E[ =>[|y/=]; rewrite in_itv/=; last exact: MA. - by split; first by rewrite /itv_open_ends; left. -rewrite /filter_from/= => [][][][[]r|[]][[]s|[]][][]; - rewrite /itv_is_ray/itv_is_bd_open// in_itv/= =>_. - - rewrite /nbhs/=/ereal_nbhs/= => /[dup]/gte_lte_real/fineK<-. - case/andP=> rx sx rsA; apply: (nbhs_interval rx sx) => *. - by apply: rsA =>/=; rewrite in_itv/=; apply/andP. - - rewrite nbhsE/= => rx ?; exists (`]r, +oo[)%classic; rewrite /open_nbhs//. - by split; [rewrite set_itvE; exact: open_ereal_gt_ereal | exact: rx]. - - rewrite nbhsE/= => xs ?; exists (`]-oo, s[)%classic; rewrite /open_nbhs//. - by split; [rewrite set_itvE; exact: open_ereal_lt_ereal | exact: xs]. - - by rewrite set_itvE/= subTset => _ ->; exact: filter_nbhsT. -Qed. - -HB.instance Definition _ := Order_isNbhs.Build _ (\bar R) ereal_order_nbhsE. - -End ereal_OrderNbhs. -*) From 6ac70d4759d42bffdaf082811a77e2400850e41b Mon Sep 17 00:00:00 2001 From: Yosuke-Ito-345 Date: Sun, 13 Jul 2025 15:58:29 +0900 Subject: [PATCH 08/10] document --- CHANGELOG_UNRELEASED.md | 56 ++++++++++++++++++++++++++++++++++++++++- 1 file changed, 55 insertions(+), 1 deletion(-) diff --git a/CHANGELOG_UNRELEASED.md b/CHANGELOG_UNRELEASED.md index 2385214fcf..a24722903a 100644 --- a/CHANGELOG_UNRELEASED.md +++ b/CHANGELOG_UNRELEASED.md @@ -6,12 +6,66 @@ ### Changed +- in `unstable.v`: + + lemma `sqrtK` + +- in `realfun.v`: + + instance `is_derive1_sqrt` +- in `mathcomp_extra.v`: + + lemmas `subrKC`, `sumr_le0`, `card_fset_sum1` + +- in `functions.v`: + + lemmas `fct_prodE`, `prodrfctE` + +- in `exp.v: + + lemma `norm_expR` +- in `hoelder.v` + + lemma `hoelder_conj_ge1` + +- in `reals.v`: + + definition `irrational` + + lemmas `irrationalE`, `rationalP` + +- in `constructive_ereal.v`: + + lemma `gte_lte_real` + +- in `ereal_normedtype.v`: + + lemma `ereal_order_nbhsE` + +- in `topology_structure.v`: + + lemmas `denseI`, `dense0` + +- in `pseudometric_normed_Zmodule.v`: + + lemma `dense_set1C` + +- new file `borel_hierarchy.v`: + + definitions `Gdelta`, `Fsigma` + + lemmas `closed_Fsigma`, `Gdelta_measurable`, `Gdelta_subspace_open`, + `irrational_Gdelta`, `not_rational_Gdelta` + +### Changed + +- moved from `pi_irrational.v` to `reals.v` and changed + + definition `rational` + +- in `lebesgue_stieltjes_measure.v` generalized: + + lemma `right_continuousW`, + + record `isCumulative` + + definition `Cumulative` + +- in `lebesgue_stieltjes_measure.v` specialized: + + lemma `nondecreasing_right_continuousP` + + definition `CumulativeBounded` + +- in `lebesgue_stieltjes_measure.v`, according to generalization of `Cumulative`, modified: + + lemmas `wlength_ge0`, `cumulative_content_sub_fsum`, `wlength_sigma_subadditive`, `lebesgue_stieltjes_measure_unique` + + definitions `lebesgue_stieltjes_measure`, `completed_lebesgue_stieltjes_measure` + ### Renamed - in `lebesgue_stieltjes_measure.v`: + `cumulativeNy0` -> `cumulativeNy` + `cumulativey1` -> `cumulativey` - + `cumulativey1` -> `cumulativey` ### Generalized From 996adf539b0505125c6a017a1ef46f61c7effa10 Mon Sep 17 00:00:00 2001 From: Reynald Affeldt Date: Mon, 14 Jul 2025 11:55:49 +0900 Subject: [PATCH 09/10] nitpick --- CHANGELOG_UNRELEASED.md | 13 +++--- reals/constructive_ereal.v | 7 ++- theories/lebesgue_stieltjes_measure.v | 2 +- theories/normedtype_theory/ereal_normedtype.v | 45 +++++++++---------- theories/topology_theory/num_topology.v | 6 +-- 5 files changed, 33 insertions(+), 40 deletions(-) diff --git a/CHANGELOG_UNRELEASED.md b/CHANGELOG_UNRELEASED.md index a24722903a..c310e6ee19 100644 --- a/CHANGELOG_UNRELEASED.md +++ b/CHANGELOG_UNRELEASED.md @@ -27,10 +27,7 @@ + lemmas `irrationalE`, `rationalP` - in `constructive_ereal.v`: - + lemma `gte_lte_real` - -- in `ereal_normedtype.v`: - + lemma `ereal_order_nbhsE` + + lemma `gte_lte_fin_num` - in `topology_structure.v`: + lemmas `denseI`, `dense0` @@ -48,13 +45,13 @@ - moved from `pi_irrational.v` to `reals.v` and changed + definition `rational` -- in `lebesgue_stieltjes_measure.v` generalized: - + lemma `right_continuousW`, +- in `lebesgue_stieltjes_measure.v` generalized (codomain is now an `orderNbhsType`): + + lemma `right_continuousW` + record `isCumulative` + definition `Cumulative` -- in `lebesgue_stieltjes_measure.v` specialized: - + lemma `nondecreasing_right_continuousP` +- in `lebesgue_stieltjes_measure.v` specialized from `numFieldType` to `realFieldType`: + + lemma `nondecreasing_right_continuousP` + definition `CumulativeBounded` - in `lebesgue_stieltjes_measure.v`, according to generalization of `Cumulative`, modified: diff --git a/reals/constructive_ereal.v b/reals/constructive_ereal.v index c7bd9390cb..ab122132fb 100644 --- a/reals/constructive_ereal.v +++ b/reals/constructive_ereal.v @@ -1695,11 +1695,10 @@ Proof. by move: x => [x| |]//=; rewrite lee_fin => x0; rewrite ltNyr. Qed. Lemma lt0_fin_numE x : x < 0 -> (x \is a fin_num) = (-oo < x). Proof. by move/ltW; exact: le0_fin_numE. Qed. -Lemma gte_lte_real (x a b : \bar R) : (a < x < b) -> x \is a fin_num. +Lemma gte_lte_fin_num x a b : a < x < b -> x \is a fin_num. Proof. -case/andP => [ax xb]; apply/fin_numPlt/andP; split. - exact: (le_lt_trans (leNye a) ax). -exact: (lt_le_trans xb (leey b)). +rewrite fin_numE -ltey -ltNye. +by move=> /andP[/(le_lt_trans (leNye _))->/=] /lt_le_trans -> //; exact: leey. Qed. Lemma eqyP x : x = +oo <-> (forall A, (0 < A)%R -> A%:E <= x). diff --git a/theories/lebesgue_stieltjes_measure.v b/theories/lebesgue_stieltjes_measure.v index 76fef7687c..c099013a8d 100644 --- a/theories/lebesgue_stieltjes_measure.v +++ b/theories/lebesgue_stieltjes_measure.v @@ -93,7 +93,7 @@ by rewrite opprB ltrBlDl => fa; exact: ltW. Qed. Section id_is_cumulative. -Variable R : realType. +Variable R : realFieldType. Let id_nd : {homo @idfun R : x y / x <= y}. Proof. by []. Qed. diff --git a/theories/normedtype_theory/ereal_normedtype.v b/theories/normedtype_theory/ereal_normedtype.v index 80edce33f2..e237ede313 100644 --- a/theories/normedtype_theory/ereal_normedtype.v +++ b/theories/normedtype_theory/ereal_normedtype.v @@ -486,33 +486,30 @@ End nbhs_ereal. Section ereal_OrderNbhs. Variable R : realFieldType. -Lemma ereal_order_nbhsE (x : \bar R) : +Let ereal_order_nbhsE (x : \bar R) : nbhs x = filter_from (fun i => itv_open_ends i /\ x \in i) (fun i => [set` i]). Proof. apply/seteqP; split=> A. - rewrite /nbhs/=/ereal_nbhs/=; case x =>[r||]. - - rewrite /nbhs/=/nbhs_ball_/filter_from/=; case=> e e_pos ball_re. - exists `](r - e)%:E, (r + e)%:E[ =>[|y/=]. - split; first by rewrite/itv_open_ends/=; right. - rewrite in_itv/= EFinB gte_subl// EFinD lteDl//; exact/andP. - rewrite in_itv/= => /[dup]/gte_lte_real/fineK<-. - rewrite !lte_fin => fy; apply: ball_re. - by rewrite /ball_/= -opprB normrN ltr_norml ltrBrDl (ltrBlDl _ r). - - case=> M [? MA]; rewrite /filter_from/=. - exists `]M%:E, +oo[ =>[|y/=]; rewrite in_itv/= andbT; last exact: MA. - by split; first by rewrite/itv_open_ends; left. - - case=> M [? MA]; rewrite /filter_from/=. - exists `]-oo, M%:E[ =>[|y/=]; rewrite in_itv/=; last exact: MA. - by split; first by rewrite /itv_open_ends; left. -rewrite /filter_from/= => [][][][[]r|[]][[]s|[]][][]; - rewrite /itv_is_ray/itv_is_bd_open// in_itv/= =>_. - - rewrite /nbhs/=/ereal_nbhs/= => /[dup]/gte_lte_real/fineK<-. - case/andP=> rx sx rsA; apply: (nbhs_interval rx sx) => *. - by apply: rsA =>/=; rewrite in_itv/=; apply/andP. - - rewrite nbhsE/= => rx ?; exists (`]r, +oo[)%classic; rewrite /open_nbhs//. - by split; [rewrite set_itvE; exact: open_ereal_gt_ereal | exact: rx]. - - rewrite nbhsE/= => xs ?; exists (`]-oo, s[)%classic; rewrite /open_nbhs//. - by split; [rewrite set_itvE; exact: open_ereal_lt_ereal | exact: xs]. + rewrite /nbhs/= /ereal_nbhs/=; move: x => [r||]. + - move=> [e/= e0 reA]. + exists `](r - e)%:E, (r + e)%:E[ => [|y/=]. + by rewrite in_itv/= ?lte_fin// ltrBlDr andbb ltrDl; split => //; right. + move: y => [y| |]//=; rewrite !in_itv/=; last by rewrite !ltNge/= leey. + by rewrite !lte_fin -ltr_distlC => /reA. + - case=> M [Mreal MA]. + exists `]M%:E, +oo[ => [|y/=]; rewrite in_itv/= andbT; last exact: MA. + by rewrite ltry; split => //; left. + - case=> M [Mreal MA]. + exists `]-oo, M%:E[ => [|y/=]; rewrite in_itv/=; last exact: MA. + by rewrite ltNyr; split => //; left. +move=> [[ [[]/= r|[]] [[]/= s|[]] ]] [] []// _. + - move=> /[dup]/gte_lte_fin_num/fineK <-; rewrite in_itv/=. + move=> /andP[rx sx] rsA; apply: (nbhs_interval rx sx) => z rz zs. + by apply: rsA =>/=; rewrite in_itv/= rz. + - rewrite nbhsE/= => rx rA; exists `]r, +oo[%classic => //. + by split; [rewrite set_itvE; exact: open_ereal_gt_ereal | ]. + - rewrite nbhsE/= => xs ?; exists `]-oo, s[%classic => //. + by split; [rewrite set_itvE; exact: open_ereal_lt_ereal | ]. - by rewrite set_itvE/= subTset => _ ->; exact: filter_nbhsT. Qed. diff --git a/theories/topology_theory/num_topology.v b/theories/topology_theory/num_topology.v index 8efbaf4b69..523b29e2bf 100644 --- a/theories/topology_theory/num_topology.v +++ b/theories/topology_theory/num_topology.v @@ -132,11 +132,11 @@ HB.instance Definition _ (R : numClosedFieldType) := PseudoPointedMetric.copy R R^o. #[export, non_forgetful_inheritance] -HB.instance Definition _ (R : realFieldType) := - Order_isNbhs.Build _ R (@real_order_nbhsE R). +HB.instance Definition _ (R : numFieldType) := PseudoPointedMetric.copy R R^o. #[export, non_forgetful_inheritance] -HB.instance Definition _ (R : numFieldType) := PseudoPointedMetric.copy R R^o. +HB.instance Definition _ (R : realFieldType) := + Order_isNbhs.Build _ R (@real_order_nbhsE R). #[export, non_forgetful_inheritance] HB.instance Definition _ (R : realType) := From 6661aa2182def9c1bb5789ce95bc808e5b252a02 Mon Sep 17 00:00:00 2001 From: Reynald Affeldt Date: Sat, 23 Aug 2025 16:44:22 +0900 Subject: [PATCH 10/10] minor changes --- CHANGELOG_UNRELEASED.md | 52 +++---------------- classical/set_interval.v | 7 +-- reals/constructive_ereal.v | 2 +- theories/normedtype_theory/ereal_normedtype.v | 39 +++++++------- theories/topology_theory/num_topology.v | 13 +++-- 5 files changed, 36 insertions(+), 77 deletions(-) diff --git a/CHANGELOG_UNRELEASED.md b/CHANGELOG_UNRELEASED.md index c310e6ee19..5affd9f1be 100644 --- a/CHANGELOG_UNRELEASED.md +++ b/CHANGELOG_UNRELEASED.md @@ -4,52 +4,11 @@ ### Added -### Changed - -- in `unstable.v`: - + lemma `sqrtK` - -- in `realfun.v`: - + instance `is_derive1_sqrt` -- in `mathcomp_extra.v`: - + lemmas `subrKC`, `sumr_le0`, `card_fset_sum1` - -- in `functions.v`: - + lemmas `fct_prodE`, `prodrfctE` - -- in `exp.v: - + lemma `norm_expR` -- in `hoelder.v` - + lemma `hoelder_conj_ge1` - -- in `reals.v`: - + definition `irrational` - + lemmas `irrationalE`, `rationalP` - - in `constructive_ereal.v`: - + lemma `gte_lte_fin_num` - -- in `topology_structure.v`: - + lemmas `denseI`, `dense0` - -- in `pseudometric_normed_Zmodule.v`: - + lemma `dense_set1C` - -- new file `borel_hierarchy.v`: - + definitions `Gdelta`, `Fsigma` - + lemmas `closed_Fsigma`, `Gdelta_measurable`, `Gdelta_subspace_open`, - `irrational_Gdelta`, `not_rational_Gdelta` + + lemma `ltgte_fin_num` ### Changed -- moved from `pi_irrational.v` to `reals.v` and changed - + definition `rational` - -- in `lebesgue_stieltjes_measure.v` generalized (codomain is now an `orderNbhsType`): - + lemma `right_continuousW` - + record `isCumulative` - + definition `Cumulative` - - in `lebesgue_stieltjes_measure.v` specialized from `numFieldType` to `realFieldType`: + lemma `nondecreasing_right_continuousP` + definition `CumulativeBounded` @@ -60,12 +19,13 @@ ### Renamed -- in `lebesgue_stieltjes_measure.v`: - + `cumulativeNy0` -> `cumulativeNy` - + `cumulativey1` -> `cumulativey` - ### Generalized +- in `lebesgue_stieltjes_measure.v` generalized (codomain is now an `orderNbhsType`): + + lemma `right_continuousW` + + record `isCumulative` + + definition `Cumulative` + ### Deprecated ### Removed diff --git a/classical/set_interval.v b/classical/set_interval.v index 5cda86b556..2b9fce511a 100644 --- a/classical/set_interval.v +++ b/classical/set_interval.v @@ -20,9 +20,10 @@ From mathcomp Require Import functions. (* factor a b x := (x - a) / (b - a) *) (* set_itvE == multirule to turn intervals into inequalities *) (* disjoint_itv i j == intervals i and j are disjoint *) -(* itv_is_ray i == i is either `]x,+oo[ or `]-oo,x[ *) -(* itv_is_bd_open i == i is `]x,y[ *) -(* itv_open_ends i == i has open endpoints, E.G. is one of the two above *) +(* itv_is_ray i == i is either `]x, +oo[ or `]-oo, x[ *) +(* itv_is_bd_open i == i is `]x, y[ *) +(* itv_open_ends i == i has open endpoints, i.e., it is one of the two *) +(* above *) (* is_open_itv A == the set A can be written as an open interval *) (* open_itv_cover A == the set A can be covered by open intervals *) (* ``` *) diff --git a/reals/constructive_ereal.v b/reals/constructive_ereal.v index ab122132fb..f48e46ca7b 100644 --- a/reals/constructive_ereal.v +++ b/reals/constructive_ereal.v @@ -1695,7 +1695,7 @@ Proof. by move: x => [x| |]//=; rewrite lee_fin => x0; rewrite ltNyr. Qed. Lemma lt0_fin_numE x : x < 0 -> (x \is a fin_num) = (-oo < x). Proof. by move/ltW; exact: le0_fin_numE. Qed. -Lemma gte_lte_fin_num x a b : a < x < b -> x \is a fin_num. +Lemma ltgte_fin_num x a b : a < x < b -> x \is a fin_num. Proof. rewrite fin_numE -ltey -ltNye. by move=> /andP[/(le_lt_trans (leNye _))->/=] /lt_le_trans -> //; exact: leey. diff --git a/theories/normedtype_theory/ereal_normedtype.v b/theories/normedtype_theory/ereal_normedtype.v index e237ede313..2225c83b02 100644 --- a/theories/normedtype_theory/ereal_normedtype.v +++ b/theories/normedtype_theory/ereal_normedtype.v @@ -487,30 +487,29 @@ Section ereal_OrderNbhs. Variable R : realFieldType. Let ereal_order_nbhsE (x : \bar R) : - nbhs x = filter_from (fun i => itv_open_ends i /\ x \in i) (fun i => [set` i]). + nbhs x = filter_from (fun i => itv_open_ends i /\ x \in i) + (fun i => [set` i]). Proof. apply/seteqP; split=> A. - rewrite /nbhs/= /ereal_nbhs/=; move: x => [r||]. - - move=> [e/= e0 reA]. - exists `](r - e)%:E, (r + e)%:E[ => [|y/=]. - by rewrite in_itv/= ?lte_fin// ltrBlDr andbb ltrDl; split => //; right. - move: y => [y| |]//=; rewrite !in_itv/=; last by rewrite !ltNge/= leey. - by rewrite !lte_fin -ltr_distlC => /reA. - - case=> M [Mreal MA]. - exists `]M%:E, +oo[ => [|y/=]; rewrite in_itv/= andbT; last exact: MA. - by rewrite ltry; split => //; left. - - case=> M [Mreal MA]. - exists `]-oo, M%:E[ => [|y/=]; rewrite in_itv/=; last exact: MA. - by rewrite ltNyr; split => //; left. -move=> [[ [[]/= r|[]] [[]/= s|[]] ]] [] []// _. - - move=> /[dup]/gte_lte_fin_num/fineK <-; rewrite in_itv/=. +- rewrite /nbhs/= /ereal_nbhs/=; move: x => [r [e/= e0 reA]||]. + + exists `](r - e)%:E, (r + e)%:E[ => [|[y|/andP[]//|//]]; rewrite ?in_itv/=. + * by rewrite !lte_fin ltrBlDr andbb ltrDl; split => //; right. + * by move/subset_ball_prop_in_itv : reA => /(_ y); rewrite /= !in_itv. + + case=> M [Mreal MA]. + exists `]M%:E, +oo[ => [|y/=]; rewrite in_itv/= andbT ?ltry; last exact: MA. + by split => //; left. + + case=> M [Mreal MA]. + exists `]-oo, M%:E[ => [|y/=]; rewrite in_itv/= ?ltNyr; last exact: MA. + by split => //; left. +- move=> [[ [[]/= r|[]] [[]/= s|[]] ]] [] []// _. + + move=> /[dup]/ltgte_fin_num/fineK <-; rewrite in_itv/=. move=> /andP[rx sx] rsA; apply: (nbhs_interval rx sx) => z rz zs. by apply: rsA =>/=; rewrite in_itv/= rz. - - rewrite nbhsE/= => rx rA; exists `]r, +oo[%classic => //. - by split; [rewrite set_itvE; exact: open_ereal_gt_ereal | ]. - - rewrite nbhsE/= => xs ?; exists `]-oo, s[%classic => //. - by split; [rewrite set_itvE; exact: open_ereal_lt_ereal | ]. - - by rewrite set_itvE/= subTset => _ ->; exact: filter_nbhsT. + + rewrite nbhsE/= => rx rA; exists `]r, +oo[%classic => //. + by split => //; rewrite set_itvE; exact: open_ereal_gt_ereal. + + rewrite nbhsE/= => xs ?; exists `]-oo, s[%classic => //. + by split => //; rewrite set_itvE; exact: open_ereal_lt_ereal. + + by rewrite set_itvE/= subTset => _ ->; exact: filter_nbhsT. Qed. HB.instance Definition _ := Order_isNbhs.Build _ (\bar R) ereal_order_nbhsE. diff --git a/theories/topology_theory/num_topology.v b/theories/topology_theory/num_topology.v index 523b29e2bf..e265bb2eac 100644 --- a/theories/topology_theory/num_topology.v +++ b/theories/topology_theory/num_topology.v @@ -33,8 +33,7 @@ Variable (R : numDomainType). Lemma nbhs_filter (p : R^o) : ProperFilter (nbhs p). Proof. split. - move=> [] e e0 /subsetP/(_ p). - by rewrite !in_setE/= subrr normr0. + by move=> [] e e0 /subsetP/(_ p); rewrite !in_setE/= subrr normr0. split=> [|P Q|P Q]. - by exists 1; [exact: ltr01|exact: subsetT]. - move=> [] /= e e0 /subsetP eP [] /= f f0 /subsetP fQ. @@ -89,9 +88,9 @@ Proof. rewrite eqEsubset; split => U. case => _ /posnumP[e] xeU. exists (`]x - e%:num, x + e%:num[); first split; first by right. - by rewrite in_itv /= -real_lter_distl subrr // normr0. - apply: (subset_trans _ xeU) => z /=. - by rewrite in_itv /= -real_lter_distl //= distrC. + by rewrite in_itv/= -lter_distl subrr normr0. + apply: subset_trans xeU => z /=. + by rewrite in_itv /= -lter_distl distrC. case => [][[[]l|[]]] [[]r|[]] [[]]//= _. - move=> xlr lrU; exists (Order.min (x - l) (r - x)). by rewrite /= lt_min ?lterBDr ?add0r ?(itvP xlr). @@ -103,12 +102,12 @@ case => [][[[]l|[]]] [[]r|[]] [[]]//= _. - move=> xl lU; exists (x - l) => /=; first by rewrite lterBDr add0r (itvP xl). apply/(subset_trans _ lU)/subset_ball_prop_in_itv. suff : (`]x - (x - l), x + (x - l)[ <= `]l, +oo[)%O. - by move/subitvP => H ?; exact: H. + by move/subitvP => + ?; exact. by rewrite subitvE lteBSide/= subKr lexx. - move=> xr rU; exists (r - x) => /=; first by rewrite lterBDr add0r (itvP xr). apply/(subset_trans _ rU)/subset_ball_prop_in_itv. suff : (`]x - (r - x), x + (r - x)[ <= `]-oo, r[)%O. - by move/subitvP => H ?; exact: H. + by move/subitvP => + ?; exact. by rewrite subitvE lteBSide/= addrC subrK. - by move=> _; rewrite set_itvE subTset => ->; exists 1 => /=. Qed.