File: Mathlib/CategoryTheory/ChosenFiniteProducts/FunctorCategory.lean

full_name: CategoryTheory.Functor.chosenTerminal
code: /-- The chosen terminal object in `J ⥤ C`. -/
abbrev chosenTerminal : J ⥤ C 
goal: CategoryTheory.Functor J C

full_name: CategoryTheory.Functor.chosenTerminalIsTerminal
code: /-- The chosen terminal object in `J ⥤ C` is terminal. -/
def chosenTerminalIsTerminal : IsTerminal (chosenTerminal J C) 
goal: CategoryTheory.Limits.IsTerminal (CategoryTheory.Functor.chosenTerminal J C)

full_name: CategoryTheory.Functor.chosenProd
code: /-- The chosen binary product on `J ⥤ C`. -/
@[simps]
def chosenProd : J ⥤ C 
goal: CategoryTheory.Functor J C

full_name: CategoryTheory.Functor.chosenProd_obj
code: /-- The chosen binary product on `J ⥤ C`. -/
@[simps]
def chosenProd : J ⥤ C 
goal: (F₁.chosenProd F₂).obj j = CategoryTheory.MonoidalCategory.tensorObj (F₁.obj j) (F₂.obj j)

full_name: CategoryTheory.Functor.chosenProd_map
code: /-- The chosen binary product on `J ⥤ C`. -/
@[simps]
def chosenProd : J ⥤ C 
goal: ∀ {X Y : J} (φ : X ⟶ Y), (F₁.chosenProd F₂).map φ = CategoryTheory.MonoidalCategory.tensorHom (F₁.map φ) (F₂.map φ)

full_name: CategoryTheory.Functor.chosenProd.fst_app
code: /-- The first projection `chosenProd F₁ F₂ ⟶ F₁`. -/
@[simps]
def fst : chosenProd F₁ F₂ ⟶ F₁ 
goal: ∀ (x : J),
  (CategoryTheory.Functor.chosenProd.fst F₁ F₂).app x = CategoryTheory.ChosenFiniteProducts.fst (F₁.obj x) (F₂.obj x)

full_name: CategoryTheory.Functor.chosenProd.fst
code: /-- The first projection `chosenProd F₁ F₂ ⟶ F₁`. -/
@[simps]
def fst : chosenProd F₁ F₂ ⟶ F₁ 
goal: F₁.chosenProd F₂ ⟶ F₁

full_name: CategoryTheory.Functor.chosenProd.snd_app
code: /-- The second projection `chosenProd F₁ F₂ ⟶ F₂`. -/
@[simps]
def snd : chosenProd F₁ F₂ ⟶ F₂ 
goal: (CategoryTheory.Functor.chosenProd.snd F₁ F₂).app j = CategoryTheory.ChosenFiniteProducts.snd (F₁.obj j) (F₂.obj j)

full_name: CategoryTheory.Functor.chosenProd.snd
code: /-- The second projection `chosenProd F₁ F₂ ⟶ F₂`. -/
@[simps]
def snd : chosenProd F₁ F₂ ⟶ F₂ 
goal: F₁.chosenProd F₂ ⟶ F₂

full_name: CategoryTheory.Functor.chosenProd.isLimit
code: /-- `Functor.chosenProd F₁ F₂` is a binary product of `F₁` and `F₂`. -/
noncomputable def isLimit : IsLimit (BinaryFan.mk (fst F₁ F₂) (snd F₁ F₂)) 
goal: CategoryTheory.Limits.IsLimit
  (CategoryTheory.Limits.BinaryFan.mk (CategoryTheory.Functor.chosenProd.fst F₁ F₂)
    (CategoryTheory.Functor.chosenProd.snd F₁ F₂))

full_name: CategoryTheory.Functor.chosenFiniteProducts
code: noncomputable instance chosenFiniteProducts :
    ChosenFiniteProducts (J ⥤ C) 
goal: CategoryTheory.ChosenFiniteProducts (CategoryTheory.Functor J C)

full_name: CategoryTheory.Functor.Monoidal.leftUnitor_hom_app
code: @[simp]
lemma leftUnitor_hom_app (F : J ⥤ C) (j : J) :
    (λ_ F).hom.app j = (λ_ (F.obj j)).hom 
goal: (CategoryTheory.MonoidalCategory.leftUnitor F).hom.app j = (CategoryTheory.MonoidalCategory.leftUnitor (F.obj j)).hom

full_name: CategoryTheory.Functor.Monoidal.leftUnitor_inv_app
code: @[simp]
lemma leftUnitor_inv_app (F : J ⥤ C) (j : J) :
    (λ_ F).inv.app j = (λ_ (F.obj j)).inv 
goal: (CategoryTheory.MonoidalCategory.leftUnitor F).inv.app j = (CategoryTheory.MonoidalCategory.leftUnitor (F.obj j)).inv

full_name: CategoryTheory.Functor.Monoidal.rightUnitor_hom_app
code: @[simp]
lemma rightUnitor_hom_app (F : J ⥤ C) (j : J) :
    (ρ_ F).hom.app j = (ρ_ (F.obj j)).hom 
goal: (CategoryTheory.MonoidalCategory.rightUnitor F).hom.app j = (CategoryTheory.MonoidalCategory.rightUnitor (F.obj j)).hom

full_name: CategoryTheory.Functor.Monoidal.rightUnitor_inv_app
code: @[simp]
lemma rightUnitor_inv_app (F : J ⥤ C) (j : J) :
    (ρ_ F).inv.app j = (ρ_ (F.obj j)).inv 
goal: (CategoryTheory.MonoidalCategory.rightUnitor F).inv.app j = (CategoryTheory.MonoidalCategory.rightUnitor (F.obj j)).inv

