| import OAI.Analysis.DiamondDistortion.DirectEnergy |
|
|
| namespace OAI |
|
|
| universe u v |
|
|
| noncomputable section |
| open scoped BigOperators Classical Topology |
| open Set |
|
|
| namespace DiamondDistortion |
|
|
| open scoped ENNReal |
|
|
| namespace LpCut |
| variable {ι : Type*} {p : ℝ≥0∞} [Fact (1 ≤ p)] |
| def linear (H : ι → Prop) [DecidablePred H] : lp (fun _ : ι => ℝ) p →ₗ[ℝ] lp (fun _ : ι => ℝ) p where |
| toFun v := ⟨fun i => if H i then v i else 0,v.property.mono' (fun i => by split_ifs <;> simp)⟩ |
| map_add' u v := by |
| ext i |
| change (if H i then u i+v i else 0)=(if H i then u i else 0)+(if H i then v i else 0) |
| by_cases h : H i <;> simp [h] |
| map_smul' c v := by ext i; by_cases h : H i <;> simp [h] |
| lemma linear_apply {ι : Type*} {p : ℝ≥0∞} [Fact (1 ≤ p)] (H : ι → Prop) [DecidablePred H] (v : lp (fun _ : ι => ℝ) p) (i : ι) : |
| linear H v i=if H i then v i else 0 := rfl |
| lemma norm_linear (H : ι → Prop) [DecidablePred H] (v : lp (fun _ : ι => ℝ) p) : ‖linear H v‖ ≤ ‖v‖ := by |
| apply lp.norm_mono (ne_of_gt (lt_of_lt_of_le zero_lt_one (Fact.out : 1 ≤ p))) |
| intro i |
| rw [linear_apply] |
| split_ifs <;> simp |
| def continuous (H : ι → Prop) [DecidablePred H] : lp (fun _ : ι => ℝ) p →L[ℝ] lp (fun _ : ι => ℝ) p := |
| (linear H).mkContinuous 1 (fun v => by simpa only [one_mul] using norm_linear H v) |
| lemma continuous_apply (H : ι → Prop) [DecidablePred H] (v : lp (fun _ : ι => ℝ) p) (i : ι) : |
| continuous H v i=if H i then v i else 0 := rfl |
| end LpCut |
|
|
| namespace RecursiveModel |
| lemma ancestors_linear (h : ℕ) {a b c : Coord h} |
| (ha : a ∈ ancestors h c) (hb : b ∈ ancestors h c) : |
| a ∈ ancestors h b ∨ b ∈ ancestors h a := by |
| induction h with |
| | zero => left; exact self_mem_ancestors _ _ |
| | succ h ih => |
| cases c with |
| | inl u => |
| have hak : a=Sum.inl () := by simpa only [ancestors,Finset.mem_singleton] using ha |
| have hbk : b=Sum.inl () := by simpa only [ancestors,Finset.mem_singleton] using hb |
| subst a; subst b |
| exact Or.inl (self_mem_ancestors _ _) |
| | inr q => |
| rcases Finset.mem_insert.mp ha with ha|ha |
| · subst a |
| rcases Finset.mem_insert.mp hb with hb|hb |
| · subst b; exact Or.inl (self_mem_ancestors _ _) |
| · obtain ⟨b',hb',rfl⟩ := Finset.mem_image.mp hb |
| exact Or.inl (Finset.mem_insert_self _ _) |
| · obtain ⟨a',ha',rfl⟩ := Finset.mem_image.mp ha |
| rcases Finset.mem_insert.mp hb with hb|hb |
| · subst b; exact Or.inr (Finset.mem_insert_self _ _) |
| · obtain ⟨b',hb',rfl⟩ := Finset.mem_image.mp hb |
| rcases ih ha' hb' with h|h |
| · exact Or.inl (Finset.mem_insert_of_mem (Finset.mem_image.mpr ⟨a',h,rfl⟩)) |
| · exact Or.inr (Finset.mem_insert_of_mem (Finset.mem_image.mpr ⟨b',h,rfl⟩)) |
|
|
| lemma ancestral_prefix (h : ℕ) (H : Coord h → Prop) [DecidablePred H] |
| (hH : ∀ a b,H b → a ∈ ancestors h b → H a) (s : Coord h) : |
| (ancestors h s).filter H=∅ ∨ ∃ t,(ancestors h s).filter H=ancestors h t := by |
| let S := (ancestors h s).filter H |
| by_cases hn : S.Nonempty |
| · obtain ⟨t,ht,hmax⟩ := Finset.exists_max_image S (fun t => (ancestors h t).card) hn |
| refine Or.inr ⟨t,?_⟩ |
| apply Finset.Subset.antisymm |
| · intro r hr |
| have hrs := (Finset.mem_filter.mp hr).1 |
| have hts := (Finset.mem_filter.mp ht).1 |
| rcases ancestors_linear h hrs hts with he|he |
| · exact he |
| · have hs : ancestors h t ⊆ ancestors h r := fun _ hk => ancestor_trans h hk he |
| have hc := hmax r hr |
| have heq := Finset.eq_of_subset_of_card_le hs hc |
| rw [heq] |
| exact self_mem_ancestors h r |
| · intro r hr |
| exact Finset.mem_filter.mpr ⟨ancestor_trans h hr (Finset.mem_filter.mp ht).1, |
| hH r t (Finset.mem_filter.mp ht).2 hr⟩ |
| · exact Or.inl (Finset.not_nonempty_iff_eq_empty.mp hn) |
| end RecursiveModel |
|
|
| namespace PathModel |
| open RecursiveModel |
| lemma cut_branch (h : ℕ) (H : Coord h → Prop) [DecidablePred H] |
| (hH : ∀ a b,H b → a ∈ ancestors h b → H a) (s : Coord h) : |
| LpCut.continuous H (branch h s)=0 ∨ ∃ t,LpCut.continuous H (branch h s)=branch h t := by |
| rcases ancestral_prefix h H hH s with he|⟨t,he⟩ |
| · left |
| ext r |
| rw [LpCut.continuous_apply,branch_apply] |
| by_cases hr : H r |
| · rw [ite_eq_left hr,ite_eq_right (by |
| intro hh |
| have hk := Finset.mem_filter.mpr ⟨hh,hr⟩ |
| rw [he] at hk |
| exact Finset.notMem_empty r hk)] |
| rfl |
| · rw [ite_eq_right hr]; rfl |
| · right |
| refine ⟨t,?_⟩ |
| ext r |
| rw [LpCut.continuous_apply,branch_apply,branch_apply] |
| have hm : r ∈ ancestors h t ↔ r ∈ ancestors h s ∧ H r := by rw [← he,Finset.mem_filter] |
| by_cases h₁ : H r <;> by_cases h₂ : r ∈ ancestors h s <;> simp [h₁,h₂,hm] |
|
|
| lemma branch_cost (h : ℕ) (s : Coord h) : cost 1 h (branch h s) ≤ 1 := by |
| have hh := (presentation 1 h).le_representation (d := WithLp.toLp 1 ((0 : L2 h),lp.single 1 s (1:ℝ))) |
| (show (presentation 1 h).output (WithLp.toLp 1 (0,lp.single 1 s (1:ℝ)))=branch h s by |
| change 0+path h (lp.single 1 s 1)=_ |
| rw [zero_add,path_single,one_smul]) |
| simpa only [WithLp.prod_norm_eq_of_L1,WithLp.fst,WithLp.snd,WithLp.ofLp_toLp,norm_zero,zero_add, |
| lp.norm_single (by norm_num : (0:ℝ≥0∞)<1),norm_one,cost] using hh |
|
|
| lemma linear_cost_cut (h : ℕ) (H : Coord h → Prop) [DecidablePred H] |
| (hH : ∀ a b,H b → a ∈ ancestors h b → H a) (v : L2 h) : |
| cost 1 h (LpCut.continuous H v) ≤ cost 1 h v := by |
| let E := linearFullData h |
| let T : L2 h →L[ℝ] E.Space := E.equiv.symm.toContinuousLinearMap.comp (LpCut.continuous H) |
| have hbranch (s : Coord h) : ‖T (branch h s)‖ ≤ 1 := by |
| change cost 1 h (LpCut.continuous H (branch h s)) ≤ 1 |
| rcases cut_branch h H hH s with he|⟨t,he⟩ |
| · rw [he,map_zero]; norm_num |
| · rw [he]; exact branch_cost h t |
| have hp (μ : L1 h) : cost 1 h (LpCut.continuous H (path h μ)) ≤ ‖μ‖ := by |
| have hnorm : Summable (fun s => ‖μ s • T (branch h s)‖) := by |
| apply Summable.of_nonneg_of_le (fun _ => norm_nonneg _) _ (summable_abs μ) |
| intro s |
| rw [norm_smul,Real.norm_eq_abs] |
| exact (mul_le_mul_of_nonneg_left (hbranch s) (abs_nonneg _)).trans_eq (mul_one _) |
| have hsum := (path_summable μ).hasSum.mapL T |
| simp_rw [map_smul] at hsum |
| change ‖T (path h μ)‖ ≤ ‖μ‖ |
| change ‖T (∑' s,μ s • branch h s)‖ ≤ ‖μ‖ |
| rw [← hsum.tsum_eq] |
| calc |
| _ ≤ ∑' s,‖μ s • T (branch h s)‖ := norm_tsum_le_tsum_norm hnorm |
| _ ≤ ∑' s,|μ s| := Summable.tsum_le_tsum (fun s => by |
| rw [norm_smul,Real.norm_eq_abs] |
| exact (mul_le_mul_of_nonneg_left (hbranch s) (abs_nonneg _)).trans_eq (mul_one _)) hnorm (summable_abs μ) |
| _ = ‖μ‖ := tsum_abs μ |
| have hb := (presentation 1 h).bound v (by norm_num : (0:ℝ) ≤ 1) (b := cost 1 h (LpCut.continuous H v)) |
| simp only [one_mul] at hb |
| apply hb |
| intro d hd |
| change d.fst+path h d.snd=v at hd |
| rw [← hd,map_add,WithLp.prod_norm_eq_of_L1] |
| exact (map_add_le_add (cost 1 h) _ _).trans (add_le_add |
| ((linear_le_norm _ _).trans (LpCut.norm_linear _ _)) (hp d.snd)) |
| end PathModel |
|
|
| namespace CoordinateCompletion.Data |
| variable {ι : Type*} (A : CoordinateCompletion.Data ι) |
| lemma projection_nested (H B : Finset ι) (hHB : H ⊆ B) (x : A.Space) : |
| A.projection H (A.projection B x)=A.projection H x := by |
| rw [A.projection_apply H (A.projection B x)] |
| simp only [coordinate_projection] |
| rw [A.projection_apply H x] |
| apply Finset.sum_congr rfl |
| intro i hi |
| rw [ite_eq_left (hHB hi)] |
| lemma projection_nested_right (H B : Finset ι) (hHB : H ⊆ B) (x : A.Space) : |
| A.projection B (A.projection H x)=A.projection H x := by |
| rw [A.projection_commutes B H] |
| exact A.projection_nested H B hHB x |
| end CoordinateCompletion.Data |
|
|
| namespace RecursiveModel |
| instance : PartialOrder ForestHead := inferInstanceAs (PartialOrder {H : Finset ForestCoord // ∀ i ∈ H,forestAncestors i ⊆ H}) |
| lemma head_upper (H K : ForestHead) : ∃ B : ForestHead,H ≤ B ∧ K ≤ B := by |
| let B : ForestHead := ⟨H.val ∪ K.val,by |
| intro i hi j hj |
| rcases Finset.mem_union.mp hi with hi|hi |
| · exact Finset.mem_union_left _ (H.property i hi hj) |
| · exact Finset.mem_union_right _ (K.property i hi hj)⟩ |
| exact ⟨B,Finset.subset_union_left,Finset.subset_union_right⟩ |
| lemma head_nonempty : Nonempty ForestHead := ⟨forestHead ∅⟩ |
| end RecursiveModel |
|
|
| namespace PathModel |
| open RecursiveModel |
| lemma linear_forest_cut (v : ForestVec) (H : ForestHead) : |
| linearForestSeminorm (v.filter (· ∈ H.val)) ≤ linearForestSeminorm v := by |
| apply aggregate_mono 2 |
| · exact outerValues_nonneg _ _ |
| · intro h |
| rw [outerValues_apply,outerValues_apply] |
| change cost 1 (h+1) (finiteEmbedding _ (components (v.filter (· ∈ H.val)) h)) ≤ |
| cost 1 (h+1) (finiteEmbedding _ (components v h)) |
| have he : finiteEmbedding (h+1) (components (v.filter (· ∈ H.val)) h)= |
| LpCut.continuous (fun i : Coord (h+1) => (⟨h,i⟩ : ForestCoord) ∈ H.val) |
| (finiteEmbedding (h+1) (components v h)) := by |
| ext i |
| change (v.filter (· ∈ H.val)) ⟨h,i⟩=if (⟨h,i⟩ : ForestCoord) ∈ H.val then v ⟨h,i⟩ else 0 |
| exact Finsupp.filter_apply _ _ _ |
| rw [he] |
| apply linear_cost_cut |
| intro a b hb hab |
| exact H.property ⟨h,b⟩ hb (Finset.mem_image.mpr ⟨a,hab,rfl⟩) |
| lemma linear_projection_contractive (H : ForestHead) (x : linearData.Space) : |
| ‖linearData.projection H.val x‖ ≤ ‖x‖ := by |
| rcases H with ⟨H,hH⟩ |
| induction x using UniformSpace.Completion.induction_on with |
| | hp => exact isClosed_le (by fun_prop) continuous_norm |
| | ih v => |
| change ‖linearData.projection H (linearData.embedding (linearData.array v))‖ ≤ ‖linearData.embedding (linearData.array v)‖ |
| rw [linearData.projection_embedding,linearData.norm_embedding,linearData.norm_embedding] |
| convert linear_forest_cut (linearData.array v) ⟨H,hH⟩ using 1 <;> congr 1 |
| ext i |
| simp only [Finsupp.filter_apply] |
| by_cases hi : i ∈ H <;> simp only [hi,ite_eq_left] |
| end PathModel |
|
|
| end DiamondDistortion |
|
|
| end |
|
|
| end OAI |
|
|
