File: Mathlib/CategoryTheory/EffectiveEpi/Preserves.lean

full_name: CategoryTheory.effectiveEpiFamilyStructOfEquivalence_aux
code: theorem effectiveEpiFamilyStructOfEquivalence_aux {W : D} (ε : (a : α) → e.functor.obj (X a) ⟶ W)
    (h : ∀ {Z : D} (a₁ a₂ : α) (g₁ : Z ⟶ e.functor.obj (X a₁)) (g₂ : Z ⟶ e.functor.obj (X a₂)),
      g₁ ≫ e.functor.map (π a₁) = g₂ ≫ e.functor.map (π a₂) → g₁ ≫ ε a₁ = g₂ ≫ ε a₂)
    {Z : C} (a₁ a₂ : α) (g₁ : Z ⟶ X a₁) (g₂ : Z ⟶ X a₂) (hg : g₁ ≫ π a₁ = g₂ ≫ π a₂) :
    g₁ ≫ (fun a ↦ e.unit.app (X a) ≫ e.inverse.map (ε a)) a₁ =
    g₂ ≫ (fun a ↦ e.unit.app (X a) ≫ e.inverse.map (ε a)) a₂ 
goal: CategoryTheory.CategoryStruct.comp g₁
    ((fun a => CategoryTheory.CategoryStruct.comp (e.unit.app (X a)) (e.inverse.map (ε a))) a₁) =
  CategoryTheory.CategoryStruct.comp g₂
    ((fun a => CategoryTheory.CategoryStruct.comp (e.unit.app (X a)) (e.inverse.map (ε a))) a₂)

full_name: CategoryTheory.effectiveEpiFamilyStructOfEquivalence
code: /-- Equivalences preserve effective epimorphic families -/
def effectiveEpiFamilyStructOfEquivalence : EffectiveEpiFamilyStruct (fun a ↦ e.functor.obj (X a))
    (fun a ↦ e.functor.map (π a)) 
goal: CategoryTheory.EffectiveEpiFamilyStruct (fun a => e.functor.obj (X a)) fun a => e.functor.map (π a)

full_name: CategoryTheory.instEffectiveEpiFamilyObjMapOfIsEquivalence
code: instance (F : C ⥤ D) [F.IsEquivalence] :
    EffectiveEpiFamily (fun a ↦ F.obj (X a)) (fun a ↦ F.map (π a)) 
goal: CategoryTheory.EffectiveEpiFamily (fun a => F.obj (X a)) fun a => F.map (π a)

full_name: CategoryTheory.Functor.PreservesEffectiveEpis.preserves
code: /--
A class describing the property of preserving effective epimorphisms.
-/
class PreservesEffectiveEpis (F : C ⥤ D) : Prop where
  /--
  A functor preserves effective epimorphisms if it maps effective
  epimorphisms to effective epimorphisms.
  -/
  preserves : ∀ {X Y : C} (f : X ⟶ Y) [EffectiveEpi f], EffectiveEpi (F.map f)
goal: CategoryTheory.EffectiveEpi (F.map f)

full_name: CategoryTheory.Functor.PreservesEffectiveEpis
code: /--
A class describing the property of preserving effective epimorphisms.
-/
class PreservesEffectiveEpis (F : C ⥤ D) : Prop where
  /--
  A functor preserves effective epimorphisms if it maps effective
  epimorphisms to effective epimorphisms.
  -/
  preserves : ∀ {X Y : C} (f : X ⟶ Y) [EffectiveEpi f], EffectiveEpi (F.map f)
goal: Prop

full_name: CategoryTheory.Functor.map_effectiveEpi
code: instance map_effectiveEpi (F : C ⥤ D) [F.PreservesEffectiveEpis] {X Y : C} (f : X ⟶ Y)
    [EffectiveEpi f] : EffectiveEpi (F.map f) 
goal: CategoryTheory.EffectiveEpi (F.map f)