full_name: CategoryTheory.Functor.Monoidal.tensorHom_app_fst
code: @[reassoc (attr := simp)]
lemma tensorHom_app_fst {F₁ F₁' F₂ F₂' : J ⥤ C} (f : F₁ ⟶ F₁') (g : F₂ ⟶ F₂') (j : J) :
    (f ⊗ g).app j ≫ fst _ _ = fst _ _ ≫ f.app j 
goal: CategoryTheory.CategoryStruct.comp ((CategoryTheory.MonoidalCategory.tensorHom f g).app j)
    (CategoryTheory.ChosenFiniteProducts.fst (F₁'.obj j) (F₂'.obj j)) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.ChosenFiniteProducts.fst (F₁.obj j) (F₂.obj j)) (f.app j)

full_name: CategoryTheory.Functor.Monoidal.tensorHom_app_snd
code: @[reassoc (attr := simp)]
lemma tensorHom_app_snd {F₁ F₁' F₂ F₂' : J ⥤ C} (f : F₁ ⟶ F₁') (g : F₂ ⟶ F₂') (j : J) :
    (f ⊗ g).app j ≫ snd _ _ = snd _ _ ≫ g.app j 
goal: CategoryTheory.CategoryStruct.comp ((CategoryTheory.MonoidalCategory.tensorHom f g).app j)
    (CategoryTheory.ChosenFiniteProducts.snd (F₁'.obj j) (F₂'.obj j)) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.ChosenFiniteProducts.snd (F₁.obj j) (F₂.obj j)) (g.app j)

full_name: CategoryTheory.Functor.Monoidal.whiskerLeft_app_fst
code: @[reassoc (attr := simp)]
lemma whiskerLeft_app_fst (F₁ : J ⥤ C) {F₂ F₂' : J ⥤ C} (g : F₂ ⟶ F₂') (j : J) :
    (F₁ ◁ g).app j ≫ fst _ _ = fst _ _ 
goal: CategoryTheory.CategoryStruct.comp ((CategoryTheory.MonoidalCategory.whiskerLeft F₁ g).app j)
    (CategoryTheory.ChosenFiniteProducts.fst (F₁.obj j) (F₂'.obj j)) =
  CategoryTheory.ChosenFiniteProducts.fst (F₁.obj j) (F₂.obj j)

full_name: CategoryTheory.Functor.Monoidal.whiskerLeft_app_snd
code: @[reassoc (attr := simp)]
lemma whiskerLeft_app_snd (F₁ : J ⥤ C) {F₂ F₂' : J ⥤ C} (g : F₂ ⟶ F₂') (j : J) :
    (F₁ ◁ g).app j ≫ snd _ _ = snd _ _ ≫ g.app j 
goal: CategoryTheory.CategoryStruct.comp ((CategoryTheory.MonoidalCategory.whiskerLeft F₁ g).app j)
    (CategoryTheory.ChosenFiniteProducts.snd (F₁.obj j) (F₂'.obj j)) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.ChosenFiniteProducts.snd (F₁.obj j) (F₂.obj j)) (g.app j)

full_name: CategoryTheory.Functor.Monoidal.whiskerRight_app_fst
code: @[reassoc (attr := simp)]
lemma whiskerRight_app_fst {F₁ F₁' : J ⥤ C} (f : F₁ ⟶ F₁') (F₂ : J ⥤ C) (j : J) :
    (f ▷ F₂).app j ≫ fst _ _ = fst _ _ ≫ f.app j 
goal: CategoryTheory.CategoryStruct.comp ((CategoryTheory.MonoidalCategory.whiskerRight f F₂).app j)
    (CategoryTheory.ChosenFiniteProducts.fst (F₁'.obj j) (F₂.obj j)) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.ChosenFiniteProducts.fst (F₁.obj j) (F₂.obj j)) (f.app j)

full_name: CategoryTheory.Functor.Monoidal.whiskerRight_app_snd
code: @[reassoc (attr := simp)]
lemma whiskerRight_app_snd {F₁ F₁' : J ⥤ C} (f : F₁ ⟶ F₁') (F₂ : J ⥤ C) (j : J) :
    (f ▷ F₂).app j ≫ snd _ _ = snd _ _ 
goal: CategoryTheory.CategoryStruct.comp ((CategoryTheory.MonoidalCategory.whiskerRight f F₂).app j)
    (CategoryTheory.ChosenFiniteProducts.snd (F₁'.obj j) (F₂.obj j)) =
  CategoryTheory.ChosenFiniteProducts.snd (F₁.obj j) (F₂.obj j)

full_name: CategoryTheory.Functor.Monoidal.associator_hom_app
code: @[simp]
lemma associator_hom_app (F₁ F₂ F₃ : J ⥤ C) (j : J) :
    (α_ F₁ F₂ F₃).hom.app j = (α_ _ _ _).hom 
goal: (CategoryTheory.MonoidalCategory.associator F₁ F₂ F₃).hom.app j =
  (CategoryTheory.MonoidalCategory.associator (F₁.obj j) (F₂.obj j) (F₃.obj j)).hom

full_name: CategoryTheory.Functor.Monoidal.associator_inv_app
code: @[simp]
lemma associator_inv_app (F₁ F₂ F₃ : J ⥤ C) (j : J) :
    (α_ F₁ F₂ F₃).inv.app j = (α_ _ _ _).inv 
goal: (CategoryTheory.MonoidalCategory.associator F₁ F₂ F₃).inv.app j =
  (CategoryTheory.MonoidalCategory.associator (F₁.obj j) (F₂.obj j) (F₃.obj j)).inv