| import OAI.Combinatorics.PlanarL1.MainFamily |
|
|
| namespace OAI |
|
|
|
|
| section |
|
|
| namespace PlanarL1.Columns.Model |
| open MeasureTheory |
| attribute [local instance] Classical.propDecidable |
| variable {n : ℕ} {M : Model n} {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω} |
|
|
| namespace OrdinaryState.MainBatch |
| variable {κ : ℝ} {S : OrdinaryState M κ Ω μ} (B : MainBatch S) |
| lemma choose_eq {i j : Fin n} {H T : ℝ} |
| (he : ∀ q, (B.step q).choose i H=(B.step q).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 n} {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,OrdinaryState.append,OrdinaryState.lift] |
| rw [he,hold] |
| end OrdinaryState.MainBatch |
|
|
| namespace MainCell |
| variable {I J : Set ℝ} {root : Fin n} (F : M.Field I 1) (hJI : J ⊆ I) |
| (R : Point.RadialTree (M := M) (J := J) (root := root)) (q : ℝ) |
| (C : Cell R q) |
| lemma choose_eq_of_name (v : M.Point J root) |
| (α : Point.RadialTree.Noise (n := n)) (E β lo : ℝ) {i j : Fin n} {H T : ℝ} |
| (hi : H ∈ domain R q C i) (hj : T ∈ domain R q C j) |
| (hn : (namedReplacement F hJI R q C v α E β lo (cellPoint R q C i H hi)).name= |
| (namedReplacement F hJI R q C v α E β lo (cellPoint R q C j T hj)).name) : |
| choose F hJI R q C v α E β lo i H=choose F hJI R q C v α E β lo j T := by |
| simp only [choose,dite_eq_left hi,dite_eq_left hj] |
| simp only [hn] |
|
|
| lemma choose_none_of_name (v : M.Point J root) |
| (α : Point.RadialTree.Noise (n := n)) (E β lo : ℝ) {i : Fin n} {H : ℝ} |
| (hi : H ∈ domain R q C i) |
| (hn : (namedReplacement F hJI R q C v α E β lo (cellPoint R q C i H hi)).name=0) : |
| choose F hJI R q C v α E β lo i H=none := by |
| simp only [choose,dite_eq_left hi,dite_eq_left hn] |
| end MainCell |
| end PlanarL1.Columns.Model |
|
|
| end |
|
|
|
|
|
|
| section |
|
|
| namespace PlanarL1.Tiling |
| lemma near_band_unique {a q h t H : ℝ} (ha : 0<a) (_ht : 0≤t) |
| (hp : Padded a q h t) (hd : |H-h|≤t) {b : ℤ} (hb : H ∈ band a q b) : |
| b=index a q h := by |
| rcases lt_trichotomy b (index a q h) with hl | he | hu |
| · have hbl : (b:ℝ)+1≤(index a q h:ℝ) := by |
| exact_mod_cast (show b+1≤ index a q h by omega) |
| have hv := mul_le_mul_of_nonneg_right hbl ha.le |
| have hlo := hp.1 |
| change q+(index a q h:ℝ)*a+t<h at hlo |
| have hh := hb.2 |
| change H≤q+((b:ℝ)+1)*a at hh |
| have hd' := (abs_le.mp hd).1 |
| linarith |
| · exact he |
| · have hbl : (index a q h:ℝ)+1≤(b:ℝ) := by |
| exact_mod_cast (show index a q h+1≤b by omega) |
| have hv := mul_le_mul_of_nonneg_right hbl ha.le |
| have hup := hp.2 |
| change h<q+((index a q h:ℝ)+1)*a-t at hup |
| have hh := hb.1 |
| change q+(b:ℝ)*a≤H at hh |
| have hd' := (abs_le.mp hd).2 |
| linarith |
|
|
| lemma near_mem_band {a q h t H : ℝ} (_ha : 0<a) (_ht : 0≤t) |
| (hp : Padded a q h t) (hd : |H-h|≤t) : H ∈ band a q (index a q h) := by |
| change q+(index a q h:ℝ)*a≤H ∧ H≤q+((index a q h:ℝ)+1)*a |
| have hlo := hp.1 |
| have hup := hp.2 |
| change q+(index a q h:ℝ)*a+t<h at hlo |
| change h<q+((index a q h:ℝ)+1)*a-t at hup |
| have hd' := abs_le.mp hd |
| constructor <;> linarith |
| end PlanarL1.Tiling |
|
|
| namespace PlanarL1.Columns.Model |
| attribute [local instance] Classical.propDecidable |
| variable {k : ℕ} {M : Model (k+1)} |
| namespace Point |
| lemma local_center {J : Set ℝ} {r s : Fin (k+1)} |
| (x y : M.Point Set.univ r) (y' : M.Point J s) |
| (hy : y'.column=y.column) (_hY : y'.height=y.height) {ρ : ℝ} (hρ : 0≤ρ) |
| (hJ : ∀ H, |H-x.height|≤ρ → H ∈ J) (hd : dist x y≤ρ) : |
| ∃ x' : M.Point J s, x'.column=x.column ∧ x'.height=x.height := by |
| obtain ⟨p,_,hp⟩ := x.exists_shortest isClosed_univ y |
| obtain ⟨q,_⟩ := p.restrict_of_length x.height y.height x.height ρ hJ (by simpa [hp] using hd) |
| have hxJ : x.height ∈ J := hJ _ (by simpa using hρ) |
| refine ⟨⟨x.column,x.height,hxJ,?_⟩,rfl,rfl⟩ |
| exact y'.reachable.trans (hy.symm ▸ q.word.reachable.symm) |
| end Point |
| namespace MainFamily |
| open Parameters |
| variable (A : Ambient M) {q L U : ℝ} |
| (phase : BandComponent (M := M) q L U → ℝ) |
| (x : M.Point Set.univ A.root) {ρ : ℝ} (hρ : 0≤ρ) |
| (hp : Tiling.Padded a₁ q x.height ρ) |
|
|
| include hρ hp |
| lemma touched_band {c : CellIndex q L U phase} {y : M.Point Set.univ A.root} |
| (hy : dist x y≤ρ) (hc : y.height ∈ domain phase c y.column) : |
| c.1.1.val=Tiling.index a₁ q x.height := by |
| apply Tiling.near_band_unique interpolationA.2.1 hρ hp _ (domain_band phase c hc) |
| rw [abs_sub_comm] |
| exact (x.height_change_le y).trans hy |
|
|
| lemma touched_envelope {c : CellIndex q L U phase} {y : M.Point Set.univ A.root} |
| (hy : dist x y≤ρ) (hc : y.height ∈ domain phase c y.column) : |
| ∀ H, |H-x.height|≤ρ → H ∈ BandTrees.band broad (lower q L U c.1.1) := by |
| intro H hH |
| have he := touched_band A phase x hρ hp hy hc |
| have hb := Tiling.near_mem_band interpolationA.2.1 hρ hp hH |
| rw [←he] at hb |
| change q+(c.1.1.val:ℝ)*a₁≤H ∧ H≤q+(c.1.1.val:ℝ)*a₁+a₁ |
| dsimp only [Tiling.band,Set.mem_Icc] at hb |
| constructor <;> linarith [hb.1,hb.2] |
|
|
| lemma local_center {c : CellIndex q L U phase} {y : M.Point Set.univ A.root} |
| (hy : dist x y≤ρ) (hc : y.height ∈ domain phase c y.column) : |
| ∃ x' : M.Point (BandTrees.band broad (lower q L U c.1.1)) |
| (BandTrees.root M broad (lower q L U c.1.1) c.1.2), |
| x'.column=x.column ∧ x'.height=x.height := |
| Point.local_center x y (MainCell.cellPoint (tree phase c) (radial phase c) c.2.2 _ _ hc) |
| rfl rfl hρ (touched_envelope A phase x hρ hp hy hc) hy |
|
|
| lemma local_ball {c : CellIndex q L U phase} |
| (x' : M.Point (BandTrees.band broad (lower q L U c.1.1)) |
| (BandTrees.root M broad (lower q L U c.1.1) c.1.2)) |
| (hx : x'.column=x.column) (hX : x'.height=x.height) |
| {y : M.Point Set.univ A.root} (hy : dist x y≤ρ) |
| (hc : c.1.1.val=Tiling.index a₁ q x.height) : |
| ∃ y' : M.Point (BandTrees.band broad (lower q L U c.1.1)) |
| (BandTrees.root M broad (lower q L U c.1.1) c.1.2), |
| y'.column=y.column ∧ y'.height=y.height ∧ dist x' y'=dist x y := by |
| apply Point.local_point x y x' hx hX isClosed_univ (Set.subset_univ _) _ hy |
| intro H hH |
| have hb := Tiling.near_mem_band interpolationA.2.1 hρ hp hH |
| rw [←hc] at hb |
| change q+(c.1.1.val:ℝ)*a₁≤H ∧ H≤q+(c.1.1.val:ℝ)*a₁+a₁ |
| dsimp only [Tiling.band,Set.mem_Icc] at hb |
| constructor <;> linarith [hb.1,hb.2] |
| end MainFamily |
| end PlanarL1.Columns.Model |
|
|
| end |
|
|
|
|
|
|
| section |
|
|
| namespace PlanarL1.Columns.Model |
| open MeasureTheory |
| attribute [local instance] Classical.propDecidable |
| variable {k : ℕ} {M : Model (k+1)} |
| namespace Point |
| lemma eq_of_coordinates {J : Set ℝ} {r : Fin (k+1)} (x y : M.Point J r) |
| (hc : x.column=y.column) (hh : x.height=y.height) : x=y := by |
| cases x |
| cases y |
| cases hc |
| cases hh |
| rfl |
| end Point |
| namespace MainFamily |
| open Parameters |
| variable {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω} |
| variable (A : Ambient M) (S : OrdinaryState M kappaA Ω μ) |
| variable {q L U : ℝ} (phase : BandComponent (M := M) q L U → ℝ) |
| variable {m : ℕ} (hm : 0 < m) (omega : Sample phase m) |
| variable (x : M.Point Set.univ A.root) {ρ : ℝ} (hρ : 0≤ρ) |
| (hp : Tiling.Padded a₁ q x.height ρ) (hsmall : 4*ρ<3*EA) |
|
|
| include hρ hp hsmall |
| / |
| small padded ball if that ball has a column outside the cell. -/ |
| lemma choose_none_crossed (c : Kept A S phase omega) |
| (hex : ∃ y : M.Point Set.univ A.root, dist x y≤ρ ∧ |
| y.column ∉ ColumnOrder.componentColumns c.val.2.2) |
| (z : M.Point Set.univ A.root) (hz : dist x z≤ρ) : |
| (keptStep A S phase hm omega c).choose z.column z.height=none := by |
| let V := keptStep A S phase hm omega c |
| change MainCell.choose V.comparison V.sub_old V.tree V.phase V.cell V.anchor |
| V.noise V.error V.shield_offset V.lo z.column z.height=none |
| by_cases hd : z.height ∈ domain phase c.val z.column |
| · obtain ⟨x',hx,hX⟩ := local_center A phase x hρ hp hz hd |
| have hb := touched_band A phase x hρ hp hz hd |
| obtain ⟨w,hw,hW,hdw⟩ := local_ball A phase x hρ hp x' hx hX hz hb |
| have hw' : w=MainCell.cellPoint V.tree V.phase V.cell z.column z.height hd := |
| Point.eq_of_coordinates _ _ hw hW |
| obtain ⟨y,hy,hout⟩ := hex |
| obtain ⟨y',hy',hY,hdy⟩ := local_ball A phase x hρ hp x' hx hX hy hb |
| have hh := MainCell.namedReplacement_retained_on_touched_ball V.comparison V.sub_old |
| V.tree V.phase V.cell isCompact_Icc V.anchor x' V.noise_bounds |
| interpolationA.1.le (show V.tree.δ=EA/8 by rfl) V.shield_offset V.lo hsmall |
| ⟨y',by simpa only [hdy] using hy,by |
| change y'.column ∉ ColumnOrder.componentColumns c.val.2.2 |
| rwa [hy']⟩ |
| w (by simpa only [hdw] using hz) (by |
| rw [hw] |
| exact ((MainCell.mem_domain _ _ _).mp hd).1) |
| apply MainCell.choose_none_of_name V.comparison V.sub_old V.tree V.phase V.cell |
| V.anchor V.noise V.error V.shield_offset V.lo hd |
| rw [←hw'] |
| exact congrArg PlanarL1.Interpolation.NamedValue.name hh |
| · exact MainCell.choose_none_outside V.comparison V.sub_old V.tree V.phase V.cell |
| V.anchor V.noise V.error V.shield_offset V.lo _ _ hd |
|
|
| / |
| none on the ball. This also covers two representatives of the same quotient |
| point and arbitrarily many touched cells. -/ |
| lemma all_choices_none_crossed (c : CellIndex q L U phase) |
| (hc : x.height ∈ domain phase c x.column) |
| (hex : ∃ y : M.Point Set.univ A.root, dist x y≤ρ ∧ |
| y.column ∉ ColumnOrder.componentColumns c.2.2) |
| (z : M.Point Set.univ A.root) (hz : dist x z≤ρ) |
| (d : Kept A S phase omega) : |
| (keptStep A S phase hm omega d).choose z.column z.height=none := by |
| by_cases hd : z.height ∈ domain phase d.val z.column |
| · apply choose_none_crossed A S phase hm omega x hρ hp hsmall d _ z hz |
| by_cases he : c=d.val |
| · subst c |
| exact hex |
| · refine ⟨x,by simpa using hρ,?_⟩ |
| intro hx |
| have hb := touched_band A phase x hρ hp hz hd |
| have hcband := touched_band A phase x hρ hp (y := x) (by simpa using hρ) hc |
| have hband : c.1.1=d.val.1.1 := Subtype.ext (hcband.trans hb.symm) |
| have hxd : x.height ∈ domain phase d.val x.column := |
| (MainCell.mem_domain _ _ _).mpr ⟨hx,touched_envelope A phase x hρ hp hz hd |
| x.height (by simpa using hρ)⟩ |
| exact he (unique_in_band phase hband hc hxd) |
| · exact MainCell.choose_none_outside |
| (keptStep A S phase hm omega d).comparison (keptStep A S phase hm omega d).sub_old |
| (tree phase d.val) (radial phase d.val) d.val.2.2 (anchor phase d.val) |
| (keptStep A S phase hm omega d).noise EA (keptStep A S phase hm omega d).shield_offset |
| (lower q L U d.val.1.1) z.column z.height hd |
| end MainFamily |
| end PlanarL1.Columns.Model |
|
|
| end |
|
|
|
|
|
|
| section |
|
|
| namespace PlanarL1.FiniteRandom |
| lemma prob_pi_eval_bound {I : Type*} {D : I → Type*} [Fintype I] [DecidableEq I] |
| [∀ i, Fintype (D i)] [∀ i, Nonempty (D i)] (i : I) (P : D i → Prop) |
| {b : ℝ} (h : prob P≤b) : prob (fun f : ∀ i, D i => P (f i))≤b := by |
| classical |
| let e := Equiv.piSplitAt i D |
| have he (u : D i × (∀ j : {j // j≠i}, D j.val)) : (e.symm u) i=u.1 := |
| congrArg Prod.fst (e.apply_symm_apply u) |
| rw [←prob_equiv e.symm] |
| apply prob_prod_bound_left |
| intro f |
| simpa only [he] using h |
| end PlanarL1.FiniteRandom |
|
|
| end |
|
|
|
|
|
|
| section |
|
|
| namespace PlanarL1.Columns.Model.MainFamily |
| open MeasureTheory Parameters |
| attribute [local instance] Classical.propDecidable |
| variable {k : ℕ} {M : Model (k+1)} {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω} |
| variable (A : Ambient M) (S : OrdinaryState M kappaA Ω μ) |
| variable {q L U : ℝ} (phase : BandComponent (M := M) q L U → ℝ) |
| variable {m : ℕ} (hm : 0 < m) (omega : Sample phase m) |
| variable (x : M.Point Set.univ A.root) {ρ : ℝ} (hρ : 0≤ρ) |
| (hp : Tiling.Padded a₁ q x.height ρ) (hsmall : 4*ρ<3*EA) |
|
|
| noncomputable def sampleName (c : CellIndex q L U phase) (hc : Available A S phase c) |
| (w : Point.RadialTree.GridSample (n := k+1) (tree phase c).depthCap m × Fin (m+1)) |
| (z : M.Point (BandTrees.band broad (lower q L U c.1.1)) |
| (BandTrees.root M broad (lower q L U c.1.1) c.1.2)) : ℕ := |
| (MainCell.namedReplacement (S.chart (index A S phase c hc)).comparison |
| (sub_old A S phase c hc) (tree phase c) (radial phase c) c.2.2 (anchor phase c) |
| ((tree phase c).gridNoise (tree phase c).depthCap m w.1) EA (EA/m*w.2.val) |
| (lower q L U c.1.1) z).name |
|
|
| include hρ hp in |
| lemma choose_none_other (c : CellIndex q L U phase) |
| (hfull : ∀ z : M.Point Set.univ A.root, dist x z≤ρ → z.height ∈ domain phase c z.column) |
| (d : Kept A S phase omega) (hne : d.val≠c) |
| (z : M.Point Set.univ A.root) (hz : dist x z≤ρ) : |
| (keptStep A S phase hm omega d).choose z.column z.height=none := by |
| apply MainCell.choose_none_outside |
| intro hd |
| have hd' : z.height ∈ domain phase d.val z.column := hd |
| have hb := touched_band A phase x hρ hp hz hd' |
| have hcband := touched_band A phase x hρ hp hz (hfull z hz) |
| exact hne (unique_in_band phase (Subtype.ext (hb.trans hcband.symm)) hd' (hfull z hz)) |
|
|
| include hρ hp hsmall in |
| lemma result_name_eq [SFinite μ] (c : CellIndex q L U phase) |
| (hc : x.height ∈ domain phase c x.column) |
| (hcontrol : ∀ hav : Available A S phase c, |
| let x' := MainCell.cellPoint (tree phase c) (radial phase c) c.2.2 x.column x.height hc |
| ∀ z, dist x' z≤ρ → |
| sampleName A S phase c hav ((omega c).1,(omega c).2.1) z= |
| sampleName A S phase c hav ((omega c).1,(omega c).2.1) x') |
| (z : M.Point Set.univ A.root) (hz : dist x z≤ρ) |
| (hold : S.name z.column z.height=S.name x.column x.height) : |
| (result A S phase hm omega).name z.column z.height= |
| (result A S phase hm omega).name x.column x.height := by |
| apply OrdinaryState.MainBatch.name_eq _ hold |
| apply OrdinaryState.MainBatch.choose_eq |
| intro j |
| let d : Kept A S phase omega := (Fintype.equivFin (Kept A S phase omega)).symm j |
| change (keptStep A S phase hm omega d).choose z.column z.height= |
| (keptStep A S phase hm omega d).choose x.column x.height |
| by_cases hex : ∃ y : M.Point Set.univ A.root, dist x y≤ρ ∧ |
| y.column ∉ ColumnOrder.componentColumns c.2.2 |
| · rw [all_choices_none_crossed A S phase hm omega x hρ hp hsmall c hc hex z hz d, |
| all_choices_none_crossed A S phase hm omega x hρ hp hsmall c hc hex x (by simpa using hρ) d] |
| · have hfull (y : M.Point Set.univ A.root) (hy : dist x y≤ρ) : |
| y.height ∈ domain phase c y.column := by |
| apply (MainCell.mem_domain _ _ _).mpr |
| refine ⟨?_,?_⟩ |
| · by_contra hn |
| exact hex ⟨y,hy,hn⟩ |
| · apply touched_envelope A phase x hρ hp (by simpa using hρ) hc |
| rw [abs_sub_comm] |
| exact (x.height_change_le y).trans hy |
| by_cases he : d.val=c |
| · subst c |
| let V := keptStep A S phase hm omega d |
| have hdz := hfull z hz |
| apply MainCell.choose_eq_of_name V.comparison V.sub_old V.tree V.phase V.cell V.anchor |
| V.noise V.error V.shield_offset V.lo hdz hc |
| let x' := MainCell.cellPoint (tree phase d.val) (radial phase d.val) d.val.2.2 |
| x.column x.height hc |
| have hb := touched_band A phase x hρ hp (by simpa using hρ) hc |
| obtain ⟨z',hz',hZ,hd⟩ := local_ball A phase x hρ hp x' rfl rfl hz hb |
| have hd' : dist x' z'≤ρ := hd.le.trans hz |
| have hn := hcontrol d.property.1 z' hd' |
| have hzP : z'=MainCell.cellPoint (tree phase d.val) (radial phase d.val) d.val.2.2 |
| z.column z.height hdz := Point.eq_of_coordinates _ _ hz' hZ |
| rw [hzP] at hn |
| exact hn |
| · rw [choose_none_other A S phase hm omega x hρ hp c hfull d he z hz, |
| choose_none_other A S phase hm omega x hρ hp c hfull d he x (by simpa using hρ)] |
| end PlanarL1.Columns.Model.MainFamily |
|
|
| end |
|
|
|
|
|
|
| section |
|
|
| namespace PlanarL1.Columns.Model.MainFamily |
| open MeasureTheory Parameters FiniteRandom |
| attribute [local instance] Classical.propDecidable |
| attribute [local irreducible] FiniteRandom.prob |
| variable {k : ℕ} {M : Model (k+1)} {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω} |
| variable (A : Ambient M) (S : OrdinaryState M kappaA Ω μ) |
| variable {q L U : ℝ} (phase : BandComponent (M := M) q L U → ℝ) |
|
|
| noncomputable def localLoss (c : CellIndex q L U phase) (ρ : ℝ) (m : ℕ) : ℝ := |
| (6*((tree phase c).lookback+1)+2 : ℕ)^2 * |
| ((4*(MainCell.replacementConstant (tree phase c) : ℝ)*ρ+(tree phase c).q/m)/(tree phase c).q+ |
| (4*(MainCell.replacementConstant (tree phase c) : ℝ)*ρ+EA/m)/EA) |
| lemma localLoss_nonneg (c : CellIndex q L U phase) {ρ : ℝ} (hρ : 0≤ρ) (m : ℕ) : |
| 0≤localLoss phase c ρ m := by |
| unfold localLoss |
| positivity [(tree phase c).q_pos,interpolationA.1] |
|
|
| lemma sampleName_probability (c : CellIndex q L U phase) (hc : Available A S phase c) |
| (x : M.Point (BandTrees.band broad (lower q L U c.1.1)) |
| (BandTrees.root M broad (lower q L U c.1.1) c.1.2)) |
| {ρ : ℝ} (hρ : 0≤ρ) (hr : ρ≤(tree phase c).radius) (m : ℕ) (hm : 0 < m) : |
| prob (fun omega : Sample phase m => ∃ z, dist x z≤ρ ∧ |
| sampleName A S phase c hc ((omega c).1,(omega c).2.1) z≠ |
| sampleName A S phase c hc ((omega c).1,(omega c).2.1) x)≤localLoss phase c ρ m := by |
| classical |
| apply prob_pi_eval_bound (D := fun d => CellSample phase d m) c |
| (fun w => ∃ z, dist x z≤ρ ∧ |
| sampleName A S phase c hc (w.1,w.2.1) z≠sampleName A S phase c hc (w.1,w.2.1) x) |
| let e := Equiv.prodAssoc |
| (Point.RadialTree.GridSample (n := k+1) (tree phase c).depthCap m) (Fin (m+1)) Bool |
| rw [←prob_equiv e] |
| apply prob_prod_bound_left |
| intro b |
| exact MainCell.namedReplacement_probability (S.chart (index A S phase c hc)).comparison |
| (sub_old A S phase c hc) (tree phase c) (radial phase c) c.2.2 isCompact_Icc |
| (anchor phase c) x EA (lower q L U c.1.1) EA interpolationA.1 hρ hr m hm |
|
|
| / |
| padded height band. No factor depending on the number of graph cells occurs. -/ |
| lemma persistence_probability [SFinite μ] (x : M.Point Set.univ A.root) |
| (c : CellIndex q L U phase) (hc : x.height ∈ domain phase c x.column) |
| {ρ : ℝ} (hρ : 0≤ρ) (hp : Tiling.Padded a₁ q x.height ρ) |
| (hsmall : 4*ρ<3*EA) (hr : ρ≤(tree phase c).radius) |
| (hold : ∀ z : M.Point Set.univ A.root, dist x z≤ρ → |
| S.name z.column z.height=S.name x.column x.height) |
| (m : ℕ) (hm : 0 < m) : |
| prob (fun omega : Sample phase m => ∃ z : M.Point Set.univ A.root, dist x z≤ρ ∧ |
| (result A S phase hm omega).name z.column z.height≠ |
| (result A S phase hm omega).name x.column x.height) ≤ localLoss phase c ρ m := by |
| classical |
| by_cases hav : Available A S phase c |
| · let x' := MainCell.cellPoint (tree phase c) (radial phase c) c.2.2 x.column x.height hc |
| apply (prob_mono (Q := fun omega : Sample phase m => ∃ z, dist x' z≤ρ ∧ |
| sampleName A S phase c hav ((omega c).1,(omega c).2.1) z≠ |
| sampleName A S phase c hav ((omega c).1,(omega c).2.1) x') _).trans |
| (sampleName_probability A S phase c hav x' hρ hr m hm) |
| intro omega hbad |
| by_contra hn |
| obtain ⟨z,hz,hz'⟩ := hbad |
| apply hz' |
| apply result_name_eq A S phase hm omega x hρ hp hsmall c hc _ z hz (hold z hz) |
| intro hc' |
| dsimp only |
| intro y hy |
| exact not_ne_iff.mp (fun he => hn ⟨y,hy,he⟩) |
| · have hzero : prob (fun omega : Sample phase m => ∃ z : M.Point Set.univ A.root, |
| dist x z≤ρ ∧ (result A S phase hm omega).name z.column z.height≠ |
| (result A S phase hm omega).name x.column x.height)≤prob (fun _ : Sample phase m => False) := by |
| apply prob_mono |
| intro omega ⟨z,hz,hz'⟩ |
| exact hz' (result_name_eq A S phase hm omega x hρ hp hsmall c hc |
| (fun hc' => False.elim (hav hc')) z hz (hold z hz)) |
| rw [prob_false] at hzero |
| exact hzero.trans (localLoss_nonneg phase c hρ m) |
| end PlanarL1.Columns.Model.MainFamily |
|
|
| end |
|
|
| end OAI |
|
|
