import Mathlib
import OAI.GroupTheory.SimpleAmenable.Simplicial.IntervalTensor

namespace OAI

section

open CategoryTheory MonoidalCategory BraidedCategory
open Functor.LaxMonoidal Functor.OplaxMonoidal
universe u v u' v' w
namespace IntervalBar.Diagram

variable {C : Type u} [Groupoid.{v} C] [MonoidalCategory C] [SymmetricCategory C]
variable {D : Type u'} [Groupoid.{v'} D] [MonoidalCategory D] [SymmetricCategory D]
variable {I : Type w} [Preorder I]
noncomputable instance reindexMonoidal {J : Type w} [Preorder J] (f : I →o J) :
    (reindex (C:=C) f).Monoidal := Functor.CoreMonoidal.toMonoidal {
  εIso := Iso.refl _
  μIso A B := Iso.refl _
  μIso_hom_natural_left := by
    intro X Y g X'
    apply Hom.ext
    intro i j h
    have hf : f i ≤ f j := f.monotone h
    change (g.app (f i) (f j) hf ⊗ₘ 𝟙 (X'.obj (f i) (f j) hf)) ≫ 𝟙 _ =
      𝟙 _ ≫ (g.app (f i) (f j) hf ⊗ₘ 𝟙 (X'.obj (f i) (f j) hf))
    simp
  μIso_hom_natural_right := by
    intro X Y X' g
    apply Hom.ext
    intro i j h
    have hf : f i ≤ f j := f.monotone h
    change (𝟙 (X'.obj (f i) (f j) hf) ⊗ₘ g.app (f i) (f j) hf) ≫ 𝟙 _ =
      𝟙 _ ≫ (𝟙 (X'.obj (f i) (f j) hf) ⊗ₘ g.app (f i) (f j) hf)
    simp
  associativity := by
    intro X Y Z
    apply Hom.ext
    intro i j h
    have hf : f i ≤ f j := f.monotone h
    let x := X.obj (f i) (f j) hf
    let y := Y.obj (f i) (f j) hf
    let z := Z.obj (f i) (f j) hf
    change (𝟙 (x ⊗ y) ⊗ₘ 𝟙 z) ≫ 𝟙 _ ≫ (α_ x y z).hom =
      (α_ x y z).hom ≫ (𝟙 x ⊗ₘ 𝟙 (y ⊗ z)) ≫ 𝟙 _
    simp
  left_unitality := by
    intro X
    apply Hom.ext
    intro i j h
    have hf : f i ≤ f j := f.monotone h
    let x := X.obj (f i) (f j) hf
    change (λ_ x).hom = (𝟙 (𝟙_ C) ⊗ₘ 𝟙 x) ≫ 𝟙 _ ≫ (λ_ x).hom
    simp
  right_unitality := by
    intro X
    apply Hom.ext
    intro i j h
    have hf : f i ≤ f j := f.monotone h
    let x := X.obj (f i) (f j) hf
    change (ρ_ x).hom = (𝟙 x ⊗ₘ 𝟙 (𝟙_ C)) ≫ 𝟙 _ ≫ (ρ_ x).hom
    simp }


noncomputable def mapεHom (F : C ⥤ D) [F.Monoidal] :
    (𝟙_ (Diagram D I)) ⟶ (map F).obj (𝟙_ (Diagram C I)) where
  app _ _ _ := ε F
  unit i := by
    change ε F ≫ (F.map (𝟙 _) ≫ η F) = 𝟙 _
    simp
  cut i j k hij hjk := by
    change (ε F ⊗ₘ ε F) ≫ (μ F _ _ ≫ F.map (λ_ _).hom) = (λ_ _).hom ≫ ε F
    rw [←Category.assoc,ε_tensorHom_comp_μ]
    simp

noncomputable def mapμHom (F : C ⥤ D) [F.Braided]
    (A B : Diagram C I) : (map F).obj A ⊗ (map F).obj B ⟶ (map F).obj (A⊗B) where
  app i j h := μ F (A.obj i j h) (B.obj i j h)
  unit i := by
    change μ F _ _ ≫ (F.map (((A.unit i).hom ⊗ₘ (B.unit i).hom) ≫ (λ_ _).hom) ≫ η F) =
      ((F.map (A.unit i).hom ≫ η F) ⊗ₘ (F.map (B.unit i).hom ≫ η F)) ≫ (λ_ _).hom
    rw [F.map_comp]
    simp only [Category.assoc]
    rw [←μ_natural_assoc,Functor.Monoidal.map_leftUnitor]
    simp only [Category.assoc,Functor.Monoidal.μ_δ_assoc]
    rw [←leftUnitor_naturality,←tensorHom_comp_tensorHom]
    simp [MonoidalCategory.tensorHom_def]
  cut i j k hij hjk := by
    change (μ F _ _ ⊗ₘ μ F _ _) ≫ (μ F _ _ ≫ F.map
      (tensorμ _ _ _ _ ≫ ((A.cut i j k hij hjk).hom ⊗ₘ (B.cut i j k hij hjk).hom))) =
      (tensorμ _ _ _ _ ≫ ((μ F _ _ ≫ F.map (A.cut i j k hij hjk).hom) ⊗ₘ
        (μ F _ _ ≫ F.map (B.cut i j k hij hjk).hom))) ≫ μ F _ _
    simp only [F.map_comp,←tensorHom_comp_tensorHom,Category.assoc]
    rw [←tensorμ_comp_μ_tensorHom_μ_comp_μ_assoc,←μ_natural]

noncomputable instance mapMonoidal (F : C ⥤ D) [F.Braided] :
    (map (I:=I) F).Monoidal := Functor.CoreMonoidal.toMonoidal {
  εIso := asIso (mapεHom F)
  μIso A B := asIso (mapμHom F A B)
  μIso_hom_natural_left := by
    intros; apply Hom.ext; intro i j h
    simp [map,mapObj,mapμHom]
  μIso_hom_natural_right := by
    intros; apply Hom.ext; intro i j h
    simp [map,mapObj,mapμHom]
  associativity := by
    intros; apply Hom.ext; intro i j h
    simp [map,mapObj,mapμHom]
  left_unitality := by
    intros; apply Hom.ext; intro i j h
    simp [map,mapObj,mapμHom,mapεHom]
  right_unitality := by
    intros; apply Hom.ext; intro i j h
    simp [map,mapObj,mapμHom,mapεHom] }

noncomputable instance reindexBraided {J : Type w} [Preorder J] (f : I →o J) :
    (reindex (C:=C) f).Braided where
  braided A B := by
    apply Hom.ext; intro i j h
    change 𝟙 _ ≫ (β_ _ _).hom = (β_ _ _).hom ≫ 𝟙 _
    simp

noncomputable instance mapBraided (F : C ⥤ D) [F.Braided] : (map (I:=I) F).Braided where
  braided A B := by
    apply Hom.ext; intro i j h
    change μ F _ _ ≫ F.map (β_ _ _).hom = (β_ _ _).hom ≫ μ F _ _
    exact Functor.LaxBraided.braided (F:=F) _ _

noncomputable instance evalBraided (n : ℕ) : (eval (C:=C) n).Braided where
  braided A B := by
    funext i
    change 𝟙 _ ≫ (β_ _ _).hom = (β_ _ _).hom ≫ 𝟙 _
    simp

end IntervalBar.Diagram

end

open CategoryTheory MonoidalCategory BraidedCategory
open Functor.LaxMonoidal Functor.OplaxMonoidal
universe u v u' v' u'' v'' w
namespace IntervalBar.Diagram

variable {C : Type u} [Groupoid.{v} C] [MonoidalCategory C]
variable {D : Type u'} [Groupoid.{v'} D] [MonoidalCategory D]
variable {E : Type u''} [Groupoid.{v''} E] [MonoidalCategory E]
variable {I : Type w} [Preorder I]

lemma ext_heq {A B : Diagram C I} (hobj : A.obj=B.obj)
    (hunit : HEq A.unit B.unit) (hcut : HEq A.cut B.cut) : A=B := by
  cases A; cases B; cases hobj; cases hunit; cases hcut; rfl

@[simp] lemma eqToHom_app {A B : Diagram C I} (h : A=B) (i j : I) (hij : i≤j) :
    (eqToHom h).app i j hij=eqToHom (congrArg (fun X : Diagram C I => X.obj i j hij) h) := by
  cases h; rfl

@[simp] lemma mapObj_id (A : Diagram C I) : mapObj (𝟭 C) A=A := by
  refine ext_heq ?_ ?_ ?_
  · rfl
  · apply heq_of_eq
    funext i
    apply Iso.ext
    simp [mapObj]
  · apply heq_of_eq
    funext i j k hij hjk
    apply Iso.ext
    simp [mapObj]
@[simp] lemma map_id : map (I:=I) (𝟭 C)=𝟭 _ := by
  refine CategoryTheory.Functor.ext (fun A => mapObj_id A) ?_
  intro A B f
  apply Hom.ext; intro i j h
  erw [comp_app, comp_app, eqToHom_app, eqToHom_app]
  simp [map]
  change f.app i j h = 𝟙 _ ≫ f.app i j h ≫ 𝟙 _
  simp

@[simp] lemma mapObj_comp (F : C ⥤ D) (G : D ⥤ E) [F.Monoidal] [G.Monoidal]
    (A : Diagram C I) : mapObj (F⋙G) A=mapObj G (mapObj F A) := by
  refine ext_heq ?_ ?_ ?_
  · rfl
  · apply heq_of_eq
    funext i
    apply Iso.ext
    simp [mapObj]
  · apply heq_of_eq
    funext i j k hij hjk
    apply Iso.ext
    simp [mapObj,Category.assoc]
@[simp] lemma map_comp (F : C ⥤ D) (G : D ⥤ E) [F.Monoidal] [G.Monoidal] :
    map (I:=I) (F⋙G)=map F ⋙ map G := by
  refine CategoryTheory.Functor.ext (fun A => mapObj_comp F G A) ?_
  intro A B f
  apply Hom.ext; intro i j h
  erw [comp_app, comp_app, eqToHom_app, eqToHom_app]
  simp [map]
  change G.map (F.map (f.app i j h)) =
    𝟙 _ ≫ G.map (F.map (f.app i j h)) ≫ 𝟙 _
  simp

variable {J : Type w} [Preorder J]
@[simp] lemma reindex_map (F : C ⥤ D) [F.Monoidal] (f : I →o J) :
    reindex (C:=C) f ⋙ map F = map F ⋙ reindex f := by
  refine CategoryTheory.Functor.ext (fun _ => rfl) ?_
  intro A B g
  apply Hom.ext
  intro i j h
  change F.map (g.app (f i) (f j) (f.monotone h)) =
    𝟙 _ ≫ F.map (g.app (f i) (f j) (f.monotone h)) ≫ 𝟙 _
  simp

end IntervalBar.Diagram

end OAI