| import Mathlib |
| import OAI.Probability.SKGap.Localization.ClosedPrediction |
| import OAI.Probability.SKGap.Matrix.RecipeTraceBudget |
|
|
| namespace OAI |
|
|
| section |
|
|
| noncomputable section |
| open scoped BigOperators Matrix.Norms.Frobenius |
| namespace SKGap.Noncrossing.ClosedMarked |
| open Matrix |
| variable {n : ℕ} |
|
|
| abbrev Word (n : ℕ) := List (WordLetter (Fin n)) |
| abbrev Polynomial (n : ℕ) := List (ℝ×Word n) |
| def matrixValue (j : ℝ) (a : Fin n→ℝ) (J : Matrix (Fin n) (Fin n) ℝ) |
| (P : Polynomial n) : Matrix (Fin n) (Fin n) ℝ := |
| (P.map (fun t=>t.1 • exactWord j a t.2 J)).sum |
| def prediction (j : ℝ) (a : Fin n→ℝ) (P : Polynomial n) (i : Fin n) : ℝ := |
| (P.map (fun t=>t.1*wordPrediction j a 1 t.2 i)).sum |
|
|
| def ungrade (P : Primary.Tensor.Series.GradedWords (Fin n)) : Polynomial n := |
| P.map (fun t=>(t.1,t.2.2)) |
| lemma ungrade_matrix (j : ℝ) (a : Fin n→ℝ) (J : Matrix (Fin n) (Fin n) ℝ) |
| (P : Primary.Tensor.Series.GradedWords (Fin n)) : |
| matrixValue j a J (ungrade P)=Primary.Tensor.Series.GradedWords.matrixValue j a J P := by |
| simp [matrixValue,ungrade,Primary.Tensor.Series.GradedWords.matrixValue,List.map_map,Function.comp_def] |
| lemma ungrade_prediction (j : ℝ) (a : Fin n→ℝ) (P : Primary.Tensor.Series.GradedWords (Fin n)) : |
| prediction j a (ungrade P)=Primary.Tensor.Series.GradedWords.prediction j a 1 P := by |
| funext i |
| simp [prediction,ungrade,Primary.Tensor.Series.GradedWords.prediction,List.map_map,Function.comp_def] |
|
|
| inductive Mark (n : ℕ) where |
| | diagonal : Word n→(Fin n→ℝ)→Word n→Mark n |
| | average : (Fin n→ℝ)→Word n→Mark n |
| namespace Mark |
|
|
| def vector : Mark n→Fin n→ℝ |
| | .diagonal _ s _ => s |
| | .average s _ => s |
| def word : Mark n→Word n |
| | .diagonal P s Q => P++(.diag s::Q) |
| | .average _ P => P |
| def scalar : Mark n→ℝ |
| | .diagonal _ _ _ => 1 |
| | .average s _ => Diagram.mean s |
| def prepend (P : Word n) : Mark n→Mark n |
| | .diagonal Q s R => .diagonal (P++Q) s R |
| | .average s Q => .average s (P++Q) |
| lemma prefix_vector (P : Word n) (t : Mark n) : (t.prepend P).vector=t.vector := by cases t <;> rfl |
| lemma prefix_scalar (P : Word n) (t : Mark n) : (t.prepend P).scalar=t.scalar := by cases t <;> rfl |
| lemma prefix_word (P : Word n) (t : Mark n) : (t.prepend P).word=P++t.word := by |
| cases t <;> simp [prepend,word,List.append_assoc] |
| def diagnostic (d : Fin n→ℝ) : Mark n→Word n |
| | .diagonal P _ Q => Q++(.diag d::P) |
| | .average _ P => P |
|
|
| lemma diagnostic_inverse (d : Fin n→ℝ) (t : Mark n) : |
| inverseCount (t.diagnostic d)=inverseCount t.word := by |
| cases t <;> simp [diagnostic,word,inverseCount,List.countP_append,Nat.add_comm] |
| |
| lemma trace_error (j : ℝ) (a : Fin n→ℝ) (J : Matrix (Fin n) (Fin n) ℝ) |
| (hn : 0<n) (d : Fin n→ℝ) (hd : ∀i,|d i|≤1) (t : Mark n) |
| (ht : inverseCount t.word≤1) {B : ℝ} (hB : 0≤B) |
| (hb : diagonalSeminorm (exactWord j a (t.diagnostic d) J- |
| Matrix.diagonal (wordPrediction j a 1 (t.diagnostic d)))≤B) : |
| |t.scalar*(trace (Matrix.diagonal d*exactWord j a t.word J)- |
| ∑i,d i*wordPrediction j a 1 t.word i)|≤SKGapCutoff.Recipe.vectorNorm t.vector*B := by |
| cases t with |
| | diagonal P s Q => |
| simpa only [scalar,one_mul,word,diagnostic,vector,SKGapCutoff.Recipe.vectorNorm] using |
| (rotated_small_word_trace_error j a d s J P Q ht).trans |
| (mul_le_mul_of_nonneg_left hb (norm_nonneg _)) |
| | average s P => |
| have H:=trace_small_diagonal_error d (wordPrediction j a 1 P) (exactWord j a P J) |
| rw [abs_mul] |
| exact (mul_le_mul_of_nonneg_left H (abs_nonneg _)).trans (by |
| change |Diagram.mean s| *(SKGapCutoff.Recipe.vectorNorm d*_)≤SKGapCutoff.Recipe.vectorNorm s*B |
| calc |
| _ ≤ |Diagram.mean s| *(SKGapCutoff.Recipe.vectorNorm d*B) := |
| mul_le_mul_of_nonneg_left (mul_le_mul_of_nonneg_left hb (norm_nonneg _)) (abs_nonneg _) |
| _ = (|Diagram.mean s| *SKGapCutoff.Recipe.vectorNorm d)*B := by ring |
| _ ≤ _ := mul_le_mul_of_nonneg_right (Primary.SmallMark.average_norm_product hn s d hd) hB) |
| end Mark |
|
|
| abbrev Marked (n : ℕ) := List (ℝ×Mark n) |
| namespace Marked |
|
|
| def plain (P : Marked n) : Polynomial n := P.map (fun t=>(t.1*t.2.scalar,t.2.word)) |
| def budget (P : Marked n) : ℝ := (P.map (fun t=>|t.1| *SKGapCutoff.Recipe.vectorNorm t.2.vector)).sum |
| def prepend (F : Word n) (P : Marked n) : Marked n := P.map (fun t=>(t.1,t.2.prepend F)) |
| def scale (c : ℝ) (P : Marked n) : Marked n := P.map (fun t=>(c*t.1,t.2)) |
| lemma plain_prefix (F : Word n) (P : Marked n) : |
| (P.prepend F).plain=P.plain.map (fun t=>(t.1,F++t.2)) := by |
| simp [prepend,plain,List.map_map,Function.comp_def,Mark.prefix_scalar,Mark.prefix_word] |
| lemma plain_scale (c : ℝ) (P : Marked n) : (P.scale c).plain=P.plain.map (fun t=>(c*t.1,t.2)) := by |
| simp [scale,plain,List.map_map,Function.comp_def,mul_assoc] |
| lemma plain_append (P Q : Marked n) : (P++Q).plain=P.plain++Q.plain := by simp [plain] |
| lemma budget_prefix (F : Word n) (P : Marked n) : (P.prepend F).budget=P.budget := by |
| simp [prepend,budget,List.map_map,Function.comp_def,Mark.prefix_vector] |
| lemma budget_scale (c : ℝ) (P : Marked n) : (P.scale c).budget=|c| *P.budget := by |
| induction P with |
| | nil => simp [scale,budget] |
| | cons t P ih => simp [scale,budget,abs_mul,mul_assoc,mul_add] at *;exact ih |
| lemma budget_append (P Q : Marked n) : (P++Q).budget=P.budget+Q.budget := by simp [budget] |
| lemma budget_nonneg (P : Marked n) : 0≤P.budget := by |
| apply List.sum_nonneg; intro r hr; obtain ⟨t,_,rfl⟩:=List.mem_map.mp hr |
| exact mul_nonneg (abs_nonneg _) (norm_nonneg _) |
|
|
| theorem trace_error (j : ℝ) (a : Fin n→ℝ) (J : Matrix (Fin n) (Fin n) ℝ) (hn : 0<n) |
| (d : Fin n→ℝ) (hd : ∀i,|d i|≤1) (P : Marked n) |
| (hI : ∀t∈P,inverseCount t.2.word≤1) {B : ℝ} (hB : 0≤B) |
| (hb : ∀t∈P,diagonalSeminorm (exactWord j a (t.2.diagnostic d) J- |
| Matrix.diagonal (wordPrediction j a 1 (t.2.diagnostic d)))≤B) : |
| |trace (Matrix.diagonal d*matrixValue j a J P.plain)- |
| ∑i,d i*prediction j a P.plain i|≤P.budget*B := by |
| induction P with |
| | nil => simp [plain,budget,matrixValue,prediction] |
| | cons t P ih => |
| have ht:=Mark.trace_error j a J hn d hd t.2 (hI t (by simp)) hB (hb t (by simp)) |
| have hh:=ih (fun s hs=>hI s (List.mem_cons_of_mem _ hs)) (fun s hs=>hb s (List.mem_cons_of_mem _ hs)) |
| simp only [plain,List.map_cons,matrixValue,List.sum_cons,prediction,budget] at * |
| simp only [mul_add,mul_smul_comm,trace_add,trace_smul,smul_eq_mul,Finset.sum_add_distrib,add_mul] |
| have he : (∑i,d i*(t.1*t.2.scalar*wordPrediction j a 1 t.2.word i))= |
| t.1*t.2.scalar*(∑i,d i*wordPrediction j a 1 t.2.word i) := by |
| rw [Finset.mul_sum];apply Finset.sum_congr rfl;intro i _;ring |
| rw [he] |
| have hc:=mul_le_mul_of_nonneg_left ht (abs_nonneg t.1) |
| rw [←abs_mul] at hc |
| calc |
| _ = |t.1*(t.2.scalar*(trace (Matrix.diagonal d*exactWord j a t.2.word J)- |
| ∑i,d i*wordPrediction j a 1 t.2.word i))+ |
| (trace (Matrix.diagonal d*(List.map (fun p=>p.1 • exactWord j a p.2 J) |
| (List.map (fun t=>(t.1*t.2.scalar,t.2.word)) P)).sum)- |
| ∑i,d i*(List.map (fun p=>p.1*wordPrediction j a 1 p.2 i) |
| (List.map (fun t=>(t.1*t.2.scalar,t.2.word)) P)).sum)| := by congr 1;ring |
| _ ≤ _ := (abs_add_le _ _).trans (add_le_add (by convert! hc using 1; ring) hh) |
| end Marked |
| end SKGap.Noncrossing.ClosedMarked |
| |
| end |
| end |
| |
| section |
| |
| noncomputable section |
| open scoped BigOperators Matrix.Norms.Frobenius |
| namespace SKGap.Noncrossing.ClosedMarked |
| open Matrix Primary Primary.Tensor.Series |
| variable {n : ℕ} |
|
|
| lemma ungrade_append (P Q : GradedWords (Fin n)) : ungrade (P++Q)=ungrade P++ungrade Q := by simp [ungrade] |
| lemma ungrade_bump (P : GradedWords (Fin n)) : ungrade (GradedWords.bump P)=ungrade P := by |
| simp [ungrade,GradedWords.bump,List.map_map,Function.comp_def] |
| lemma ungrade_prepend (l : WordLetter (Fin n)) (P : GradedWords (Fin n)) : |
| ungrade (GradedWords.prepend l P)=(ungrade P).map (fun t=>(t.1,l::t.2)) := by |
| simp [ungrade,GradedWords.prepend,List.map_map,Function.comp_def] |
| lemma ungrade_scale (c : ℝ) (P : GradedWords (Fin n)) : |
| ungrade (GradedWords.scale c P)=(ungrade P).map (fun t=>(c*t.1,t.2)) := by |
| simp [ungrade,GradedWords.scale,List.map_map,Function.comp_def] |
|
|
| namespace Marked |
|
|
| def diagonalWords (s : Fin n→ℝ) (P : GradedWords (Fin n)) : Marked n := |
| P.map (fun t=>(t.1,Mark.diagonal [] s t.2.2)) |
| def averageWords (c : ℝ) (s : Fin n→ℝ) (P : GradedWords (Fin n)) : Marked n := |
| P.map (fun t=>(c*t.1,Mark.average s t.2.2)) |
| def mass (P : GradedWords (Fin n)) : ℝ := (P.map (fun t=>|t.1|)).sum |
| lemma plain_diagonalWords (s : Fin n→ℝ) (P : GradedWords (Fin n)) : |
| (diagonalWords s P).plain=ungrade (GradedWords.prepend (.diag s) P) := by |
| simp [diagonalWords,plain,ungrade,GradedWords.prepend,List.map_map,Function.comp_def,Mark.scalar,Mark.word] |
| lemma plain_averageWords (c : ℝ) (s : Fin n→ℝ) (P : GradedWords (Fin n)) : |
| (averageWords c s P).plain=ungrade (GradedWords.scale (c*Diagram.mean s) P) := by |
| simp only [averageWords,plain,ungrade,GradedWords.scale,List.map_map,Function.comp_def,Mark.scalar,Mark.word] |
| congr 1;funext t;congr 1;ring |
| lemma budget_diagonalWords (s : Fin n→ℝ) (P : GradedWords (Fin n)) : |
| (diagonalWords s P).budget=SKGapCutoff.Recipe.vectorNorm s*mass P := by |
| induction P with |
| | nil => simp [diagonalWords,budget,mass] |
| | cons t P ih => |
| simp only [diagonalWords,List.map_cons,budget,List.sum_cons,Mark.vector,mass] at * |
| rw [ih];ring |
| lemma budget_averageWords (c : ℝ) (s : Fin n→ℝ) (P : GradedWords (Fin n)) : |
| (averageWords c s P).budget=|c| *SKGapCutoff.Recipe.vectorNorm s*mass P := by |
| induction P with |
| | nil => simp [averageWords,budget,mass] |
| | cons t P ih => |
| simp only [averageWords,List.map_cons,budget,List.sum_cons,Mark.vector,mass,abs_mul] at * |
| rw [ih];ring |
| |
| lemma bounded_of_plain (P : Marked n) (Q : GradedWords (Fin n)) (h : P.plain=ungrade Q) |
| (hQ : GradedWords.bounded 1 Q) : ∀t∈P,inverseCount t.2.word≤1 := by |
| intro t ht |
| have hp : (t.1*t.2.scalar,t.2.word)∈ungrade Q := h ▸ List.mem_map.mpr ⟨t,ht,rfl⟩ |
| obtain ⟨q,hq,he⟩:=List.mem_map.mp hp |
| have hword : q.2.2=t.2.word := congrArg Prod.snd he |
| rw [←hword] |
| exact hQ q hq |
| end Marked |
|
|
| abbrev Pair (n : ℕ) := Marked n×Marked n |
| def pairPlain (P : Pair n) : Polynomial n×Polynomial n := (P.1.plain,P.2.plain) |
| def pairUngrade (P : GradedWords (Fin n)×GradedWords (Fin n)) := (ungrade P.1,ungrade P.2) |
| def zeroPair : Pair n := ([(0,.average 0 [])],[(0,.average 0 [.noise])]) |
| lemma zeroPair_plain (j : ℝ) : pairPlain (zeroPair (n:=n))=pairUngrade (GradedWords.ordinaryWords j (.leaf 0)) := by |
| simp [pairPlain,pairUngrade,zeroPair,Marked.plain,Mark.scalar,Mark.word,GradedWords.ordinaryWords, |
| GradedWords.scalar,GradedWords.bump,GradedWords.prepend,ungrade] |
|
|
| def implicitPair (j : ℝ) (a p : Fin n→ℝ) (t : SourceTree (Fin n→ℝ)) : Pair n := |
| let T:=GradedWords.ordinaryWords j t |
| let S:=(Marked.diagonalWords p T.2).prepend [.inverse]++ |
| (Marked.averageWords (-j) p T.1).prepend [.inverse,.diag a] |
| (S,(S.prepend [.noise]++S.scale (-(j*Diagram.mean a)))++Marked.averageWords (-j) p T.1) |
|
|
| lemma implicitPair_plain (j : ℝ) (a p : Fin n→ℝ) (t : SourceTree (Fin n→ℝ)) : |
| pairPlain (implicitPair j a p t)=pairUngrade (GradedWords.implicitSource j a p t,GradedWords.implicitField j a p t) := by |
| have hs : (implicitPair j a p t).1.plain=ungrade (GradedWords.implicitSource j a p t) := by |
| simp only [implicitPair,Marked.plain_append,Marked.plain_prefix,Marked.plain_diagonalWords, |
| Marked.plain_averageWords,GradedWords.implicitSource,ungrade_prepend,ungrade_append, |
| ungrade_scale,ungrade_bump,List.map_append,List.map_map,Function.comp_def, |
| List.cons_append,List.nil_append,neg_mul] |
| apply Prod.ext hs |
| dsimp only [pairPlain,pairUngrade] |
| change ((implicitPair j a p t).1.prepend [.noise]++ |
| (implicitPair j a p t).1.scale (-(j*Diagram.mean a))++Marked.averageWords (-j) p (GradedWords.ordinaryWords j t).1).plain=_ |
| rw [Marked.plain_append,Marked.plain_append,Marked.plain_prefix,Marked.plain_scale,hs,Marked.plain_averageWords] |
| simp [GradedWords.implicitField,ungrade_append,ungrade_bump,ungrade_scale,ungrade_prepend,neg_mul] |
|
|
| def smallBranch (j : ℝ) (p : Fin n→ℝ) (T : GradedWords (Fin n)×GradedWords (Fin n)) (V : Pair n) : Pair n := |
| (Marked.diagonalWords p T.2++V.1, |
| ((Marked.diagonalWords p T.2).prepend [.noise]++Marked.averageWords (-j) p T.1)++V.2) |
| def boundedBranch (j : ℝ) (p : Fin n→ℝ) (U V : Pair n) : Pair n := |
| (U.2.prepend [.diag p]++V.1, |
| (U.2.prepend [.noise,.diag p]++U.1.scale (-(j*Diagram.mean p)))++V.2) |
| lemma smallBranch_plain (j : ℝ) (p : Fin n→ℝ) (T V : GradedWords (Fin n)×GradedWords (Fin n)) |
| (Q : Pair n) (hQ : pairPlain Q=pairUngrade V) : |
| pairPlain (smallBranch j p T Q)=pairUngrade (GradedWords.branch j p T V) := by |
| have h₁ : Q.1.plain=ungrade V.1 := congrArg Prod.fst hQ |
| have h₂ : Q.2.plain=ungrade V.2 := congrArg Prod.snd hQ |
| simp [pairPlain,smallBranch,Marked.plain_append,Marked.plain_prefix,Marked.plain_diagonalWords, |
| Marked.plain_averageWords,h₁,h₂,pairUngrade,GradedWords.branch,ungrade_append,ungrade_bump, |
| ungrade_prepend,ungrade_scale,List.map_map,Function.comp_def,neg_mul] |
| lemma boundedBranch_plain (j : ℝ) (p : Fin n→ℝ) (T V : GradedWords (Fin n)×GradedWords (Fin n)) |
| (P Q : Pair n) (hP : pairPlain P=pairUngrade T) (hQ : pairPlain Q=pairUngrade V) : |
| pairPlain (boundedBranch j p P Q)=pairUngrade (GradedWords.branch j p T V) := by |
| have h₁ : P.1.plain=ungrade T.1 := congrArg Prod.fst hP |
| have h₂ : P.2.plain=ungrade T.2 := congrArg Prod.snd hP |
| have h₃ : Q.1.plain=ungrade V.1 := congrArg Prod.fst hQ |
| have h₄ : Q.2.plain=ungrade V.2 := congrArg Prod.snd hQ |
| simp [pairPlain,boundedBranch,Marked.plain_append,Marked.plain_prefix,Marked.plain_scale, |
| h₁,h₂,h₃,h₄,pairUngrade,GradedWords.branch,ungrade_append,ungrade_bump,ungrade_prepend, |
| ungrade_scale,List.map_map,Function.comp_def] |
|
|
| inductive SmallTree (n : ℕ) where |
| | zero |
| | implicit : (Fin n→ℝ)→SourceTree (Fin n→ℝ)→SmallTree n |
| | small : (Fin n→ℝ)→ClosedTree (Fin n→ℝ)→SmallTree n→SmallTree n |
| | bounded : (Fin n→ℝ)→SmallTree n→SmallTree n→SmallTree n |
| namespace SmallTree |
|
|
| def tree : SmallTree n→ClosedTree (Fin n→ℝ) |
| | .zero=>.leaf 0 |
| | .implicit p T=>.implicit p T |
| | .small p T V=>.branch p T V.tree |
| | .bounded p T V=>.branch p T.tree V.tree |
| def marked (j : ℝ) (a : Fin n→ℝ) : SmallTree n→Pair n |
| | .zero=>zeroPair |
| | .implicit p T=>implicitPair j a p T |
| | .small p T V=>smallBranch j p (T.words j a) (V.marked j a) |
| | .bounded p T V=>boundedBranch j p (T.marked j a) (V.marked j a) |
| lemma leafMass (T : SmallTree n) : T.tree.leafMass=0 := by |
| induction T with |
| | zero=>rfl |
| | implicit=>rfl |
| | small p U V ih=>exact ih |
| | bounded p U V ih1 ih2=>exact ih2 |
| lemma plain (j : ℝ) (a : Fin n→ℝ) (T : SmallTree n) : |
| pairPlain (T.marked j a)=pairUngrade (T.tree.words j a) := by |
| induction T with |
| | zero=>exact zeroPair_plain j |
| | implicit p U=>exact implicitPair_plain j a p U |
| | small p U V ih=>exact smallBranch_plain j p (U.words j a) (V.tree.words j a) (V.marked j a) ih |
| | bounded p U V ih1 ih2 => |
| exact boundedBranch_plain j p (U.tree.words j a) (V.tree.words j a) |
| (U.marked j a) (V.marked j a) ih1 ih2 |
|
|
| theorem diagonal (j : ℝ) (a : Fin n→ℝ) (J : Matrix (Fin n) (Fin n) ℝ) (hn : 0<n) |
| (T : SmallTree n) {B : ℝ} (hB : 0≤B) |
| (hb : ∀d:Fin n→ℝ,(∀i,|d i|≤1)→∀P∈[ (T.marked j a).1,(T.marked j a).2 ],∀t∈P, |
| diagonalSeminorm (exactWord j a (t.2.diagnostic d) J- |
| Matrix.diagonal (wordPrediction j a 1 (t.2.diagnostic d)))≤B) : |
| (∑i,|GradedWords.matrixValue j a J (T.tree.words j a).1 i i|)≤(T.marked j a).1.budget*B ∧ |
| (∑i,|GradedWords.matrixValue j a J (T.tree.words j a).2 i i|)≤(T.marked j a).2.budget*B := by |
| have hs : (T.marked j a).1.plain=ungrade (T.tree.words j a).1 := congrArg Prod.fst (T.plain j a) |
| have hf : (T.marked j a).2.plain=ungrade (T.tree.words j a).2 := congrArg Prod.snd (T.plain j a) |
| have hbound (P : Marked n) (Q : GradedWords (Fin n)) (hp : P.plain=ungrade Q) |
| (hQ : GradedWords.bounded 1 Q) (hz : ∀i,GradedWords.prediction j a 1 Q i=0) |
| (hP : P∈[(T.marked j a).1,(T.marked j a).2]) : |
| (∑i,|GradedWords.matrixValue j a J Q i i|)≤P.budget*B := by |
| apply diagonal_abs_sum_of_tests |
| intro d hd |
| have H:=Marked.trace_error j a J hn d hd P (P.bounded_of_plain Q hp hQ) hB (hb d hd P hP) |
| rw [hp,ungrade_matrix,ungrade_prediction] at H |
| simpa only [hz,mul_zero,Finset.sum_const_zero,sub_zero] using H |
| exact ⟨hbound _ _ hs (T.tree.words_bounded j a).1 (T.tree.source_prediction_zero j a T.leafMass 1) (by simp), |
| hbound _ _ hf (T.tree.words_bounded j a).2 (T.tree.field_prediction_zero j a 1) (by simp)⟩ |
| end SmallTree |
| end SKGap.Noncrossing.ClosedMarked |
|
|
| end |
| end |
|
|
| end OAI |
|
|
