| import OAI.Analysis.ForestSpace.Coordinates |
|
|
| namespace OAI |
|
|
| open scoped BigOperators |
| open Finset |
|
|
| namespace ForestSpace |
|
|
| noncomputable section |
| attribute [local instance] Classical.propDecidable |
|
|
| section Words |
|
|
| /-- Finite words, ordered by extension, including the empty root. -/ |
| structure Word where |
| letters : List ℕ |
| deriving DecidableEq |
|
|
| namespace Word |
| @[ext] theorem ext {a b : Word} (h : a.letters = b.letters) : a = b := by |
| cases a; cases b; cases h; rfl |
| instance : Countable Word := Function.Injective.countable (f := letters) (fun _ _ => ext) |
| instance : Infinite Word := Infinite.of_injective (fun n : ℕ => Word.mk [n]) (by |
| intro i j h |
| simpa using congrArg letters h) |
| instance : PartialOrder Word where |
| le a b := a.letters <+: b.letters |
| le_refl _ := List.prefix_rfl |
| le_trans _ _ _ := List.IsPrefix.trans |
| le_antisymm a b hab hba := by |
| have h := hab.eq_of_length (Nat.le_antisymm hab.length_le hba.length_le) |
| cases a; cases b; cases h; rfl |
|
|
| @[simp] theorem le_def (a b : Word) : a ≤ b ↔ a.letters <+: b.letters := Iff.rfl |
| theorem forestOrder : ForestOrder Word := by |
| intro a b c hac hbc |
| rcases le_total a.letters.length b.letters.length with h | h |
| · exact Or.inl (List.prefix_of_prefix_length_le hac hbc h) |
| · exact Or.inr (List.prefix_of_prefix_length_le hbc hac h) |
|
|
| theorem finiteAncestors (v : Word) : (Set.Iic v).Finite := by |
| apply (v.letters.inits.toFinset.finite_toSet.image Word.mk).subset |
| intro w hw |
| exact ⟨w.letters,by simpa only [Finset.mem_coe,List.mem_toFinset,List.mem_inits] using (show w.letters <+: v.letters from hw),rfl⟩ |
|
|
| def root : Word := ⟨[]⟩ |
| def child (s : Word) (j : ℕ) : Word := ⟨s.letters++[j]⟩ |
|
|
| theorem le_child (s : Word) (j : ℕ) : s ≤ child s j := List.prefix_append _ _ |
| theorem child_not_le (s : Word) (j : ℕ) : ¬child s j ≤ s := by |
| intro h |
| have hh := h.length_le |
| simp only [child,List.length_append,List.length_singleton] at hh |
| omega |
|
|
| theorem child_injective (s : Word) : Function.Injective (child s) := by |
| intro i j h |
| have hh := congrArg letters h |
| simpa [child] using hh |
|
|
| theorem le_child_iff (s w : Word) (j : ℕ) : |
| w ≤ child s j ↔ w = child s j ∨ w ≤ s := by |
| constructor |
| · intro h |
| by_cases hlen : w.letters.length ≤ s.letters.length |
| · exact Or.inr (List.prefix_of_prefix_length_le h (le_child s j) hlen) |
| · left |
| apply ext |
| apply h.eq_of_length |
| have hh := h.length_le |
| simp only [child,List.length_append,List.length_singleton] at hh ⊢ |
| omega |
| · rintro (rfl | h) |
| · exact le_rfl |
| · exact h.trans (le_child s j) |
|
|
| theorem ancestor_finset_child (s : Word) (j : ℕ) : |
| (finiteAncestors (child s j)).toFinset = insert (child s j) (finiteAncestors s).toFinset := by |
| ext w |
| simp only [Set.Finite.mem_toFinset, Set.mem_Iic, Finset.mem_insert] |
| exact le_child_iff s w j |
|
|
| theorem path_child (s : Word) (j : ℕ) : |
| pathVector (child s j) (finiteAncestors _) - pathVector s (finiteAncestors _) = eX (child s j) := by |
| unfold pathVector |
| rw [ancestor_finset_child,Finset.sum_insert] |
| · abel |
| · simpa using child_not_le s j |
|
|
| theorem weakNull_path_children (s : Word) : |
| WeakNull (fun j => pathVector (child s j) (finiteAncestors _) - |
| pathVector s (finiteAncestors _)) := by |
| simpa only [path_child] using weakNull_coordinates (child s) (child_injective s) |
|
|
| end Word |
|
|
| /-- The James-tree coordinate completion has zero AUC modulus at exactly the |
| comparison scale for every equivalent norm; reflexivity is not assumed. -/ |
| theorem word_auc_modulus_zero {α β : ℝ} (R : EquivalentNorm (X Word) α β) : |
| aucModulus (X Word) R.N (α/(2*β)) = 0 := by |
| apply R.bounded_trees_auc_zero not_finiteDimensional_X |
| (fun _ s => pathVector (Word.mk s) (Word.finiteAncestors _)) |
| · intro h hh s hs |
| exact norm_pathVector Word.forestOrder _ _ |
| · intro h hh s hs j |
| have he := Word.path_child (Word.mk s) j |
| change pathVector (Word.mk (s++[j])) _ - pathVector (Word.mk s) _ = _ at he |
| rw [he,norm_eX] |
| · intro h hh s hs |
| exact Word.weakNull_path_children (Word.mk s) |
|
|
| end Words |
|
|
| section FiniteHeightForest |
|
|
| /-- A disjoint forest: one copy of `Nat^{≤h}` for every `h≥1`. -/ |
| structure Vertex where |
| height : ℕ |
| positive : 1 ≤ height |
| word : Word |
| bounded : word.letters.length ≤ height |
| deriving DecidableEq |
|
|
| namespace Vertex |
| @[ext] theorem ext {a b : Vertex} (hh : a.height = b.height) (hw : a.word = b.word) : a = b := by |
| cases a; cases b; cases hh; cases hw; rfl |
| instance : Countable Vertex := Function.Injective.countable |
| (f := fun v : Vertex => (v.height,v.word)) (by |
| intro a b h |
| exact ext (congrArg Prod.fst h) (congrArg Prod.snd h)) |
| instance : PartialOrder Vertex where |
| le a b := a.height = b.height ∧ a.word ≤ b.word |
| le_refl _ := ⟨rfl,le_rfl⟩ |
| le_trans a b c hab hbc := ⟨hab.1.trans hbc.1,hab.2.trans hbc.2⟩ |
| le_antisymm a b hab hba := by |
| obtain ⟨hh, hw⟩ := hab |
| have he := le_antisymm hw hba.2 |
| cases a; cases b; cases hh; cases he; rfl |
| @[simp] theorem le_def (a b : Vertex) : a ≤ b ↔ a.height = b.height ∧ a.word ≤ b.word := Iff.rfl |
| theorem forestOrder : ForestOrder Vertex := by |
| intro a b c hac hbc |
| rcases Word.forestOrder a.word b.word c.word hac.2 hbc.2 with h | h |
| · exact Or.inl ⟨hac.1.trans hbc.1.symm,h⟩ |
| · exact Or.inr ⟨hbc.1.trans hac.1.symm,h⟩ |
|
|
| theorem finiteAncestors (v : Vertex) : (Set.Iic v).Finite := by |
| apply Set.Finite.of_finite_image (f := fun w : Vertex => w.word) |
| ((Word.finiteAncestors v.word).subset ?_) ?_ |
| · rintro _ ⟨w,hw,rfl⟩ |
| exact hw.2 |
| · intro a ha b hb he |
| exact ext (ha.1.trans hb.1.symm) he |
|
|
| def node (h : ℕ) (hh : 1 ≤ h) (s : List ℕ) (hs : s.length ≤ h) : Vertex := |
| ⟨h,hh,Word.mk s,hs⟩ |
|
|
| def child (v : Vertex) (hv : v.word.letters.length < v.height) (j : ℕ) : Vertex := |
| ⟨v.height,v.positive,Word.child v.word j,by |
| simp only [Word.child,List.length_append,List.length_singleton] |
| omega⟩ |
|
|
| theorem child_injective (v : Vertex) (hv : v.word.letters.length < v.height) : |
| Function.Injective (child v hv) := by |
| intro i j h |
| exact Word.child_injective v.word (congrArg word h) |
|
|
| instance : Infinite Vertex := Infinite.of_injective |
| (child (node 1 le_rfl [] (by simp)) (by simp [node])) |
| (child_injective _ _) |
|
|
| theorem child_not_le (v : Vertex) (hv : v.word.letters.length < v.height) (j : ℕ) : |
| ¬ child v hv j ≤ v := fun h => Word.child_not_le v.word j h.2 |
|
|
| theorem le_child_iff (v w : Vertex) (hv : v.word.letters.length < v.height) (j : ℕ) : |
| w ≤ child v hv j ↔ w = child v hv j ∨ w ≤ v := by |
| constructor |
| · intro hw |
| rcases (Word.le_child_iff v.word w.word j).mp hw.2 with h | h |
| · exact Or.inl (ext hw.1 h) |
| · exact Or.inr ⟨hw.1,h⟩ |
| · rintro (rfl | h) |
| · exact le_rfl |
| · exact ⟨h.1,h.2.trans (Word.le_child v.word j)⟩ |
|
|
| theorem ancestor_finset_child (v : Vertex) (hv : v.word.letters.length < v.height) (j : ℕ) : |
| (finiteAncestors (child v hv j)).toFinset = insert (child v hv j) (finiteAncestors v).toFinset := by |
| ext w |
| simp only [Set.Finite.mem_toFinset,Set.mem_Iic,Finset.mem_insert] |
| exact le_child_iff v w hv j |
|
|
| theorem path_child (v : Vertex) (hv : v.word.letters.length < v.height) (j : ℕ) : |
| pathVector (child v hv j) (finiteAncestors _) - pathVector v (finiteAncestors _) = eX (child v hv j) := by |
| unfold pathVector |
| rw [ancestor_finset_child,Finset.sum_insert] |
| · abel |
| · simpa using child_not_le v hv j |
|
|
| /-- A total extension of the path vector; the off-tree values are never used. -/ |
| noncomputable def treePath (h : ℕ) (s : List ℕ) : X Vertex := |
| if hh : 1 ≤ h then if hs : s.length ≤ h then |
| pathVector (node h hh s hs) (finiteAncestors _) else 0 else 0 |
|
|
| theorem norm_treePath (h : ℕ) (hh : 1 ≤ h) (s : List ℕ) (hs : s.length ≤ h) : |
| ‖treePath h s‖ = 1 := by |
| simp only [treePath,dite_eq_left hh,dite_eq_left hs] |
| exact norm_pathVector forestOrder _ _ |
|
|
| theorem treePath_child (h : ℕ) (hh : 1 ≤ h) (s : List ℕ) (hs : s.length < h) (j : ℕ) : |
| treePath h (s++[j]) - treePath h s = |
| eX (child (node h hh s (by omega)) hs j) := by |
| have hs' : (s++[j]).length ≤ h := by simp; omega |
| simpa only [treePath,dite_eq_left hh,dite_eq_left hs',dite_eq_left (Nat.le_of_lt hs),node,child,Word.child] using |
| path_child (node h hh s (Nat.le_of_lt hs)) hs j |
|
|
| end Vertex |
|
|
| theorem finite_forest_auc_modulus_zero {α β : ℝ} (R : EquivalentNorm (X Vertex) α β) : |
| aucModulus (X Vertex) R.N (α/(2*β)) = 0 := by |
| apply R.bounded_trees_auc_zero not_finiteDimensional_X Vertex.treePath |
| · exact Vertex.norm_treePath |
| · intro h hh s hs j |
| rw [Vertex.treePath_child h hh s hs j,norm_eX] |
| · intro h hh s hs |
| simpa only [Vertex.treePath_child h hh s hs] using |
| weakNull_coordinates _ (Vertex.child_injective (Vertex.node h hh s (Nat.le_of_lt hs)) hs) |
|
|
| end FiniteHeightForest |
|
|
| end |
|
|
| end ForestSpace |
|
|
| end OAI |
|
|
