math / data /lean /OAI /Combinatorics /PlanarL1 /LocalPersistence.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
27.5 kB
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)
/-- At a doubly height-interior point, a narrow-band path can reach a seed
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
/-- Universal packing for the whole actual, finitely selected family. Both
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
/-- Sparse, genuinely independent component samples in the literal maximum.
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
/-- A local finite atom expansion, including its proved one-coordinate tests.
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 → ℝ)
/-- Literal secondary field has a bounded local atom expansion on any lifted
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