File size: 5,950 Bytes
2fca478
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
import OAI.Geometry.PinnedDistances.EmpiricalCompactness

namespace OAI

universe u1 u2 u3 u4 u5 u6 u7

section
noncomputable section
open MeasureTheory Filter
open scoped BigOperators Topology ENNReal
namespace WeakPinned.Bounded

variable {I : Type u1} {V : Type u2} {X : Type u3} {Y : Type u4} [Fintype I] [Fintype V]
  [MeasurableSpace X] [MeasurableSpace Y]

lemma finiteLaw_fst (w : I → ℝ) (p : I → V → ℝ) (U : I → X)
    (hw : ∀ i,0≤w i) (hp : ∀ i x,0≤p i x) (hpsum : ∀ i,∑ x,p i x=1) :
    finiteLaw (edgeWeight w p) (fun r => U r.1)=finiteLaw w U := by
  unfold finiteLaw edgeWeight
  rw [Fintype.sum_prod_type]
  apply Finset.sum_congr rfl
  intro i _
  dsimp only
  rw [← Finset.sum_smul,← ENNReal.ofReal_sum_of_nonneg (fun x _ => mul_nonneg (hw i) (hp i x)),
    ← Finset.mul_sum,hpsum,mul_one]

lemma tripleLaw_edge (w : I → ℝ) (p : I → V → ℝ) (U : I × V → X)
    (hw : ∀ i,0≤w i) (hp : ∀ i x,0≤p i x) (hpsum : ∀ i,∑ x,p i x=1) :
    finiteLaw (tripleWeight w p) (fun r => U (r.1,r.2.1))=finiteLaw (edgeWeight w p) U := by
  unfold finiteLaw tripleWeight edgeWeight
  simp only [Fintype.sum_prod_type]
  apply Finset.sum_congr rfl
  intro i _
  apply Finset.sum_congr rfl
  intro x _
  rw [show (∑ z,∑ t, ENNReal.ofReal (w i*p i x*p i z*p i t) • Measure.dirac (U (i,x))) =
    ∑ z,ENNReal.ofReal (w i*p i x*p i z) • Measure.dirac (U (i,x)) by
      apply Finset.sum_congr rfl
      intro z _
      rw [← Finset.sum_smul,← ENNReal.ofReal_sum_of_nonneg (fun t _ => mul_nonneg (mul_nonneg (mul_nonneg (hw i) (hp i x)) (hp i z)) (hp i t)),
        ← Finset.mul_sum,hpsum,mul_one]]
  rw [← Finset.sum_smul,← ENNReal.ofReal_sum_of_nonneg (fun z _ => mul_nonneg (mul_nonneg (hw i) (hp i x)) (hp i z)),
    ← Finset.mul_sum,hpsum,mul_one]

lemma finiteLaw_mono (w v : I → ℝ) (U : I → X) (hle : ∀ i,w i≤v i) :
    finiteLaw w U≤finiteLaw v U := by
  apply Measure.le_iff.mpr
  intro s hs
  simp only [finiteLaw,Measure.finsetSum_apply,Measure.smul_apply,smul_eq_mul]
  apply Finset.sum_le_sum
  intro i _
  gcongr
  exact hle i

lemma finiteLaw_prod (w : I → ℝ) (v : V → ℝ) (U : I → X) (W : V → Y)
    (hw : ∀ i,0≤w i) :
    (finiteLaw w U).prod (finiteLaw v W)=
      finiteLaw (fun r : I × V => w r.1*v r.2) (fun r => (U r.1,W r.2)) := by
  simp only [finiteLaw,← Measure.sum_fintype,Measure.prod_sum,
    Measure.prod_smul_left,Measure.prod_smul_right,Measure.dirac_prod_dirac,
    smul_smul,ENNReal.ofReal_mul (hw _),mul_comm]

lemma finiteLaw_smul (w : I → ℝ) (U : I → X) (c : ℝ) (hc : 0≤c) :
    finiteLaw (fun i => c*w i) U=ENNReal.ofReal c •finiteLaw w U := by
  simp only [finiteLaw,ENNReal.ofReal_mul hc,Finset.smul_sum,smul_smul]

end WeakPinned.Bounded

