| import OAI.Combinatorics.PlanarL1.Distance |
| import OAI.Combinatorics.PlanarL1.Interpolation |
|
|
| namespace OAI |
|
|
| section |
|
|
| namespace PlanarL1 |
| namespace Columns |
| namespace Model |
|
|
| variable {n : ℕ} (M : Model n) |
|
|
| namespace Point |
|
|
| variable {M} {J : Set ℝ} {root : Fin n} |
|
|
| /-! ### The actual radial-node tree and its interpolation formulas |
| The geometric data below use precisely the thin-band constants. Nodes and their |
| parent maps are induced-graph components, not an assumed abstract hierarchy. -/ |
|
|
| structure RadialTree where |
| base : M.Point J root |
| δ : ℝ |
| a : ℝ |
| ζ : ℝ |
| delta_pos : 0 < δ |
| width_pos : 0 < a |
| zeta_pos : 0 < ζ |
| zeta_lt_one : ζ < 1 |
| width_bound : a ≤ ζ * δ / 1000000 |
| half_width : ∀ T ∈ J, |base.height - T| ≤ a / 2 |
| closed_band : IsClosed J |
| interval_band : Set.OrdConnected J |
|
|
| namespace RadialTree |
|
|
| variable (R : RadialTree (M := M) (J := J) (root := root)) |
|
|
| def Node (k : ℕ) := |
| ((M.activeGraph J).induce |
| (R.base.superlevel R.base.height R.base.inBand (k * R.δ))).ConnectedComponent |
|
|
| lemma width_small : R.a < R.δ / 1000 := by |
| have h := mul_lt_mul_of_pos_right R.zeta_lt_one R.delta_pos |
| nlinarith [R.width_bound, R.delta_pos] |
|
|
| lemma superlevel_antitone {k m : ℕ} (hkm : k ≤ m) : |
| R.base.superlevel R.base.height R.base.inBand (m * R.δ) ⊆ |
| R.base.superlevel R.base.height R.base.inBand (k * R.δ) := by |
| rintro i ⟨hr, hi⟩ |
| refine ⟨hr, le_trans ?_ hi⟩ |
| exact mul_le_mul_of_nonneg_right (by exact_mod_cast hkm) R.delta_pos.le |
|
|
| def parent {k : ℕ} (C : R.Node (k + 1)) : R.Node k := |
| ColumnOrder.componentAbove (R.superlevel_antitone (Nat.le_succ k)) C |
|
|
| lemma mem_parent {k : ℕ} (C : R.Node (k + 1)) : |
| ColumnOrder.componentColumns C ⊆ ColumnOrder.componentColumns (R.parent C) := |
| ColumnOrder.componentColumns_above _ C |
|
|
| noncomputable def portals {k : ℕ} (C : R.Node k) : |
| R.base.PortalData R.base.height R.base.inBand R.a (k * R.δ) C := |
| Classical.choice (R.base.portalData_nonempty R.closed_band R.base.inBand rfl |
| R.width_pos R.half_width (by |
| by_cases hk : k = 0 |
| · left; simp [hk] |
| · right |
| have hk' : (1 : ℝ) ≤ k := by exact_mod_cast Nat.one_le_iff_ne_zero.mpr hk |
| have hw := R.width_small |
| nlinarith [mul_le_mul_of_nonneg_right hk' R.delta_pos.le, R.delta_pos]) C) |
|
|
| lemma parent_near {k : ℕ} (C : R.Node (k + 1)) (v : M.Point J root) |
| (hv : v = (R.portals C).left ∨ v = (R.portals C).right) : |
| min (dist v (R.portals (R.parent C)).left) |
| (dist v (R.portals (R.parent C)).right) ≤ R.δ + 220 * R.a := by |
| have hm : v.column ∈ ColumnOrder.componentColumns (R.parent C) := by |
| apply R.mem_parent C |
| rcases hv with rfl | rfl |
| · exact (R.portals C).left_mem |
| · exact (R.portals C).right_mem |
| have hr : dist R.base v < (k : ℝ) * R.δ + R.δ + R.a := by |
| rcases hv with rfl | rfl |
| · simpa only [Nat.cast_add, Nat.cast_one, add_mul, one_mul] using |
| (R.portals C).left_radial.2 |
| · simpa only [Nat.cast_add, Nat.cast_one, add_mul, one_mul] using |
| (R.portals C).right_radial.2 |
| linarith [(R.portals (R.parent C)).near_of_radial v hm hr.le, R.width_pos] |
|
|
| lemma parent_separated {k : ℕ} (C : R.Node (k + 1)) (u v : M.Point J root) |
| (hu : u = (R.portals (R.parent C)).left ∨ u = (R.portals (R.parent C)).right) |
| (hv : v = (R.portals C).left ∨ v = (R.portals C).right) : |
| R.δ - 10 * R.a ≤ dist u v := by |
| have hr : dist R.base u < (k : ℝ) * R.δ + R.a := by |
| rcases hu with rfl | rfl |
| · exact (R.portals (R.parent C)).left_radial.2 |
| · exact (R.portals (R.parent C)).right_radial.2 |
| have hs : (k : ℝ) * R.δ + R.δ ≤ dist R.base v := by |
| rcases hv with rfl | rfl |
| · simpa only [Nat.cast_add, Nat.cast_one, add_mul, one_mul] using |
| (R.portals C).left_radial.1 |
| · simpa only [Nat.cast_add, Nat.cast_one, add_mul, one_mul] using |
| (R.portals C).right_radial.1 |
| linarith [dist_triangle R.base u v, R.width_pos] |
|
|
| /-- Atom names use depth, portal column and type. Equal portals therefore have |
| one name and one noise, including the root's single tentative atom. -/ |
| def atomName (k : ℕ) (v : M.Point J root) (j : Fin 3) : ℕ := |
| 3 * (n * k + v.column.val) + j.val |
|
|
| lemma atomName_bounds (k : ℕ) (v : M.Point J root) (j : Fin 3) : |
| 3 * n * k ≤ atomName k v j ∧ atomName k v j < 3 * n * (k + 1) := by |
| simp only [atomName, Nat.mul_add, Nat.mul_one, Nat.mul_assoc] |
| have := v.column.isLt |
| have := j.isLt |
| constructor <;> omega |
| |
| /-- A complete noise assignment. Bounds and independence are imposed on the |
| actual probability space later, not assumed properties of the output. -/ |
| abbrev Noise := ℕ → Fin n → Fin 3 → ℝ |
|
|
| open Interpolation |
|
|
| noncomputable def tentative (p : M.Point J root → ℝ) (α : Noise (n := n)) |
| {k : ℕ} (C : R.Node k) (v : M.Point J root) : NamedValue := |
| minNamed |
| ⟨atomName k (R.portals C).left 0, |
| p (R.portals C).left + dist (R.portals C).left v + α k (R.portals C).left.column 0⟩ |
| ⟨atomName k (R.portals C).right 0, |
| p (R.portals C).right + dist (R.portals C).right v + α k (R.portals C).right.column 0⟩ |
|
|
| noncomputable def upperCone (F : M.Point J root → NamedValue) (α : Noise (n := n)) |
| {k : ℕ} (C : R.Node k) (v : M.Point J root) : NamedValue := |
| minNamed |
| ⟨atomName k (R.portals C).left 1, |
| (F (R.portals C).left).value + dist (R.portals C).left v - α k (R.portals C).left.column 1⟩ |
| ⟨atomName k (R.portals C).right 1, |
| (F (R.portals C).right).value + dist (R.portals C).right v - α k (R.portals C).right.column 1⟩ |
|
|
| noncomputable def lowerCone (F : M.Point J root → NamedValue) (α : Noise (n := n)) |
| {k : ℕ} (C : R.Node k) (v : M.Point J root) : NamedValue := |
| maxNamed |
| ⟨atomName k (R.portals C).left 2, |
| (F (R.portals C).left).value - dist (R.portals C).left v + α k (R.portals C).left.column 2⟩ |
| ⟨atomName k (R.portals C).right 2, |
| (F (R.portals C).right).value - dist (R.portals C).right v + α k (R.portals C).right.column 2⟩ |
|
|
| /-- The manuscript's recursive named formulas, on the whole metric component. -/ |
| noncomputable def formula (p : M.Point J root → ℝ) (α : Noise (n := n)) : |
| (k : ℕ) → R.Node k → M.Point J root → NamedValue |
| | 0, C, v => R.tentative p α C v |
| | k + 1, C, v => |
| let F := formula p α k (R.parent C) |
| nodeNamed (F v) (R.upperCone F α C v) (R.lowerCone F α C v) (R.tentative p α C v) |
|
|
| lemma tentative_names (p : M.Point J root → ℝ) (α : Noise (n := n)) |
| {k : ℕ} (C : R.Node k) (v : M.Point J root) : |
| 3 * n * k ≤ (R.tentative p α C v).name ∧ |
| (R.tentative p α C v).name < 3 * n * (k + 1) := by |
| rcases minNamed_mem _ _ with h | h |
| · rw [tentative, h] |
| exact atomName_bounds k (R.portals C).left 0 |
| · rw [tentative, h] |
| exact atomName_bounds k (R.portals C).right 0 |
|
|
| lemma upperCone_names (F : M.Point J root → NamedValue) (α : Noise (n := n)) |
| {k : ℕ} (C : R.Node k) (v : M.Point J root) : |
| 3 * n * k ≤ (R.upperCone F α C v).name ∧ |
| (R.upperCone F α C v).name < 3 * n * (k + 1) := by |
| rcases minNamed_mem _ _ with h | h |
| · rw [upperCone, h] |
| exact atomName_bounds k (R.portals C).left 1 |
| · rw [upperCone, h] |
| exact atomName_bounds k (R.portals C).right 1 |
|
|
| lemma lowerCone_names (F : M.Point J root → NamedValue) (α : Noise (n := n)) |
| {k : ℕ} (C : R.Node k) (v : M.Point J root) : |
| 3 * n * k ≤ (R.lowerCone F α C v).name ∧ |
| (R.lowerCone F α C v).name < 3 * n * (k + 1) := by |
| rcases maxNamed_mem _ _ with h | h |
| · rw [lowerCone, h] |
| exact atomName_bounds k (R.portals C).left 2 |
| · rw [lowerCone, h] |
| exact atomName_bounds k (R.portals C).right 2 |
|
|
| lemma formula_name_bound (p : M.Point J root → ℝ) (α : Noise (n := n)) |
| (k : ℕ) (C : R.Node k) (v : M.Point J root) : |
| (R.formula p α k C v).name < 3 * n * (k + 1) := by |
| induction k with |
| | zero => exact (R.tentative_names p α C v).2 |
| | succ k ih => |
| rw [formula] |
| rcases nodeNamed_mem _ _ _ _ with h | h | h | h |
| · rw [h] |
| exact (ih (R.parent C)).trans_le (Nat.mul_le_mul_left (3 * n) (Nat.le_succ (k + 1))) |
| · rw [h] |
| exact (R.upperCone_names _ _ _ _).2 |
| · rw [h] |
| exact (R.lowerCone_names _ _ _ _).2 |
| · rw [h] |
| exact (R.tentative_names _ _ _ _).2 |
|
|
| lemma tentative_lipschitz (p : M.Point J root → ℝ) (α : Noise (n := n)) |
| {k : ℕ} (C : R.Node k) : LipschitzWith 1 (fun v => (R.tentative p α C v).value) := by |
| let l := (R.portals C).left |
| let r := (R.portals C).right |
| have hl := (distance_cone_lipschitz l (p l + α k l.column 0)).1 |
| have hr := (distance_cone_lipschitz r (p r + α k r.column 0)).1 |
| simpa only [tentative, minNamed_value, max_self, add_right_comm] using hl.min hr |
|
|
| lemma upperCone_lipschitz (F : M.Point J root → NamedValue) (α : Noise (n := n)) |
| {k : ℕ} (C : R.Node k) : LipschitzWith 1 (fun v => (R.upperCone F α C v).value) := by |
| let l := (R.portals C).left |
| let r := (R.portals C).right |
| have hl := (distance_cone_lipschitz l ((F l).value - α k l.column 1)).1 |
| have hr := (distance_cone_lipschitz r ((F r).value - α k r.column 1)).1 |
| simpa only [upperCone, minNamed_value, max_self, sub_add_eq_add_sub] using hl.min hr |
|
|
| lemma lowerCone_lipschitz (F : M.Point J root → NamedValue) (α : Noise (n := n)) |
| {k : ℕ} (C : R.Node k) : LipschitzWith 1 (fun v => (R.lowerCone F α C v).value) := by |
| let l := (R.portals C).left |
| let r := (R.portals C).right |
| have hl := (distance_cone_lipschitz l ((F l).value + α k l.column 2)).2 |
| have hr := (distance_cone_lipschitz r ((F r).value + α k r.column 2)).2 |
| simpa only [lowerCone, maxNamed_value, max_self, sub_add_eq_add_sub] using hl.max hr |
|
|
| lemma formula_lipschitz (p : M.Point J root → ℝ) (α : Noise (n := n)) |
| (k : ℕ) (C : R.Node k) : LipschitzWith 1 (fun v => (R.formula p α k C v).value) := by |
| induction k with |
| | zero => exact R.tentative_lipschitz p α C |
| | succ k ih => |
| simpa only [formula, nodeNamed_value] using |
| nodeValue_lipschitz (ih (R.parent C)) (R.upperCone_lipschitz _ _ _) |
| (R.lowerCone_lipschitz _ _ _) (R.tentative_lipschitz _ _ _) |
|
|
| noncomputable def q : ℝ := R.ζ * R.δ / 20 |
|
|
| lemma q_pos : 0 < R.q := div_pos (mul_pos R.zeta_pos R.delta_pos) (by norm_num) |
|
|
| lemma q_small : 2 * R.q ≤ R.δ / 10 := by |
| have h := mul_lt_mul_of_pos_right R.zeta_lt_one R.delta_pos |
| dsimp [q] |
| linarith |
|
|
| def NoiseBounds (α : Noise (n := n)) : Prop := |
| ∀ k i j, R.q ≤ α k i j ∧ α k i j ≤ 2 * R.q |
|
|
| def InputLip (p : M.Point J root → ℝ) : Prop := |
| ∀ x y, |p x - p y| ≤ (1 - R.ζ) * dist x y |
|
|
| noncomputable def portalDistance {k : ℕ} (C : R.Node k) (v : M.Point J root) : ℝ := |
| min (dist (R.portals C).left v) (dist (R.portals C).right v) |
|
|
| lemma portalDistance_nonneg {k : ℕ} (C : R.Node k) (v : M.Point J root) : |
| 0 ≤ R.portalDistance C v := le_min dist_nonneg dist_nonneg |
|
|
| lemma tentative_bounds {p : M.Point J root → ℝ} {α : Noise (n := n)} |
| (hp : R.InputLip p) (hα : R.NoiseBounds α) {k : ℕ} (C : R.Node k) (v : M.Point J root) : |
| p v + R.ζ * R.portalDistance C v + R.q ≤ (R.tentative p α C v).value ∧ |
| (R.tentative p α C v).value ≤ p v + (2 - R.ζ) * R.portalDistance C v + 2 * R.q := by |
| have atom (w : M.Point J root) : |
| p v + R.ζ * dist w v + R.q ≤ p w + dist w v + α k w.column 0 ∧ |
| p w + dist w v + α k w.column 0 ≤ p v + (2 - R.ζ) * dist w v + 2 * R.q := by |
| have hlip := abs_le.mp (hp w v) |
| have hn := hα k w.column 0 |
| constructor <;> nlinarith |
| have hleft := atom (R.portals C).left |
| have hright := atom (R.portals C).right |
| simp only [tentative, minNamed_value] |
| constructor |
| · apply le_min |
| · have hd := mul_le_mul_of_nonneg_left |
| (min_le_left (dist (R.portals C).left v) (dist (R.portals C).right v)) R.zeta_pos.le |
| dsimp [portalDistance] |
| linarith |
| · have hd := mul_le_mul_of_nonneg_left |
| (min_le_right (dist (R.portals C).left v) (dist (R.portals C).right v)) R.zeta_pos.le |
| dsimp [portalDistance] |
| linarith |
| · rcases le_total (dist (R.portals C).left v) (dist (R.portals C).right v) with h | h |
| · rw [portalDistance, min_eq_left h] |
| exact (min_le_left _ _).trans hleft.2 |
| · rw [portalDistance, min_eq_right h] |
| exact (min_le_right _ _).trans hright.2 |
|
|
| lemma cone_bounds {p : M.Point J root → ℝ} {α : Noise (n := n)} |
| (hp : R.InputLip p) (hα : R.NoiseBounds α) {k : ℕ} (C : R.Node k) |
| (F : M.Point J root → NamedValue) |
| (hF : ∀ w, w = (R.portals C).left ∨ w = (R.portals C).right → |
| |(F w).value - p w| ≤ 5 * R.δ) (v : M.Point J root) : |
| p v - 5 * R.δ + R.ζ * R.portalDistance C v - 2 * R.q ≤ (R.upperCone F α C v).value ∧ |
| (R.lowerCone F α C v).value ≤ p v + 5 * R.δ - R.ζ * R.portalDistance C v + 2 * R.q := by |
| have atom (w : M.Point J root) (hw : w = (R.portals C).left ∨ w = (R.portals C).right) |
| (hd : R.portalDistance C v ≤ dist w v) : |
| p v - 5 * R.δ + R.ζ * R.portalDistance C v - 2 * R.q ≤ |
| (F w).value + dist w v - α k w.column 1 ∧ |
| (F w).value - dist w v + α k w.column 2 ≤ |
| p v + 5 * R.δ - R.ζ * R.portalDistance C v + 2 * R.q := by |
| have hlip := abs_le.mp (hp w v) |
| have ha := abs_le.mp (hF w hw) |
| have hn₁ := hα k w.column 1 |
| have hn₂ := hα k w.column 2 |
| have hz := mul_le_mul_of_nonneg_left hd R.zeta_pos.le |
| constructor <;> nlinarith |
| have hl := atom (R.portals C).left (Or.inl rfl) (min_le_left _ _) |
| have hr := atom (R.portals C).right (Or.inr rfl) (min_le_right _ _) |
| exact ⟨by simpa only [upperCone, minNamed_value, le_min_iff] using And.intro hl.1 hr.1, |
| by simpa only [lowerCone, maxNamed_value, max_le_iff] using And.intro hl.2 hr.2⟩ |
|
|
| /-- With the thin-band constants, every nearby tentative value lies in the |
| same three-delta window used in the manuscript's induction. -/ |
| lemma tentative_near {p : M.Point J root → ℝ} {α : Noise (n := n)} |
| (hp : R.InputLip p) (hα : R.NoiseBounds α) {k : ℕ} (C : R.Node k) (v : M.Point J root) |
| (hn : R.portalDistance C v ≤ R.δ + 220 * R.a) : |
| p v ≤ (R.tentative p α C v).value ∧ (R.tentative p α C v).value ≤ p v + 3 * R.δ := by |
| obtain ⟨hl, hu⟩ := R.tentative_bounds hp hα C v |
| have hd := R.portalDistance_nonneg C v |
| have hz := R.zeta_pos |
| have hδ := R.delta_pos |
| constructor |
| · nlinarith [R.q_pos] |
| · have h := mul_le_mul_of_nonneg_left hn (by linarith [R.zeta_lt_one] : 0 ≤ 2 - R.ζ) |
| have hw := R.width_small |
| have hq := R.q_small |
| nlinarith [R.width_pos, mul_nonneg hz.le hd] |
|
|
| /-- Exact named inheritance on the genuine entrance collar. -/ |
| lemma formula_collar (p : M.Point J root → ℝ) {α : Noise (n := n)} |
| (hα : R.NoiseBounds α) {k : ℕ} (C : R.Node (k + 1)) (v : M.Point J root) |
| (hc : R.portalDistance C v ≤ R.ζ * R.δ / 50) : |
| R.formula p α (k + 1) C v = R.formula p α k (R.parent C) v := by |
| let F := R.formula p α k (R.parent C) |
| have hF := R.formula_lipschitz p α k (R.parent C) |
| have hcq : 2 * (R.ζ * R.δ / 50) < R.q := by |
| dsimp [q] |
| nlinarith [mul_pos R.zeta_pos R.delta_pos] |
| have single (w : M.Point J root) (hw : dist w v ≤ R.ζ * R.δ / 50) : |
| (F w).value + dist w v - α (k + 1) w.column 1 < (F v).value ∧ |
| (F v).value < (F w).value - dist w v + α (k + 1) w.column 2 := by |
| have hlip := hF.dist_le_mul w v |
| change |(F w).value - (F v).value| ≤ (1 : ℝ) * dist w v at hlip |
| simp only [one_mul, abs_le] at hlip |
| have hn₁ := hα (k + 1) w.column 1 |
| have hn₂ := hα (k + 1) w.column 2 |
| constructor <;> linarith |
| have hcones : (R.upperCone F α C v).value < (F v).value ∧ |
| (F v).value < (R.lowerCone F α C v).value := by |
| simp only [upperCone, lowerCone, minNamed_value, maxNamed_value] |
| rcases min_le_iff.mp hc with h | h |
| · have hs := single (R.portals C).left h |
| exact ⟨lt_of_le_of_lt (min_le_left _ _) hs.1, |
| lt_of_lt_of_le hs.2 (le_max_left _ _)⟩ |
| · have hs := single (R.portals C).right h |
| exact ⟨lt_of_le_of_lt (min_le_right _ _) hs.1, |
| lt_of_lt_of_le hs.2 (le_max_right _ _)⟩ |
| change nodeNamed (F v) _ _ _ = F v |
| apply nodeNamed_collar hcones.1 hcones.2 |
| exact (R.formula_name_bound p α k (R.parent C) v).le.trans |
| (R.tentative_names p α C v).1 |
|
|
|
|
| lemma portal_spacing : 2 * R.q ≤ R.ζ * (R.δ - 10 * R.a) := by |
| have hw : R.δ / 10 ≤ R.δ - 10 * R.a := by linarith [R.width_small, R.delta_pos] |
| have hh := mul_le_mul_of_nonneg_left hw R.zeta_pos.le |
| dsimp [q] |
| nlinarith |
|
|
| /-- The complete quantitative induction on the ACTUAL component hierarchy. |
| The second bound applies to child portals; the first applies on the own layer. -/ |
| lemma formula_near_accuracy {p : M.Point J root → ℝ} {α : Noise (n := n)} |
| (hp : R.InputLip p) (hα : R.NoiseBounds α) (k : ℕ) (C : R.Node k) (v : M.Point J root) |
| (hn : R.portalDistance C v ≤ R.δ + 220 * R.a) : |
| |(R.formula p α k C v).value - p v| ≤ 5 * R.δ + 2 * R.q ∧ |
| (2 * R.q ≤ R.ζ * R.portalDistance C v → |
| |(R.formula p α k C v).value - p v| ≤ 5 * R.δ) := by |
| induction k generalizing v with |
| | zero => |
| have hT := R.tentative_near hp hα C v hn |
| simp only [formula, abs_le] |
| constructor |
| · constructor <;> linarith [R.delta_pos, R.q_pos] |
| · intro _ |
| constructor <;> linarith [R.delta_pos] |
| | succ k ih => |
| let F := R.formula p α k (R.parent C) |
| have hF : ∀ w, w = (R.portals C).left ∨ w = (R.portals C).right → |
| |(F w).value - p w| ≤ 5 * R.δ := by |
| intro w hw |
| have hn' : R.portalDistance (R.parent C) w ≤ R.δ + 220 * R.a := by |
| simpa only [portalDistance, dist_comm w] using R.parent_near C w hw |
| have hd : R.δ - 10 * R.a ≤ R.portalDistance (R.parent C) w := |
| le_min (R.parent_separated C _ w (Or.inl rfl) hw) |
| (R.parent_separated C _ w (Or.inr rfl) hw) |
| have hs := R.portal_spacing.trans (mul_le_mul_of_nonneg_left hd R.zeta_pos.le) |
| exact (ih (R.parent C) w hn').2 hs |
| obtain ⟨hA, hB⟩ := R.cone_bounds hp hα C F hF v |
| obtain ⟨hTlo, hThi⟩ := R.tentative_near hp hα C v hn |
| have hval : (R.formula p α (k + 1) C v).value = |
| nodeValue (F v).value (R.upperCone F α C v).value |
| (R.lowerCone F α C v).value (R.tentative p α C v).value := by |
| simp only [formula, nodeNamed_value, F] |
| have bound (e : ℝ) (he : 3 * R.δ ≤ e) |
| (hu : 5 * R.δ - R.ζ * R.portalDistance C v + 2 * R.q ≤ e) : |
| |(R.formula p α (k + 1) C v).value - p v| ≤ e := by |
| have hb := nodeValue_bounds (parent := (F v).value) |
| (lo := p v - e) (hi := p v + e) |
| (show p v - e ≤ (R.upperCone F α C v).value by linarith) |
| (show (R.lowerCone F α C v).value ≤ p v + e by linarith) |
| (show p v - e ≤ (R.tentative p α C v).value by linarith [R.delta_pos]) |
| (show (R.tentative p α C v).value ≤ p v + e by linarith) |
| rw [hval, abs_le] |
| constructor <;> linarith |
| constructor |
| · apply bound (5 * R.δ + 2 * R.q) |
| · linarith [R.delta_pos, R.q_pos] |
| · nlinarith [mul_nonneg R.zeta_pos.le (R.portalDistance_nonneg C v)] |
| · intro hs |
| exact bound (5 * R.δ) (by linarith [R.delta_pos]) (by linarith) |
| |
| lemma formula_child_accuracy {p : M.Point J root → ℝ} {α : Noise (n := n)} |
| (hp : R.InputLip p) (hα : R.NoiseBounds α) {k : ℕ} (C : R.Node (k + 1)) |
| (v : M.Point J root) (hv : v = (R.portals C).left ∨ v = (R.portals C).right) : |
| |(R.formula p α k (R.parent C) v).value - p v| ≤ 5 * R.δ := by |
| have hn : R.portalDistance (R.parent C) v ≤ R.δ + 220 * R.a := by |
| simpa only [portalDistance, dist_comm v] using R.parent_near C v hv |
| have hd : R.δ - 10 * R.a ≤ R.portalDistance (R.parent C) v := |
| le_min (R.parent_separated C _ v (Or.inl rfl) hv) |
| (R.parent_separated C _ v (Or.inr rfl) hv) |
| exact (R.formula_near_accuracy hp hα k (R.parent C) v hn).2 |
| (R.portal_spacing.trans (mul_le_mul_of_nonneg_left hd R.zeta_pos.le)) |
|
|
| lemma formula_layer_accuracy {p : M.Point J root → ℝ} {α : Noise (n := n)} |
| (hp : R.InputLip p) (hα : R.NoiseBounds α) {k : ℕ} (C : R.Node k) (v : M.Point J root) |
| (hv : v.column ∈ ColumnOrder.componentColumns C) |
| (hr : dist R.base (v.withHeight R.base.height R.base.inBand) < (k + 1 : ℕ) * R.δ) : |
| |(R.formula p α k C v).value - p v| ≤ 6 * R.δ := by |
| have hn : R.portalDistance C v ≤ R.δ + 220 * R.a := by |
| have hh : dist R.base (v.withHeight R.base.height R.base.inBand) < (k : ℝ) * R.δ + R.δ := by |
| simpa only [Nat.cast_add, Nat.cast_one, add_mul, one_mul] using hr |
| simpa only [portalDistance, dist_comm v] using |
| (R.portals C).near_layer R.half_width R.width_pos.le v hv hh |
| have ha := (R.formula_near_accuracy hp hα k C v hn).1 |
| linarith [R.q_small, R.delta_pos] |
|
|
|
|
| /-- The unique depth of the layer assigned to a column. -/ |
| noncomputable def layerDepth (v : M.Point J root) : ℕ := |
| ⌊dist R.base (v.withHeight R.base.height R.base.inBand) / R.δ⌋₊ |
|
|
| lemma layerDepth_bounds (v : M.Point J root) : |
| (R.layerDepth v : ℝ) * R.δ ≤ dist R.base (v.withHeight R.base.height R.base.inBand) ∧ |
| dist R.base (v.withHeight R.base.height R.base.inBand) < (R.layerDepth v + 1 : ℕ) * R.δ := by |
| have hl := Nat.floor_le (div_nonneg (dist_nonneg (x := R.base) |
| (y := v.withHeight R.base.height R.base.inBand)) R.delta_pos.le) |
| have hu := Nat.lt_floor_add_one |
| (dist R.base (v.withHeight R.base.height R.base.inBand) / R.δ) |
| constructor |
| · exact (le_div_iff₀ R.delta_pos).mp hl |
| · simpa only [layerDepth, Nat.cast_add, Nat.cast_one] using (div_lt_iff₀ R.delta_pos).mp hu |
|
|
| lemma layerDepth_eq {k : ℕ} (v : M.Point J root) |
| (hl : (k : ℝ) * R.δ ≤ dist R.base (v.withHeight R.base.height R.base.inBand)) |
| (hu : dist R.base (v.withHeight R.base.height R.base.inBand) < (k + 1 : ℕ) * R.δ) : |
| R.layerDepth v = k := by |
| apply (Nat.floor_eq_iff (div_nonneg dist_nonneg R.delta_pos.le)).mpr |
| refine ⟨(le_div_iff₀ R.delta_pos).mpr hl, ?_⟩ |
| apply (div_lt_iff₀ R.delta_pos).mpr |
| simpa only [Nat.cast_add, Nat.cast_one] using hu |
|
|
| noncomputable def nodeOf (k : ℕ) (v : M.Point J root) |
| (hv : (k : ℝ) * R.δ ≤ dist R.base (v.withHeight R.base.height R.base.inBand)) : R.Node k := |
| ((M.activeGraph J).induce _).connectedComponentMk |
| ⟨v.column, (R.base.mem_superlevel_iff v R.base.height R.base.inBand (k * R.δ)).mpr hv⟩ |
|
|
| lemma mem_nodeOf (k : ℕ) (v : M.Point J root) |
| (hv : (k : ℝ) * R.δ ≤ dist R.base (v.withHeight R.base.height R.base.inBand)) : |
| v.column ∈ ColumnOrder.componentColumns (R.nodeOf k v hv) := |
| ⟨⟨v.column, (R.base.mem_superlevel_iff v R.base.height R.base.inBand (k * R.δ)).mpr hv⟩, rfl, rfl⟩ |
|
|
| noncomputable def layerNode (v : M.Point J root) : R.Node (R.layerDepth v) := |
| R.nodeOf (R.layerDepth v) v (R.layerDepth_bounds v).1 |
|
|
| lemma mem_layerNode (v : M.Point J root) : |
| v.column ∈ ColumnOrder.componentColumns (R.layerNode v) := |
| R.mem_nodeOf (R.layerDepth v) v (R.layerDepth_bounds v).1 |
|
|
| /-- The actual pasted named output on representatives. -/ |
| noncomputable def pasted (p : M.Point J root → ℝ) (α : Noise (n := n)) (v : M.Point J root) : NamedValue := |
| R.formula p α (R.layerDepth v) (R.layerNode v) v |
|
|
| lemma pasted_eq_of_layer (p : M.Point J root → ℝ) (α : Noise (n := n)) |
| {k : ℕ} (C : R.Node k) (v : M.Point J root) |
| (hm : v.column ∈ ColumnOrder.componentColumns C) |
| (hl : (k : ℝ) * R.δ ≤ dist R.base (v.withHeight R.base.height R.base.inBand)) |
| (hu : dist R.base (v.withHeight R.base.height R.base.inBand) < (k + 1 : ℕ) * R.δ) : |
| R.pasted p α v = R.formula p α k C v := by |
| have hd := R.layerDepth_eq v hl hu |
| subst k |
| have he : R.layerNode v = C := ColumnOrder.component_eq_of_column (R.mem_layerNode v) hm |
| simp only [pasted, he] |
|
|
| lemma pasted_accuracy {p : M.Point J root → ℝ} {α : Noise (n := n)} |
| (hp : R.InputLip p) (hα : R.NoiseBounds α) (v : M.Point J root) : |
| |(R.pasted p α v).value - p v| ≤ 6 * R.δ := |
| R.formula_layer_accuracy hp hα (R.layerNode v) v (R.mem_layerNode v) (R.layerDepth_bounds v).2 |
|
|
| noncomputable def radius : ℝ := R.ζ * R.δ / 1000 |
|
|
| lemma radius_pos : 0 < R.radius := div_pos (mul_pos R.zeta_pos R.delta_pos) (by norm_num) |
|
|
| lemma radius_bounds {ρ : ℝ} (hρ : ρ ≤ R.radius) : |
| 2 * ρ + R.a < R.δ ∧ 2 * ρ + 200 * R.a ≤ R.ζ * R.δ / 50 := by |
| have hw := R.width_bound |
| have hd := mul_lt_mul_of_pos_right R.zeta_lt_one R.delta_pos |
| have hz := mul_pos R.zeta_pos R.delta_pos |
| dsimp [radius] at hρ |
| constructor <;> nlinarith |
| |
| /-- One deterministic node formula, with identical atom names, represents the |
| pasted output on the whole small ball (including every zero-distance copy). |
| The node exists independently of the noises and the input. -/ |
| lemma common_formula (x : M.Point J root) {ρ : ℝ} (hρ : 0 ≤ ρ) (hs : ρ ≤ R.radius) : |
| ∃ k : ℕ, ∃ C : R.Node k, |
| (∀ z : M.Point J root, dist x z ≤ ρ → |
| (k : ℝ) * R.δ ≤ dist R.base (z.withHeight R.base.height R.base.inBand)) ∧ |
| (∀ (p : M.Point J root → ℝ) (α : Noise (n := n)), R.NoiseBounds α → |
| ∀ z : M.Point J root, dist x z ≤ ρ → R.pasted p α z = R.formula p α k C z) := by |
| obtain ⟨k, y, C, hy, hylo, hC⟩ := R.base.ball_two_layers R.closed_band x R.base.inBand |
| hρ R.delta_pos R.half_width (R.radius_bounds hs).1 |
| refine ⟨k, C, fun z hz => (hC z hz).2.1, ?_⟩ |
| intro p α hα z hz |
| obtain ⟨hzm, hzl, hzu⟩ := hC z hz |
| by_cases hlo : dist R.base (z.withHeight R.base.height R.base.inBand) < (k + 1 : ℕ) * R.δ |
| · exact R.pasted_eq_of_layer p α C z hzm hzl hlo |
| · have hzl' := le_of_not_gt hlo |
| let D := R.nodeOf (k + 1) z hzl' |
| have hD := R.mem_nodeOf (k + 1) z hzl' |
| have hparent : R.parent D = C := |
| ColumnOrder.component_eq_of_column (R.mem_parent D hD) hzm |
| have hyout : y.column ∉ ColumnOrder.componentColumns D := by |
| intro hym |
| have hry := (R.base.mem_superlevel_iff y R.base.height R.base.inBand (((k + 1 : ℕ) : ℝ) * R.δ)).mp |
| (ColumnOrder.componentColumns_subset D hym) |
| have hyp : dist R.base (y.withHeight R.base.height R.base.inBand) < ((k + 1 : ℕ) : ℝ) * R.δ := by |
| simpa only [Nat.cast_add, Nat.cast_one] using hylo |
| exact hyp.not_ge hry |
| have hexit := (R.portals D).near_exit R.closed_band z y hD hyout |
| have hzy : dist z y ≤ 2 * ρ := by |
| have ht := dist_triangle z x y |
| rw [dist_comm z x] at ht |
| linarith |
| have hcollar : R.portalDistance D z ≤ R.ζ * R.δ / 50 := by |
| dsimp only [portalDistance] |
| simp only [dist_comm z] at hexit |
| rw [dist_comm y z] at hexit |
| linarith [(R.radius_bounds hs).2] |
| have hupper : dist R.base (z.withHeight R.base.height R.base.inBand) < ((k + 1 + 1 : ℕ) : ℝ) * R.δ := by |
| simpa only [Nat.cast_add, Nat.cast_one, Nat.cast_ofNat, add_assoc, one_add_one_eq_two] using hzu |
| rw [R.pasted_eq_of_layer p α D z hD hzl' hupper, |
| R.formula_collar p hα D z hcollar, hparent] |
|
|
| lemma formula_congr_zero (p : M.Point J root → ℝ) (α : Noise (n := n)) |
| (k : ℕ) (C : R.Node k) (x y : M.Point J root) (hxy : dist x y = 0) : |
| R.formula p α k C x = R.formula p α k C y := by |
| have hd (w : M.Point J root) : dist w x = dist w y := by |
| apply le_antisymm |
| · have ht := dist_triangle w y x |
| rw [dist_comm y x, hxy, add_zero] at ht |
| exact ht |
| · have ht := dist_triangle w x y |
| rw [hxy, add_zero] at ht |
| exact ht |
| induction k with |
| | zero => simp only [formula, tentative, hd] |
| | succ k ih => simp only [formula, tentative, upperCone, lowerCone, hd, ih] |
|
|
| lemma pasted_congr_zero (p : M.Point J root → ℝ) {α : Noise (n := n)} |
| (hα : R.NoiseBounds α) (x y : M.Point J root) (hxy : dist x y = 0) : |
| R.pasted p α x = R.pasted p α y := by |
| obtain ⟨k, C, _, hC⟩ := R.common_formula x R.radius_pos.le le_rfl |
| rw [hC p α hα x (by simpa using R.radius_pos.le), hC p α hα y (by simpa [hxy] using R.radius_pos.le)] |
| exact R.formula_congr_zero p α k C x y hxy |
|
|
| lemma pasted_local_lipschitz (p : M.Point J root → ℝ) {α : Noise (n := n)} |
| (hα : R.NoiseBounds α) (x y : M.Point J root) (hxy : dist x y ≤ R.radius) : |
| |(R.pasted p α x).value - (R.pasted p α y).value| ≤ dist x y := by |
| obtain ⟨k, C, _, hC⟩ := R.common_formula x R.radius_pos.le le_rfl |
| rw [hC p α hα x (by simpa using R.radius_pos.le), hC p α hα y hxy] |
| simpa only [Real.dist_eq, NNReal.coe_one, one_mul] using (R.formula_lipschitz p α k C).dist_le_mul x y |
|
|
| /-- Uniform local unit bounds extend globally by genuine shortest-path |
| interpolation. No length-space axiom has been added. -/ |
| lemma pasted_lipschitz (p : M.Point J root → ℝ) {α : Noise (n := n)} (hα : R.NoiseBounds α) : |
| LipschitzWith 1 (fun v => (R.pasted p α v).value) := by |
| have bound (m : ℕ) : ∀ x y : M.Point J root, dist x y ≤ m * R.radius → |
| |(R.pasted p α x).value - (R.pasted p α y).value| ≤ dist x y := by |
| induction m with |
| | zero => |
| intro x y hxy |
| have hzero : dist x y ≤ 0 := by simpa only [Nat.cast_zero, zero_mul] using hxy |
| exact R.pasted_local_lipschitz p hα x y (hzero.trans R.radius_pos.le) |
| | succ m ih => |
| intro x y hxy |
| by_cases hsmall : dist x y ≤ R.radius |
| · exact R.pasted_local_lipschitz p hα x y hsmall |
| · obtain ⟨z, hxz, hzy⟩ := x.exists_between R.closed_band R.interval_band y |
| R.radius_pos.le (le_of_not_ge hsmall) |
| have hzsmall : dist z y ≤ m * R.radius := by |
| simp only [Nat.cast_succ, add_mul, one_mul] at hxy |
| linarith |
| have h₁ := R.pasted_local_lipschitz p hα x z hxz.le |
| have h₂ := ih z y hzsmall |
| have htri := abs_sub_le (R.pasted p α x).value (R.pasted p α z).value (R.pasted p α y).value |
| linarith |
| apply LipschitzWith.of_dist_le_mul |
| intro x y |
| obtain ⟨m, hm⟩ := exists_nat_ge (dist x y / R.radius) |
| have hdist := bound m x y ((div_le_iff₀ R.radius_pos).mp hm) |
| simpa only [Real.dist_eq, NNReal.coe_one, one_mul] using hdist |
|
|
|
|
| /-- Ancestors are constructed by inclusion of actual superlevel components. -/ |
| def ancestor {k : ℕ} (C : R.Node k) (j : ℕ) (hj : j ≤ k) : R.Node j := |
| ColumnOrder.componentAbove (R.superlevel_antitone hj) C |
|
|
| lemma mem_ancestor {k : ℕ} (C : R.Node k) (j : ℕ) (hj : j ≤ k) : |
| ColumnOrder.componentColumns C ⊆ ColumnOrder.componentColumns (R.ancestor C j hj) := |
| ColumnOrder.componentColumns_above _ C |
|
|
| lemma ancestor_self {k : ℕ} (C : R.Node k) (h : k ≤ k) : R.ancestor C k h = C := by |
| obtain ⟨i, hi⟩ := C.nonempty_supp |
| exact ColumnOrder.component_eq_of_column (R.mem_ancestor C k h ⟨i, hi, rfl⟩) ⟨i, hi, rfl⟩ |
|
|
| lemma ancestor_parent {k j : ℕ} (C : R.Node (k + 1)) (hj : j ≤ k) : |
| R.ancestor (R.parent C) j hj = R.ancestor C j (hj.trans (Nat.le_succ k)) := by |
| obtain ⟨i, hi⟩ := C.nonempty_supp |
| have hm : i.val ∈ ColumnOrder.componentColumns C := ⟨i, hi, rfl⟩ |
| exact ColumnOrder.component_eq_of_column |
| (R.mem_ancestor (R.parent C) j hj (R.mem_parent C hm)) (R.mem_ancestor C j _ hm) |
|
|
| lemma parent_ancestor {k j : ℕ} (C : R.Node k) (hj : j + 1 ≤ k) : |
| R.parent (R.ancestor C (j + 1) hj) = R.ancestor C j (by omega) := by |
| obtain ⟨i, hi⟩ := C.nonempty_supp |
| have hm : i.val ∈ ColumnOrder.componentColumns C := ⟨i, hi, rfl⟩ |
| exact ColumnOrder.component_eq_of_column |
| (R.mem_parent _ (R.mem_ancestor C (j + 1) hj hm)) (R.mem_ancestor C j _ hm) |
|
|
| /-- A name older than a chosen depth is inherited literally all the way back |
| through the actual hierarchy. Intercepts are not re-evaluated or renamed. -/ |
| lemma formula_inherits (p : M.Point J root → ℝ) (α : Noise (n := n)) |
| (k : ℕ) (C : R.Node k) (j : ℕ) (hj : j ≤ k) (v : M.Point J root) |
| (hname : (R.formula p α k C v).name < 3 * n * j) : |
| R.formula p α k C v = R.formula p α j (R.ancestor C j hj) v := by |
| induction k generalizing j with |
| | zero => |
| have hj0 : j = 0 := by omega |
| subst j |
| rw [R.ancestor_self] |
| | succ k ih => |
| by_cases hlast : j = k + 1 |
| · subst j |
| rw [R.ancestor_self] |
| · have hjk : j ≤ k := by omega |
| have hstep : R.formula p α (k + 1) C v = R.formula p α k (R.parent C) v := by |
| change nodeNamed _ _ _ _ = _ |
| apply nodeNamed_old (cutoff := 3 * n * j) |
| · exact (Nat.mul_le_mul_left (3 * n) hj).trans (R.upperCone_names _ _ C v).1 |
| · exact (Nat.mul_le_mul_left (3 * n) hj).trans (R.lowerCone_names _ _ C v).1 |
| · exact (Nat.mul_le_mul_left (3 * n) hj).trans (R.tentative_names p α C v).1 |
| · exact hname |
| have hi := ih (R.parent C) j hjk (by simpa only [hstep] using hname) |
| rw [R.ancestor_parent C hjk] at hi |
| exact hstep.trans hi |
|
|
| /-- A far node cannot output an accurate value carrying an earlier name. -/ |
| lemma formula_far_name {p : M.Point J root → ℝ} {α : Noise (n := n)} |
| (hp : R.InputLip p) (hα : R.NoiseBounds α) {k : ℕ} (C : R.Node (k + 1)) (v : M.Point J root) |
| (hfar : 13 * R.δ < R.ζ * R.portalDistance C v) |
| (hacc : |(R.formula p α (k + 1) C v).value - p v| ≤ 6 * R.δ) : |
| 3 * n * (k + 1) ≤ (R.formula p α (k + 1) C v).name := by |
| by_contra hn |
| have hn' := lt_of_not_ge hn |
| let F := R.formula p α k (R.parent C) |
| have hF : ∀ w, w = (R.portals C).left ∨ w = (R.portals C).right → |
| |(F w).value - p w| ≤ 5 * R.δ := R.formula_child_accuracy hp hα C |
| obtain ⟨hA, hB⟩ := R.cone_bounds hp hα C F hF v |
| have hT := (R.tentative_bounds hp hα C v).1 |
| have hsame : R.formula p α (k + 1) C v = F v := by |
| apply nodeNamed_old (R.upperCone_names F α C v).1 (R.lowerCone_names F α C v).1 |
| (R.tentative_names p α C v).1 hn' |
| have hparent : |(F v).value - p v| ≤ 6 * R.δ := by simpa only [hsame] using hacc |
| have hneq := (distant_node_overwrites R.delta_pos hparent |
| (show p v + 7 * R.δ < (R.upperCone F α C v).value by linarith [R.q_small, R.delta_pos]) |
| (show (R.lowerCone F α C v).value < p v - 7 * R.δ by linarith [R.q_small, R.delta_pos]) |
| (show p v + 13 * R.δ < (R.tentative p α C v).value by linarith [R.q_pos])).2 |
| apply hneq |
| have heq := congrArg NamedValue.value hsame |
| simpa only [formula, nodeNamed_value, F] using heq |
|
|
| /-- The source's lookback constant, independent of diameter and tree depth. -/ |
| noncomputable def lookback : ℕ := ⌈15 / R.ζ⌉₊ + 3 |
|
|
| lemma lookback_large : 15 ≤ R.ζ * (R.lookback : ℝ) := by |
| have hh := Nat.le_ceil (15 / R.ζ) |
| have hb : 15 / R.ζ ≤ (R.lookback : ℝ) := by |
| dsimp [lookback] |
| push_cast |
| linarith |
| have h := (div_le_iff₀ R.zeta_pos).mp hb |
| nlinarith |
|
|
| lemma ancestor_distance {k j : ℕ} (C : R.Node k) (hj : j ≤ k) (v : M.Point J root) |
| (hv : (k : ℝ) * R.δ ≤ dist R.base (v.withHeight R.base.height R.base.inBand)) : |
| ((k : ℝ) - j) * R.δ - 3 * R.a ≤ R.portalDistance (R.ancestor C j hj) v := by |
| let D := R.ancestor C j hj |
| have hver : dist v (v.withHeight R.base.height R.base.inBand) ≤ R.a / 2 := by |
| rw [v.dist_withHeight, abs_sub_comm] |
| exact R.half_width v.height v.inBand |
| have hrad := dist_triangle R.base v (v.withHeight R.base.height R.base.inBand) |
| have single (w : M.Point J root) (hw : dist R.base w < (j : ℝ) * R.δ + R.a) : |
| ((k : ℝ) - j) * R.δ - 3 * R.a ≤ dist w v := by |
| nlinarith [dist_triangle R.base w v, R.width_pos] |
| exact le_min (single (R.portals D).left (R.portals D).left_radial.2) |
| (single (R.portals D).right (R.portals D).right_radial.2) |
|
|
| lemma far_after_lookback {r : ℝ} (hr : (R.lookback : ℝ) * R.δ - 3 * R.a ≤ r) : |
| 13 * R.δ < R.ζ * r := by |
| have h₁ := mul_le_mul_of_nonneg_left hr R.zeta_pos.le |
| have h₂ := mul_le_mul_of_nonneg_right R.lookback_large R.delta_pos.le |
| have h₃ : R.ζ * R.a ≤ R.a := by |
| have hh := mul_lt_mul_of_pos_right R.zeta_lt_one R.width_pos |
| linarith |
| nlinarith [R.width_small, R.delta_pos] |
|
|
| /-- Selected names of an accurate node at high radial points originate no |
| more than `lookback` generations earlier. This is not an assumed depth bound. -/ |
| lemma formula_recent_bound {p : M.Point J root → ℝ} {α : Noise (n := n)} |
| (hp : R.InputLip p) (hα : R.NoiseBounds α) (k : ℕ) (C : R.Node k) (v : M.Point J root) |
| (hv : (k : ℝ) * R.δ ≤ dist R.base (v.withHeight R.base.height R.base.inBand)) |
| (ha : |(R.formula p α k C v).value - p v| ≤ 6 * R.δ) : |
| 3 * n * (k - R.lookback) ≤ (R.formula p α k C v).name := by |
| by_cases hk : k ≤ R.lookback |
| · simp only [Nat.sub_eq_zero_of_le hk, Nat.mul_zero, Nat.zero_le] |
| · have hmk : k - R.lookback ≤ k := Nat.sub_le _ _ |
| obtain ⟨j, hj⟩ := Nat.exists_eq_succ_of_ne_zero |
| (show k - R.lookback ≠ 0 by omega) |
| have hjk : j + 1 ≤ k := by omega |
| by_contra hname |
| have hn : (R.formula p α k C v).name < 3 * n * (j + 1) := by |
| simpa only [hj] using lt_of_not_ge hname |
| have heq := R.formula_inherits p α k C (j + 1) hjk v hn |
| let D := R.ancestor C (j + 1) hjk |
| have hacc : |(R.formula p α (j + 1) D v).value - p v| ≤ 6 * R.δ := by |
| simpa only [heq] using ha |
| have hfar := R.ancestor_distance C hjk v hv |
| have hcast : (k : ℝ) - (j + 1 : ℕ) = R.lookback := by |
| have hn : k = j + 1 + R.lookback := by omega |
| exact_mod_cast (show (k : ℤ) - (j + 1) = R.lookback by omega) |
| rw [hcast] at hfar |
| have hnew := R.formula_far_name hp hα D v (R.far_after_lookback hfar) hacc |
| rw [heq] at hn |
| exact hn.not_ge hnew |
|
|
|
|
| /-- The fixed enumeration remembers whichever portal occurrence generated a |
| name. Duplicated portals still produce the same name. -/ |
| noncomputable def portalAt {k : ℕ} (C : R.Node k) (i : Fin 2) : M.Point J root := |
| if i = 0 then (R.portals C).left else (R.portals C).right |
|
|
| noncomputable def nodeNames {k : ℕ} (C : R.Node k) : Finset ℕ := |
| Finset.univ.image (fun ij : Fin 2 × Fin 3 => atomName k (R.portalAt C ij.1) ij.2) |
|
|
| lemma nodeNames_card {k : ℕ} (C : R.Node k) : (R.nodeNames C).card ≤ 6 := by |
| calc |
| (R.nodeNames C).card ≤ (Finset.univ : Finset (Fin 2 × Fin 3)).card := Finset.card_image_le |
| _ = 6 := by simp |
|
|
| lemma nodeNames_mem {k : ℕ} (C : R.Node k) (i : Fin 2) (t : Fin 3) : |
| atomName k (R.portalAt C i) t ∈ R.nodeNames C := by |
| exact Finset.mem_image.mpr ⟨(i, t), Finset.mem_univ _, rfl⟩ |
|
|
| lemma nodeNames_left {k : ℕ} (C : R.Node k) (t : Fin 3) : |
| atomName k (R.portals C).left t ∈ R.nodeNames C := by |
| simpa [portalAt] using R.nodeNames_mem C 0 t |
|
|
| lemma nodeNames_right {k : ℕ} (C : R.Node k) (t : Fin 3) : |
| atomName k (R.portals C).right t ∈ R.nodeNames C := by |
| simpa only [portalAt, show (1 : Fin 2) ≠ 0 by decide, ite_false] using R.nodeNames_mem C 1 t |
|
|
| lemma nodeNames_bounds {k : ℕ} (C : R.Node k) {m : ℕ} (hm : m ∈ R.nodeNames C) : |
| 3 * n * k ≤ m ∧ m < 3 * n * (k + 1) := by |
| obtain ⟨⟨i,t⟩, _, rfl⟩ := Finset.mem_image.mp hm |
| exact atomName_bounds k (R.portalAt C i) t |
|
|
| lemma tentative_name_mem (p : M.Point J root → ℝ) (α : Noise (n := n)) |
| {k : ℕ} (C : R.Node k) (v : M.Point J root) : |
| (R.tentative p α C v).name ∈ R.nodeNames C := by |
| rcases minNamed_mem _ _ with h | h |
| · rw [tentative, h]; exact R.nodeNames_left C 0 |
| · rw [tentative, h]; exact R.nodeNames_right C 0 |
| |
| lemma upperCone_name_mem (F : M.Point J root → NamedValue) (α : Noise (n := n)) |
| {k : ℕ} (C : R.Node k) (v : M.Point J root) : |
| (R.upperCone F α C v).name ∈ R.nodeNames C := by |
| rcases minNamed_mem _ _ with h | h |
| · rw [upperCone, h]; exact R.nodeNames_left C 1 |
| · rw [upperCone, h]; exact R.nodeNames_right C 1 |
| |
| lemma lowerCone_name_mem (F : M.Point J root → NamedValue) (α : Noise (n := n)) |
| {k : ℕ} (C : R.Node k) (v : M.Point J root) : |
| (R.lowerCone F α C v).name ∈ R.nodeNames C := by |
| rcases maxNamed_mem _ _ with h | h |
| · rw [lowerCone, h]; exact R.nodeNames_left C 2 |
| · rw [lowerCone, h]; exact R.nodeNames_right C 2 |
| |
| lemma formula_name_origin (p : M.Point J root → ℝ) (α : Noise (n := n)) |
| (k : ℕ) (C : R.Node k) (v : M.Point J root) : |
| ∃ j : ℕ, ∃ hj : j ≤ k, |
| (R.formula p α k C v).name ∈ R.nodeNames (R.ancestor C j hj) := by |
| induction k with |
| | zero => |
| refine ⟨0, le_rfl, ?_⟩ |
| rw [R.ancestor_self] |
| exact R.tentative_name_mem p α C v |
| | succ k ih => |
| rw [formula] |
| rcases nodeNamed_mem _ _ _ _ with h | h | h | h |
| · obtain ⟨j, hj, hm⟩ := ih (R.parent C) |
| refine ⟨j, hj.trans (Nat.le_succ k), ?_⟩ |
| rw [h, ← R.ancestor_parent C hj] |
| exact hm |
| · refine ⟨k + 1, le_rfl, ?_⟩ |
| rw [h, R.ancestor_self] |
| exact R.upperCone_name_mem _ _ C v |
| · refine ⟨k + 1, le_rfl, ?_⟩ |
| rw [h, R.ancestor_self] |
| exact R.lowerCone_name_mem _ _ C v |
| · refine ⟨k + 1, le_rfl, ?_⟩ |
| rw [h, R.ancestor_self] |
| exact R.tentative_name_mem _ _ C v |
|
|
| /-- The deterministic, diameter-independent list at a node. -/ |
| noncomputable def recentNames {k : ℕ} (C : R.Node k) (L : ℕ) : Finset ℕ := |
| (Finset.Icc (k - L) k).attach.biUnion |
| (fun j => R.nodeNames (R.ancestor C j (Finset.mem_Icc.mp j.property).2)) |
|
|
| lemma recentNames_card {k : ℕ} (C : R.Node k) (L : ℕ) : |
| (R.recentNames C L).card ≤ 6 * (L + 1) := by |
| calc |
| (R.recentNames C L).card ≤ |
| ∑ j ∈ (Finset.Icc (k - L) k).attach, |
| (R.nodeNames (R.ancestor C j (Finset.mem_Icc.mp j.property).2)).card := |
| Finset.card_biUnion_le |
| _ ≤ ∑ _j ∈ (Finset.Icc (k - L) k).attach, 6 := |
| Finset.sum_le_sum (fun _ _ => R.nodeNames_card _) |
| _ = (k + 1 - (k - L)) * 6 := by simp |
| _ ≤ 6 * (L + 1) := by omega |
|
|
| lemma mem_recentNames {k j : ℕ} (C : R.Node k) (L : ℕ) (hj : j ≤ k) (hl : k - L ≤ j) |
| {m : ℕ} (hm : m ∈ R.nodeNames (R.ancestor C j hj)) : m ∈ R.recentNames C L := by |
| apply Finset.mem_biUnion.mpr |
| exact ⟨⟨j, Finset.mem_Icc.mpr ⟨hl, hj⟩⟩, Finset.mem_attach _ _, hm⟩ |
|
|
| lemma formula_name_recent {p : M.Point J root → ℝ} {α : Noise (n := n)} |
| (hp : R.InputLip p) (hα : R.NoiseBounds α) (k : ℕ) (C : R.Node k) (v : M.Point J root) |
| (hv : (k : ℝ) * R.δ ≤ dist R.base (v.withHeight R.base.height R.base.inBand)) |
| (ha : |(R.formula p α k C v).value - p v| ≤ 6 * R.δ) : |
| (R.formula p α k C v).name ∈ R.recentNames C R.lookback := by |
| obtain ⟨j, hj, hm⟩ := R.formula_name_origin p α k C v |
| have hlow := R.formula_recent_bound hp hα k C v hv ha |
| have hu := (R.nodeNames_bounds _ hm).2 |
| have hn : 0 < n := Nat.zero_lt_of_lt v.column.isLt |
| have hmul : 0 < 3 * n := by omega |
| have hjlow : k - R.lookback ≤ j := by |
| by_contra h |
| have hj' : j + 1 ≤ k - R.lookback := by omega |
| have hle := Nat.mul_le_mul_left (3 * n) hj' |
| omega |
| exact R.mem_recentNames C R.lookback hj hjlow hm |
|
|
| /-- The source's bounded local name theorem, derived from the actual tree and |
| from actual metric balls. Its list is fixed before input/noise sampling. -/ |
| lemma local_name_list (x : M.Point J root) {ρ : ℝ} (hρ : 0 ≤ ρ) (hs : ρ ≤ R.radius) : |
| ∃ S : Finset ℕ, S.card ≤ 6 * (R.lookback + 1) ∧ |
| ∀ (p : M.Point J root → ℝ) (α : Noise (n := n)), |
| R.InputLip p → R.NoiseBounds α → |
| ∀ z : M.Point J root, dist x z ≤ ρ → (R.pasted p α z).name ∈ S := by |
| obtain ⟨k, C, hlo, heq⟩ := R.common_formula x hρ hs |
| refine ⟨R.recentNames C R.lookback, R.recentNames_card C R.lookback, ?_⟩ |
| intro p α hp hα z hz |
| rw [heq p α hα z hz] |
| apply R.formula_name_recent hp hα k C z (hlo z hz) |
| rw [← heq p α hα z hz] |
| exact R.pasted_accuracy hp hα z |
|
|
| lemma portalAt_height {k : ℕ} (C : R.Node k) (i : Fin 2) : |
| (R.portalAt C i).height = R.base.height := by |
| dsimp only [portalAt] |
| split |
| · exact (R.portals C).left_height |
| · exact (R.portals C).right_height |
|
|
| lemma portalAt_eq_of_column {k : ℕ} (C : R.Node k) (i i' : Fin 2) |
| (h : (R.portalAt C i).column = (R.portalAt C i').column) : |
| R.portalAt C i = R.portalAt C i' := by |
| have hh := (R.portalAt_height C i).trans (R.portalAt_height C i').symm |
| have hext : ∀ x y : M.Point J root, x.column = y.column → x.height = y.height → x = y := by |
| rintro ⟨xc, xh, xb, xr⟩ ⟨yc, yh, yb, yr⟩ hc hh |
| cases hc |
| cases hh |
| rfl |
| exact hext _ _ h hh |
|
|
| lemma atomName_same_depth {k : ℕ} (u v : M.Point J root) (t t' : Fin 3) |
| (h : atomName k u t = atomName k v t') : u.column = v.column ∧ t = t' := by |
| have ht := t.isLt |
| have ht' := t'.isLt |
| simp only [atomName] at h |
| constructor <;> apply Fin.ext <;> omega |
| |
| /-- A node's parent intercept uses no noise from the current depth. The |
| root convention below merely fills unused clamping slots with the fixed input. -/ |
| noncomputable def parentValue (p : M.Point J root → ℝ) (α : Noise (n := n)) : |
| (k : ℕ) → R.Node k → M.Point J root → ℝ |
| | 0, _, v => p v |
| | k + 1, C, v => (R.formula p α k (R.parent C) v).value |
|
|
| noncomputable def atomIntercept (p : M.Point J root → ℝ) (α : Noise (n := n)) |
| {k : ℕ} (C : R.Node k) (i : Fin 2) (t : Fin 3) (v : M.Point J root) : ℝ := |
| (if t = 0 then p (R.portalAt C i) else R.parentValue p α k C (R.portalAt C i)) + |
| (if t = 2 then -dist (R.portalAt C i) v else dist (R.portalAt C i) v) |
|
|
| noncomputable def nodeAtom (p : M.Point J root → ℝ) (α : Noise (n := n)) |
| {k : ℕ} (C : R.Node k) (i : Fin 2) (t : Fin 3) (v : M.Point J root) : NamedValue := |
| ⟨atomName k (R.portalAt C i) t, |
| R.atomIntercept p α C i t v + |
| (if t = 1 then -α k (R.portalAt C i).column t else α k (R.portalAt C i).column t)⟩ |
|
|
| lemma tentative_eq_atom (p : M.Point J root → ℝ) (α : Noise (n := n)) |
| {k : ℕ} (C : R.Node k) (v : M.Point J root) : |
| ∃ i : Fin 2, R.tentative p α C v = R.nodeAtom p α C i 0 v := by |
| rcases minNamed_mem _ _ with h | h |
| · refine ⟨0, ?_⟩ |
| rw [tentative, h] |
| simp [nodeAtom, atomIntercept, portalAt] |
| · refine ⟨1, ?_⟩ |
| rw [tentative, h] |
| simp [nodeAtom, atomIntercept, portalAt] |
|
|
| lemma upperCone_eq_atom (p : M.Point J root → ℝ) (α : Noise (n := n)) |
| {k : ℕ} (C : R.Node (k + 1)) (v : M.Point J root) : |
| ∃ i : Fin 2, R.upperCone (R.formula p α k (R.parent C)) α C v = R.nodeAtom p α C i 1 v := by |
| rcases minNamed_mem _ _ with h | h |
| · refine ⟨0, ?_⟩ |
| rw [upperCone, h] |
| simp [nodeAtom, atomIntercept, portalAt, parentValue, sub_eq_add_neg] |
| · refine ⟨1, ?_⟩ |
| rw [upperCone, h] |
| simp [nodeAtom, atomIntercept, portalAt, parentValue, sub_eq_add_neg] |
|
|
| lemma lowerCone_eq_atom (p : M.Point J root → ℝ) (α : Noise (n := n)) |
| {k : ℕ} (C : R.Node (k + 1)) (v : M.Point J root) : |
| ∃ i : Fin 2, R.lowerCone (R.formula p α k (R.parent C)) α C v = R.nodeAtom p α C i 2 v := by |
| rcases maxNamed_mem _ _ with h | h |
| · refine ⟨0, ?_⟩ |
| rw [lowerCone, h] |
| simp [nodeAtom, atomIntercept, portalAt, parentValue, sub_eq_add_neg] |
| · refine ⟨1, ?_⟩ |
| rw [lowerCone, h] |
| simp [nodeAtom, atomIntercept, portalAt, parentValue, sub_eq_add_neg] |
|
|
| /-- Selection is of literal named functions, not just numerical atom names. -/ |
| lemma formula_eq_atom (p : M.Point J root → ℝ) (α : Noise (n := n)) |
| (k : ℕ) (C : R.Node k) (v : M.Point J root) : |
| ∃ j : ℕ, ∃ hj : j ≤ k, ∃ i : Fin 2, ∃ t : Fin 3, |
| R.formula p α k C v = R.nodeAtom p α (R.ancestor C j hj) i t v := by |
| induction k with |
| | zero => |
| obtain ⟨i, hi⟩ := R.tentative_eq_atom p α C v |
| exact ⟨0, le_rfl, i, 0, by simpa only [formula, R.ancestor_self] using hi⟩ |
| | succ k ih => |
| rw [formula] |
| rcases nodeNamed_mem _ _ _ _ with h | h | h | h |
| · obtain ⟨j, hj, i, t, heq⟩ := ih (R.parent C) |
| refine ⟨j, hj.trans (Nat.le_succ k), i, t, ?_⟩ |
| rw [h, ← R.ancestor_parent C hj] |
| exact heq |
| · obtain ⟨i, hi⟩ := R.upperCone_eq_atom p α C v |
| exact ⟨k + 1, le_rfl, i, 1, by simpa only [h, R.ancestor_self] using hi⟩ |
| · obtain ⟨i, hi⟩ := R.lowerCone_eq_atom p α C v |
| exact ⟨k + 1, le_rfl, i, 2, by simpa only [h, R.ancestor_self] using hi⟩ |
| · obtain ⟨i, hi⟩ := R.tentative_eq_atom p α C v |
| exact ⟨k + 1, le_rfl, i, 0, by simpa only [h, R.ancestor_self] using hi⟩ |
|
|
| lemma formula_noise_congr (p : M.Point J root → ℝ) (α β : Noise (n := n)) |
| (k : ℕ) (h : ∀ j ≤ k, ∀ i t, α j i t = β j i t) |
| (C : R.Node k) (v : M.Point J root) : R.formula p α k C v = R.formula p β k C v := by |
| induction k generalizing v with |
| | zero => simp only [formula, tentative, h 0 le_rfl] |
| | succ k ih => |
| have he : R.formula p α k (R.parent C) = R.formula p β k (R.parent C) := |
| funext (fun w => ih (fun j hj => h j (hj.trans (Nat.le_succ k))) (R.parent C) w) |
| simp only [formula, he, upperCone, lowerCone, tentative, h (k + 1) le_rfl] |
|
|
| lemma parentValue_noise_congr (p : M.Point J root → ℝ) (α β : Noise (n := n)) |
| (k : ℕ) (h : ∀ j < k, ∀ i t, α j i t = β j i t) |
| (C : R.Node k) (v : M.Point J root) : R.parentValue p α k C v = R.parentValue p β k C v := by |
| cases k with |
| | zero => rfl |
| | succ k => exact congrArg NamedValue.value (R.formula_noise_congr p α β k |
| (fun j hj => h j (Nat.lt_succ_of_le hj)) (R.parent C) v) |
|
|
| lemma atomIntercept_noise_congr (p : M.Point J root → ℝ) (α β : Noise (n := n)) |
| (k : ℕ) (h : ∀ j < k, ∀ i t, α j i t = β j i t) |
| (C : R.Node k) (i : Fin 2) (t : Fin 3) (v : M.Point J root) : |
| R.atomIntercept p α C i t v = R.atomIntercept p β C i t v := by |
| simp only [atomIntercept, R.parentValue_noise_congr p α β k h] |
|
|
| lemma nodeAtom_lipschitz (p : M.Point J root → ℝ) (α : Noise (n := n)) |
| {k : ℕ} (C : R.Node k) (i : Fin 2) (t : Fin 3) : |
| LipschitzWith 1 (fun v => (R.nodeAtom p α C i t v).value) := by |
| let c := (if t = 0 then p (R.portalAt C i) else R.parentValue p α k C (R.portalAt C i)) + |
| (if t = 1 then -α k (R.portalAt C i).column t else α k (R.portalAt C i).column t) |
| by_cases ht : t = 2 |
| · have he : (fun v => (R.nodeAtom p α C i t v).value) = (fun v => c - dist (R.portalAt C i) v) := by |
| funext v |
| simp only [nodeAtom, atomIntercept, ite_eq_left ht] |
| dsimp only [c] |
| ring |
| rw [he] |
| exact (distance_cone_lipschitz (R.portalAt C i) c).2 |
| · have he : (fun v => (R.nodeAtom p α C i t v).value) = (fun v => c + dist (R.portalAt C i) v) := by |
| funext v |
| simp only [nodeAtom, atomIntercept, ite_eq_right ht] |
| dsimp only [c] |
| ring |
| rw [he] |
| exact (distance_cone_lipschitz (R.portalAt C i) c).1 |
|
|
| lemma nodeAtom_eq_of_name (p : M.Point J root → ℝ) (α : Noise (n := n)) |
| {k : ℕ} (C : R.Node k) (i i' : Fin 2) (t t' : Fin 3) |
| (h : atomName k (R.portalAt C i) t = atomName k (R.portalAt C i') t') : |
| R.nodeAtom p α C i t = R.nodeAtom p α C i' t' := by |
| obtain ⟨hc, rfl⟩ := atomName_same_depth _ _ _ _ h |
| have he := R.portalAt_eq_of_column C i i' hc |
| funext v |
| simp only [nodeAtom, atomIntercept, he] |
|
|
| /-- Explicit positions in the ancestor chain. The name, not this occurrence, |
| is the randomized identity; opposite portal occurrences may coincide. -/ |
| abbrev ChainIndex (k : ℕ) := Fin (k + 1) × Fin 2 × Fin 3 |
|
|
| noncomputable def chainName {k : ℕ} (C : R.Node k) (u : ChainIndex k) : ℕ := |
| atomName u.1 (R.portalAt (R.ancestor C u.1 (Nat.le_of_lt_succ u.1.isLt)) u.2.1) u.2.2 |
|
|
| noncomputable def chainAtom (p : M.Point J root → ℝ) (α : Noise (n := n)) |
| {k : ℕ} (C : R.Node k) (u : ChainIndex k) : M.Point J root → NamedValue := |
| R.nodeAtom p α (R.ancestor C u.1 (Nat.le_of_lt_succ u.1.isLt)) u.2.1 u.2.2 |
|
|
| lemma chainName_bounds {k : ℕ} (C : R.Node k) (u : ChainIndex k) : |
| 3 * n * u.1.val ≤ R.chainName C u ∧ R.chainName C u < 3 * n * (u.1.val + 1) := |
| atomName_bounds _ _ _ |
|
|
| lemma chainAtom_eq_of_name (p : M.Point J root → ℝ) (α : Noise (n := n)) |
| {k : ℕ} (C : R.Node k) (u u' : ChainIndex k) (h : R.chainName C u = R.chainName C u') : |
| R.chainAtom p α C u = R.chainAtom p α C u' := by |
| have h₁ := R.chainName_bounds C u |
| have h₂ := R.chainName_bounds C u' |
| have hd : u.1.val = u'.1.val := by |
| rcases lt_trichotomy u.1.val u'.1.val with hl | he | hr |
| · have hb := Nat.mul_le_mul_left (3 * n) (Nat.succ_le_of_lt hl) |
| simp only [Nat.succ_eq_add_one] at hb |
| omega |
| · exact he |
| · have hb := Nat.mul_le_mul_left (3 * n) (Nat.succ_le_of_lt hr) |
| simp only [Nat.succ_eq_add_one] at hb |
| omega |
| rcases u with ⟨j, i, t⟩ |
| rcases u' with ⟨j', i', t'⟩ |
| have hj : j = j' := Fin.ext hd |
| subst j' |
| exact R.nodeAtom_eq_of_name p α _ i i' t t' h |
|
|
| lemma recentNames_representation {k : ℕ} (C : R.Node k) (L m : ℕ) |
| (hm : m ∈ R.recentNames C L) : ∃ u : ChainIndex k, R.chainName C u = m := by |
| obtain ⟨j, _, hj⟩ := Finset.mem_biUnion.mp hm |
| obtain ⟨⟨i,t⟩, _, he⟩ := Finset.mem_image.mp hj |
| exact ⟨(⟨j.val, Nat.lt_succ_of_le (Finset.mem_Icc.mp j.property).2⟩, i, t), he⟩ |
|
|
| noncomputable def representative {k : ℕ} (C : R.Node k) (L m : ℕ) |
| (hm : m ∈ R.recentNames C L) : ChainIndex k := |
| (R.recentNames_representation C L m hm).choose |
|
|
| lemma representative_name {k : ℕ} (C : R.Node k) (L m : ℕ) |
| (hm : m ∈ R.recentNames C L) : R.chainName C (R.representative C L m hm) = m := |
| (R.recentNames_representation C L m hm).choose_spec |
|
|
| /-- A fixed representation for each name, chosen from geometry before noises. |
| Off the list the harmless zero branch makes this a total function. -/ |
| noncomputable def listedAtom (p : M.Point J root → ℝ) (α : Noise (n := n)) |
| {k : ℕ} (C : R.Node k) (L m : ℕ) (v : M.Point J root) : NamedValue := |
| if hm : m ∈ R.recentNames C L then R.chainAtom p α C (R.representative C L m hm) v |
| else ⟨m, 0⟩ |
|
|
| lemma listedAtom_name (p : M.Point J root → ℝ) (α : Noise (n := n)) |
| {k : ℕ} (C : R.Node k) (L m : ℕ) (v : M.Point J root) : |
| (R.listedAtom p α C L m v).name = m := by |
| unfold listedAtom |
| split_ifs with hm |
| · exact R.representative_name C L m hm |
| · rfl |
|
|
| lemma listedAtom_lipschitz (p : M.Point J root → ℝ) (α : Noise (n := n)) |
| {k : ℕ} (C : R.Node k) (L m : ℕ) : |
| LipschitzWith 1 (fun v => (R.listedAtom p α C L m v).value) := by |
| unfold listedAtom |
| split_ifs with hm |
| · exact R.nodeAtom_lipschitz p α _ _ _ |
| · exact (LipschitzWith.const (0 : ℝ)).weaken (by simp) |
|
|
| lemma formula_eq_listed {p : M.Point J root → ℝ} {α : Noise (n := n)} |
| (hp : R.InputLip p) (hα : R.NoiseBounds α) (k : ℕ) (C : R.Node k) (v : M.Point J root) |
| (hv : (k : ℝ) * R.δ ≤ dist R.base (v.withHeight R.base.height R.base.inBand)) |
| (ha : |(R.formula p α k C v).value - p v| ≤ 6 * R.δ) : |
| R.formula p α k C v = R.listedAtom p α C R.lookback (R.formula p α k C v).name v := by |
| have hm := R.formula_name_recent hp hα k C v hv ha |
| obtain ⟨j, hj, i, t, he⟩ := R.formula_eq_atom p α k C v |
| rw [listedAtom, dite_eq_left hm] |
| let u : ChainIndex k := (⟨j, Nat.lt_succ_of_le hj⟩, i, t) |
| have hu : R.chainName C u = (R.formula p α k C v).name := (congrArg NamedValue.name he).symm |
| have hn := R.representative_name C R.lookback (R.formula p α k C v).name hm |
| have heq := congrFun (R.chainAtom_eq_of_name p α C u _ (hu.trans hn.symm)) v |
| exact he.trans heq |
|
|
| /-- The complete local list, including the actual named Lipschitz functions. |
| At most six atoms per recent ancestor survive. -/ |
| lemma local_atom_list (x : M.Point J root) {ρ : ℝ} (hρ : 0 ≤ ρ) (hs : ρ ≤ R.radius) : |
| ∃ k : ℕ, ∃ C : R.Node k, |
| ∀ (p : M.Point J root → ℝ) (α : Noise (n := n)), |
| R.InputLip p → R.NoiseBounds α → ∀ z : M.Point J root, dist x z ≤ ρ → |
| (R.pasted p α z).name ∈ R.recentNames C R.lookback ∧ |
| R.pasted p α z = R.listedAtom p α C R.lookback (R.pasted p α z).name z := by |
| obtain ⟨k, C, hlo, heq⟩ := R.common_formula x hρ hs |
| refine ⟨k, C, ?_⟩ |
| intro p α hp hα z hz |
| have ha : |(R.formula p α k C z).value - p z| ≤ 6 * R.δ := by |
| rw [← heq p α hα z hz] |
| exact R.pasted_accuracy hp hα z |
| rw [heq p α hα z hz] |
| exact ⟨R.formula_name_recent hp hα k C z (hlo z hz) ha, |
| R.formula_eq_listed hp hα k C z (hlo z hz) ha⟩ |
|
|
| /-- Off the finite near-tie event the selected name is constant. Direct |
| Lipschitz comparison proves this on the entire ball without a topological |
| selection argument, and also covers zero-distance representatives. -/ |
| lemma stable_names_of_no_tie (x : M.Point J root) {ρ : ℝ} (hρ : 0 ≤ ρ) |
| {k : ℕ} (C : R.Node k) (p : M.Point J root → ℝ) (α : Noise (n := n)) |
| (hα : R.NoiseBounds α) |
| (hlist : ∀ z : M.Point J root, dist x z ≤ ρ → |
| (R.pasted p α z).name ∈ R.recentNames C R.lookback ∧ |
| R.pasted p α z = R.listedAtom p α C R.lookback (R.pasted p α z).name z) |
| (hgap : ∀ m ∈ R.recentNames C R.lookback, ∀ m' ∈ R.recentNames C R.lookback, m ≠ m' → |
| 2 * ρ < |(R.listedAtom p α C R.lookback m x).value - |
| (R.listedAtom p α C R.lookback m' x).value|) : |
| ∀ z : M.Point J root, dist x z ≤ ρ → (R.pasted p α z).name = (R.pasted p α x).name := by |
| intro z hz |
| have hx := hlist x (by simpa using hρ) |
| have hz' := hlist z hz |
| by_contra hn |
| have hg := hgap (R.pasted p α x).name hx.1 (R.pasted p α z).name hz'.1 (Ne.symm hn) |
| have hl₁ := (R.pasted_lipschitz p hα).dist_le_mul x z |
| have hl₂ := (R.listedAtom_lipschitz p α C R.lookback (R.pasted p α z).name).dist_le_mul z x |
| simp only [Real.dist_eq, NNReal.coe_one, one_mul] at hl₁ hl₂ |
| rw [dist_comm z x] at hl₂ |
| have he₁ := congrArg NamedValue.value hx.2 |
| have he₂ := congrArg NamedValue.value hz'.2 |
| have ht := abs_sub_le (R.pasted p α x).value (R.pasted p α z).value |
| (R.listedAtom p α C R.lookback (R.pasted p α z).name x).value |
| rw [← he₂] at hl₂ |
| rw [← he₁] at hg |
| linarith |
|
|
| /-- Replacement of exactly one current interpolation noise. -/ |
| noncomputable def replaceNoise (α : Noise (n := n)) (d : ℕ) (c : Fin n) (t : Fin 3) (r : ℝ) : |
| Noise (n := n) := fun j i s => if j = d ∧ i = c ∧ s = t then r else α j i s |
|
|
| lemma replaceNoise_self (α : Noise (n := n)) (d : ℕ) (c : Fin n) (t : Fin 3) (r : ℝ) : |
| replaceNoise α d c t r d c t = r := by simp [replaceNoise] |
|
|
| lemma replaceNoise_other (α : Noise (n := n)) (d j : ℕ) (c i : Fin n) (t s : Fin 3) (r : ℝ) |
| (h : ¬ (j = d ∧ i = c ∧ s = t)) : replaceNoise α d c t r j i s = α j i s := by |
| simp only [replaceNoise, ite_eq_right h] |
|
|
| lemma atomIntercept_replace (p : M.Point J root → ℝ) (α : Noise (n := n)) |
| {k d : ℕ} (C : R.Node k) (i : Fin 2) (t : Fin 3) (v : M.Point J root) |
| (hd : k ≤ d) (c : Fin n) (s : Fin 3) (r : ℝ) : |
| R.atomIntercept p (replaceNoise α d c s r) C i t v = R.atomIntercept p α C i t v := by |
| apply R.atomIntercept_noise_congr |
| intro j hj u w |
| exact replaceNoise_other α d j c u s w r (by omega) |
|
|
| lemma nodeAtom_replace_self (p : M.Point J root → ℝ) (α : Noise (n := n)) |
| {k : ℕ} (C : R.Node k) (i : Fin 2) (t : Fin 3) (v : M.Point J root) (r : ℝ) : |
| (R.nodeAtom p (replaceNoise α k (R.portalAt C i).column t r) C i t v).value = |
| R.atomIntercept p α C i t v + (if t = 1 then -r else r) := by |
| simp only [nodeAtom, R.atomIntercept_replace p α C i t v le_rfl, |
| replaceNoise_self] |
|
|
| lemma nodeAtom_replace_other (p : M.Point J root → ℝ) (α : Noise (n := n)) |
| {k d : ℕ} (C : R.Node k) (i : Fin 2) (t : Fin 3) (v : M.Point J root) |
| (hd : k ≤ d) (c : Fin n) (s : Fin 3) (r : ℝ) |
| (h : ¬ (k = d ∧ (R.portalAt C i).column = c ∧ t = s)) : |
| R.nodeAtom p (replaceNoise α d c s r) C i t v = R.nodeAtom p α C i t v := by |
| simp only [nodeAtom, R.atomIntercept_replace p α C i t v hd, |
| replaceNoise_other α d k c (R.portalAt C i).column s t r h] |
|
|
| /-- Every distinct pair on the ancestor chain has a fresh coordinate: after |
| all other noises are fixed, their difference is affine with slope ±1 in it. -/ |
| lemma chainPair_fresh (p : M.Point J root → ℝ) {k : ℕ} (C : R.Node k) |
| (u u' : ChainIndex k) (hne : R.chainName C u ≠ R.chainName C u') (v : M.Point J root) : |
| ∃ d ≤ k, ∃ c : Fin n, ∃ s : Fin 3, |
| ∀ α : Noise (n := n), ∃ b : ℝ, |
| (∀ r : ℝ, (R.chainAtom p (replaceNoise α d c s r) C u v).value - |
| (R.chainAtom p (replaceNoise α d c s r) C u' v).value = b + r) ∨ |
| (∀ r : ℝ, (R.chainAtom p (replaceNoise α d c s r) C u v).value - |
| (R.chainAtom p (replaceNoise α d c s r) C u' v).value = b - r) := by |
| let D := R.ancestor C u.1 (Nat.le_of_lt_succ u.1.isLt) |
| let D' := R.ancestor C u'.1 (Nat.le_of_lt_succ u'.1.isLt) |
| have hcoord : ¬ (u.1.val = u'.1.val ∧ |
| (R.portalAt D u.2.1).column = (R.portalAt D' u'.2.1).column ∧ u.2.2 = u'.2.2) := by |
| rintro ⟨hd, hc, ht⟩ |
| apply hne |
| simp only [chainName, atomName] |
| change 3 * (n * u.1.val + (R.portalAt D u.2.1).column.val) + u.2.2.val = |
| 3 * (n * u'.1.val + (R.portalAt D' u'.2.1).column.val) + u'.2.2.val |
| simp only [hd, hc, ht] |
| by_cases hd : u.1.val ≤ u'.1.val |
| · refine ⟨u'.1, Nat.le_of_lt_succ u'.1.isLt, (R.portalAt D' u'.2.1).column, u'.2.2, ?_⟩ |
| intro α |
| refine ⟨(R.chainAtom p α C u v).value - R.atomIntercept p α D' u'.2.1 u'.2.2 v, ?_⟩ |
| by_cases hs : u'.2.2 = 1 |
| · left |
| intro r |
| dsimp only [chainAtom] |
| rw [R.nodeAtom_replace_other p α D _ _ v hd _ _ r hcoord, |
| R.nodeAtom_replace_self p α D' _ _ v r, ite_eq_left hs] |
| ring |
| · right |
| intro r |
| dsimp only [chainAtom] |
| rw [R.nodeAtom_replace_other p α D _ _ v hd _ _ r hcoord, |
| R.nodeAtom_replace_self p α D' _ _ v r, ite_eq_right hs] |
| ring |
| · have hd' : u'.1.val ≤ u.1.val := by omega |
| have hcoord' : ¬ (u'.1.val = u.1.val ∧ |
| (R.portalAt D' u'.2.1).column = (R.portalAt D u.2.1).column ∧ u'.2.2 = u.2.2) := by |
| rintro ⟨he, hc, ht⟩ |
| exact hcoord ⟨he.symm, hc.symm, ht.symm⟩ |
| refine ⟨u.1, Nat.le_of_lt_succ u.1.isLt, (R.portalAt D u.2.1).column, u.2.2, ?_⟩ |
| intro α |
| refine ⟨R.atomIntercept p α D u.2.1 u.2.2 v - (R.chainAtom p α C u' v).value, ?_⟩ |
| by_cases hs : u.2.2 = 1 |
| · right |
| intro r |
| dsimp only [chainAtom] |
| rw [R.nodeAtom_replace_other p α D' _ _ v hd' _ _ r hcoord', |
| R.nodeAtom_replace_self p α D _ _ v r, ite_eq_left hs] |
| ring |
| · left |
| intro r |
| dsimp only [chainAtom] |
| rw [R.nodeAtom_replace_other p α D' _ _ v hd' _ _ r hcoord', |
| R.nodeAtom_replace_self p α D _ _ v r, ite_eq_right hs] |
| ring |
|
|
| /-- The finite noise sample space used by the construction. -/ |
| abbrev GridSample (cap m : ℕ) := (Fin cap × Fin n × Fin 3) → Fin (m + 1) |
|
|
| noncomputable def gridNoise (cap m : ℕ) (ω : GridSample (n := n) cap m) : Noise (n := n) := |
| fun j i t => if hj : j < cap then R.q + R.q / m * (ω (⟨j,hj⟩,i,t)).val else R.q |
|
|
| lemma gridNoise_bounds (cap m : ℕ) (hm : 0 < m) (ω : GridSample (n := n) cap m) : |
| R.NoiseBounds (R.gridNoise cap m ω) := by |
| intro j i t |
| have hm' : (0 : ℝ) < m := by exact_mod_cast hm |
| have hstep : 0 < R.q / m := div_pos R.q_pos hm' |
| have hmul : R.q / (m : ℝ) * m = R.q := div_mul_cancel₀ R.q (ne_of_gt hm') |
| simp only [gridNoise] |
| split_ifs with hj |
| · have hval : ((ω (⟨j,hj⟩,i,t)).val : ℝ) ≤ m := by |
| exact_mod_cast Nat.le_of_lt_succ (ω (⟨j,hj⟩,i,t)).isLt |
| have hhi := mul_le_mul_of_nonneg_left hval hstep.le |
| rw [hmul] at hhi |
| have hlo := mul_nonneg hstep.le (Nat.cast_nonneg (ω (⟨j,hj⟩,i,t)).val) |
| constructor <;> linarith |
| · constructor <;> linarith [R.q_pos] |
| |
| lemma gridNoise_update (cap m : ℕ) (ω : GridSample (n := n) cap m) |
| (d : ℕ) (hd : d < cap) (c : Fin n) (s : Fin 3) (r : Fin (m + 1)) : |
| R.gridNoise cap m (Function.update ω (⟨d,hd⟩,c,s) r) = |
| replaceNoise (R.gridNoise cap m ω) d c s (R.q + R.q / m * r.val) := by |
| funext j i t |
| by_cases hj : j < cap |
| · by_cases he : (⟨j,hj⟩,i,t) = ((⟨d,hd⟩ : Fin cap),c,s) |
| · have hparts := Prod.mk.inj he |
| have hjd : j = d := congrArg Fin.val hparts.1 |
| obtain ⟨hic, hts⟩ := Prod.mk.inj hparts.2 |
| subst j |
| subst i |
| subst t |
| simp only [gridNoise, dite_eq_left hd, Function.update_self, replaceNoise_self] |
| · have hne : ¬ (j = d ∧ i = c ∧ t = s) := by |
| rintro ⟨hjd, hic, hts⟩ |
| exact he (by subst j; subst i; subst t; rfl) |
| rw [replaceNoise_other _ d j c i s t _ hne] |
| simp only [gridNoise, dite_eq_left hj, Function.update_of_ne he] |
| · have hne : ¬ (j = d ∧ i = c ∧ t = s) := fun h => hj (h.1 ▸ hd) |
| rw [replaceNoise_other _ d j c i s t _ hne] |
| simp only [gridNoise, dite_eq_right hj] |
|
|
| /-- The radial profile has only finitely many values, one per reachable column. |
| This explicit cap bounds every node ever used by the pasted field. -/ |
| noncomputable def depthCap : ℕ := by |
| classical |
| exact 1 + ∑ i : Fin n, |
| if hi : (M.activeGraph J).Reachable root i then |
| ⌊dist R.base (⟨i, R.base.height, R.base.inBand, hi⟩ : M.Point J root) / R.δ⌋₊ else 0 |
|
|
| lemma layerDepth_lt_cap (v : M.Point J root) : R.layerDepth v < R.depthCap := by |
| classical |
| let g : Fin n → ℕ := fun i => if hi : (M.activeGraph J).Reachable root i then |
| ⌊dist R.base (⟨i, R.base.height, R.base.inBand, hi⟩ : M.Point J root) / R.δ⌋₊ else 0 |
| have hsum := Finset.single_le_sum (s := Finset.univ) (f := g) (fun i _ => Nat.zero_le (g i)) |
| (Finset.mem_univ v.column) |
| have he : R.layerDepth v = g v.column := by |
| simp only [g, dite_eq_left v.reachable, layerDepth, withHeight] |
| dsimp only [depthCap] |
| change R.layerDepth v < 1 + ∑ i, g i |
| omega |
|
|
| lemma depth_le_layerDepth {k : ℕ} (v : M.Point J root) |
| (hk : (k : ℝ) * R.δ ≤ dist R.base (v.withHeight R.base.height R.base.inBand)) : |
| k ≤ R.layerDepth v := by |
| apply Nat.le_floor |
| exact (le_div_iff₀ R.delta_pos).mpr hk |
|
|
|
|
| lemma chainPair_probability (p : M.Point J root → ℝ) {k : ℕ} (C : R.Node k) |
| (u u' : ChainIndex k) (hne : R.chainName C u ≠ R.chainName C u') |
| (v : M.Point J root) (cap m : ℕ) (hk : k < cap) (hm : 0 < m) |
| {t : ℝ} (ht : 0 ≤ t) : |
| FiniteRandom.prob (fun ω : GridSample (n := n) cap m => |
| |(R.chainAtom p (R.gridNoise cap m ω) C u v).value - |
| (R.chainAtom p (R.gridNoise cap m ω) C u' v).value| ≤ t) ≤ |
| (2 * t + R.q / m) / R.q := by |
| classical |
| obtain ⟨d, hd, c, s, hf⟩ := R.chainPair_fresh p C u u' hne v |
| have hdc : d < cap := hd.trans_lt hk |
| apply FiniteRandom.coordinate_probability (⟨d,hdc⟩,c,s) m hm R.q_pos ht |
| intro ω |
| obtain ⟨b, hb⟩ := hf (R.gridNoise cap m ω) |
| rcases hb with hb | hb |
| · refine ⟨b + R.q, Or.inl ?_⟩ |
| intro r |
| rw [R.gridNoise_update cap m ω d hdc c s r, hb] |
| ring |
| · refine ⟨b - R.q, Or.inr ?_⟩ |
| intro r |
| rw [R.gridNoise_update cap m ω d hdc c s r, hb] |
| ring |
|
|
| lemma listedPair_probability (p : M.Point J root → ℝ) {k : ℕ} (C : R.Node k) |
| (L i j : ℕ) (hi : i ∈ R.recentNames C L) (hj : j ∈ R.recentNames C L) (hne : i ≠ j) |
| (v : M.Point J root) (cap m : ℕ) (hk : k < cap) (hm : 0 < m) |
| {t : ℝ} (ht : 0 ≤ t) : |
| FiniteRandom.prob (fun ω : GridSample (n := n) cap m => |
| |(R.listedAtom p (R.gridNoise cap m ω) C L i v).value - |
| (R.listedAtom p (R.gridNoise cap m ω) C L j v).value| ≤ t) ≤ |
| (2 * t + R.q / m) / R.q := by |
| have hn : R.chainName C (R.representative C L i hi) ≠ |
| R.chainName C (R.representative C L j hj) := by |
| simpa only [R.representative_name] using hne |
| simpa only [listedAtom, dite_eq_left hi, dite_eq_left hj] using |
| R.chainPair_probability p C _ _ hn v cap m hk hm ht |
|
|
| /-- Actual finite-grid anti-concentration for a changed interpolation atom name |
| anywhere on the closed ball. Its list and depth cap were constructed strictly |
| from the geometry before sampling the fresh independent coordinates. -/ |
| lemma local_name_probability (p : M.Point J root → ℝ) (hp : R.InputLip p) |
| (x : M.Point J root) {ρ : ℝ} (hρ : 0 ≤ ρ) (hs : ρ ≤ R.radius) |
| (m : ℕ) (hm : 0 < m) : |
| FiniteRandom.prob (fun ω : GridSample (n := n) R.depthCap m => |
| ∃ z : M.Point J root, dist x z ≤ ρ ∧ |
| (R.pasted p (R.gridNoise R.depthCap m ω) z).name ≠ |
| (R.pasted p (R.gridNoise R.depthCap m ω) x).name) ≤ |
| (6 * (R.lookback + 1) : ℕ)^2 * ((4 * ρ + R.q / m) / R.q) := by |
| classical |
| obtain ⟨k, C, hlo, heq⟩ := R.common_formula x hρ hs |
| have hk : k < R.depthCap := |
| (R.depth_le_layerDepth x (hlo x (by simpa using hρ))).trans_lt (R.layerDepth_lt_cap x) |
| have hlist (ω : GridSample (n := n) R.depthCap m) (z : M.Point J root) (hz : dist x z ≤ ρ) : |
| (R.pasted p (R.gridNoise R.depthCap m ω) z).name ∈ R.recentNames C R.lookback ∧ |
| R.pasted p (R.gridNoise R.depthCap m ω) z = |
| R.listedAtom p (R.gridNoise R.depthCap m ω) C R.lookback |
| (R.pasted p (R.gridNoise R.depthCap m ω) z).name z := by |
| have hα := R.gridNoise_bounds R.depthCap m hm ω |
| have ha : |(R.formula p (R.gridNoise R.depthCap m ω) k C z).value - p z| ≤ 6 * R.δ := by |
| rw [← heq p _ hα z hz] |
| exact R.pasted_accuracy hp hα z |
| rw [heq p _ hα z hz] |
| exact ⟨R.formula_name_recent hp hα k C z (hlo z hz) ha, |
| R.formula_eq_listed hp hα k C z (hlo z hz) ha⟩ |
| have hsub : ∀ ω : GridSample (n := n) R.depthCap m, |
| (∃ z : M.Point J root, dist x z ≤ ρ ∧ |
| (R.pasted p (R.gridNoise R.depthCap m ω) z).name ≠ |
| (R.pasted p (R.gridNoise R.depthCap m ω) x).name) → |
| ∃ i ∈ R.recentNames C R.lookback, ∃ j ∈ R.recentNames C R.lookback, |
| i ≠ j ∧ |(R.listedAtom p (R.gridNoise R.depthCap m ω) C R.lookback i x).value - |
| (R.listedAtom p (R.gridNoise R.depthCap m ω) C R.lookback j x).value| ≤ 2 * ρ := by |
| intro ω hbad |
| by_contra hn |
| have hgap : ∀ i ∈ R.recentNames C R.lookback, ∀ j ∈ R.recentNames C R.lookback, i ≠ j → |
| 2 * ρ < |(R.listedAtom p (R.gridNoise R.depthCap m ω) C R.lookback i x).value - |
| (R.listedAtom p (R.gridNoise R.depthCap m ω) C R.lookback j x).value| := by |
| intro i hi j hj hij |
| exact lt_of_not_ge (fun ht => hn ⟨i,hi,j,hj,hij,ht⟩) |
| obtain ⟨z, hz, hne⟩ := hbad |
| exact hne (R.stable_names_of_no_tie x hρ C p _ (R.gridNoise_bounds _ _ hm ω) |
| (hlist ω) hgap z hz) |
| have hb : 0 ≤ (4 * ρ + R.q / m) / R.q := by |
| have hq := R.q_pos |
| positivity |
| have hprob := FiniteRandom.prob_pair_bound (R.recentNames C R.lookback) |
| (fun i j (ω : GridSample (n := n) R.depthCap m) => |
| |(R.listedAtom p (R.gridNoise R.depthCap m ω) C R.lookback i x).value - |
| (R.listedAtom p (R.gridNoise R.depthCap m ω) C R.lookback j x).value| ≤ 2 * ρ) hb |
| (fun i hi j hj hij => by |
| simpa only [show 2 * (2 * ρ) = 4 * ρ by ring] using |
| R.listedPair_probability p C R.lookback i j hi hj hij x R.depthCap m hk hm |
| (t := 2 * ρ) (by positivity)) |
| refine (FiniteRandom.prob_mono hsub).trans (hprob.trans ?_) |
| apply mul_le_mul_of_nonneg_right _ hb |
| exact pow_le_pow_left₀ (Nat.cast_nonneg _) (by exact_mod_cast R.recentNames_card C R.lookback) _ |
|
|
| end RadialTree |
|
|
|
|
| end Point |
|
|
| end Model |
| end Columns |
| end PlanarL1 |
|
|
| end |
|
|
| section |
|
|
| namespace PlanarL1.Columns.Model.Point.RadialTree |
| open PlanarL1.Interpolation |
| variable {n : ℕ} {M : Model n} {J : Set ℝ} {root : Fin n} |
| variable (R : RadialTree (M := M) (J := J) (root := root)) |
|
|
| /-- Comparison with a fixed old field uses the current atom's own offset, not |
| an unjustified independence assertion about its inherited intercept. -/ |
| lemma chainConstant_probability (p : M.Point J root → ℝ) {k : ℕ} |
| (C : R.Node k) (u : ChainIndex k) (v : M.Point J root) (c : ℝ) |
| (cap m : ℕ) (hk : k < cap) (hm : 0 < m) {t : ℝ} (ht : 0 ≤ t) : |
| FiniteRandom.prob (fun ω : GridSample (n := n) cap m => |
| |(R.chainAtom p (R.gridNoise cap m ω) C u v).value-c| ≤ t) ≤ |
| (2*t+R.q/m)/R.q := by |
| let D := R.ancestor C u.1 (Nat.le_of_lt_succ u.1.isLt) |
| have hd : u.1.val < cap := (Nat.le_of_lt_succ u.1.isLt).trans_lt hk |
| apply FiniteRandom.coordinate_probability |
| (⟨u.1,hd⟩,(R.portalAt D u.2.1).column,u.2.2) m hm R.q_pos ht |
| intro ω |
| by_cases hs : u.2.2 = 1 |
| · refine ⟨R.atomIntercept p (R.gridNoise cap m ω) D u.2.1 u.2.2 v-c-R.q,Or.inr ?_⟩ |
| intro r |
| rw [R.gridNoise_update cap m ω u.1 hd (R.portalAt D u.2.1).column u.2.2 r] |
| dsimp only [chainAtom] |
| rw [R.nodeAtom_replace_self p _ D _ _ v _,ite_eq_left hs] |
| ring |
| · refine ⟨R.atomIntercept p (R.gridNoise cap m ω) D u.2.1 u.2.2 v-c+R.q,Or.inl ?_⟩ |
| intro r |
| rw [R.gridNoise_update cap m ω u.1 hd (R.portalAt D u.2.1).column u.2.2 r] |
| dsimp only [chainAtom] |
| rw [R.nodeAtom_replace_self p _ D _ _ v _,ite_eq_right hs] |
| ring |
|
|
| lemma listedConstant_probability (p : M.Point J root → ℝ) {k : ℕ} |
| (C : R.Node k) (L i : ℕ) (hi : i ∈ R.recentNames C L) |
| (v : M.Point J root) (c : ℝ) (cap m : ℕ) (hk : k < cap) (hm : 0 < m) |
| {t : ℝ} (ht : 0 ≤ t) : |
| FiniteRandom.prob (fun ω : GridSample (n := n) cap m => |
| |(R.listedAtom p (R.gridNoise cap m ω) C L i v).value-c| ≤ t) ≤ |
| (2*t+R.q/m)/R.q := by |
| simpa only [listedAtom,dite_eq_left hi] using |
| R.chainConstant_probability p C (R.representative C L i hi) v c cap m hk hm ht |
|
|
| /-- Between independent interpolations, conditioning on the other full sample |
| still leaves the chosen atom's fresh coordinate available. -/ |
| lemma listedIndependent_probability {Ω : Type*} [Fintype Ω] [Nonempty Ω] |
| (p : M.Point J root → ℝ) {k : ℕ} (C : R.Node k) (L i : ℕ) |
| (hi : i ∈ R.recentNames C L) (v : M.Point J root) (other : Ω → ℝ) |
| (cap m : ℕ) (hk : k < cap) (hm : 0 < m) {t : ℝ} (ht : 0 ≤ t) : |
| FiniteRandom.prob (fun ω : GridSample (n := n) cap m × Ω => |
| |(R.listedAtom p (R.gridNoise cap m ω.1) C L i v).value-other ω.2| ≤ t) ≤ |
| (2*t+R.q/m)/R.q := by |
| apply FiniteRandom.prob_prod_bound_left |
| intro z |
| exact R.listedConstant_probability p C L i hi v (other z) cap m hk hm ht |
|
|
| end PlanarL1.Columns.Model.Point.RadialTree |
|
|
|
|
|
|
|
|
| end |
|
|
| end OAI |
|
|
