| import OAI.Analysis.DiamondDistortion.FiniteAverage |
|
|
| namespace OAI |
|
|
| universe u v |
|
|
| noncomputable section |
| open scoped BigOperators Classical Topology |
| open Set |
|
|
| namespace DiamondDistortion |
|
|
| structure SegmentSystem (ι : Type*) where |
| IsSegment : Finset ι → Prop |
| singleton : ∀ v, IsSegment {v} |
|
|
| namespace SegmentSystem |
| variable {ι : Type*} (T : SegmentSystem ι) |
|
|
| /-- The represented disjoint families in the definition of the primal segment norm. -/ |
| structure Family where |
| n : ℕ |
| seg : Fin n → Finset ι |
| allowed : ∀ i, T.IsSegment (seg i) |
| disjoint : Pairwise (fun i j => Disjoint (seg i) (seg j)) |
|
|
| instance : Nonempty T.Family := ⟨{ |
| n := 0 |
| seg := Fin.elim0 |
| allowed := fun i => Fin.elim0 i |
| disjoint := fun {i} => Fin.elim0 i }⟩ |
|
|
| variable {T} |
|
|
| /-- Segment testing as a Euclidean-valued linear map. -/ |
| def Family.test (F : T.Family) : (ι →₀ ℝ) →ₗ[ℝ] EuclideanSpace ℝ (Fin F.n) where |
| toFun u := WithLp.toLp 2 (fun i => ∑ v ∈ F.seg i, u v) |
| map_add' u v := by |
| ext i |
| simp [Finset.sum_add_distrib] |
| map_smul' c u := by |
| ext i |
| simp [Finset.mul_sum] |
|
|
| @[simp] theorem Family.test_apply (F : T.Family) (u : ι →₀ ℝ) (i : Fin F.n) : |
| F.test u i = ∑ v ∈ F.seg i, u v := rfl |
|
|
| def Family.seminorm (F : T.Family) : Seminorm ℝ (ι →₀ ℝ) := |
| (normSeminorm ℝ (EuclideanSpace ℝ (Fin F.n))).comp F.test |
|
|
| @[simp] theorem Family.seminorm_apply (F : T.Family) (u : ι →₀ ℝ) : |
| F.seminorm u = ‖F.test u‖ := rfl |
|
|
| lemma Family.test_single_le (F : T.Family) (v : ι) (r : ℝ) : |
| ‖F.test (Finsupp.single v r)‖ ≤ |r| := by |
| classical |
| rw [EuclideanSpace.norm_eq] |
| apply (Real.sqrt_le_left (abs_nonneg r)).2 |
| by_cases h : ∃ i, v ∈ F.seg i |
| · obtain ⟨i, hi⟩ := h |
| have hne : ∀ j, j ≠ i → v ∉ F.seg j := by |
| intro j hji hj |
| exact Finset.disjoint_left.mp (F.disjoint hji) hj hi |
| rw [Finset.sum_eq_single i] |
| · simp [Family.test, Finsupp.single_apply, hi] |
| · intro j _ hji |
| simp [Family.test, Finsupp.single_apply, hne j hji] |
| · simp |
| · have hn : ∀ i, v ∉ F.seg i := by simpa using h |
| simp [Family.test, Finsupp.single_apply, hn, sq_nonneg] |
|
|
| lemma Family.test_le_l1 (F : T.Family) (u : ι →₀ ℝ) : |
| ‖F.test u‖ ≤ u.sum (fun _ r => |r|) := by |
| classical |
| calc |
| ‖F.test u‖ = ‖∑ v ∈ u.support, F.test (Finsupp.single v (u v))‖ := by |
| rw [← map_sum] |
| congr 2 |
| exact (Finsupp.sum_single u).symm |
| _ ≤ ∑ v ∈ u.support, ‖F.test (Finsupp.single v (u v))‖ := norm_sum_le _ _ |
| _ ≤ ∑ v ∈ u.support, |u v| := Finset.sum_le_sum fun v _ => F.test_single_le v (u v) |
| _ = u.sum (fun _ r => |r|) := rfl |
|
|
| variable (T) |
|
|
| lemma families_bddAbove : BddAbove (Set.range (Family.seminorm (T := T))) := by |
| rw [Seminorm.bddAbove_range_iff] |
| intro u |
| exact ⟨u.sum (fun _ r => |r|), by rintro _ ⟨F, rfl⟩; exact F.test_le_l1 u⟩ |
| |
| def primalSeminorm : Seminorm ℝ (ι →₀ ℝ) := ⨆ F : T.Family, F.seminorm |
|
|
| lemma test_le_primal (F : T.Family) (u : ι →₀ ℝ) : |
| ‖F.test u‖ ≤ T.primalSeminorm u := by |
| rw [primalSeminorm, Seminorm.iSup_apply T.families_bddAbove] |
| exact le_ciSup (⟨u.sum (fun _ r => |r|), by |
| rintro _ ⟨G, rfl⟩; exact G.test_le_l1 u⟩ : |
| BddAbove (Set.range (fun G : T.Family => G.seminorm u))) F |
|
|
| lemma primal_le_l1 (u : ι →₀ ℝ) : |
| T.primalSeminorm u ≤ u.sum (fun _ r => |r|) := by |
| rw [primalSeminorm, Seminorm.iSup_apply T.families_bddAbove] |
| apply ciSup_le |
| intro F |
| exact F.test_le_l1 u |
|
|
| /-- Singleton families ensure that the segment seminorm separates points. -/ |
| def singletonFamily (v : ι) : T.Family where |
| n := 1 |
| seg _ := {v} |
| allowed _ := T.singleton v |
| disjoint := by intro i j h; exact False.elim (h (Subsingleton.elim _ _)) |
| |
| lemma coordinate_le_primal (u : ι →₀ ℝ) (v : ι) : |u v| ≤ T.primalSeminorm u := by |
| have h := T.test_le_primal (T.singletonFamily v) u |
| rw [EuclideanSpace.norm_eq] at h |
| change Real.sqrt (∑ _ : Fin 1, ‖∑ w ∈ ({v} : Finset ι), u w‖ ^ 2) ≤ _ at h |
| simpa [Real.sqrt_sq_eq_abs] using h |
|
|
| lemma primal_eq_zero_iff (u : ι →₀ ℝ) : T.primalSeminorm u = 0 ↔ u = 0 := by |
| constructor |
| · intro h |
| ext v |
| have := T.coordinate_le_primal u v |
| simpa [h] using this |
| · rintro rfl |
| exact map_zero _ |
|
|
| /-- Finite families with any finite index type give the same segment tests. -/ |
| def familyOfFintype {κ : Type*} [Fintype κ] (S : κ → Finset ι) |
| (hS : ∀ i, T.IsSegment (S i)) |
| (hd : Pairwise (fun i j => Disjoint (S i) (S j))) : T.Family where |
| n := Fintype.card κ |
| seg i := S ((Fintype.equivFin κ).symm i) |
| allowed i := hS _ |
| disjoint := by |
| intro i j hij |
| exact hd (fun he => hij ((Fintype.equivFin κ).symm.injective he)) |
|
|
| lemma test_energy_le {κ : Type*} [Fintype κ] (S : κ → Finset ι) |
| (hS : ∀ i, T.IsSegment (S i)) |
| (hd : Pairwise (fun i j => Disjoint (S i) (S j))) (u : ι →₀ ℝ) : |
| (∑ i, (∑ v ∈ S i, u v) ^ 2) ≤ (T.primalSeminorm u) ^ 2 := by |
| let F := T.familyOfFintype S hS hd |
| have hb := pow_le_pow_left₀ (norm_nonneg (F.test u)) (T.test_le_primal F u) 2 |
| rw [EuclideanSpace.norm_sq_eq] at hb |
| change (∑ i : Fin (Fintype.card κ), |
| ‖∑ v ∈ S ((Fintype.equivFin κ).symm i), u v‖ ^ 2) ≤ _ at hb |
| rw [(Fintype.equivFin κ).symm.sum_comp (fun i : κ => ‖∑ v ∈ S i, u v‖ ^ 2)] at hb |
| simpa only [Real.norm_eq_abs, sq_abs] using hb |
|
|
| /-- Empty pieces in a partition may be discarded; they contribute no energy. -/ |
| lemma test_energy_le_allow_empty {κ : Type*} [Fintype κ] (S : κ → Finset ι) |
| (hS : ∀ i, (S i).Nonempty → T.IsSegment (S i)) |
| (hd : Pairwise (fun i j => Disjoint (S i) (S j))) (u : ι →₀ ℝ) : |
| (∑ i, (∑ v ∈ S i, u v) ^ 2) ≤ (T.primalSeminorm u) ^ 2 := by |
| classical |
| let K := {i : κ // (S i).Nonempty} |
| have h := T.test_energy_le (fun i : K => S i.val) (fun i => hS _ i.property) |
| (by intro i j hij; exact hd (fun he => hij (Subtype.ext he))) u |
| have hz : (∑ i : {i : κ // ¬ (S i).Nonempty}, (∑ v ∈ S i.val, u v) ^ 2) = 0 := by |
| apply Finset.sum_eq_zero |
| intro i _ |
| have hi : S i.val = ∅ := Finset.not_nonempty_iff_eq_empty.mp i.property |
| simp [hi] |
| have he := Fintype.sum_subtype_add_sum_subtype |
| (fun i : κ => (S i).Nonempty) (fun i => (∑ v ∈ S i, u v) ^ 2) |
| rw [hz, add_zero] at he |
| rwa [← he] |
|
|
| def Primal (_T : SegmentSystem ι) := ι →₀ ℝ |
|
|
| /-- Explicit conversions keep the chosen norm distinct from unrelated Finsupp structures. -/ |
| def ofPrimal (u : T.Primal) : ι →₀ ℝ := u |
|
|
| def toPrimal (u : ι →₀ ℝ) : T.Primal := u |
|
|
| def filterPrimal (p : ι → Prop) (u : T.Primal) : T.Primal := |
| (T.ofPrimal u).filter p |
|
|
| instance : AddCommGroup T.Primal := inferInstanceAs (AddCommGroup (ι →₀ ℝ)) |
| instance : Module ℝ T.Primal := inferInstanceAs (Module ℝ (ι →₀ ℝ)) |
|
|
| attribute [-simp] Family.test_apply Family.seminorm_apply in |
| instance : NormedAddCommGroup T.Primal := by |
| have Family.test_apply (F : T.Family) (u : ι →₀ ℝ) (i : Fin F.n) : |
| F.test u i = ∑ v ∈ F.seg i, u v := rfl |
| have Family.seminorm_apply (F : T.Family) (u : ι →₀ ℝ) : |
| F.seminorm u = ‖F.test u‖ := rfl |
| have Family.test_single_le (F : T.Family) (v : ι) (r : ℝ) : |
| ‖F.test (Finsupp.single v r)‖ ≤ |r| := by |
| classical |
| rw [EuclideanSpace.norm_eq] |
| apply (Real.sqrt_le_left (abs_nonneg r)).2 |
| by_cases h : ∃ i, v ∈ F.seg i |
| · obtain ⟨i, hi⟩ := h |
| have hne : ∀ j, j ≠ i → v ∉ F.seg j := by |
| intro j hji hj |
| exact Finset.disjoint_left.mp (F.disjoint hji) hj hi |
| rw [Finset.sum_eq_single i] |
| · simp [Family.test, Finsupp.single_apply, hi] |
| · intro j _ hji |
| simp [Family.test, Finsupp.single_apply, hne j hji] |
| · simp |
| · have hn : ∀ i, v ∉ F.seg i := by simpa using h |
| simp [Family.test, Finsupp.single_apply, hn, sq_nonneg] |
| have Family.test_le_l1 (F : T.Family) (u : ι →₀ ℝ) : |
| ‖F.test u‖ ≤ u.sum (fun _ r => |r|) := by |
| classical |
| calc |
| ‖F.test u‖ = ‖∑ v ∈ u.support, F.test (Finsupp.single v (u v))‖ := by |
| rw [← map_sum] |
| congr 2 |
| exact (Finsupp.sum_single u).symm |
| _ ≤ ∑ v ∈ u.support, ‖F.test (Finsupp.single v (u v))‖ := norm_sum_le _ _ |
| _ ≤ ∑ v ∈ u.support, |u v| := Finset.sum_le_sum fun v _ => Family.test_single_le F v (u v) |
| _ = u.sum (fun _ r => |r|) := rfl |
| have families_bddAbove : BddAbove (Set.range (Family.seminorm (T := T))) := by |
| rw [Seminorm.bddAbove_range_iff] |
| intro u |
| exact ⟨u.sum (fun _ r => |r|), by rintro _ ⟨F, rfl⟩; exact Family.test_le_l1 F u⟩ |
| have test_le_primal (F : T.Family) (u : ι →₀ ℝ) : |
| ‖F.test u‖ ≤ T.primalSeminorm u := by |
| rw [primalSeminorm, Seminorm.iSup_apply families_bddAbove] |
| exact le_ciSup (⟨u.sum (fun _ r => |r|), by |
| rintro _ ⟨G, rfl⟩; exact Family.test_le_l1 G u⟩ : |
| BddAbove (Set.range (fun G : T.Family => G.seminorm u))) F |
| have coordinate_le_primal (u : ι →₀ ℝ) (v : ι) : |u v| ≤ T.primalSeminorm u := by |
| have h := test_le_primal (T.singletonFamily v) u |
| rw [EuclideanSpace.norm_eq] at h |
| change Real.sqrt (∑ _ : Fin 1, ‖∑ w ∈ ({v} : Finset ι), u w‖ ^ 2) ≤ _ at h |
| simpa [Real.sqrt_sq_eq_abs] using h |
| have primal_eq_zero_iff (u : ι →₀ ℝ) : T.primalSeminorm u = 0 ↔ u = 0 := by |
| constructor |
| · intro h |
| ext v |
| have := coordinate_le_primal u v |
| simpa [h] using this |
| · rintro rfl |
| exact map_zero _ |
| exact AddGroupNorm.toNormedAddCommGroup |
| { T.primalSeminorm.toAddGroupSeminorm with |
| eq_zero_of_map_eq_zero' := fun u h => (primal_eq_zero_iff u).mp h } |
|
|
| instance : NormedSpace ℝ T.Primal where |
| norm_smul_le c u := le_of_eq (T.primalSeminorm.smul' c u) |
|
|
| @[simp] lemma ofPrimal_sub (u v : T.Primal) : |
| T.ofPrimal (u-v) = T.ofPrimal u - T.ofPrimal v := rfl |
|
|
| @[simp] lemma ofPrimal_smul (a : ℝ) (u : T.Primal) : |
| T.ofPrimal (a • u) = a • T.ofPrimal u := rfl |
|
|
| @[simp] lemma ofPrimal_sum {κ : Type*} (s : Finset κ) (f : κ → T.Primal) : |
| T.ofPrimal (∑ i ∈ s, f i) = ∑ i ∈ s, T.ofPrimal (f i) := rfl |
|
|
| @[simp] lemma ofPrimal_filter (p : ι → Prop) (u : T.Primal) : |
| T.ofPrimal (T.filterPrimal p u) = (T.ofPrimal u).filter p := rfl |
|
|
| @[simp] lemma norm_eq_primal (u : T.Primal) : |
| ‖u‖ = T.primalSeminorm (T.ofPrimal u) := rfl |
|
|
| lemma sub_filterPrimal (p : ι → Prop) (u : T.Primal) : |
| u - T.filterPrimal p u = T.filterPrimal (fun x => ¬ p x) u := by |
| apply Finsupp.ext |
| intro v |
| change T.ofPrimal (u - T.filterPrimal p u) v = |
| T.ofPrimal (T.filterPrimal (fun x => ¬ p x) u) v |
| simp only [ofPrimal_sub, ofPrimal_filter, Finsupp.sub_apply, Finsupp.filter_apply] |
| split_ifs <;> simp_all |
| |
| abbrev JamesSpace := UniformSpace.Completion T.Primal |
|
|
| /-- Its full real continuous dual. -/ |
| abbrev Dual := StrongDual ℝ T.JamesSpace |
|
|
| /-- Coordinate evaluation on finite arrays, bounded by the singleton test. -/ |
| def coordinateFinite (v : ι) : T.Primal →L[ℝ] ℝ := by |
| have Family.test_apply (F : T.Family) (u : ι →₀ ℝ) (i : Fin F.n) : |
| F.test u i = ∑ v ∈ F.seg i, u v := rfl |
| have Family.seminorm_apply (F : T.Family) (u : ι →₀ ℝ) : |
| F.seminorm u = ‖F.test u‖ := rfl |
| have Family.test_single_le (F : T.Family) (v : ι) (r : ℝ) : |
| ‖F.test (Finsupp.single v r)‖ ≤ |r| := by |
| classical |
| rw [EuclideanSpace.norm_eq] |
| apply (Real.sqrt_le_left (abs_nonneg r)).2 |
| by_cases h : ∃ i, v ∈ F.seg i |
| · obtain ⟨i, hi⟩ := h |
| have hne : ∀ j, j ≠ i → v ∉ F.seg j := by |
| intro j hji hj |
| exact Finset.disjoint_left.mp (F.disjoint hji) hj hi |
| rw [Finset.sum_eq_single i] |
| · simp [Family.test, Finsupp.single_apply, hi] |
| · intro j _ hji |
| simp [Family.test, Finsupp.single_apply, hne j hji] |
| · simp |
| · have hn : ∀ i, v ∉ F.seg i := by simpa using h |
| simp [Family.test, Finsupp.single_apply, hn, sq_nonneg] |
| have Family.test_le_l1 (F : T.Family) (u : ι →₀ ℝ) : |
| ‖F.test u‖ ≤ u.sum (fun _ r => |r|) := by |
| classical |
| calc |
| ‖F.test u‖ = ‖∑ v ∈ u.support, F.test (Finsupp.single v (u v))‖ := by |
| rw [← map_sum] |
| congr 2 |
| exact (Finsupp.sum_single u).symm |
| _ ≤ ∑ v ∈ u.support, ‖F.test (Finsupp.single v (u v))‖ := norm_sum_le _ _ |
| _ ≤ ∑ v ∈ u.support, |u v| := Finset.sum_le_sum fun v _ => Family.test_single_le F v (u v) |
| _ = u.sum (fun _ r => |r|) := rfl |
| have families_bddAbove : BddAbove (Set.range (Family.seminorm (T := T))) := by |
| rw [Seminorm.bddAbove_range_iff] |
| intro u |
| exact ⟨u.sum (fun _ r => |r|), by rintro _ ⟨F, rfl⟩; exact Family.test_le_l1 F u⟩ |
| have test_le_primal (F : T.Family) (u : ι →₀ ℝ) : |
| ‖F.test u‖ ≤ T.primalSeminorm u := by |
| rw [primalSeminorm, Seminorm.iSup_apply families_bddAbove] |
| exact le_ciSup (⟨u.sum (fun _ r => |r|), by |
| rintro _ ⟨G, rfl⟩; exact Family.test_le_l1 G u⟩ : |
| BddAbove (Set.range (fun G : T.Family => G.seminorm u))) F |
| have coordinate_le_primal (u : ι →₀ ℝ) (v : ι) : |u v| ≤ T.primalSeminorm u := by |
| have h := test_le_primal (T.singletonFamily v) u |
| rw [EuclideanSpace.norm_eq] at h |
| change Real.sqrt (∑ _ : Fin 1, ‖∑ w ∈ ({v} : Finset ι), u w‖ ^ 2) ≤ _ at h |
| simpa [Real.sqrt_sq_eq_abs] using h |
| exact (show T.Primal →ₗ[ℝ] ℝ from Finsupp.lapply v).mkContinuous 1 (by |
| intro u |
| change ‖(show ι →₀ ℝ from u) v‖ ≤ 1 * T.primalSeminorm u |
| simpa only [one_mul, Real.norm_eq_abs] using coordinate_le_primal u v) |
|
|
| def coordinate (v : ι) : T.Dual := |
| (T.coordinateFinite v).extend UniformSpace.Completion.toComplL |
|
|
| @[simp] lemma coordinate_coe (v : ι) (u : T.Primal) : |
| T.coordinate v (u : T.JamesSpace) = (show ι →₀ ℝ from u) v := by |
| exact ContinuousLinearMap.extend_eq _ UniformSpace.Completion.denseRange_coe |
| (UniformSpace.Completion.isUniformInducing_coe _) u |
|
|
| /-- Primal unit coordinate and its canonical image in the completion. -/ |
| def unitFinite (v : ι) : T.Primal := Finsupp.single v 1 |
|
|
| def unitVector (v : ι) : T.JamesSpace := (T.unitFinite v : T.JamesSpace) |
|
|
| @[simp] lemma norm_unitFinite (v : ι) : ‖T.unitFinite v‖ = 1 := by |
| change T.primalSeminorm (Finsupp.single v 1) = 1 |
| apply le_antisymm |
| · have h := T.primal_le_l1 (Finsupp.single v 1) |
| simpa using h |
| · have h := T.coordinate_le_primal (Finsupp.single v 1) v |
| simpa using h |
|
|
| @[simp] lemma norm_unitVector (v : ι) : ‖T.unitVector v‖ = 1 := by |
| rw [unitVector, UniformSpace.Completion.norm_coe, norm_unitFinite] |
|
|
| @[simp] lemma coordinate_unitVector (v w : ι) : |
| T.coordinate v (T.unitVector w) = if w = v then 1 else 0 := by |
| classical |
| rw [unitVector, coordinate_coe] |
| exact Finsupp.single_apply |
|
|
| /-- Finite head projection on the completed primal, defined even for nonancestral sets. -/ |
| def headPrimal (H : Finset ι) : T.JamesSpace →L[ℝ] T.JamesSpace := |
| ∑ v ∈ H, (T.coordinate v).smulRight (T.unitVector v) |
|
|
| @[simp] lemma headPrimal_apply (H : Finset ι) (u : T.JamesSpace) : |
| T.headPrimal H u = ∑ v ∈ H, T.coordinate v u • T.unitVector v := by |
| simp [headPrimal] |
|
|
| lemma sum_units_eq_filter (H : Finset ι) (u : T.Primal) : |
| (∑ v ∈ H, T.ofPrimal u v • T.unitFinite v) = T.filterPrimal (· ∈ H) u := by |
| classical |
| apply Finsupp.ext |
| intro w |
| change T.ofPrimal (∑ v ∈ H, T.ofPrimal u v • T.unitFinite v) w = |
| T.ofPrimal (T.filterPrimal (· ∈ H) u) w |
| simp only [ofPrimal_sum, ofPrimal_smul, ofPrimal_filter, Finsupp.finsetSum_apply, |
| Finsupp.smul_apply, smul_eq_mul] |
| simp [ofPrimal, unitFinite, Finsupp.single_apply, |
| mul_ite, Finset.sum_ite_eq'] |
| convert (Finsupp.filter_apply (· ∈ H) (T.ofPrimal u) w).symm using 1 |
| all_goals congr |
|
|
| lemma headPrimal_coe (H : Finset ι) (u : T.Primal) : |
| T.headPrimal H (u : T.JamesSpace) = |
| (T.filterPrimal (· ∈ H) u : T.JamesSpace) := by |
| classical |
| rw [headPrimal_apply, ← T.sum_units_eq_filter] |
| simp only [coordinate_coe, unitVector] |
| change (∑ v ∈ H, T.ofPrimal u v • |
| (UniformSpace.Completion.toComplL (S := ℝ)) (T.unitFinite v)) = |
| (UniformSpace.Completion.toComplL (S := ℝ)) (∑ v ∈ H, T.ofPrimal u v • T.unitFinite v) |
| simp only [map_sum, map_smul] |
|
|
| def headDual (H : Finset ι) : T.Dual →L[ℝ] T.Dual := |
| ∑ v ∈ H, (ContinuousLinearMap.apply ℝ ℝ (T.unitVector v)).smulRight (T.coordinate v) |
|
|
| @[simp] lemma headDual_apply (H : Finset ι) (x : T.Dual) : |
| T.headDual H x = ∑ v ∈ H, x (T.unitVector v) • T.coordinate v := by |
| simp [headDual] |
|
|
| lemma headDual_apply_apply (H : Finset ι) (x : T.Dual) (u : T.JamesSpace) : |
| T.headDual H x u = x (T.headPrimal H u) := by |
| simp [headDual_apply, headPrimal_apply, mul_comm] |
|
|
| /-- Complementary coordinate projection, never assumed contractive without proof. -/ |
| def tailDual (H : Finset ι) : T.Dual →L[ℝ] T.Dual := |
| ContinuousLinearMap.id ℝ T.Dual - T.headDual H |
|
|
| @[simp] lemma tailDual_apply (H : Finset ι) (x : T.Dual) : |
| T.tailDual H x = x - T.headDual H x := rfl |
|
|
| lemma tailDual_apply_apply (H : Finset ι) (x : T.Dual) (u : T.JamesSpace) : |
| T.tailDual H x u = x (u - T.headPrimal H u) := by |
| simp [tailDual_apply, mul_comm] |
|
|
| /-- The canonical linear embedding, presented on actual finitely supported arrays. -/ |
| def finiteEmbedding : (ι →₀ ℝ) →ₗ[ℝ] T.JamesSpace := |
| (UniformSpace.Completion.toComplL (S := ℝ) (α := T.Primal)).toLinearMap |
|
|
| @[simp] lemma finiteEmbedding_apply (u : ι →₀ ℝ) : |
| T.finiteEmbedding u = (T.toPrimal u : T.JamesSpace) := rfl |
|
|
| @[simp] lemma finiteEmbedding_single (v : ι) (a : ℝ) : |
| T.finiteEmbedding (Finsupp.single v a) = a • T.unitVector v := by |
| have he : Finsupp.single v a = a • (Finsupp.single v 1 : ι →₀ ℝ) := by |
| simp only [Finsupp.smul_single, smul_eq_mul, mul_one] |
| rw [he, map_smul] |
| rfl |
|
|
| lemma dual_coe_apply (x : T.Dual) (u : T.Primal) : |
| x (u : T.JamesSpace) = ∑ v ∈ (T.ofPrimal u).support, T.ofPrimal u v * x (T.unitVector v) := by |
| have hu := Finsupp.sum_single (T.ofPrimal u) |
| have he := congrArg (fun z => x (T.finiteEmbedding z)) hu |
| simp only [Finsupp.sum, map_sum, finiteEmbedding_single, map_smul, smul_eq_mul] at he |
| change (∑ v ∈ (T.ofPrimal u).support, T.ofPrimal u v * x (T.unitVector v)) = |
| x (u : T.JamesSpace) at he |
| exact he.symm |
|
|
| /-- Full dual functionals are determined by all coordinate unit vectors. -/ |
| lemma dual_ext {x y : T.Dual} (h : ∀ v, x (T.unitVector v) = y (T.unitVector v)) : x = y := by |
| apply ContinuousLinearMap.ext |
| intro u |
| induction u using UniformSpace.Completion.induction_on with |
| | hp => exact isClosed_eq (by fun_prop) (by fun_prop) |
| | ih u => simp only [dual_coe_apply, h] |
|
|
| def segmentFunctional (S : Finset ι) : T.Dual := ∑ v ∈ S, T.coordinate v |
|
|
| @[simp] lemma segmentFunctional_coe (S : Finset ι) (u : T.Primal) : |
| T.segmentFunctional S (u : T.JamesSpace) = ∑ v ∈ S, T.ofPrimal u v := by |
| simp only [segmentFunctional, sum_apply, coordinate_coe, ofPrimal] |
|
|
| @[simp] lemma segmentFunctional_unit (S : Finset ι) (v : ι) : |
| T.segmentFunctional S (T.unitVector v) = if v ∈ S then 1 else 0 := by |
| classical |
| simp [segmentFunctional, coordinate_unitVector] |
|
|
| /-- Finite represented vectors retain their segment families as data. -/ |
| def combine {κ : Type*} [Fintype κ] (S : κ → Finset ι) (a : κ → ℝ) : T.Dual := |
| ∑ i, a i • T.segmentFunctional (S i) |
|
|
| @[simp] lemma combine_coe {κ : Type*} [Fintype κ] (S : κ → Finset ι) |
| (a : κ → ℝ) (u : T.Primal) : |
| T.combine S a (u : T.JamesSpace) = ∑ i, a i * (∑ v ∈ S i, T.ofPrimal u v) := by |
| simp only [combine, sum_apply, smul_apply, |
| segmentFunctional_coe, smul_eq_mul] |
|
|
| @[simp] lemma combine_unit {κ : Type*} [Fintype κ] (S : κ → Finset ι) |
| (a : κ → ℝ) (v : ι) : |
| T.combine S a (T.unitVector v) = ∑ i, if v ∈ S i then a i else 0 := by |
| simp only [combine, sum_apply, smul_apply, |
| segmentFunctional_unit, smul_eq_mul, mul_ite, mul_one, mul_zero] |
|
|
| lemma combine_add {κ : Type*} [Fintype κ] (S : κ → Finset ι) (a b : κ → ℝ) : |
| T.combine S (a+b) = T.combine S a + T.combine S b := by |
| simp [combine, add_smul, Finset.sum_add_distrib] |
|
|
| lemma combine_sub {κ : Type*} [Fintype κ] (S : κ → Finset ι) (a b : κ → ℝ) : |
| T.combine S (a-b) = T.combine S a - T.combine S b := by |
| unfold combine |
| rw [← Finset.sum_sub_distrib] |
| apply Finset.sum_congr rfl |
| intro i _ |
| exact sub_smul (a i) (b i) (T.segmentFunctional (S i)) |
|
|
| lemma combine_unit_of_mem (F : T.Family) (a : Fin F.n → ℝ) |
| (i : Fin F.n) {v : ι} (hv : v ∈ F.seg i) : |
| T.combine F.seg a (T.unitVector v) = a i := by |
| classical |
| rw [combine_unit, Finset.sum_eq_single i] |
| · simp only [ite_eq_left hv] |
| · intro j _ hji |
| rw [ite_eq_right (fun h => Finset.disjoint_left.mp (F.disjoint hji) h hv)] |
| · simp |
|
|
| /-- Cauchy--Schwarz for represented disjoint segment coefficients, with empty |
| pieces permitted after a projection. -/ |
| lemma norm_combine_le {κ : Type*} [Fintype κ] (S : κ → Finset ι) (a : κ → ℝ) |
| (hS : ∀ i, (S i).Nonempty → T.IsSegment (S i)) |
| (hd : Pairwise (fun i j => Disjoint (S i) (S j))) : |
| ‖T.combine S a‖ ≤ Real.sqrt (∑ i, (a i) ^ 2) := by |
| apply ContinuousLinearMap.opNorm_le_bound _ (Real.sqrt_nonneg _) |
| intro u |
| induction u using UniformSpace.Completion.induction_on with |
| | hp => exact isClosed_le (by fun_prop) (by fun_prop) |
| | ih u => |
| rw [combine_coe, Real.norm_eq_abs, UniformSpace.Completion.norm_coe, norm_eq_primal] |
| have htest : Real.sqrt (∑ i, (∑ v ∈ S i, T.ofPrimal u v) ^ 2) ≤ |
| T.primalSeminorm (T.ofPrimal u) := by |
| exact (Real.sqrt_le_left (apply_nonneg _ _)).mpr |
| (T.test_energy_le_allow_empty S hS hd (T.ofPrimal u)) |
| calc |
| |∑ i, a i * (∑ v ∈ S i, T.ofPrimal u v)| ≤ |
| ∑ i, |a i * (∑ v ∈ S i, T.ofPrimal u v)| := Finset.abs_sum_le_sum_abs _ _ |
| _ = ∑ i, |a i| * |∑ v ∈ S i, T.ofPrimal u v| := by simp only [abs_mul] |
| _ ≤ Real.sqrt (∑ i, (a i) ^ 2) * |
| Real.sqrt (∑ i, (∑ v ∈ S i, T.ofPrimal u v) ^ 2) := by |
| simpa only [sq_abs] using Real.sum_mul_le_sqrt_mul_sqrt Finset.univ |
| (fun i => |a i|) (fun i => |∑ v ∈ S i, T.ofPrimal u v|) |
| _ ≤ _ := mul_le_mul_of_nonneg_left htest (Real.sqrt_nonneg _) |
|
|
| /-- A finite family of disjoint cones can be tested by independently maximizing |
| each cone's represented segment. This is the finite dual reconstruction bound. -/ |
| lemma norm_cone_mean_le {Ω κ : Type*} [Fintype Ω] [Nonempty Ω] [Fintype κ] |
| (S : Ω → κ → Finset ι) (a : Ω → κ → ℝ) (w : Ω → ℝ) (hw : ∀ ω, 0 ≤ w ω) |
| (hS : ∀ ω g, (S ω g).Nonempty → T.IsSegment (S ω g)) |
| (hd : ∀ g h, g ≠ h → ∀ ω ν, Disjoint (S ω g) (S ν h)) : |
| ‖∑ ω, w ω • T.combine (S ω) (a ω)‖ ≤ |
| Real.sqrt (∑ g, (∑ ω, w ω * |a ω g|) ^ 2) := by |
| classical |
| apply ContinuousLinearMap.opNorm_le_bound _ (Real.sqrt_nonneg _) |
| intro u |
| induction u using UniformSpace.Completion.induction_on with |
| | hp => exact isClosed_le (by fun_prop) (by fun_prop) |
| | ih u => |
| rw [sum_apply] |
| simp only [smul_apply, smul_eq_mul, combine_coe, Real.norm_eq_abs, |
| UniformSpace.Completion.norm_coe, norm_eq_primal] |
| choose idx hidx hmax using fun g : κ => Finset.exists_max_image Finset.univ |
| (fun ω => |∑ v ∈ S ω g, T.ofPrimal u v|) Finset.univ_nonempty |
| let t : κ → ℝ := fun g => |∑ v ∈ S (idx g) g, T.ofPrimal u v| |
| have ht (ω : Ω) (g : κ) : |∑ v ∈ S ω g, T.ofPrimal u v| ≤ t g := |
| hmax g ω (Finset.mem_univ _) |
| have htest : Real.sqrt (∑ g, t g ^ 2) ≤ T.primalSeminorm (T.ofPrimal u) := by |
| apply (Real.sqrt_le_left (apply_nonneg _ _)).2 |
| simpa only [t, sq_abs] using T.test_energy_le_allow_empty |
| (fun g => S (idx g) g) (fun g => hS (idx g) g) |
| (fun {g h} hgh => hd g h hgh (idx g) (idx h)) (T.ofPrimal u) |
| calc |
| |∑ ω, w ω * ∑ g, a ω g * (∑ v ∈ S ω g, T.ofPrimal u v)| ≤ |
| ∑ ω, |w ω * ∑ g, a ω g * (∑ v ∈ S ω g, T.ofPrimal u v)| := |
| Finset.abs_sum_le_sum_abs _ _ |
| _ = ∑ ω, w ω * |∑ g, a ω g * (∑ v ∈ S ω g, T.ofPrimal u v)| := by |
| simp only [abs_mul, abs_of_nonneg (hw _)] |
| _ ≤ ∑ ω, w ω * (∑ g, |a ω g| * t g) := by |
| apply Finset.sum_le_sum |
| intro ω _ |
| apply mul_le_mul_of_nonneg_left _ (hw ω) |
| calc |
| _ ≤ ∑ g, |a ω g * (∑ v ∈ S ω g, T.ofPrimal u v)| := Finset.abs_sum_le_sum_abs _ _ |
| _ ≤ _ := by |
| apply Finset.sum_le_sum |
| intro g _ |
| rw [abs_mul] |
| exact mul_le_mul_of_nonneg_left (ht ω g) (abs_nonneg _) |
| _ = ∑ g, (∑ ω, w ω * |a ω g|) * t g := by |
| simp_rw [Finset.mul_sum, Finset.sum_mul] |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro g _ |
| apply Finset.sum_congr rfl |
| intro ω _ |
| ring |
| _ ≤ Real.sqrt (∑ g, (∑ ω, w ω * |a ω g|) ^ 2) * Real.sqrt (∑ g, t g ^ 2) := |
| Real.sum_mul_le_sqrt_mul_sqrt _ _ _ |
| _ ≤ _ := mul_le_mul_of_nonneg_left htest (Real.sqrt_nonneg _) |
|
|
| lemma combine_smul {κ : Type*} [Fintype κ] (S : κ → Finset ι) (a : κ → ℝ) (c : ℝ) : |
| T.combine S (fun i => c * a i) = c • T.combine S a := by |
| simp only [combine, mul_smul, Finset.smul_sum] |
|
|
| lemma headDual_unit (H : Finset ι) (x : T.Dual) (v : ι) : |
| T.headDual H x (T.unitVector v) = if v ∈ H then x (T.unitVector v) else 0 := by |
| classical |
| simp [headDual_apply, coordinate_unitVector, mul_ite, Finset.sum_ite_eq] |
|
|
| lemma headDual_eq_self {H : Finset ι} {x : T.Dual} |
| (hx : ∀ v, v ∉ H → x (T.unitVector v) = 0) : T.headDual H x = x := by |
| apply T.dual_ext |
| intro v |
| rw [headDual_unit] |
| split_ifs with hv |
| · rfl |
| · exact (hx v hv).symm |
|
|
| lemma headDual_finite_apply {H : Finset ι} (x : T.Dual) (u : T.Primal) |
| (hu : (T.ofPrimal u).support ⊆ H) : |
| T.headDual H x (u : T.JamesSpace) = x (u : T.JamesSpace) := by |
| rw [dual_coe_apply, dual_coe_apply] |
| apply Finset.sum_congr rfl |
| intro v hv |
| rw [headDual_unit, ite_eq_left (hu hv)] |
|
|
| lemma headDual_commute (H K : Finset ι) (x : T.Dual) : |
| T.headDual H (T.headDual K x) = T.headDual K (T.headDual H x) := by |
| apply T.dual_ext |
| intro v |
| simp only [headDual_unit] |
| split_ifs <;> rfl |
| |
| lemma tailDual_headDual (H K : Finset ι) (x : T.Dual) : |
| T.tailDual H (T.headDual K x) = T.headDual K (T.tailDual H x) := by |
| rw [tailDual_apply, tailDual_apply, map_sub, headDual_commute] |
|
|
| /-- The array representing an arbitrary completed vector's finite head. -/ |
| def headArray (H : Finset ι) (u : T.JamesSpace) : ι →₀ ℝ := |
| ∑ v ∈ H, T.coordinate v u • Finsupp.single v 1 |
|
|
| lemma headArray_outside (H : Finset ι) (u : T.JamesSpace) {v : ι} (hv : v ∉ H) : |
| T.headArray H u v = 0 := by |
| classical |
| simp [headArray, Finsupp.finsetSum_apply, Finsupp.single_apply, hv, |
| Finset.sum_ite_eq'] |
|
|
| lemma finiteEmbedding_headArray (H : Finset ι) (u : T.JamesSpace) : |
| T.finiteEmbedding (T.headArray H u) = T.headPrimal H u := by |
| simp only [headArray, map_sum, map_smul, finiteEmbedding_single, one_smul, |
| headPrimal_apply] |
|
|
| lemma headDual_segment (H S : Finset ι) : |
| T.headDual H (T.segmentFunctional S) = T.segmentFunctional (S.filter (· ∈ H)) := by |
| apply T.dual_ext |
| intro v |
| rw [headDual_unit, segmentFunctional_unit, segmentFunctional_unit] |
| simp only [Finset.mem_filter] |
| split_ifs <;> simp_all |
| |
| lemma tailDual_segment (H S : Finset ι) : |
| T.tailDual H (T.segmentFunctional S) = T.segmentFunctional (S.filter (· ∉ H)) := by |
| apply T.dual_ext |
| intro v |
| simp only [tailDual_apply, sub_apply, headDual_unit, |
| segmentFunctional_unit, Finset.mem_filter] |
| split_ifs <;> simp_all |
| |
| lemma headDual_combine {κ : Type*} [Fintype κ] (H : Finset ι) (S : κ → Finset ι) (a : κ → ℝ) : |
| T.headDual H (T.combine S a) = T.combine (fun i => (S i).filter (· ∈ H)) a := by |
| simp only [combine, map_sum, map_smul, headDual_segment] |
|
|
| lemma tailDual_combine {κ : Type*} [Fintype κ] (H : Finset ι) (S : κ → Finset ι) (a : κ → ℝ) : |
| T.tailDual H (T.combine S a) = T.combine (fun i => (S i).filter (· ∉ H)) a := by |
| simp only [combine, map_sum, map_smul, tailDual_segment] |
|
|
| abbrev Coordinates (_T : SegmentSystem ι) (K : Finset ι) := K → ℝ |
|
|
| def coordinateTest (K : Finset ι) (a : T.Coordinates K) : ι →₀ ℝ := |
| Finsupp.onFinset K (fun v => if h : v ∈ K then a ⟨v, h⟩ else 0) (by |
| intro v hv |
| by_contra h |
| simp only [dite_eq_right h] at hv |
| exact hv rfl) |
|
|
| @[simp] lemma coordinateTest_mem (K : Finset ι) (a : T.Coordinates K) (v : K) : |
| T.coordinateTest K a v.val = a v := by simp [coordinateTest] |
|
|
| lemma coordinateTest_not_mem (K : Finset ι) (a : T.Coordinates K) |
| {v : ι} (hv : v ∉ K) : T.coordinateTest K a v = 0 := by simp [coordinateTest, hv] |
|
|
| lemma coordinateTest_sum (K S : Finset ι) (a : T.Coordinates K) (hSK : S ⊆ K) : |
| (∑ v ∈ S, T.coordinateTest K a v) = |
| ∑ v : K, if v.val ∈ S then a v else 0 := by |
| classical |
| have hfilter : K.filter (· ∈ S) = S := by ext v; simp; exact fun h => hSK h |
| calc |
| _ = ∑ v ∈ K, if v ∈ S then T.coordinateTest K a v else 0 := by |
| rw [← Finset.sum_filter, hfilter] |
| _ = ∑ v : K, if v.val ∈ S then T.coordinateTest K a v.val else 0 := |
| (Finset.sum_coe_sort K _).symm |
| _ = _ := by simp only [coordinateTest_mem] |
|
|
| lemma functional_pi_formula (K : Finset ι) (f : T.Coordinates K →L[ℝ] ℝ) |
| (z : T.Coordinates K) : f z = ∑ v : K, z v * f (Pi.single v 1) := by |
| classical |
| have hz : z = ∑ v : K, z v • (Pi.single v 1 : T.Coordinates K) := by |
| ext w |
| simp [Pi.single_apply, Finset.sum_apply, mul_ite, Finset.sum_ite_eq] |
| conv_lhs => rw [hz] |
| simp only [map_sum, map_smul, smul_eq_mul] |
|
|
| /-- All local disjoint families. This type is finite even when the tree branches |
| countably, because each member is a family of subsets of the fixed head K. -/ |
| def LocalFamily (K : Finset ι) := {F : Finset (Finset ι) // |
| F ∈ K.powerset.powerset ∧ (∀ S ∈ F, T.IsSegment S) ∧ (F : Set (Finset ι)).Pairwise Disjoint} |
|
|
| instance localFamilyFintype (K : Finset ι) : Fintype (T.LocalFamily K) := |
| Fintype.subtype (K.powerset.powerset.filter |
| (fun F => (∀ S ∈ F, T.IsSegment S) ∧ (F : Set (Finset ι)).Pairwise Disjoint)) (by intro F; simp) |
| |
| abbrev LocalIndex {K : Finset ι} (F : T.LocalFamily K) := ↥F.val |
|
|
| lemma localFamily_subset {K : Finset ι} (F : T.LocalFamily K) (S : T.LocalIndex F) : |
| S.val ⊆ K := |
| Finset.mem_powerset.mp ((Finset.mem_powerset.mp F.property.1) S.property) |
|
|
| lemma localFamily_allowed {K : Finset ι} (F : T.LocalFamily K) (S : T.LocalIndex F) : |
| T.IsSegment S.val := F.property.2.1 _ S.property |
|
|
| lemma localFamily_disjoint {K : Finset ι} (F : T.LocalFamily K) : |
| Pairwise (fun S U : T.LocalIndex F => Disjoint S.val U.val) := by |
| intro S U hne |
| exact F.property.2.2 S.property U.property (fun h => hne (Subtype.ext h)) |
|
|
| variable {T} |
|
|
| def LocalFamily.asFamily {K : Finset ι} (F : T.LocalFamily K) : T.Family where |
| n := Fintype.card (T.LocalIndex F) |
| seg i := ((Fintype.equivFin (T.LocalIndex F)).symm i).val |
| allowed i := T.localFamily_allowed F _ |
| disjoint := by |
| intro i j hij |
| apply T.localFamily_disjoint F |
| exact fun h => hij ((Fintype.equivFin (T.LocalIndex F)).symm.injective h) |
|
|
| def LocalFamily.reindex {K : Finset ι} (F : T.LocalFamily K) |
| (a : EuclideanSpace ℝ (T.LocalIndex F)) : Fin F.asFamily.n → ℝ := |
| fun i => a ((Fintype.equivFin (T.LocalIndex F)).symm i) |
|
|
| lemma LocalFamily.reindex_energy {K : Finset ι} (F : T.LocalFamily K) |
| (a : EuclideanSpace ℝ (T.LocalIndex F)) : |
| (∑ i, F.reindex a i ^ 2) = ‖a‖ ^ 2 := by |
| rw [EuclideanSpace.norm_sq_eq] |
| simp only [Real.norm_eq_abs, sq_abs] |
| exact (Fintype.equivFin (T.LocalIndex F)).symm.sum_comp (fun i => a i ^ 2) |
|
|
| lemma LocalFamily.reindex_combine {K : Finset ι} (F : T.LocalFamily K) |
| (a : EuclideanSpace ℝ (T.LocalIndex F)) : |
| T.combine F.asFamily.seg (F.reindex a) = T.combine (fun S : T.LocalIndex F => S.val) a := by |
| unfold combine |
| exact (Fintype.equivFin (T.LocalIndex F)).symm.sum_comp |
| (fun S => a S • T.segmentFunctional S.val) |
|
|
| lemma LocalFamily.asFamily_subset {K : Finset ι} (F : T.LocalFamily K) |
| (i : Fin F.asFamily.n) : F.asFamily.seg i ⊆ K := |
| T.localFamily_subset F _ |
|
|
| variable (T) |
|
|
| /-- Local atoms as linear images of Euclidean blocks. -/ |
| def localMap {K : Finset ι} (F : T.LocalFamily K) : |
| EuclideanSpace ℝ (T.LocalIndex F) →ₗ[ℝ] T.Coordinates K where |
| toFun a v := ∑ S : T.LocalIndex F, if v.val ∈ S.val then a S else 0 |
| map_add' a b := by |
| ext v |
| simp only [Pi.add_apply, PiLp.add_apply] |
| rw [← Finset.sum_add_distrib] |
| apply Finset.sum_congr rfl |
| intro S _ |
| split_ifs <;> simp |
| map_smul' a b := by |
| ext v |
| simp only [Pi.smul_apply, smul_eq_mul, RingHom.id_apply] |
| rw [Finset.mul_sum] |
| apply Finset.sum_congr rfl |
| intro S _ |
| split_ifs <;> simp |
| |
| lemma localMap_combine {K : Finset ι} (F : T.LocalFamily K) |
| (a : EuclideanSpace ℝ (T.LocalIndex F)) (v : K) : |
| T.localMap F a v = T.combine (fun S : T.LocalIndex F => S.val) a (T.unitVector v.val) := by |
| simp [localMap, combine_unit] |
|
|
| lemma functional_localMap {K : Finset ι} (F : T.LocalFamily K) |
| (f : T.Coordinates K →L[ℝ] ℝ) (a : EuclideanSpace ℝ (T.LocalIndex F)) : |
| f (T.localMap F a) = ∑ S : T.LocalIndex F, a S * |
| (∑ v ∈ S.val, T.coordinateTest K (fun w => f (Pi.single w 1)) v) := by |
| classical |
| rw [T.functional_pi_formula] |
| simp only [localMap, LinearMap.coe_mk, AddHom.coe_mk, Finset.sum_mul] |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro S _ |
| rw [T.coordinateTest_sum K S.val _ (T.localFamily_subset F S), Finset.mul_sum] |
| apply Finset.sum_congr rfl |
| intro v _ |
| split_ifs <;> simp |
| |
| lemma finiteEmbedding_norm (p : ι →₀ ℝ) : |
| ‖T.finiteEmbedding p‖ = T.primalSeminorm p := by |
| rw [finiteEmbedding_apply, UniformSpace.Completion.norm_coe] |
| rfl |
|
|
| lemma coordinateTest_pairing (K : Finset ι) (a : T.Coordinates K) (x : T.Dual) : |
| x (T.finiteEmbedding (T.coordinateTest K a)) = |
| ∑ v : K, a v * x (T.unitVector v.val) := by |
| classical |
| rw [finiteEmbedding_apply, dual_coe_apply] |
| change (∑ v ∈ (T.coordinateTest K a).support, |
| T.coordinateTest K a v * x (T.unitVector v)) = _ |
| have hs : (T.coordinateTest K a).support ⊆ K := by |
| intro v hv |
| by_contra hn |
| exact Finsupp.mem_support_iff.mp hv (T.coordinateTest_not_mem K a hn) |
| calc |
| _ = ∑ v ∈ K, T.coordinateTest K a v * x (T.unitVector v) := by |
| apply Finset.sum_subset hs |
| intro v _ hv |
| rw [Finsupp.notMem_support_iff.mp hv, zero_mul] |
| _ = ∑ v : K, T.coordinateTest K a v.val * x (T.unitVector v.val) := |
| (Finset.sum_coe_sort K _).symm |
| _ = _ := by simp only [coordinateTest_mem] |
|
|
| lemma local_energy_le_of_functional_bound {K : Finset ι} (F : T.LocalFamily K) |
| (f : T.Coordinates K →L[ℝ] ℝ) {u : ℝ} (hu : 0 ≤ u) |
| (hf : ∀ a : EuclideanSpace ℝ (T.LocalIndex F), ‖a‖ ≤ 1 → |
| f (T.localMap F a) ≤ u) : |
| (∑ S : T.LocalIndex F, (∑ v ∈ S.val, |
| T.coordinateTest K (fun w => f (Pi.single w 1)) v) ^ 2) ≤ u ^ 2 := by |
| classical |
| let b : EuclideanSpace ℝ (T.LocalIndex F) := WithLp.toLp 2 |
| (fun S => ∑ v ∈ S.val, T.coordinateTest K (fun w => f (Pi.single w 1)) v) |
| have he : (∑ S : T.LocalIndex F, (∑ v ∈ S.val, |
| T.coordinateTest K (fun w => f (Pi.single w 1)) v) ^ 2) = ‖b‖ ^ 2 := by |
| rw [EuclideanSpace.norm_sq_eq] |
| simp only [b, Real.norm_eq_abs, sq_abs] |
| rw [he] |
| apply (sq_le_sq₀ (norm_nonneg _) hu).2 |
| by_cases hb : b = 0 |
| · simpa only [hb, norm_zero] using hu |
| have hn : ‖b‖ ≠ 0 := norm_ne_zero_iff.mpr hb |
| have hbn : ‖‖b‖⁻¹ • b‖ ≤ 1 := by |
| rw [norm_smul, Real.norm_eq_abs, abs_of_nonneg (inv_nonneg.mpr (norm_nonneg _)), |
| inv_mul_cancel₀ hn] |
| have h := hf (‖b‖⁻¹ • b) hbn |
| rw [T.functional_localMap] at h |
| have hsum : (∑ S : T.LocalIndex F, (‖b‖⁻¹ • b) S * |
| (∑ v ∈ S.val, T.coordinateTest K (fun w => f (Pi.single w 1)) v)) = ‖b‖ := by |
| simp only [PiLp.smul_apply, smul_eq_mul] |
| change (∑ S, ‖b‖⁻¹ * b S * b S) = ‖b‖ |
| simp_rw [mul_assoc, ← sq] |
| rw [← Finset.mul_sum] |
| have hb2 : (∑ S, b S ^ 2) = ‖b‖ ^ 2 := by |
| rw [EuclideanSpace.norm_sq_eq] |
| simp only [Real.norm_eq_abs, sq_abs] |
| rw [hb2, sq, ← mul_assoc, inv_mul_cancel₀ hn, one_mul] |
| rwa [hsum] at h |
|
|
| /-- An l1-of-Euclidean-block ball gives a compact convex parameter space for all |
| finite atomic combinations. No Caratheodory theorem is assumed. -/ |
| abbrev Coefficients (K : Finset ι) := |
| (F : T.LocalFamily K) → EuclideanSpace ℝ (T.LocalIndex F) |
|
|
| def totalMap (K : Finset ι) : T.Coefficients K →ₗ[ℝ] T.Coordinates K where |
| toFun c := ∑ F, T.localMap F (c F) |
| map_add' c d := by simp only [Pi.add_apply, map_add, Finset.sum_add_distrib] |
| map_smul' a c := by simp only [Pi.smul_apply, map_smul, Finset.smul_sum, RingHom.id_apply] |
|
|
| def coefficientBall (K : Finset ι) (R : ℝ) : Set (T.Coefficients K) := |
| {c | ∑ F, ‖c F‖ ≤ R} |
|
|
| lemma coefficientBall_compact (K : Finset ι) {R : ℝ} (hR : 0 ≤ R) : |
| IsCompact (T.coefficientBall K R) := by |
| apply (isCompact_closedBall (0 : T.Coefficients K) R).of_isClosed_subset |
| · exact isClosed_le (by fun_prop) continuous_const |
| · intro c hc |
| simp only [Metric.mem_closedBall, dist_zero_right] |
| apply (pi_norm_le_iff_of_nonneg hR).mpr |
| intro F |
| exact (Finset.single_le_sum (fun G _ => norm_nonneg (c G)) (Finset.mem_univ F)).trans hc |
|
|
| lemma coefficientBall_convex (K : Finset ι) (R : ℝ) : |
| Convex ℝ (T.coefficientBall K R) := by |
| intro c hc d hd a b ha hb hab |
| change ∑ F, ‖a • c F + b • d F‖ ≤ R |
| calc |
| _ ≤ ∑ F, (a * ‖c F‖ + b * ‖d F‖) := by |
| apply Finset.sum_le_sum |
| intro F _ |
| calc |
| ‖a • c F + b • d F‖ ≤ ‖a • c F‖ + ‖b • d F‖ := norm_add_le _ _ |
| _ = _ := by rw [norm_smul, norm_smul, Real.norm_eq_abs, Real.norm_eq_abs, |
| abs_of_nonneg ha, abs_of_nonneg hb] |
| _ = a * (∑ F, ‖c F‖) + b * (∑ F, ‖d F‖) := by |
| rw [Finset.sum_add_distrib, ← Finset.mul_sum, ← Finset.mul_sum] |
| _ ≤ a * R + b * R := add_le_add (mul_le_mul_of_nonneg_left hc ha) |
| (mul_le_mul_of_nonneg_left hd hb) |
| _ = R := by rw [← add_mul, hab, one_mul] |
|
|
| lemma totalMap_single (K : Finset ι) (F : T.LocalFamily K) |
| (a : EuclideanSpace ℝ (T.LocalIndex F)) : |
| T.totalMap K (Pi.single F a) = T.localMap F a := by |
| classical |
| rw [totalMap, LinearMap.coe_mk, AddHom.coe_mk, Finset.sum_eq_single F] |
| · rw [Pi.single_eq_same] |
| · intro G _ hGF |
| rw [Pi.single_eq_of_ne hGF, map_zero] |
| · simp |
|
|
| lemma single_mem_coefficientBall (K : Finset ι) (F : T.LocalFamily K) |
| (a : EuclideanSpace ℝ (T.LocalIndex F)) {R : ℝ} (ha : ‖a‖ ≤ R) : |
| Pi.single F a ∈ T.coefficientBall K R := by |
| classical |
| change ∑ G, ‖(Pi.single F a : T.Coefficients K) G‖ ≤ R |
| rw [Finset.sum_eq_single F] |
| · simpa only [Pi.single_eq_same] using ha |
| · intro G _ hGF |
| rw [Pi.single_eq_of_ne hGF, norm_zero] |
| · simp |
|
|
| /-- A represented atom includes its coefficients, rather than just its value. -/ |
| structure Atom (R : ℝ) where |
| family : T.Family |
| coeff : Fin family.n → ℝ |
| energy_le : (∑ i, coeff i ^ 2) ≤ R ^ 2 |
|
|
| def Atom.value {T : SegmentSystem ι} {R : ℝ} (a : T.Atom R) : T.Dual := |
| T.combine a.family.seg a.coeff |
|
|
| /-- Finite convex atom laws, with explicit probabilities and mean. -/ |
| structure AtomLaw (Ω : Type*) [Fintype Ω] (R : ℝ) (x : T.Dual) where |
| atom : Ω → T.Atom R |
| weight : Ω → ℝ |
| nonneg : ∀ ω, 0 ≤ weight ω |
| sum_one : ∑ ω, weight ω = 1 |
| mean : (∑ ω, weight ω • (atom ω).value) = x |
|
|
| def zeroAtom (R : ℝ) : T.Atom R where |
| family := { |
| n := 0 |
| seg := Fin.elim0 |
| allowed := fun i => Fin.elim0 i |
| disjoint := fun {i} => Fin.elim0 i } |
| coeff := Fin.elim0 |
| energy_le := by simpa using sq_nonneg R |
|
|
| @[simp] lemma zeroAtom_value (R : ℝ) : (T.zeroAtom R).value = 0 := by |
| change (∑ i : Fin 0, (Fin.elim0 i : ℝ) • T.segmentFunctional (Fin.elim0 i)) = 0 |
| exact Finset.sum_eq_zero (fun i _ => Fin.elim0 i) |
|
|
| /-- Normalize a local block to radius R. A zero block stays zero. -/ |
| def blockAtom {K : Finset ι} (F : T.LocalFamily K) |
| (a : EuclideanSpace ℝ (T.LocalIndex F)) {R : ℝ} (hR : 0 ≤ R) : T.Atom R where |
| family := F.asFamily |
| coeff := F.reindex ((R / ‖a‖) • a) |
| energy_le := by |
| rw [F.reindex_energy, norm_smul, Real.norm_eq_abs, |
| abs_of_nonneg (div_nonneg hR (norm_nonneg _))] |
| by_cases ha : a = 0 |
| · simp [ha, sq_nonneg] |
| · have hn : ‖a‖ ≠ 0 := norm_ne_zero_iff.mpr ha |
| rw [div_mul_cancel₀ _ hn] |
|
|
| lemma blockAtom_value {K : Finset ι} (F : T.LocalFamily K) |
| (a : EuclideanSpace ℝ (T.LocalIndex F)) {R : ℝ} (hR : 0 ≤ R) : |
| (T.blockAtom F a hR).value = (R / ‖a‖) • T.combine (fun S : T.LocalIndex F => S.val) a := by |
| rw [Atom.value, blockAtom, F.reindex_combine] |
| simp only [combine, PiLp.smul_apply, smul_eq_mul, mul_smul, Finset.smul_sum] |
|
|
| lemma weighted_blockAtom {K : Finset ι} (F : T.LocalFamily K) |
| (a : EuclideanSpace ℝ (T.LocalIndex F)) {R : ℝ} (hR : 0 < R) : |
| (‖a‖ / R) • (T.blockAtom F a hR.le).value = |
| T.combine (fun S : T.LocalIndex F => S.val) a := by |
| rw [T.blockAtom_value, smul_smul] |
| by_cases ha : a = 0 |
| · simp [ha, combine] |
| · have hn : ‖a‖ ≠ 0 := norm_ne_zero_iff.mpr ha |
| have he : ‖a‖ / R * (R / ‖a‖) = 1 := by field_simp |
| rw [he, one_smul] |
|
|
| lemma representation_combine {K : Finset ι} (x : T.Dual) (c : T.Coefficients K) |
| (hc : T.totalMap K c = fun v : K => x (T.unitVector v.val)) : |
| (∑ F, T.combine (fun S : T.LocalIndex F => S.val) (c F)) = T.headDual K x := by |
| apply T.dual_ext |
| intro v |
| simp only [sum_apply, headDual_unit] |
| by_cases hv : v ∈ K |
| · rw [ite_eq_left hv] |
| have he := congrFun hc ⟨v,hv⟩ |
| change (∑ F, T.localMap F (c F)) ⟨v,hv⟩ = _ at he |
| simp only [Finset.sum_apply, localMap_combine] at he |
| exact he |
| · rw [ite_eq_right hv] |
| apply Finset.sum_eq_zero |
| intro F _ |
| rw [combine_unit] |
| apply Finset.sum_eq_zero |
| intro S _ |
| rw [ite_eq_right (fun h => hv (T.localFamily_subset F S h))] |
|
|
| /-- Every block decomposition is a finite probability law, with its unused mass |
| placed on the zero atom. -/ |
| def lawOfCoefficients {K : Finset ι} (x : T.Dual) {R : ℝ} (hR : 0 < R) |
| (c : T.Coefficients K) (hc : c ∈ T.coefficientBall K R) |
| (hce : T.totalMap K c = fun v : K => x (T.unitVector v.val)) : |
| T.AtomLaw (Option (T.LocalFamily K)) R (T.headDual K x) where |
| atom ω := match ω with |
| | none => T.zeroAtom R |
| | some F => T.blockAtom F (c F) hR.le |
| weight ω := match ω with |
| | none => 1 - ∑ F, ‖c F‖ / R |
| | some F => ‖c F‖ / R |
| nonneg := by |
| intro ω |
| cases ω with |
| | none => |
| dsimp |
| rw [← Finset.sum_div] |
| exact sub_nonneg.mpr ((div_le_one hR).mpr hc) |
| | some F => exact div_nonneg (norm_nonneg _) hR.le |
| sum_one := by |
| rw [Fintype.sum_option] |
| dsimp |
| ring |
| mean := by |
| rw [Fintype.sum_option] |
| simp only [zeroAtom_value, smul_zero, zero_add] |
| simp_rw [T.weighted_blockAtom _ _ hR] |
| exact T.representation_combine x c hce |
|
|
| lemma lawOfCoefficients_subset {K : Finset ι} (x : T.Dual) {R : ℝ} (hR : 0 < R) |
| (c : T.Coefficients K) (hc : c ∈ T.coefficientBall K R) |
| (hce : T.totalMap K c = fun v : K => x (T.unitVector v.val)) |
| (ω : Option (T.LocalFamily K)) |
| (i : Fin ((T.lawOfCoefficients x hR c hc hce).atom ω).family.n) : |
| ((T.lawOfCoefficients x hR c hc hce).atom ω).family.seg i ⊆ K := by |
| cases ω with |
| | none => exact Fin.elim0 i |
| | some F => exact F.asFamily_subset i |
|
|
| structure BipolarLaw (Ω : Type*) [Fintype Ω] (R : ℝ) (x y : T.Dual) |
| extends T.AtomLaw Ω R x where |
| sign : Ω → ℝ |
| abs_sign : ∀ ω, |sign ω| = 1 |
| signed_mean : (∑ ω, weight ω • (sign ω • (atom ω).value)) = y |
|
|
| def pairLaws {Ω : Type*} [Fintype Ω] {R : ℝ} {x y : T.Dual} |
| (Lp : T.AtomLaw Ω R (x+y)) (Lm : T.AtomLaw Ω R (x-y)) : |
| T.BipolarLaw (Bool × Ω) R x y where |
| atom ω := if ω.1 then Lp.atom ω.2 else Lm.atom ω.2 |
| weight ω := (1/2 : ℝ) * (if ω.1 then Lp.weight ω.2 else Lm.weight ω.2) |
| nonneg := by |
| rintro ⟨b,ω⟩ |
| cases b <;> exact mul_nonneg (by norm_num) (by first | exact Lm.nonneg ω | exact Lp.nonneg ω) |
| sum_one := by |
| simp only [Fintype.sum_prod_type, Fintype.sum_bool, Bool.false_eq_true, ↓reduceIte] |
| rw [← Finset.mul_sum, ← Finset.mul_sum, Lp.sum_one, Lm.sum_one] |
| norm_num |
| mean := by |
| simp only [Fintype.sum_prod_type, Fintype.sum_bool, Bool.false_eq_true, ↓reduceIte, |
| mul_smul, ← Finset.smul_sum] |
| rw [Lp.mean, Lm.mean] |
| module |
| sign ω := if ω.1 then 1 else -1 |
| abs_sign := by rintro ⟨b,ω⟩; cases b <;> norm_num |
| signed_mean := by |
| apply ContinuousLinearMap.ext |
| intro u |
| have hp := congrArg (fun f : T.Dual => f u) Lp.mean |
| have hm := congrArg (fun f : T.Dual => f u) Lm.mean |
| simp only [sum_apply, smul_apply, smul_eq_mul, add_apply] at hp |
| simp only [sum_apply, smul_apply, smul_eq_mul, sub_apply] at hm |
| simp only [add_apply, sum_apply, smul_apply, smul_eq_mul, Fintype.sum_prod_type, |
| Fintype.sum_bool, Bool.false_eq_true, ↓reduceIte] |
| have hcoeff (ω : Ω) : (1/2:ℝ) * Lm.weight ω * (-1 * (Lm.atom ω).value u) = |
| -(1/2:ℝ) * (Lm.weight ω * (Lm.atom ω).value u) := by ring |
| simp_rw [hcoeff, one_mul, mul_assoc] |
| rw [← Finset.mul_sum, ← Finset.mul_sum, hp, hm] |
| ring |
|
|
| lemma pairLaws_subset {Ω : Type*} [Fintype Ω] {R : ℝ} {x y : T.Dual} |
| (Lp : T.AtomLaw Ω R (x+y)) (Lm : T.AtomLaw Ω R (x-y)) (K : Finset ι) |
| (hp : ∀ ω i, (Lp.atom ω).family.seg i ⊆ K) |
| (hm : ∀ ω i, (Lm.atom ω).family.seg i ⊆ K) : |
| ∀ ω i, ((T.pairLaws Lp Lm).atom ω).family.seg i ⊆ K := by |
| rintro ⟨b,ω⟩ i |
| cases b |
| · exact hm ω i |
| · exact hp ω i |
|
|
| /-- The norm-closed coordinate span, not the full infinite-tree dual. -/ |
| def CoordinatePredual : Submodule ℝ T.Dual := |
| (Submodule.span ℝ (Set.range T.coordinate)).topologicalClosure |
|
|
| lemma span_coordinates_finite_support {x : T.Dual} |
| (hx : x ∈ Submodule.span ℝ (Set.range T.coordinate)) : |
| ∃ S : Finset ι, ∀ v, v ∉ S → x (T.unitVector v)=0 := by |
| classical |
| induction hx using Submodule.span_induction with |
| | mem x hx => |
| obtain ⟨v,rfl⟩ := hx |
| refine ⟨{v}, ?_⟩ |
| intro w hw |
| simp only [Finset.mem_singleton] at hw |
| simp [coordinate_unitVector,hw] |
| | zero => exact ⟨∅, by simp⟩ |
| | add x y _ _ hx hy => |
| obtain ⟨S,hS⟩ := hx |
| obtain ⟨U,hU⟩ := hy |
| refine ⟨S ∪ U, ?_⟩ |
| intro v hv |
| have hvS : v ∉ S := fun h => hv (Finset.mem_union_left _ h) |
| have hvU : v ∉ U := fun h => hv (Finset.mem_union_right _ h) |
| simp only [add_apply,hS v hvS,hU v hvU,add_zero] |
| | smul a x _ hx => |
| obtain ⟨S,hS⟩ := hx |
| exact ⟨S, fun v hv => by simp only [smul_apply,hS v hv,smul_zero]⟩ |
|
|
| end SegmentSystem |
|
|
| end DiamondDistortion |
|
|
| end |
|
|
| end OAI |
|
|