end
end
section
noncomputable section
open MeasureTheory Filter
open scoped BigOperators Topology ENNReal
namespace WeakPinned.Bounded
open Variance
variable {V : Type u5} {I : Type u6} {X : Type u7} [Fintype V] [DecidableEq V] [Fintype I]
  [MeasurableSpace X] [MeasurableSingletonClass X]
  [TopologicalSpace X] [BorelSpace X] [HasOuterApproxClosed X]
variable (G : Core.Fibers V I)

lemma graph_edge_eval (F : V → V → ℝ) :
    (∑ e,G.fiberWeight e*∑ y,prob (G.targets e) y*F (G.source e) y)=
      ∑ x,∑ y,G.edgeLaw x y*F x y := by
  rw [← G.incoming_eval]
  simp only [Finset.mul_sum,← mul_assoc,G.sampling_conditional]
  exact Finset.sum_comm

lemma graph_edge_law (U : V → V → X) (hG : 0<G.edgeCount)
    (hB : ∀ e,(G.targets e).Nonempty) :
    finiteLaw (edgeWeight G.fiberWeight (fun e => prob (G.targets e)))
      (fun r => U (G.source r.1) r.2)=
    finiteLaw (fun r : V × V => G.edgeLaw r.1 r.2) (fun r => U r.1 r.2) := by
  have hw (r : I × V) : 0≤edgeWeight G.fiberWeight (fun e => prob (G.targets e)) r :=
    mul_nonneg (G.fiberWeight_nonneg _) (Core.Fibers.prob_nn _ _)
  let : IsProbabilityMeasure (finiteLaw (edgeWeight G.fiberWeight (fun e => prob (G.targets e)))
      (fun r => U (G.source r.1) r.2)) := finiteLaw_probability _ _ hw
        (sum_edgeWeight _ _ (G.sum_fiberWeight hG) (fun e => sum_prob _ (hB e)))
  let : IsProbabilityMeasure (finiteLaw (fun r : V × V => G.edgeLaw r.1 r.2) (fun r => U r.1 r.2)) :=
    finiteLaw_probability _ _ (fun r => G.edgeLaw_nonneg _ _)
      (by simpa only [Fintype.sum_prod_type] using G.sum_edgeLaw hG)
  apply ext_of_forall_integral_eq_of_IsFiniteMeasure
  intro f
  rw [integral_finiteLaw _ _ hw,integral_finiteLaw _ _ (fun r => G.edgeLaw_nonneg _ _)]
  simp only [edgeWeight,Fintype.sum_prod_type,mul_assoc,← Finset.mul_sum]
  exact graph_edge_eval G (fun x y => f (U x y))

omit G in
lemma pairProb_le_uniform (hn : 2≤Fintype.card V) (x y : V) :
    pairProb Finset.univ x y≤2*(Fintype.card V:ℝ)⁻¹*(Fintype.card V:ℝ)⁻¹ := by
  have hnR : (2:ℝ)≤Fintype.card V := by exact_mod_cast hn
  have hn0 : (0:ℝ)<Fintype.card V := by linarith
  simp only [pairProb,Finset.mem_univ,true_and,Finset.card_univ]
  split_ifs
  · field_simp
    apply (div_le_iff₀ (by linarith : 0<(Fintype.card V:ℝ)-1)).mpr
    nlinarith
  · positivity

omit [Fintype I] [MeasurableSingletonClass X] [TopologicalSpace X] [BorelSpace X] [HasOuterApproxClosed X] in
lemma graph_domination (U : V → X) (hn : 2≤Fintype.card V) (M : ℝ) (hM : 0≤M)
    (hdom : ∀ x y,G.edgeLaw x y≤M*pairProb Finset.univ x y) :
    finiteLaw (fun r : V × V => G.edgeLaw r.1 r.2) (fun r => (U r.1,U r.2))≤
      ENNReal.ofReal (2*M) • (uniformLaw U).prod (uniformLaw U) := by
  rw [uniformLaw,finiteLaw_prod _ _ _ _ (fun _ => by positivity),← finiteLaw_smul _ _ _ (by positivity)]
  apply finiteLaw_mono
  intro r
  calc
    _ ≤ M*pairProb Finset.univ r.1 r.2 := hdom _ _
    _ ≤ M*(2*(Fintype.card V:ℝ)⁻¹*(Fintype.card V:ℝ)⁻¹) :=
      mul_le_mul_of_nonneg_left (pairProb_le_uniform hn _ _) hM
    _ = _ := by ring

end WeakPinned.Bounded

end
end

end OAI