| import OAI.Analysis.ForestSpace.Segments |
|
|
| namespace OAI |
|
|
| open scoped BigOperators |
| open Finset |
|
|
| namespace ForestSpace |
|
|
| noncomputable section |
| attribute [local instance] Classical.propDecidable |
|
|
| section FiniteGeometry |
| variable {V : Type} [Fintype V] [PartialOrder V] |
|
|
| /-- The ancestral interval [a,g), ending immediately before g along its path. -/ |
| noncomputable def before (a g : V) : Finset V := by |
| classical |
| exact univ.filter (fun v => a ≤ v ∧ v < g) |
|
|
| @[simp] theorem mem_before {a g v : V} : v ∈ before a g ↔ a ≤ v ∧ v < g := by |
| classical |
| simp [before] |
|
|
| theorem isSegment_before (hF : ForestOrder V) (a g : V) : IsSegment (before a g) := by |
| constructor |
| · intro v hv w hw |
| exact hF v w g (mem_before.mp hv).2.le (mem_before.mp hw).2.le |
| · intro v hv w hw z hvz hzw |
| exact mem_before.mpr ⟨(mem_before.mp hv).1.trans hvz, |
| lt_of_le_of_lt hzw (mem_before.mp hw).2⟩ |
|
|
| theorem before_mono {a b g : V} (hab : a ≤ b) : before b g ⊆ before a g := by |
| intro v hv |
| exact mem_before.mpr ⟨hab.trans (mem_before.mp hv).1, (mem_before.mp hv).2⟩ |
|
|
| theorem before_subset_head {H : Set V} {g a : V} (hg : Gate H g) : |
| ∀ v ∈ before a g, v ∈ H := by |
| intro v hv |
| exact hg.2 v (mem_before.mp hv).2 |
|
|
| theorem IsSegment.head_eq_before {H : Set V} (hH : IsLowerSet H) |
| {S : Finset V} (hS : IsSegment S) {g : V} (hg : Gate H g) (hgs : g ∈ S) |
| (hp : ∃ a ∈ S, a ∈ H) : |
| ∃ a, a < g ∧ S.filter (· ∈ H) = before a g := by |
| classical |
| obtain ⟨a, ha, b, hb, hab⟩ := hS.endpoints ⟨g, hgs⟩ |
| have haH : a ∈ H := by |
| obtain ⟨w, hw, hwH⟩ := hp |
| exact hH ((hab w).mp hw).1 hwH |
| have hag : a < g := lt_of_le_of_ne ((hab g).mp hgs).1 |
| (fun h => hg.1 (h ▸ haH)) |
| refine ⟨a, hag, ?_⟩ |
| ext v |
| simp only [mem_filter, mem_before] |
| constructor |
| · rintro ⟨hv, hvH⟩ |
| refine ⟨((hab v).mp hv).1, ?_⟩ |
| have hvg : v ≤ g := (hS.1 v hv g hgs).resolve_right (fun h => hg.1 (hH h hvH)) |
| exact lt_of_le_of_ne hvg (fun he => hg.1 (he ▸ hvH)) |
| · rintro ⟨hav, hvg⟩ |
| exact ⟨hS.2 a ha g hgs v hav hvg.le, hg.2 v hvg⟩ |
|
|
| /-- Removing a terminal suffix from any segment leaves a segment. -/ |
| theorem IsSegment.sdiff_before {S : Finset V} (hS : IsSegment S) {a b g : V} |
| (hSa : S = before a g) : IsSegment (S \ before b g) := by |
| classical |
| subst S |
| constructor |
| · intro v hv w hw |
| exact hS.1 v (mem_sdiff.mp hv).1 w (mem_sdiff.mp hw).1 |
| · intro v hv w hw z hvz hzw |
| have hz := hS.2 v (mem_sdiff.mp hv).1 w (mem_sdiff.mp hw).1 z hvz hzw |
| refine mem_sdiff.mpr ⟨hz, ?_⟩ |
| intro hzb |
| apply (mem_sdiff.mp hw).2 |
| exact mem_before.mpr ⟨(mem_before.mp hzb).1.trans hzw, |
| (mem_before.mp (mem_sdiff.mp hw).1).2⟩ |
|
|
| /-- The closed ancestral interval [g,w]. -/ |
| noncomputable def along (g w : V) : Finset V := |
| univ.filter (fun v => g ≤ v ∧ v ≤ w) |
|
|
| @[simp] theorem mem_along {g w v : V} : v ∈ along g w ↔ g ≤ v ∧ v ≤ w := by |
| simp [along] |
|
|
| theorem isSegment_along (hF : ForestOrder V) (g w : V) : IsSegment (along g w) := by |
| constructor |
| · intro a ha b hb |
| exact hF a b w (mem_along.mp ha).2 (mem_along.mp hb).2 |
| · intro a ha b hb c hac hcb |
| exact mem_along.mpr ⟨(mem_along.mp ha).1.trans hac, hcb.trans (mem_along.mp hb).2⟩ |
|
|
| theorem IsSegment.tail_eq_along {H : Set V} (hH : IsLowerSet H) |
| {S : Finset V} (hS : IsSegment S) {g : V} (hg : Gate H g) (hgs : g ∈ S) : |
| ∃ b, S.filter (· ∉ H) = along g b := by |
| obtain ⟨a, ha, b, hb, hab⟩ := hS.endpoints ⟨g, hgs⟩ |
| refine ⟨b, ?_⟩ |
| ext v |
| simp only [mem_filter, mem_along] |
| constructor |
| · rintro ⟨hv, hvH⟩ |
| refine ⟨?_, ((hab v).mp hv).2⟩ |
| rcases hS.1 g hgs v hv with hgv | hvg |
| · exact hgv |
| · by_contra hngv |
| exact hvH (hg.2 v (lt_of_le_not_ge hvg hngv)) |
| · rintro ⟨hgv, hvb⟩ |
| exact ⟨hS.2 g hgs b hb v hgv hvb, fun hv => hg.1 (hH hgv hv)⟩ |
|
|
| /-- Maximal initial-segment mass of a test inside the cone at g. -/ |
| noncomputable def mass (k : V → ℝ) (g : V) : ℝ := |
| univ.sup' ⟨g, mem_univ g⟩ (fun w => |segSum k (along g w)|) |
| |
| theorem abs_segSum_along_le (k : V → ℝ) (g w : V) : |
| |segSum k (along g w)| ≤ mass k g := |
| le_sup' (fun w => |segSum k (along g w)|) (mem_univ w) |
|
|
| theorem mass_nonneg (k : V → ℝ) (g : V) : 0 ≤ mass k g := |
| (abs_nonneg _).trans (abs_segSum_along_le k g g) |
|
|
| theorem mass_attained (k : V → ℝ) (g : V) : |
| ∃ w, mass k g = |segSum k (along g w)| := by |
| obtain ⟨w, hw, he⟩ := exists_mem_eq_sup' (⟨g, mem_univ g⟩ : (univ : Finset V).Nonempty) |
| (fun w => |segSum k (along g w)|) |
| exact ⟨w, he⟩ |
|
|
| theorem gate_mass_bound (hF : ForestOrder V) {k : V → ℝ} (hk : TestBound k 1) |
| (H : Set V) : ∑ g : {g // Gate H g}, mass k g ^ 2 ≤ 1 := by |
| choose w hw using (fun g : {g // Gate H g} => mass_attained k g) |
| have hd : Pairwise (fun g h : {g // Gate H g} => Disjoint (along (g : V) (w g)) (along (h : V) (w h))) := by |
| intro g h hne |
| apply disjoint_left.mpr |
| intro v hvg hvh |
| have hcomp := hF g h v (mem_along.mp hvg).1 (mem_along.mp hvh).1 |
| apply hne |
| apply Subtype.ext |
| exact hcomp.elim (g.property.eq_of_le h.property) (fun hle => (h.property.eq_of_le g.property hle).symm) |
| have hh := hk {g // Gate H g} inferInstance (fun g => along (g : V) (w g)) |
| (fun g => isSegment_along hF g (w g)) hd |
| simpa only [hw, sq_abs] using hh |
|
|
| /-- Square mass at gates, and zero elsewhere. -/ |
| noncomputable def gateWeight (H : Set V) (k : V → ℝ) (g : V) : ℝ := |
| if Gate H g then mass k g ^ 2 else 0 |
|
|
| theorem gateWeight_nonneg (H : Set V) (k : V → ℝ) (g : V) : 0 ≤ gateWeight H k g := by |
| unfold gateWeight |
| split_ifs <;> positivity |
|
|
| theorem gateWeight_sum_le (hF : ForestOrder V) {k : V → ℝ} (hk : TestBound k 1) |
| (H : Set V) : ∑ g, gateWeight H k g ≤ 1 := by |
| have he : (∑ g, gateWeight H k g) = ∑ g : {g // Gate H g}, mass k g ^ 2 := by |
| rw [← sum_subtype (p := Gate H) (univ.filter (Gate H)) (by simp) |
| (fun g => mass k g ^ 2)] |
| simp only [gateWeight, sum_filter] |
| rw [he] |
| exact gate_mass_bound hF hk H |
|
|
| omit [Fintype V] [PartialOrder V] in |
| theorem disjoint_sum_le [Fintype V] [PartialOrder V] {ι : Type} [Fintype ι] (S : ι → Finset V) |
| (hd : Pairwise (fun i j => Disjoint (S i) (S j))) (q : V → ℝ) (hq : ∀ v, 0 ≤ q v) : |
| (∑ i, ∑ v ∈ S i, q v) ≤ ∑ v, q v := by |
| rw [← sum_biUnion (s := univ) (t := S) (by intro i hi j hj hij; exact hd hij)] |
| exact sum_le_sum_of_subset_of_nonneg (subset_univ _) (by intro v hv hv'; exact hq v) |
|
|
| theorem gateWeight_family_le (hF : ForestOrder V) {k : V → ℝ} (hk : TestBound k 1) |
| (H : Set V) {ι : Type} [Fintype ι] (S : ι → Finset V) |
| (hd : Pairwise (fun i j => Disjoint (S i) (S j))) : |
| (∑ i, ∑ v ∈ S i, gateWeight H k v) ≤ 1 := |
| (disjoint_sum_le S hd _ (gateWeight_nonneg H k)).trans (gateWeight_sum_le hF hk H) |
|
|
| omit [Fintype V] [PartialOrder V] in |
| /-- A segment contains at most one coordinate of a gate-supported vector. -/ |
| theorem sum_gate_supported [Fintype V] [PartialOrder V] {H : Set V} {c : V → ℝ} |
| (hc : ∀ v, ¬ Gate H v → c v = 0) {S : Finset V} (hS : IsSegment S) |
| {g : V} (hg : Gate H g) (hgs : g ∈ S) : segSum c S = c g := by |
| apply sum_eq_single g |
| · intro v hv hvg |
| apply hc v |
| intro hgate |
| exact hvg (hS.gate_unique hgate hg hv hgs) |
| · exact fun h => (h hgs).elim |
|
|
| noncomputable def correction (H : Set V) (k σ : V → ℝ) (g : V) : ℝ := |
| if Gate H g then σ g * mass k g else 0 |
|
|
| theorem correction_supported (H : Set V) (k σ : V → ℝ) : |
| SupportedOn (correction H k σ) Hᶜ := by |
| intro v hv |
| simp only [Set.mem_compl_iff, not_not] at hv |
| exact ite_eq_right (fun hg => hg.1 hv) |
|
|
| theorem correction_sum {H : Set V} {k σ : V → ℝ} {S : Finset V} (hS : IsSegment S) |
| {g : V} (hg : Gate H g) (hgs : g ∈ S) : |
| segSum (correction H k σ) S = σ g * mass k g := by |
| rw [sum_gate_supported (c := correction H k σ) (fun v hv => ite_eq_right hv) hS hg hgs] |
| exact ite_eq_left hg |
|
|
| theorem correction_segment_sq {H : Set V} {k σ : V → ℝ} (hσ : ∀ v, σ v ^ 2 = 1) |
| {S : Finset V} (hS : IsSegment S) : |
| segSum (correction H k σ) S ^ 2 = ∑ v ∈ S, gateWeight H k v := by |
| by_cases h : ∃ g ∈ S, Gate H g |
| · obtain ⟨g, hgs, hg⟩ := h |
| rw [correction_sum hS hg hgs, mul_pow, hσ, one_mul] |
| symm |
| calc |
| (∑ v ∈ S, gateWeight H k v) = gateWeight H k g := by |
| apply sum_eq_single g |
| · intro v hv hvg |
| exact ite_eq_right (fun hgate => hvg (hS.gate_unique hgate hg hv hgs)) |
| · exact fun hn => (hn hgs).elim |
| _ = mass k g ^ 2 := ite_eq_left hg |
| · have hz : segSum (correction H k σ) S = 0 := by |
| apply sum_eq_zero |
| intro v hv |
| exact ite_eq_right (fun hg => h ⟨v, hv, hg⟩) |
| rw [hz, zero_pow (by decide : (2 : ℕ) ≠ 0)] |
| symm |
| apply sum_eq_zero |
| intro v hv |
| exact ite_eq_right (fun hg => h ⟨v, hv, hg⟩) |
|
|
| theorem correction_testBound (hF : ForestOrder V) {k σ : V → ℝ} (hk : TestBound k 1) |
| (hσ : ∀ v, σ v ^ 2 = 1) (H : Set V) : TestBound (correction H k σ) 1 := by |
| intro ι inst S hS hd |
| simp_rw [correction_segment_sq hσ (hS _)] |
| exact gateWeight_family_le hF hk H S hd |
|
|
| theorem tail_sum_le_mass {H : Set V} (hH : IsLowerSet H) {k : V → ℝ} |
| (hk : SupportedOn k Hᶜ) {S : Finset V} (hS : IsSegment S) |
| {g : V} (hg : Gate H g) (hgs : g ∈ S) : |segSum k S| ≤ mass k g := by |
| obtain ⟨b, hb⟩ := hS.tail_eq_along hH hg hgs |
| have he := hk.segSum_filter S |
| simp only [Set.mem_compl_iff] at he |
| rw [← he, hb] |
| exact abs_segSum_along_le k g b |
|
|
| /-- Candidate starts of suffixes whose head sum reaches the gate threshold. -/ |
| noncomputable def largeStarts (f k : V → ℝ) (s : ℝ) (g : V) : Finset V := |
| univ.filter (fun a => a < g ∧ 2 * s * mass k g ≤ |segSum f (before a g)|) |
| |
| @[simp] theorem mem_largeStarts {f k : V → ℝ} {s : ℝ} {g a : V} : |
| a ∈ largeStarts f k s g ↔ a < g ∧ 2 * s * mass k g ≤ |segSum f (before a g)| := by |
| simp [largeStarts] |
|
|
| noncomputable def selectedStart (f k : V → ℝ) (s : ℝ) (g : V) |
| (h : (largeStarts f k s g).Nonempty) : V := |
| Classical.choose ((largeStarts f k s g).exists_maximal h) |
|
|
| theorem selectedStart_spec (f k : V → ℝ) (s : ℝ) (g : V) |
| (h : (largeStarts f k s g).Nonempty) : |
| Maximal (· ∈ largeStarts f k s g) (selectedStart f k s g h) := |
| Classical.choose_spec ((largeStarts f k s g).exists_maximal h) |
|
|
| noncomputable def selectedHead (f k : V → ℝ) (s : ℝ) (g : V) : Finset V := |
| if h : (largeStarts f k s g).Nonempty then before (selectedStart f k s g h) g else ∅ |
|
|
| theorem selectedHead_segment (hF : ForestOrder V) (f k : V → ℝ) (s : ℝ) (g : V) : |
| IsSegment (selectedHead f k s g) := by |
| unfold selectedHead |
| split_ifs |
| · exact isSegment_before hF _ _ |
| · exact isSegment_empty |
|
|
| theorem selectedHead_subset (hF : ForestOrder V) {f k : V → ℝ} {s : ℝ} {a g : V} |
| (ha : a ∈ largeStarts f k s g) : selectedHead f k s g ⊆ before a g := by |
| have hne : (largeStarts f k s g).Nonempty := ⟨a, ha⟩ |
| rw [selectedHead, dite_eq_left hne] |
| apply before_mono |
| have hb := selectedStart_spec f k s g hne |
| exact (hF a (selectedStart f k s g hne) g |
| (mem_largeStarts.mp ha).1.le (mem_largeStarts.mp hb.1).1.le).elim id (hb.2 ha) |
|
|
| theorem selectedHead_large {f k : V → ℝ} {s : ℝ} {a g : V} |
| (ha : a ∈ largeStarts f k s g) : |
| 2 * s * mass k g ≤ |segSum f (selectedHead f k s g)| := by |
| have hne : (largeStarts f k s g).Nonempty := ⟨a, ha⟩ |
| rw [selectedHead, dite_eq_left hne] |
| exact (mem_largeStarts.mp (selectedStart_spec f k s g hne).1).2 |
|
|
| theorem sdiff_selectedHead_segment {f k : V → ℝ} {s : ℝ} {a g : V} |
| (hS : IsSegment (before a g)) : IsSegment (before a g \ selectedHead f k s g) := by |
| unfold selectedHead |
| split_ifs |
| · exact hS.sdiff_before rfl |
| · simpa using hS |
|
|
| end FiniteGeometry |
|
|
| section CrossTermAlgebra |
|
|
| /-- Opposite sign for the selected head sum; at zero either sign is harmless. -/ |
| def oppositeSign (r : ℝ) : ℝ := if r < 0 then 1 else -1 |
|
|
| theorem oppositeSign_sq (r : ℝ) : oppositeSign r ^ 2 = 1 := by |
| unfold oppositeSign |
| split_ifs <;> norm_num |
|
|
| theorem abs_oppositeSign (r : ℝ) : |oppositeSign r| = 1 := by |
| unfold oppositeSign |
| split_ifs <;> norm_num |
|
|
| theorem oppositeSign_cross {r m d : ℝ} (hd : |d| ≤ m) : |
| r * (oppositeSign r * m + d) ≤ 0 := by |
| have hd' := abs_le.mp hd |
| unfold oppositeSign |
| split_ifs with hr |
| · exact mul_nonpos_of_nonpos_of_nonneg hr.le (by linarith) |
| · exact mul_nonpos_of_nonneg_of_nonpos (le_of_not_gt hr) (by linarith) |
|
|
| theorem oppositeSign_tail_abs {r m d : ℝ} (hm : 0 ≤ m) (hd : |d| ≤ m) : |
| |oppositeSign r * m + d| ≤ 2 * m := by |
| calc |
| |oppositeSign r * m + d| ≤ |oppositeSign r * m| + |d| := abs_add_le _ _ |
| _ ≤ m + m := by rw [abs_mul, abs_oppositeSign, abs_of_nonneg hm, one_mul]; linarith |
| _ = 2 * m := by ring |
|
|
| theorem small_cross_bound {a b s m q : ℝ} (hs : 0 ≤ s) (hm : 0 ≤ m) |
| (ha : |a| ≤ 2 * s * m) (hb : |b| ≤ 2 * m) (hq : m ^ 2 ≤ q) : |
| 2 * s * a * b ≤ 8 * s ^ 2 * q := by |
| have hab : a * b ≤ (2 * s * m) * (2 * m) := |
| (le_abs_self _).trans (by rw [abs_mul]; exact mul_le_mul ha hb (abs_nonneg _) (by positivity)) |
| have h₁ := mul_le_mul_of_nonneg_left hab (show 0 ≤ 2 * s by positivity) |
| have h₂ := mul_le_mul_of_nonneg_left hq (show 0 ≤ 8 * s ^ 2 by positivity) |
| nlinarith |
|
|
| theorem cross_sign {a b r : ℝ} (hab : 0 < a * b) (hrb : r * b ≤ 0) : a * r ≤ 0 := by |
| rcases lt_or_ge b 0 with hb | hb |
| · have ha : a < 0 := (mul_pos_iff.mp hab).resolve_left (fun hh => not_lt_of_ge hb.le hh.2) |
| |>.1 |
| have hr : 0 ≤ r := by nlinarith |
| exact mul_nonpos_of_nonpos_of_nonneg ha.le hr |
| · have hb' : 0 < b := lt_of_le_of_ne hb (by intro h; subst b; simp at hab) |
| have ha : 0 < a := (mul_pos_iff.mp hab).resolve_right (fun hh => not_lt_of_ge hb hh.2) |
| |>.1 |
| have hr : r ≤ 0 := by nlinarith |
| exact mul_nonpos_of_nonneg_of_nonpos ha.le hr |
|
|
| /-- A large positive cross term is paid for by splitting off the selected suffix. -/ |
| theorem large_cross_bound {a b r s m : ℝ} (hs : 0 ≤ s) (hm : 0 ≤ m) |
| (hab : 0 < a * b) (hrb : r * b ≤ 0) (hr : 2 * s * m ≤ |r|) |
| (hb : |b| ≤ 2 * m) : |
| 2 * s * a * b ≤ (a - r) ^ 2 + r ^ 2 - a ^ 2 := by |
| have har := cross_sign hab hrb |
| have h₁ : a * b ≤ |a| * (2 * m) := |
| (le_abs_self _).trans (by |
| rw [abs_mul, mul_comm |a| |b|, mul_comm |a| (2 * m)] |
| exact mul_le_mul hb le_rfl (abs_nonneg a) (mul_nonneg (by norm_num) hm)) |
| have h₂ := mul_le_mul_of_nonneg_left h₁ (show 0 ≤ 2 * s by positivity) |
| have h₃ := mul_le_mul_of_nonneg_left hr (show 0 ≤ 2 * |a| by positivity) |
| have he : |a| * |r| = -(a * r) := by rw [← abs_mul, abs_of_nonpos har] |
| nlinarith [sq_nonneg r] |
|
|
| end CrossTermAlgebra |
|
|
| end |
|
|
| end ForestSpace |
|
|
| end OAI |
|
|
