Theorem: CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.functorObj_obj_X
File: Mathlib/CategoryTheory/Monoidal/Internal/FunctorCategory.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Comon_ (C ⥤ D)
X✝ Y✝ : C
f : X✝ ⟶ Y✝
⊢ A.X.map f ≫
      ((fun X =>
            { X := A.X.obj X, counit := A.counit.app X, comul := A.comul.app X, counit_comul := ⋯, comul_counit := ⋯,
              comul_assoc := ⋯ })
          Y✝).counit =
    ((fun X =>
          { X := A.X.obj X, counit := A.counit.app X, comul := A.comul.app X, counit_comul := ⋯, comul_counit := ⋯,
            comul_assoc := ⋯ })
        X✝).counit
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Comon_ (C ⥤ D)
X✝ Y✝ : C
f : X✝ ⟶ Y✝
⊢ A.X.map f ≫ A.counit.app Y✝ = A.counit.app X✝
tactic: dsimp
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Comon_ (C ⥤ D)
X✝ Y✝ : C
f : X✝ ⟶ Y✝
⊢ A.X.map f ≫ A.counit.app Y✝ = A.counit.app X✝
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Comon_ (C ⥤ D)
X✝ Y✝ : C
f : X✝ ⟶ Y✝
⊢ A.counit.app X✝ ≫ 𝟙 (𝟙_ D) = A.counit.app X✝
tactic: rw [A.counit.naturality, tensorUnit_map]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Comon_ (C ⥤ D)
X✝ Y✝ : C
f : X✝ ⟶ Y✝
⊢ A.counit.app X✝ ≫ 𝟙 (𝟙_ D) = A.counit.app X✝
state_after: no goals
tactic: rw [Category.comp_id]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Comon_ (C ⥤ D)
X✝ Y✝ : C
f : X✝ ⟶ Y✝
⊢ A.X.map f ≫
      ((fun X =>
            { X := A.X.obj X, counit := A.counit.app X, comul := A.comul.app X, counit_comul := ⋯, comul_counit := ⋯,
              comul_assoc := ⋯ })
          Y✝).comul =
    ((fun X =>
            { X := A.X.obj X, counit := A.counit.app X, comul := A.comul.app X, counit_comul := ⋯, comul_counit := ⋯,
              comul_assoc := ⋯ })
          X✝).comul ≫
      (A.X.map f ⊗ A.X.map f)
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Comon_ (C ⥤ D)
X✝ Y✝ : C
f : X✝ ⟶ Y✝
⊢ A.X.map f ≫ A.comul.app Y✝ = A.comul.app X✝ ≫ (A.X.map f ⊗ A.X.map f)
tactic: dsimp
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Comon_ (C ⥤ D)
X✝ Y✝ : C
f : X✝ ⟶ Y✝
⊢ A.X.map f ≫ A.comul.app Y✝ = A.comul.app X✝ ≫ (A.X.map f ⊗ A.X.map f)
state_after: no goals
tactic: rw [A.comul.naturality, tensorObj_map]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Comon_ (C ⥤ D)
X : C
⊢ {
          obj := fun X =>
            { X := A.X.obj X, counit := A.counit.app X, comul := A.comul.app X, counit_comul := ⋯, comul_counit := ⋯,
              comul_assoc := ⋯ },
          map := fun {X Y} f => { hom := A.X.map f, hom_counit := ⋯, hom_comul := ⋯ } }.map
      (𝟙 X) =
    𝟙
      ({
            obj := fun X =>
              { X := A.X.obj X, counit := A.counit.app X, comul := A.comul.app X, counit_comul := ⋯, comul_counit := ⋯,
                comul_assoc := ⋯ },
            map := fun {X Y} f => { hom := A.X.map f, hom_counit := ⋯, hom_comul := ⋯ } }.obj
        X)
state_after: case w
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Comon_ (C ⥤ D)
X : C
⊢ ({
            obj := fun X =>
              { X := A.X.obj X, counit := A.counit.app X, comul := A.comul.app X, counit_comul := ⋯, comul_counit := ⋯,
                comul_assoc := ⋯ },
            map := fun {X Y} f => { hom := A.X.map f, hom_counit := ⋯, hom_comul := ⋯ } }.map
        (𝟙 X)).hom =
    (𝟙
        ({
              obj := fun X =>
                { X := A.X.obj X, counit := A.counit.app X, comul := A.comul.app X, counit_comul := ⋯,
                  comul_counit := ⋯, comul_assoc := ⋯ },
              map := fun {X Y} f => { hom := A.X.map f, hom_counit := ⋯, hom_comul := ⋯ } }.obj
          X)).hom
