| import Mathlib |
| import OAI.Probability.SKGap.Localization.Append |
| import OAI.Probability.SKGap.Localization.NoiseSplit |
|
|
| namespace OAI |
|
|
| section |
| noncomputable section |
| noncomputable section |
| open scoped BigOperators |
| noncomputable section |
| noncomputable section |
| noncomputable section |
| open scoped BigOperators |
| noncomputable section |
| open scoped BigOperators |
| noncomputable section |
| open scoped BigOperators |
| noncomputable section |
| open scoped BigOperators |
| noncomputable section |
| open scoped BigOperators |
| namespace SKGap.Noncrossing |
| namespace Diagram |
| variable {D E : Type*} |
|
|
| @[simp] lemma map_size (f : D→E) (d : Diagram D) : (d.map f).size=d.size := by |
| induction d <;> simp_all [map,size] |
| lemma map_map {G : Type*} (f : D→E) (g : E→G) (d : Diagram D) : |
| (d.map f).map g=d.map (g∘f) := by induction d <;> simp_all [map] |
|
|
| lemma fiber_map_injective (f : D→E) (d e : Diagram D) |
| (hw : d.word=e.word) (he : d.map f=e.map f) : d=e := by |
| induction d generalizing e with |
| | nil => cases e <;> simp_all [word,map] |
| | diag a d ih => |
| cases e with |
| | nil => simp [word] at hw |
| | arch u v => simp [word] at hw |
| | diag b e => |
| simp only [word,List.cons.injEq,Letter.diag.injEq] at hw |
| simp only [map,Diagram.diag.injEq] at he |
| obtain ⟨rfl,hw⟩ := hw |
| exact congrArg (Diagram.diag a) (ih e hw he.2) |
| | arch d r hd hr => |
| cases e with |
| | nil => simp [word] at hw |
| | diag b e => simp [word] at hw |
| | arch u v => |
| simp only [map,Diagram.arch.injEq] at he |
| have hlen : d.word.length=u.word.length := by |
| simpa only [word_length,map_size] using congrArg Diagram.size he.1 |
| simp only [word,List.cons.injEq,true_and] at hw |
| have hw' := List.append_inj hw hlen |
| have hu := hd u hw'.1 he.1 |
| have hv := hr v (List.cons.inj hw'.2).2 he.2 |
| subst u; subst v; rfl |
|
|
| lemma exists_map_of_word (f : D→E) (d : Diagram E) (F : List (Letter D)) |
| (hw : F.map (Letter.map f)=d.word) : |
| ∃ e : Diagram D, e.word=F ∧ e.map f=d := by |
| induction d generalizing F with |
| | nil => |
| have hF : F=[] := List.map_eq_nil_iff.mp hw |
| subst F |
| exact ⟨.nil,rfl,rfl⟩ |
| | diag a d ih => |
| cases F with |
| | nil => simp [word] at hw |
| | cons l F => |
| cases l with |
| | noise => simp [Letter.map,word] at hw |
| | diag b => |
| simp only [List.map_cons,Letter.map,word,List.cons.injEq,Letter.diag.injEq] at hw |
| obtain ⟨e,he,hef⟩ := ih F hw.2 |
| exact ⟨.diag b e,by simp [word,he],by simp [map,hef,hw.1]⟩ |
| | arch d e hd he => |
| cases F with |
| | nil => simp [word] at hw |
| | cons l F => |
| cases l with |
| | diag b => simp [Letter.map,word] at hw |
| | noise => |
| simp only [List.map_cons,Letter.map,word,List.cons.injEq,true_and] at hw |
| obtain ⟨P,Q,hF,hP,hQ⟩ := List.map_eq_append_iff.mp hw |
| cases Q with |
| | nil => simp at hQ |
| | cons l Q => |
| cases l with |
| | diag b => simp [Letter.map] at hQ |
| | noise => |
| simp only [List.map_cons,Letter.map,List.cons.injEq,true_and] at hQ |
| obtain ⟨u,hu,huf⟩ := hd P hP |
| obtain ⟨v,hv,hvf⟩ := he Q hQ |
| exact ⟨.arch u v,by simp [word,hu,hv,hF],by simp [map,huf,hvf]⟩ |
|
|
| def Paired.map (f : D→E) (F : List (Letter D)) (d : Paired F) : |
| Paired (F.map (Letter.map f)) := ⟨d.val.map f,by rw [map_word,d.property]⟩ |
| lemma Paired.map_bijective (f : D→E) (F : List (Letter D)) : |
| Function.Bijective (Paired.map f F) := by |
| constructor |
| · intro d e h |
| apply Subtype.ext |
| exact fiber_map_injective f d.val e.val (d.property.trans e.property.symm) |
| (congrArg (fun z => z.val) h) |
| · intro d |
| obtain ⟨e,he,hef⟩ := exists_map_of_word f d.val F d.property.symm |
| exact ⟨⟨e,he⟩,Subtype.ext hef⟩ |
| def Paired.mapEquiv (f : D→E) (F : List (Letter D)) : |
| Paired F ≃ Paired (F.map (Letter.map f)) := |
| Equiv.ofBijective (Paired.map f F) (Paired.map_bijective f F) |
|
|
| variable {ι : Type*} [Fintype ι] |
| lemma evaluate_map (j : ℝ) (v : E→ι→ℝ) (f : D→E) (d : Diagram D) : |
| evaluate j v (d.map f)=evaluate j (v∘f) d := by simp [evaluate,map_map] |
|
|
| lemma expect_map (j : ℝ) (v : E→ι→ℝ) (f : D→E) (F : List (Letter D)) (i : ι) : |
| expect j v (F.map (Letter.map f)) i=expect j (v∘f) F i := by |
| symm |
| apply Fintype.sum_equiv (Paired.mapEquiv f F) |
| intro d |
| exact congrFun (evaluate_map j v f d.val).symm i |
|
|
| end Diagram |
| end SKGap.Noncrossing |
|
|
| noncomputable section |
| open scoped BigOperators |
|
|
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
|
|
| end OAI |
|
|
