| import OAI.Combinatorics.PlanarL1.MainPersistence |
| import OAI.Combinatorics.PlanarL1.ScaleHistory |
| import OAI.Combinatorics.PlanarL1.SecondaryGain |
|
|
| namespace OAI |
|
|
|
|
| section |
|
|
| namespace PlanarL1.Columns.Model.SecondaryCell |
| open PlanarL1.Interpolation |
| variable {n : ℕ} {M : Model n} {J : Set ℝ} {root : Fin n} |
| variable (T : Point.RadialTree (M := M) (J := J) (root := root)) |
| variable (S : Finset (M.Point J root)) (old L : M.Point J root → ℝ) (ordinary : Bool) |
| lemma namedReplacement_eq_old_of_value (pc radius αo αh lo : ℝ) |
| (α : Point.RadialTree.Noise (n := n)) (x : M.Point J root) |
| (he : replacement T S old L ordinary pc radius αo αh lo α x=old x) : |
| namedReplacement T S old L ordinary pc radius αo αh lo α x=⟨0,old x⟩ := by |
| apply clippedNamed_eq_old_of_value rfl |
| exact (namedReplacement_value T S old L ordinary pc radius αo αh lo α x).trans he |
|
|
| lemma namedReplacement_boundary_ball (hS : S.Nonempty) (hOld : LipschitzWith 5 old) |
| (hL : LipschitzWith 1 L) (hζ : T.ζ = (1:ℝ)/10) |
| {pc radius αo : ℝ} (hr : 0 ≤ radius) (hαo : αo ≤ radius/1000) |
| (hδ : T.δ = (radius/1000)/8) {α : Point.RadialTree.Noise (n := n)} (hα : T.NoiseBounds α) |
| (hord : ordinary = true → ∀ x, L x ≤ old x) |
| (hadmit : ordinary = false → ∀ w ∈ S, ∀ x, dist w x = radius → pc-(65/100:ℝ)*radius ≤ old x) |
| (αh lo : ℝ) (x y : M.Point J root) {ρ : ℝ} |
| (hsmall : 18*ρ ≤ (199/1000:ℝ)*radius) |
| (hy : dist x y ≤ ρ) (hout : radius ≤ seedDistance S y) |
| (z : M.Point J root) (hz : dist x z ≤ ρ) (hin : seedDistance S z ≤ radius) : |
| namedReplacement T S old L ordinary pc radius αo αh lo α z=⟨0,old z⟩ := |
| namedReplacement_eq_old_of_value T S old L ordinary pc radius αo αh lo α z |
| (replacement_boundary_ball T S old L ordinary hS hOld hL hζ hr hαo hδ hα hord hadmit |
| αh lo x y hsmall hy hout z hz hin) |
| end PlanarL1.Columns.Model.SecondaryCell |
|
|
| namespace PlanarL1.Columns.Model.BState |
| open MeasureTheory PlanarL1.Interpolation |
| open scoped NNReal |
| attribute [local instance] Classical.propDecidable |
| variable {k : ℕ} {M : Model (k+1)} {κ : ℝ} {lam : ℝ≥0} |
| {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω} {S : BState M κ lam Ω μ} |
| namespace SecondaryBatch |
| variable (B : SecondaryBatch S) |
| lemma chosen_name (i : Fin (k+1)) (H : B.data.band) (a : B.NewIndex) |
| (ha : B.chosen i H.val a) : |
| (B.selected i H).name=familyName a.1 (a.2.val+1) := by |
| obtain ⟨hb,_,he⟩ := ha |
| exact congrArg NamedValue.name he |
| lemma newIndex_names_injective : Function.Injective (fun a : B.NewIndex => familyName a.1 (a.2.val+1)) := by |
| intro a b hab |
| obtain ⟨ha,hb⟩ := (familyName_inj a.1 b.1 (by omega) (by omega)).mp hab |
| rcases a with ⟨a,i⟩ |
| rcases b with ⟨b,j⟩ |
| dsimp only at ha hb |
| subst b |
| have he : i=j := Fin.ext (by omega) |
| subst j |
| rfl |
| lemma chosen_iff_name (i : Fin (k+1)) (H : B.data.band) (a : B.NewIndex) : |
| B.chosen i H.val a ↔ (B.selected i H).name=familyName a.1 (a.2.val+1) := by |
| constructor |
| · exact B.chosen_name i H a |
| · intro he |
| have hn : (B.selected i H).name≠0 := by rw [he]; exact familyName_ne_zero _ (by omega) |
| obtain ⟨b,hb⟩ := B.exists_chosen i H hn |
| have he' : b=a := B.newIndex_names_injective ((B.chosen_name i H b hb).symm.trans he) |
| exact he' ▸ hb |
| lemma choose_eq_of_name {i j : Fin (k+1)} (H T : B.data.band) |
| (hn : (B.selected i H).name=(B.selected j T).name) : |
| B.choose i H.val=B.choose j T.val := by |
| have he : B.chosen i H.val=B.chosen j T.val := by |
| funext a |
| exact propext ((B.chosen_iff_name i H a).trans (hn ▸ (B.chosen_iff_name j T a).symm)) |
| unfold choose |
| simp only [he] |
| lemma choose_none_of_old_name {i : Fin (k+1)} {H : ℝ} (hne : S.name i H≠B.index) : |
| B.choose i H=none := by |
| have hn : ¬∃ a, B.chosen i H a := by |
| rintro ⟨a,ha⟩ |
| exact hne (B.domain_name (B.mem_domain.mpr ⟨a.1,B.chosen_domain i H a ha⟩)) |
| exact dite_eq_right hn |
| end SecondaryBatch |
| namespace SecondaryLayer |
| variable (B : SecondaryLayer S) |
| lemma choose_eq {i j : Fin (k+1)} {H T : ℝ} |
| (he : ∀ a, (B.batch a).choose i H=(B.batch a).choose j T) : |
| B.choose i H=B.choose j T := by |
| have h : B.chosen i H=B.chosen j T := by |
| funext a |
| simp only [chosen,he a.1] |
| unfold choose |
| simp only [h] |
| lemma name_eq [SFinite μ] {i j : Fin (k+1)} {H T : ℝ} |
| (hold : S.name i H=S.name j T) (he : B.choose i H=B.choose j T) : |
| B.apply.name i H=B.apply.name j T := by |
| dsimp only [apply,BState.append,BState.lift] |
| rw [he,hold] |
| lemma name_eq_of_selected [SFinite μ] {i j : Fin (k+1)} {H T : ℝ} |
| (a : Fin (S.count+1)) (hH : H ∈ (B.batch a).data.band) (hT : T ∈ (B.batch a).data.band) |
| (hi : S.name i H=a) (hj : S.name j T=a) |
| (hn : ((B.batch a).selected i ⟨H,hH⟩).name=((B.batch a).selected j ⟨T,hT⟩).name) : |
| B.apply.name i H=B.apply.name j T := by |
| apply B.name_eq (hi.trans hj.symm) |
| apply B.choose_eq |
| intro b |
| by_cases hb : b=a |
| · subst b |
| exact (B.batch a).choose_eq_of_name _ _ hn |
| · rw [(B.batch b).choose_none_of_old_name (by simpa only [hi,B.same_index] using Ne.symm hb), |
| (B.batch b).choose_none_of_old_name (by simpa only [hj,B.same_index] using Ne.symm hb)] |
| end SecondaryLayer |
| end PlanarL1.Columns.Model.BState |
|
|
| end |
|
|
|
|
|
|
| section |
|
|
| namespace PlanarL1.Columns.Model.RetainedSelection |
| open Parameters |
| variable {k : ℕ} {M : Model (k+1)} {q p L U : ℝ} |
| namespace Block |
| variable (b : Block (M := M) q p L U) |
| / |
| only in this very processed broad/component/narrow block. -/ |
| lemma eq_of_path_small (d : Block (M := M) q p L U) |
| (c : M.Point (BandTrees.band broad b.lower) (BandTrees.root M broad b.lower b.1.2)) |
| (e : M.Point (BandTrees.band broad d.lower) (BandTrees.root M broad d.lower d.1.2)) |
| (hc : c.height ∈ BandTrees.band narrow b.lower₂) |
| (hd : c.height ∈ BandTrees.band narrow d.lower₂) |
| {ρ τ : ℝ} (hρ : 0≤ρ) (hτ : 0≤τ) |
| (hp : Tiling.Padded a₁ q c.height ρ) |
| (hn : Tiling.Padded a₂ p c.height τ) |
| (path : M.Path (BandTrees.band narrow d.lower₂) c.column e.column) : b=d := by |
| have hNb : b.2.val.val=Tiling.index a₂ p c.height := |
| Tiling.unique_band_of_padded interpolationB.2.1 hτ hn (b.narrow_eq ▸ hc) |
| have hNd : d.2.val.val=Tiling.index a₂ p c.height := |
| Tiling.unique_band_of_padded interpolationB.2.1 hτ hn (d.narrow_eq ▸ hd) |
| have hBb : b.1.1.val=Tiling.index a₁ q c.height := |
| Tiling.unique_band_of_padded interpolationA.2.1 hρ hp (b.broad_eq ▸ c.inBand) |
| have hBd : d.1.1.val=Tiling.index a₁ q c.height := |
| Tiling.unique_band_of_padded interpolationA.2.1 hρ hp (d.broad_eq ▸ d.sub hd) |
| have hB : b.1.1=d.1.1 := Subtype.ext (hBb.trans hBd.symm) |
| rcases b with ⟨⟨bi,bC⟩,bn⟩ |
| rcases d with ⟨⟨di,dC⟩,dn⟩ |
| dsimp only at hB |
| subst di |
| have hC : bC=dC := by |
| have hr := c.reachable.trans ((path.widen (Block.sub ⟨⟨bi,dC⟩,dn⟩)).word.reachable.trans e.reachable.symm) |
| have hm := SimpleGraph.ConnectedComponent.sound hr |
| have hb : (M.activeGraph (BandTrees.band broad (MainFamily.lower q L U bi))).connectedComponentMk |
| (BandTrees.root M broad (MainFamily.lower q L U bi) bC)=bC := BandTrees.root_mem _ _ _ _ |
| have hd' : (M.activeGraph (BandTrees.band broad (MainFamily.lower q L U bi))).connectedComponentMk |
| (BandTrees.root M broad (MainFamily.lower q L U bi) dC)=dC := BandTrees.root_mem _ _ _ _ |
| exact hb.symm.trans (hm.trans hd') |
| subst dC |
| have hN : bn=dn := Subtype.ext (Subtype.ext (hNb.trans hNd.symm)) |
| subst dn |
| rfl |
| end Block |
| end PlanarL1.Columns.Model.RetainedSelection |
|
|
| namespace PlanarL1.Columns.Model.RetainedSelection |
| open Parameters MeasureTheory |
| attribute [local instance] Classical.propDecidable |
| variable {k : ℕ} {M : Model (k+1)} {V Ω Ξ : Type*} |
| variable [Fintype V] [MeasurableSpace Ω] [MeasurableSpace Ξ] |
| variable {μ : Measure Ω} {ν : Measure Ξ} |
| variable (A : Ambient M) (SA : OrdinaryState M kappaA Ω μ) |
| variable (SB : BState M kappaB SecondaryGeometry.Group.lam Ξ ν) |
| variable (v : V → M.Point Set.univ A.root) |
| variable {L U : ℝ} (hv : ∀ x, (v x).height ∈ Set.Icc L U) |
| variable {q p : ℝ} {phaseD phaseG : MainFamily.BandComponent (M := M) q L U → ℝ} |
| variable (b : Block (M := M) q p L U) |
| variable (c : M.Point (BandTrees.band broad b.lower) (BandTrees.root M broad b.lower b.1.2)) |
|
|
| variable (hc : c.height ∈ BandTrees.band narrow b.lower₂) |
| variable {ρ τ : ℝ} (hρ : 0≤ρ) (hτ : 0≤τ) |
| variable (hp : Tiling.Padded a₁ q c.height ρ) (hn : Tiling.Padded a₂ p c.height τ) |
| include hc hρ hτ hp hn |
|
|
| lemma touch_block_small {i : GroupIndex A SA SB v hv (p := p) (phaseD := phaseD) (phaseG := phaseG)} |
| (h : Touch A SA SB v hv b c i) : i.1=b := by |
| obtain ⟨w,_,path,_⟩ := h.2 |
| exact (b.eq_of_path_small i.1 c (localSeeds A SA SB v hv (phaseD := phaseD) (phaseG := phaseG) i.1 w).point hc h.1 hρ hτ hp hn path).symm |
|
|
| noncomputable def localHit_small (i : Hits A SA SB v hv b c (phaseD := phaseD) (phaseG := phaseG)) : |
| SurvivingGroups.Hits (localSeeds A SA SB v hv (phaseD := phaseD) (phaseG := phaseG) b) c := by |
| have he := touch_block_small A SA SB v hv b c hc hρ hτ hp hn i.property |
| rcases i with ⟨⟨d,j⟩,hi⟩ |
| dsimp only at he |
| subst d |
| exact ⟨j,hi.2⟩ |
|
|
| lemma localHit_injective_small : Function.Injective |
| (localHit_small A SA SB v hv b c hc hρ hτ hp hn (phaseD := phaseD) (phaseG := phaseG)) := by |
| intro i j he |
| have hi := touch_block_small A SA SB v hv b c hc hρ hτ hp hn i.property |
| have hj := touch_block_small A SA SB v hv b c hc hρ hτ hp hn j.property |
| rcases i with ⟨⟨d,i⟩,hi'⟩ |
| rcases j with ⟨⟨e,j⟩,hj'⟩ |
| dsimp only at hi hj |
| subst d |
| subst e |
| have hraw : i=j := congrArg Subtype.val he |
| subst j |
| rfl |
|
|
| / |
| old identifiers are derived by the local packing theorem, not assumed. -/ |
| lemma touching_card_small : Fintype.card (Hits A SA SB v hv b c (phaseD := phaseD) (phaseG := phaseG))≤ |
| SurvivingGroups.packBound := by |
| let := SurvivingGroups.instFintypeHits |
| (localSeeds A SA SB v hv (phaseD := phaseD) (phaseG := phaseG) b) c |
| have hb := SurvivingGroups.touching_card |
| (localSeeds A SA SB v hv (phaseD := phaseD) (phaseG := phaseG) b) b.sub c hc |
| apply le_trans _ hb |
| exact Fintype.card_le_of_injective _ (localHit_injective_small A SA SB v hv b c hc hρ hτ hp hn) |
|
|
| lemma touching_finset_card_small : |
| (Finset.univ.filter (Touch A SA SB v hv b c (phaseD := phaseD) (phaseG := phaseG))).card≤ |
| SurvivingGroups.packBound := by |
| simpa only [Hits,Fintype.card_subtype] using touching_card_small A SA SB v hv b c hc hρ hτ hp hn |
|
|
| end PlanarL1.Columns.Model.RetainedSelection |
|
|
| end |
|
|
|
|
|
|
| section |
|
|
| namespace PlanarL1.FiniteRandom |
| attribute [local irreducible] prob |
| lemma prob_update_bound_pi {I : Type*} {D : I → Type*} [Fintype I] [DecidableEq I] |
| [∀ i, Fintype (D i)] [∀ i, Nonempty (D i)] (i : I) (P : (∀ i, D i) → Prop) {b : ℝ} |
| (h : ∀ α, prob (fun r : D i => P (Function.update α i r)) ≤ b) : prob P≤b := by |
| classical |
| let e := (Equiv.piSplitAt i D).trans (Equiv.prodComm _ _) |
| rw [←prob_equiv e.symm P] |
| apply prob_prod_bound |
| intro rest |
| let α : ∀ i, D i := e.symm (rest, Classical.arbitrary (D i)) |
| have hu (r : D i) : e.symm (rest,r)=Function.update α i r := by |
| funext j |
| by_cases hj : j=i |
| · subst j; simp [e,α,Equiv.piSplitAt] |
| · simp [e,α,Equiv.piSplitAt,hj] |
| simpa only [hu] using h α |
| end PlanarL1.FiniteRandom |
|
|
| namespace PlanarL1.Interpolation |
| attribute [local irreducible] FiniteRandom.prob |
| lemma familyAtomPair_probability_pi {X I : Type*} {D : I → Type*} {k : ℕ} |
| [Fintype I] [DecidableEq I] [∀ i, Fintype (D i)] [∀ i, Nonempty (D i)] |
| (ι : Fin k → I) (hinj : Function.Injective ι) |
| (old : X → ℝ) (A : ∀ g : Fin k, D (ι g) → ℕ → X → ℝ) (S : Fin k → Finset ℕ) |
| (x : X) {t b : ℝ} |
| (hpair : ∀ g i, i ∈ S g → ∀ j, j ∈ S g → i ≠ j → |
| FiniteRandom.prob (fun ω => |A g ω i x-A g ω j x| ≤ t) ≤ b) |
| (hconst : ∀ g i, i ∈ S g → i ≠ 0 → ∀ c : ℝ, |
| FiniteRandom.prob (fun ω => |A g ω i x-c| ≤ t) ≤ b) |
| (i j : ℕ) (hi : i ∈ familyNames S) (hj : j ∈ familyNames S) (hne : i ≠ j) : |
| FiniteRandom.prob (fun ω : ∀ i, D i => |
| |familyAtom old (fun g => A g (ω (ι g))) i x-familyAtom old (fun g => A g (ω (ι g))) j x| ≤ t) ≤ b := by |
| classical |
| rcases mem_familyNames.mp hi with rfl | ⟨g,a,ha,rfl⟩ |
| · obtain ⟨h,c,hc,hcj⟩ := (mem_familyNames.mp hj).resolve_left (Ne.symm hne) |
| subst j |
| have hc0 : c ≠ 0 := by intro he; subst c; simp only [familyName_zero] at hne; exact hne rfl |
| simp only [familyAtom_zero,familyAtom_name old _ h hc0] |
| apply FiniteRandom.prob_update_bound_pi (ι h) |
| intro ω |
| simpa only [Function.update_self,abs_sub_comm] using hconst h c hc hc0 (old x) |
| · rcases mem_familyNames.mp hj with rfl | ⟨h,c,hc,rfl⟩ |
| · have ha0 : a ≠ 0 := by intro he; subst a; simp only [familyName_zero] at hne; exact hne rfl |
| simp only [familyAtom_name old _ g ha0,familyAtom_zero] |
| apply FiniteRandom.prob_update_bound_pi (ι g) |
| intro ω |
| simpa only [Function.update_self] using hconst g a ha ha0 (old x) |
| · by_cases ha0 : a=0 |
| · subst a |
| have hc0 : c ≠ 0 := by intro he; subst c; simp only [familyName_zero] at hne; exact hne rfl |
| simp only [familyName_zero,familyAtom_zero,familyAtom_name old _ h hc0] |
| apply FiniteRandom.prob_update_bound_pi (ι h) |
| intro ω |
| simpa only [Function.update_self,abs_sub_comm] using hconst h c hc hc0 (old x) |
| · by_cases hc0 : c=0 |
| · subst c |
| simp only [familyName_zero,familyAtom_zero,familyAtom_name old _ g ha0] |
| apply FiniteRandom.prob_update_bound_pi (ι g) |
| intro ω |
| simpa only [Function.update_self] using hconst g a ha ha0 (old x) |
| · simp only [familyAtom_name old _ g ha0,familyAtom_name old _ h hc0] |
| by_cases hgh : g=h |
| · subst h |
| have hac : a ≠ c := by intro he; subst c; exact hne rfl |
| apply FiniteRandom.prob_update_bound_pi (ι g) |
| intro ω |
| simpa only [Function.update_self] using hpair g a ha c hc hac |
| · apply FiniteRandom.prob_update_bound_pi (ι g) |
| intro ω |
| simpa only [Function.update_self,Function.update_of_ne (fun he => hgh (hinj he).symm)] using |
| hconst g a ha ha0 (A h (ω (ι h)) c x) |
|
|
|
|
| lemma familyNames_card_sparse {k N : ℕ} (S : Fin k → Finset ℕ) (T : Finset (Fin k)) |
| (hS : ∀ g ∈ T, (S g).card≤N) (hout : ∀ g, g∉T → S g⊆{0}) : |
| (familyNames S).card≤1+T.card*N := by |
| classical |
| have hsub : familyNames S⊆insert 0 (T.biUnion (fun g => (S g).image (familyName g))) := by |
| intro i hi |
| rcases mem_familyNames.mp hi with rfl | ⟨g,j,hj,rfl⟩ |
| · exact Finset.mem_insert_self _ _ |
| · by_cases hg : g∈T |
| · exact Finset.mem_insert_of_mem (Finset.mem_biUnion.mpr ⟨g,hg,Finset.mem_image.mpr ⟨j,hj,rfl⟩⟩) |
| · have hj0 : j=0 := Finset.mem_singleton.mp (hout g hg hj) |
| rw [hj0,familyName_zero] |
| exact Finset.mem_insert_self _ _ |
| calc |
| _ ≤ (insert 0 (T.biUnion (fun g => (S g).image (familyName g)))).card := Finset.card_le_card hsub |
| _ ≤ (T.biUnion (fun g => (S g).image (familyName g))).card+1 := Finset.card_insert_le _ _ |
| _ ≤ (∑ g∈T, ((S g).image (familyName g)).card)+1 := Nat.add_le_add_right Finset.card_biUnion_le 1 |
| _ ≤ (∑ _g∈T, N)+1 := Nat.add_le_add_right (Finset.sum_le_sum (fun g hg => |
| (Finset.card_image_le (s := S g) (f := familyName g)).trans (hS g hg))) 1 |
| _ = 1+T.card*N := by simp [Nat.add_comm] |
|
|
| lemma selection_near_tie_modulus {X : Type*} (F : X → NamedValue) |
| (atom : ℕ → X → ℝ) (S : Finset ℕ) (x : X) (P : X → Prop) (hx : P x) {e : ℝ} |
| (hF : ∀ z, P z → |(F x).value-(F z).value|≤e) |
| (hA : ∀ i∈S, ∀ z, P z → |atom i z-atom i x|≤e) |
| (hlist : ∀ z, P z → (F z).name∈S ∧ (F z).value=atom (F z).name z) |
| (hbad : ∃ z, P z ∧ (F z).name≠(F x).name) : |
| ∃ i∈S, ∃ j∈S, i≠j ∧ |atom i x-atom j x|≤2*e := by |
| obtain ⟨z,hz,hn⟩ := hbad |
| refine ⟨(F x).name,(hlist x hx).1,(F z).name,(hlist z hz).1,Ne.symm hn,?_⟩ |
| have hf := hF z hz |
| have ha := hA (F z).name (hlist z hz).1 z hz |
| rw [←(hlist z hz).2] at ha |
| rw [←(hlist x hx).2] |
| have ht := abs_sub_le (F x).value (F z).value (atom (F z).name x) |
| linarith |
|
|
| lemma selection_probability_modulus {X Ω : Type*} [Fintype Ω] |
| (F : Ω → X → NamedValue) (atom : Ω → ℕ → X → ℝ) (S : Finset ℕ) |
| (x : X) (P : X → Prop) (hx : P x) {e b : ℝ} (hb : 0≤b) |
| (hF : ∀ ω z, P z → |(F ω x).value-(F ω z).value|≤e) |
| (hA : ∀ ω i, i∈S → ∀ z, P z → |atom ω i z-atom ω i x|≤e) |
| (hlist : ∀ ω z, P z → (F ω z).name∈S ∧ (F ω z).value=atom ω (F ω z).name z) |
| (hpair : ∀ i∈S, ∀ j∈S, i≠j → |
| FiniteRandom.prob (fun ω => |atom ω i x-atom ω j x|≤2*e)≤b) : |
| FiniteRandom.prob (fun ω => ∃ z, P z ∧ (F ω z).name≠(F ω x).name)≤S.card^2*b := by |
| apply (FiniteRandom.prob_mono (fun ω h => selection_near_tie_modulus (F ω) (atom ω) S x P hx |
| (hF ω) (hA ω) (hlist ω) h)).trans |
| exact FiniteRandom.prob_pair_bound S _ hb hpair |
|
|
| lemma maxSelection_modulus {X : Type*} (old : X → NamedValue) |
| (Fs : List (X → NamedValue)) (x z : X) {e : ℝ} |
| (ho : |(old x).value-(old z).value|≤e) |
| (hF : ∀ F∈Fs, |(F x).value-(F z).value|≤e) : |
| |(maxSelection old Fs x).value-(maxSelection old Fs z).value|≤e := by |
| induction Fs with |
| | nil => exact ho |
| | cons F Fs ih => |
| simp only [maxSelection,maxNamed_value] |
| exact (abs_max_sub_max_le_max _ _ _ _).trans (max_le (hF F (by simp)) |
| (ih (fun G hG => hF G (List.mem_cons_of_mem _ hG)))) |
|
|
| lemma familySelection_modulus {X : Type*} {k : ℕ} (old : X → ℝ) |
| (F : Fin k → X → NamedValue) (x z : X) {e : ℝ} |
| (ho : |old x-old z|≤e) (hF : ∀ g, |(F g x).value-(F g z).value|≤e) : |
| |(familySelection old F x).value-(familySelection old F z).value|≤e := by |
| apply maxSelection_modulus _ _ _ _ ho |
| intro G hG |
| obtain ⟨g,rfl⟩ := List.mem_ofFn.mp hG |
| exact hF g |
|
|
| lemma familyAtom_modulus {X : Type*} {k : ℕ} (old : X → ℝ) |
| (A : Fin k → ℕ → X → ℝ) (x z : X) {e : ℝ} |
| (ho : |old z-old x|≤e) (hA : ∀ g i, |A g i z-A g i x|≤e) (i : ℕ) : |
| |familyAtom old A i z-familyAtom old A i x|≤e := by |
| simp only [familyAtom] |
| split_ifs with h h' |
| · exact ho |
| · exact hA _ _ |
| · exact ho |
|
|
| / |
| The full family numbering is retained even for groups irrelevant to the ball. -/ |
| lemma familySelection_probability_sparse {X I : Type*} {D : I → Type*} |
| [Fintype I] [DecidableEq I] [∀ i, Fintype (D i)] [∀ i, Nonempty (D i)] |
| {k N B : ℕ} (ι : Fin k → I) (hinj : Function.Injective ι) |
| (old : X → ℝ) (F : ∀ g : Fin k, D (ι g) → X → NamedValue) |
| (A : ∀ g : Fin k, D (ι g) → ℕ → X → ℝ) |
| (S : Fin k → Finset ℕ) (T : Finset (Fin k)) |
| (hcard : ∀ g∈T, (S g).card≤N) (hout : ∀ g, g∉T → S g⊆{0}) (hT : T.card≤B) |
| (x : X) (P : X → Prop) (hx : P x) {e b : ℝ} (hb : 0≤b) |
| (ho : ∀ z, P z → |old x-old z|≤e) |
| (hF : ∀ g ω z, P z → |(F g ω x).value-(F g ω z).value|≤e) |
| (hA : ∀ g ω i z, P z → |A g ω i z-A g ω i x|≤e) |
| (hzero : ∀ g ω z, A g ω 0 z=old z) |
| (hlist : ∀ g ω z, P z → (F g ω z).name∈S g ∧ (F g ω z).value=A g ω (F g ω z).name z) |
| (hpair : ∀ g i, i∈S g → ∀ j, j∈S g → i≠j → |
| FiniteRandom.prob (fun ω => |A g ω i x-A g ω j x|≤2*e)≤b) |
| (hconst : ∀ g i, i∈S g → i≠0 → ∀ c : ℝ, |
| FiniteRandom.prob (fun ω => |A g ω i x-c|≤2*e)≤b) : |
| FiniteRandom.prob (fun ω : ∀ i, D i => ∃ z, P z ∧ |
| (familySelection old (fun g => F g (ω (ι g))) z).name≠ |
| (familySelection old (fun g => F g (ω (ι g))) x).name) ≤ (1+B*N : ℕ)^2*b := by |
| have hp := selection_probability_modulus |
| (fun ω : ∀ i, D i => familySelection old (fun g => F g (ω (ι g)))) |
| (fun ω => familyAtom old (fun g => A g (ω (ι g)))) (familyNames S) x P hx hb |
| (fun ω z hz => familySelection_modulus old _ x z (ho z hz) (fun g => hF g _ z hz)) |
| (fun ω i _ z hz => familyAtom_modulus old _ x z ((abs_sub_comm _ _).trans_le (ho z hz)) |
| (fun g j => hA g _ j z hz) i) |
| (fun ω z hz => familySelection_list old _ _ S (fun g y => hzero g _ y) z (fun g => hlist g _ z hz)) |
| (fun i hi j hj hij => familyAtomPair_probability_pi ι hinj old A S x hpair hconst i j hi hj hij) |
| refine hp.trans (mul_le_mul_of_nonneg_right (pow_le_pow_left₀ (Nat.cast_nonneg (familyNames S).card) ?_ 2) hb) |
| exact_mod_cast (familyNames_card_sparse S T hcard hout).trans |
| (Nat.add_le_add_left (Nat.mul_le_mul_right N hT) 1) |
| end PlanarL1.Interpolation |
|
|
| end |
|
|
|
|
|
|
| section |
|
|
| namespace PlanarL1.Interpolation |
| / |
| This is proof data for an actual named field, not a substitute for a chart. -/ |
| structure LocalList {X W : Type*} [Fintype W] (old : X → ℝ) |
| (F : W → X → NamedValue) (x : X) (e b : ℝ) where |
| names : Finset ℕ |
| atom : W → ℕ → X → ℝ |
| zero : ∀ w z, atom w 0 z=old z |
| selected : ∀ w z, (F w z).name∈names ∧ (F w z).value=atom w (F w z).name z |
| field_variation : ∀ w z, |(F w x).value-(F w z).value|≤e |
| atom_variation : ∀ w i z, |atom w i z-atom w i x|≤e |
| pair_test : ∀ i∈names, ∀ j∈names, i≠j → |
| FiniteRandom.prob (fun w => |atom w i x-atom w j x|≤2*e)≤b |
| constant_test : ∀ i∈names, i≠0 → ∀ c : ℝ, |
| FiniteRandom.prob (fun w => |atom w i x-c|≤2*e)≤b |
|
|
| noncomputable def oldLocalList {X W : Type*} [Fintype W] (old : X → ℝ) |
| (x : X) {e b : ℝ} (ho : ∀ z, |old x-old z|≤e) : |
| LocalList old (fun (_ : W) z => ⟨0,old z⟩) x e b where |
| names := {0} |
| atom _ _ z := old z |
| zero _ _ := rfl |
| selected _ _ := ⟨Finset.mem_singleton_self _,rfl⟩ |
| field_variation _ z := ho z |
| atom_variation _ _ z := (abs_sub_comm _ _).trans_le (ho z) |
| pair_test _i hi _j hj hn := False.elim (hn ((Finset.mem_singleton.mp hi).trans (Finset.mem_singleton.mp hj).symm)) |
| constant_test _i hi hn := False.elim (hn (Finset.mem_singleton.mp hi)) |
|
|
| lemma LocalList.family_probability {X I : Type*} {D : I → Type*} |
| [Fintype I] [DecidableEq I] [∀ i, Fintype (D i)] [∀ i, Nonempty (D i)] |
| {k N B : ℕ} (ι : Fin k → I) (hinj : Function.Injective ι) |
| (old : X → ℝ) (F : ∀ g : Fin k, D (ι g) → X → NamedValue) |
| (x : X) {e b : ℝ} (hb : 0≤b) (ho : ∀ z, |old x-old z|≤e) |
| (L : ∀ g, LocalList old (F g) x e b) (T : Finset (Fin k)) |
| (hc : ∀ g∈T, (L g).names.card≤N) (hout : ∀ g, g∉T → (L g).names⊆{0}) (hT : T.card≤B) : |
| FiniteRandom.prob (fun w : ∀ i, D i => ∃ z, |
| (familySelection old (fun g => F g (w (ι g))) z).name≠ |
| (familySelection old (fun g => F g (w (ι g))) x).name)≤(1+B*N : ℕ)^2*b := by |
| simpa only [true_and] using familySelection_probability_sparse ι hinj old F |
| (fun g => (L g).atom) (fun g => (L g).names) T hc hout hT x (fun _ => True) trivial hb |
| (fun z _ => ho z) (fun g w z _ => (L g).field_variation w z) |
| (fun g w i z _ => (L g).atom_variation w i z) (fun g => (L g).zero) |
| (fun g w z _ => (L g).selected w z) (fun g => (L g).pair_test) (fun g => (L g).constant_test) |
| end PlanarL1.Interpolation |
|
|
| namespace PlanarL1.Columns.Model.SecondaryCell |
| open PlanarL1.Interpolation |
| open scoped NNReal |
| variable {n : ℕ} {M : Model n} {J : Set ℝ} {root : Fin n} |
| variable (R : Point.RadialTree (M := M) (J := J) (root := root)) |
| variable (S : Finset (M.Point J root)) (old L : M.Point J root → ℝ) |
|
|
| / |
| ball. The chosen radial node and the whole list precede all fresh offsets. -/ |
| lemma sampled_local_list {X : Type*} (lift : X → M.Point J root) (x : X) {ρ : ℝ} |
| (hρ : 0≤ρ) (hs : ρ≤R.radius) (hd : ∀ z, dist (lift x) (lift z)≤ρ) |
| (ordinary : Bool) (hOld : LipschitzWith 5 old) (hL : LipschitzWith 1 L) |
| (hζ : R.ζ=(1:ℝ)/10) (pc radius lo B : ℝ) (hB : 0 < B) (m : ℕ) (hm : 0 < m) : |
| ∃ C : LocalList (fun z => old (lift z)) |
| (fun (w : Point.RadialTree.GridSample (n := n) R.depthCap m × Fin (m+1) × Fin (m+1)) z => |
| namedReplacement R S old L ordinary pc radius (B/m*w.2.1.val) (B/m*w.2.2.val) lo |
| (R.gridNoise R.depthCap m w.1) (lift z)) x ((replacementConstant R : ℝ)*ρ) |
| (((4*(replacementConstant R : ℝ)*ρ+R.q/m)/R.q)+(4*(replacementConstant R : ℝ)*ρ+B/m)/B), |
| C.names.card≤6*(R.lookback+1)+3 := by |
| classical |
| obtain ⟨k,A,hlo,heq⟩ := R.common_formula (lift x) hρ hs |
| have hk : k < R.depthCap := (R.depth_le_layerDepth (lift x) (hlo _ (by simpa using hρ))).trans_lt |
| (R.layerDepth_lt_cap _) |
| let atom := fun (w : Point.RadialTree.GridSample (n := n) R.depthCap m × Fin (m+1) × Fin (m+1)) |
| (i : ℕ) z => localAtom R S old L A pc radius (B/m*w.2.1.val) (B/m*w.2.2.val) lo |
| (R.gridNoise R.depthCap m w.1) i (lift z) |
| have ha (w : Point.RadialTree.GridSample (n := n) R.depthCap m × Fin (m+1) × Fin (m+1)) (i : ℕ) : LipschitzWith (replacementConstant R) |
| (localAtom R S old L A pc radius (B/m*w.2.1.val) (B/m*w.2.2.val) lo |
| (R.gridNoise R.depthCap m w.1) i) := localAtom_lipschitz R S old L hOld hL A _ _ _ _ _ _ i |
| refine ⟨{ names := secondaryNames (R.recentNames A R.lookback) |
| atom := atom |
| zero := ?_ |
| selected := ?_ |
| field_variation := ?_ |
| atom_variation := ?_ |
| pair_test := ?_ |
| constant_test := ?_ }, ?_⟩ |
| · intro w z |
| simp [atom,localAtom,secondaryAtom] |
| · intro w z |
| exact namedReplacement_local_list R S old L hζ A (lift x) hlo heq ordinary _ _ _ _ _ _ |
| (R.gridNoise_bounds _ _ hm _) (lift z) (hd z) |
| · intro w z |
| exact ((sampledReplacement_lipschitz R S old L ordinary hOld hL pc radius lo B _ m hm w).dist_le_mul |
| (lift x) (lift z)).trans (mul_le_mul_of_nonneg_left (hd z) (NNReal.coe_nonneg _)) |
| · intro w i z |
| have hh := (ha w i).dist_le_mul (lift z) (lift x) |
| rw [Real.dist_eq,dist_comm (lift z)] at hh |
| exact hh.trans (mul_le_mul_of_nonneg_left (hd z) (NNReal.coe_nonneg _)) |
| · intro i hi j hj hij |
| simpa only [atom,show 2*(2*((replacementConstant R : ℝ)*ρ))=4*(replacementConstant R : ℝ)*ρ by ring] using |
| localAtomPair_probability R S old L A (lift x) pc radius lo B hB _ m hk hm i j hi hj hij |
| (show 0≤2*((replacementConstant R : ℝ)*ρ) by positivity) |
| · intro i hi hi0 c |
| simpa only [atom,show 2*(2*((replacementConstant R : ℝ)*ρ))=4*(replacementConstant R : ℝ)*ρ by ring] using |
| localAtomConstant_probability R S old L A (lift x) pc radius lo B hB _ m hk hm i hi hi0 c |
| (show 0≤2*((replacementConstant R : ℝ)*ρ) by positivity) |
| · exact (secondaryNames_card _).trans (Nat.add_le_add_right (R.recentNames_card A R.lookback) 3) |
| end PlanarL1.Columns.Model.SecondaryCell |
|
|
| end |
|
|
| end OAI |
|
|
