File: Mathlib/CategoryTheory/Pi/Basic.lean

full_name: CategoryTheory.pi
code: /-- `pi C` gives the cartesian product of an indexed family of categories.
-/
instance pi : Category.{max w₀ v₁} (∀ i, C i) 
goal: CategoryTheory.Category.{max w₀ v₁, max u₁ w₀} ((i : I) → C i)

full_name: CategoryTheory.pi'
code: /-- This provides some assistance to typeclass search in a common situation,
which otherwise fails. (Without this `CategoryTheory.Pi.has_limit_of_has_limit_comp_eval` fails.)
-/
abbrev pi' {I : Type v₁} (C : I → Type u₁) [∀ i, Category.{v₁} (C i)] : Category.{v₁} (∀ i, C i) 
goal: CategoryTheory.Category.{v₁, max u₁ v₁} ((i : I) → C i)

full_name: CategoryTheory.Pi.id_apply
code: @[simp]
theorem id_apply (X : ∀ i, C i) (i) : (𝟙 X : ∀ i, X i ⟶ X i) i = 𝟙 (X i) 
goal: CategoryTheory.CategoryStruct.id X i = CategoryTheory.CategoryStruct.id (X i)

full_name: CategoryTheory.Pi.comp_apply
code: @[simp]
theorem comp_apply {X Y Z : ∀ i, C i} (f : X ⟶ Y) (g : Y ⟶ Z) (i) :
    (f ≫ g : ∀ i, X i ⟶ Z i) i = f i ≫ g i 
goal: CategoryTheory.CategoryStruct.comp f g i = CategoryTheory.CategoryStruct.comp (f i) (g i)

full_name: CategoryTheory.Pi.ext
code: @[ext]
lemma ext {X Y : ∀ i, C i} {f g : X ⟶ Y} (w : ∀ i, f i = g i) : f = g 
goal: f = g

full_name: CategoryTheory.Pi.eval
code: /--
The evaluation functor at `i : I`, sending an `I`-indexed family of objects to the object over `i`.
-/
@[simps]
def eval (i : I) : (∀ i, C i) ⥤ C i 
goal: CategoryTheory.Functor ((i : I) → C i) (C i)

full_name: CategoryTheory.Pi.eval_obj
code: /--
The evaluation functor at `i : I`, sending an `I`-indexed family of objects to the object over `i`.
-/
@[simps]
def eval (i : I) : (∀ i, C i) ⥤ C i 
goal: (CategoryTheory.Pi.eval C i).obj f = f i

full_name: CategoryTheory.Pi.eval_map
code: /--
The evaluation functor at `i : I`, sending an `I`-indexed family of objects to the object over `i`.
-/
@[simps]
def eval (i : I) : (∀ i, C i) ⥤ C i 
goal: ∀ {X Y : (i : I) → C i} (α : X ⟶ Y), (CategoryTheory.Pi.eval C i).map α = α i

full_name: CategoryTheory.Pi.instCategoryComp
code: instance (f : J → I) : (j : J) → Category ((C ∘ f) j) 
goal: CategoryTheory.Category.{v₁, u₁} ((C ∘ f) j)

full_name: CategoryTheory.Pi.comap_map
code: /-- Pull back an `I`-indexed family of objects to a `J`-indexed family, along a function `J → I`.
-/
@[simps]
def comap (h : J → I) : (∀ i, C i) ⥤ (∀ j, C (h j)) 
goal: ∀ {X Y : (i : I) → C i} (α : X ⟶ Y) (i : J), (CategoryTheory.Pi.comap C h).map α i = α (h i)

full_name: CategoryTheory.Pi.comap
code: /-- Pull back an `I`-indexed family of objects to a `J`-indexed family, along a function `J → I`.
-/
@[simps]
def comap (h : J → I) : (∀ i, C i) ⥤ (∀ j, C (h j)) 
goal: CategoryTheory.Functor ((i : I) → C i) ((j : J) → C (h j))

full_name: CategoryTheory.Pi.comap_obj
code: /-- Pull back an `I`-indexed family of objects to a `J`-indexed family, along a function `J → I`.
-/
@[simps]
def comap (h : J → I) : (∀ i, C i) ⥤ (∀ j, C (h j)) 
goal: (CategoryTheory.Pi.comap C h).obj f i = f (h i)

full_name: CategoryTheory.Pi.comapId_hom_app
code: /-- The natural isomorphism between
pulling back a grading along the identity function,
and the identity functor. -/
@[simps]
def comapId : comap C (id : I → I) ≅ 𝟭 (∀ i, C i) 
goal: (CategoryTheory.Pi.comapId I C).hom.app X i = CategoryTheory.CategoryStruct.id X i

