l3lab/ntp-mathlib huggingface dataset:
/-- Given a trifunctor `F : C₁ ⥤ C₂ ⥤ C₃ ⥤ C₄` and types `I₁`, `I₂`, `I₃`,
this is the obvious functor
`GradedObject I₁ C₁ ⥤ GradedObject I₂ C₂ ⥤ GradedObject I₃ C₃ ⥤ GradedObject (I₁ × I₂ × I₃) C₄`.
-/
@[simps]
def mapTrifunctor (I₁ I₂ I₃ : Type*) :
    GradedObject I₁ C₁ ⥤ GradedObject I₂ C₂ ⥤ GradedObject I₃ C₃ ⥤
      GradedObject (I₁ × I₂ × I₃) C₄ where
  obj X₁ := mapTrifunctorObj F X₁ I₂ I₃
  map {X₁ Y₁} φ :=
    { app := fun X₂ =>
        { app := fun X₃ x => ((F.map (φ x.1)).app (X₂ x.2.1)).app (X₃ x.2.2) }
      naturality := fun {X₂ Y₂} ψ => by
        

Proof state:
C₁ : Type u_1
C₂ : Type u_2
C₃ : Type u_3
C₄ : Type u_4
inst✝³ : Category.{?u.35817, u_1} C₁
inst✝² : Category.{?u.35821, u_2} C₂
inst✝¹ : Category.{?u.35825, u_3} C₃
inst✝ : Category.{?u.35829, u_4} C₄
F F' : C₁ ⥤ C₂ ⥤ C₃ ⥤ C₄
I₁ : Type u_5
I₂ : Type u_6
I₃ : Type u_7
X₁ Y₁ : GradedObject I₁ C₁
φ : X₁ ⟶ Y₁
X₂ Y₂ : GradedObject I₂ C₂
ψ : X₂ ⟶ Y₂
⊢ ((fun X₁ => mapTrifunctorObj F X₁ I₂ I₃) X₁).map ψ ≫
      (fun X₂ => NatTrans.mk fun X₃ x => ((F.map (φ x.1)).app (X₂ x.2.1)).app (X₃ x.2.2)) Y₂ =
    (fun X₂ => NatTrans.mk fun X₃ x => ((F.map (φ x.1)).app (X₂ x.2.1)).app (X₃ x.2.2)) X₂ ≫
      ((fun X₁ => mapTrifunctorObj F X₁ I₂ I₃) Y₁).map ψ

Next tactic:
ext X₃ x
/-- Given a trifunctor `F : C₁ ⥤ C₂ ⥤ C₃ ⥤ C₄` and types `I₁`, `I₂`, `I₃`,
this is the obvious functor
`GradedObject I₁ C₁ ⥤ GradedObject I₂ C₂ ⥤ GradedObject I₃ C₃ ⥤ GradedObject (I₁ × I₂ × I₃) C₄`.
-/
@[simps]
def mapTrifunctor (I₁ I₂ I₃ : Type*) :
    GradedObject I₁ C₁ ⥤ GradedObject I₂ C₂ ⥤ GradedObject I₃ C₃ ⥤
      GradedObject (I₁ × I₂ × I₃) C₄ where
  obj X₁ := mapTrifunctorObj F X₁ I₂ I₃
  map {X₁ Y₁} φ :=
    { app := fun X₂ =>
        { app := fun X₃ x => ((F.map (φ x.1)).app (X₂ x.2.1)).app (X₃ x.2.2) }
      naturality := fun {X₂ Y₂} ψ => by
        ext X₃ x
        

Proof state:
case w.h.h
C₁ : Type u_1
C₂ : Type u_2
C₃ : Type u_3
C₄ : Type u_4
inst✝³ : Category.{?u.35817, u_1} C₁
inst✝² : Category.{?u.35821, u_2} C₂
inst✝¹ : Category.{?u.35825, u_3} C₃
inst✝ : Category.{?u.35829, u_4} C₄
F F' : C₁ ⥤ C₂ ⥤ C₃ ⥤ C₄
I₁ : Type u_5
I₂ : Type u_6
I₃ : Type u_7
X₁ Y₁ : GradedObject I₁ C₁
φ : X₁ ⟶ Y₁
X₂ Y₂ : GradedObject I₂ C₂
ψ : X₂ ⟶ Y₂
X₃ : GradedObject I₃ C₃
x : I₁ × I₂ × I₃
⊢ (((fun X₁ => mapTrifunctorObj F X₁ I₂ I₃) X₁).map ψ ≫
          (fun X₂ => NatTrans.mk fun X₃ x => ((F.map (φ x.1)).app (X₂ x.2.1)).app (X₃ x.2.2)) Y₂).app
      X₃ x =
    ((fun X₂ => NatTrans.mk fun X₃ x => ((F.map (φ x.1)).app (X₂ x.2.1)).app (X₃ x.2.2)) X₂ ≫
          ((fun X₁ => mapTrifunctorObj F X₁ I₂ I₃) Y₁).map ψ).app
      X₃ x

Next tactic:
dsimp
/-- Given a trifunctor `F : C₁ ⥤ C₂ ⥤ C₃ ⥤ C₄` and types `I₁`, `I₂`, `I₃`,
this is the obvious functor
`GradedObject I₁ C₁ ⥤ GradedObject I₂ C₂ ⥤ GradedObject I₃ C₃ ⥤ GradedObject (I₁ × I₂ × I₃) C₄`.
-/
@[simps]
def mapTrifunctor (I₁ I₂ I₃ : Type*) :
    GradedObject I₁ C₁ ⥤ GradedObject I₂ C₂ ⥤ GradedObject I₃ C₃ ⥤
      GradedObject (I₁ × I₂ × I₃) C₄ where
  obj X₁ := mapTrifunctorObj F X₁ I₂ I₃
  map {X₁ Y₁} φ :=
    { app := fun X₂ =>
        { app := fun X₃ x => ((F.map (φ x.1)).app (X₂ x.2.1)).app (X₃ x.2.2) }
      naturality := fun {X₂ Y₂} ψ => by
        ext X₃ x
        dsimp
        

Proof state:
case w.h.h
C₁ : Type u_1
C₂ : Type u_2
C₃ : Type u_3
C₄ : Type u_4
inst✝³ : Category.{?u.35817, u_1} C₁
inst✝² : Category.{?u.35821, u_2} C₂
inst✝¹ : Category.{?u.35825, u_3} C₃
inst✝ : Category.{?u.35829, u_4} C₄
F F' : C₁ ⥤ C₂ ⥤ C₃ ⥤ C₄
I₁ : Type u_5
I₂ : Type u_6
I₃ : Type u_7
X₁ Y₁ : GradedObject I₁ C₁
φ : X₁ ⟶ Y₁
X₂ Y₂ : GradedObject I₂ C₂
ψ : X₂ ⟶ Y₂
X₃ : GradedObject I₃ C₃
x : I₁ × I₂ × I₃
⊢ ((F.obj (X₁ x.1)).map (ψ x.2.1)).app (X₃ x.2.2) ≫ ((F.map (φ x.1)).app (Y₂ x.2.1)).app (X₃ x.2.2) =
    ((F.map (φ x.1)).app (X₂ x.2.1)).app (X₃ x.2.2) ≫ ((F.obj (Y₁ x.1)).map (ψ x.2.1)).app (X₃ x.2.2)

Next tactic:
simp only [← NatTrans.comp_app]
/-- Given a trifunctor `F : C₁ ⥤ C₂ ⥤ C₃ ⥤ C₄` and types `I₁`, `I₂`, `I₃`,
this is the obvious functor
`GradedObject I₁ C₁ ⥤ GradedObject I₂ C₂ ⥤ GradedObject I₃ C₃ ⥤ GradedObject (I₁ × I₂ × I₃) C₄`.
-/
@[simps]
def mapTrifunctor (I₁ I₂ I₃ : Type*) :
    GradedObject I₁ C₁ ⥤ GradedObject I₂ C₂ ⥤ GradedObject I₃ C₃ ⥤
      GradedObject (I₁ × I₂ × I₃) C₄ where
  obj X₁ := mapTrifunctorObj F X₁ I₂ I₃
  map {X₁ Y₁} φ :=
    { app := fun X₂ =>
        { app := fun X₃ x => ((F.map (φ x.1)).app (X₂ x.2.1)).app (X₃ x.2.2) }
      naturality := fun {X₂ Y₂} ψ => by
        ext X₃ x
        dsimp
        simp only [← NatTrans.comp_app]
        

Proof state:
case w.h.h
C₁ : Type u_1
C₂ : Type u_2
C₃ : Type u_3
C₄ : Type u_4
inst✝³ : Category.{?u.35817, u_1} C₁
inst✝² : Category.{?u.35821, u_2} C₂
inst✝¹ : Category.{?u.35825, u_3} C₃
inst✝ : Category.{?u.35829, u_4} C₄
F F' : C₁ ⥤ C₂ ⥤ C₃ ⥤ C₄
I₁ : Type u_5
I₂ : Type u_6
I₃ : Type u_7
X₁ Y₁ : GradedObject I₁ C₁
φ : X₁ ⟶ Y₁
X₂ Y₂ : GradedObject I₂ C₂
ψ : X₂ ⟶ Y₂
X₃ : GradedObject I₃ C₃
x : I₁ × I₂ × I₃
⊢ ((F.obj (X₁ x.1)).map (ψ x.2.1) ≫ (F.map (φ x.1)).app (Y₂ x.2.1)).app (X₃ x.2.2) =
    ((F.map (φ x.1)).app (X₂ x.2.1) ≫ (F.obj (Y₁ x.1)).map (ψ x.2.1)).app (X₃ x.2.2)

Next tactic:
congr 1
/-- Given a trifunctor `F : C₁ ⥤ C₂ ⥤ C₃ ⥤ C₄` and types `I₁`, `I₂`, `I₃`,
this is the obvious functor
`GradedObject I₁ C₁ ⥤ GradedObject I₂ C₂ ⥤ GradedObject I₃ C₃ ⥤ GradedObject (I₁ × I₂ × I₃) C₄`.
-/
@[simps]
def mapTrifunctor (I₁ I₂ I₃ : Type*) :
    GradedObject I₁ C₁ ⥤ GradedObject I₂ C₂ ⥤ GradedObject I₃ C₃ ⥤
      GradedObject (I₁ × I₂ × I₃) C₄ where
  obj X₁ := mapTrifunctorObj F X₁ I₂ I₃
  map {X₁ Y₁} φ :=
    { app := fun X₂ =>
        { app := fun X₃ x => ((F.map (φ x.1)).app (X₂ x.2.1)).app (X₃ x.2.2) }
      naturality := fun {X₂ Y₂} ψ => by
        ext X₃ x
        dsimp
        simp only [← NatTrans.comp_app]
        congr 1
        

Proof state:
case w.h.h.e_self
C₁ : Type u_1
C₂ : Type u_2
C₃ : Type u_3
C₄ : Type u_4
inst✝³ : Category.{?u.35817, u_1} C₁
inst✝² : Category.{?u.35821, u_2} C₂
inst✝¹ : Category.{?u.35825, u_3} C₃
inst✝ : Category.{?u.35829, u_4} C₄
F F' : C₁ ⥤ C₂ ⥤ C₃ ⥤ C₄
I₁ : Type u_5
I₂ : Type u_6
I₃ : Type u_7
X₁ Y₁ : GradedObject I₁ C₁
φ : X₁ ⟶ Y₁
X₂ Y₂ : GradedObject I₂ C₂
ψ : X₂ ⟶ Y₂
X₃ : GradedObject I₃ C₃
x : I₁ × I₂ × I₃
⊢ (F.obj (X₁ x.1)).map (ψ x.2.1) ≫ (F.map (φ x.1)).app (Y₂ x.2.1) =
    (F.map (φ x.1)).app (X₂ x.2.1) ≫ (F.obj (Y₁ x.1)).map (ψ x.2.1)

Next tactic:
rw [NatTrans.naturality]
/-- The natural transformation `mapTrifunctor F I₁ I₂ I₃ ⟶ mapTrifunctor F' I₁ I₂ I₃`
induced by a natural transformation `F ⟶ F` of trifunctors. -/
@[simps]
def mapTrifunctorMapNatTrans (α : F ⟶ F') (I₁ I₂ I₃ : Type*) :
    mapTrifunctor F I₁ I₂ I₃ ⟶ mapTrifunctor F' I₁ I₂ I₃ where
  app X₁ :=
    { app := fun X₂ =>
        { app := fun X₃ i => ((α.app _).app _).app _ }
      naturality := fun {X₂ Y₂} φ => by
        

Proof state:
C₁ : Type u_1
C₂ : Type u_2
C₃ : Type u_3
C₄ : Type u_4
inst✝³ : Category.{?u.62962, u_1} C₁
inst✝² : Category.{?u.62966, u_2} C₂
inst✝¹ : Category.{?u.62970, u_3} C₃
inst✝ : Category.{?u.62974, u_4} C₄
F F' : C₁ ⥤ C₂ ⥤ C₃ ⥤ C₄
α : F ⟶ F'
I₁ : Type u_5
I₂ : Type u_6
I₃ : Type u_7
X₁ : GradedObject I₁ C₁
X₂ Y₂ : GradedObject I₂ C₂
φ : X₂ ⟶ Y₂
⊢ ((mapTrifunctor F I₁ I₂ I₃).obj X₁).map φ ≫
      (fun X₂ => NatTrans.mk fun X₃ i => ((α.app (X₁ i.1)).app (X₂ i.2.1)).app (X₃ i.2.2)) Y₂ =
    (fun X₂ => NatTrans.mk fun X₃ i => ((α.app (X₁ i.1)).app (X₂ i.2.1)).app (X₃ i.2.2)) X₂ ≫
      ((mapTrifunctor F' I₁ I₂ I₃).obj X₁).map φ

Next tactic:
ext X₃ ⟨i₁, i₂, i₃⟩
/-- The natural transformation `mapTrifunctor F I₁ I₂ I₃ ⟶ mapTrifunctor F' I₁ I₂ I₃`
induced by a natural transformation `F ⟶ F` of trifunctors. -/
@[simps]
def mapTrifunctorMapNatTrans (α : F ⟶ F') (I₁ I₂ I₃ : Type*) :
    mapTrifunctor F I₁ I₂ I₃ ⟶ mapTrifunctor F' I₁ I₂ I₃ where
  app X₁ :=
    { app := fun X₂ =>
        { app := fun X₃ i => ((α.app _).app _).app _ }
      naturality := fun {X₂ Y₂} φ => by
        ext X₃ ⟨i₁, i₂, i₃⟩
        

Proof state:
case w.h.h.mk.mk
C₁ : Type u_1
C₂ : Type u_2
C₃ : Type u_3
C₄ : Type u_4
inst✝³ : Category.{?u.62962, u_1} C₁
inst✝² : Category.{?u.62966, u_2} C₂
inst✝¹ : Category.{?u.62970, u_3} C₃
inst✝ : Category.{?u.62974, u_4} C₄
F F' : C₁ ⥤ C₂ ⥤ C₃ ⥤ C₄
α : F ⟶ F'
I₁ : Type u_5
I₂ : Type u_6
I₃ : Type u_7
X₁ : GradedObject I₁ C₁
X₂ Y₂ : GradedObject I₂ C₂
φ : X₂ ⟶ Y₂
X₃ : GradedObject I₃ C₃
i₁ : I₁
i₂ : I₂
i₃ : I₃
⊢ (((mapTrifunctor F I₁ I₂ I₃).obj X₁).map φ ≫
          (fun X₂ => NatTrans.mk fun X₃ i => ((α.app (X₁ i.1)).app (X₂ i.2.1)).app (X₃ i.2.2)) Y₂).app
      X₃ (i₁, i₂, i₃) =
    ((fun X₂ => NatTrans.mk fun X₃ i => ((α.app (X₁ i.1)).app (X₂ i.2.1)).app (X₃ i.2.2)) X₂ ≫
          ((mapTrifunctor F' I₁ I₂ I₃).obj X₁).map φ).app
      X₃ (i₁, i₂, i₃)

Next tactic:
dsimp
/-- The natural transformation `mapTrifunctor F I₁ I₂ I₃ ⟶ mapTrifunctor F' I₁ I₂ I₃`
induced by a natural transformation `F ⟶ F` of trifunctors. -/
@[simps]
def mapTrifunctorMapNatTrans (α : F ⟶ F') (I₁ I₂ I₃ : Type*) :
    mapTrifunctor F I₁ I₂ I₃ ⟶ mapTrifunctor F' I₁ I₂ I₃ where
  app X₁ :=
    { app := fun X₂ =>
        { app := fun X₃ i => ((α.app _).app _).app _ }
      naturality := fun {X₂ Y₂} φ => by
        ext X₃ ⟨i₁, i₂, i₃⟩
        dsimp
        

Proof state:
case w.h.h.mk.mk
C₁ : Type u_1
C₂ : Type u_2
C₃ : Type u_3
C₄ : Type u_4
inst✝³ : Category.{?u.62962, u_1} C₁
inst✝² : Category.{?u.62966, u_2} C₂
inst✝¹ : Category.{?u.62970, u_3} C₃
inst✝ : Category.{?u.62974, u_4} C₄
F F' : C₁ ⥤ C₂ ⥤ C₃ ⥤ C₄
α : F ⟶ F'
I₁ : Type u_5
I₂ : Type u_6
I₃ : Type u_7
X₁ : GradedObject I₁ C₁
X₂ Y₂ : GradedObject I₂ C₂
φ : X₂ ⟶ Y₂
X₃ : GradedObject I₃ C₃
i₁ : I₁
i₂ : I₂
i₃ : I₃
⊢ ((F.obj (X₁ i₁)).map (φ i₂)).app (X₃ i₃) ≫ ((α.app (X₁ i₁)).app (Y₂ i₂)).app (X₃ i₃) =
    ((α.app (X₁ i₁)).app (X₂ i₂)).app (X₃ i₃) ≫ ((F'.obj (X₁ i₁)).map (φ i₂)).app (X₃ i₃)

Next tactic:
simp only [← NatTrans.comp_app, NatTrans.naturality]
/-- The natural transformation `mapTrifunctor F I₁ I₂ I₃ ⟶ mapTrifunctor F' I₁ I₂ I₃`
induced by a natural transformation `F ⟶ F` of trifunctors. -/
@[simps]
def mapTrifunctorMapNatTrans (α : F ⟶ F') (I₁ I₂ I₃ : Type*) :
    mapTrifunctor F I₁ I₂ I₃ ⟶ mapTrifunctor F' I₁ I₂ I₃ where
  app X₁ :=
    { app := fun X₂ =>
        { app := fun X₃ i => ((α.app _).app _).app _ }
      naturality := fun {X₂ Y₂} φ => by
        ext X₃ ⟨i₁, i₂, i₃⟩
        dsimp
        simp only [← NatTrans.comp_app, NatTrans.naturality] }
  naturality := fun {X₁ Y₁} φ => by
    

Proof state:
C₁ : Type u_1
C₂ : Type u_2
C₃ : Type u_3
C₄ : Type u_4
inst✝³ : Category.{?u.62962, u_1} C₁
inst✝² : Category.{?u.62966, u_2} C₂
inst✝¹ : Category.{?u.62970, u_3} C₃
inst✝ : Category.{?u.62974, u_4} C₄
F F' : C₁ ⥤ C₂ ⥤ C₃ ⥤ C₄
α : F ⟶ F'
I₁ : Type u_5
I₂ : Type u_6
I₃ : Type u_7
X₁ Y₁ : GradedObject I₁ C₁
φ : X₁ ⟶ Y₁
⊢ (mapTrifunctor F I₁ I₂ I₃).map φ ≫
      (fun X₁ => NatTrans.mk fun X₂ => NatTrans.mk fun X₃ i => ((α.app (X₁ i.1)).app (X₂ i.2.1)).app (X₃ i.2.2)) Y₁ =
    (fun X₁ => NatTrans.mk fun X₂ => NatTrans.mk fun X₃ i => ((α.app (X₁ i.1)).app (X₂ i.2.1)).app (X₃ i.2.2)) X₁ ≫
      (mapTrifunctor F' I₁ I₂ I₃).map φ

Next tactic:
ext X₂ X₃ ⟨i₁, i₂, i₃⟩
/-- The natural transformation `mapTrifunctor F I₁ I₂ I₃ ⟶ mapTrifunctor F' I₁ I₂ I₃`
induced by a natural transformation `F ⟶ F` of trifunctors. -/
@[simps]
def mapTrifunctorMapNatTrans (α : F ⟶ F') (I₁ I₂ I₃ : Type*) :
    mapTrifunctor F I₁ I₂ I₃ ⟶ mapTrifunctor F' I₁ I₂ I₃ where
  app X₁ :=
    { app := fun X₂ =>
        { app := fun X₃ i => ((α.app _).app _).app _ }
      naturality := fun {X₂ Y₂} φ => by
        ext X₃ ⟨i₁, i₂, i₃⟩
        dsimp
        simp only [← NatTrans.comp_app, NatTrans.naturality] }
  naturality := fun {X₁ Y₁} φ => by
    ext X₂ X₃ ⟨i₁, i₂, i₃⟩
    

Proof state:
case w.h.w.h.h.mk.mk
C₁ : Type u_1
C₂ : Type u_2
C₃ : Type u_3
C₄ : Type u_4
inst✝³ : Category.{?u.62962, u_1} C₁
inst✝² : Category.{?u.62966, u_2} C₂
inst✝¹ : Category.{?u.62970, u_3} C₃
inst✝ : Category.{?u.62974, u_4} C₄
F F' : C₁ ⥤ C₂ ⥤ C₃ ⥤ C₄
α : F ⟶ F'
I₁ : Type u_5
I₂ : Type u_6
I₃ : Type u_7
X₁ Y₁ : GradedObject I₁ C₁
φ : X₁ ⟶ Y₁
X₂ : GradedObject I₂ C₂
X₃ : GradedObject I₃ C₃
i₁ : I₁
i₂ : I₂
i₃ : I₃
⊢ (((mapTrifunctor F I₁ I₂ I₃).map φ ≫
              (fun X₁ => NatTrans.mk fun X₂ => NatTrans.mk fun X₃ i => ((α.app (X₁ i.1)).app (X₂ i.2.1)).app (X₃ i.2.2))
                Y₁).app
          X₂).app
      X₃ (i₁, i₂, i₃) =
    (((fun X₁ => NatTrans.mk fun X₂ => NatTrans.mk fun X₃ i => ((α.app (X₁ i.1)).app (X₂ i.2.1)).app (X₃ i.2.2)) X₁ ≫
              (mapTrifunctor F' I₁ I₂ I₃).map φ).app
          X₂).app
      X₃ (i₁, i₂, i₃)

Next tactic:
dsimp
/-- The natural transformation `mapTrifunctor F I₁ I₂ I₃ ⟶ mapTrifunctor F' I₁ I₂ I₃`
induced by a natural transformation `F ⟶ F` of trifunctors. -/
@[simps]
def mapTrifunctorMapNatTrans (α : F ⟶ F') (I₁ I₂ I₃ : Type*) :
    mapTrifunctor F I₁ I₂ I₃ ⟶ mapTrifunctor F' I₁ I₂ I₃ where
  app X₁ :=
    { app := fun X₂ =>
        { app := fun X₃ i => ((α.app _).app _).app _ }
      naturality := fun {X₂ Y₂} φ => by
        ext X₃ ⟨i₁, i₂, i₃⟩
        dsimp
        simp only [← NatTrans.comp_app, NatTrans.naturality] }
  naturality := fun {X₁ Y₁} φ => by
    ext X₂ X₃ ⟨i₁, i₂, i₃⟩
    dsimp
    

Proof state:
case w.h.w.h.h.mk.mk
C₁ : Type u_1
C₂ : Type u_2
C₃ : Type u_3
C₄ : Type u_4
inst✝³ : Category.{?u.62962, u_1} C₁
inst✝² : Category.{?u.62966, u_2} C₂
inst✝¹ : Category.{?u.62970, u_3} C₃
inst✝ : Category.{?u.62974, u_4} C₄
F F' : C₁ ⥤ C₂ ⥤ C₃ ⥤ C₄
α : F ⟶ F'
I₁ : Type u_5
I₂ : Type u_6
I₃ : Type u_7
X₁ Y₁ : GradedObject I₁ C₁
φ : X₁ ⟶ Y₁
X₂ : GradedObject I₂ C₂
X₃ : GradedObject I₃ C₃
i₁ : I₁
i₂ : I₂
i₃ : I₃
⊢ ((F.map (φ i₁)).app (X₂ i₂)).app (X₃ i₃) ≫ ((α.app (Y₁ i₁)).app (X₂ i₂)).app (X₃ i₃) =
    ((α.app (X₁ i₁)).app (X₂ i₂)).app (X₃ i₃) ≫ ((F'.map (φ i₁)).app (X₂ i₂)).app (X₃ i₃)

Next tactic:
simp only [← NatTrans.comp_app, NatTrans.naturality]
/-- The natural isomorphism `mapTrifunctor F I₁ I₂ I₃ ≅ mapTrifunctor F' I₁ I₂ I₃`
induced by a natural isomorphism `F ≅ F` of trifunctors. -/
@[simps]
def mapTrifunctorMapIso (e : F ≅ F') (I₁ I₂ I₃ : Type*) :
    mapTrifunctor F I₁ I₂ I₃ ≅ mapTrifunctor F' I₁ I₂ I₃ where
  hom := mapTrifunctorMapNatTrans e.hom I₁ I₂ I₃
  inv := mapTrifunctorMapNatTrans e.inv I₁ I₂ I₃
  hom_inv_id := by
    

Proof state:
C₁ : Type u_1
C₂ : Type u_2
C₃ : Type u_3
C₄ : Type u_4
inst✝³ : Category.{?u.76521, u_1} C₁
inst✝² : Category.{?u.76525, u_2} C₂
inst✝¹ : Category.{?u.76529, u_3} C₃
inst✝ : Category.{?u.76533, u_4} C₄
F F' : C₁ ⥤ C₂ ⥤ C₃ ⥤ C₄
e : F ≅ F'
I₁ : Type u_5
I₂ : Type u_6
I₃ : Type u_7
⊢ mapTrifunctorMapNatTrans e.hom I₁ I₂ I₃ ≫ mapTrifunctorMapNatTrans e.inv I₁ I₂ I₃ = 𝟙 (mapTrifunctor F I₁ I₂ I₃)

Next tactic:
ext X₁ X₂ X₃ ⟨i₁, i₂, i₃⟩
/-- The natural isomorphism `mapTrifunctor F I₁ I₂ I₃ ≅ mapTrifunctor F' I₁ I₂ I₃`
induced by a natural isomorphism `F ≅ F` of trifunctors. -/
@[simps]
def mapTrifunctorMapIso (e : F ≅ F') (I₁ I₂ I₃ : Type*) :
    mapTrifunctor F I₁ I₂ I₃ ≅ mapTrifunctor F' I₁ I₂ I₃ where
  hom := mapTrifunctorMapNatTrans e.hom I₁ I₂ I₃
  inv := mapTrifunctorMapNatTrans e.inv I₁ I₂ I₃
  hom_inv_id := by
    ext X₁ X₂ X₃ ⟨i₁, i₂, i₃⟩
    

Proof state:
case w.h.w.h.w.h.h.mk.mk
C₁ : Type u_1
C₂ : Type u_2
C₃ : Type u_3
C₄ : Type u_4
inst✝³ : Category.{?u.76521, u_1} C₁
inst✝² : Category.{?u.76525, u_2} C₂
inst✝¹ : Category.{?u.76529, u_3} C₃
inst✝ : Category.{?u.76533, u_4} C₄
F F' : C₁ ⥤ C₂ ⥤ C₃ ⥤ C₄
e : F ≅ F'
I₁ : Type u_5
I₂ : Type u_6
I₃ : Type u_7
X₁ : GradedObject I₁ C₁
X₂ : GradedObject I₂ C₂
X₃ : GradedObject I₃ C₃
i₁ : I₁
i₂ : I₂
i₃ : I₃
⊢ (((mapTrifunctorMapNatTrans e.hom I₁ I₂ I₃ ≫ mapTrifunctorMapNatTrans e.inv I₁ I₂ I₃).app X₁).app X₂).app X₃
      (i₁, i₂, i₃) =
    (((𝟙 (mapTrifunctor F I₁ I₂ I₃)).app X₁).app X₂).app X₃ (i₁, i₂, i₃)

Next tactic:
dsimp
/-- The natural isomorphism `mapTrifunctor F I₁ I₂ I₃ ≅ mapTrifunctor F' I₁ I₂ I₃`
induced by a natural isomorphism `F ≅ F` of trifunctors. -/
@[simps]
def mapTrifunctorMapIso (e : F ≅ F') (I₁ I₂ I₃ : Type*) :
    mapTrifunctor F I₁ I₂ I₃ ≅ mapTrifunctor F' I₁ I₂ I₃ where
  hom := mapTrifunctorMapNatTrans e.hom I₁ I₂ I₃
  inv := mapTrifunctorMapNatTrans e.inv I₁ I₂ I₃
  hom_inv_id := by
    ext X₁ X₂ X₃ ⟨i₁, i₂, i₃⟩
    dsimp
    

Proof state:
case w.h.w.h.w.h.h.mk.mk
C₁ : Type u_1
C₂ : Type u_2
C₃ : Type u_3
C₄ : Type u_4
inst✝³ : Category.{?u.76521, u_1} C₁
inst✝² : Category.{?u.76525, u_2} C₂
inst✝¹ : Category.{?u.76529, u_3} C₃
inst✝ : Category.{?u.76533, u_4} C₄
F F' : C₁ ⥤ C₂ ⥤ C₃ ⥤ C₄
e : F ≅ F'
I₁ : Type u_5
I₂ : Type u_6
I₃ : Type u_7
X₁ : GradedObject I₁ C₁
X₂ : GradedObject I₂ C₂
X₃ : GradedObject I₃ C₃
i₁ : I₁
i₂ : I₂
i₃ : I₃
⊢ ((e.hom.app (X₁ i₁)).app (X₂ i₂)).app (X₃ i₃) ≫ ((e.inv.app (X₁ i₁)).app (X₂ i₂)).app (X₃ i₃) =
    𝟙 (((F.obj (X₁ i₁)).obj (X₂ i₂)).obj (X₃ i₃))

Next tactic:
simp only [← NatTrans.comp_app, e.hom_inv_id, NatTrans.id_app]
/-- The natural isomorphism `mapTrifunctor F I₁ I₂ I₃ ≅ mapTrifunctor F' I₁ I₂ I₃`
induced by a natural isomorphism `F ≅ F` of trifunctors. -/
@[simps]
def mapTrifunctorMapIso (e : F ≅ F') (I₁ I₂ I₃ : Type*) :
    mapTrifunctor F I₁ I₂ I₃ ≅ mapTrifunctor F' I₁ I₂ I₃ where
  hom := mapTrifunctorMapNatTrans e.hom I₁ I₂ I₃
  inv := mapTrifunctorMapNatTrans e.inv I₁ I₂ I₃
  hom_inv_id := by
    ext X₁ X₂ X₃ ⟨i₁, i₂, i₃⟩
    dsimp
    simp only [← NatTrans.comp_app, e.hom_inv_id, NatTrans.id_app]
  inv_hom_id := by
    

Proof state:
C₁ : Type u_1
C₂ : Type u_2
C₃ : Type u_3
C₄ : Type u_4
inst✝³ : Category.{?u.76521, u_1} C₁
inst✝² : Category.{?u.76525, u_2} C₂
inst✝¹ : Category.{?u.76529, u_3} C₃
inst✝ : Category.{?u.76533, u_4} C₄
F F' : C₁ ⥤ C₂ ⥤ C₃ ⥤ C₄
e : F ≅ F'
I₁ : Type u_5
I₂ : Type u_6
I₃ : Type u_7
⊢ mapTrifunctorMapNatTrans e.inv I₁ I₂ I₃ ≫ mapTrifunctorMapNatTrans e.hom I₁ I₂ I₃ = 𝟙 (mapTrifunctor F' I₁ I₂ I₃)

Next tactic:
ext X₁ X₂ X₃ ⟨i₁, i₂, i₃⟩
/-- The natural isomorphism `mapTrifunctor F I₁ I₂ I₃ ≅ mapTrifunctor F' I₁ I₂ I₃`
induced by a natural isomorphism `F ≅ F` of trifunctors. -/
@[simps]
def mapTrifunctorMapIso (e : F ≅ F') (I₁ I₂ I₃ : Type*) :
    mapTrifunctor F I₁ I₂ I₃ ≅ mapTrifunctor F' I₁ I₂ I₃ where
  hom := mapTrifunctorMapNatTrans e.hom I₁ I₂ I₃
  inv := mapTrifunctorMapNatTrans e.inv I₁ I₂ I₃
  hom_inv_id := by
    ext X₁ X₂ X₃ ⟨i₁, i₂, i₃⟩
    dsimp
    simp only [← NatTrans.comp_app, e.hom_inv_id, NatTrans.id_app]
  inv_hom_id := by
    ext X₁ X₂ X₃ ⟨i₁, i₂, i₃⟩
    

Proof state:
case w.h.w.h.w.h.h.mk.mk
C₁ : Type u_1
C₂ : Type u_2
C₃ : Type u_3
C₄ : Type u_4
inst✝³ : Category.{?u.76521, u_1} C₁
inst✝² : Category.{?u.76525, u_2} C₂
inst✝¹ : Category.{?u.76529, u_3} C₃
inst✝ : Category.{?u.76533, u_4} C₄
F F' : C₁ ⥤ C₂ ⥤ C₃ ⥤ C₄
e : F ≅ F'
I₁ : Type u_5
I₂ : Type u_6
I₃ : Type u_7
X₁ : GradedObject I₁ C₁
X₂ : GradedObject I₂ C₂
X₃ : GradedObject I₃ C₃
i₁ : I₁
i₂ : I₂
i₃ : I₃
⊢ (((mapTrifunctorMapNatTrans e.inv I₁ I₂ I₃ ≫ mapTrifunctorMapNatTrans e.hom I₁ I₂ I₃).app X₁).app X₂).app X₃
      (i₁, i₂, i₃) =
    (((𝟙 (mapTrifunctor F' I₁ I₂ I₃)).app X₁).app X₂).app X₃ (i₁, i₂, i₃)

Next tactic:
dsimp
/-- The natural isomorphism `mapTrifunctor F I₁ I₂ I₃ ≅ mapTrifunctor F' I₁ I₂ I₃`
induced by a natural isomorphism `F ≅ F` of trifunctors. -/
@[simps]
def mapTrifunctorMapIso (e : F ≅ F') (I₁ I₂ I₃ : Type*) :
    mapTrifunctor F I₁ I₂ I₃ ≅ mapTrifunctor F' I₁ I₂ I₃ where
  hom := mapTrifunctorMapNatTrans e.hom I₁ I₂ I₃
  inv := mapTrifunctorMapNatTrans e.inv I₁ I₂ I₃
  hom_inv_id := by
    ext X₁ X₂ X₃ ⟨i₁, i₂, i₃⟩
    dsimp
    simp only [← NatTrans.comp_app, e.hom_inv_id, NatTrans.id_app]
  inv_hom_id := by
    ext X₁ X₂ X₃ ⟨i₁, i₂, i₃⟩
    dsimp
    

Proof state:
case w.h.w.h.w.h.h.mk.mk
C₁ : Type u_1
C₂ : Type u_2
C₃ : Type u_3
C₄ : Type u_4
inst✝³ : Category.{?u.76521, u_1} C₁
inst✝² : Category.{?u.76525, u_2} C₂
inst✝¹ : Category.{?u.76529, u_3} C₃
inst✝ : Category.{?u.76533, u_4} C₄
F F' : C₁ ⥤ C₂ ⥤ C₃ ⥤ C₄
e : F ≅ F'
I₁ : Type u_5
I₂ : Type u_6
I₃ : Type u_7
X₁ : GradedObject I₁ C₁
X₂ : GradedObject I₂ C₂
X₃ : GradedObject I₃ C₃
i₁ : I₁
i₂ : I₂
i₃ : I₃
⊢ ((e.inv.app (X₁ i₁)).app (X₂ i₂)).app (X₃ i₃) ≫ ((e.hom.app (X₁ i₁)).app (X₂ i₂)).app (X₃ i₃) =
    𝟙 (((F'.obj (X₁ i₁)).obj (X₂ i₂)).obj (X₃ i₃))

Next tactic:
simp only [← NatTrans.comp_app, e.inv_hom_id, NatTrans.id_app]
@[reassoc (attr := simp)]
lemma ι_mapTrifunctorMapMap {X₁ Y₁ : GradedObject I₁ C₁} (f₁ : X₁ ⟶ Y₁)
    {X₂ Y₂ : GradedObject I₂ C₂} (f₂ : X₂ ⟶ Y₂)
    {X₃ Y₃ : GradedObject I₃ C₃} (f₃ : X₃ ⟶ Y₃)
    [HasMap ((((mapTrifunctor F I₁ I₂ I₃).obj X₁).obj X₂).obj X₃) p]
    [HasMap ((((mapTrifunctor F I₁ I₂ I₃).obj Y₁).obj Y₂).obj Y₃) p]
    (i₁ : I₁) (i₂ : I₂) (i₃ : I₃) (j : J) (h : p ⟨i₁, i₂, i₃⟩ = j) :
  ιMapTrifunctorMapObj F p X₁ X₂ X₃ i₁ i₂ i₃ j h ≫ mapTrifunctorMapMap F p f₁ f₂ f₃ j =
    ((F.map (f₁ i₁)).app (X₂ i₂)).app (X₃ i₃) ≫
      ((F.obj (Y₁ i₁)).map (f₂ i₂)).app (X₃ i₃) ≫
      ((F.obj (Y₁ i₁)).obj (Y₂ i₂)).map (f₃ i₃) ≫
      ιMapTrifunctorMapObj F p Y₁ Y₂ Y₃ i₁ i₂ i₃ j h := by
  

Proof state:
C₁ : Type u_1
C₂ : Type u_2
C₃ : Type u_3
C₄ : Type u_4
inst✝⁵ : Category.{u_9, u_1} C₁
inst✝⁴ : Category.{u_10, u_2} C₂
inst✝³ : Category.{u_11, u_3} C₃
inst✝² : Category.{u_12, u_4} C₄
F F' : C₁ ⥤ C₂ ⥤ C₃ ⥤ C₄
I₁ : Type u_5
I₂ : Type u_6
I₃ : Type u_7
J : Type u_8
p : I₁ × I₂ × I₃ → J
X₁ Y₁ : GradedObject I₁ C₁
f₁ : X₁ ⟶ Y₁
X₂ Y₂ : GradedObject I₂ C₂
f₂ : X₂ ⟶ Y₂
X₃ Y₃ : GradedObject I₃ C₃
f₃ : X₃ ⟶ Y₃
inst✝¹ : HasMap ((((mapTrifunctor F I₁ I₂ I₃).obj X₁).obj X₂).obj X₃) p
inst✝ : HasMap ((((mapTrifunctor F I₁ I₂ I₃).obj Y₁).obj Y₂).obj Y₃) p
i₁ : I₁
i₂ : I₂
i₃ : I₃
j : J
h : p (i₁, i₂, i₃) = j
⊢ ιMapTrifunctorMapObj F p X₁ X₂ X₃ i₁ i₂ i₃ j h ≫ mapTrifunctorMapMap F p f₁ f₂ f₃ j =
    ((F.map (f₁ i₁)).app (X₂ i₂)).app (X₃ i₃) ≫
      ((F.obj (Y₁ i₁)).map (f₂ i₂)).app (X₃ i₃) ≫
        ((F.obj (Y₁ i₁)).obj (Y₂ i₂)).map (f₃ i₃) ≫ ιMapTrifunctorMapObj F p Y₁ Y₂ Y₃ i₁ i₂ i₃ j h

Next tactic:
dsimp only [ιMapTrifunctorMapObj, mapTrifunctorMapMap]
@[reassoc (attr := simp)]
lemma ι_mapTrifunctorMapMap {X₁ Y₁ : GradedObject I₁ C₁} (f₁ : X₁ ⟶ Y₁)
    {X₂ Y₂ : GradedObject I₂ C₂} (f₂ : X₂ ⟶ Y₂)
    {X₃ Y₃ : GradedObject I₃ C₃} (f₃ : X₃ ⟶ Y₃)
    [HasMap ((((mapTrifunctor F I₁ I₂ I₃).obj X₁).obj X₂).obj X₃) p]
    [HasMap ((((mapTrifunctor F I₁ I₂ I₃).obj Y₁).obj Y₂).obj Y₃) p]
    (i₁ : I₁) (i₂ : I₂) (i₃ : I₃) (j : J) (h : p ⟨i₁, i₂, i₃⟩ = j) :
  ιMapTrifunctorMapObj F p X₁ X₂ X₃ i₁ i₂ i₃ j h ≫ mapTrifunctorMapMap F p f₁ f₂ f₃ j =
    ((F.map (f₁ i₁)).app (X₂ i₂)).app (X₃ i₃) ≫
      ((F.obj (Y₁ i₁)).map (f₂ i₂)).app (X₃ i₃) ≫
      ((F.obj (Y₁ i₁)).obj (Y₂ i₂)).map (f₃ i₃) ≫
      ιMapTrifunctorMapObj F p Y₁ Y₂ Y₃ i₁ i₂ i₃ j h := by
  dsimp only [ιMapTrifunctorMapObj, mapTrifunctorMapMap]
  

Proof state:
C₁ : Type u_1
C₂ : Type u_2
C₃ : Type u_3
C₄ : Type u_4
inst✝⁵ : Category.{u_9, u_1} C₁
inst✝⁴ : Category.{u_10, u_2} C₂
inst✝³ : Category.{u_11, u_3} C₃
inst✝² : Category.{u_12, u_4} C₄
F F' : C₁ ⥤ C₂ ⥤ C₃ ⥤ C₄
I₁ : Type u_5
I₂ : Type u_6
I₃ : Type u_7
J : Type u_8
p : I₁ × I₂ × I₃ → J
X₁ Y₁ : GradedObject I₁ C₁
f₁ : X₁ ⟶ Y₁
X₂ Y₂ : GradedObject I₂ C₂
f₂ : X₂ ⟶ Y₂
X₃ Y₃ : GradedObject I₃ C₃
f₃ : X₃ ⟶ Y₃
inst✝¹ : HasMap ((((mapTrifunctor F I₁ I₂ I₃).obj X₁).obj X₂).obj X₃) p
inst✝ : HasMap ((((mapTrifunctor F I₁ I₂ I₃).obj Y₁).obj Y₂).obj Y₃) p
i₁ : I₁
i₂ : I₂
i₃ : I₃
j : J
h : p (i₁, i₂, i₃) = j
⊢ ιMapObj ((((mapTrifunctor F I₁ I₂ I₃).obj X₁).obj X₂).obj X₃) p (i₁, i₂, i₃) j h ≫
      mapMap
        ((((mapTrifunctor F I₁ I₂ I₃).map f₁).app X₂).app X₃ ≫
          (((mapTrifunctor F I₁ I₂ I₃).obj Y₁).map f₂).app X₃ ≫ (((mapTrifunctor F I₁ I₂ I₃).obj Y₁).obj Y₂).map f₃)
        p j =
    ((F.map (f₁ i₁)).app (X₂ i₂)).app (X₃ i₃) ≫
      ((F.obj (Y₁ i₁)).map (f₂ i₂)).app (X₃ i₃) ≫
        ((F.obj (Y₁ i₁)).obj (Y₂ i₂)).map (f₃ i₃) ≫
          ιMapObj ((((mapTrifunctor F I₁ I₂ I₃).obj Y₁).obj Y₂).obj Y₃) p (i₁, i₂, i₃) j h

Next tactic:
rw [ι_mapMap]