| import OAI.Geometry.PinnedDistances.TreeTransport |
|
|
| namespace OAI |
|
|
| universe u1 u2 u3 u4 u5 u6 u7 u8 u9 |
|
|
| section |
| noncomputable section |
| open NumberField |
| open scoped BigOperators |
| noncomputable section |
| open MeasureTheory |
| open scoped Topology |
| noncomputable section |
| open MeasureTheory |
| open scoped Topology ENNReal |
| noncomputable section |
| open MeasureTheory NumberField |
| open scoped BigOperators |
| noncomputable section |
| open scoped BigOperators |
| open MeasureTheory |
| noncomputable section |
| open Filter |
| open scoped Topology |
| noncomputable section |
| open scoped BigOperators |
| noncomputable section |
| open Filter |
| open scoped Topology |
| noncomputable section |
| open MeasureTheory |
| open scoped BigOperators |
| noncomputable section |
| noncomputable section |
| open scoped BigOperators |
|
|
| namespace WeakPinned.Hierarchy.Depth |
| open MeasureTheory |
| variable {P : Type u1} [Fintype P] [DecidableEq P] |
| variable (d : Depth P) |
|
|
| def allCuts : Finset (Finset P) := by |
| classical |
| exact Finset.univ.filter (fun C => ∃ r : ℝ, C ∈ d.cells r) |
|
|
| lemma mem_allCuts (C : Finset P) : C ∈ d.allCuts ↔ ∃ r : ℝ, C ∈ d.cells r := by |
| classical |
| simp [allCuts] |
|
|
| lemma cells_subset_allCuts (r : ℝ) : d.cells r ⊆ d.allCuts := |
| fun C hC => (d.mem_allCuts C).mpr ⟨r,hC⟩ |
|
|
| lemma allCuts_laminar : Cuts.Laminar d.allCuts := by |
| intro C hC B hB |
| obtain ⟨r,hr⟩ := (d.mem_allCuts C).mp hC |
| obtain ⟨t,ht⟩ := (d.mem_allCuts B).mp hB |
| by_cases hi : Disjoint C B |
| · exact Or.inr (Or.inr hi) |
| · obtain ⟨x,hxC,hxB⟩ := Finset.not_disjoint_iff.mp hi |
| rw [d.cell_of_mem hr hxC,d.cell_of_mem ht hxB] |
| rcases le_total t r with h | h |
| · exact Or.inl (d.cell_mono h x) |
| · exact Or.inr (Or.inl (d.cell_mono h x)) |
|
|
| def cutAt (f : Finset P → ℝ) (C : Finset P) (r : ℝ) : ℝ := |
| if C ∈ d.cells r then f C else 0 |
|
|
| def cutLength (f : Finset P → ℝ) (C : Finset P) : ℝ := ∫ r, d.cutAt f C r |
|
|
| lemma measurable_cutAt (f : Finset P → ℝ) (C : Finset P) : Measurable (d.cutAt f C) := |
| (measurable_of_finite (fun s : Finset (Finset P) => if C ∈ s then f C else 0)).comp d.measurable_cells |
|
|
| lemma cutAt_bound (f : Finset P → ℝ) (C : Finset P) (r : ℝ) : ‖d.cutAt f C r‖ ≤ |f C| := by |
| unfold cutAt |
| split_ifs <;> simp [Real.norm_eq_abs,abs_nonneg] |
| |
| lemma cutAt_vanish (f : Finset P → ℝ) (hfu : f Finset.univ=0) |
| (hfs : ∀ x, f {x}=0) (C : Finset P) (r : ℝ) (hr : r ∉ Set.Icc (-d.radius) d.radius) : |
| d.cutAt f C r=0 := by |
| unfold cutAt |
| split_ifs with hc |
| · obtain ⟨x,rfl⟩ := (d.mem_cells r C).mp hc |
| rcases not_and_or.mp hr with hlo | hhi |
| · rw [d.cell_of_low (le_of_lt (lt_of_not_ge hlo)),hfu] |
| · rw [d.cell_of_high (lt_of_not_ge hhi),hfs] |
| · rfl |
|
|
| lemma integrable_cutAt (f : Finset P → ℝ) (hfu : f Finset.univ=0) |
| (hfs : ∀ x, f {x}=0) (C : Finset P) : Integrable (d.cutAt f C) := by |
| exact integrable_supported_Icc (d.measurable_cutAt f C) (d.cutAt_bound f C) |
| (d.cutAt_vanish f hfu hfs C) |
|
|
| lemma cutLength_nonneg (f : Finset P → ℝ) (hf : ∀ C, 0 ≤ f C) (C : Finset P) : |
| 0 ≤ d.cutLength f C := by |
| apply integral_nonneg |
| intro r |
| unfold cutAt |
| split_ifs |
| · exact hf C |
| · exact le_rfl |
|
|
| lemma cutLength_eq_zero (f : Finset P → ℝ) (C : Finset P) (hC : f C=0) : |
| d.cutLength f C=0 := by simp [cutLength,cutAt,hC] |
|
|
| lemma cutLength_outside (f : Finset P → ℝ) (C : Finset P) (hC : C ∉ d.allCuts) : |
| d.cutLength f C=0 := by |
| have hh (r : ℝ) : C ∉ d.cells r := fun hc => hC ((d.mem_allCuts C).mpr ⟨r,hc⟩) |
| simp [cutLength,cutAt,hh] |
|
|
| lemma integral_cut_sum (f : Finset P → ℝ) (hfu : f Finset.univ=0) |
| (hfs : ∀ x, f {x}=0) (g : Finset P → ℝ) : |
| (∫ r, ∑ C ∈ d.cells r, f C*g C) = ∑ C ∈ d.allCuts, d.cutLength f C*g C := by |
| have he (r : ℝ) : (∑ C ∈ d.cells r, f C*g C) = |
| ∑ C ∈ d.allCuts, d.cutAt f C r*g C := by |
| simp only [cutAt,ite_mul,zero_mul,← Finset.sum_filter] |
| congr 1 |
| ext C |
| simp only [Finset.mem_filter] |
| exact ⟨fun hc => ⟨d.cells_subset_allCuts r hc,hc⟩,fun hc => hc.2⟩ |
| simp only [he] |
| rw [integral_finsetSum _ (fun C _ => (d.integrable_cutAt f hfu hfs C).mul_const (g C))] |
| exact Finset.sum_congr rfl (fun C _ => by rw [integral_mul_const]; rfl) |
| |
| lemma symmetric_integral_cut_sum (hn : 2 ≤ Fintype.card P) (f : Finset P → ℝ) |
| (hfs : ∀ C, C.card ≤ 1 → f C=0) (hsym : ∀ C, f Cᶜ=f C) : |
| (∑ C, d.mass C*f C) = ∑ C ∈ d.allCuts, d.cutLength f C := by |
| have hu : f Finset.univ=0 := by simpa using (hsym ∅).trans (hfs ∅ (by simp)) |
| rw [← d.integral_sumCells hn f hfs] |
| have he (r : ℝ) : d.sumCells f r=∑ C ∈ d.cells r, f C := by |
| simp only [d.sumCells_formula,hsym,sub_self,Finset.sum_const_zero,add_zero] |
| simp only [he] |
| simpa using d.integral_cut_sum f hu (fun x => hfs {x} (by simp)) (fun _ => 1) |
|
|
| lemma cutLength_balanced (p : P → ℝ) (w : ℝ → ℝ) (η : ℝ) |
| (hws : ∀ u, ¬(η ≤ u ∧ η ≤ 1-u) → w u=0) (C : Finset P) |
| (hC : 0 < d.cutLength (fun B => w (Cuts.mass p B)) C) : |
| η ≤ Cuts.mass p C ∧ η ≤ 1-Cuts.mass p C := by |
| by_contra hn |
| have hz := d.cutLength_eq_zero (fun B => w (Cuts.mass p B)) C (hws _ hn) |
| linarith |
|
|
| lemma actual_cut_fluctuation (p : P → ℝ) (hp0 : ∀ x, 0 ≤ p x) (hp : ∑ x, p x=1) |
| (w : ℝ → ℝ) (hw : ∀ u, 0 ≤ w u) (η : ℝ) (hη : 0 ≤ η) |
| (hws : ∀ u, ¬(η ≤ u ∧ η ≤ 1-u) → w u=0) : |
| η^3*(∑ C ∈ d.allCuts, d.cutLength (fun B => w (Cuts.mass p B)) C) ≤ |
| ∑ y, p y*Cuts.doubleMean d.allCuts (d.cutLength (fun B => w (Cuts.mass p B))) p y := by |
| exact Cuts.fluctuation_lower d.allCuts d.allCuts_laminar _ |
| (fun C _ => d.cutLength_nonneg _ (fun C => hw _) C) p hp0 hp η hη |
| (fun C _ hC => d.cutLength_balanced p w η hws C hC) |
|
|
| end WeakPinned.Hierarchy.Depth |
|
|
| namespace WeakPinned.Hierarchy.Depth |
| open MeasureTheory |
| variable {P : Type u2} [Fintype P] [DecidableEq P] |
| variable (d : Depth P) |
|
|
| omit [Fintype P] [DecidableEq P] in |
| lemma value_eq_of_lt (x y z : P) (hxy : x ≠ y) (hyz : y ≠ z) (hxz : x ≠ z) |
| (hlt : d.value x y < d.value y z) : d.value x z=d.value x y := by |
| have h1 := d.ultra x y z hxy hyz hxz |
| rw [min_eq_left (le_of_lt hlt)] at h1 |
| apply le_antisymm _ h1 |
| by_contra! hn |
| have h2 := d.ultra x z y hxz hyz.symm hxy |
| rw [d.symm z y] at h2 |
| exact (lt_min hn hlt).not_ge h2 |
|
|
| def differenceTail (x y : P) (u : ℝ) : Finset P := |
| Finset.univ.filter (fun z => z=y ∨ (z ≠ x ∧ u ≤ d.value y z-d.value x z)) |
|
|
| lemma differenceTail_pos (x y : P) (hxy : x ≠ y) (u : ℝ) (hu : 0 < u) : |
| d.differenceTail x y u=d.cell (d.value x y+u) y := by |
| ext z |
| simp only [differenceTail,Finset.mem_filter,Finset.mem_univ,true_and,mem_cell,share] |
| by_cases hzy : z=y |
| · simp [hzy] |
| by_cases hzx : z=x |
| · subst z |
| have hlt : ¬d.value x y+u ≤ d.value y x := by rw [d.symm y x]; linarith |
| simp [hxy,hxy.symm,hlt] |
| · simp only [hzx,ne_eq,false_or,not_false_eq_true,true_and,eq_comm (a:=y) (b:=z),hzy] |
| constructor |
| · intro h |
| have hlt : d.value x z < d.value z y := by rw [d.symm z y]; linarith |
| have he := d.value_eq_of_lt x z y (Ne.symm hzx) hzy hxy hlt |
| linarith |
| · intro h |
| have hlt : d.value x y < d.value y z := by linarith |
| rw [d.value_eq_of_lt x y z hxy (Ne.symm hzy) (Ne.symm hzx) hlt] |
| linarith |
|
|
| lemma differenceTail_neg_compl (x y : P) (hxy : x ≠ y) (u : ℝ) (hu : u < 0) |
| (hne : ∀ z, u ≠ d.value x y-d.value x z) : |
| (d.differenceTail x y u)ᶜ=d.cell (d.value x y-u) x := by |
| ext z |
| simp only [Finset.mem_compl,differenceTail,Finset.mem_filter,Finset.mem_univ,true_and,mem_cell,share] |
| by_cases hzx : z=x |
| · subst z |
| simp [hxy] |
| by_cases hzy : z=y |
| · subst z |
| have hlt : ¬d.value x y-u ≤ d.value x y := by linarith |
| simp [hxy,hxy.symm,hlt] |
| · simp only [hzy,false_or,ne_eq,not_false_eq_true,true_and,eq_comm (a:=x) (b:=z),hzx,not_le] |
| constructor |
| · intro h |
| have hlt : d.value y z < d.value z x := by rw [d.symm z x]; linarith |
| have he := d.value_eq_of_lt y z x (Ne.symm hzy) hzx hxy.symm hlt |
| rw [d.symm y x] at he |
| linarith |
| · intro h |
| have hlt : d.value y x < d.value x z := by rw [d.symm y x]; linarith |
| have he := d.value_eq_of_lt y x z hxy.symm (Ne.symm hzx) (Ne.symm hzy) hlt |
| rw [d.symm y x] at he |
| have hn := hne z |
| rw [he] |
| rcases lt_or_eq_of_le h with h | h |
| · linarith |
| · exfalso |
| apply hn |
| linarith |
|
|
| lemma mass_compl (p : P → ℝ) (hp : ∑ x, p x=1) (C : Finset P) : |
| Cuts.mass p Cᶜ=1-Cuts.mass p C := by |
| have hh := Finset.sum_add_sum_compl C p |
| simp only [Cuts.mass] |
| rw [hp] at hh |
| linarith |
|
|
| lemma ae_differenceTail_formula (p : P → ℝ) (hp : ∑ x, p x=1) (w : ℝ → ℝ) |
| (hw : ∀ u, w (1-u)=w u) (x y : P) (hxy : x ≠ y) : |
| ∀ᵐ u : ℝ, w (Cuts.mass p (d.differenceTail x y u)) = |
| (if d.value x y < d.value x y+u then w (Cuts.mass p (d.cell (d.value x y+u) y)) else 0)+ |
| (if d.value x y < d.value x y-u then w (Cuts.mass p (d.cell (d.value x y-u) x)) else 0) := by |
| have hn : ∀ᵐ u : ℝ, ∀ z : P, u ≠ d.value x y-d.value x z := |
| ae_all_iff.mpr (fun z => volume.ae_ne _) |
| filter_upwards [hn,volume.ae_ne (0 : ℝ)] with u hne hu |
| rcases lt_or_gt_of_ne hu with hu | hu |
| · have he := d.differenceTail_neg_compl x y hxy u hu hne |
| have hm := mass_compl p hp (d.differenceTail x y u) |
| rw [he] at hm |
| rw [ite_eq_right (by linarith),ite_eq_left (by linarith),zero_add,hm,hw] |
| · rw [d.differenceTail_pos x y hxy u hu,ite_eq_left (by linarith),ite_eq_right (by linarith),add_zero] |
|
|
| end WeakPinned.Hierarchy.Depth |
|
|
| namespace WeakPinned.Hierarchy.Depth |
| open MeasureTheory |
| variable {P : Type u3} [Fintype P] [DecidableEq P] |
| variable (d : Depth P) |
|
|
| def aboveCell (f : Finset P → ℝ) (a : ℝ) (x : P) (r : ℝ) : ℝ := |
| if a < r then f (d.cell r x) else 0 |
|
|
| omit [DecidableEq P] in |
| lemma measurable_aboveCell (f : Finset P → ℝ) (a : ℝ) (x : P) : |
| Measurable (d.aboveCell f a x) := by |
| apply Measurable.ite (measurableSet_lt measurable_const measurable_id) |
| · exact (measurable_of_finite f).comp (d.measurable_cell x) |
| · exact measurable_const |
|
|
| omit [DecidableEq P] in |
| lemma integrable_aboveCell (f : Finset P → ℝ) (hfs : ∀ x, f {x}=0) |
| (a : ℝ) (ha : -d.radius ≤ a) (x : P) : Integrable (d.aboveCell f a x) := by |
| apply integrable_supported_Icc (d.measurable_aboveCell f a x) |
| (C:=∑ C : Finset P, |f C|) (a:= -d.radius) (b:=d.radius) |
| · intro r |
| unfold aboveCell |
| split_ifs |
| · simpa only [Real.norm_eq_abs] using (Finset.single_le_sum (s:=Finset.univ) (f:=fun C : Finset P => |f C|) |
| (fun _ _ => abs_nonneg _) (Finset.mem_univ (d.cell r x))) |
| · simpa using Finset.sum_nonneg (fun C (_ : C ∈ (Finset.univ : Finset (Finset P))) => abs_nonneg (f C)) |
| · intro r hr |
| rcases not_and_or.mp hr with hlo | hhi |
| · have hh : ¬a < r := by have := lt_of_not_ge hlo; linarith |
| simp [aboveCell,hh] |
| · simp [aboveCell,d.cell_of_high (lt_of_not_ge hhi) x,hfs] |
| |
| lemma sum_cut_separation (f : Finset P → ℝ) (r : ℝ) (x y : P) (hxy : x ≠ y) : |
| (∑ C ∈ d.cells r, f C*|Cuts.ind C x-Cuts.ind C y|) = |
| d.aboveCell f (d.value x y) x r+d.aboveCell f (d.value x y) y r := by |
| have hmem (z : P) (C : Finset P) (hC : C ∈ d.cells r) : z ∈ C ↔ C=d.cell r z := |
| ⟨fun hz => d.cell_of_mem hC hz,fun he => by rw [he]; exact d.self_mem_cell r z⟩ |
| by_cases hr : r ≤ d.value x y |
| · have hce : d.cell r x=d.cell r y := d.cell_eq_of_share (Or.inr hr) |
| have hz : ∑ C ∈ d.cells r, f C*|Cuts.ind C x-Cuts.ind C y|=0 := by |
| apply Finset.sum_eq_zero |
| intro C hC |
| have hm : x ∈ C ↔ y ∈ C := by rw [hmem x C hC,hmem y C hC,hce] |
| simp only [Cuts.ind,hm,sub_self,abs_zero,mul_zero] |
| simp [hz,aboveCell,not_lt.mpr hr] |
| · have hlt : d.value x y < r := lt_of_not_ge hr |
| have hns : ¬d.share r x y := by simpa [share,hxy] using hr |
| have he (C : Finset P) (hC : C ∈ d.cells r) : |
| f C*|Cuts.ind C x-Cuts.ind C y| = |
| (if C=d.cell r x then f (d.cell r x) else 0)+ |
| (if C=d.cell r y then f (d.cell r y) else 0) := by |
| by_cases hx : x ∈ C <;> by_cases hy : y ∈ C |
| · have hc := d.cell_of_mem hC hx |
| have hh : d.share r x y := by rwa [hc,d.mem_cell] at hy |
| exact (hns hh).elim |
| · have hc := (hmem x C hC).mp hx |
| have hn : C ≠ d.cell r y := fun h => hy ((hmem y C hC).mpr h) |
| simp only [Cuts.ind,ite_eq_left hx,ite_eq_right hy,sub_zero,abs_one,mul_one,ite_eq_left hc,ite_eq_right hn,add_zero] |
| rw [hc] |
| · have hc := (hmem y C hC).mp hy |
| have hn : C ≠ d.cell r x := fun h => hx ((hmem x C hC).mpr h) |
| simp only [Cuts.ind,ite_eq_right hx,ite_eq_left hy,zero_sub,abs_neg,abs_one,mul_one,ite_eq_left hc,ite_eq_right hn,zero_add] |
| rw [hc] |
| · have hn1 : C ≠ d.cell r x := fun h => hx ((hmem x C hC).mpr h) |
| have hn2 : C ≠ d.cell r y := fun h => hy ((hmem y C hC).mpr h) |
| simp [Cuts.ind,hx,hy,hn1,hn2] |
| rw [Finset.sum_congr rfl he,Finset.sum_add_distrib] |
| simp [d.cell_mem_cells,aboveCell,hlt] |
|
|
| lemma cut_distance_two_integrals (f : Finset P → ℝ) (hfu : f Finset.univ=0) |
| (hfs : ∀ x, f {x}=0) (x y : P) (hxy : x ≠ y) : |
| Cuts.distance d.allCuts (d.cutLength f) x y = |
| (∫ r, d.aboveCell f (d.value x y) x r)+(∫ r, d.aboveCell f (d.value x y) y r) := by |
| rw [Cuts.distance,← d.integral_cut_sum f hfu hfs (fun C => |Cuts.ind C x-Cuts.ind C y|)] |
| simp only [d.sum_cut_separation f _ x y hxy] |
| exact integral_add (d.integrable_aboveCell f hfs _ (abs_le.mp (d.abs_value_le_radius x y)).1 x) |
| (d.integrable_aboveCell f hfs _ (abs_le.mp (d.abs_value_le_radius x y)).1 y) |
|
|
| end WeakPinned.Hierarchy.Depth |
|
|
| namespace WeakPinned.Hierarchy.Depth |
| open MeasureTheory |
| variable {P : Type u4} [Fintype P] [DecidableEq P] |
| variable (d : Depth P) |
|
|
| /-- Exact projection identity, including the formal infinite values at the |
| two endpoints, represented by their tail-set membership. -/ |
| lemma cut_projection (p : P → ℝ) (hp : ∑ x, p x=1) (w : ℝ → ℝ) |
| (hwu : w 1=0) (hws : ∀ x, w (p x)=0) (hwsym : ∀ u, w (1-u)=w u) |
| (x y : P) (hxy : x ≠ y) : |
| Cuts.distance d.allCuts (d.cutLength (fun C => w (Cuts.mass p C))) x y = |
| ∫ u, w (Cuts.mass p (d.differenceTail x y u)) := by |
| let f : Finset P → ℝ := fun C => w (Cuts.mass p C) |
| have hfu : f Finset.univ=0 := by simpa [f,Cuts.mass,hp] using hwu |
| have hfs : ∀ z, f {z}=0 := by intro z; simpa [f,Cuts.mass] using hws z |
| have hi (z : P) := d.integrable_aboveCell f hfs (d.value x y) |
| (abs_le.mp (d.abs_value_le_radius x y)).1 z |
| have hiY : Integrable (fun u => d.aboveCell f (d.value x y) y (d.value x y+u)) := by |
| exact ((measurePreserving_add_left volume (d.value x y)).integrable_comp (hi y).aestronglyMeasurable).mpr (hi y) |
| have hiX : Integrable (fun u => d.aboveCell f (d.value x y) x (d.value x y-u)) := |
| (integrable_comp_sub_left _ _).mpr (hi x) |
| rw [d.cut_distance_two_integrals f hfu hfs x y hxy] |
| have he := integral_congr_ae (d.ae_differenceTail_formula p hp w hwsym x y hxy) |
| change (∫ u, w (Cuts.mass p (d.differenceTail x y u))) = |
| ∫ u, d.aboveCell f (d.value x y) y (d.value x y+u)+d.aboveCell f (d.value x y) x (d.value x y-u) at he |
| rw [he,integral_add hiY hiX,integral_add_left_eq_self,integral_sub_left_eq_self] |
| exact add_comm _ _ |
|
|
| end WeakPinned.Hierarchy.Depth |
|
|
| namespace WeakPinned.Tail |
| open MeasureTheory |
| open scoped NNReal |
| variable {P : Type u5} [Fintype P] |
|
|
| def step (a u : ℝ) : ℝ := if u ≤ a then 1 else 0 |
|
|
| def law (b : ℝ) (p : P → ℝ) (f : P → ℝ) (u : ℝ) : ℝ := b+∑ z, p z*step (f z) u |
|
|
| lemma measurable_step (a : ℝ) : Measurable (step a) := by |
| exact Measurable.ite (measurableSet_le measurable_id measurable_const) measurable_const measurable_const |
|
|
| lemma measurable_law (b : ℝ) (p f : P → ℝ) : Measurable (law b p f) := |
| measurable_const.add (Finset.measurable_sum _ (fun _z _ => measurable_const.mul (measurable_step _))) |
|
|
| lemma step_difference (a b u : ℝ) : |step a u-step b u| = |
| if min a b < u ∧ u ≤ max a b then 1 else 0 := by |
| unfold step |
| rcases le_total a b with h | h |
| · rw [min_eq_left h,max_eq_right h] |
| by_cases hua : u ≤ a |
| · have hub : u ≤ b := hua.trans h |
| simp [hua,hub,not_lt.mpr hua] |
| · have hau : a < u := lt_of_not_ge hua |
| by_cases hub : u ≤ b <;> simp [hua,hub,hau] |
| · rw [min_eq_right h,max_eq_left h] |
| by_cases hub : u ≤ b |
| · have hua : u ≤ a := hub.trans h |
| simp [hua,hub,not_lt.mpr hub] |
| · have hbu : b < u := lt_of_not_ge hub |
| by_cases hua : u ≤ a <;> simp [hua,hub,hbu] |
| |
| lemma step_difference_indicator (a b : ℝ) : (fun u => |step a u-step b u|) = |
| (Set.Ioc (min a b) (max a b)).indicator (fun _ : ℝ => 1) := by |
| funext u |
| simp [step_difference,Set.indicator_apply] |
|
|
| lemma integrable_step_difference (a b : ℝ) : Integrable (fun u => |step a u-step b u|) := by |
| rw [step_difference_indicator,integrable_indicator_iff measurableSet_Ioc] |
| exact integrableOn_const (by rw [Real.volume_Ioc]; exact ENNReal.ofReal_ne_top) |
| |
| lemma integral_step_difference (a b : ℝ) : (∫ u, |step a u-step b u|) = |a-b| := by |
| rw [step_difference_indicator,integral_indicator measurableSet_Ioc] |
| simp only [integral_const,Measure.restrict_apply_univ,smul_eq_mul,mul_one,measureReal_def,Real.volume_Ioc] |
| rw [ENNReal.toReal_ofReal (sub_nonneg.mpr (min_le_max (a:=a) (b:=b)))] |
| rcases le_total a b with hh | hh |
| · simp [max_eq_right hh,min_eq_left hh,abs_of_nonpos (sub_nonpos.mpr hh)] |
| · simp [max_eq_left hh,min_eq_right hh,abs_of_nonneg (sub_nonneg.mpr hh)] |
|
|
| lemma law_difference_bound (b : ℝ) (p f g : P → ℝ) (hp : ∀ z, 0 ≤ p z) (u : ℝ) : |
| |law b p f u-law b p g u| ≤ ∑ z, p z*|step (f z) u-step (g z) u| := by |
| have he : law b p f u-law b p g u=∑ z, p z*(step (f z) u-step (g z) u) := by |
| simp only [law,mul_sub,Finset.sum_sub_distrib] |
| ring |
| rw [he] |
| calc |
| _ ≤ ∑ z, |p z*(step (f z) u-step (g z) u)| := Finset.abs_sum_le_sum_abs _ _ |
| _ = _ := by simp only [abs_mul,abs_of_nonneg (hp _)] |
|
|
| lemma lipschitz_tail_bound (b : ℝ) (p f g : P → ℝ) (hp : ∀ z, 0 ≤ p z) |
| (w : ℝ → ℝ) (Λ : ℝ≥0) (hw : LipschitzWith Λ w) : |
| (∫ u, |w (law b p f u)-w (law b p g u)|) ≤ (Λ:ℝ)*∑ z, p z*|f z-g z| := by |
| let h : ℝ → ℝ := fun u => (Λ:ℝ)*∑ z, p z*|step (f z) u-step (g z) u| |
| have hi : Integrable h := (integrable_finsetSum (s:=Finset.univ) |
| (fun z _ => (integrable_step_difference (f z) (g z)).const_mul (p z))).const_mul _ |
| have hb (u : ℝ) : |w (law b p f u)-w (law b p g u)| ≤ h u := by |
| have hh := hw.norm_sub_le (law b p f u) (law b p g u) |
| simp only [Real.norm_eq_abs] at hh |
| exact hh.trans (mul_le_mul_of_nonneg_left (law_difference_bound b p f g hp u) Λ.coe_nonneg) |
| have hm : Measurable (fun u => |w (law b p f u)-w (law b p g u)|) := |
| ((hw.continuous.measurable.comp (measurable_law b p f)).sub |
| (hw.continuous.measurable.comp (measurable_law b p g))).abs |
| have hi' := hi.mono' hm.aestronglyMeasurable (Filter.Eventually.of_forall (fun u => by |
| simpa only [Real.norm_eq_abs,abs_abs] using hb u)) |
| calc |
| _ ≤ ∫ u, h u := integral_mono hi' hi hb |
| _ = _ := by |
| simp only [h,integral_const_mul] |
| rw [integral_finsetSum _ (fun z _ => (integrable_step_difference (f z) (g z)).const_mul (p z))] |
| simp only [integral_const_mul,integral_step_difference] |
|
|
| end WeakPinned.Tail |
|
|
| namespace WeakPinned.Hierarchy.Depth |
| open MeasureTheory |
| variable {P : Type u6} [Fintype P] [DecidableEq P] |
| variable (d : Depth P) |
|
|
| omit [DecidableEq P] in |
| lemma integrable_cellWeight (f : Finset P → ℝ) (hfu : f Finset.univ=0) |
| (hfs : ∀ x, f {x}=0) (x : P) : Integrable (fun r => f (d.cell r x)) := by |
| apply integrable_supported_Icc ((measurable_of_finite f).comp (d.measurable_cell x)) |
| (C:=∑ C : Finset P, |f C|) (a:= -d.radius) (b:=d.radius) |
| · intro r |
| simpa only [Function.comp_def,Real.norm_eq_abs] using (Finset.single_le_sum (s:=Finset.univ) (f:=fun C : Finset P => |f C|) |
| (fun _ _ => abs_nonneg _) (Finset.mem_univ (d.cell r x))) |
| · intro r hr |
| change f (d.cell r x)=0 |
| rcases not_and_or.mp hr with hlo | hhi |
| · rw [d.cell_of_low (le_of_lt (lt_of_not_ge hlo)),hfu] |
| · rw [d.cell_of_high (lt_of_not_ge hhi),hfs] |
|
|
| lemma cut_root_projection (f : Finset P → ℝ) (hfu : f Finset.univ=0) |
| (hfs : ∀ x, f {x}=0) (y : P) : |
| Cuts.rootDistance d.allCuts (d.cutLength f) y = ∫ r, f (d.cell r y) := by |
| rw [Cuts.rootDistance,← d.integral_cut_sum f hfu hfs (fun C => Cuts.ind C y)] |
| apply integral_congr_ae |
| apply Filter.Eventually.of_forall |
| intro r |
| have he (C : Finset P) (hC : C ∈ d.cells r) : f C*Cuts.ind C y = |
| if C=d.cell r y then f (d.cell r y) else 0 := by |
| by_cases hy : y ∈ C |
| · have hc := d.cell_of_mem hC hy |
| subst C |
| simp [Cuts.ind,d.self_mem_cell] |
| · have hn : C ≠ d.cell r y := fun h => hy (h ▸ d.self_mem_cell r y) |
| simp [Cuts.ind,hy,hn] |
| change (∑ C ∈ d.cells r, f C*Cuts.ind C y)=f (d.cell r y) |
| rw [Finset.sum_congr rfl he] |
| simp [d.cell_mem_cells] |
|
|
| lemma integrable_differenceTail (p : P → ℝ) (hp : ∑ x, p x=1) (w : ℝ → ℝ) |
| (hws : ∀ x, w (p x)=0) (hwsym : ∀ u, w (1-u)=w u) |
| (x y : P) (hxy : x ≠ y) : Integrable (fun u => w (Cuts.mass p (d.differenceTail x y u))) := by |
| let f : Finset P → ℝ := fun C => w (Cuts.mass p C) |
| have hfs : ∀ z, f {z}=0 := by intro z; simpa [f,Cuts.mass] using hws z |
| have hi (z : P) := d.integrable_aboveCell f hfs (d.value x y) |
| (abs_le.mp (d.abs_value_le_radius x y)).1 z |
| have hiY : Integrable (fun u => d.aboveCell f (d.value x y) y (d.value x y+u)) := |
| ((measurePreserving_add_left volume (d.value x y)).integrable_comp (hi y).aestronglyMeasurable).mpr (hi y) |
| have hiX : Integrable (fun u => d.aboveCell f (d.value x y) x (d.value x y-u)) := |
| (integrable_comp_sub_left _ _).mpr (hi x) |
| apply (hiY.add hiX).congr |
| filter_upwards [d.ae_differenceTail_formula p hp w hwsym x y hxy] with u hu |
| exact hu.symm |
|
|
| end WeakPinned.Hierarchy.Depth |
|
|
| namespace WeakPinned.Tail |
| open MeasureTheory Hierarchy |
| open scoped NNReal |
| variable {P : Type u7} [Fintype P] [DecidableEq P] |
|
|
| def offTwo (p : P → ℝ) (x y z : P) : ℝ := if z=x ∨ z=y then 0 else p z |
|
|
| omit [Fintype P] in |
| lemma offTwo_nonneg (p : P → ℝ) (hp : ∀ z, 0 ≤ p z) (x y z : P) : 0 ≤ offTwo p x y z := by |
| unfold offTwo |
| split_ifs <;> simp [hp] |
| |
| lemma mass_as_sum (p : P → ℝ) (C : Finset P) : Cuts.mass p C=∑ z, if z ∈ C then p z else 0 := by |
| simp [Cuts.mass] |
|
|
| lemma differenceTail_law (d : Depth P) (p : P → ℝ) (x y : P) (hxy : x ≠ y) (u : ℝ) : |
| Cuts.mass p (d.differenceTail x y u)= |
| law (p y) (offTwo p x y) (fun z => d.value y z-d.value x z) u := by |
| rw [mass_as_sum] |
| have he (z : P) : (if z ∈ d.differenceTail x y u then p z else 0)= |
| (if z=y then p y else 0)+offTwo p x y z*step (d.value y z-d.value x z) u := by |
| by_cases hy : z=y |
| · subst z; simp [Depth.differenceTail,offTwo] |
| by_cases hx : z=x |
| · subst z; simp [Depth.differenceTail,offTwo,hxy] |
| · simp [Depth.differenceTail,offTwo,step,hx,hy,mul_ite] |
| simp only [he,Finset.sum_add_distrib] |
| simp [law] |
| |
| lemma rootTail_law (d : Depth P) (p : P → ℝ) (x y : P) (hx : p x=0) (hxy : x ≠ y) (c u : ℝ) : |
| Cuts.mass p (d.cell (u-c) y)=law (p y) (offTwo p x y) (fun z => d.value y z+c) u := by |
| rw [mass_as_sum] |
| have he (z : P) : (if z ∈ d.cell (u-c) y then p z else 0)= |
| (if z=y then p y else 0)+offTwo p x y z*step (d.value y z+c) u := by |
| by_cases hy : z=y |
| · subst z; simp [offTwo,d.self_mem_cell] |
| by_cases hz : z=x |
| · subst z; simp [offTwo,hx,hxy] |
| · have hh : u-c ≤ d.value y z ↔ u ≤ d.value y z+c := by constructor <;> intro hh <;> linarith |
| simp [Depth.mem_cell,Depth.share,offTwo,step,hz,hy,Ne.symm hy,hh,mul_ite] |
| simp only [he,Finset.sum_add_distrib] |
| simp [law] |
| |
| /-- Quantitative fiber-tree comparison, before inserting the arithmetic |
| raw-depth equation. The y endpoint is included; x has zero fiber mass. -/ |
| lemma fiber_cut_error (d d' : Depth P) (p : P → ℝ) (hp0 : ∀ z, 0 ≤ p z) (hp : ∑ z, p z=1) |
| (w : ℝ → ℝ) (Λ : ℝ≥0) (hw : LipschitzWith Λ w) |
| (hwu : w 1=0) (hws : ∀ z, w (p z)=0) (hwsym : ∀ u, w (1-u)=w u) |
| (x y : P) (hpx : p x=0) (hxy : x ≠ y) (c : ℝ) : |
| |Cuts.distance d.allCuts (d.cutLength (fun C => w (Cuts.mass p C))) x y- |
| Cuts.rootDistance d'.allCuts (d'.cutLength (fun C => w (Cuts.mass p C))) y| ≤ |
| (Λ:ℝ)*∑ z, offTwo p x y z*|d.value y z-d.value x z-(d'.value y z+c)| := by |
| let f : Finset P → ℝ := fun C => w (Cuts.mass p C) |
| have hfu : f Finset.univ=0 := by simpa [f,Cuts.mass,hp] using hwu |
| have hfs : ∀ z, f {z}=0 := by intro z; simpa [f,Cuts.mass] using hws z |
| let a := law (p y) (offTwo p x y) (fun z => d.value y z-d.value x z) |
| let b := law (p y) (offTwo p x y) (fun z => d'.value y z+c) |
| have hia : Integrable (fun u => w (a u)) := by |
| simpa only [differenceTail_law d p x y hxy] using |
| d.integrable_differenceTail p hp w hws hwsym x y hxy |
| have hib0 := d'.integrable_cellWeight f hfu hfs y |
| have hib : Integrable (fun u => w (b u)) := by |
| have hh := ((measurePreserving_add_right volume (-c)).integrable_comp hib0.aestronglyMeasurable).mpr hib0 |
| simpa only [Function.comp_def,f,← sub_eq_add_neg,rootTail_law d' p x y hpx hxy c] using hh |
| have he : (∫ u, w (b u))=Cuts.rootDistance d'.allCuts (d'.cutLength f) y := by |
| rw [d'.cut_root_projection f hfu hfs y] |
| have hh := integral_add_right_eq_self (μ:=volume) (fun r => f (d'.cell r y)) (-c) |
| simpa only [f,← sub_eq_add_neg,rootTail_law d' p x y hpx hxy c] using hh |
| rw [d.cut_projection p hp w hwu hws hwsym x y hxy,← he] |
| simp only [differenceTail_law d p x y hxy] |
| change |(∫ u, w (a u))-(∫ u, w (b u))| ≤ _ |
| rw [← integral_sub hia hib] |
| calc |
| _ ≤ ∫ u, |w (a u)-w (b u)| := by simpa only [Real.norm_eq_abs] using norm_integral_le_integral_norm (fun u => w (a u)-w (b u)) |
| _ ≤ _ := lipschitz_tail_bound (p y) (offTwo p x y) _ _ (offTwo_nonneg p hp0 x y) w Λ hw |
|
|
| end WeakPinned.Tail |
|
|
| namespace WeakPinned.Arithmetic |
| variable {K : Type u8} [Field K] |
|
|
| lemma paired_log (v : AbsoluteValue K ℝ) (a b c d z w t : K) |
| (hc : c ≠ a) (hz : z ≠ a) (hcz : c ≠ z) (ht : t ≠ 0) |
| (hcd : (c-a)*(d-b)=t) (hzw : (z-a)*(w-b)=t) : |
| -Real.log (v (w-d)) = -Real.log (v (c-z))+Real.log (v (z-a))- |
| Real.log (v t)+Real.log (v (c-a)) := by |
| rw [paired_difference a b c d z w t hc hz hcd hzw, |
| map_div₀,map_mul,map_mul, |
| Real.log_div (mul_ne_zero (v.pos ht).ne' (v.pos (sub_ne_zero.mpr hcz)).ne') |
| (mul_ne_zero (v.pos (sub_ne_zero.mpr hz)).ne' (v.pos (sub_ne_zero.mpr hc)).ne'), |
| Real.log_mul (v.pos ht).ne' (v.pos (sub_ne_zero.mpr hcz)).ne', |
| Real.log_mul (v.pos (sub_ne_zero.mpr hz)).ne' (v.pos (sub_ne_zero.mpr hc)).ne'] |
| ring |
|
|
| lemma absval_sub_symm (v : AbsoluteValue K ℝ) (a b : K) : v (a-b)=v (b-a) := by |
| rw [← neg_sub b a,map_neg_eq_map] |
|
|
| /-- The raw cross-fiber identity at every place. The three points are distinct |
| and the source is outside its fiber. -/ |
| lemma raw_cross_fiber {P : Type u9} (Z₁ Z₂ : P → K) (h₁ : Function.Injective Z₁) |
| (h₂ : Function.Injective Z₂) (v : AbsoluteValue K ℝ) (x y z : P) |
| (hxy : x ≠ y) (hxz : x ≠ z) (hyz : y ≠ z) (t : K) |
| (hy : (Z₁ x-Z₁ y)*(Z₂ x-Z₂ y)=t) |
| (hz : (Z₁ x-Z₁ z)*(Z₂ x-Z₂ z)=t) : |
| -Real.log (v (Z₂ y-Z₂ z)) = -Real.log (v (Z₁ y-Z₁ z))- |
| (-Real.log (v (Z₁ x-Z₁ z)))-Real.log (v t)-(-Real.log (v (Z₁ x-Z₁ y))) := by |
| have ht : t ≠ 0 := by rw [← hy]; exact mul_ne_zero (sub_ne_zero.mpr (h₁.ne hxy)) (sub_ne_zero.mpr (h₂.ne hxy)) |
| have hh := paired_log v (Z₁ x) (Z₂ x) (Z₁ y) (Z₂ y) (Z₁ z) (Z₂ z) t |
| (h₁.ne hxy.symm) (h₁.ne hxz.symm) (h₁.ne hyz) ht |
| (by convert hy using 1; ring) (by convert hz using 1; ring) |
| rw [absval_sub_symm v (Z₂ z) (Z₂ y),absval_sub_symm v (Z₁ z) (Z₁ x), |
| absval_sub_symm v (Z₁ y) (Z₁ x)] at hh |
| linarith |
| end WeakPinned.Arithmetic |
| |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| |
| end OAI |
| |
