File size: 3,791 Bytes
4a56cd6
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
import Mathlib
import OAI.Probability.CriticalPercolation.ProductMeasure.ProductConditioning

namespace OAI

section
section
noncomputable section
open Set Function MeasureTheory ProbabilityTheory
open scoped Classical BigOperators ENNReal

namespace CriticalPercolation.BernoulliProduct
variable {E I : Type*}

lemma block_event_disjoint_forceOn (X Y : Set E) (hXY : Disjoint X Y)
    (A : Set (Set E)) (hA : MeasurableSet[blockSigma Y] A) (Οƒ Ο‰ : Set E) :
    forceOn X Οƒ Ο‰βˆˆA ↔ Ο‰βˆˆA := by
  have he : forceOn Y (forceOn X Οƒ Ο‰) Ο‰=Ο‰ := by
    ext e
    by_cases heY : e∈Y
    Β· have heX : eβˆ‰X := fun h => Set.disjoint_left.mp hXY h heY
      simp only [mem_forceOn,ite_eq_left heY,ite_eq_right heX]
    Β· simp only [mem_forceOn,ite_eq_right heY]
  have hh := block_event_forceOn Y A hA (forceOn X Οƒ Ο‰) Ο‰
  rw [he] at hh
  exact hh.symm

def selectedEvent (d : Set E β†’ I) (A : I β†’ Set (Set E)) : Set (Set E) :=
  {Ο‰ | Ο‰βˆˆA (d Ο‰)}

lemma selectedEvent_eq_iUnion (d : Set E β†’ I) (A : I β†’ Set (Set E)) :
    selectedEvent d A=⋃ i, ({Ο‰ | d Ο‰=i}∩A i) := by
  ext Ο‰
  simp only [selectedEvent,Set.mem_ofPred_eq,Set.mem_iUnion,Set.mem_inter_iff]
  exact ⟨fun h => ⟨d Ο‰,rfl,h⟩,fun ⟨i,hi,h⟩ => hi.symm β–Έ h⟩

lemma measurableSet_selectedEvent [Countable I] (d : Set E β†’ I)
    (A : I β†’ Set (Set E)) (hd : βˆ€ i, MeasurableSet {Ο‰ | d Ο‰=i})
    (hA : βˆ€ i, MeasurableSet (A i)) : MeasurableSet (selectedEvent d A) := by
  rw [selectedEvent_eq_iUnion]
  exact MeasurableSet.iUnion (fun i => (hd i).inter (hA i))

theorem blockProbability_selected (q : E β†’ unitInterval) (X Y : Set E)
    (hXY : Disjoint X Y) (d : Set E β†’ I) (A : I β†’ Set (Set E))
    (hd : βˆ€ i, MeasurableSet[blockSigma X] {Ο‰ | d Ο‰=i})
    (hA : βˆ€ i, MeasurableSet[blockSigma Y] (A i)) (Οƒ : Set E) :
    blockProbability q X (selectedEvent d A) Οƒ=law q (A (d Οƒ)) := by
  unfold blockProbability
  congr 1
  ext Ο‰
  change forceOn X Οƒ Ο‰βˆˆA (d (forceOn X Οƒ Ο‰)) ↔ Ο‰βˆˆA (d Οƒ)
  have hh : d (forceOn X Οƒ Ο‰)=d Οƒ :=
    (block_event_forceOn X {Ο„ | d Ο„=d Οƒ} (hd _) Οƒ Ο‰).mpr rfl
  rw [hh]
  exact block_event_disjoint_forceOn X Y hXY (A (d Οƒ)) (hA _) Οƒ Ο‰

theorem selected_fresh_bound [Countable I] (q : E β†’ unitInterval) (X Y : Set E)
    (hXY : Disjoint X Y) (d : Set E β†’ I) (A : I β†’ Set (Set E))
    (hd : βˆ€ i, MeasurableSet[blockSigma X] {Ο‰ | d Ο‰=i})
    (hA : βˆ€ i, MeasurableSet[blockSigma Y] (A i))
    (C : Set (Set E)) (hC : MeasurableSet[blockSigma X] C)
    (r : ℝ) (hr : 0 ≀ r) (hb : βˆ€ ΟƒβˆˆC, (law q).real (A (d Οƒ)) ≀ r) :
    (law q).real (C∩selectedEvent d A) ≀ r*(law q).real C := by
  have hmA := measurableSet_selectedEvent d A (fun i => blockSigma_le X _ (hd i))
    (fun i => blockSigma_le Y _ (hA i))
  have hk (Οƒ : Set E) (hΟƒ : ΟƒβˆˆC) :
      blockProbability q X (selectedEvent d A) Οƒ ≀ ENNReal.ofReal r := by
    rw [blockProbability_selected q X Y hXY d A hd hA Οƒ]
    apply (ENNReal.toReal_le_toReal (measure_ne_top _ _) ENNReal.ofReal_ne_top).mp
    rw [ENNReal.toReal_ofReal hr]
    exact hb σ hσ
  have hh : law q (selectedEvent d A∩C) ≀ ENNReal.ofReal r*law q C := by
    rw [← setLIntegral_blockProbability q X _ C hmA hC]
    calc
      (∫⁻ Οƒ in C, blockProbability q X (selectedEvent d A) Οƒ βˆ‚law q) ≀
          ∫⁻ _ in C, ENNReal.ofReal r βˆ‚law q :=
        setLIntegral_mono' (blockSigma_le X _ hC) hk
      _ = _ := by rw [lintegral_const,Measure.restrict_apply_univ]
  have ht := ENNReal.toReal_mono (ENNReal.mul_ne_top ENNReal.ofReal_ne_top
    (measure_ne_top _ _)) hh
  simpa only [Set.inter_comm (selectedEvent d A) C,ENNReal.toReal_mul,
    ENNReal.toReal_ofReal hr,Measure.real] using ht

end CriticalPercolation.BernoulliProduct
end
end
end

end OAI