| import Mathlib |
| import OAI.Probability.SKGap.Localization.MarkedDiagnostic |
| import OAI.Probability.SKGap.Matrix.ClosedErrorTrace |
| import OAI.Probability.SKGap.Localization.StartedMarked |
|
|
| namespace OAI |
|
|
| section |
|
|
| noncomputable section |
| open scoped BigOperators |
| namespace SKGap.Noncrossing.ClosedMarked |
| open SKGapCutoff.Recipe Primary Primary.Tensor.Series Marked |
| variable {n : ℕ} |
| lemma closedWordBounded_diag {A : ℝ} {w : Word n} (hw : closedWordBounded A w) (d : Fin n→ℝ) (hd : ∀i,|d i|≤A) : |
| closedWordBounded A (w++[.diag d]) := by |
| apply closedWordBounded_append hw |
| intro l hl;have he:=List.mem_singleton.mp hl;subst l;exact hd |
|
|
| def MarkControl (A : ℝ) (L : ℕ) (t : Mark n) : Prop := |
| ∀d:Fin n→ℝ,(∀i,|d i|≤1)→ closedWordBounded A (t.diagnostic d) ∧ (t.diagnostic d).length≤L |
|
|
| def MarkedControl (A : ℝ) (L : ℕ) (P : Marked n) : Prop := ∀t∈P,MarkControl A L t.2 |
|
|
| def PairControl (A : ℝ) (L : ℕ) (P : Pair n) : Prop := MarkedControl A L P.1 ∧ MarkedControl A L P.2 |
|
|
| lemma MarkControl.mono {A : ℝ} {L K : ℕ} {t : Mark n} (h : MarkControl A L t) (hLK : L≤K) : |
| MarkControl A K t := fun d hd=>⟨(h d hd).1,(h d hd).2.trans hLK⟩ |
|
|
| lemma MarkControl.prepend {A : ℝ} {L : ℕ} {t : Mark n} (h : MarkControl A L t) |
| (P : Word n) (hp : closedWordBounded A P) : MarkControl A (L+P.length) (t.prepend P) := by |
| intro d hd |
| rcases h d hd with ⟨hb,hl⟩ |
| cases t with |
| | diagonal Q s R=> |
| simp only [Mark.prepend,Mark.diagnostic,List.length_append,List.length_cons] at * |
| constructor |
| · intro l hh |
| simp only [List.mem_append,List.mem_cons] at hh |
| rcases hh with hh|hh|hh|hh |
| · exact hb l (List.mem_append_left _ hh) |
| · subst l; exact hb (.diag d) (by simp) |
| · exact hp l hh |
| · exact hb l (by simp [hh]) |
| · omega |
| | average s Q=> |
| simp only [Mark.prepend,Mark.diagnostic] at * |
| exact ⟨closedWordBounded_append hp hb,by simp only [List.length_append]; omega⟩ |
|
|
| lemma MarkedControl.append {A : ℝ} {L : ℕ} {P Q : Marked n} |
| (hp : MarkedControl A L P) (hq : MarkedControl A L Q) : MarkedControl A L (P++Q) := by |
| intro t ht; rcases List.mem_append.mp ht with ht|ht |
| · exact hp t ht |
| · exact hq t ht |
|
|
| lemma MarkedControl.mono {A : ℝ} {L K : ℕ} {P : Marked n} |
| (h : MarkedControl A L P) (hLK : L≤K) : MarkedControl A K P := fun t ht=>(h t ht).mono hLK |
|
|
| lemma MarkedControl.prepend {A : ℝ} {L : ℕ} {P : Marked n} |
| (h : MarkedControl A L P) (w : Word n) (hw : closedWordBounded A w) : |
| MarkedControl A (L+w.length) (P.prepend w) := by |
| intro t ht |
| obtain ⟨s,hs,rfl⟩:=List.mem_map.mp ht |
| exact (h s hs).prepend w hw |
|
|
| lemma MarkedControl.scale {A : ℝ} {L : ℕ} {P : Marked n} |
| (h : MarkedControl A L P) (c : ℝ) : MarkedControl A L (P.scale c) := by |
| intro t ht |
| obtain ⟨s,hs,rfl⟩:=List.mem_map.mp ht |
| exact h s hs |
|
|
| lemma diagonalWords_control {A : ℝ} {L : ℕ} (hA : 1≤A) (s : Fin n→ℝ) |
| (P : GradedWords (Fin n)) (hP : ∀t∈P,closedWordBounded A t.2.2 ∧ t.2.2.length≤L) : |
| MarkedControl A (L+1) (diagonalWords s P) := by |
| intro t ht d hd |
| obtain ⟨r,hr,he⟩:=List.mem_map.mp ht |
| subst t |
| simp only [Mark.diagnostic,List.length_append,List.length_cons,List.length_nil] |
| exact ⟨closedWordBounded_diag (hP r hr).1 d (fun i=>(hd i).trans hA),by have hh:=(hP r hr).2; omega⟩ |
|
|
| lemma averageWords_control {A : ℝ} {L : ℕ} (c : ℝ) (s : Fin n→ℝ) |
| (P : GradedWords (Fin n)) (hP : ∀t∈P,closedWordBounded A t.2.2 ∧ t.2.2.length≤L) : |
| MarkedControl A L (averageWords c s P) := by |
| intro t ht d hd |
| obtain ⟨r,hr,he⟩:=List.mem_map.mp ht |
| subst t |
| exact hP r hr |
|
|
| lemma zeroPair_control {A : ℝ} {L : ℕ} (hL : 1≤L) : PairControl (n:=n) A L zeroPair := by |
| constructor |
| · intro t ht; have he:=List.mem_singleton.mp ht; subst t |
| intro d hd; exact ⟨by intro l hl; simp [Mark.diagnostic] at hl,by simp [Mark.diagnostic]⟩ |
| · intro t ht; have he:=List.mem_singleton.mp ht; subst t |
| intro d hd |
| constructor |
| · intro l hl |
| have he : l=WordLetter.noise := by simpa [Mark.diagnostic] using hl |
| subst l |
| trivial |
| · simpa [Mark.diagnostic] using hL |
|
|
| lemma smallBranch_control {A : ℝ} {L K : ℕ} (hA : 1≤A) (hLK : L+2≤K) |
| (j : ℝ) (p : Fin n→ℝ) (T : GradedWords (Fin n)×GradedWords (Fin n)) (V : Pair n) |
| (hT : (∀t∈T.1,closedWordBounded A t.2.2 ∧ t.2.2.length≤L) ∧ |
| (∀t∈T.2,closedWordBounded A t.2.2 ∧ t.2.2.length≤L)) |
| (hV : PairControl A K V) : PairControl A K (smallBranch j p T V) := by |
| have hd:=diagonalWords_control hA p _ hT.2 |
| have ha:=averageWords_control (-j) p _ hT.1 |
| have hn : closedWordBounded (n:=n) A [.noise] := by intro l hl; have he:=List.mem_singleton.mp hl; subst l; trivial |
| refine ⟨(hd.mono (by omega)).append hV.1,?_⟩ |
| exact (((hd.prepend [.noise] hn).mono (by simp only [List.length_cons,List.length_nil]; omega)).append (ha.mono (by omega))).append hV.2 |
|
|
| lemma boundedBranch_control {A : ℝ} {L K : ℕ} (hLK : L+2≤K) |
| (j : ℝ) (p : Fin n→ℝ) (hp : ∀i,|p i|≤A) (U V : Pair n) |
| (hU : PairControl A L U) (hV : PairControl A K V) : PairControl A K (boundedBranch j p U V) := by |
| have hd : closedWordBounded (n:=n) A [.diag p] := by intro l hl; have he:=List.mem_singleton.mp hl; subst l; exact hp |
| have hd' : closedWordBounded (n:=n) A [.noise,.diag p] := by |
| intro l hl; simp only [List.mem_cons,List.not_mem_nil,or_false] at hl |
| rcases hl with rfl|rfl |
| · trivial |
| · exact hp |
| refine ⟨((hU.2.prepend [.diag p] hd).mono (by simp only [List.length_singleton]; omega)).append hV.1,?_⟩ |
| exact (((hU.2.prepend [.noise,.diag p] hd').mono (by simp only [List.length_cons,List.length_nil]; omega)).append |
| ((hU.1.scale _).mono (by omega))).append hV.2 |
|
|
| end SKGap.Noncrossing.ClosedMarked |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open scoped BigOperators |
| namespace SKGap.Noncrossing.ClosedMarked |
| open SKGapCutoff.Recipe Primary Primary.Tensor.Series Marked |
| variable {n : ℕ} |
|
|
| def GradedControl (A : ℝ) (L : ℕ) (P : GradedWords (Fin n)) : Prop := |
| ∀v∈P,closedWordBounded A v.2.2 ∧ v.2.2.length≤L |
|
|
| lemma PairControl.mono {A : ℝ} {L K : ℕ} {P : Pair n} (h : PairControl A L P) (hLK : L≤K) : |
| PairControl A K P := ⟨h.1.mono hLK,h.2.mono hLK⟩ |
| lemma implicitPair_control (j : ℝ) (a p : Fin n→ℝ) (T : SourceTree (Fin n→ℝ)) |
| {A : ℝ} {L : ℕ} (hA : 1≤A) (ha : ∀i,|a i|≤A) |
| (hT : GradedControl A L (GradedWords.ordinaryWords j T).1 ∧ |
| GradedControl A L (GradedWords.ordinaryWords j T).2) : |
| PairControl A (L+3) (implicitPair j a p T) := by |
| have hd:=diagonalWords_control hA p _ hT.2 |
| have hm:=averageWords_control (-j) p _ hT.1 |
| have hb : closedWordBounded (n:=n) A [.inverse] := by |
| intro l hl;have he:=List.mem_singleton.mp hl;subst l;trivial |
| have hba : closedWordBounded A [.inverse,.diag a] := by |
| intro l hl;simp only [List.mem_cons,List.not_mem_nil,or_false] at hl |
| rcases hl with rfl|rfl |
| · trivial |
| · exact ha |
| have hS : MarkedControl A (L+2) (implicitPair j a p T).1 := by |
| exact ((hd.prepend [.inverse] hb).mono (by simp)).append |
| ((hm.prepend [.inverse,.diag a] hba).mono (by simp)) |
| have hn : closedWordBounded (n:=n) A [.noise] := by |
| intro l hl;have he:=List.mem_singleton.mp hl;subst l;trivial |
| refine ⟨hS.mono (by omega),?_⟩ |
| exact (((hS.prepend [.noise] hn).mono (by simp)).append |
| ((hS.scale _).mono (by omega))).append (hm.mono (by omega)) |
|
|
| namespace SmallTree |
| lemma smallBranches_control (j : ℝ) (a₀ : Fin n→ℝ) {A : ℝ} {L K : ℕ} |
| (hA : 1≤A) (hLK : L+2≤K) |
| (xs : List ((Fin n→ℝ)×ClosedTree (Fin n→ℝ))) (U : SmallTree n) |
| (hT : ∀t∈xs,GradedControl A L (t.2.words j a₀).1 ∧ GradedControl A L (t.2.words j a₀).2) |
| (hU : PairControl A K (U.marked j a₀)) : |
| PairControl A K ((smallBranches xs U).marked j a₀) := by |
| induction xs with |
| | nil=>exact hU |
| | cons t xs ih=> |
| exact smallBranch_control hA hLK j _ _ _ (hT t (by simp)) (ih (fun v hv=>hT v (by simp [hv]))) |
| lemma boundedBranches_control (j : ℝ) (a₀ : Fin n→ℝ) {A : ℝ} {L K : ℕ} |
| (hLK : L+2≤K) |
| (xs : List ((Fin n→ℝ)×SmallTree n)) (U : SmallTree n) |
| (ha : ∀t∈xs,∀i,|t.1 i|≤A) (hT : ∀t∈xs,PairControl A L (t.2.marked j a₀)) |
| (hU : PairControl A K (U.marked j a₀)) : |
| PairControl A K ((boundedBranches xs U).marked j a₀) := by |
| induction xs with |
| | nil=>exact hU |
| | cons t xs ih=> |
| exact boundedBranch_control hLK j _ (ha t (by simp)) _ _ (hT t (by simp)) |
| (ih (fun v hv=>ha v (by simp [hv])) (fun v hv=>hT v (by simp [hv]))) |
| end SmallTree |
| end SKGap.Noncrossing.ClosedMarked |
| namespace SKGapCutoff.Recipe.OrdinaryData |
| open Primary SKGap SKGap.Noncrossing SKGap.Noncrossing.Primary SKGap.Noncrossing.Primary.Tensor.Series |
| open SKGap.Noncrossing.ClosedMarked |
| variable {n : ℕ} {ι κ σ : Type*} [Fintype ι] [DecidableEq ι] [Fintype κ] [DecidableEq κ] [Fintype σ] |
| variable (D : OrdinaryData n ι κ σ) |
|
|
| theorem startedMarked_control (w y : VectorFields n) (T : ι→SourceTree (Fin n→ℝ)) |
| (t₀ : SmallTree n) (a₀ : Fin n→ℝ) (x : Spin n) (N L : ℕ) {A : ℝ} (hA : 1≤A) |
| (hinit : SKGap.Noncrossing.ClosedMarked.PairControl A (L+3) (t₀.marked D.j a₀)) |
| (hT : ∀l,GradedControl A L (GradedWords.ordinaryWords D.j (T l)).1 ∧ |
| GradedControl A L (GradedWords.ordinaryWords D.j (T l)).2) |
| (ha : ∀a≤N,∀b i,|D.auxCoefficient a b x i|≤A) : |
| ∀a≤N,SKGap.Noncrossing.ClosedMarked.PairControl A (L+2*a+3) ((D.startedSmallTree w y T t₀ x a).marked D.j a₀) := by |
| intro a |
| induction a using Nat.strong_induction_on with |
| | h a ih=> |
| intro haN |
| rcases a with _|r |
| · simpa only [startedSmallTree,Nat.mul_zero,Nat.add_zero] using hinit |
| · rw [startedSmallTree] |
| apply SmallTree.smallBranches_control D.j a₀ (L:=L) hA (by omega) |
| · intro t ht |
| obtain ⟨l,hl,rfl⟩:=List.mem_map.mp ht |
| simpa only [ClosedTree.words_ofOrdinary] using hT l |
| · apply SmallTree.boundedBranches_control D.j a₀ (L:=L+2*r+3) (by omega) |
| · intro t ht;obtain ⟨b,hb,rfl⟩:=List.mem_map.mp ht |
| exact ha (r+1) haN b |
| · intro t ht;obtain ⟨b,hb,rfl⟩:=List.mem_map.mp ht |
| exact (ih b b.isLt (b.isLt.le.trans haN)).mono (by omega) |
| · exact SKGap.Noncrossing.ClosedMarked.zeroPair_control (by omega) |
| end SKGapCutoff.Recipe.OrdinaryData |
|
|
| end |
| end |
|
|
| end OAI |
|
|
