File: Mathlib/CategoryTheory/Preadditive/Projective.lean

full_name: CategoryTheory.Projective
code: /--
An object `P` is called *projective* if every morphism out of `P` factors through every epimorphism.
-/
class Projective (P : C) : Prop where
  factors : ∀ {E X : C} (f : P ⟶ X) (e : E ⟶ X) [Epi e], ∃ f', f' ≫ e = f
goal: Prop

full_name: CategoryTheory.Projective.factors
code: /--
An object `P` is called *projective* if every morphism out of `P` factors through every epimorphism.
-/
class Projective (P : C) : Prop where
  factors : ∀ {E X : C} (f : P ⟶ X) (e : E ⟶ X) [Epi e], ∃ f', f' ≫ e = f
goal: ∃ f', f' ≫ e = f

full_name: CategoryTheory.Limits.IsZero.projective
code: lemma Limits.IsZero.projective {X : C} (h : IsZero X) : Projective X 
goal: CategoryTheory.Projective X

full_name: CategoryTheory.ProjectivePresentation.epi
code: /-- A projective presentation of an object `X` consists of an epimorphism `f : P ⟶ X`
from some projective object `P`.
-/
-- Porting note(#5171): was @[nolint has_nonempty_instance]
structure ProjectivePresentation (X : C) where
  p : C
  [projective : Projective p]
  f : p ⟶ X
  [epi : Epi f]
goal: CategoryTheory.Epi self.f

full_name: CategoryTheory.ProjectivePresentation.f
code: /-- A projective presentation of an object `X` consists of an epimorphism `f : P ⟶ X`
from some projective object `P`.
-/
-- Porting note(#5171): was @[nolint has_nonempty_instance]
structure ProjectivePresentation (X : C) where
  p : C
  [projective : Projective p]
  f : p ⟶ X
  [epi : Epi f]
goal: self.p ⟶ X

full_name: CategoryTheory.ProjectivePresentation.projective
code: /-- A projective presentation of an object `X` consists of an epimorphism `f : P ⟶ X`
from some projective object `P`.
-/
-- Porting note(#5171): was @[nolint has_nonempty_instance]
structure ProjectivePresentation (X : C) where
  p : C
  [projective : Projective p]
  f : p ⟶ X
  [epi : Epi f]
goal: CategoryTheory.Projective self.p

full_name: CategoryTheory.ProjectivePresentation.p
code: /-- A projective presentation of an object `X` consists of an epimorphism `f : P ⟶ X`
from some projective object `P`.
-/
-- Porting note(#5171): was @[nolint has_nonempty_instance]
structure ProjectivePresentation (X : C) where
  p : C
  [projective : Projective p]
  f : p ⟶ X
  [epi : Epi f]
goal: C

full_name: CategoryTheory.ProjectivePresentation
code: /-- A projective presentation of an object `X` consists of an epimorphism `f : P ⟶ X`
from some projective object `P`.
-/
-- Porting note(#5171): was @[nolint has_nonempty_instance]
structure ProjectivePresentation (X : C) where
  p : C
  [projective : Projective p]
  f : p ⟶ X
  [epi : Epi f]
goal: Type (max u v)

full_name: CategoryTheory.EnoughProjectives.presentation
code: /-- A category "has enough projectives" if for every object `X` there is a projective object `P` and
    an epimorphism `P ↠ X`. -/
class EnoughProjectives : Prop where
  presentation : ∀ X : C, Nonempty (ProjectivePresentation X)
goal: Nonempty (CategoryTheory.ProjectivePresentation X)

full_name: CategoryTheory.EnoughProjectives
code: /-- A category "has enough projectives" if for every object `X` there is a projective object `P` and
    an epimorphism `P ↠ X`. -/
class EnoughProjectives : Prop where
  presentation : ∀ X : C, Nonempty (ProjectivePresentation X)
goal: Prop

full_name: CategoryTheory.Projective.factorThru
code: /--
An arbitrarily chosen factorisation of a morphism out of a projective object through an epimorphism.
-/
def factorThru {P X E : C} [Projective P] (f : P ⟶ X) (e : E ⟶ X) [Epi e] : P ⟶ E 
goal: P ⟶ E

full_name: CategoryTheory.Projective.factorThru_comp
code: @[reassoc (attr := simp)]
theorem factorThru_comp {P X E : C} [Projective P] (f : P ⟶ X) (e : E ⟶ X) [Epi e] :
    factorThru f e ≫ e = f 
goal: CategoryTheory.Projective.factorThru f e ≫ e = f

full_name: CategoryTheory.Projective.zero_projective
code: instance zero_projective [HasZeroObject C] : Projective (0 : C) 
goal: CategoryTheory.Projective 0

full_name: CategoryTheory.Projective.of_iso
code: theorem of_iso {P Q : C} (i : P ≅ Q) (hP : Projective P) : Projective Q 
goal: CategoryTheory.Projective Q

full_name: CategoryTheory.Projective.iso_iff
code: theorem iso_iff {P Q : C} (i : P ≅ Q) : Projective P ↔ Projective Q 
goal: CategoryTheory.Projective P ↔ CategoryTheory.Projective Q

full_name: CategoryTheory.Projective.inst
code: /-- The axiom of choice says that every type is a projective object in `Type`. -/
instance (X : Type u) : Projective X 
goal: CategoryTheory.Projective X

full_name: CategoryTheory.Projective.Type.enoughProjectives
code: instance Type.enoughProjectives : EnoughProjectives (Type u) 
goal: CategoryTheory.EnoughProjectives (Type u)

full_name: CategoryTheory.Projective.instCoprod
code: instance {P Q : C} [HasBinaryCoproduct P Q] [Projective P] [Projective Q] : Projective (P ⨿ Q) 
goal: CategoryTheory.Projective (P ⨿ Q)

full_name: CategoryTheory.Projective.instSigmaObj
code: instance {β : Type v} (g : β → C) [HasCoproduct g] [∀ b, Projective (g b)] : Projective (∐ g) 
goal: CategoryTheory.Projective (∐ g)

full_name: CategoryTheory.Projective.instBiprod
code: instance {P Q : C} [HasZeroMorphisms C] [HasBinaryBiproduct P Q] [Projective P] [Projective Q] :
    Projective (P ⊞ Q) 
goal: CategoryTheory.Projective (P ⊞ Q)

full_name: CategoryTheory.Projective.instBiproduct
code: instance {β : Type v} (g : β → C) [HasZeroMorphisms C] [HasBiproduct g] [∀ b, Projective (g b)] :
    Projective (⨁ g) 
goal: CategoryTheory.Projective (⨁ g)

full_name: CategoryTheory.Projective.projective_iff_preservesEpimorphisms_coyoneda_obj
code: theorem projective_iff_preservesEpimorphisms_coyoneda_obj (P : C) :
    Projective P ↔ (coyoneda.obj (op P)).PreservesEpimorphisms 
goal: CategoryTheory.Projective P ↔ (CategoryTheory.coyoneda.obj (Opposite.op P)).PreservesEpimorphisms

full_name: CategoryTheory.Projective.over
code: /-- `Projective.over X` provides an arbitrarily chosen projective object equipped with
an epimorphism `Projective.π : Projective.over X ⟶ X`.
-/
def over (X : C) : C 
goal: C

full_name: CategoryTheory.Projective.projective_over
code: instance projective_over (X : C) : Projective (over X) 
goal: CategoryTheory.Projective (CategoryTheory.Projective.over X)

full_name: CategoryTheory.Projective.π
code: /-- The epimorphism `projective.π : projective.over X ⟶ X`
from the arbitrarily chosen projective object over `X`.
-/
def π (X : C) : over X ⟶ X 
goal: CategoryTheory.Projective.over X ⟶ X

full_name: CategoryTheory.Projective.π_epi
code: instance π_epi (X : C) : Epi (π X) 
goal: CategoryTheory.Epi (CategoryTheory.Projective.π X)

full_name: CategoryTheory.Projective.syzygies
code: /-- When `C` has enough projectives, the object `Projective.syzygies f` is
an arbitrarily chosen projective object over `kernel f`.
-/
def syzygies : C 
goal: C

full_name: CategoryTheory.Projective.instSyzygies
code: instance : Projective (syzygies f) 
goal: CategoryTheory.Projective (CategoryTheory.Projective.syzygies f)

full_name: CategoryTheory.Projective.d
code: /-- When `C` has enough projectives,
`Projective.d f : Projective.syzygies f ⟶ X` is the composition
`π (kernel f) ≫ kernel.ι f`.

(When `C` is abelian, we have `exact (projective.d f) f`.)
-/
abbrev d : syzygies f ⟶ X 
goal: CategoryTheory.Projective.syzygies f ⟶ X

full_name: CategoryTheory.Adjunction.map_projective
code: theorem map_projective (adj : F ⊣ G) [G.PreservesEpimorphisms] (P : C) (hP : Projective P) :
    Projective (F.obj P) 
goal: CategoryTheory.Projective (F.obj P)

full_name: CategoryTheory.Adjunction.projective_of_map_projective
code: theorem projective_of_map_projective (adj : F ⊣ G) [F.Full] [F.Faithful] (P : C)
    (hP : Projective (F.obj P)) : Projective P 
goal: CategoryTheory.Projective P

full_name: CategoryTheory.Adjunction.mapProjectivePresentation
code: /-- Given an adjunction `F ⊣ G` such that `G` preserves epis, `F` maps a projective presentation of
`X` to a projective presentation of `F(X)`. -/
def mapProjectivePresentation (adj : F ⊣ G) [G.PreservesEpimorphisms] (X : C)
    (Y : ProjectivePresentation X) : ProjectivePresentation (F.obj X) 
goal: CategoryTheory.ProjectivePresentation (F.obj X)

full_name: CategoryTheory.Equivalence.map_projective_iff
code: theorem map_projective_iff (P : C) : Projective (F.functor.obj P) ↔ Projective P 
goal: CategoryTheory.Projective (F.functor.obj P) ↔ CategoryTheory.Projective P

full_name: CategoryTheory.Equivalence.projectivePresentationOfMapProjectivePresentation
code: /-- Given an equivalence of categories `F`, a projective presentation of `F(X)` induces a
projective presentation of `X.` -/
def projectivePresentationOfMapProjectivePresentation (X : C)
    (Y : ProjectivePresentation (F.functor.obj X)) : ProjectivePresentation X 
goal: CategoryTheory.ProjectivePresentation X

full_name: CategoryTheory.Equivalence.enoughProjectives_iff
code: theorem enoughProjectives_iff (F : C ≌ D) : EnoughProjectives C ↔ EnoughProjectives D 
goal: CategoryTheory.EnoughProjectives C ↔ CategoryTheory.EnoughProjectives D