l3lab/ntp-mathlib huggingface dataset:
instance (F : LaxMonoidalFunctor V W) : EnrichedCategory W (TransportEnrichment F C) where
  Hom := fun X Y : C => F.obj (X ⟶[V] Y)
  id := fun X : C => F.ε ≫ F.map (eId V X)
  comp := fun X Y Z : C => F.μ _ _ ≫ F.map (eComp V X Y Z)
  id_comp X Y := by
    rw [comp_tensor_id, Category.assoc, ← F.toFunctor.map_id, F.μ_natural_assoc,
      F.toFunctor.map_id, F.left_unitality_inv_assoc, ← F.toFunctor.map_comp, ←
      F.toFunctor.map_comp, e_id_comp, F.toFunctor.map_id]
  comp_id X Y := by
    rw [id_tensor_comp, Category.assoc, ← F.toFunctor.map_id, F.μ_natural_assoc,
      F.toFunctor.map_id, F.right_unitality_inv_assoc, ← F.toFunctor.map_comp, ←
      F.toFunctor.map_comp, e_comp_id, F.toFunctor.map_id]
  assoc P Q R S := by
    

Proof state:
V : Type v
inst✝⁴ : Category.{w, v} V
inst✝³ : MonoidalCategory V
C : Type u₁
inst✝² : EnrichedCategory V C
W : Type v
inst✝¹ : Category.{w, v} W
inst✝ : MonoidalCategory W
F : LaxMonoidalFunctor V W
P Q R S : TransportEnrichment F C
⊢ (α_ ((fun X Y => F.obj (EnrichedCategory.Hom X Y)) P Q) ((fun X Y => F.obj (EnrichedCategory.Hom X Y)) Q R)
          ((fun X Y => F.obj (EnrichedCategory.Hom X Y)) R S)).inv ≫
      ((fun X Y Z =>
              LaxMonoidalFunctor.μ F (EnrichedCategory.Hom X Y) (EnrichedCategory.Hom Y Z) ≫ F.map (eComp V X Y Z))
            P Q R ⊗
          𝟙 ((fun X Y => F.obj (EnrichedCategory.Hom X Y)) R S)) ≫
        (fun X Y Z =>
            LaxMonoidalFunctor.μ F (EnrichedCategory.Hom X Y) (EnrichedCategory.Hom Y Z) ≫ F.map (eComp V X Y Z))
          P R S =
    (𝟙 ((fun X Y => F.obj (EnrichedCategory.Hom X Y)) P Q) ⊗
        (fun X Y Z =>
            LaxMonoidalFunctor.μ F (EnrichedCategory.Hom X Y) (EnrichedCategory.Hom Y Z) ≫ F.map (eComp V X Y Z))
          Q R S) ≫
      (fun X Y Z =>
          LaxMonoidalFunctor.μ F (EnrichedCategory.Hom X Y) (EnrichedCategory.Hom Y Z) ≫ F.map (eComp V X Y Z))
        P Q S

Next tactic:
rw [comp_tensor_id, Category.assoc, ← F.toFunctor.map_id, F.μ_natural_assoc,
      F.toFunctor.map_id, ← F.associativity_inv_assoc, ← F.toFunctor.map_comp, ←
      F.toFunctor.map_comp, e_assoc, id_tensor_comp, Category.assoc, ← F.toFunctor.map_id,
      F.μ_natural_assoc, F.toFunctor.map_comp]
/-- Construct a `Type v`-enriched category from an honest category.
-/
def enrichedCategoryTypeOfCategory (C : Type u₁) [𝒞 : Category.{v} C] : EnrichedCategory (Type v) C
    where
  Hom := 𝒞.Hom
  id X _ := 𝟙 X
  comp X Y Z p := p.1 ≫ p.2
  id_comp X Y := by 

Proof state:
V : Type v
inst✝² : Category.{w, v} V
inst✝¹ : MonoidalCategory V
C✝ : Type u₁
inst✝ : EnrichedCategory V C✝
C : Type u₁
𝒞 : Category.{v, u₁} C
X Y : C
⊢ (λ_ (X ⟶ Y)).inv ≫ ((fun X x => 𝟙 X) X ⊗ 𝟙 (X ⟶ Y)) ≫ (fun X Y Z p => p.1 ≫ p.2) X X Y = 𝟙 (X ⟶ Y)