tactic: ext
state_before: case w
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Comon_ (C ⥤ D)
X : C
⊢ ({
            obj := fun X =>
              { X := A.X.obj X, counit := A.counit.app X, comul := A.comul.app X, counit_comul := ⋯, comul_counit := ⋯,
                comul_assoc := ⋯ },
            map := fun {X Y} f => { hom := A.X.map f, hom_counit := ⋯, hom_comul := ⋯ } }.map
        (𝟙 X)).hom =
    (𝟙
        ({
              obj := fun X =>
                { X := A.X.obj X, counit := A.counit.app X, comul := A.comul.app X, counit_comul := ⋯,
                  comul_counit := ⋯, comul_assoc := ⋯ },
              map := fun {X Y} f => { hom := A.X.map f, hom_counit := ⋯, hom_comul := ⋯ } }.obj
          X)).hom
state_after: case w
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Comon_ (C ⥤ D)
X : C
⊢ A.X.map (𝟙 X) = 𝟙 (A.X.obj X)
tactic: dsimp
state_before: case w
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Comon_ (C ⥤ D)
X : C
⊢ A.X.map (𝟙 X) = 𝟙 (A.X.obj X)
state_after: no goals
tactic: rw [CategoryTheory.Functor.map_id]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Comon_ (C ⥤ D)
X✝ Y✝ Z✝ : C
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ {
          obj := fun X =>
            { X := A.X.obj X, counit := A.counit.app X, comul := A.comul.app X, counit_comul := ⋯, comul_counit := ⋯,
              comul_assoc := ⋯ },
          map := fun {X Y} f => { hom := A.X.map f, hom_counit := ⋯, hom_comul := ⋯ } }.map
      (f ≫ g) =
    {
            obj := fun X =>
              { X := A.X.obj X, counit := A.counit.app X, comul := A.comul.app X, counit_comul := ⋯, comul_counit := ⋯,
                comul_assoc := ⋯ },
            map := fun {X Y} f => { hom := A.X.map f, hom_counit := ⋯, hom_comul := ⋯ } }.map
        f ≫
      {
            obj := fun X =>
              { X := A.X.obj X, counit := A.counit.app X, comul := A.comul.app X, counit_comul := ⋯, comul_counit := ⋯,
                comul_assoc := ⋯ },
            map := fun {X Y} f => { hom := A.X.map f, hom_counit := ⋯, hom_comul := ⋯ } }.map
        g
state_after: case w
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Comon_ (C ⥤ D)
X✝ Y✝ Z✝ : C
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ ({
            obj := fun X =>
              { X := A.X.obj X, counit := A.counit.app X, comul := A.comul.app X, counit_comul := ⋯, comul_counit := ⋯,
                comul_assoc := ⋯ },
            map := fun {X Y} f => { hom := A.X.map f, hom_counit := ⋯, hom_comul := ⋯ } }.map
        (f ≫ g)).hom =
    ({
              obj := fun X =>
                { X := A.X.obj X, counit := A.counit.app X, comul := A.comul.app X, counit_comul := ⋯,
                  comul_counit := ⋯, comul_assoc := ⋯ },
              map := fun {X Y} f => { hom := A.X.map f, hom_counit := ⋯, hom_comul := ⋯ } }.map
          f ≫
        {
              obj := fun X =>
                { X := A.X.obj X, counit := A.counit.app X, comul := A.comul.app X, counit_comul := ⋯,
                  comul_counit := ⋯, comul_assoc := ⋯ },
              map := fun {X Y} f => { hom := A.X.map f, hom_counit := ⋯, hom_comul := ⋯ } }.map
          g).hom
tactic: ext
state_before: case w
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Comon_ (C ⥤ D)
X✝ Y✝ Z✝ : C
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ ({
            obj := fun X =>
              { X := A.X.obj X, counit := A.counit.app X, comul := A.comul.app X, counit_comul := ⋯, comul_counit := ⋯,
                comul_assoc := ⋯ },
            map := fun {X Y} f => { hom := A.X.map f, hom_counit := ⋯, hom_comul := ⋯ } }.map
        (f ≫ g)).hom =
    ({
              obj := fun X =>
                { X := A.X.obj X, counit := A.counit.app X, comul := A.comul.app X, counit_comul := ⋯,
                  comul_counit := ⋯, comul_assoc := ⋯ },
              map := fun {X Y} f => { hom := A.X.map f, hom_counit := ⋯, hom_comul := ⋯ } }.map
          f ≫
        {
              obj := fun X =>
                { X := A.X.obj X, counit := A.counit.app X, comul := A.comul.app X, counit_comul := ⋯,
                  comul_counit := ⋯, comul_assoc := ⋯ },
              map := fun {X Y} f => { hom := A.X.map f, hom_counit := ⋯, hom_comul := ⋯ } }.map
          g).hom
state_after: case w
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Comon_ (C ⥤ D)
X✝ Y✝ Z✝ : C
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ A.X.map (f ≫ g) = A.X.map f ≫ A.X.map g
tactic: dsimp
state_before: case w
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Comon_ (C ⥤ D)
X✝ Y✝ Z✝ : C
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ A.X.map (f ≫ g) = A.X.map f ≫ A.X.map g
state_after: no goals
tactic: rw [Functor.map_comp]