full_name: CategoryTheory.Pi.comapId_inv_app
code: /-- The natural isomorphism between
pulling back a grading along the identity function,
and the identity functor. -/
@[simps]
def comapId : comap C (id : I → I) ≅ 𝟭 (∀ i, C i) 
goal: (CategoryTheory.Pi.comapId I C).inv.app X i = CategoryTheory.CategoryStruct.id X i

full_name: CategoryTheory.Pi.comapId
code: /-- The natural isomorphism between
pulling back a grading along the identity function,
and the identity functor. -/
@[simps]
def comapId : comap C (id : I → I) ≅ 𝟭 (∀ i, C i) 
goal: CategoryTheory.Pi.comap C id ≅ CategoryTheory.Functor.id ((i : I) → C i)

full_name: CategoryTheory.Pi.comapComp_inv_app
code: /-- The natural isomorphism comparing between
pulling back along two successive functions, and
pulling back along their composition
-/
@[simps!]
def comapComp (f : K → J) (g : J → I) : comap C g ⋙ comap (C ∘ g) f ≅ comap C (g ∘ f) 
goal: (CategoryTheory.Pi.comapComp C f g).inv.app X b = CategoryTheory.CategoryStruct.id (X (g (f b)))

full_name: CategoryTheory.Pi.comapComp_hom_app
code: /-- The natural isomorphism comparing between
pulling back along two successive functions, and
pulling back along their composition
-/
@[simps!]
def comapComp (f : K → J) (g : J → I) : comap C g ⋙ comap (C ∘ g) f ≅ comap C (g ∘ f) 
goal: (CategoryTheory.Pi.comapComp C f g).hom.app X b = CategoryTheory.CategoryStruct.id (X (g (f b)))

full_name: CategoryTheory.Pi.comapComp
code: /-- The natural isomorphism comparing between
pulling back along two successive functions, and
pulling back along their composition
-/
@[simps!]
def comapComp (f : K → J) (g : J → I) : comap C g ⋙ comap (C ∘ g) f ≅ comap C (g ∘ f) 
goal: (CategoryTheory.Pi.comap C g).comp (CategoryTheory.Pi.comap (C ∘ g) f) ≅ CategoryTheory.Pi.comap C (g ∘ f)

full_name: CategoryTheory.Pi.comapEvalIsoEval
code: /-- The natural isomorphism between pulling back then evaluating, and just evaluating. -/
@[simps!]
def comapEvalIsoEval (h : J → I) (j : J) : comap C h ⋙ eval (C ∘ h) j ≅ eval C (h j) 
goal: (CategoryTheory.Pi.comap C h).comp (CategoryTheory.Pi.eval (C ∘ h) j) ≅ CategoryTheory.Pi.eval C (h j)

full_name: CategoryTheory.Pi.comapEvalIsoEval_inv_app
code: /-- The natural isomorphism between pulling back then evaluating, and just evaluating. -/
@[simps!]
def comapEvalIsoEval (h : J → I) (j : J) : comap C h ⋙ eval (C ∘ h) j ≅ eval C (h j) 
goal: (CategoryTheory.Pi.comapEvalIsoEval C h j).inv.app X = CategoryTheory.CategoryStruct.id (X (h j))

full_name: CategoryTheory.Pi.comapEvalIsoEval_hom_app
code: /-- The natural isomorphism between pulling back then evaluating, and just evaluating. -/
@[simps!]
def comapEvalIsoEval (h : J → I) (j : J) : comap C h ⋙ eval (C ∘ h) j ≅ eval C (h j) 
goal: (CategoryTheory.Pi.comapEvalIsoEval C h j).hom.app X = CategoryTheory.CategoryStruct.id (X (h j))

full_name: CategoryTheory.Pi.sumElimCategory
code: instance sumElimCategory : ∀ s : I ⊕ J, Category.{v₁} (Sum.elim C D s)
  
goal: CategoryTheory.Category.{v₁, u₁} (Sum.elim C D s)

full_name: CategoryTheory.Pi.sum_obj_map
code: /-- The bifunctor combining an `I`-indexed family of objects with a `J`-indexed family of objects
to obtain an `I ⊕ J`-indexed family of objects.
-/
@[simps]
def sum : (∀ i, C i) ⥤ (∀ j, D j) ⥤ ∀ s : I ⊕ J, Sum.elim C D s 
goal: ((CategoryTheory.Pi.sum C).obj X).map f s =
  match s with
  | Sum.inl i => CategoryTheory.CategoryStruct.id (X i)
  | Sum.inr j => f j