Next tactic:
ext
/-- Construct a `Type v`-enriched category from an honest category.
-/
def enrichedCategoryTypeOfCategory (C : Type u₁) [𝒞 : Category.{v} C] : EnrichedCategory (Type v) C
    where
  Hom := 𝒞.Hom
  id X _ := 𝟙 X
  comp X Y Z p := p.1 ≫ p.2
  id_comp X Y := by ext; 

Proof state:
case h
V : Type v
inst✝² : Category.{w, v} V
inst✝¹ : MonoidalCategory V
C✝ : Type u₁
inst✝ : EnrichedCategory V C✝
C : Type u₁
𝒞 : Category.{v, u₁} C
X Y : C
a✝ : X ⟶ Y
⊢ ((λ_ (X ⟶ Y)).inv ≫ ((fun X x => 𝟙 X) X ⊗ 𝟙 (X ⟶ Y)) ≫ (fun X Y Z p => p.1 ≫ p.2) X X Y) a✝ = 𝟙 (X ⟶ Y) a✝

Next tactic:
simp
/-- Construct a `Type v`-enriched category from an honest category.
-/
def enrichedCategoryTypeOfCategory (C : Type u₁) [𝒞 : Category.{v} C] : EnrichedCategory (Type v) C
    where
  Hom := 𝒞.Hom
  id X _ := 𝟙 X
  comp X Y Z p := p.1 ≫ p.2
  id_comp X Y := by ext; simp
  comp_id X Y := by 

Proof state:
V : Type v
inst✝² : Category.{w, v} V
inst✝¹ : MonoidalCategory V
C✝ : Type u₁
inst✝ : EnrichedCategory V C✝
C : Type u₁
𝒞 : Category.{v, u₁} C
X Y : C
⊢ (ρ_ (X ⟶ Y)).inv ≫ (𝟙 (X ⟶ Y) ⊗ (fun X x => 𝟙 X) Y) ≫ (fun X Y Z p => p.1 ≫ p.2) X Y Y = 𝟙 (X ⟶ Y)

Next tactic:
ext
/-- Construct a `Type v`-enriched category from an honest category.
-/
def enrichedCategoryTypeOfCategory (C : Type u₁) [𝒞 : Category.{v} C] : EnrichedCategory (Type v) C
    where
  Hom := 𝒞.Hom
  id X _ := 𝟙 X
  comp X Y Z p := p.1 ≫ p.2
  id_comp X Y := by ext; simp
  comp_id X Y := by ext; 

Proof state:
case h
V : Type v
inst✝² : Category.{w, v} V
inst✝¹ : MonoidalCategory V
C✝ : Type u₁
inst✝ : EnrichedCategory V C✝
C : Type u₁
𝒞 : Category.{v, u₁} C
X Y : C
a✝ : X ⟶ Y
⊢ ((ρ_ (X ⟶ Y)).inv ≫ (𝟙 (X ⟶ Y) ⊗ (fun X x => 𝟙 X) Y) ≫ (fun X Y Z p => p.1 ≫ p.2) X Y Y) a✝ = 𝟙 (X ⟶ Y) a✝

Next tactic:
simp
/-- Construct a `Type v`-enriched category from an honest category.
-/
def enrichedCategoryTypeOfCategory (C : Type u₁) [𝒞 : Category.{v} C] : EnrichedCategory (Type v) C
    where
  Hom := 𝒞.Hom
  id X _ := 𝟙 X
  comp X Y Z p := p.1 ≫ p.2
  id_comp X Y := by ext; simp
  comp_id X Y := by ext; simp
  assoc W X Y Z := by 

Proof state:
V : Type v
inst✝² : Category.{w, v} V
inst✝¹ : MonoidalCategory V
C✝ : Type u₁
inst✝ : EnrichedCategory V C✝
C : Type u₁
𝒞 : Category.{v, u₁} C
W X Y Z : C
⊢ (α_ (W ⟶ X) (X ⟶ Y) (Y ⟶ Z)).inv ≫ ((fun X Y Z p => p.1 ≫ p.2) W X Y ⊗ 𝟙 (Y ⟶ Z)) ≫ (fun X Y Z p => p.1 ≫ p.2) W Y Z =
    (𝟙 (W ⟶ X) ⊗ (fun X Y Z p => p.1 ≫ p.2) X Y Z) ≫ (fun X Y Z p => p.1 ≫ p.2) W X Z

Next tactic:
ext ⟨f, g, h⟩
/-- Construct a `Type v`-enriched category from an honest category.
-/
def enrichedCategoryTypeOfCategory (C : Type u₁) [𝒞 : Category.{v} C] : EnrichedCategory (Type v) C
    where
  Hom := 𝒞.Hom
  id X _ := 𝟙 X
  comp X Y Z p := p.1 ≫ p.2
  id_comp X Y := by ext; simp
  comp_id X Y := by ext; simp
  assoc W X Y Z := by ext ⟨f, g, h⟩; 

