Module mathcomp.analysis.measure_theory.measurable_structure
From HB Require Import structures.From mathcomp Require Import all_ssreflect_compat all_algebra finmap.
#[warning="-warn-library-file-internal-analysis"]
From mathcomp Require Import unstable.
From mathcomp Require Import boolp classical_sets functions cardinality reals.
From mathcomp Require Import ereal topology normedtype sequences.
Set SsrOldRewriteGoalsOrder.
Set Implicit Arguments.
Unset Strict Implicit.
Unset Printing Implicit Defensive.
Import ProperNotations.
Import Order.TTheory GRing.Theory Num.Theory.
Reserved Notation "'s<|' D , G '|>'" (at level 40, G, D at next level).
Reserved Notation "'s<<' A '>>'".
Reserved Notation "'d<<' D '>>'".
Reserved Notation "mu .-measurable" (format "mu .-measurable").
Reserved Notation "G .-sigma" (format "G .-sigma").
Reserved Notation "G .-sigma.-measurable" (format "G .-sigma.-measurable").
Reserved Notation "f .-preimage" (format "f .-preimage").
Reserved Notation "f .-preimage.-measurable" (format "f .-preimage.-measurable").
Reserved Notation "'<<l' D , G '>>'" (format "'<<l' D , G '>>'").
Reserved Notation "'<<l' G '>>'" (format "'<<l' G '>>'").
Reserved Notation "'<<d' G '>>'" (format "'<<d' G '>>'").
Reserved Notation "'<<s' D , G '>>'" (format "'<<s' D , G '>>'").
Reserved Notation "'<<s' G '>>'" (format "'<<s' G '>>'").
Reserved Notation "'<<r' G '>>'" (format "'<<r' G '>>'").
Reserved Notation "'<<sr' G '>>'" (format "'<<sr' G '>>'").
Reserved Notation "'<<M' G '>>'" (format "'<<M' G '>>'").
Reserved Notation "p .-prod" (format "p .-prod").
Reserved Notation "p .-prod.-measurable" (format "p .-prod.-measurable").
Inductive
- mathcomp.analysis.lebesgue_stieltjes_measure
- mathcomp.analysis.measurable_realfun
Source code
Declare Scope measure_display_scope.
Delimit Scope measure_display_scope with mdisp.
Bind Scope measure_display_scope with measure_display.
Local Open Scope classical_set_scope.
Local Open Scope ring_scope.
Section set_systems.
Context {} ( : set (set T) -> Prop) ( : set T) ( : set (set T)).
Definition
Source code
Definition
mnormalize : forall [d : measure_display] [T : measurableType d] [R : realType], measure T R -> probability T R -> set T -> \bar R mnormalize is not universe polymorphic Arguments mnormalize [d]%measure_display_scope [T R] mu P U%classical_set_scope mnormalize is transparent Expands to: Constant mathcomp.analysis.measure_theory.probability_measure.mnormalize Declared in library mathcomp.analysis.measure_theory.probability_measure, line 146, characters 11-21
Used by
- mathcomp.analysis.kernel
- mathcomp.analysis.measure_theory.measure_function
Source code
Definition
mset : forall [d : measure_display] [T : measurableType d] [R : realType], set T -> R -> set (probability T R) mset is not universe polymorphic Arguments mset [d]%measure_display_scope [T R] U%classical_set_scope r%ring_scope _ mset is transparent Expands to: Constant mathcomp.analysis.measure_theory.probability_measure.mset Declared in library mathcomp.analysis.measure_theory.probability_measure, line 198, characters 11-15
Used by
- mathcomp.analysis.measure_theory.measure_function
Source code
Definition
pset : forall [d : measure_display] [T : measurableType d] [R : realType], set (set (probability T R)) pset is not universe polymorphic Arguments pset [d]%measure_display_scope [T R] _ pset is transparent Expands to: Constant mathcomp.analysis.measure_theory.probability_measure.pset Declared in library mathcomp.analysis.measure_theory.probability_measure, line 214, characters 11-15
Source code
Definition
pprobability : forall [d : measure_display] (T : measurableType d) (R : realType), measurableType (pset (R:=R)).-sigma pprobability is not universe polymorphic Arguments pprobability [d]%measure_display_scope T R pprobability is transparent Expands to: Constant mathcomp.analysis.measure_theory.probability_measure.pprobability Declared in library mathcomp.analysis.measure_theory.probability_measure, line 217, characters 11-23
Source code
forall ( : set I) , finite_set D -> (forall , D i -> G (A_ i)) ->
G (\bigcap_( in D) (A_ i)).
Definition
Used by
- mathcomp.analysis.measure_theory.measure_function
Source code
forall ( : set I) , finite_set D -> D !=set0 ->
(forall , D i -> G (A_ i)) ->
G (\bigcap_( in D) (A_ i)).
Definition
Source code
forall ( : set I) , finite_set D -> (forall , D i -> G (A_ i)) ->
G (\bigcup_( in D) (A_ i)).
Definition
Used by
- mathcomp.analysis.lebesgue_stieltjes_measure
Source code
[/\ finite_set D, D `<=` G, A `\` B = \bigcup_( in D) X & trivIset D id].
Lemma
Proof.
by move=> X ->; apply: mD.
by move=> X Y -> ->.
Qed.
Definition
Used by
- mathcomp.analysis.measure_theory.measure_function
- mathcomp.analysis.lebesgue_integral_theory.lebesgue_integral_fubini
Source code
forall , nondecreasing_seq F -> (forall , G (F i)) -> G (\bigcup_ (F i)).
Definition
Source code
forall , nonincreasing_seq F -> (forall , G (F i)) -> G (\bigcap_ (F i)).
Definition
Source code
forall : (set T)^nat, trivIset setT F -> (forall , G (F n)) ->
G (\bigcup_ F k).
Definition
Used by
- mathcomp.analysis.measure_theory.measure_function
Source code
forall ( : set I) ( : I -> set T), finite_set D -> trivIset D F ->
(forall , D i -> G (F i)) -> G (\bigcup_( in D) F k).
Definition
Source code
Definition
Source code
(forall : (set T)^nat, (forall , G (A n)) -> G (\bigcup_ A k))].
Definition
Source code
[/\ G set0, (forall , G A -> G (D `\` A)) &
(forall : (set T)^nat, (forall , G (A n)) -> G (\bigcup_ A k))].
Definition
Source code
Used by
- mathcomp.analysis.kernel
- mathcomp.analysis.lebesgue_integral_theory.lebesgue_integral_fubini
Source code
[/\ forall , G A -> A `<=` D, G D, setSD_closed & ndseq_closed].
Definition
setC_closed : forall {T : Type}, set (set T) -> Prop setC_closed is not universe polymorphic Arguments setC_closed {T}%type_scope G%classical_set_scope setC_closed is transparent Expands to: Constant mathcomp.analysis.measure_theory.measurable_structure.setC_closed Declared in library mathcomp.analysis.measure_theory.measurable_structure, line 163, characters 11-22
Source code
End set_systems.
#[deprecated(since="mathcomp-analysis 1.9.0", note="renamed `setD_closed`")]
Notation
#[deprecated(since="mathcomp-analysis 1.9.0", note="renamed `setD_semi_setD_closed`")]
Notation
Lemma
sigma_ring [set | X `<=` D].
Proof.
by move=> F FA/=; apply: bigcup_sub => i _; exact: FA.
by move=> U V + VA; apply: subset_trans; exact: subDsetl.
Qed.
Lemma
lambda_system D [set | X `<=` D].
Proof.
- by move=> A B BA + BD; apply: subset_trans; exact: subDsetl.
- by move=> /= F _ FD; exact: bigcup_sub.
Qed.
Notation
classical_set_scope.
Notation
Notation
Notation
classical_set_scope.
Notation
Notation
Notation
Notation
Section lambda_system_smallest.
Variables ( : Type) ( : set T) ( : set (set T)).
Hypothesis : forall , G A -> A `<=` D.
Lemma
Proof.
- have monoH := powerset_lambda_system D.
by case: (monoH) => + _ _ _; apply; exact: MA.
- by case: monoE.
- by apply setDE => //; [exact: MA|exact: MB].
- by move=> F ndF MF E [[EsubD ED setDE ndE] CE]; apply ndE=> // n; exact: MF.
Qed.
End lambda_system_smallest.
Lemma
(G set0 /\ setU_closed G) <-> fin_bigcup_closed G.
Proof.
have G0 : G set0 by have := GU void set0 point; rewrite bigcup0//; apply.
by split=> // A B GA GB; rewrite -bigcup2inE; apply: GU => // -[|[|[]]].
elim/Pchoice: I => I in D DF A GA *; rewrite -bigsetU_fset_set// big_seq.
by elim/big_ind: _ => // i; rewrite in_fset_set// inE => /GA.
Qed.
Lemma
- mathcomp.analysis.measure_theory.measure_function
Source code
setI_closed G <-> finN0_bigcap_closed G.
Proof.
by rewrite -bigcap2inE; apply: GI => // [|[|[|[]]]]; first by exists 0%N.
elim/Pchoice: I => I in D DF i Di A GA *.
have finDDi : finite_set (D `\ i) by exact: finite_setD.
rewrite (bigcap_setD1 i)// -bigsetI_fset_set// big_seq.
elim/big_rec: _ => // [|j B]; first by rewrite setIT; apply: GA.
rewrite in_fset_set// inE => -[Dj /eqP nij] GAB.
by rewrite setICA; apply: GI => //; apply: GA.
Qed.
Lemma
setD_closed G <-> (setI_closed G /\ setSD_closed G).
Proof.
Notation
Lemma
( : I -> set (set T)) ( : set I) :
(forall , J n -> sigma_algebra D (F n)) ->
sigma_algebra D (\bigcap_( in J) F i).
Proof.
- by have [_ mGiC _] := mG i Ji; exact/mGiC/AJ.
- by have [_ _ mGiU] := mG i Ji; apply: mGiU => j; exact: GH.
Qed.
Lemma
(forall , C X -> X `<=` U) ->
sigma_algebra U C <->
[/\ C U, setSD_closed C, ndseq_closed C & setI_closed C].
Proof.
- by rewrite -(setD0 U); apply: CD.
- move=> A B BA CA CB; rewrite (_ : A `\` B = U `\` ((U `\` A) `|` B)).
by apply CD; rewrite -bigcup2E; apply: CU => -[|[|[|]]] //=; exact: CD.
rewrite setDUr setDD [in RHS]setDE setIACA setIid -setDE setIidr//.
by rewrite setDE; apply: subIset; left; apply: C_subU.
- by move=> F ndF DF; exact: CU.
- move=> A B DA DB; rewrite (_ : A `&` B = U `\` ((U `\` A) `|` (U `\` B))).
by apply CD; rewrite -bigcup2E; apply: CU => -[|[|[|]]] //; exact: CD.
rewrite setDUr !setDD setIACA setIid (@setIidr _ U)//.
by apply: subIset; left; exact: C_subU.
- by rewrite -(setDv U); exact: DC.
- by move=> A CA; apply: DC => //; exact: C_subU.
- move=> F DF.
rewrite [X in C X](_ : _ = \bigcup_ \big[setU/set0]_( < i.+1) F j).
apply: DU; first by move=> *; exact/subsetPset/subset_bigsetU.
elim=> [|n ih]; first by rewrite big_ord_recr /= big_ord0 set0U; exact: DF.
have CU : setU_closed C.
move=> A B DA DB; rewrite (_ : A `|` B = U `\` ((U `\` A) `&` (U `\` B))).
apply DC => //; last by apply: DI; apply: DC => //; exact: C_subU.
by apply: subIset; left; apply: subIset; left.
by rewrite setDIr// !setDD (setIidr (C_subU _ DA)) (setIidr (C_subU _ _)).
by rewrite big_ord_recr; exact: CU.
rewrite predeqE => x; split => [[n _ Fnx]|[n _]].
by exists n => //; rewrite big_ord_recr /=; right.
by rewrite -bigcup_mkord => -[m /=]; rewrite ltnS => _ Fmx; exists m.
Qed.
Section generated_sigma_algebra.
Context { : Type} ( : set T) ( : set (set T)).
Implicit Types (M : set (set T)).
Lemma
- mathcomp.analysis.measurable_realfun
Source code
Proof.
by apply: (PD); apply: GA.
by apply: (PU) => n; apply: GA.
Qed.
Lemma
Proof.
Lemma
Proof.
Lemma
- mathcomp.analysis.lebesgue_stieltjes_measure
- mathcomp.analysis.lebesgue_measure
- mathcomp.analysis.kernel
- mathcomp.analysis.measure_theory.measure_function
- mathcomp.analysis.measure_theory.measurable_function
- mathcomp.analysis.measure_theory.measure_extension
- mathcomp.analysis.measurable_realfun
Source code
Proof.
Lemma
- mathcomp.analysis.lebesgue_integral_theory.giry
Source code
Proof.
Lemma
Proof.
Lemma
- mathcomp.analysis.lebesgue_integral_theory.giry
Source code
(forall , <<s D, G >> (A i)) -> <<s D, G >> (\bigcup_ (A i)).
Proof.
End generated_sigma_algebra.
#[global] Hint Resolve smallest_sigma_algebra : core.
Section generated_setring.
Context { : Type} ( : set (set T)).
Implicit Types (M : set (set T)).
Lemma
Proof.
by apply: (PU); [apply: GA|apply: GB].
by apply: (PDI); [apply: GA|apply: GB].
Qed.
Lemma
Proof.
Lemma
Proof.
Lemma
Proof.
Lemma
- mathcomp.analysis.measure_theory.measure_function
Source code
Proof.
Lemma
- mathcomp.analysis.measure_theory.measure_function
Source code
Proof.
Lemma
- mathcomp.analysis.measure_theory.measure_function
Source code
Proof.
Lemma
Proof.
End generated_setring.
#[global] Hint Resolve smallest_setring setring0 : core.
#[deprecated(since="mathcomp-analysis 1.9.0", note="renamed `setringD`")]
Notation
Lemma
(forall , <<s D, G >> X -> X `<=` D) ->
lambda_system D <<s D, G >>.
Proof.
by move=> /(sigma_algebraP sDGD) [sT sD snd sI]; split.
Qed.
Lemma
Proof.
- by apply: (CDI); [exact: GA|exact: GB].
- by apply: (CU) => n; exact: GA.
Qed.
Proof.
rewrite -(@setD_bigcup _ _ F _ O)//; apply: (GDI); first exact: GF.
by rewrite bigcup_mkcond; apply: GU => n; case: ifPn => // _; exact: GDI.
Qed.
Lemma
Proof.
Lemma
Proof.
setring G -> monotone G -> sigma_ring G.
Proof.
rewrite -bigcup_bigsetU_bigcup; apply: ndG.
by move=> *; exact/subsetPset/subset_bigsetU.
by elim=> [|n ih]; rewrite big_ord_recr/= ?big_ord0 ?set0U//; exact: GU.
Qed.
Lemma
Proof.
have {}GC : <<M G >> `<=` C by exact: smallest_sub.
- by apply: (ndC) => // i; apply: (GC); exact: GF.
- by apply: (niC) => // i; apply: (GC); exact: GF.
Qed.
Section g_monotone_g_sigma_ring.
Variables ( : Type) ( : set (set T)).
Hypothesis
Proof.
pose K := [set | [/\ M (E `\` F), M (F `\` E) & M (E `|` F)] ].
have KP E F : K(F) E -> K(E) F by move=> [] *; split; rewrite 1?setUC.
have K_monotone F : monotone (K(F)).
split.
move=> /= H ndH KFH; split.
- rewrite setD_bigcupl; apply: (g_monotone_monotone G).1.
by move=> m n mn; apply/subsetPset; apply: setSD; exact/subsetPset/ndH.
by move=> i; have [] := KFH i.
- rewrite setDE setC_bigcup -bigcapIr//; apply: (g_monotone_monotone G).2.
move=> m n mn; apply/subsetPset.
by apply: setDS; exact/subsetPset/ndH.
by move=> i; have [] := KFH i.
- rewrite -bigcupUl//; apply: (g_monotone_monotone G).1.
move=> m n mn; apply/subsetPset.
by apply: setSU; exact/subsetPset/ndH.
by move=> i; have [] := KFH i.
move=> /= H niH KFH; split.
- rewrite setDE -bigcapIl//; apply: (g_monotone_monotone G).2.
move=> m n mn; apply/subsetPset; apply: setSI; exact/subsetPset/niH.
by move=> i; have [] := KFH i.
- rewrite setDE setC_bigcap setI_bigcupr; apply: (g_monotone_monotone G).1.
move=> m n mn; apply/subsetPset.
by apply: setIS; apply: subsetC; exact/subsetPset/niH.
by move=> i; have [] := KFH i.
- rewrite setU_bigcapl//; apply: (g_monotone_monotone G).2.
move=> m n mn; apply/subsetPset.
by apply: setSU; exact/subsetPset/niH.
by move=> i; have [] := KFH i.
have G_KF F : G F -> G `<=` K(F).
case: ringG => _ GU GDI GF A GA; split.
- by apply: sub_gen_smallest; exact: GDI.
- by apply: sub_gen_smallest; exact: GDI.
- by apply: sub_gen_smallest; exact: GU.
have GM_KF F : G F -> M `<=` K(F).
by move=> GF; apply: smallest_sub => //; exact: G_KF.
have MG_KF F : M F -> G `<=` K(F).
by move=> MF A GA; rewrite /K/=; split; have /KP[] := GM_KF _ GA _ MF.
have MM_KF F : M F -> M `<=` K(F).
by move=> MF; apply: smallest_sub => //; exact: MG_KF.
split.
- by apply: sub_gen_smallest; case: ringG.
- by move=> A B GA GB; have [] := MM_KF _ GB _ GA.
- by move=> A B GA GB; have [] := MM_KF _ GB _ GA.
Qed.
Lemma
Proof.
by apply: smallest_sub; [exact: g_sigma_ring_monotone|
exact: sub_g_sigma_ring].
apply: smallest_sub; last exact: sub_smallest.
apply: setring_monotone_sigma_ring; last exact: g_monotone_monotone.
exact: g_monotone_setring.
Qed.
End g_monotone_g_sigma_ring.
Corollary
setring R -> R `<=` G -> <<sr R>> `<=` G.
Proof.
Section smallest_lambda_system.
Variables ( : Type) ( : set (set T)) (
Hypothesis
Lemma
<<l D, G >> = <<s D, G >>.
Proof.
apply: smallest_sub; first exact: g_sigma_algebra_lambda_system.
exact: sub_sigma_algebra.
suff: setI_closed <<l D, G >>.
move=> IH; apply: smallest_sub => //.
by apply/sigma_algebraP; case: lambdaDG.
pose H := <<l D, G >>.
pose H_ := [set | H X /\ H (X `&` A)].
have setDH_ A : setSD_closed (H_ A).
move=> X Y XY [HX HXA] [HY HYA]; case: lambdaDG => h _ setDH _; split.
exact: setDH.
rewrite (_ : _ `&` _ = (X `&` A) `\` (Y `&` A)); last first.
rewrite predeqE => x; split=> [[[? ?] ?]|]; first by split => // -[].
by move=> [[? ?] YAx]; split => //; split => //; apply: contra_not YAx.
by apply: setDH => //; exact: setSI.
have ndH_ A : ndseq_closed (H_ A).
move=> F ndF H_AF; split.
by case: lambdaDG => h _ _; apply => // => n; have [] := H_AF n.
rewrite setI_bigcupl; case: lambdaDG => h _ _; apply => //.
by move=> m n mn; apply/subsetPset; apply: setSI; apply/subsetPset/ndF.
by move=> n; have [] := H_AF n.
have GGH_ X : G X -> G `<=` H_ X.
move=> GX; rewrite /H_ => A GA; split; first exact: sub_smallest GA.
by apply: (@sub_smallest _ _ _ G) => //; exact: setIG.
have HD X : H X -> X `<=` D by move=> ?; case: lambdaDG => + _ _ _; apply.
have GHH_ X : G X -> H `<=` H_ X.
move=> GX; apply: smallest_sub; last exact: GGH_.
split => //; first by move=> A [HA _]; case: lambdaDG => + _ _ _; exact.
have XD : X `<=` D by apply: HD; exact: (@sub_smallest _ _ _ G).
rewrite /H_ /= setIidr//; split; [by case: lambdaDG|].
exact: (@sub_smallest _ _ _ G).
have HGH_ X : H X -> G `<=` H_ X.
move=> *; split; [|by rewrite setIC; apply GHH_].
exact: (@sub_smallest _ _ _ G).
have HHH_ X : H X -> H `<=` H_ X.
move=> HX; apply: smallest_sub; last exact: HGH_.
split=> //.
- by move=> ? [? ?]; case: lambdaDG => + _ _ _; exact.
- have XD : X `<=` D := HD _ HX.
by rewrite /H_/= setIidr//; split => //; case: lambdaDG.
by move=> *; apply HHH_.
Qed.
End smallest_lambda_system.
Section lambda_system_subset.
Variables ( : Type) ( : set (set T)) (
Variables ( : set (set T)) ( : lambda_system D H) ( : G `<=` H).
- mathcomp.analysis.kernel
- mathcomp.analysis.measure_theory.measure_function
- mathcomp.analysis.lebesgue_integral_theory.lebesgue_integral_fubini
Source code
<<s D, G >> `<=` H.
Proof.
rewrite -(@smallest_lambda_system _ _ setIG D) //.
- exact: smallest_sub.
- apply: lambda_system_smallest => A GA.
by apply: sDGD; exact: sub_sigma_algebra.
Qed.
End lambda_system_subset.
Section dynkin.
Variable : Type.
Implicit Types G D : set (set T).
Lemma
Proof.
Lemma
Proof.
Lemma
(forall , G (F n)) -> G (\bigcup_ F k))
Proof.
End dynkin.
Section dynkin_lemmas.
Variable : Type.
Implicit Types D G : set (set T).
Lemma
Proof.
- move=> A B BA GA GB; rewrite setDE -(setCK (_ `&` _)) setCI; apply: (setCG).
rewrite setCK -bigcup2E; apply trG.
+ by rewrite -trivIset_bigcup2 setIC; apply subsets_disjoint.
+ by move=> [|[//|n]]; [exact: setCG|rewrite /bigcup2 -setCT; apply: setCG].
- move=> F ndF GF; rewrite -eq_bigcup_seqD; apply: (trG).
exact: trivIset_seqD.
move=> [/=|n]; first exact: GF.
rewrite /seqD setDE -(setCK (_ `&` _)) setCI; apply: (setCG).
rewrite setCK -bigcup2E; apply: trG.
+ rewrite -trivIset_bigcup2 setIC; apply subsets_disjoint.
exact/subsetPset/ndF/ltnW.
+ move=> [|[|]]; rewrite /bigcup2 /=; [exact/setCG/GF|exact/GF|].
by move=> _; rewrite -setCT; apply: setCG.
- by move=> A B; rewrite -setTD; apply: setDG.
- move=> F tF GF; pose A := \big[setU/set0]_( < i.+1) F k.
rewrite -bigcup_bigsetU_bigcup.
apply: ndG; first by move=> a b ab; exact/subsetPset/subset_bigsetU.
elim=> /= => [|n ih].
by rewrite /A big_ord_recr /= big_ord0 set0U; exact: GF.
rewrite /A /= big_ord_recr /= -/(A n).
rewrite (_ : _ `|` _ = ~` (~` A n `\` F n.+1)); last first.
by rewrite setDE setCI !setCK.
rewrite -setTD; apply: (setDG) => //; apply: (setDG) => //; last first.
by rewrite -setTD; apply: setDG.
apply/disjoints_subset; rewrite setIC.
by apply: (@trivIset_bigsetUI _ predT) => //; rewrite /predT /= trueE.
Qed.
Lemma
Proof.
- by move=> Y sGY D /= [dD GD]; exact/(dynkinC dD)/(sGY D).
- by move=> F tF gGF D /= [dD GD]; apply dD => // k; exact: gGF.
Qed.
Lemma
Proof.
Lemma
sigma_algebra setT G.
Proof.
- by rewrite -setCT; exact/(dynkinC dG)/(dynkinT dG).
- by move=> A GA; rewrite setTD; exact: (dynkinC dG).
- rewrite seqDU_bigcup_eq; apply/(dynkinU dG) => //.
move=> n; rewrite /seqDU setDE; apply GI => //.
rewrite -bigcup_mkord setC_bigcup bigcap_mkord.
apply: big_ind => //; first by case: dG.
by move=> i _; exact/(dynkinC dG).
Qed.
Lemma
setI_closed G -> <<d G >> = <<s G >>.
Proof.
by apply: sub_smallest2l; exact: sigma_algebra_dynkin.
pose delta ( : set T) := [set | <<d G >> (E `&` D)].
have ddelta ( : set T) : <<d G >> D -> dynkin (delta D).
move=> dGD; split; first by rewrite /delta /= setTI.
- move=> E DE; rewrite /delta /=.
have -> : (~` E) `&` D = ~` ((E `&` D) `|` (~` D)).
by rewrite -[LHS]setU0 -(setICl D) -setIUl -setCI -{2}(setCK D) -setCU.
have : <<d G >> ((E `&` D) `|` ~` D).
rewrite -bigcup2E => S [dS GS]; apply: (dynkinU dS).
move=> [|[|i]] [|[|j]] => // _ _; rewrite /bigcup2 /=.
+ by rewrite -setIA setICr setI0 => /set0P; rewrite eqxx.
+ by rewrite setI0 => /set0P; rewrite eqxx.
+ by rewrite setICA setICl setI0 => /set0P; rewrite eqxx.
+ by rewrite setI0 => /set0P; rewrite eqxx.
+ by rewrite set0I => /set0P; rewrite eqxx.
+ by rewrite set0I => /set0P; rewrite eqxx.
+ by rewrite set0I => /set0P; rewrite eqxx.
move=> [|[|n]] //; rewrite /bigcup2 /=; [exact: DE| |].
+ suff: <<d G >> (~` D) by exact.
by move=> F [dF GF]; apply: (dynkinC dF) => //; exact: dGD.
+ by rewrite -setCT; apply/(dynkinC dS)/(dynkinT dS).
by move=> dGEDD S /= [+ GS] => dS; apply/(dynkinC dS); exact: dGEDD.
- move=> F tF deltaDF; rewrite /delta /= => S /= [dS GS].
rewrite setI_bigcupl; apply: (dynkinU dS) => //.
by under eq_fun do rewrite setIC; exact: trivIset_setIl.
by move=> n; exact: deltaDF.
have GdG : G `<=` <<d G >> by move=> ? ? ? [_]; apply.
have Gdelta A : G A -> G `<=` delta A.
by move=> ? ? ?; rewrite /delta /= => ? [?]; apply; exact/GI.
have GdGdelta A : G A -> <<d G >> `<=` delta A.
move=> ?; apply: smallest_sub => //; last exact: Gdelta.
by apply/ddelta; exact: GdG.
have dGGI A B : <<d G >> A -> G B -> <<d G >> (A `&` B).
by move=> ? ?; apply: GdGdelta.
have dGGdelta A : <<d G >> A -> G `<=` delta A.
by move=> ? ? ?; rewrite /delta /= setIC; exact: dGGI.
have dGdGdelta A : <<d G >> A -> <<d G >> `<=` delta A.
by move=> ?; exact: smallest_sub (ddelta _ _) (dGGdelta _ _).
have dGdGdG A B : <<d G >> A -> <<d G >> B -> <<d G >> (A `&` B).
by move=> ? ?; exact: dGdGdelta.
apply: smallest_sub => //; apply: dynkin_setI_sigma_algebra => //.
exact: g_dynkin_dynkin.
Qed.
End dynkin_lemmas.
Section trace.
Variable ( : Type).
Implicit Types (G : set (set T)) (A D : set T).
Definition
setSD_closed : forall {T : Type}, set (set T) -> Prop setSD_closed is not universe polymorphic Arguments setSD_closed {T}%type_scope G%classical_set_scope setSD_closed is transparent Expands to: Constant mathcomp.analysis.measure_theory.measurable_structure.setSD_closed Declared in library mathcomp.analysis.measure_theory.measurable_structure, line 164, characters 11-23 setD_closed : forall {T : Type}, set (set T) -> Prop setD_closed is not universe polymorphic Arguments setD_closed {T}%type_scope G%classical_set_scope setD_closed is transparent Expands to: Constant mathcomp.analysis.measure_theory.measurable_structure.setD_closed Declared in library mathcomp.analysis.measure_theory.measurable_structure, line 165, characters 11-22 setY_closed : forall {T : Type}, set (set T) -> Prop setY_closed is not universe polymorphic Arguments setY_closed {T}%type_scope G%classical_set_scope setY_closed is transparent Expands to: Constant mathcomp.analysis.measure_theory.measurable_structure.setY_closed Declared in library mathcomp.analysis.measure_theory.measurable_structure, line 166, characters 11-22
Source code
Lemma
Proof.
Lemma
Proof.
by move=> X [A0 GA0 <-]; exact: subIsetr.
Qed.
Lemma
Proof.
- by exists set0; rewrite ?set0I//; have [] := smallest_sigma_ring G.
- move=> _ _ [A0 GA0] <- [A1 GA1] <-.
exists (A0 `\` A1); first by have [_ + _] := smallest_sigma_ring G; exact.
by rewrite -setIDA setDIr setDv setU0 setIDAC setIDA.
- move=> F GAF.
pose f := sval (cid2 (GAF n)).
pose Hf := (svalP (cid2 (GAF n))).1.
pose H := (svalP (cid2 (GAF n))).2.
exists (\bigcup_ f k).
by have [_ _] := smallest_sigma_ring G; apply => n; exact: Hf.
by rewrite setI_bigcupl; apply: eq_bigcupr => i _; exact: H.
Qed.
Proof.
have D_sigma_ring : sigma_ring D.
split.
- exists set0; first by have [] := smallest_sigma_ring (strace G A).
exists set0; first by have [] := smallest_sigma_ring G.
by rewrite set0D setU0.
- move=> _ _ [B0 GAB0] [C0 GC0] <- [B1 GAB1] [C1 GC1] <-.
exists (B0 `\` B1).
by have [_ + _] := smallest_sigma_ring (strace G A); exact.
exists (C0 `\` C1); first by have [_ + _] := smallest_sigma_ring G; exact.
apply/esym; rewrite setDUD.
transitivity (((B0 `\` B1) `&` (B0 `\` (C1 `\` A))) `|`
((C0 `\` (A `|` B1)) `&` (C0 `\` C1))).
congr setU; first by rewrite setDUr.
apply/seteqP; split => [x [[C0x Ax]]|x].
move=> /not_orP[B1x /not_andP[C1x|//]].
by split=> //; split => // -[].
move=> [[C0x /not_orP[Ax B1x] [_ C1x]]].
by split=> // -[//|[]].
transitivity (((B0 `\` B1) `&` B0) `|`
((C0 `\` A ) `&` (C0 `\` C1))).
apply/seteqP; split => [x [[[B0x B1x] [_ /not_andP[C1x|]]]|
[[C0x /not_orP[Ax B1x]] [_ C1x]]]|
x [[[B0x B1x] _]|[[C0x Ax] [_ C1x]]]].
+ by left; split.
+ by move=> /contrapT Ax; left.
+ by right; split.
+ left; split => //; split => // -[] _; apply.
exact: (g_sigma_ring_strace GAB0).
+ right; split => //; split => // -[//|B1x]; apply: Ax.
exact: (g_sigma_ring_strace GAB1).
+ congr setU; first by rewrite setDE setIAC setIid.
by rewrite setDDl setDUr setIC.
- move=> F DF.
pose f := sval (cid2 (DF n)).
pose Hf := (svalP (cid2 (DF n))).1.
pose g := sval (cid2 (svalP (cid2 (DF n))).2).
pose Hg := (svalP (cid2 (svalP (cid2 (DF n))).2)).1.
exists (\bigcup_ f n).
have [_ _] := smallest_sigma_ring (strace G A).
by apply => n; exact: Hf.
exists (\bigcup_ g n).
have [_ _] := smallest_sigma_ring G.
by apply => n; exact: Hg.
pose H := (svalP (cid2 (svalP (cid2 (DF n))).2)).2.
by rewrite setD_bigcupl -bigcupU; apply: eq_bigcupr => k _; exact: H.
apply/seteqP; split => [|].
have GD : G `<=` D.
move=> E GE; exists (E `&` A).
by apply: sub_g_sigma_ring; exists E.
by exists E; [exact: sub_g_sigma_ring|exact: setUIDK].
have {}GD : <<sr G >> `<=` D by exact: smallest_sub GD.
have GDA : strace <<sr G >> A `<=` strace D A by exact: subset_strace.
suff: strace D A = <<sr strace G A >> by move=> <-.
apply/seteqP; split.
move=> _ [_ [gA HgA [g Hg] <-] <-].
by rewrite setIUl setDKI setU0 setIidl//; exact: (g_sigma_ring_strace HgA).
move=> X HX; exists X.
exists X => //; exists set0; rewrite ?set0D ?setU0//.
by have [] := smallest_sigma_ring G.
by rewrite setIidl//; exact: (g_sigma_ring_strace HX).
have : strace G A `<=` strace <<sr G>> A.
by move=> X [Y GY <-]; exists Y => //; exact: sub_smallest GY.
by apply: smallest_sub; exact: strace_sigma_ring.
Qed.
Lemma
sigma_algebra setT G -> sigma_algebra D (strace G D).
Proof.
- move=> S [A mA ADS]; have mCA := GC _ mA.
have : strace G D (D `&` ~` A).
by rewrite setIC; exists (setT `\` A) => //; rewrite setTD.
rewrite -setDE => trDA.
have DADS : D `\` A = D `\` S by rewrite -ADS !setDE setCI setIUr setICr setU0.
by rewrite DADS in trDA.
- move=> S mS; have /choice[M GM] : forall , exists , G A /\ S n = A `&` D.
by move=> n; have [A mA ADSn] := mS n; exists A.
exists (\bigcup_ (M i)); first by apply GU => i; exact: (GM i).1.
by rewrite setI_bigcupl; apply eq_bigcupr => i _; rewrite (GM i).2.
Qed.
End trace.
.
measurable : set (set T) ;
measurable0 : measurable set0 ;
measurableI : setI_closed measurable;
semi_measurableD : semi_setD_closed measurable;
}.
.
{ of Pointed T & isSemiRingOfSets d T}.
Arguments measurable {d}%_measure_display_scope {s} _%_classical_set_scope.
Lemma
( : T1 * T2 -> set T) ( : T1 * T2) :
measurable (G x) <-> measurable (curry G x.1 x.2).
Proof.
Notation
- mathcomp.analysis.lebesgue_measure
- mathcomp.analysis.charge
- mathcomp.analysis.ess_sup_inf
- mathcomp.analysis.kernel
- mathcomp.analysis.measure_theory.measure_function
- mathcomp.analysis.measure_theory.measure_extension
- mathcomp.analysis.measurable_realfun
- mathcomp.analysis.lebesgue_integral_theory.lebesgue_integrable
- mathcomp.analysis.lebesgue_integral_theory.lebesgue_Rintegral
- mathcomp.analysis.lebesgue_integral_theory.lebesgue_integral_nonneg
- mathcomp.analysis.lebesgue_integral_theory.measurable_fun_approximation
- mathcomp.analysis.probability_theory.random_variable
Source code
Notation
(@measurable default_measure_display) : classical_set_scope.
.
measurableU : @setU_closed T measurable
}.
.
{ of SemiRingOfSets d T & SemiRingOfSets_isRingOfSets d T }.
.
measurableT : measurable [set: T]
}.
.
{ of RingOfSets d T & RingOfSets_isAlgebraOfSets d T }.
.
bigcupT_measurable : forall : (set T)^nat, (forall , measurable (F i)) ->
measurable (\bigcup_ (F i))
}.
.
Let : @setU_closed T measurable.
Proof.
by apply: bigcupT_measurable => -[//|[//|/= _]]; exact: measurable0.
Qed.
.
.
.
{ of SemiRingOfSets d T & hasMeasurableCountableUnion d T}.
.
measurable : set (set T) ;
measurable0 : measurable set0 ;
measurableD : setD_closed measurable ;
bigcupT_measurable : forall : (set T)^nat, (forall , measurable (F i)) ->
measurable (\bigcup_ (F i))
}.
.
Let : measurable set0
Proof.
Let : setI_closed measurable.
Proof.
Let : semi_setD_closed measurable.
Proof.
.
.
.
.
{ of AlgebraOfSets d T & hasMeasurableCountableUnion d T }.
.
measurable : set (set T) ;
measurable0 : measurable set0 ;
measurableU : setU_closed measurable;
measurableD : setD_closed measurable;
}.
.
Implicit Types (A B C D : set T).
Lemma : setI_closed measurable.
Proof.
Lemma : semi_setD_closed measurable.
Proof.
.
.
.
.
& Pointed T := {
measurable : set (set T) ;
measurable_nonempty : measurable !=set0 ;
measurable_setY : setY_closed measurable ;
measurable_setI : setI_closed measurable }.
.
Let : measurable set0.
Proof.
Let : setU_closed measurable.
Proof.
by apply: measurable_setY; [exact: measurable_setY|exact: measurable_setI].
Qed.
Let : setD_closed measurable.
Proof.
.
.
.
measurable : set (set T) ;
measurable0 : measurable set0 ;
measurableU : setU_closed measurable;
measurableC : setC_closed measurable
}.
.
Lemma : setD_closed measurable.
Proof.
by do ?[apply: measurableU | apply: measurableC].
Qed.
.
measurable measurable0 measurableU mD.
Lemma
Proof.
.
.
.
measurable : set (set T) ;
measurableT : measurable [set: T] ;
measurableD : setD_closed measurable
}.
.
Let : measurable set0.
Proof.
Let : setU_closed measurable.
Proof.
rewrite -(setCK A) -setCD -!setTD; apply: measurableD; first exact: measurableT.
by do 2 apply: measurableD => //; exact: measurableT.
Qed.
.
.
.
- mathcomp.analysis.lebesgue_stieltjes_measure
- mathcomp.analysis.measurable_realfun
Source code
- mathcomp.analysis.lebesgue_stieltjes_measure
- mathcomp.analysis.measurable_realfun
Source code
- mathcomp.analysis.lebesgue_stieltjes_measure
- mathcomp.analysis.measurable_realfun
Source code
- mathcomp.analysis.lebesgue_stieltjes_measure
- mathcomp.analysis.measurable_realfun
Source code
- mathcomp.analysis.lebesgue_stieltjes_measure
- mathcomp.analysis.measurable_realfun
Source code
- mathcomp.analysis.lebesgue_stieltjes_measure
- mathcomp.analysis.measurable_realfun
Source code
- mathcomp.analysis.lebesgue_stieltjes_measure
- mathcomp.analysis.measurable_realfun
Source code
measurable : set (set T) ;
measurable0 : measurable set0 ;
measurableC : forall , measurable A -> measurable (~` A) ;
measurable_bigcup : forall : (set T)^nat, (forall , measurable (F i)) ->
measurable (\bigcup_ (F i))
}.
.
Obligation Tactic := idtac.
Lemma : setU_closed measurable.
Proof.
by apply: measurable_bigcup => -[//|[//|i]]; exact: measurable0.
Qed.
Lemma : setC_closed measurable
Proof.
.
measurable measurable0 mU mC.
.
.
#[global] Hint Extern 0 (measurable set0) => solve [apply: measurable0] : core.
#[global] Hint Extern 0 (measurable setT) => solve [apply: measurableT] : core.
Section ringofsets_lemmas.
Context ( : ringOfSetsType d).
Implicit Types A B : set T.
Lemma
- mathcomp.analysis.lebesgue_measure
- mathcomp.analysis.charge
- mathcomp.analysis.ftc
- mathcomp.analysis.measure_theory.measure_negligible
- mathcomp.analysis.measure_theory.measure_function
- mathcomp.analysis.lebesgue_integral_theory.lebesgue_integral_under
- mathcomp.analysis.lebesgue_integral_theory.lebesgue_integral_differentiation
- mathcomp.analysis.lebesgue_integral_theory.lebesgue_integral_nonneg
- mathcomp.analysis.lebesgue_integral_theory.lebesgue_integral_definition
Source code
(forall , P i -> measurable (F i)) ->
measurable (\big[setU/set0]_( <- r | P i) F i).
Proof.
Lemma
- mathcomp.analysis.measure_theory.measure_function
- mathcomp.analysis.lebesgue_integral_theory.measurable_fun_approximation
Source code
finite_set D ->
(forall , D i -> measurable (F i)) ->
measurable (\bigcup_( in D) F i).
Proof.
rewrite -bigsetU_fset_set// big_seq; apply: bigsetU_measurable => i.
by rewrite in_fset_set ?inE// => *; apply: Fm.
Qed.
Lemma
- mathcomp.analysis.lebesgue_stieltjes_measure
- mathcomp.analysis.lebesgue_measure
- mathcomp.analysis.charge
- mathcomp.analysis.ftc
- mathcomp.analysis.kernel
- mathcomp.analysis.measure_theory.measure_negligible
- mathcomp.analysis.measure_theory.measure_function
- mathcomp.analysis.measure_theory.measurable_function
- mathcomp.analysis.measure_theory.measure_extension
- mathcomp.analysis.measurable_realfun
- mathcomp.analysis.lebesgue_integral_theory.lebesgue_integrable
- mathcomp.analysis.lebesgue_integral_theory.lebesgue_integral_fubini
- mathcomp.analysis.lebesgue_integral_theory.lebesgue_integral_dominated_convergence
- mathcomp.analysis.lebesgue_integral_theory.lebesgue_integral_under
- mathcomp.analysis.lebesgue_integral_theory.lebesgue_integral_differentiation
- mathcomp.analysis.lebesgue_integral_theory.lebesgue_integral_nonneg
- mathcomp.analysis.lebesgue_integral_theory.measurable_fun_approximation
Source code
Proof.
by apply: fin_bigcup_measurable.
Qed.
Lemma
- mathcomp.analysis.measure_theory.measure_negligible
Source code
(forall , measurable (F n)) -> forall , measurable (seqDU F n).
Proof.
End ringofsets_lemmas.
Section algebraofsets_lemmas.
Context ( : algebraOfSetsType d).
Implicit Types A B : set T.
Lemma
- mathcomp.analysis.lebesgue_stieltjes_measure
- mathcomp.analysis.lebesgue_measure
- mathcomp.analysis.charge
- mathcomp.analysis.ftc
- mathcomp.analysis.kernel
- mathcomp.analysis.measure_theory.probability_measure
- mathcomp.analysis.measure_theory.measure_function
- mathcomp.analysis.measure_theory.measurable_function
- mathcomp.analysis.measure_theory.measure_extension
- mathcomp.analysis.measurable_realfun
- mathcomp.analysis.lebesgue_integral_theory.lebesgue_integrable
- mathcomp.analysis.lebesgue_integral_theory.lebesgue_integral_fubini
- mathcomp.analysis.lebesgue_integral_theory.lebesgue_integral_nonneg
- mathcomp.analysis.lebesgue_integral_theory.measurable_fun_approximation
- mathcomp.analysis.probability_theory.random_variable
- mathcomp.analysis.probability_theory.exponential_distribution
Source code
Proof.
Lemma
(forall , P i -> measurable (F i)) ->
measurable (\big[setI/setT]_( <- r | P i) F i).
Proof.
by apply: bigsetU_measurable => i Pi; apply/measurableC/mF.
Qed.
Lemma
finite_set D ->
(forall , D i -> measurable (F i)) ->
measurable (\bigcap_( in D) F i).
Proof.
rewrite -bigsetI_fset_set// big_seq; apply: bigsetI_measurable => i.
by rewrite in_fset_set ?inE// => *; apply: Fm.
Qed.
Lemma
- mathcomp.analysis.measure_theory.measurable_function
Source code
measurable (A `\` B).
Proof.
by rewrite setIUr setICr set0U.
Qed.
End algebraofsets_lemmas.
Section sigmaring_lemmas.
Context ( : sigmaRingType d).
Implicit Types (A B : set T) (F : (set T)^nat) (P : set nat).
Lemma
- mathcomp.analysis.lebesgue_stieltjes_measure
- mathcomp.analysis.lebesgue_measure
- mathcomp.analysis.charge
- mathcomp.analysis.ftc
- mathcomp.analysis.kernel
- mathcomp.analysis.measure_theory.measure_negligible
- mathcomp.analysis.measure_theory.measure_function
- mathcomp.analysis.measure_theory.measurable_function
- mathcomp.analysis.measurable_realfun
- mathcomp.analysis.lebesgue_integral_theory.lebesgue_integrable
- mathcomp.analysis.lebesgue_integral_theory.lebesgue_integral_under
- mathcomp.analysis.lebesgue_integral_theory.lebesgue_integral_nonneg
- mathcomp.analysis.lebesgue_integral_theory.measurable_fun_approximation
- mathcomp.analysis.lebesgue_integral_theory.giry
- mathcomp.analysis.probability_theory.random_variable
Source code
(forall , P k -> measurable (F k)) -> measurable (\bigcup_( in P) F i).
Proof.
by case: ifP => //; rewrite inE; exact: PF.
Qed.
Lemma
- mathcomp.analysis.lebesgue_stieltjes_measure
- mathcomp.analysis.charge
- mathcomp.analysis.measure_theory.measure_function
- mathcomp.analysis.measurable_realfun
- mathcomp.analysis.lebesgue_integral_theory.measurable_fun_approximation
- mathcomp.analysis.probability_theory.random_variable
Source code
(forall , P k -> measurable (F k)) -> measurable (\bigcap_( in P) F i).
Proof.
apply: measurableD; first exact: PF.
by apply: bigcup_measurable => k/= [Pk kj]; apply: measurableD; exact: PF.
Qed.
Lemma
- mathcomp.analysis.lebesgue_measure
- mathcomp.analysis.measurable_realfun
- mathcomp.analysis.lebesgue_integral_theory.lebesgue_integral_differentiation
- mathcomp.analysis.borel_hierarchy
Source code
(forall , measurable (F k)) -> measurable (\bigcap_ F i).
Proof.
End sigmaring_lemmas.
Lemma
- mathcomp.analysis.lebesgue_integral_theory.giry
Source code
( : set_system T) :
@measurable _ T = <<s G >> ->
setI_closed G ->
P [set: T] ->
G `<=` P ->
(forall , measurable S -> P S -> P (~` S)) ->
(forall : (set T)^nat,
(forall , measurable (F n)) ->
trivIset [set: nat] F ->
(forall , P (F n)) -> P (\bigcup_ F k)) ->
(forall , <<s G >> S -> P S).
Proof.
suff: <<s G >> `<=` [set | measurable A /\ P A] by move=> /(_ _ sGA)[].
apply: lambda_system_subset; [by []| | |by []].
- apply/dynkin_lambda_system; split => //.
+ by move=> B [mB PB]; split; [exact: measurableC|exact: PsetC].
+ move=> F tF Hm; split.
by apply: bigcup_measurable => k _; apply Hm.
by apply: Pbigcup => //; apply Hm.
- move=> B GB; split; last exact: GP.
by rewrite GE; exact: sub_gen_smallest.
Qed.
Lemma
- mathcomp.analysis.probability_theory.random_variable
Source code
(forall : T, measurable [set t]) -> countable A -> measurable A.
Proof.
rewrite -(injpinv_image (cst r) injf).
rewrite [X in _ X](_ : _ = \bigcup_( in f @` A) [set 'pinv_(cst r) A f x]).
by apply: bigcup_measurable => _ /= [s As <-].
by rewrite eqEsubset; split=> [_ [_ [s As <-]] <-|_ [_ [s As <-]] ->];
exists (f s).
Qed.
Context ( : sigmaRingType d).
Lemma
lambda_system D [set | measurable X /\ X `<=` D].
Proof.
- by move=> A /=[].
- by split.
- move=> B A AB/= [mB BD] [mA AD]; split; first exact: measurableD.
by apply: subset_trans BD; exact: subDsetl.
- move=> /= F _ mFD; split.
by apply: bigcup_measurable => i _; exact: (mFD _).1.
by apply: bigcup_sub => i _; exact: (mFD _).2.
Qed.
End sigma_ring_lambda_system.
Lemma
( : U -> set T) : countable [set: U] ->
(forall , measurable (F i)) -> measurable (\bigcup_ F i).
Proof.
move=> /countable_bijP[B] /ppcard_eqP[f] Fm.
rewrite (reindex_bigcup f^-1%FUN setT)//=; first exact: bigcupT_measurable.
exact: (@subl_surj _ _ B).
Qed.
Lemma
- mathcomp.analysis.measurable_realfun
Source code
(forall , measurable (F i)) -> measurable (\bigcup_ F i).
Proof.
Section measurable_lemmas.
Context ( : measurableType d).
Implicit Types (A B : set T) (F : (set T)^nat) (P : set nat).
Lemma
- mathcomp.analysis.measure_theory.measure_function
- mathcomp.analysis.measure_theory.measurable_function
- mathcomp.analysis.lebesgue_integral_theory.giry
Source code
Proof.
Lemma
- mathcomp.analysis.charge
- mathcomp.analysis.measurable_realfun
Source code
(forall , P k -> measurable (F k)) -> measurable (\bigcap_( in P) F i).
Proof.
by apply: bigcup_measurable => k Pk; exact/measurableC/PF.
Qed.
End measurable_lemmas.
Section discrete_measurable.
Context { : Type}.
Definition
fin_bigcap_closed : forall {T : Type}, set (set T) -> Prop fin_bigcap_closed is not universe polymorphic Arguments fin_bigcap_closed {T}%type_scope G%classical_set_scope fin_bigcap_closed is transparent Expands to: Constant mathcomp.analysis.measure_theory.measurable_structure.fin_bigcap_closed Declared in library mathcomp.analysis.measure_theory.measurable_structure, line 168, characters 11-28 finN0_bigcap_closed : forall {T : Type}, set (set T) -> Prop finN0_bigcap_closed is not universe polymorphic Arguments finN0_bigcap_closed {T}%type_scope G%classical_set_scope finN0_bigcap_closed is transparent Expands to: Constant mathcomp.analysis.measure_theory.measurable_structure.finN0_bigcap_closed Declared in library mathcomp.analysis.measure_theory.measurable_structure, line 172, characters 11-30 fin_bigcup_closed : forall {T : Type}, set (set T) -> Prop fin_bigcup_closed is not universe polymorphic Arguments fin_bigcup_closed {T}%type_scope G%classical_set_scope fin_bigcup_closed is transparent Expands to: Constant mathcomp.analysis.measure_theory.measurable_structure.fin_bigcup_closed Declared in library mathcomp.analysis.measure_theory.measurable_structure, line 177, characters 11-28
Source code
Lemma
Proof.
Lemma
discrete_measurable X -> discrete_measurable (~` X).
Proof.
Lemma
(forall , discrete_measurable (F i)) ->
discrete_measurable (\bigcup_ F i).
Proof.
End discrete_measurable.
.
unit discrete_measurable discrete_measurable0
discrete_measurableC discrete_measurableU.
.
bool discrete_measurable discrete_measurable0
discrete_measurableC discrete_measurableU.
.
nat discrete_measurable discrete_measurable0
discrete_measurableC discrete_measurableU.
Definition
semi_setD_closed : forall {T : Type}, set (set T) -> Prop semi_setD_closed is not universe polymorphic Arguments semi_setD_closed {T}%type_scope G%classical_set_scope semi_setD_closed is transparent Expands to: Constant mathcomp.analysis.measure_theory.measurable_structure.semi_setD_closed Declared in library mathcomp.analysis.measure_theory.measurable_structure, line 181, characters 11-27
Source code
Proof.
Definition
ndseq_closed : forall {T : Type}, set (set T) -> Prop ndseq_closed is not universe polymorphic Arguments ndseq_closed {T}%type_scope G%classical_set_scope ndseq_closed is transparent Expands to: Constant mathcomp.analysis.measure_theory.measurable_structure.ndseq_closed Declared in library mathcomp.analysis.measure_theory.measurable_structure, line 191, characters 11-23
Used by
- mathcomp.analysis.lebesgue_stieltjes_measure
- mathcomp.analysis.measure_theory.probability_measure
- mathcomp.analysis.measure_theory.measure_function
- mathcomp.analysis.measure_theory.measurable_function
- mathcomp.analysis.measure_theory.measure_extension
- mathcomp.analysis.lebesgue_integral_theory.lebesgue_integral_nonneg
Source code
Section g_salgebra_instance.
Variables ( : pointedType) ( : set (set T)).
Lemma
- mathcomp.analysis.lebesgue_integral_theory.giry
Source code
Proof.
.
.
(g_sigma_algebraType G)
<<s G >> (@sigma_algebra0 _ setT G) (@sigma_algebraC)
(@sigma_algebra_bigcup _ setT G).
End g_salgebra_instance.
Notation
- mathcomp.analysis.measure_theory.probability_measure
- mathcomp.analysis.measure_theory.measure_function
Source code
Notation
- mathcomp.analysis.lebesgue_stieltjes_measure
- mathcomp.analysis.lebesgue_measure
- mathcomp.analysis.measure_theory.measure_extension
- mathcomp.analysis.measurable_realfun
Source code
(measurable : set (set (g_sigma_algebraType G))) : classical_set_scope.
Lemma
sigma_algebra setT G -> G.-sigma.-measurable = G.
Proof.
Section measurability.
Definition
niseq_closed : forall {T : Type}, set (set T) -> Prop niseq_closed is not universe polymorphic Arguments niseq_closed {T}%type_scope G%classical_set_scope niseq_closed is transparent Expands to: Constant mathcomp.analysis.measure_theory.measurable_structure.niseq_closed Declared in library mathcomp.analysis.measure_theory.measurable_structure, line 194, characters 11-23
Used by
- mathcomp.analysis.measure_theory.measure_function
- mathcomp.analysis.measure_theory.measurable_function
- mathcomp.analysis.lebesgue_integral_theory.giry
Source code
( : set_system rT) : set (set aT) :=
[set D `&` f @^-1` B | in G].
Lemma
- mathcomp.analysis.measure_theory.measurable_function
Source code
preimage_set_system D f set0 = set0.
Proof.
Lemma
- mathcomp.analysis.measure_theory.measurable_function
Source code
{morph preimage_set_system D f : / x `|` y >-> x `|` y}.
Proof.
Lemma
- mathcomp.analysis.measure_theory.measurable_function
Source code
( : aT -> bT) ( : bT -> rT) ( : set_system rT) :
preimage_set_system D (g \o f) F
= preimage_set_system D f (preimage_set_system setT g F).
Proof.
by exists (g @^-1` B) => //; exists B => //; rewrite setTI.
by exists C => //; rewrite setTI comp_preimage.
Qed.
Lemma
preimage_set_system D idfun F = setI D @` F.
Proof.
Lemma
( : set aT) ( : aT -> rT) :
sigma_algebra setT G -> sigma_algebra D (preimage_set_system D f G).
Proof.
- move=> A; rewrite /preimage_set_system /= => -[B mB <-{A}].
exists (~` B); first by rewrite -setTD; exact: hC.
rewrite predeqE => x; split=> [[Dx Bfx]|[Dx]]; first by split => // -[] _ /Bfx.
by move=> /not_andP[].
- move=> F; rewrite /preimage_set_system /= => mF.
have {}mF n : exists , G x /\ D `&` f @^-1` x = F n.
by have := mF n => -[B mB <-]; exists B.
have [F' mF'] := @choice _ _ (fun => G y /\ D `&` f @^-1` y = F x) mF.
exists (\bigcup_ (F' k)); first by apply: hU => n; exact: (mF' n).1.
rewrite preimage_bigcup setI_bigcupr; apply: eq_bigcupr => i _.
exact: (mF' i).2.
Qed.
Definition
trivIset_closed : forall {T : Type}, set (set T) -> Prop trivIset_closed is not universe polymorphic Arguments trivIset_closed {T}%type_scope G%classical_set_scope trivIset_closed is transparent Expands to: Constant mathcomp.analysis.measure_theory.measurable_structure.trivIset_closed Declared in library mathcomp.analysis.measure_theory.measurable_structure, line 197, characters 11-26
Source code
Proof.
Definition
fin_trivIset_closed : forall {T : Type}, set (set T) -> Prop fin_trivIset_closed is not universe polymorphic Arguments fin_trivIset_closed {T}%type_scope G%classical_set_scope fin_trivIset_closed is transparent Expands to: Constant mathcomp.analysis.measure_theory.measurable_structure.fin_trivIset_closed Declared in library mathcomp.analysis.measure_theory.measurable_structure, line 201, characters 11-30
Source code
( : measurableType d') ( : T -> T') : Type := T.
Definition
setring : forall {T : Type}, set (set T) -> Prop setring is not universe polymorphic Arguments setring {T}%type_scope G%classical_set_scope setring is transparent Expands to: Constant mathcomp.analysis.measure_theory.measurable_structure.setring Declared in library mathcomp.analysis.measure_theory.measurable_structure, line 205, characters 11-18
Source code
( : measurableType d') ( : T -> T') :=
preimage_set_system setT f (@measurable _ T').
Section preimage_generated_sigma_algebra.
Context {} ( : pointedType) ( : measurableType d').
Variable : T -> T'.
Let
Proof.
by exists set0 => //; rewrite preimage_set0 setI0.
Qed.
Let
g_sigma_algebra_preimage f A -> g_sigma_algebra_preimage f (~` A).
Proof.
by exists (~` B); [exact: measurableC|rewrite !setTI preimage_setC].
Qed.
Let
(forall , g_sigma_algebra_preimage f (F i)) ->
g_sigma_algebra_preimage f (\bigcup_ (F i)).
Proof.
pose g := fun => sval (cid2 (mF i)).
pose mg := fun => svalP (cid2 (mF i)).
exists (\bigcup_ g i).
by apply: bigcup_measurable => k; case: (mg k).
rewrite setTI /g preimage_bigcup; apply: eq_bigcupr => k _.
by case: (mg k) => _; rewrite setTI.
Qed.
.
.
(g_sigma_algebra_preimageType f) (g_sigma_algebra_preimage f)
preimage_set0 preimage_setC preimage_bigcup.
End preimage_generated_sigma_algebra.
Notation
Notation
(measurable : set (set (g_sigma_algebra_preimageType f))) : classical_set_scope.
Definition
sigma_ring : forall {T : Type}, set (set T) -> Prop sigma_ring is not universe polymorphic Arguments sigma_ring {T}%type_scope G%classical_set_scope sigma_ring is transparent Expands to: Constant mathcomp.analysis.measure_theory.measurable_structure.sigma_ring Declared in library mathcomp.analysis.measure_theory.measurable_structure, line 207, characters 11-21
Used by
- mathcomp.analysis.measure_theory.measurable_function
Source code
( : set (set aT)) : set (set rT) :=
[set : set rT | G (D `&` f @^-1` B)].
Lemma
- mathcomp.analysis.measure_theory.measurable_function
Source code
( : set (set aT)) :
sigma_algebra D G -> sigma_algebra setT (image_set_system D f G).
Proof.
- by rewrite /= preimage_set0 setI0.
- move=> A /= GfAD; rewrite setTD -preimage_setC -setDE.
rewrite (_ : _ `\` _ = D `\` (D `&` f @^-1` A)); first exact: GC.
rewrite predeqE => x; split=> [[Dx fAx]|[Dx fADx]].
by split => // -[] _ /fAx.
by split => //; exact: contra_not fADx.
- by move=> F /= mF; rewrite preimage_bigcup setI_bigcupr; exact: GU.
Qed.
Lemma
- mathcomp.analysis.measure_theory.measure_function
- mathcomp.analysis.measure_theory.measurable_function
Source code
( : aT -> rT) ( : set (set rT)) :
<<s D, preimage_set_system D f G' >> =
preimage_set_system D f (G'.-sigma.-measurable).
Proof.
have mG : sigma_algebra D
(preimage_set_system D f (G'.-sigma.-measurable)).
exact/sigma_algebra_preimage/sigma_algebra_measurable.
have subset_preimage : preimage_set_system D f G' `<=`
preimage_set_system D f (G'.-sigma.-measurable).
by move=> A [B CCB <-{A}]; exists B => //; exact: sub_sigma_algebra.
exact: smallest_sub.
have G'pre A' : G' A' -> (preimage_set_system D f G') (D `&` f @^-1` A').
by move=> ?; exists A'.
pose I : set (set aT) := <<s D, preimage_set_system D f G' >>.
have G'sfun : G' `<=` image_set_system D f I.
by move=> A' /G'pre[B G'B h]; apply: sub_sigma_algebra; exists B.
have sG'sfun : <<s G' >> `<=` image_set_system D f I.
apply: smallest_sub => //; apply: sigma_algebra_image.
exact: smallest_sigma_algebra.
by move=> _ [B mB <-]; exact: sG'sfun.
Qed.
End measurability.
#[deprecated(since="mathcomp-analysis 1.9.0", note="renamed to `preimage_set_system`")]
Notation
#[deprecated(since="mathcomp-analysis 1.9.0", note="renamed to `image_set_system`")]
Notation
#[deprecated(since="mathcomp-analysis 1.9.0", note="renamed to `sigma_algebra_preimage`")]
Notation
#[deprecated(since="mathcomp-analysis 1.9.0", note="renamed to `sigma_algebra_image`")]
Notation
#[deprecated(since="mathcomp-analysis 1.9.0", note="renamed to `g_sigma_preimageE`")]
Notation
sigma_algebra : forall {T : Type}, set T -> set (set T) -> Prop sigma_algebra is not universe polymorphic Arguments sigma_algebra {T}%type_scope (D G)%classical_set_scope sigma_algebra is transparent Expands to: Constant mathcomp.analysis.measure_theory.measurable_structure.sigma_algebra Declared in library mathcomp.analysis.measure_theory.measurable_structure, line 210, characters 11-24
Used by
- mathcomp.analysis.lebesgue_stieltjes_measure
- mathcomp.analysis.lebesgue_measure
- mathcomp.analysis.measure_theory.measure_function
- mathcomp.analysis.measure_theory.measure_extension
Source code
( : set T -> \bar R) ( : set T) ( : nat -> set T) :=
A `<=` \bigcup_ F n -> (mu A <= \sum_( <oo) mu (F n))%E.
Lemma
- mathcomp.analysis.measure_theory.measure_function
Source code
( : Monoid.com_law idx) ( : I -> set T) ( : set T -> R) :
finite_set D -> trivIset D A -> F set0 = idx ->
\big[op/idx]_( <- fset_set D) F (A i) =
\big[op/idx]_( <- (A @` fset_set D)%fset) F X.
Proof.
move=> Dfin Atriv F0; symmetry.
pose D' := [fset in fset_set D | A i != set0]%fset.
transitivity (\big[op/idx]_( <- (A @` D')%fset) F X).
apply: perm_big_supp; rewrite uniq_perm ?filter_uniq//=.
move=> X; rewrite !mem_filter; case: (eqVneq (F X) idx) => //= FXNidx.
apply/imfsetP/imfsetP=> -[i/=]; rewrite ?(inE, in_fset_set)//=.
move=> Di XAi; exists i; rewrite // !(inE, in_fset_set)//=.
by rewrite (mem_set Di)/= -XAi; apply: contra_neq FXNidx => ->.
by move=> /andP[Di AiN0] XAi; exists i; rewrite ?in_fset_set.
rewrite big_imfset//=; last first.
move=> i j; rewrite !(inE, in_fset_set)//= => /andP[+ +] /andP[+ +].
rewrite !inE => Di /set0P[x Aix] Dj _ Aij.
by apply: (Atriv _ _ Di Dj); exists x; split=> //; rewrite -Aij.
apply: perm_big_supp; rewrite uniq_perm ?filter_uniq//= => i.
rewrite !mem_filter; case: (eqVneq (F (A i)) idx) => //= FAiidx.
rewrite !(in_fset_set, inE)//=; case: (boolP (i \in D)) => //= Di.
by apply: contra_neq FAiidx => ->.
Qed.
Section covering.
Context { : Type}.
Implicit Type (C : forall , set (set I)).
Implicit Type (P : forall , set I -> set (I -> set T)).
Definition
dynkin : forall {T : Type}, set (set T) -> Prop dynkin is not universe polymorphic Arguments dynkin {T}%type_scope G%classical_set_scope dynkin is transparent Expands to: Constant mathcomp.analysis.measure_theory.measurable_structure.dynkin Declared in library mathcomp.analysis.measure_theory.measurable_structure, line 214, characters 11-17
Source code
[set : set T | exists , [/\ C I D, P I D A & X = \bigcup_( in D) A i]].
Lemma
covered_by C P `<=` covered_by C P'.
Proof.
Lemma
covered_by C P (\bigcup_( in D) A i).
Proof.
Lemma
(forall ( : set I) , (forall , D i -> A i = set0) -> P I D A) ->
(forall ( : pointedType) , finite_set D -> P I D A ->
P nat `I_#|` fset_set D| (A \o nth point (fset_set D))) ->
covered_by (@finite_set) P =
[set : set T | exists , [/\ P nat `I_n A & X = \bigcup_( < n) A i]].
Proof.
by move=> [n [A [Am ->]]]; exists nat, `I_n, A; split.
case; elim/Ppointed=> I [D [A [Dfin Am ->]]].
exists 0%N, (fun=> set0); split; first by rewrite II0; apply: P0.
by rewrite //= emptyE II0 !bigcup0.
exists #|`fset_set D|, (A \o nth point (fset_set D)).
split; first exact: Pc.
by rewrite -bigsetU_fset_set// (big_nth point) big_mkord bigcup_mkord.
Qed.
Lemma
(forall ( : set I) , (forall , D i -> A i = set0) -> P I D A) ->
(forall ( : choiceType) ( : set I) ( : I -> set T) ( : nat -> I),
set_surj [set: nat] D f ->
P I D A -> P nat [set: nat] (A \o f)) ->
covered_by (@countable) P =
[set : set T | exists , [/\ P nat [set: nat] A & X = \bigcup_ A i]].
Proof.
by move=> [A [Am ->]]; exists nat, [set: nat], A; split.
case; elim/Ppointed=> I [D [A [Dcnt Am ->]]].
exists (fun=> set0); split; first exact: P0.
by rewrite emptyE bigcup_set0 bigcup0.
have /pfcard_geP[->|[f]] := Dcnt.
exists (fun=> set0); split; first exact: P0.
by rewrite !bigcup_set0 bigcup0.
pose g := [splitsurjfun of split f].
exists (A \o g); split=> /=; first exact: Pc Am.
apply/predeqP=> x; split=> [[i Di Aix]|[n _ Afnx]].
by exists (g^-1%FUN i) => //=; rewrite invK// inE.
by exists (g n) => //; apply: funS.
Qed.
End covering.
Lemma
- mathcomp.analysis.measure_theory.measure_extension
Source code
( : T1 -> T2 -> set T) ( : T1 * T2) :
measurable (G x.1 x.2) <-> measurable (uncurry G x).
Proof.
Definition
lambda_system : forall {T : Type}, set T -> set (set T) -> Prop lambda_system is not universe polymorphic Arguments lambda_system {T}%type_scope (D G)%classical_set_scope lambda_system is transparent Expands to: Constant mathcomp.analysis.measure_theory.measurable_structure.lambda_system Declared in library mathcomp.analysis.measure_theory.measurable_structure, line 219, characters 11-24
Used by
- mathcomp.analysis.measure_theory.measurable_function
Source code
( : semiRingOfSetsType d1) ( : semiRingOfSetsType d2) ( : Type)
( : T -> T1) ( : T -> T2) :=
<<s preimage_set_system setT f1 measurable `|`
preimage_set_system setT f2 measurable >>.
#[deprecated(since="mathcomp-analysis 1.9.0",
note="renamed to `g_sigma_preimageU`")]
Notation
Section product_lemma.
Context ( : semiRingOfSetsType d1) ( : semiRingOfSetsType d2).
Variables ( : pointedType) ( : T -> T1) ( : T -> T2).
Variables ( : Type) ( : T3 -> T).
Lemma
- mathcomp.analysis.measure_theory.measurable_function
Source code
preimage_set_system setT g (g_sigma_preimageU f1 f2).
Proof.
rewrite predeqE => C; split.
- move=> [[A mA <-{C}]|[A mA <-{C}]].
+ by exists (f1 @^-1` A) => //; left; exists A => //; rewrite setTI.
+ by exists (f2 @^-1` A) => //; right; exists A => //; rewrite setTI.
- move=> [A [[B mB <-{A} <-{C}]|[B mB <-{A} <-{C}]]].
+ by left; rewrite !setTI; exists B => //; rewrite setTI.
+ by right; rewrite !setTI; exists B => //; rewrite setTI.
Qed.
End product_lemma.
#[deprecated(since="mathcomp-analysis 1.9.0",
note="renamed to `g_sigma_preimageU_comp`")]
Notation
Definition
monotone : forall {T : Type}, set (set T) -> Prop monotone is not universe polymorphic Arguments monotone {T}%type_scope G%classical_set_scope monotone is transparent Expands to: Constant mathcomp.analysis.measure_theory.measurable_structure.monotone Declared in library mathcomp.analysis.measure_theory.measurable_structure, line 222, characters 11-19
Used by
- mathcomp.analysis.kernel
Source code
(measure_display * measure_display) -> measure_display.
Proof.
Section product_salgebra_instance.
Context ( : semiRingOfSetsType d1) ( : semiRingOfSetsType d2).
Let := @fst T1 T2.
Let := @snd T1 T2.
Let
Proof.
Let
g_sigma_preimageU f1 f2 (~` A).
Proof.
Let
(forall , g_sigma_preimageU f1 f2 (F i)) ->
g_sigma_preimageU f1 f2 (\bigcup_ (F i)).
Proof.
.
.
(T1 * T2)%type (g_sigma_preimageU f1 f2)
(prod_salgebra_set0) (prod_salgebra_setC) (prod_salgebra_bigcup).
End product_salgebra_instance.
Notation
Notation
- mathcomp.analysis.kernel
Source code
((p.-prod).-measurable : set (set (_ * _))) :
classical_set_scope.
Lemma
- mathcomp.analysis.kernel
- mathcomp.analysis.lebesgue_integral_theory.lebesgue_integral_fubini
Source code
( : set T1) ( : set T2) :
measurable A -> measurable B -> measurable (A `*` B).
Proof.
have -> : A `*` B = (A `*` setT) `&` (setT `*` B) :> set (T1 * T2).
by rewrite -{1}(setIT A) -{1}(setTI B) setXI.
rewrite setXT setTX; apply: measurableI.
- by apply: sub_sigma_algebra; left; exists A => //; rewrite setTI.
- by apply: sub_sigma_algebra; right; exists B => //; rewrite setTI.
Qed.
Section product_salgebra_algebraOfSetsType.
Context ( : algebraOfSetsType d1) ( : algebraOfSetsType d2).
Let := @measurable _ T1.
Let := @measurable _ T2.
Let
Lemma
- mathcomp.analysis.kernel
- mathcomp.analysis.lebesgue_integral_theory.lebesgue_integral_fubini
- mathcomp.analysis.lebesgue_integral_theory.giry
Source code
(d1, d2).-prod.-measurable = <<s M1xM2 >>.
Proof.
apply: smallest_sub; first exact: smallest_sigma_algebra.
rewrite subUset; split.
- have /subset_trans : preimage_set_system setT fst M1 `<=` M1xM2.
by move=> _ [X MX <-]; exists X=> //; exists setT; rewrite /M2 // setIC//.
by apply; exact: sub_sigma_algebra.
- have /subset_trans : preimage_set_system setT snd M2 `<=` M1xM2.
by move=> _ [Y MY <-]; exists setT; rewrite /M1 //; exists Y.
by apply; exact: sub_sigma_algebra.
apply: smallest_sub; first exact: smallest_sigma_algebra.
by move=> _ [A ?] [B ?] <-; apply: measurableX => //; exact: sub_sigma_algebra.
Qed.
End product_salgebra_algebraOfSetsType.
Section product_salgebra_g_measurableTypeR.
Context ( : algebraOfSetsType d1) ( : pointedType) ( : set (set T2)).
Hypothesis
Lemma
@measurable _ (T1 * g_sigma_algebraType C2)%type
= <<s [set A `*` B | in measurable & in C2] >>.
Proof.
rewrite predeqE => X; split=> [[A mA] [B mB] <-{X}|[A C1A] [B C2B] <-{X}].
by exists A => //; exists B => //; exact: setTC2.
by exists A => //; exists B => //; exact: sub_sigma_algebra.
Qed.
End product_salgebra_g_measurableTypeR.
Section product_salgebra_g_measurableType.
Variables ( : pointedType) ( : set (set T1)) ( : set (set T2)).
Hypotheses (
Lemma
@measurable _ (g_sigma_algebraType C1 * g_sigma_algebraType C2)%type =
<<s [set A `*` B | in C1 & in C2] >>.
Proof.
rewrite predeqE => X; split=> [[A mA] [B mB] <-{X}|[A C1A] [B C2B] <-{X}].
by exists A; [exact: setTC1|exists B => //; exact: setTC2].
by exists A; [exact: sub_sigma_algebra|exists B => //; exact: sub_sigma_algebra].
Qed.
End product_salgebra_g_measurableType.
Definition
strace : forall [T : Type], set (set T) -> set T -> set (set T) strace is not universe polymorphic Arguments strace [T]%type_scope (G D)%classical_set_scope _ strace is transparent Expands to: Constant mathcomp.analysis.measure_theory.measurable_structure.strace Declared in library mathcomp.analysis.measure_theory.measurable_structure, line 739, characters 11-17
Used by
- mathcomp.analysis.measure_theory.measurable_function
Source code
( : nat) ( : 'I_n -> aT -> rT) : set (set aT) :=
<<s \big[setU/set0]_( < n) preimage_set_system setT (f i) measurable >>.
Lemma
- mathcomp.analysis.measure_theory.measurable_function
Source code
{ : pointedType} ( : 'I_n -> T -> T1) { : Type} ( : T2 -> T) :
g_sigma_preimage (fun => f i \o g) =
preimage_set_system [set: T2] g (g_sigma_preimage f).
Proof.
case: n => [|n] in f *; first by rewrite !big_ord0 preimage_set_system0.
rewrite predeqE => B; split.
- rewrite -bigcup_mkord_ord => -[i Ii [A mA <-{B}]].
have iE : Ordinal Ii = inord i by apply/val_inj => /=; rewrite inordK.
exists (f (inord i) @^-1` A) => //.
rewrite -bigcup_mkord_ord; exists i => //.
by exists A => //; rewrite -iE setTI.
- move=> [C].
rewrite -bigcup_mkord_ord => -[i Ii [A mA <-{C}]] <-{B}.
rewrite -bigcup_mkord_ord; exists i => //.
by exists A => //; rewrite !setTI -comp_preimage.
Qed.
Definition
discrete_measurable : forall {T : Type}, set (set T) discrete_measurable is not universe polymorphic Arguments discrete_measurable {T}%type_scope _ discrete_measurable is transparent Expands to: Constant mathcomp.analysis.measure_theory.measurable_structure.discrete_measurable Declared in library mathcomp.analysis.measure_theory.measurable_structure, line 1252, characters 11-30
Source code
Proof.
Section measurable_tuple.
Context {} { : sigmaRingType d}.
Variable : nat.
Let
Let
Proof.
Let
Proof.
Let
g_sigma_preimage coors (\bigcup_ (F i)).
Proof.
.
(n.-tuple T) (g_sigma_preimage coors) tuple_set0 tuple_setC tuple_bigcup.
End measurable_tuple.