full_name: CategoryTheory.Pi.sum_obj_obj
code: /-- The bifunctor combining an `I`-indexed family of objects with a `J`-indexed family of objects
to obtain an `I ⊕ J`-indexed family of objects.
-/
@[simps]
def sum : (∀ i, C i) ⥤ (∀ j, D j) ⥤ ∀ s : I ⊕ J, Sum.elim C D s 
goal: ((CategoryTheory.Pi.sum C).obj X).obj Y s =
  match s with
  | Sum.inl i => X i
  | Sum.inr j => Y j

full_name: CategoryTheory.Pi.sum
code: /-- The bifunctor combining an `I`-indexed family of objects with a `J`-indexed family of objects
to obtain an `I ⊕ J`-indexed family of objects.
-/
@[simps]
def sum : (∀ i, C i) ⥤ (∀ j, D j) ⥤ ∀ s : I ⊕ J, Sum.elim C D s 
goal: CategoryTheory.Functor ((i : I) → C i) (CategoryTheory.Functor ((j : J) → D j) ((s : I ⊕ J) → Sum.elim C D s))

full_name: CategoryTheory.Pi.sum_map_app
code: /-- The bifunctor combining an `I`-indexed family of objects with a `J`-indexed family of objects
to obtain an `I ⊕ J`-indexed family of objects.
-/
@[simps]
def sum : (∀ i, C i) ⥤ (∀ j, D j) ⥤ ∀ s : I ⊕ J, Sum.elim C D s 
goal: ((CategoryTheory.Pi.sum C).map f).app Y s =
  match s with
  | Sum.inl i => f i
  | Sum.inr j => CategoryTheory.CategoryStruct.id (Y j)

full_name: CategoryTheory.Pi.isoApp_inv
code: /-- An isomorphism between `I`-indexed objects gives an isomorphism between each
pair of corresponding components. -/
@[simps]
def isoApp {X Y : ∀ i, C i} (f : X ≅ Y) (i : I) : X i ≅ Y i 
goal: (CategoryTheory.Pi.isoApp f i).inv = f.inv i

full_name: CategoryTheory.Pi.isoApp_hom
code: /-- An isomorphism between `I`-indexed objects gives an isomorphism between each
pair of corresponding components. -/
@[simps]
def isoApp {X Y : ∀ i, C i} (f : X ≅ Y) (i : I) : X i ≅ Y i 
goal: (CategoryTheory.Pi.isoApp f i).hom = f.hom i

full_name: CategoryTheory.Pi.isoApp
code: /-- An isomorphism between `I`-indexed objects gives an isomorphism between each
pair of corresponding components. -/
@[simps]
def isoApp {X Y : ∀ i, C i} (f : X ≅ Y) (i : I) : X i ≅ Y i 
goal: X i ≅ Y i

full_name: CategoryTheory.Pi.isoApp_refl
code: @[simp]
theorem isoApp_refl (X : ∀ i, C i) (i : I) : isoApp (Iso.refl X) i = Iso.refl (X i) 
goal: CategoryTheory.Pi.isoApp (CategoryTheory.Iso.refl X) i = CategoryTheory.Iso.refl (X i)

full_name: CategoryTheory.Pi.isoApp_symm
code: @[simp]
theorem isoApp_symm {X Y : ∀ i, C i} (f : X ≅ Y) (i : I) : isoApp f.symm i = (isoApp f i).symm 
goal: CategoryTheory.Pi.isoApp f.symm i = (CategoryTheory.Pi.isoApp f i).symm

full_name: CategoryTheory.Pi.isoApp_trans
code: @[simp]
theorem isoApp_trans {X Y Z : ∀ i, C i} (f : X ≅ Y) (g : Y ≅ Z) (i : I) :
    isoApp (f ≪≫ g) i = isoApp f i ≪≫ isoApp g i 
goal: CategoryTheory.Pi.isoApp (f ≪≫ g) i = CategoryTheory.Pi.isoApp f i ≪≫ CategoryTheory.Pi.isoApp g i

full_name: CategoryTheory.Functor.pi_map
code: /-- Assemble an `I`-indexed family of functors into a functor between the pi types.
-/
@[simps]
def pi (F : ∀ i, C i ⥤ D i) : (∀ i, C i) ⥤ ∀ i, D i 
goal: ∀ {X Y : (i : I) → C i} (α : X ⟶ Y) (i : I), (CategoryTheory.Functor.pi F).map α i = (F i).map (α i)

full_name: CategoryTheory.Functor.pi
code: /-- Assemble an `I`-indexed family of functors into a functor between the pi types.
-/
@[simps]
def pi (F : ∀ i, C i ⥤ D i) : (∀ i, C i) ⥤ ∀ i, D i 
goal: CategoryTheory.Functor ((i : I) → C i) ((i : I) → D i)