Proof state:
case h.mk.mk
V : Type v
inst✝² : Category.{w, v} V
inst✝¹ : MonoidalCategory V
C✝ : Type u₁
inst✝ : EnrichedCategory V C✝
C : Type u₁
𝒞 : Category.{v, u₁} C
W X Y Z : C
f : W ⟶ X
g : X ⟶ Y
h : Y ⟶ Z
⊢ ((α_ (W ⟶ X) (X ⟶ Y) (Y ⟶ Z)).inv ≫ ((fun X Y Z p => p.1 ≫ p.2) W X Y ⊗ 𝟙 (Y ⟶ Z)) ≫ (fun X Y Z p => p.1 ≫ p.2) W Y Z)
      (f, g, h) =
    ((𝟙 (W ⟶ X) ⊗ (fun X Y Z p => p.1 ≫ p.2) X Y Z) ≫ (fun X Y Z p => p.1 ≫ p.2) W X Z) (f, g, h)

Next tactic:
simp
instance categoryForgetEnrichment : Category (ForgetEnrichment W C) := by
  

Proof state:
V : Type v
inst✝⁵ : Category.{w, v} V
inst✝⁴ : MonoidalCategory V
C : Type u₁
inst✝³ : EnrichedCategory V C
W : Type (v + 1)
inst✝² : Category.{v, v + 1} W
inst✝¹ : MonoidalCategory W
inst✝ : EnrichedCategory W C
⊢ Category.{?u.104366, u₁} (ForgetEnrichment W C)

Next tactic:
let I : EnrichedCategory (Type v) (TransportEnrichment (coyonedaTensorUnit W) C) :=
    inferInstance
instance categoryForgetEnrichment : Category (ForgetEnrichment W C) := by
  let I : EnrichedCategory (Type v) (TransportEnrichment (coyonedaTensorUnit W) C) :=
    inferInstance
  

Proof state:
V : Type v
inst✝⁵ : Category.{w, v} V
inst✝⁴ : MonoidalCategory V
C : Type u₁
inst✝³ : EnrichedCategory V C
W : Type (v + 1)
inst✝² : Category.{v, v + 1} W
inst✝¹ : MonoidalCategory W
inst✝ : EnrichedCategory W C
I : EnrichedCategory (Type v) (TransportEnrichment (coyonedaTensorUnit W) C) := inferInstance
⊢ Category.{?u.104366, u₁} (ForgetEnrichment W C)

Next tactic:
exact enrichedCategoryTypeEquivCategory C I
/-- An enriched functor induces an honest functor of the underlying categories,
by mapping the `(𝟙_ W)`-shaped morphisms.
-/
def EnrichedFunctor.forget {C : Type u₁} {D : Type u₂} [EnrichedCategory W C] [EnrichedCategory W D]
    (F : EnrichedFunctor W C D) : ForgetEnrichment W C ⥤ ForgetEnrichment W D where
  obj X := ForgetEnrichment.of W (F.obj (ForgetEnrichment.to W X))
  map f :=
    ForgetEnrichment.homOf W
      (ForgetEnrichment.homTo W f ≫ F.map (ForgetEnrichment.to W _) (ForgetEnrichment.to W _))
  map_comp f g := by
    

Proof state:
V : Type v
inst✝⁶ : Category.{w, v} V
inst✝⁵ : MonoidalCategory V
C✝ : Type u₁
inst✝⁴ : EnrichedCategory V C✝
W : Type (v + 1)
inst✝³ : Category.{v, v + 1} W
inst✝² : MonoidalCategory W
C : Type u₁
D : Type u₂
inst✝¹ : EnrichedCategory W C
inst✝ : EnrichedCategory W D
F : EnrichedFunctor W C D
X✝ Y✝ Z✝ : ForgetEnrichment W C
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ { obj := fun X => ForgetEnrichment.of W (obj F (ForgetEnrichment.to W X)),
          map := fun {X Y} f =>
            ForgetEnrichment.homOf W
              (ForgetEnrichment.homTo W f ≫ map F (ForgetEnrichment.to W X) (ForgetEnrichment.to W Y)) }.map
      (f ≫ g) =
    { obj := fun X => ForgetEnrichment.of W (obj F (ForgetEnrichment.to W X)),
            map := fun {X Y} f =>
              ForgetEnrichment.homOf W
                (ForgetEnrichment.homTo W f ≫ map F (ForgetEnrichment.to W X) (ForgetEnrichment.to W Y)) }.map
        f ≫
      { obj := fun X => ForgetEnrichment.of W (obj F (ForgetEnrichment.to W X)),
            map := fun {X Y} f =>
              ForgetEnrichment.homOf W
                (ForgetEnrichment.homTo W f ≫ map F (ForgetEnrichment.to W X) (ForgetEnrichment.to W Y)) }.map
        g

