File size: 6,204 Bytes
f61e547 | 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 141 142 143 144 145 146 147 148 149 150 151 152 | import OAI.Probability.FirstPassage.BKForcing
import OAI.Probability.FirstPassage.LocalizedEvents
import Mathlib.Analysis.SpecialFunctions.Log.Monotone
import Mathlib.Tactic.Positivity
namespace OAI
namespace PlanarFPP
open Finset
structure StrictPathWitness where
start : Vertex
steps : List Step
bound : ℝ
namespace StrictPathWitness
def edges (p : StrictPathWitness) : Finset Edge := pathEdges p.start p.steps
def bits (p : StrictPathWitness) (t : ℕ) : Finset (Edge × Fin t) := p.edges ×ˢ univ
end StrictPathWitness
noncomputable def dyadicSurvival (t : ℕ) (x : Finset (Edge × Fin t)) (e : Edge) : ℝ :=
∑ h : Fin t, if (e,h) ∈ x then 1/(2:ℝ)^(h.val+1) else 0
lemma dyadicSurvival_nonneg (t : ℕ) (x : Finset (Edge × Fin t)) (e : Edge) :
0 ≤ dyadicSurvival t x e := by
apply Finset.sum_nonneg
intro h _
split_ifs <;> positivity
lemma dyadicSurvival_mono (t : ℕ) {x y : Finset (Edge × Fin t)} (hxy : x ⊆ y) (e : Edge) :
dyadicSurvival t x e ≤ dyadicSurvival t y e := by
apply Finset.sum_le_sum
intro h _
by_cases hx : (e,h) ∈ x
· simp [hx,hxy hx]
· simp only [hx,↓reduceIte]
split_ifs <;> positivity
lemma dyadicSurvival_eq (t : ℕ) (x y : Finset (Edge × Fin t)) (e : Edge)
(h : ∀ a : Fin t, (e,a) ∈ x ↔ (e,a) ∈ y) :
dyadicSurvival t x e = dyadicSurvival t y e := by
apply Finset.sum_congr rfl
intro a _
simp only [h a]
lemma pathCost_le_of_edges {w v : Edge → ℝ} (p : Vertex) (ds : List Step)
(h : ∀ e ∈ pathEdges p ds, w e ≤ v e) : pathCost w p ds ≤ pathCost v p ds := by
induction ds generalizing p with
| nil => exact le_rfl
| cons d ds ih =>
exact add_le_add (h _ (by simp [pathEdges]))
(ih _ (fun e he => h e (by simp [pathEdges,he])))
def DyadicPathGood (t : ℕ) (x : Finset (Edge × Fin t)) (p : StrictPathWitness) : Prop :=
(∀ e ∈ p.edges, 0 < dyadicSurvival t x e) ∧
pathCost (fun e => -Real.log (dyadicSurvival t x e)) p.start p.steps < p.bound
lemma DyadicPathGood.mono {t : ℕ} {x y : Finset (Edge × Fin t)} {p : StrictPathWitness}
(h : DyadicPathGood t x p) (hxy : x ⊆ y) : DyadicPathGood t y p := by
constructor
· intro e he
exact (h.1 e he).trans_le (dyadicSurvival_mono t hxy e)
· apply lt_of_le_of_lt (pathCost_le_of_edges p.start p.steps ?_) h.2
intro e he
exact neg_le_neg (Real.log_le_log (h.1 e he) (dyadicSurvival_mono t hxy e))
lemma DyadicPathGood.of_agree {t : ℕ} {x y : Finset (Edge × Fin t)} {p : StrictPathWitness}
(h : DyadicPathGood t x p)
(hxy : ∀ a ∈ p.bits t, a ∈ y ↔ a ∈ x) : DyadicPathGood t y p := by
have heq : ∀ e ∈ p.edges, dyadicSurvival t y e = dyadicSurvival t x e := by
intro e he
apply dyadicSurvival_eq
intro a
exact hxy (e,a) (by simp [StrictPathWitness.bits,he])
constructor
· intro e he; rw [heq e he]; exact h.1 e he
· have hc := pathCost_eq_of_agree
(fun e => -Real.log (dyadicSurvival t y e))
(fun e => -Real.log (dyadicSurvival t x e)) p.start p.steps
(fun e he => congrArg (fun a => -Real.log a) (heq e he))
rw [hc]; exact h.2
noncomputable def dyadicPathFamily (S : Finset Edge) (t : ℕ) (F : Set StrictPathWitness) :
Finset (Finset (Edge × Fin t)) := by
classical
exact (S ×ˢ (univ : Finset (Fin t))).powerset.filter
(fun x => ∃ p ∈ F, p.edges ⊆ S ∧ DyadicPathGood t x p)
lemma mem_dyadicPathFamily (S : Finset Edge) (t : ℕ) (F : Set StrictPathWitness)
(x : Finset (Edge × Fin t)) :
x ∈ dyadicPathFamily S t F ↔ x ⊆ S ×ˢ univ ∧
∃ p ∈ F, p.edges ⊆ S ∧ DyadicPathGood t x p := by
classical
simp [dyadicPathFamily]
lemma upward_dyadicPathFamily (S : Finset Edge) (t : ℕ) (F : Set StrictPathWitness) :
UpwardFamily (S ×ˢ univ) (dyadicPathFamily S t F) := by
constructor
· intro x hx; exact ((mem_dyadicPathFamily ..).mp hx).1
· intro x hx y hxy hys
obtain ⟨_,p,hp,he,hgood⟩ := (mem_dyadicPathFamily ..).mp hx
exact (mem_dyadicPathFamily ..).mpr ⟨hys,p,hp,he,hgood.mono hxy⟩
lemma dyadic_path_forces (S : Finset Edge) (t : ℕ) (F : Set StrictPathWitness)
(x : Finset (Edge × Fin t)) (p : StrictPathWitness)
(hp : p ∈ F) (he : p.edges ⊆ S) (hgood : DyadicPathGood t x p) :
ForcesBits (S ×ˢ univ) (dyadicPathFamily S t F) x (p.bits t) := by
intro y hys hxy
exact (mem_dyadicPathFamily ..).mpr ⟨hys,p,hp,he,hgood.of_agree hxy⟩
lemma StrictPathWitness.disjoint_bits {p q : StrictPathWitness} (t : ℕ)
(h : Disjoint p.edges q.edges) : Disjoint (p.bits t) (q.bits t) := by
apply Finset.disjoint_left.mpr
intro a hp hq
exact Finset.disjoint_left.mp h (Finset.mem_product.mp hp).1 (Finset.mem_product.mp hq).1
noncomputable def dyadicDisjointPathFamily (S : Finset Edge) (t : ℕ)
(Fs : List (Set StrictPathWitness)) : Finset (Finset (Edge × Fin t)) := by
classical
exact (S ×ˢ (univ : Finset (Fin t))).powerset.filter (fun x =>
∃ ps : List StrictPathWitness,
List.Forall₂ (fun p F => p ∈ F ∧ p.edges ⊆ S ∧ DyadicPathGood t x p) ps Fs ∧
ps.Pairwise (fun p q => Disjoint p.edges q.edges))
theorem dyadic_strict_path_BK (S : Finset Edge) (t : ℕ) (Fs : List (Set StrictPathWitness)) :
fairFamilyMass (S ×ˢ univ) (dyadicDisjointPathFamily S t Fs) ≤
(Fs.map (fun F => fairFamilyMass (S ×ˢ univ) (dyadicPathFamily S t F))).prod := by
apply (finite_fair_BK_forcing (S ×ˢ univ) (Fs.map (dyadicPathFamily S t))
(dyadicDisjointPathFamily S t Fs) ?_ ?_).trans_eq
(by simp only [List.map_map,Function.comp_def])
· intro A hA
obtain ⟨F,_,rfl⟩ := List.mem_map.mp hA
exact upward_dyadicPathFamily S t F
· intro x hx
simp only [dyadicDisjointPathFamily,mem_filter,mem_powerset] at hx
obtain ⟨hxs,ps,hps,hd⟩ := hx
refine ⟨hxs,ps.map (fun p => p.bits t),?_,?_⟩
· clear hd
induction hps with
| nil => exact List.Forall₂.nil
| cons h ht ih =>
exact List.Forall₂.cons (dyadic_path_forces S t _ x _ h.1 h.2.1 h.2.2) ih
· rw [List.pairwise_map]
exact hd.imp (fun h => StrictPathWitness.disjoint_bits t h)
end PlanarFPP
end OAI
|