full_name: CategoryTheory.Functor.pi_obj
code: /-- Assemble an `I`-indexed family of functors into a functor between the pi types.
-/
@[simps]
def pi (F : ∀ i, C i ⥤ D i) : (∀ i, C i) ⥤ ∀ i, D i 
goal: (CategoryTheory.Functor.pi F).obj f i = (F i).obj (f i)

full_name: CategoryTheory.Functor.pi'_obj
code: /-- Similar to `pi`, but all functors come from the same category `A`
-/
@[simps]
def pi' (f : ∀ i, A ⥤ C i) : A ⥤ ∀ i, C i 
goal: (CategoryTheory.Functor.pi' f).obj a i = (f i).obj a

full_name: CategoryTheory.Functor.pi'
code: /-- Similar to `pi`, but all functors come from the same category `A`
-/
@[simps]
def pi' (f : ∀ i, A ⥤ C i) : A ⥤ ∀ i, C i 
goal: CategoryTheory.Functor A ((i : I) → C i)

full_name: CategoryTheory.Functor.pi'_map
code: /-- Similar to `pi`, but all functors come from the same category `A`
-/
@[simps]
def pi' (f : ∀ i, A ⥤ C i) : A ⥤ ∀ i, C i 
goal: ∀ {X Y : A} (h : X ⟶ Y) (i : I), (CategoryTheory.Functor.pi' f).map h i = (f i).map h

full_name: CategoryTheory.Functor.pi'CompEval_hom_app
code: /-- The projections of `Functor.pi' F` are isomorphic to the functors of the family `F` -/
@[simps!]
def pi'CompEval {A : Type*} [Category A] (F : ∀ i, A ⥤ C i) (i : I) :
    pi' F ⋙ Pi.eval C i ≅ F i 
goal: (CategoryTheory.Functor.pi'CompEval F i).hom.app X = CategoryTheory.CategoryStruct.id ((F i).obj X)

full_name: CategoryTheory.Functor.pi'CompEval_inv_app
code: /-- The projections of `Functor.pi' F` are isomorphic to the functors of the family `F` -/
@[simps!]
def pi'CompEval {A : Type*} [Category A] (F : ∀ i, A ⥤ C i) (i : I) :
    pi' F ⋙ Pi.eval C i ≅ F i 
goal: (CategoryTheory.Functor.pi'CompEval F i).inv.app X = CategoryTheory.CategoryStruct.id ((F i).obj X)

full_name: CategoryTheory.Functor.pi'CompEval
code: /-- The projections of `Functor.pi' F` are isomorphic to the functors of the family `F` -/
@[simps!]
def pi'CompEval {A : Type*} [Category A] (F : ∀ i, A ⥤ C i) (i : I) :
    pi' F ⋙ Pi.eval C i ≅ F i 
goal: (CategoryTheory.Functor.pi' F).comp (CategoryTheory.Pi.eval C i) ≅ F i

full_name: CategoryTheory.Functor.eqToHom_proj
code: @[simp]
theorem eqToHom_proj {x x' : ∀ i, C i} (h : x = x') (i : I) :
    (eqToHom h : x ⟶ x') i = eqToHom (Function.funext_iff.mp h i) 
goal: CategoryTheory.eqToHom h i = CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.Functor.pi'_eval
code: @[simp]
theorem pi'_eval (f : ∀ i, A ⥤ C i) (i : I) : pi' f ⋙ Pi.eval C i = f i 
goal: (CategoryTheory.Functor.pi' f).comp (CategoryTheory.Pi.eval C i) = f i

full_name: CategoryTheory.Functor.pi_ext
code: /-- Two functors to a product category are equal iff they agree on every coordinate. -/
theorem pi_ext (f f' : A ⥤ ∀ i, C i) (h : ∀ i, f ⋙ (Pi.eval C i) = f' ⋙ (Pi.eval C i)) :
    f = f' 
goal: f = f'

full_name: CategoryTheory.NatTrans.pi
code: /-- Assemble an `I`-indexed family of natural transformations into a single natural transformation.
-/
@[simps!]
def pi (α : ∀ i, F i ⟶ G i) : Functor.pi F ⟶ Functor.pi G 
goal: CategoryTheory.Functor.pi F ⟶ CategoryTheory.Functor.pi G

full_name: CategoryTheory.NatTrans.pi_app
code: /-- Assemble an `I`-indexed family of natural transformations into a single natural transformation.
-/
@[simps!]
def pi (α : ∀ i, F i ⟶ G i) : Functor.pi F ⟶ Functor.pi G 
goal: (CategoryTheory.NatTrans.pi α).app f i = (α i).app (f i)

full_name: CategoryTheory.NatTrans.pi'_app
code: /-- Assemble an `I`-indexed family of natural transformations into a single natural transformation.
-/
@[simps]
def pi' {E : Type*} [Category E] {F G : E ⥤ ∀ i, C i}
    (τ : ∀ i, F ⋙ Pi.eval C i ⟶ G ⋙ Pi.eval C i) : F ⟶ G 
goal: (CategoryTheory.NatTrans.pi' τ).app X i = (τ i).app X

full_name: CategoryTheory.NatTrans.pi'
code: /-- Assemble an `I`-indexed family of natural transformations into a single natural transformation.
-/
@[simps]
def pi' {E : Type*} [Category E] {F G : E ⥤ ∀ i, C i}
    (τ : ∀ i, F ⋙ Pi.eval C i ⟶ G ⋙ Pi.eval C i) : F ⟶ G 
goal: F ⟶ G

full_name: CategoryTheory.NatIso.pi_hom
code: /-- Assemble an `I`-indexed family of natural isomorphisms into a single natural isomorphism.
-/
@[simps]
def pi (e : ∀ i, F i ≅ G i) : Functor.pi F ≅ Functor.pi G 
goal: (CategoryTheory.NatIso.pi e).hom = CategoryTheory.NatTrans.pi fun i => (e i).hom

full_name: CategoryTheory.NatIso.pi
code: /-- Assemble an `I`-indexed family of natural isomorphisms into a single natural isomorphism.
-/
@[simps]
def pi (e : ∀ i, F i ≅ G i) : Functor.pi F ≅ Functor.pi G 
goal: CategoryTheory.Functor.pi F ≅ CategoryTheory.Functor.pi G

full_name: CategoryTheory.NatIso.pi_inv
code: /-- Assemble an `I`-indexed family of natural isomorphisms into a single natural isomorphism.
-/
@[simps]
def pi (e : ∀ i, F i ≅ G i) : Functor.pi F ≅ Functor.pi G 
goal: (CategoryTheory.NatIso.pi e).inv = CategoryTheory.NatTrans.pi fun i => (e i).inv

full_name: CategoryTheory.NatIso.pi'_hom
code: /-- Assemble an `I`-indexed family of natural isomorphisms into a single natural isomorphism.
-/
@[simps]
def pi' {E : Type*} [Category E] {F G : E ⥤ ∀ i, C i}
    (e : ∀ i, F ⋙ Pi.eval C i ≅ G ⋙ Pi.eval C i) : F ≅ G 
goal: (CategoryTheory.NatIso.pi' e).hom = CategoryTheory.NatTrans.pi' fun i => (e i).hom

full_name: CategoryTheory.NatIso.pi'_inv
code: /-- Assemble an `I`-indexed family of natural isomorphisms into a single natural isomorphism.
-/
@[simps]
def pi' {E : Type*} [Category E] {F G : E ⥤ ∀ i, C i}
    (e : ∀ i, F ⋙ Pi.eval C i ≅ G ⋙ Pi.eval C i) : F ≅ G 
goal: (CategoryTheory.NatIso.pi' e).inv = CategoryTheory.NatTrans.pi' fun i => (e i).inv

full_name: CategoryTheory.NatIso.pi'
code: /-- Assemble an `I`-indexed family of natural isomorphisms into a single natural isomorphism.
-/
@[simps]
def pi' {E : Type*} [Category E] {F G : E ⥤ ∀ i, C i}
    (e : ∀ i, F ⋙ Pi.eval C i ≅ G ⋙ Pi.eval C i) : F ≅ G 
goal: F ≅ G

full_name: CategoryTheory.isIso_pi_iff
code: lemma isIso_pi_iff {X Y : ∀ i, C i} (f : X ⟶ Y) :
    IsIso f ↔ ∀ i, IsIso (f i) 
goal: CategoryTheory.IsIso f ↔ ∀ (i : I), CategoryTheory.IsIso (f i)

full_name: CategoryTheory.Pi.eqToEquivalence
code: /-- For a family of categories `C i` indexed by `I`, an equality `i = j` in `I` induces
an equivalence `C i ≌ C j`. -/
def Pi.eqToEquivalence {i j : I} (h : i = j) : C i ≌ C j 
goal: C i ≌ C j

full_name: CategoryTheory.Pi.evalCompEqToEquivalenceFunctor_inv
code: /-- When `i = j`, projections `Pi.eval C i` and `Pi.eval C j` are related by the equivalence
`Pi.eqToEquivalence C h : C i ≌ C j`. -/
@[simps!]
def Pi.evalCompEqToEquivalenceFunctor {i j : I} (h : i = j) :
    Pi.eval C i ⋙ (Pi.eqToEquivalence C h).functor ≅
      Pi.eval C j 
goal: (CategoryTheory.Pi.evalCompEqToEquivalenceFunctor C h).inv = CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.Pi.evalCompEqToEquivalenceFunctor
code: /-- When `i = j`, projections `Pi.eval C i` and `Pi.eval C j` are related by the equivalence
`Pi.eqToEquivalence C h : C i ≌ C j`. -/
@[simps!]
def Pi.evalCompEqToEquivalenceFunctor {i j : I} (h : i = j) :
    Pi.eval C i ⋙ (Pi.eqToEquivalence C h).functor ≅
      Pi.eval C j 
goal: (CategoryTheory.Pi.eval C i).comp (CategoryTheory.Pi.eqToEquivalence C h).functor ≅ CategoryTheory.Pi.eval C j

full_name: CategoryTheory.Pi.evalCompEqToEquivalenceFunctor_hom
code: /-- When `i = j`, projections `Pi.eval C i` and `Pi.eval C j` are related by the equivalence
`Pi.eqToEquivalence C h : C i ≌ C j`. -/
@[simps!]
def Pi.evalCompEqToEquivalenceFunctor {i j : I} (h : i = j) :
    Pi.eval C i ⋙ (Pi.eqToEquivalence C h).functor ≅
      Pi.eval C j 
goal: (CategoryTheory.Pi.evalCompEqToEquivalenceFunctor C h).hom = CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.Pi.eqToEquivalenceFunctorIso_inv
code: /-- The equivalences given by `Pi.eqToEquivalence` are compatible with reindexing. -/
@[simps!]
def Pi.eqToEquivalenceFunctorIso (f : J → I) {i' j' : J} (h : i' = j') :
    (Pi.eqToEquivalence C (congr_arg f h)).functor ≅
      (Pi.eqToEquivalence (fun i' => C (f i')) h).functor 
goal: (CategoryTheory.Pi.eqToEquivalenceFunctorIso C f h).inv = CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.Pi.eqToEquivalenceFunctorIso
code: /-- The equivalences given by `Pi.eqToEquivalence` are compatible with reindexing. -/
@[simps!]
def Pi.eqToEquivalenceFunctorIso (f : J → I) {i' j' : J} (h : i' = j') :
    (Pi.eqToEquivalence C (congr_arg f h)).functor ≅
      (Pi.eqToEquivalence (fun i' => C (f i')) h).functor 
goal: (CategoryTheory.Pi.eqToEquivalence C ⋯).functor ≅ (CategoryTheory.Pi.eqToEquivalence (fun i' => C (f i')) h).functor

full_name: CategoryTheory.Pi.eqToEquivalenceFunctorIso_hom
code: /-- The equivalences given by `Pi.eqToEquivalence` are compatible with reindexing. -/
@[simps!]
def Pi.eqToEquivalenceFunctorIso (f : J → I) {i' j' : J} (h : i' = j') :
    (Pi.eqToEquivalence C (congr_arg f h)).functor ≅
      (Pi.eqToEquivalence (fun i' => C (f i')) h).functor 
goal: (CategoryTheory.Pi.eqToEquivalenceFunctorIso C f h).hom = CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.Pi.equivalenceOfEquiv_counitIso
code: /-- Reindexing a family of categories gives equivalent `Pi` categories. -/
@[simps]
noncomputable def Pi.equivalenceOfEquiv (e : J ≃ I) :
    (∀ j, C (e j)) ≌ (∀ i, C i) 
goal: (CategoryTheory.Pi.equivalenceOfEquiv C e).counitIso =
  CategoryTheory.NatIso.pi' fun i =>
    ((CategoryTheory.Functor.pi' fun i' => CategoryTheory.Pi.eval C (e i')).associator
          (CategoryTheory.Pi.eval (fun j => C (e j)) (e.symm i))
          (CategoryTheory.Pi.eqToEquivalence C ⋯).functor).symm ≪≫
      CategoryTheory.isoWhiskerRight
          (CategoryTheory.Functor.pi'CompEval (fun i' => CategoryTheory.Pi.eval C (e i')) (e.symm i))
          (CategoryTheory.Pi.eqToEquivalence C ⋯).functor ≪≫
        CategoryTheory.Pi.evalCompEqToEquivalenceFunctor C ⋯ ≪≫ (CategoryTheory.Pi.eval C i).leftUnitor.symm

full_name: CategoryTheory.Pi.equivalenceOfEquiv_inverse
code: /-- Reindexing a family of categories gives equivalent `Pi` categories. -/
@[simps]
noncomputable def Pi.equivalenceOfEquiv (e : J ≃ I) :
    (∀ j, C (e j)) ≌ (∀ i, C i) 
goal: (CategoryTheory.Pi.equivalenceOfEquiv C e).inverse =
  CategoryTheory.Functor.pi' fun i' => CategoryTheory.Pi.eval C (e i')

full_name: CategoryTheory.Pi.equivalenceOfEquiv
code: /-- Reindexing a family of categories gives equivalent `Pi` categories. -/
@[simps]
noncomputable def Pi.equivalenceOfEquiv (e : J ≃ I) :
    (∀ j, C (e j)) ≌ (∀ i, C i) 
goal: ((j : J) → C (e j)) ≌ (i : I) → C i

full_name: CategoryTheory.Pi.equivalenceOfEquiv_functor
code: /-- Reindexing a family of categories gives equivalent `Pi` categories. -/
@[simps]
noncomputable def Pi.equivalenceOfEquiv (e : J ≃ I) :
    (∀ j, C (e j)) ≌ (∀ i, C i) 
goal: (CategoryTheory.Pi.equivalenceOfEquiv C e).functor =
  CategoryTheory.Functor.pi' fun i =>
    (CategoryTheory.Pi.eval (fun j => C (e j)) (e.symm i)).comp (CategoryTheory.Pi.eqToEquivalence C ⋯).functor

full_name: CategoryTheory.Pi.equivalenceOfEquiv_unitIso
code: /-- Reindexing a family of categories gives equivalent `Pi` categories. -/
@[simps]
noncomputable def Pi.equivalenceOfEquiv (e : J ≃ I) :
    (∀ j, C (e j)) ≌ (∀ i, C i) 
goal: (CategoryTheory.Pi.equivalenceOfEquiv C e).unitIso =
  CategoryTheory.NatIso.pi' fun i' =>
    (CategoryTheory.Pi.eval (fun i => C (e i)) i').leftUnitor ≪≫
      (CategoryTheory.Pi.evalCompEqToEquivalenceFunctor (fun j => C (e j)) ⋯).symm ≪≫
        CategoryTheory.isoWhiskerLeft (CategoryTheory.Pi.eval (fun j => C (e j)) (e.symm (e i')))
            (CategoryTheory.Pi.eqToEquivalenceFunctorIso C ⇑e ⋯).symm ≪≫
          (CategoryTheory.Functor.pi'CompEval (CategoryTheory.Pi.eval (fun j => C (e j)) (e.symm (e i'))).comp
                (CategoryTheory.Pi.eqToEquivalence C ⋯).functor).symm ≪≫
            CategoryTheory.isoWhiskerLeft
                (CategoryTheory.Functor.pi' (CategoryTheory.Pi.eval (fun j => C (e j)) (e.symm (e i'))).comp)
                (CategoryTheory.Functor.pi'CompEval (CategoryTheory.Pi.eval fun i => C (e i'))
                    (CategoryTheory.Pi.eqToEquivalence C ⋯).functor).symm ≪≫
              ((CategoryTheory.Functor.pi' (CategoryTheory.Pi.eval (fun j => C (e j)) (e.symm (e i'))).comp).associator
                  (CategoryTheory.Functor.pi' (CategoryTheory.Pi.eval fun i => C (e i')))
                  (CategoryTheory.Pi.eval (fun i => C (e i')) (CategoryTheory.Pi.eqToEquivalence C ⋯).functor)).symm

full_name: CategoryTheory.Pi.optionEquivalence
code: /-- A product of categories indexed by `Option J` identifies to a binary product. -/
@[simps]
def Pi.optionEquivalence (C' : Option J → Type u₁) [∀ i, Category.{v₁} (C' i)] :
    (∀ i, C' i) ≌ C' none × (∀ (j : J), C' (some j)) 
goal: ((i : Option J) → C' i) ≌ C' none × ((j : J) → C' (some j))

full_name: CategoryTheory.Pi.optionEquivalence_unitIso
code: /-- A product of categories indexed by `Option J` identifies to a binary product. -/
@[simps]
def Pi.optionEquivalence (C' : Option J → Type u₁) [∀ i, Category.{v₁} (C' i)] :
    (∀ i, C' i) ≌ C' none × (∀ (j : J), C' (some j)) 
goal: (CategoryTheory.Pi.optionEquivalence C').unitIso =
  CategoryTheory.NatIso.pi' fun i =>
    match i with
    | none =>
      CategoryTheory.Iso.refl
        ((CategoryTheory.Functor.id ((i : Option J) → C' i)).comp (CategoryTheory.Pi.eval C' none))
    | some i =>
      CategoryTheory.Iso.refl
        ((CategoryTheory.Functor.id ((i : Option J) → C' i)).comp (CategoryTheory.Pi.eval C' (some i)))

full_name: CategoryTheory.Pi.optionEquivalence_functor
code: /-- A product of categories indexed by `Option J` identifies to a binary product. -/
@[simps]
def Pi.optionEquivalence (C' : Option J → Type u₁) [∀ i, Category.{v₁} (C' i)] :
    (∀ i, C' i) ≌ C' none × (∀ (j : J), C' (some j)) 
goal: (CategoryTheory.Pi.optionEquivalence C').functor =
  (CategoryTheory.Pi.eval C' none).prod' (CategoryTheory.Functor.pi' fun i => CategoryTheory.Pi.eval C' (some i))

full_name: CategoryTheory.Pi.optionEquivalence_counitIso
code: /-- A product of categories indexed by `Option J` identifies to a binary product. -/
@[simps]
def Pi.optionEquivalence (C' : Option J → Type u₁) [∀ i, Category.{v₁} (C' i)] :
    (∀ i, C' i) ≌ C' none × (∀ (j : J), C' (some j)) 
goal: (CategoryTheory.Pi.optionEquivalence C').counitIso =
  CategoryTheory.Iso.refl
    ((CategoryTheory.Functor.pi' fun i =>
          match i with
          | none => CategoryTheory.Prod.fst (C' none) ((j : J) → C' (some j))
          | some i =>
            (CategoryTheory.Prod.snd (C' none) ((j : J) → C' (some j))).comp
              (CategoryTheory.Pi.eval (fun j => C' (some j)) i)).comp
      ((CategoryTheory.Pi.eval C' none).prod' (CategoryTheory.Functor.pi' fun i => CategoryTheory.Pi.eval C' (some i))))

full_name: CategoryTheory.Pi.optionEquivalence_inverse
code: /-- A product of categories indexed by `Option J` identifies to a binary product. -/
@[simps]
def Pi.optionEquivalence (C' : Option J → Type u₁) [∀ i, Category.{v₁} (C' i)] :
    (∀ i, C' i) ≌ C' none × (∀ (j : J), C' (some j)) 
goal: (CategoryTheory.Pi.optionEquivalence C').inverse =
  CategoryTheory.Functor.pi' fun i =>
    match i with
    | none => CategoryTheory.Prod.fst (C' none) ((j : J) → C' (some j))
    | some i =>
      (CategoryTheory.Prod.snd (C' none) ((j : J) → C' (some j))).comp (CategoryTheory.Pi.eval (fun j => C' (some j)) i)

full_name: CategoryTheory.Equivalence.pi_counitIso
code: /-- Assemble an `I`-indexed family of equivalences of categories
into a single equivalence. -/
@[simps]
def pi (E : ∀ i, C i ≌ D i) : (∀ i, C i) ≌ (∀ i, D i) 
goal: (CategoryTheory.Equivalence.pi E).counitIso = CategoryTheory.NatIso.pi fun i => (E i).counitIso

full_name: CategoryTheory.Equivalence.pi_functor
code: /-- Assemble an `I`-indexed family of equivalences of categories
into a single equivalence. -/
@[simps]
def pi (E : ∀ i, C i ≌ D i) : (∀ i, C i) ≌ (∀ i, D i) 
goal: (CategoryTheory.Equivalence.pi E).functor = CategoryTheory.Functor.pi fun i => (E i).functor

full_name: CategoryTheory.Equivalence.pi_unitIso
code: /-- Assemble an `I`-indexed family of equivalences of categories
into a single equivalence. -/
@[simps]
def pi (E : ∀ i, C i ≌ D i) : (∀ i, C i) ≌ (∀ i, D i) 
goal: (CategoryTheory.Equivalence.pi E).unitIso = CategoryTheory.NatIso.pi fun i => (E i).unitIso

full_name: CategoryTheory.Equivalence.pi_inverse
code: /-- Assemble an `I`-indexed family of equivalences of categories
into a single equivalence. -/
@[simps]
def pi (E : ∀ i, C i ≌ D i) : (∀ i, C i) ≌ (∀ i, D i) 
goal: (CategoryTheory.Equivalence.pi E).inverse = CategoryTheory.Functor.pi fun i => (E i).inverse

full_name: CategoryTheory.Equivalence.pi
code: /-- Assemble an `I`-indexed family of equivalences of categories
into a single equivalence. -/
@[simps]
def pi (E : ∀ i, C i ≌ D i) : (∀ i, C i) ≌ (∀ i, D i) 
goal: ((i : I) → C i) ≌ (i : I) → D i

full_name: CategoryTheory.Equivalence.instIsEquivalenceForallPi
code: instance (F : ∀ i, C i ⥤ D i) [∀ i, (F i).IsEquivalence] :
    (Functor.pi F).IsEquivalence 
goal: (CategoryTheory.Functor.pi F).IsEquivalence