Next tactic:
dsimp
/-- An enriched functor induces an honest functor of the underlying categories,
by mapping the `(𝟙_ W)`-shaped morphisms.
-/
def EnrichedFunctor.forget {C : Type u₁} {D : Type u₂} [EnrichedCategory W C] [EnrichedCategory W D]
    (F : EnrichedFunctor W C D) : ForgetEnrichment W C ⥤ ForgetEnrichment W D where
  obj X := ForgetEnrichment.of W (F.obj (ForgetEnrichment.to W X))
  map f :=
    ForgetEnrichment.homOf W
      (ForgetEnrichment.homTo W f ≫ F.map (ForgetEnrichment.to W _) (ForgetEnrichment.to W _))
  map_comp f g := by
    dsimp
    

Proof state:
V : Type v
inst✝⁶ : Category.{w, v} V
inst✝⁵ : MonoidalCategory V
C✝ : Type u₁
inst✝⁴ : EnrichedCategory V C✝
W : Type (v + 1)
inst✝³ : Category.{v, v + 1} W
inst✝² : MonoidalCategory W
C : Type u₁
D : Type u₂
inst✝¹ : EnrichedCategory W C
inst✝ : EnrichedCategory W D
F : EnrichedFunctor W C D
X✝ Y✝ Z✝ : ForgetEnrichment W C
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ ForgetEnrichment.homOf W
      ((((λ_ (𝟙_ W)).inv ≫ (ForgetEnrichment.homTo W f ⊗ ForgetEnrichment.homTo W g)) ≫
          eComp W (ForgetEnrichment.to W X✝) (ForgetEnrichment.to W Y✝) (ForgetEnrichment.to W Z✝)) ≫
        map F (ForgetEnrichment.to W X✝) (ForgetEnrichment.to W Z✝)) =
    ForgetEnrichment.homOf W
        (ForgetEnrichment.homTo W f ≫ map F (ForgetEnrichment.to W X✝) (ForgetEnrichment.to W Y✝)) ≫
      ForgetEnrichment.homOf W
        (ForgetEnrichment.homTo W g ≫ map F (ForgetEnrichment.to W Y✝) (ForgetEnrichment.to W Z✝))

Next tactic:
apply_fun ForgetEnrichment.homTo W
/-- An enriched functor induces an honest functor of the underlying categories,
by mapping the `(𝟙_ W)`-shaped morphisms.
-/
def EnrichedFunctor.forget {C : Type u₁} {D : Type u₂} [EnrichedCategory W C] [EnrichedCategory W D]
    (F : EnrichedFunctor W C D) : ForgetEnrichment W C ⥤ ForgetEnrichment W D where
  obj X := ForgetEnrichment.of W (F.obj (ForgetEnrichment.to W X))
  map f :=
    ForgetEnrichment.homOf W
      (ForgetEnrichment.homTo W f ≫ F.map (ForgetEnrichment.to W _) (ForgetEnrichment.to W _))
  map_comp f g := by
    dsimp
    apply_fun ForgetEnrichment.homTo W
    · 

Proof state:
V : Type v
inst✝⁶ : Category.{w, v} V
inst✝⁵ : MonoidalCategory V
C✝ : Type u₁
inst✝⁴ : EnrichedCategory V C✝
W : Type (v + 1)
inst✝³ : Category.{v, v + 1} W
inst✝² : MonoidalCategory W
C : Type u₁
D : Type u₂
inst✝¹ : EnrichedCategory W C
inst✝ : EnrichedCategory W D
F : EnrichedFunctor W C D
X✝ Y✝ Z✝ : ForgetEnrichment W C
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ ForgetEnrichment.homTo W
      (ForgetEnrichment.homOf W
        ((((λ_ (𝟙_ W)).inv ≫ (ForgetEnrichment.homTo W f ⊗ ForgetEnrichment.homTo W g)) ≫
            eComp W (ForgetEnrichment.to W X✝) (ForgetEnrichment.to W Y✝) (ForgetEnrichment.to W Z✝)) ≫
          map F (ForgetEnrichment.to W X✝) (ForgetEnrichment.to W Z✝))) =
    ForgetEnrichment.homTo W
      (ForgetEnrichment.homOf W
          (ForgetEnrichment.homTo W f ≫ map F (ForgetEnrichment.to W X✝) (ForgetEnrichment.to W Y✝)) ≫
        ForgetEnrichment.homOf W
          (ForgetEnrichment.homTo W g ≫ map F (ForgetEnrichment.to W Y✝) (ForgetEnrichment.to W Z✝)))

