File: Mathlib/CategoryTheory/EffectiveEpi/Comp.lean

full_name: CategoryTheory.effectiveEpiFamilyStructCompOfEffectiveEpiSplitEpi'
code: /--
An effective epi family precomposed by a family of split epis is effective epimorphic.
This version takes an explicit section to the split epis, and is mainly used to define
`effectiveEpiStructCompOfEffectiveEpiSplitEpi`,
which takes a `IsSplitEpi` instance instead.
-/
noncomputable
def effectiveEpiFamilyStructCompOfEffectiveEpiSplitEpi' {α : Type*} {B : C} {X Y : α → C}
    (f : (a : α) → X a ⟶ B) (g : (a : α) → Y a ⟶ X a) (i : (a : α) → X a ⟶ Y a)
    (hi : ∀ a, i a ≫ g a = 𝟙 _) [EffectiveEpiFamily _ f] :
    EffectiveEpiFamilyStruct _ (fun a ↦ g a ≫ f a) 
goal: CategoryTheory.EffectiveEpiFamilyStruct Y fun a => CategoryTheory.CategoryStruct.comp (g a) (f a)

full_name: CategoryTheory.effectiveEpiFamilyStructCompOfEffectiveEpiSplitEpi
code: /--
An effective epi family precomposed with a family of split epis is effective epimorphic.
-/
noncomputable
def effectiveEpiFamilyStructCompOfEffectiveEpiSplitEpi {α : Type*} {B : C} {X Y : α → C}
    (f : (a : α) → X a ⟶ B) (g : (a : α) → Y a ⟶ X a) [∀ a, IsSplitEpi (g a)]
    [EffectiveEpiFamily _ f] : EffectiveEpiFamilyStruct _ (fun a ↦ g a ≫ f a) 
goal: CategoryTheory.EffectiveEpiFamilyStruct Y fun a => CategoryTheory.CategoryStruct.comp (g a) (f a)

full_name: CategoryTheory.instEffectiveEpiFamilyCompOfIsSplitEpi
code: instance {α : Type*} {B : C} {X Y : α → C}
    (f : (a : α) → X a ⟶ B) (g : (a : α) → Y a ⟶ X a) [∀ a, IsSplitEpi (g a)]
    [EffectiveEpiFamily _ f] : EffectiveEpiFamily _ (fun a ↦ g a ≫ f a) 
goal: CategoryTheory.EffectiveEpiFamily Y fun a => CategoryTheory.CategoryStruct.comp (g a) (f a)

full_name: CategoryTheory.IsSplitEpi.EffectiveEpi
code: instance IsSplitEpi.EffectiveEpi {B X : C} (f : X ⟶ B) [IsSplitEpi f] : EffectiveEpi f 
goal: CategoryTheory.EffectiveEpi f

full_name: CategoryTheory.effectiveEpiFamilyStructOfComp
code: /--
If a family of morphisms with fixed target, precomposed by a family of epis is
effective epimorphic, then the original family is as well.
-/
noncomputable def effectiveEpiFamilyStructOfComp {C : Type*} [Category C]
    {I : Type*} {Z Y : I → C} {X : C} (g : ∀ i, Z i ⟶ Y i) (f : ∀ i, Y i ⟶ X)
    [EffectiveEpiFamily _ (fun i => g i ≫ f i)] [∀ i, Epi (g i)] :
    EffectiveEpiFamilyStruct _ f 
goal: CategoryTheory.EffectiveEpiFamilyStruct Y f

full_name: CategoryTheory.effectiveEpiFamily_of_effectiveEpi_epi_comp
code: lemma effectiveEpiFamily_of_effectiveEpi_epi_comp {α : Type*} {B : C} {X Y : α → C}
    (f : (a : α) → X a ⟶ B) (g : (a : α) → Y a ⟶ X a) [∀ a, Epi (g a)]
    [EffectiveEpiFamily _ (fun a ↦ g a ≫ f a)] : EffectiveEpiFamily _ f 
goal: CategoryTheory.EffectiveEpiFamily X f

full_name: CategoryTheory.effectiveEpi_of_effectiveEpi_epi_comp
code: lemma effectiveEpi_of_effectiveEpi_epi_comp {B X Y : C} (f : X ⟶ B) (g : Y ⟶ X)
    [Epi g] [EffectiveEpi (g ≫ f)] : EffectiveEpi f 
goal: CategoryTheory.EffectiveEpi f

full_name: CategoryTheory.effectiveEpiFamilyStructCompIso_aux
code: theorem effectiveEpiFamilyStructCompIso_aux
    {W : C} (e : (a : α) → X a ⟶ W)
    (h : ∀ {Z : C} (a₁ a₂ : α) (g₁ : Z ⟶ X a₁) (g₂ : Z ⟶ X a₂),
      g₁ ≫ π a₁ ≫ i = g₂ ≫ π a₂ ≫ i → g₁ ≫ e a₁ = g₂ ≫ e a₂)
    {Z : C} (a₁ a₂ : α) (g₁ : Z ⟶ X a₁) (g₂ : Z ⟶ X a₂) (hg : g₁ ≫ π a₁ = g₂ ≫ π a₂) :
    g₁ ≫ e a₁ = g₂ ≫ e a₂ 
goal: CategoryTheory.CategoryStruct.comp g₁ (e a₁) = CategoryTheory.CategoryStruct.comp g₂ (e a₂)

full_name: CategoryTheory.effectiveEpiFamilyStructCompIso
code: /-- An effective epi family followed by an iso is an effective epi family. -/
noncomputable
def effectiveEpiFamilyStructCompIso : EffectiveEpiFamilyStruct X (fun a ↦ π a ≫ i) 
goal: CategoryTheory.EffectiveEpiFamilyStruct X fun a => CategoryTheory.CategoryStruct.comp (π a) i

full_name: CategoryTheory.instEffectiveEpiFamilyComp
code: instance : EffectiveEpiFamily X (fun a ↦ π a ≫ i) 
goal: CategoryTheory.EffectiveEpiFamily X fun a => CategoryTheory.CategoryStruct.comp (π a) i