full_name: CategoryTheory.Functor.PreservesEffectiveEpiFamilies
code: /--
A class describing the property of preserving effective epimorphic families.
-/
class PreservesEffectiveEpiFamilies (F : C ⥤ D) : Prop where
  /--
  A functor preserves effective epimorphic families if it maps effective epimorphic families to
  effective epimorphic families.
  -/
  preserves : ∀ {α : Type u} {B : C} (X : α → C) (π : (a : α) → (X a ⟶ B)) [EffectiveEpiFamily X π],
    EffectiveEpiFamily (fun a ↦ F.obj (X a)) (fun a  ↦ F.map (π a))
goal: Prop

full_name: CategoryTheory.Functor.PreservesEffectiveEpiFamilies.preserves
code: /--
A class describing the property of preserving effective epimorphic families.
-/
class PreservesEffectiveEpiFamilies (F : C ⥤ D) : Prop where
  /--
  A functor preserves effective epimorphic families if it maps effective epimorphic families to
  effective epimorphic families.
  -/
  preserves : ∀ {α : Type u} {B : C} (X : α → C) (π : (a : α) → (X a ⟶ B)) [EffectiveEpiFamily X π],
    EffectiveEpiFamily (fun a ↦ F.obj (X a)) (fun a  ↦ F.map (π a))
goal: CategoryTheory.EffectiveEpiFamily (fun a => F.obj (X a)) fun a => F.map (π a)

full_name: CategoryTheory.Functor.map_effectiveEpiFamily
code: instance map_effectiveEpiFamily (F : C ⥤ D) [PreservesEffectiveEpiFamilies.{u} F]
    {α : Type u} {B : C} (X : α → C) (π : (a : α) → (X a ⟶ B)) [EffectiveEpiFamily X π] :
    EffectiveEpiFamily (fun a ↦ F.obj (X a)) (fun a  ↦ F.map (π a)) 
goal: CategoryTheory.EffectiveEpiFamily (fun a => F.obj (X a)) fun a => F.map (π a)

full_name: CategoryTheory.Functor.PreservesFiniteEffectiveEpiFamilies.preserves
code: /--
A class describing the property of preserving finite effective epimorphic families.
-/
class PreservesFiniteEffectiveEpiFamilies (F : C ⥤ D) : Prop where
  /--
  A functor preserves finite effective epimorphic families if it maps finite effective epimorphic
  families to effective epimorphic families.
  -/
  preserves : ∀ {α : Type} [Finite α] {B : C} (X : α → C) (π : (a : α) → (X a ⟶ B))
    [EffectiveEpiFamily X π],
    EffectiveEpiFamily (fun a ↦ F.obj (X a)) (fun a  ↦ F.map (π a))
goal: CategoryTheory.EffectiveEpiFamily (fun a => F.obj (X a)) fun a => F.map (π a)

full_name: CategoryTheory.Functor.PreservesFiniteEffectiveEpiFamilies
code: /--
A class describing the property of preserving finite effective epimorphic families.
-/
class PreservesFiniteEffectiveEpiFamilies (F : C ⥤ D) : Prop where
  /--
  A functor preserves finite effective epimorphic families if it maps finite effective epimorphic
  families to effective epimorphic families.
  -/
  preserves : ∀ {α : Type} [Finite α] {B : C} (X : α → C) (π : (a : α) → (X a ⟶ B))
    [EffectiveEpiFamily X π],
    EffectiveEpiFamily (fun a ↦ F.obj (X a)) (fun a  ↦ F.map (π a))
goal: Prop

full_name: CategoryTheory.Functor.map_finite_effectiveEpiFamily
code: instance map_finite_effectiveEpiFamily (F : C ⥤ D) [F.PreservesFiniteEffectiveEpiFamilies]
    {α : Type} [Finite α] {B : C} (X : α → C) (π : (a : α) → (X a ⟶ B)) [EffectiveEpiFamily X π] :
    EffectiveEpiFamily (fun a ↦ F.obj (X a)) (fun a  ↦ F.map (π a)) 
goal: CategoryTheory.EffectiveEpiFamily (fun a => F.obj (X a)) fun a => F.map (π a)