Next tactic:
simp only [Iso.cancel_iso_inv_left, Category.assoc, tensor_comp,
        ForgetEnrichment.homTo_homOf, EnrichedFunctor.map_comp, forgetEnrichment_comp]
/-- An enriched functor induces an honest functor of the underlying categories,
by mapping the `(𝟙_ W)`-shaped morphisms.
-/
def EnrichedFunctor.forget {C : Type u₁} {D : Type u₂} [EnrichedCategory W C] [EnrichedCategory W D]
    (F : EnrichedFunctor W C D) : ForgetEnrichment W C ⥤ ForgetEnrichment W D where
  obj X := ForgetEnrichment.of W (F.obj (ForgetEnrichment.to W X))
  map f :=
    ForgetEnrichment.homOf W
      (ForgetEnrichment.homTo W f ≫ F.map (ForgetEnrichment.to W _) (ForgetEnrichment.to W _))
  map_comp f g := by
    dsimp
    apply_fun ForgetEnrichment.homTo W
    · simp only [Iso.cancel_iso_inv_left, Category.assoc, tensor_comp,
        ForgetEnrichment.homTo_homOf, EnrichedFunctor.map_comp, forgetEnrichment_comp]
      

Proof state:
V : Type v
inst✝⁶ : Category.{w, v} V
inst✝⁵ : MonoidalCategory V
C✝ : Type u₁
inst✝⁴ : EnrichedCategory V C✝
W : Type (v + 1)
inst✝³ : Category.{v, v + 1} W
inst✝² : MonoidalCategory W
C : Type u₁
D : Type u₂
inst✝¹ : EnrichedCategory W C
inst✝ : EnrichedCategory W D
F : EnrichedFunctor W C D
X✝ Y✝ Z✝ : ForgetEnrichment W C
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ (ForgetEnrichment.homTo W f ⊗ ForgetEnrichment.homTo W g) ≫
      (map F (ForgetEnrichment.to W X✝) (ForgetEnrichment.to W Y✝) ⊗
          map F (ForgetEnrichment.to W Y✝) (ForgetEnrichment.to W Z✝)) ≫
        eComp W (obj F (ForgetEnrichment.to W X✝)) (obj F (ForgetEnrichment.to W Y✝))
          (obj F (ForgetEnrichment.to W Z✝)) =
    (ForgetEnrichment.homTo W f ⊗ ForgetEnrichment.homTo W g) ≫
      (map F (ForgetEnrichment.to W X✝) (ForgetEnrichment.to W Y✝) ⊗
          map F (ForgetEnrichment.to W Y✝) (ForgetEnrichment.to W Z✝)) ≫
        eComp W (ForgetEnrichment.to W (ForgetEnrichment.of W (obj F (ForgetEnrichment.to W X✝))))
          (ForgetEnrichment.to W (ForgetEnrichment.of W (obj F (ForgetEnrichment.to W Y✝))))
          (ForgetEnrichment.to W (ForgetEnrichment.of W (obj F (ForgetEnrichment.to W Z✝))))

Next tactic:
rfl
/-- An enriched functor induces an honest functor of the underlying categories,
by mapping the `(𝟙_ W)`-shaped morphisms.
-/
def EnrichedFunctor.forget {C : Type u₁} {D : Type u₂} [EnrichedCategory W C] [EnrichedCategory W D]
    (F : EnrichedFunctor W C D) : ForgetEnrichment W C ⥤ ForgetEnrichment W D where
  obj X := ForgetEnrichment.of W (F.obj (ForgetEnrichment.to W X))
  map f :=
    ForgetEnrichment.homOf W
      (ForgetEnrichment.homTo W f ≫ F.map (ForgetEnrichment.to W _) (ForgetEnrichment.to W _))
  map_comp f g := by
    dsimp
    apply_fun ForgetEnrichment.homTo W
    · simp only [Iso.cancel_iso_inv_left, Category.assoc, tensor_comp,
        ForgetEnrichment.homTo_homOf, EnrichedFunctor.map_comp, forgetEnrichment_comp]
      rfl
    · 

