File: Mathlib/CategoryTheory/Simple.lean

full_name: CategoryTheory.Simple
code: /-- An object is simple if monomorphisms into it are (exclusively) either isomorphisms or zero. -/
class Simple (X : C) : Prop where
  mono_isIso_iff_nonzero : ∀ {Y : C} (f : Y ⟶ X) [Mono f], IsIso f ↔ f ≠ 0
goal: Prop

full_name: CategoryTheory.Simple.mono_isIso_iff_nonzero
code: /-- An object is simple if monomorphisms into it are (exclusively) either isomorphisms or zero. -/
class Simple (X : C) : Prop where
  mono_isIso_iff_nonzero : ∀ {Y : C} (f : Y ⟶ X) [Mono f], IsIso f ↔ f ≠ 0
goal: CategoryTheory.IsIso f ↔ f ≠ 0

full_name: CategoryTheory.isIso_of_mono_of_nonzero
code: /-- A nonzero monomorphism to a simple object is an isomorphism. -/
theorem isIso_of_mono_of_nonzero {X Y : C} [Simple Y] {f : X ⟶ Y} [Mono f] (w : f ≠ 0) : IsIso f 
goal: CategoryTheory.IsIso f

full_name: CategoryTheory.Simple.of_iso
code: theorem Simple.of_iso {X Y : C} [Simple Y] (i : X ≅ Y) : Simple X 
goal: CategoryTheory.Simple X

full_name: CategoryTheory.Simple.iff_of_iso
code: theorem Simple.iff_of_iso {X Y : C} (i : X ≅ Y) : Simple X ↔ Simple Y 
goal: CategoryTheory.Simple X ↔ CategoryTheory.Simple Y

full_name: CategoryTheory.kernel_zero_of_nonzero_from_simple
code: theorem kernel_zero_of_nonzero_from_simple {X Y : C} [Simple X] {f : X ⟶ Y} [HasKernel f]
    (w : f ≠ 0) : kernel.ι f = 0 
goal: CategoryTheory.Limits.kernel.ι f = 0

full_name: CategoryTheory.epi_of_nonzero_to_simple
code: /-- A nonzero morphism `f` to a simple object is an epimorphism
(assuming `f` has an image, and `C` has equalizers).
-/
theorem epi_of_nonzero_to_simple [HasEqualizers C] {X Y : C} [Simple Y] {f : X ⟶ Y} [HasImage f]
    (w : f ≠ 0) : Epi f 
goal: CategoryTheory.Epi f

full_name: CategoryTheory.mono_to_simple_zero_of_not_iso
code: theorem mono_to_simple_zero_of_not_iso {X Y : C} [Simple Y] {f : X ⟶ Y} [Mono f]
    (w : IsIso f → False) : f = 0 
goal: f = 0

full_name: CategoryTheory.id_nonzero
code: theorem id_nonzero (X : C) [Simple.{v} X] : 𝟙 X ≠ 0 
goal: CategoryTheory.CategoryStruct.id X ≠ 0

full_name: CategoryTheory.instNontrivialEndOfSimple
code: instance (X : C) [Simple.{v} X] : Nontrivial (End X) 
goal: Nontrivial (CategoryTheory.End X)

full_name: CategoryTheory.Simple.not_isZero
code: theorem Simple.not_isZero (X : C) [Simple X] : ¬IsZero X 
goal: ¬CategoryTheory.Limits.IsZero X

full_name: CategoryTheory.zero_not_simple
code: /-- We don't want the definition of 'simple' to include the zero object, so we check that here. -/
theorem zero_not_simple [Simple (0 : C)] : False 
goal: False

full_name: CategoryTheory.simple_of_cosimple
code: /-- In an abelian category, an object satisfying the dual of the definition of a simple object is
    simple. -/
theorem simple_of_cosimple (X : C) (h : ∀ {Z : C} (f : X ⟶ Z) [Epi f], IsIso f ↔ f ≠ 0) :
    Simple X 
goal: CategoryTheory.Simple X

full_name: CategoryTheory.isIso_of_epi_of_nonzero
code: /-- A nonzero epimorphism from a simple object is an isomorphism. -/
theorem isIso_of_epi_of_nonzero {X Y : C} [Simple X] {f : X ⟶ Y} [Epi f] (w : f ≠ 0) : IsIso f 
goal: CategoryTheory.IsIso f

full_name: CategoryTheory.cokernel_zero_of_nonzero_to_simple
code: theorem cokernel_zero_of_nonzero_to_simple {X Y : C} [Simple Y] {f : X ⟶ Y} (w : f ≠ 0) :
    cokernel.π f = 0 
goal: CategoryTheory.Limits.cokernel.π f = 0

full_name: CategoryTheory.epi_from_simple_zero_of_not_iso
code: theorem epi_from_simple_zero_of_not_iso {X Y : C} [Simple X] {f : X ⟶ Y} [Epi f]
    (w : IsIso f → False) : f = 0 
goal: f = 0

full_name: CategoryTheory.Biprod.isIso_inl_iff_isZero
code: theorem Biprod.isIso_inl_iff_isZero (X Y : C) : IsIso (biprod.inl : X ⟶ X ⊞ Y) ↔ IsZero Y 
goal: CategoryTheory.IsIso CategoryTheory.Limits.biprod.inl ↔ CategoryTheory.Limits.IsZero Y

full_name: CategoryTheory.indecomposable_of_simple
code: /-- Any simple object in a preadditive category is indecomposable. -/
theorem indecomposable_of_simple (X : C) [Simple X] : Indecomposable X 
goal: CategoryTheory.Indecomposable X

full_name: CategoryTheory.instNontrivialSubobjectOfSimple
code: instance {X : C} [Simple X] : Nontrivial (Subobject X) 
goal: Nontrivial (CategoryTheory.Subobject X)

full_name: CategoryTheory.instIsSimpleOrderSubobjectOfSimple
code: instance {X : C} [Simple X] : IsSimpleOrder (Subobject X) 
goal: IsSimpleOrder (CategoryTheory.Subobject X)

full_name: CategoryTheory.simple_of_isSimpleOrder_subobject
code: /-- If `X` has subobject lattice `{⊥, ⊤}`, then `X` is simple. -/
theorem simple_of_isSimpleOrder_subobject (X : C) [IsSimpleOrder (Subobject X)] : Simple X 
goal: CategoryTheory.Simple X

full_name: CategoryTheory.simple_iff_subobject_isSimpleOrder
code: /-- `X` is simple iff it has subobject lattice `{⊥, ⊤}`. -/
theorem simple_iff_subobject_isSimpleOrder (X : C) : Simple X ↔ IsSimpleOrder (Subobject X) 
goal: CategoryTheory.Simple X ↔ IsSimpleOrder (CategoryTheory.Subobject X)

full_name: CategoryTheory.subobject_simple_iff_isAtom
code: /-- A subobject is simple iff it is an atom in the subobject lattice. -/
theorem subobject_simple_iff_isAtom {X : C} (Y : Subobject X) : Simple (Y : C) ↔ IsAtom Y 
goal: CategoryTheory.Simple (CategoryTheory.Subobject.underlying.obj Y) ↔ IsAtom Y