full_name: CategoryTheory.Functor.instPreservesFiniteEffectiveEpiFamiliesOfPreservesEffectiveEpiFamilies
code: instance (F : C ⥤ D) [PreservesEffectiveEpiFamilies.{0} F] :
    PreservesFiniteEffectiveEpiFamilies F 
goal: F.PreservesFiniteEffectiveEpiFamilies

full_name: CategoryTheory.Functor.instPreservesEffectiveEpisOfPreservesFiniteEffectiveEpiFamilies
code: instance (F : C ⥤ D) [PreservesFiniteEffectiveEpiFamilies F] : PreservesEffectiveEpis F 
goal: F.PreservesEffectiveEpis

full_name: CategoryTheory.Functor.instPreservesEffectiveEpiFamiliesOfIsEquivalence
code: instance (F : C ⥤ D) [IsEquivalence F] : F.PreservesEffectiveEpiFamilies 
goal: F.PreservesEffectiveEpiFamilies

full_name: CategoryTheory.Functor.ReflectsEffectiveEpis
code: /--
A class describing the property of reflecting effective epimorphisms.
-/
class ReflectsEffectiveEpis (F : C ⥤ D) : Prop where
  /--
  A functor reflects effective epimorphisms if morphisms that are mapped to epimorphisms are
  themselves effective epimorphisms.
  -/
  reflects : ∀ {X Y : C} (f : X ⟶ Y), EffectiveEpi (F.map f) → EffectiveEpi f
goal: Prop

full_name: CategoryTheory.Functor.ReflectsEffectiveEpis.reflects
code: /--
A class describing the property of reflecting effective epimorphisms.
-/
class ReflectsEffectiveEpis (F : C ⥤ D) : Prop where
  /--
  A functor reflects effective epimorphisms if morphisms that are mapped to epimorphisms are
  themselves effective epimorphisms.
  -/
  reflects : ∀ {X Y : C} (f : X ⟶ Y), EffectiveEpi (F.map f) → EffectiveEpi f
goal: CategoryTheory.EffectiveEpi (F.map f) → CategoryTheory.EffectiveEpi f

full_name: CategoryTheory.Functor.effectiveEpi_of_map
code: lemma effectiveEpi_of_map (F : C ⥤ D) [F.ReflectsEffectiveEpis] {X Y : C} (f : X ⟶ Y)
    (h : EffectiveEpi (F.map f)) : EffectiveEpi f 
goal: CategoryTheory.EffectiveEpi f

full_name: CategoryTheory.Functor.ReflectsEffectiveEpiFamilies.reflects
code: /--
A class describing the property of reflecting effective epimorphic families.
-/
class ReflectsEffectiveEpiFamilies (F : C ⥤ D) : Prop where
  /--
  A functor reflects effective epimorphic families if families that are mapped to effective
  epimorphic families are themselves effective epimorphic families.
  -/
  reflects : ∀ {α : Type u} {B : C} (X : α → C) (π : (a : α) → (X a ⟶ B)),
    EffectiveEpiFamily (fun a ↦ F.obj (X a)) (fun a  ↦ F.map (π a)) →
    EffectiveEpiFamily X π
goal: (CategoryTheory.EffectiveEpiFamily (fun a => F.obj (X a)) fun a => F.map (π a)) → CategoryTheory.EffectiveEpiFamily X π

full_name: CategoryTheory.Functor.ReflectsEffectiveEpiFamilies
code: /--
A class describing the property of reflecting effective epimorphic families.
-/
class ReflectsEffectiveEpiFamilies (F : C ⥤ D) : Prop where
  /--
  A functor reflects effective epimorphic families if families that are mapped to effective
  epimorphic families are themselves effective epimorphic families.
  -/
  reflects : ∀ {α : Type u} {B : C} (X : α → C) (π : (a : α) → (X a ⟶ B)),
    EffectiveEpiFamily (fun a ↦ F.obj (X a)) (fun a  ↦ F.map (π a)) →
    EffectiveEpiFamily X π
goal: Prop

