| import Mathlib | |
| import OAI.Probability.SKGap.Matrix.WordFockSeries | |
| namespace OAI | |
| section | |
| noncomputable section | |
| open scoped BigOperators | |
| namespace SKGap.Noncrossing.Primary.Tensor.Series | |
| open Diagram InverseDiagram WordSeries Loop | |
| variable {ι : Type*} [Fintype ι] | |
| namespace GradedWords | |
| def branch (j : ℝ) (p : ι→ℝ) (U V : GradedWords ι×GradedWords ι) : GradedWords ι×GradedWords ι := | |
| (prepend (.diag p) U.2++V.1, | |
| (bump (prepend .noise (prepend (.diag p) U.2))++ | |
| scale (-(j*Diagram.mean p)) (bump (bump U.1)))++V.2) | |
| def ordinaryWords (j : ℝ) : SourceTree (ι→ℝ)→GradedWords ι×GradedWords ι | |
| | .leaf c => (scalar c,bump (prepend .noise (scalar c))) | |
| | .branch p t u => branch j p (ordinaryWords j t) (ordinaryWords j u) | |
| def implicitSource (j : ℝ) (a p : ι→ℝ) (t : SourceTree (ι→ℝ)) : GradedWords ι := | |
| prepend .inverse (prepend (.diag p) (ordinaryWords j t).2++ | |
| scale (-(j*Diagram.mean p)) (bump (bump (prepend (.diag a) (ordinaryWords j t).1)))) | |
| def implicitField (j : ℝ) (a p : ι→ℝ) (t : SourceTree (ι→ℝ)) : GradedWords ι := | |
| (bump (prepend .noise (implicitSource j a p t))++ | |
| scale (-(j*Diagram.mean a)) (bump (bump (implicitSource j a p t))))++ | |
| scale (-(j*Diagram.mean p)) (bump (bump (ordinaryWords j t).1)) | |
| def pairSeq (j : ℝ) (a : ι→ℝ) (P : GradedWords ι×GradedWords ι) := | |
| (seq j a P.1,seq j a P.2) | |
| lemma pairSeq_branch (j : ℝ) (a p : ι→ℝ) (U V : GradedWords ι×GradedWords ι) : | |
| pairSeq j a (branch j p U V)= | |
| (branchSource p (pairSeq j a U) (pairSeq j a V), | |
| branchField j p (pairSeq j a U) (pairSeq j a V)) := by | |
| simp [pairSeq,branch,branchSource,branchField,seq_append,seq_bump,seq_prepend, | |
| seq_scale,letterOperator,sub_eq_add_neg,add_assoc] | |
| lemma pairSeq_ordinary (j : ℝ) (a : ι→ℝ) (t : SourceTree (ι→ℝ)) : | |
| pairSeq j a (ordinaryWords j t)=ordinary j t := by | |
| induction t with | |
| | leaf c => | |
| simp [ordinaryWords,pairSeq,seq_scalar,seq_bump,seq_prepend,letterOperator, | |
| ordinary,act_ofVector] | |
| | branch p t u ih1 ih2 => simp only [ordinaryWords,pairSeq_branch,ih1,ih2,ordinary] | |
| lemma seq_implicitSource (j : ℝ) (a p : ι→ℝ) (t : SourceTree (ι→ℝ)) : | |
| seq j a (implicitSource j a p t)=loopSource j a p t := by | |
| have h1:=congrArg Prod.fst (pairSeq_ordinary j a t) | |
| have h2:=congrArg Prod.snd (pairSeq_ordinary j a t) | |
| simp only [pairSeq] at h1 h2 | |
| simp [implicitSource,seq_prepend,seq_append,seq_scale,seq_bump,letterOperator, | |
| h1,h2,loopSource,sub_eq_add_neg] | |
| lemma seq_implicitField (j : ℝ) (a p : ι→ℝ) (t : SourceTree (ι→ℝ)) : | |
| seq j a (implicitField j a p t)=loopField j a p t := by | |
| have h1:=congrArg Prod.fst (pairSeq_ordinary j a t) | |
| simp only [pairSeq] at h1 | |
| simp [implicitField,seq_prepend,seq_append,seq_scale,seq_bump,letterOperator, | |
| h1,seq_implicitSource,loopField,sub_eq_add_neg,add_assoc] | |
| section | |
| omit [Fintype ι] | |
| def bounded (k : ℕ) (P : GradedWords ι) : Prop := ∀ t∈P,inverseCount t.2.2≤k | |
| lemma bounded_mono {k l : ℕ} (hkl : k≤l) {P : GradedWords ι} (h : bounded k P) : bounded l P := | |
| fun t ht=>(h t ht).trans hkl | |
| lemma bounded_scalar (k : ℕ) (c : ℝ) : bounded k (scalar (ι:=ι) c) := by | |
| rintro t ht | |
| simp only [scalar,List.mem_singleton] at ht | |
| subst t | |
| simp [inverseCount] | |
| lemma bounded_append {k : ℕ} {P Q : GradedWords ι} (hP : bounded k P) (hQ : bounded k Q) : | |
| bounded k (P++Q) := by | |
| intro t ht | |
| rcases List.mem_append.mp ht with h|h | |
| · exact hP t h | |
| · exact hQ t h | |
| lemma bounded_scale {k : ℕ} {P : GradedWords ι} (c : ℝ) (hP : bounded k P) : bounded k (scale c P) := by | |
| intro t ht | |
| obtain ⟨s,hs,rfl⟩:=List.mem_map.mp ht | |
| exact hP s hs | |
| lemma bounded_bump {k : ℕ} {P : GradedWords ι} (hP : bounded k P) : bounded k (bump P) := by | |
| intro t ht | |
| obtain ⟨s,hs,rfl⟩:=List.mem_map.mp ht | |
| exact hP s hs | |
| lemma bounded_diag {k : ℕ} {P : GradedWords ι} (d : ι→ℝ) (hP : bounded k P) : | |
| bounded k (prepend (.diag d) P) := by | |
| intro t ht | |
| obtain ⟨s,hs,rfl⟩:=List.mem_map.mp ht | |
| exact hP s hs | |
| lemma bounded_noise {k : ℕ} {P : GradedWords ι} (hP : bounded k P) : | |
| bounded k (prepend .noise P) := by | |
| intro t ht | |
| obtain ⟨s,hs,rfl⟩:=List.mem_map.mp ht | |
| exact hP s hs | |
| lemma bounded_inverse {k : ℕ} {P : GradedWords ι} (hP : bounded k P) : | |
| bounded (k+1) (prepend .inverse P) := by | |
| intro t ht | |
| obtain ⟨s,hs,rfl⟩:=List.mem_map.mp ht | |
| simpa only [inverseCount_inverse] using Nat.add_le_add_right (hP s hs) 1 | |
| end | |
| lemma bounded_branch {k : ℕ} (j : ℝ) (p : ι→ℝ) {U V : GradedWords ι×GradedWords ι} | |
| (hU : bounded k U.1 ∧ bounded k U.2) (hV : bounded k V.1 ∧ bounded k V.2) : | |
| bounded k (branch j p U V).1 ∧ bounded k (branch j p U V).2 := by | |
| exact ⟨bounded_append (bounded_diag _ hU.2) hV.1, | |
| bounded_append (bounded_append (bounded_bump (bounded_noise (bounded_diag _ hU.2))) | |
| (bounded_scale _ (bounded_bump (bounded_bump hU.1)))) hV.2⟩ | |
| lemma bounded_ordinary (j : ℝ) (t : SourceTree (ι→ℝ)) : | |
| bounded 0 (ordinaryWords j t).1 ∧ bounded 0 (ordinaryWords j t).2 := by | |
| induction t with | |
| | leaf c => exact ⟨bounded_scalar 0 c,bounded_bump (bounded_noise (bounded_scalar 0 c))⟩ | |
| | branch p t u ih1 ih2 => exact bounded_branch j p ih1 ih2 | |
| lemma bounded_implicitSource (j : ℝ) (a p : ι→ℝ) (t : SourceTree (ι→ℝ)) : | |
| bounded 1 (implicitSource j a p t) := by | |
| have h:=bounded_ordinary j t | |
| exact bounded_inverse (bounded_append (bounded_diag _ h.2) | |
| (bounded_scale _ (bounded_bump (bounded_bump (bounded_diag _ h.1))))) | |
| lemma bounded_implicitField (j : ℝ) (a p : ι→ℝ) (t : SourceTree (ι→ℝ)) : | |
| bounded 1 (implicitField j a p t) := by | |
| have h:=bounded_implicitSource j a p t | |
| exact bounded_append (bounded_append (bounded_bump (bounded_noise h)) | |
| (bounded_scale _ (bounded_bump (bounded_bump h)))) | |
| (bounded_scale _ (bounded_bump (bounded_bump (bounded_mono (by omega) (bounded_ordinary j t).1)))) | |
| end GradedWords | |
| namespace ClosedTree | |
| open GradedWords | |
| def words (j : ℝ) (a : ι→ℝ) : ClosedTree (ι→ℝ)→GradedWords ι×GradedWords ι | |
| | .leaf c => ordinaryWords j (.leaf c) | |
| | .implicit p t => (implicitSource j a p t,implicitField j a p t) | |
| | .branch p t u => GradedWords.branch j p (t.words j a) (u.words j a) | |
| lemma words_series (j : ℝ) (a : ι→ℝ) (t : ClosedTree (ι→ℝ)) : | |
| pairSeq j a (t.words j a)=t.series j a := by | |
| induction t with | |
| | leaf c => exact pairSeq_ordinary j a (.leaf c) | |
| | implicit p t => exact Prod.ext (seq_implicitSource j a p t) (seq_implicitField j a p t) | |
| | branch p t u ih1 ih2 => simp only [words,pairSeq_branch,ih1,ih2,series] | |
| lemma words_bounded (j : ℝ) (a : ι→ℝ) (t : ClosedTree (ι→ℝ)) : | |
| bounded 1 (t.words j a).1 ∧ bounded 1 (t.words j a).2 := by | |
| induction t with | |
| | leaf c => | |
| exact ⟨bounded_mono (by omega) (bounded_ordinary j (.leaf c)).1, | |
| bounded_mono (by omega) (bounded_ordinary j (.leaf c)).2⟩ | |
| | implicit p t => exact ⟨bounded_implicitSource j a p t,bounded_implicitField j a p t⟩ | |
| | branch p t u ih1 ih2 => exact bounded_branch j p ih1 ih2 | |
| theorem field_prediction_zero (j : ℝ) (a : ι→ℝ) (t : ClosedTree (ι→ℝ)) (z : ℝ) (i : ι) : | |
| prediction j a z (t.words j a).2 i=0 := by | |
| apply prediction_zero_of_project j a _ (t.words_bounded j a).2 | |
| intro n | |
| have h:=congrArg Prod.snd (t.words_series j a) | |
| change seq j a (t.words j a).2=(t.series j a).2 at h | |
| rw [h] | |
| exact t.project_field j a n ▸ rfl | |
| theorem source_prediction_zero (j : ℝ) (a : ι→ℝ) (t : ClosedTree (ι→ℝ)) | |
| (ht : t.leafMass=0) (z : ℝ) (i : ι) : prediction j a z (t.words j a).1 i=0 := by | |
| apply prediction_zero_of_project j a _ (t.words_bounded j a).1 | |
| intro n | |
| have h:=congrArg Prod.fst (t.words_series j a) | |
| change seq j a (t.words j a).1=(t.series j a).1 at h | |
| rw [h,t.project_source,ht] | |
| split_ifs <;> rfl | |
| end ClosedTree | |
| end SKGap.Noncrossing.Primary.Tensor.Series | |
| end | |
| end | |
| end OAI | |