Proof state:
case inj
V : Type v
inst✝⁶ : Category.{w, v} V
inst✝⁵ : MonoidalCategory V
C✝ : Type u₁
inst✝⁴ : EnrichedCategory V C✝
W : Type (v + 1)
inst✝³ : Category.{v, v + 1} W
inst✝² : MonoidalCategory W
C : Type u₁
D : Type u₂
inst✝¹ : EnrichedCategory W C
inst✝ : EnrichedCategory W D
F : EnrichedFunctor W C D
X✝ Y✝ Z✝ : ForgetEnrichment W C
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ Function.Injective (ForgetEnrichment.homTo W)

Next tactic:
intro f g w
/-- An enriched functor induces an honest functor of the underlying categories,
by mapping the `(𝟙_ W)`-shaped morphisms.
-/
def EnrichedFunctor.forget {C : Type u₁} {D : Type u₂} [EnrichedCategory W C] [EnrichedCategory W D]
    (F : EnrichedFunctor W C D) : ForgetEnrichment W C ⥤ ForgetEnrichment W D where
  obj X := ForgetEnrichment.of W (F.obj (ForgetEnrichment.to W X))
  map f :=
    ForgetEnrichment.homOf W
      (ForgetEnrichment.homTo W f ≫ F.map (ForgetEnrichment.to W _) (ForgetEnrichment.to W _))
  map_comp f g := by
    dsimp
    apply_fun ForgetEnrichment.homTo W
    · simp only [Iso.cancel_iso_inv_left, Category.assoc, tensor_comp,
        ForgetEnrichment.homTo_homOf, EnrichedFunctor.map_comp, forgetEnrichment_comp]
      rfl
    · intro f g w; 

Proof state:
case inj
V : Type v
inst✝⁶ : Category.{w, v} V
inst✝⁵ : MonoidalCategory V
C✝ : Type u₁
inst✝⁴ : EnrichedCategory V C✝
W : Type (v + 1)
inst✝³ : Category.{v, v + 1} W
inst✝² : MonoidalCategory W
C : Type u₁
D : Type u₂
inst✝¹ : EnrichedCategory W C
inst✝ : EnrichedCategory W D
F : EnrichedFunctor W C D
X✝ Y✝ Z✝ : ForgetEnrichment W C
f✝ : X✝ ⟶ Y✝
g✝ : Y✝ ⟶ Z✝
f g :
  ForgetEnrichment.of W (obj F (ForgetEnrichment.to W X✝)) ⟶ ForgetEnrichment.of W (obj F (ForgetEnrichment.to W Z✝))
w : ForgetEnrichment.homTo W f = ForgetEnrichment.homTo W g
⊢ f = g

Next tactic:
apply_fun ForgetEnrichment.homOf W at w
/-- An enriched functor induces an honest functor of the underlying categories,
by mapping the `(𝟙_ W)`-shaped morphisms.
-/
def EnrichedFunctor.forget {C : Type u₁} {D : Type u₂} [EnrichedCategory W C] [EnrichedCategory W D]
    (F : EnrichedFunctor W C D) : ForgetEnrichment W C ⥤ ForgetEnrichment W D where
  obj X := ForgetEnrichment.of W (F.obj (ForgetEnrichment.to W X))
  map f :=
    ForgetEnrichment.homOf W
      (ForgetEnrichment.homTo W f ≫ F.map (ForgetEnrichment.to W _) (ForgetEnrichment.to W _))
  map_comp f g := by
    dsimp
    apply_fun ForgetEnrichment.homTo W
    · simp only [Iso.cancel_iso_inv_left, Category.assoc, tensor_comp,
        ForgetEnrichment.homTo_homOf, EnrichedFunctor.map_comp, forgetEnrichment_comp]
      rfl
    · intro f g w; apply_fun ForgetEnrichment.homOf W at w; 

Proof state:
case inj
V : Type v
inst✝⁶ : Category.{w, v} V
inst✝⁵ : MonoidalCategory V
C✝ : Type u₁
inst✝⁴ : EnrichedCategory V C✝
W : Type (v + 1)
inst✝³ : Category.{v, v + 1} W
inst✝² : MonoidalCategory W
C : Type u₁
D : Type u₂
inst✝¹ : EnrichedCategory W C
inst✝ : EnrichedCategory W D
F : EnrichedFunctor W C D
X✝ Y✝ Z✝ : ForgetEnrichment W C
f✝ : X✝ ⟶ Y✝
g✝ : Y✝ ⟶ Z✝
f g :
  ForgetEnrichment.of W (obj F (ForgetEnrichment.to W X✝)) ⟶ ForgetEnrichment.of W (obj F (ForgetEnrichment.to W Z✝))