full_name: CategoryTheory.Functor.effectiveEpiFamily_of_map
code: lemma effectiveEpiFamily_of_map (F : C ⥤ D) [ReflectsEffectiveEpiFamilies.{u} F]
    {α : Type u} {B : C} (X : α → C) (π : (a : α) → (X a ⟶ B))
    (h : EffectiveEpiFamily (fun a ↦ F.obj (X a)) (fun a  ↦ F.map (π a))) :
    EffectiveEpiFamily X π 
goal: CategoryTheory.EffectiveEpiFamily X π

full_name: CategoryTheory.Functor.ReflectsFiniteEffectiveEpiFamilies
code: /--
A class describing the property of reflecting finite effective epimorphic families.
-/
class ReflectsFiniteEffectiveEpiFamilies (F : C ⥤ D) : Prop where
  /--
  A functor reflects finite effective epimorphic families if finite families that are
  mapped to effective epimorphic families are themselves effective epimorphic families.
  -/
  reflects : ∀ {α : Type} [Finite α] {B : C} (X : α → C) (π : (a : α) → (X a ⟶ B)),
    EffectiveEpiFamily (fun a ↦ F.obj (X a)) (fun a  ↦ F.map (π a)) →
    EffectiveEpiFamily X π
goal: Prop

full_name: CategoryTheory.Functor.ReflectsFiniteEffectiveEpiFamilies.reflects
code: /--
A class describing the property of reflecting finite effective epimorphic families.
-/
class ReflectsFiniteEffectiveEpiFamilies (F : C ⥤ D) : Prop where
  /--
  A functor reflects finite effective epimorphic families if finite families that are
  mapped to effective epimorphic families are themselves effective epimorphic families.
  -/
  reflects : ∀ {α : Type} [Finite α] {B : C} (X : α → C) (π : (a : α) → (X a ⟶ B)),
    EffectiveEpiFamily (fun a ↦ F.obj (X a)) (fun a  ↦ F.map (π a)) →
    EffectiveEpiFamily X π
goal: (CategoryTheory.EffectiveEpiFamily (fun a => F.obj (X a)) fun a => F.map (π a)) → CategoryTheory.EffectiveEpiFamily X π

full_name: CategoryTheory.Functor.finite_effectiveEpiFamily_of_map
code: lemma finite_effectiveEpiFamily_of_map (F : C ⥤ D) [ReflectsFiniteEffectiveEpiFamilies F]
    {α : Type} [Finite α] {B : C} (X : α → C) (π : (a : α) → (X a ⟶ B))
    (h : EffectiveEpiFamily (fun a ↦ F.obj (X a)) (fun a  ↦ F.map (π a))) :
    EffectiveEpiFamily X π 
goal: CategoryTheory.EffectiveEpiFamily X π

full_name: CategoryTheory.Functor.instReflectsFiniteEffectiveEpiFamiliesOfReflectsEffectiveEpiFamilies
code: instance (F : C ⥤ D) [ReflectsEffectiveEpiFamilies.{0} F] :
    ReflectsFiniteEffectiveEpiFamilies F 
goal: F.ReflectsFiniteEffectiveEpiFamilies

full_name: CategoryTheory.Functor.instReflectsEffectiveEpisOfReflectsFiniteEffectiveEpiFamilies
code: instance (F : C ⥤ D) [ReflectsFiniteEffectiveEpiFamilies F] : ReflectsEffectiveEpis F 
goal: F.ReflectsEffectiveEpis

full_name: CategoryTheory.Functor.instPreservesEffectiveEpiFamiliesOfIsEquivalence_1
code: instance (F : C ⥤ D) [IsEquivalence F] : F.PreservesEffectiveEpiFamilies 
goal: F.PreservesEffectiveEpiFamilies

full_name: CategoryTheory.Functor.instReflectsEffectiveEpiFamiliesOfIsEquivalence
code: instance (F : C ⥤ D) [IsEquivalence F] : F.ReflectsEffectiveEpiFamilies 
goal: F.ReflectsEffectiveEpiFamilies