w : ForgetEnrichment.homOf W (ForgetEnrichment.homTo W f) = ForgetEnrichment.homOf W (ForgetEnrichment.homTo W g)
⊢ f = g

Next tactic:
simpa using w
/-- A presheaf isomorphic to the Yoneda embedding of
the `V`-object of natural transformations from `F` to `G`.
-/
@[simps]
def enrichedNatTransYoneda (F G : EnrichedFunctor V C D) : Vᵒᵖ ⥤ Type max u₁ w where
  obj A := GradedNatTrans ((Center.ofBraided V).obj (unop A)) F G
  map f σ :=
    { app := fun X => f.unop ≫ σ.app X
      naturality := fun X Y => by
        

Proof state:
V : Type v
inst✝⁴ : Category.{w, v} V
inst✝³ : MonoidalCategory V
C : Type u₁
inst✝² : EnrichedCategory V C
D : Type u₂
inst✝¹ : EnrichedCategory V D
inst✝ : BraidedCategory V
F G : EnrichedFunctor V C D
X✝ Y✝ : Vᵒᵖ
f : X✝ ⟶ Y✝
σ : (fun A => GradedNatTrans ((Center.ofBraided V).toLaxMonoidalFunctor.toFunctor.obj A.unop) F G) X✝
X Y : C
⊢ (HalfBraiding.β ((Center.ofBraided V).toLaxMonoidalFunctor.toFunctor.obj Y✝.unop).snd
          (EnrichedCategory.Hom X Y)).hom ≫
      (EnrichedFunctor.map F X Y ⊗ (fun X => f.unop ≫ GradedNatTrans.app σ X) Y) ≫
        eComp V (EnrichedFunctor.obj F X) (EnrichedFunctor.obj F Y) (EnrichedFunctor.obj G Y) =
    ((fun X => f.unop ≫ GradedNatTrans.app σ X) X ⊗ EnrichedFunctor.map G X Y) ≫
      eComp V (EnrichedFunctor.obj F X) (EnrichedFunctor.obj G X) (EnrichedFunctor.obj G Y)

Next tactic:
have p := σ.naturality X Y
/-- A presheaf isomorphic to the Yoneda embedding of
the `V`-object of natural transformations from `F` to `G`.
-/
@[simps]
def enrichedNatTransYoneda (F G : EnrichedFunctor V C D) : Vᵒᵖ ⥤ Type max u₁ w where
  obj A := GradedNatTrans ((Center.ofBraided V).obj (unop A)) F G
  map f σ :=
    { app := fun X => f.unop ≫ σ.app X
      naturality := fun X Y => by
        have p := σ.naturality X Y
        

Proof state:
V : Type v
inst✝⁴ : Category.{w, v} V
inst✝³ : MonoidalCategory V
C : Type u₁
inst✝² : EnrichedCategory V C
D : Type u₂
inst✝¹ : EnrichedCategory V D
inst✝ : BraidedCategory V
F G : EnrichedFunctor V C D
X✝ Y✝ : Vᵒᵖ
f : X✝ ⟶ Y✝
σ : (fun A => GradedNatTrans ((Center.ofBraided V).toLaxMonoidalFunctor.toFunctor.obj A.unop) F G) X✝
X Y : C
p :
  (HalfBraiding.β ((Center.ofBraided V).toLaxMonoidalFunctor.toFunctor.obj X✝.unop).snd
          (EnrichedCategory.Hom X Y)).hom ≫
      (EnrichedFunctor.map F X Y ⊗ GradedNatTrans.app σ Y) ≫
        eComp V (EnrichedFunctor.obj F X) (EnrichedFunctor.obj F Y) (EnrichedFunctor.obj G Y) =
    (GradedNatTrans.app σ X ⊗ EnrichedFunctor.map G X Y) ≫
      eComp V (EnrichedFunctor.obj F X) (EnrichedFunctor.obj G X) (EnrichedFunctor.obj G Y)
⊢ (HalfBraiding.β ((Center.ofBraided V).toLaxMonoidalFunctor.toFunctor.obj Y✝.unop).snd
          (EnrichedCategory.Hom X Y)).hom ≫
      (EnrichedFunctor.map F X Y ⊗ (fun X => f.unop ≫ GradedNatTrans.app σ X) Y) ≫
        eComp V (EnrichedFunctor.obj F X) (EnrichedFunctor.obj F Y) (EnrichedFunctor.obj G Y) =
    ((fun X => f.unop ≫ GradedNatTrans.app σ X) X ⊗ EnrichedFunctor.map G X Y) ≫
      eComp V (EnrichedFunctor.obj F X) (EnrichedFunctor.obj G X) (EnrichedFunctor.obj G Y)

Next tactic:
dsimp at p ⊢
/-- A presheaf isomorphic to the Yoneda embedding of
the `V`-object of natural transformations from `F` to `G`.
-/
@[simps]
def enrichedNatTransYoneda (F G : EnrichedFunctor V C D) : Vᵒᵖ ⥤ Type max u₁ w where
  obj A := GradedNatTrans ((Center.ofBraided V).obj (unop A)) F G
  map f σ :=
    { app := fun X => f.unop ≫ σ.app X
      naturality := fun X Y => by
        have p := σ.naturality X Y
        dsimp at p ⊢
        

Proof state:
V : Type v
inst✝⁴ : Category.{w, v} V
inst✝³ : MonoidalCategory V
C : Type u₁
inst✝² : EnrichedCategory V C
D : Type u₂
inst✝¹ : EnrichedCategory V D
inst✝ : BraidedCategory V
F G : EnrichedFunctor V C D
X✝ Y✝ : Vᵒᵖ
f : X✝ ⟶ Y✝
σ : (fun A => GradedNatTrans ((Center.ofBraided V).toLaxMonoidalFunctor.toFunctor.obj A.unop) F G) X✝
X Y : C
p :
  (β_ X✝.unop (EnrichedCategory.Hom X Y)).hom ≫
      (EnrichedFunctor.map F X Y ⊗ GradedNatTrans.app σ Y) ≫
        eComp V (EnrichedFunctor.obj F X) (EnrichedFunctor.obj F Y) (EnrichedFunctor.obj G Y) =
    (GradedNatTrans.app σ X ⊗ EnrichedFunctor.map G X Y) ≫
      eComp V (EnrichedFunctor.obj F X) (EnrichedFunctor.obj G X) (EnrichedFunctor.obj G Y)
⊢ (β_ Y✝.unop (EnrichedCategory.Hom X Y)).hom ≫
      (EnrichedFunctor.map F X Y ⊗ f.unop ≫ GradedNatTrans.app σ Y) ≫
        eComp V (EnrichedFunctor.obj F X) (EnrichedFunctor.obj F Y) (EnrichedFunctor.obj G Y) =
    (f.unop ≫ GradedNatTrans.app σ X ⊗ EnrichedFunctor.map G X Y) ≫
      eComp V (EnrichedFunctor.obj F X) (EnrichedFunctor.obj G X) (EnrichedFunctor.obj G Y)

Next tactic:
rw [← id_tensor_comp_tensor_id (f.unop ≫ σ.app Y) _, id_tensor_comp, Category.assoc,
          Category.assoc, ← braiding_naturality_assoc, id_tensor_comp_tensor_id_assoc, p, ←
          tensor_comp_assoc, Category.id_comp]
/-- We verify that an enriched functor between `Type v` enriched categories
is just the same thing as an honest functor.
-/
@[simps]
def enrichedFunctorTypeEquivFunctor {C : Type u₁} [𝒞 : EnrichedCategory (Type v) C] {D : Type u₂}
    [𝒟 : EnrichedCategory (Type v) D] : EnrichedFunctor (Type v) C D ≃ C ⥤ D where
  toFun F :=
    { obj := fun X => F.obj X
      map := fun f => F.map _ _ f
      map_id := fun X => congr_fun (F.map_id X) PUnit.unit
      map_comp := fun f g => congr_fun (F.map_comp _ _ _) ⟨f, g⟩ }
  invFun F :=
    { obj := fun X => F.obj X
      map := fun X Y f => F.map f
      map_id := fun X => by 

Proof state:
V : Type v
inst✝² : Category.{w, v} V
inst✝¹ : MonoidalCategory V
C✝ : Type u₁
inst✝ : EnrichedCategory V C✝
C : Type u₁
𝒞 : EnrichedCategory (Type v) C
D : Type u₂
𝒟 : EnrichedCategory (Type v) D
F : C ⥤ D
X : C
⊢ eId (Type v) X ≫ (fun X Y f => F.map f) X X = eId (Type v) ((fun X => F.obj X) X)

Next tactic:
ext ⟨⟩