File: Mathlib/CategoryTheory/Subobject/Limits.lean

full_name: CategoryTheory.Limits.equalizerSubobject
code: /-- The equalizer of morphisms `f g : X ⟶ Y` as a `Subobject X`. -/
abbrev equalizerSubobject : Subobject X 
goal: CategoryTheory.Subobject X

full_name: CategoryTheory.Limits.equalizerSubobjectIso
code: /-- The underlying object of `equalizerSubobject f g` is (up to isomorphism!)
the same as the chosen object `equalizer f g`. -/
def equalizerSubobjectIso : (equalizerSubobject f g : C) ≅ equalizer f g 
goal: CategoryTheory.Subobject.underlying.obj (CategoryTheory.Limits.equalizerSubobject f g) ≅
  CategoryTheory.Limits.equalizer f g

full_name: CategoryTheory.Limits.equalizerSubobject_arrow
code: @[reassoc (attr := simp)]
theorem equalizerSubobject_arrow :
    (equalizerSubobjectIso f g).hom ≫ equalizer.ι f g = (equalizerSubobject f g).arrow 
goal: (CategoryTheory.Limits.equalizerSubobjectIso f g).hom ≫ CategoryTheory.Limits.equalizer.ι f g =
  (CategoryTheory.Limits.equalizerSubobject f g).arrow

full_name: CategoryTheory.Limits.equalizerSubobject_arrow'
code: @[reassoc (attr := simp)]
theorem equalizerSubobject_arrow' :
    (equalizerSubobjectIso f g).inv ≫ (equalizerSubobject f g).arrow = equalizer.ι f g 
goal: (CategoryTheory.Limits.equalizerSubobjectIso f g).inv ≫ (CategoryTheory.Limits.equalizerSubobject f g).arrow =
  CategoryTheory.Limits.equalizer.ι f g

full_name: CategoryTheory.Limits.equalizerSubobject_arrow_comp
code: @[reassoc]
theorem equalizerSubobject_arrow_comp :
    (equalizerSubobject f g).arrow ≫ f = (equalizerSubobject f g).arrow ≫ g 
goal: (CategoryTheory.Limits.equalizerSubobject f g).arrow ≫ f = (CategoryTheory.Limits.equalizerSubobject f g).arrow ≫ g

full_name: CategoryTheory.Limits.equalizerSubobject_factors
code: theorem equalizerSubobject_factors {W : C} (h : W ⟶ X) (w : h ≫ f = h ≫ g) :
    (equalizerSubobject f g).Factors h 
goal: (CategoryTheory.Limits.equalizerSubobject f g).Factors h

full_name: CategoryTheory.Limits.equalizerSubobject_factors_iff
code: theorem equalizerSubobject_factors_iff {W : C} (h : W ⟶ X) :
    (equalizerSubobject f g).Factors h ↔ h ≫ f = h ≫ g 
goal: (CategoryTheory.Limits.equalizerSubobject f g).Factors h ↔ h ≫ f = h ≫ g

full_name: CategoryTheory.Limits.kernelSubobject
code: /-- The kernel of a morphism `f : X ⟶ Y` as a `Subobject X`. -/
abbrev kernelSubobject : Subobject X 
goal: CategoryTheory.Subobject X

full_name: CategoryTheory.Limits.kernelSubobjectIso
code: /-- The underlying object of `kernelSubobject f` is (up to isomorphism!)
the same as the chosen object `kernel f`. -/
def kernelSubobjectIso : (kernelSubobject f : C) ≅ kernel f 
goal: CategoryTheory.Subobject.underlying.obj (CategoryTheory.Limits.kernelSubobject f) ≅ CategoryTheory.Limits.kernel f

full_name: CategoryTheory.Limits.kernelSubobject_arrow
code: @[reassoc (attr := simp), elementwise (attr := simp)]
theorem kernelSubobject_arrow :
    (kernelSubobjectIso f).hom ≫ kernel.ι f = (kernelSubobject f).arrow 
goal: (CategoryTheory.Limits.kernelSubobjectIso f).hom ≫ CategoryTheory.Limits.kernel.ι f =
  (CategoryTheory.Limits.kernelSubobject f).arrow

full_name: CategoryTheory.Limits.kernelSubobject_arrow'
code: @[reassoc (attr := simp), elementwise (attr := simp)]
theorem kernelSubobject_arrow' :
    (kernelSubobjectIso f).inv ≫ (kernelSubobject f).arrow = kernel.ι f 
goal: (CategoryTheory.Limits.kernelSubobjectIso f).inv ≫ (CategoryTheory.Limits.kernelSubobject f).arrow =
  CategoryTheory.Limits.kernel.ι f

full_name: CategoryTheory.Limits.kernelSubobject_arrow_comp
code: @[reassoc (attr := simp), elementwise (attr := simp)]
theorem kernelSubobject_arrow_comp : (kernelSubobject f).arrow ≫ f = 0 
goal: (CategoryTheory.Limits.kernelSubobject f).arrow ≫ f = 0

full_name: CategoryTheory.Limits.kernelSubobject_factors
code: theorem kernelSubobject_factors {W : C} (h : W ⟶ X) (w : h ≫ f = 0) :
    (kernelSubobject f).Factors h 
goal: (CategoryTheory.Limits.kernelSubobject f).Factors h

full_name: CategoryTheory.Limits.kernelSubobject_factors_iff
code: theorem kernelSubobject_factors_iff {W : C} (h : W ⟶ X) :
    (kernelSubobject f).Factors h ↔ h ≫ f = 0 
goal: (CategoryTheory.Limits.kernelSubobject f).Factors h ↔ h ≫ f = 0

full_name: CategoryTheory.Limits.factorThruKernelSubobject
code: /-- A factorisation of `h : W ⟶ X` through `kernelSubobject f`, assuming `h ≫ f = 0`. -/
def factorThruKernelSubobject {W : C} (h : W ⟶ X) (w : h ≫ f = 0) : W ⟶ kernelSubobject f 
goal: W ⟶ CategoryTheory.Subobject.underlying.obj (CategoryTheory.Limits.kernelSubobject f)

full_name: CategoryTheory.Limits.factorThruKernelSubobject_comp_arrow
code: @[simp]
theorem factorThruKernelSubobject_comp_arrow {W : C} (h : W ⟶ X) (w : h ≫ f = 0) :
    factorThruKernelSubobject f h w ≫ (kernelSubobject f).arrow = h 
goal: CategoryTheory.Limits.factorThruKernelSubobject f h w ≫ (CategoryTheory.Limits.kernelSubobject f).arrow = h

full_name: CategoryTheory.Limits.factorThruKernelSubobject_comp_kernelSubobjectIso
code: @[simp]
theorem factorThruKernelSubobject_comp_kernelSubobjectIso {W : C} (h : W ⟶ X) (w : h ≫ f = 0) :
    factorThruKernelSubobject f h w ≫ (kernelSubobjectIso f).hom = kernel.lift f h w 
goal: CategoryTheory.Limits.factorThruKernelSubobject f h w ≫ (CategoryTheory.Limits.kernelSubobjectIso f).hom =
  CategoryTheory.Limits.kernel.lift f h w

full_name: CategoryTheory.Limits.kernelSubobjectMap
code: /-- A commuting square induces a morphism between the kernel subobjects. -/
def kernelSubobjectMap (sq : Arrow.mk f ⟶ Arrow.mk f') :
    (kernelSubobject f : C) ⟶ (kernelSubobject f' : C) 
goal: CategoryTheory.Subobject.underlying.obj (CategoryTheory.Limits.kernelSubobject f) ⟶
  CategoryTheory.Subobject.underlying.obj (CategoryTheory.Limits.kernelSubobject f')

full_name: CategoryTheory.Limits.kernelSubobjectMap_arrow
code: @[reassoc (attr := simp), elementwise (attr := simp)]
theorem kernelSubobjectMap_arrow (sq : Arrow.mk f ⟶ Arrow.mk f') :
    kernelSubobjectMap sq ≫ (kernelSubobject f').arrow = (kernelSubobject f).arrow ≫ sq.left 
goal: CategoryTheory.Limits.kernelSubobjectMap sq ≫ (CategoryTheory.Limits.kernelSubobject f').arrow =
  (CategoryTheory.Limits.kernelSubobject f).arrow ≫ sq.left

full_name: CategoryTheory.Limits.kernelSubobjectMap_id
code: @[simp]
theorem kernelSubobjectMap_id : kernelSubobjectMap (𝟙 (Arrow.mk f)) = 𝟙 _ 
goal: CategoryTheory.Limits.kernelSubobjectMap (𝟙 (CategoryTheory.Arrow.mk f)) =
  𝟙 (CategoryTheory.Subobject.underlying.obj (CategoryTheory.Limits.kernelSubobject f))

full_name: CategoryTheory.Limits.kernelSubobjectMap_comp
code: @[simp]
theorem kernelSubobjectMap_comp {X'' Y'' : C} {f'' : X'' ⟶ Y''} [HasKernel f'']
    (sq : Arrow.mk f ⟶ Arrow.mk f') (sq' : Arrow.mk f' ⟶ Arrow.mk f'') :
    kernelSubobjectMap (sq ≫ sq') = kernelSubobjectMap sq ≫ kernelSubobjectMap sq' 
goal: CategoryTheory.Limits.kernelSubobjectMap (sq ≫ sq') =
  CategoryTheory.Limits.kernelSubobjectMap sq ≫ CategoryTheory.Limits.kernelSubobjectMap sq'

full_name: CategoryTheory.Limits.kernel_map_comp_kernelSubobjectIso_inv
code: @[reassoc]
theorem kernel_map_comp_kernelSubobjectIso_inv (sq : Arrow.mk f ⟶ Arrow.mk f') :
    kernel.map f f' sq.1 sq.2 sq.3.symm ≫ (kernelSubobjectIso _).inv =
      (kernelSubobjectIso _).inv ≫ kernelSubobjectMap sq 
goal: CategoryTheory.Limits.kernel.map f f' sq.left sq.right ⋯ ≫ (CategoryTheory.Limits.kernelSubobjectIso f').inv =
  (CategoryTheory.Limits.kernelSubobjectIso f).inv ≫ CategoryTheory.Limits.kernelSubobjectMap sq

full_name: CategoryTheory.Limits.kernelSubobjectIso_comp_kernel_map
code: @[reassoc]
theorem kernelSubobjectIso_comp_kernel_map (sq : Arrow.mk f ⟶ Arrow.mk f') :
    (kernelSubobjectIso _).hom ≫ kernel.map f f' sq.1 sq.2 sq.3.symm =
      kernelSubobjectMap sq ≫ (kernelSubobjectIso _).hom 
goal: (CategoryTheory.Limits.kernelSubobjectIso f).hom ≫ CategoryTheory.Limits.kernel.map f f' sq.left sq.right ⋯ =
  CategoryTheory.Limits.kernelSubobjectMap sq ≫ (CategoryTheory.Limits.kernelSubobjectIso f').hom

full_name: CategoryTheory.Limits.kernelSubobject_zero
code: @[simp]
theorem kernelSubobject_zero {A B : C} : kernelSubobject (0 : A ⟶ B) = ⊤ 
goal: CategoryTheory.Limits.kernelSubobject 0 = ⊤

full_name: CategoryTheory.Limits.isIso_kernelSubobject_zero_arrow
code: instance isIso_kernelSubobject_zero_arrow : IsIso (kernelSubobject (0 : X ⟶ Y)).arrow 
goal: CategoryTheory.IsIso (CategoryTheory.Limits.kernelSubobject 0).arrow

full_name: CategoryTheory.Limits.le_kernelSubobject
code: theorem le_kernelSubobject (A : Subobject X) (h : A.arrow ≫ f = 0) : A ≤ kernelSubobject f 
goal: A ≤ CategoryTheory.Limits.kernelSubobject f

full_name: CategoryTheory.Limits.kernelSubobjectIsoComp
code: /-- The isomorphism between the kernel of `f ≫ g` and the kernel of `g`,
when `f` is an isomorphism.
-/
def kernelSubobjectIsoComp {X' : C} (f : X' ⟶ X) [IsIso f] (g : X ⟶ Y) [HasKernel g] :
    (kernelSubobject (f ≫ g) : C) ≅ (kernelSubobject g : C) 
goal: CategoryTheory.Subobject.underlying.obj (CategoryTheory.Limits.kernelSubobject (f ≫ g)) ≅
  CategoryTheory.Subobject.underlying.obj (CategoryTheory.Limits.kernelSubobject g)

full_name: CategoryTheory.Limits.kernelSubobjectIsoComp_hom_arrow
code: @[simp]
theorem kernelSubobjectIsoComp_hom_arrow {X' : C} (f : X' ⟶ X) [IsIso f] (g : X ⟶ Y) [HasKernel g] :
    (kernelSubobjectIsoComp f g).hom ≫ (kernelSubobject g).arrow =
      (kernelSubobject (f ≫ g)).arrow ≫ f 
goal: (CategoryTheory.Limits.kernelSubobjectIsoComp f g).hom ≫ (CategoryTheory.Limits.kernelSubobject g).arrow =
  (CategoryTheory.Limits.kernelSubobject (f ≫ g)).arrow ≫ f

full_name: CategoryTheory.Limits.kernelSubobjectIsoComp_inv_arrow
code: @[simp]
theorem kernelSubobjectIsoComp_inv_arrow {X' : C} (f : X' ⟶ X) [IsIso f] (g : X ⟶ Y) [HasKernel g] :
    (kernelSubobjectIsoComp f g).inv ≫ (kernelSubobject (f ≫ g)).arrow =
      (kernelSubobject g).arrow ≫ inv f 
goal: (CategoryTheory.Limits.kernelSubobjectIsoComp f g).inv ≫ (CategoryTheory.Limits.kernelSubobject (f ≫ g)).arrow =
  (CategoryTheory.Limits.kernelSubobject g).arrow ≫ CategoryTheory.inv f

full_name: CategoryTheory.Limits.kernelSubobject_comp_le
code: /-- The kernel of `f` is always a smaller subobject than the kernel of `f ≫ h`. -/
theorem kernelSubobject_comp_le (f : X ⟶ Y) [HasKernel f] {Z : C} (h : Y ⟶ Z) [HasKernel (f ≫ h)] :
    kernelSubobject f ≤ kernelSubobject (f ≫ h) 
goal: CategoryTheory.Limits.kernelSubobject f ≤ CategoryTheory.Limits.kernelSubobject (f ≫ h)

full_name: CategoryTheory.Limits.kernelSubobject_comp_mono
code: /-- Postcomposing by a monomorphism does not change the kernel subobject. -/
@[simp]
theorem kernelSubobject_comp_mono (f : X ⟶ Y) [HasKernel f] {Z : C} (h : Y ⟶ Z) [Mono h] :
    kernelSubobject (f ≫ h) = kernelSubobject f 
goal: CategoryTheory.Limits.kernelSubobject (f ≫ h) = CategoryTheory.Limits.kernelSubobject f

full_name: CategoryTheory.Limits.kernelSubobject_comp_mono_isIso
code: instance kernelSubobject_comp_mono_isIso (f : X ⟶ Y) [HasKernel f] {Z : C} (h : Y ⟶ Z) [Mono h] :
    IsIso (Subobject.ofLE _ _ (kernelSubobject_comp_le f h)) 
goal: CategoryTheory.IsIso ((CategoryTheory.Limits.kernelSubobject f).ofLE (CategoryTheory.Limits.kernelSubobject (f ≫ h)) ⋯)

full_name: CategoryTheory.Limits.cokernelOrderHom
code: /-- Taking cokernels is an order-reversing map from the subobjects of `X` to the quotient objects
    of `X`. -/
@[simps]
def cokernelOrderHom [HasCokernels C] (X : C) : Subobject X →o (Subobject (op X))ᵒᵈ 
goal: CategoryTheory.Subobject X →o (CategoryTheory.Subobject (Opposite.op X))ᵒᵈ

full_name: CategoryTheory.Limits.cokernelOrderHom_coe
code: /-- Taking cokernels is an order-reversing map from the subobjects of `X` to the quotient objects
    of `X`. -/
@[simps]
def cokernelOrderHom [HasCokernels C] (X : C) : Subobject X →o (Subobject (op X))ᵒᵈ 
goal: ∀ (a : CategoryTheory.Subobject X),
  (CategoryTheory.Limits.cokernelOrderHom X) a =
    CategoryTheory.Subobject.lift (fun A f x => CategoryTheory.Subobject.mk (CategoryTheory.Limits.cokernel.π f).op) ⋯ a

full_name: CategoryTheory.Limits.kernelOrderHom
code: /-- Taking kernels is an order-reversing map from the quotient objects of `X` to the subobjects of
    `X`. -/
@[simps]
def kernelOrderHom [HasKernels C] (X : C) : (Subobject (op X))ᵒᵈ →o Subobject X 
goal: (CategoryTheory.Subobject (Opposite.op X))ᵒᵈ →o CategoryTheory.Subobject X

full_name: CategoryTheory.Limits.kernelOrderHom_coe
code: /-- Taking kernels is an order-reversing map from the quotient objects of `X` to the subobjects of
    `X`. -/
@[simps]
def kernelOrderHom [HasKernels C] (X : C) : (Subobject (op X))ᵒᵈ →o Subobject X 
goal: ∀ (a : CategoryTheory.Subobject (Opposite.op X)),
  (CategoryTheory.Limits.kernelOrderHom X) a =
    CategoryTheory.Subobject.lift (fun A f x => CategoryTheory.Subobject.mk (CategoryTheory.Limits.kernel.ι f.unop)) ⋯ a

full_name: CategoryTheory.Limits.imageSubobject
code: /-- The image of a morphism `f g : X ⟶ Y` as a `Subobject Y`. -/
abbrev imageSubobject : Subobject Y 
goal: CategoryTheory.Subobject Y

full_name: CategoryTheory.Limits.imageSubobjectIso
code: /-- The underlying object of `imageSubobject f` is (up to isomorphism!)
the same as the chosen object `image f`. -/
def imageSubobjectIso : (imageSubobject f : C) ≅ image f 
goal: CategoryTheory.Subobject.underlying.obj (CategoryTheory.Limits.imageSubobject f) ≅ CategoryTheory.Limits.image f

full_name: CategoryTheory.Limits.imageSubobject_arrow
code: @[reassoc (attr := simp)]
theorem imageSubobject_arrow :
    (imageSubobjectIso f).hom ≫ image.ι f = (imageSubobject f).arrow 
goal: (CategoryTheory.Limits.imageSubobjectIso f).hom ≫ CategoryTheory.Limits.image.ι f =
  (CategoryTheory.Limits.imageSubobject f).arrow

full_name: CategoryTheory.Limits.imageSubobject_arrow'
code: @[reassoc (attr := simp)]
theorem imageSubobject_arrow' :
    (imageSubobjectIso f).inv ≫ (imageSubobject f).arrow = image.ι f 
goal: (CategoryTheory.Limits.imageSubobjectIso f).inv ≫ (CategoryTheory.Limits.imageSubobject f).arrow =
  CategoryTheory.Limits.image.ι f

full_name: CategoryTheory.Limits.factorThruImageSubobject
code: /-- A factorisation of `f : X ⟶ Y` through `imageSubobject f`. -/
def factorThruImageSubobject : X ⟶ imageSubobject f 
goal: X ⟶ CategoryTheory.Subobject.underlying.obj (CategoryTheory.Limits.imageSubobject f)

full_name: CategoryTheory.Limits.instEpiFactorThruImageSubobjectOfHasEqualizers
code: instance [HasEqualizers C] : Epi (factorThruImageSubobject f) 
goal: CategoryTheory.Epi (CategoryTheory.Limits.factorThruImageSubobject f)

full_name: CategoryTheory.Limits.imageSubobject_arrow_comp
code: @[reassoc (attr := simp), elementwise (attr := simp)]
theorem imageSubobject_arrow_comp : factorThruImageSubobject f ≫ (imageSubobject f).arrow = f 
goal: CategoryTheory.Limits.factorThruImageSubobject f ≫ (CategoryTheory.Limits.imageSubobject f).arrow = f

full_name: CategoryTheory.Limits.imageSubobject_arrow_comp_eq_zero
code: theorem imageSubobject_arrow_comp_eq_zero [HasZeroMorphisms C] {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z}
    [HasImage f] [Epi (factorThruImageSubobject f)] (h : f ≫ g = 0) :
    (imageSubobject f).arrow ≫ g = 0 
goal: (CategoryTheory.Limits.imageSubobject f).arrow ≫ g = 0

full_name: CategoryTheory.Limits.imageSubobject_factors_comp_self
code: theorem imageSubobject_factors_comp_self {W : C} (k : W ⟶ X) : (imageSubobject f).Factors (k ≫ f) 
goal: (CategoryTheory.Limits.imageSubobject f).Factors (k ≫ f)

full_name: CategoryTheory.Limits.factorThruImageSubobject_comp_self
code: @[simp]
theorem factorThruImageSubobject_comp_self {W : C} (k : W ⟶ X) (h) :
    (imageSubobject f).factorThru (k ≫ f) h = k ≫ factorThruImageSubobject f 
goal: (CategoryTheory.Limits.imageSubobject f).factorThru (k ≫ f) h = k ≫ CategoryTheory.Limits.factorThruImageSubobject f

full_name: CategoryTheory.Limits.factorThruImageSubobject_comp_self_assoc
code: @[simp]
theorem factorThruImageSubobject_comp_self_assoc {W W' : C} (k : W ⟶ W') (k' : W' ⟶ X) (h) :
    (imageSubobject f).factorThru (k ≫ k' ≫ f) h = k ≫ k' ≫ factorThruImageSubobject f 
goal: (CategoryTheory.Limits.imageSubobject f).factorThru (k ≫ k' ≫ f) h =
  k ≫ k' ≫ CategoryTheory.Limits.factorThruImageSubobject f

full_name: CategoryTheory.Limits.imageSubobject_comp_le
code: /-- The image of `h ≫ f` is always a smaller subobject than the image of `f`. -/
theorem imageSubobject_comp_le {X' : C} (h : X' ⟶ X) (f : X ⟶ Y) [HasImage f] [HasImage (h ≫ f)] :
    imageSubobject (h ≫ f) ≤ imageSubobject f 
goal: CategoryTheory.Limits.imageSubobject (h ≫ f) ≤ CategoryTheory.Limits.imageSubobject f

full_name: CategoryTheory.Limits.imageSubobject_zero_arrow
code: @[simp]
theorem imageSubobject_zero_arrow : (imageSubobject (0 : X ⟶ Y)).arrow = 0 
goal: (CategoryTheory.Limits.imageSubobject 0).arrow = 0

full_name: CategoryTheory.Limits.imageSubobject_zero
code: @[simp]
theorem imageSubobject_zero {A B : C} : imageSubobject (0 : A ⟶ B) = ⊥ 
goal: CategoryTheory.Limits.imageSubobject 0 = ⊥

full_name: CategoryTheory.Limits.imageSubobject_comp_le_epi_of_epi
code: /-- The morphism `imageSubobject (h ≫ f) ⟶ imageSubobject f`
is an epimorphism when `h` is an epimorphism.
In general this does not imply that `imageSubobject (h ≫ f) = imageSubobject f`,
although it will when the ambient category is abelian.
 -/
instance imageSubobject_comp_le_epi_of_epi {X' : C} (h : X' ⟶ X) [Epi h] (f : X ⟶ Y) [HasImage f]
    [HasImage (h ≫ f)] : Epi (Subobject.ofLE _ _ (imageSubobject_comp_le h f)) 
goal: CategoryTheory.Epi ((CategoryTheory.Limits.imageSubobject (h ≫ f)).ofLE (CategoryTheory.Limits.imageSubobject f) ⋯)

full_name: CategoryTheory.Limits.imageSubobjectCompIso
code: /-- Postcomposing by an isomorphism gives an isomorphism between image subobjects. -/
def imageSubobjectCompIso (f : X ⟶ Y) [HasImage f] {Y' : C} (h : Y ⟶ Y') [IsIso h] :
    (imageSubobject (f ≫ h) : C) ≅ (imageSubobject f : C) 
goal: CategoryTheory.Subobject.underlying.obj (CategoryTheory.Limits.imageSubobject (f ≫ h)) ≅
  CategoryTheory.Subobject.underlying.obj (CategoryTheory.Limits.imageSubobject f)

full_name: CategoryTheory.Limits.imageSubobjectCompIso_hom_arrow
code: @[reassoc (attr := simp)]
theorem imageSubobjectCompIso_hom_arrow (f : X ⟶ Y) [HasImage f] {Y' : C} (h : Y ⟶ Y') [IsIso h] :
    (imageSubobjectCompIso f h).hom ≫ (imageSubobject f).arrow =
      (imageSubobject (f ≫ h)).arrow ≫ inv h 
goal: (CategoryTheory.Limits.imageSubobjectCompIso f h).hom ≫ (CategoryTheory.Limits.imageSubobject f).arrow =
  (CategoryTheory.Limits.imageSubobject (f ≫ h)).arrow ≫ CategoryTheory.inv h

full_name: CategoryTheory.Limits.imageSubobjectCompIso_inv_arrow
code: @[reassoc (attr := simp)]
theorem imageSubobjectCompIso_inv_arrow (f : X ⟶ Y) [HasImage f] {Y' : C} (h : Y ⟶ Y') [IsIso h] :
    (imageSubobjectCompIso f h).inv ≫ (imageSubobject (f ≫ h)).arrow =
      (imageSubobject f).arrow ≫ h 
goal: (CategoryTheory.Limits.imageSubobjectCompIso f h).inv ≫ (CategoryTheory.Limits.imageSubobject (f ≫ h)).arrow =
  (CategoryTheory.Limits.imageSubobject f).arrow ≫ h

full_name: CategoryTheory.Limits.imageSubobject_mono
code: theorem imageSubobject_mono (f : X ⟶ Y) [Mono f] : imageSubobject f = Subobject.mk f 
goal: CategoryTheory.Limits.imageSubobject f = CategoryTheory.Subobject.mk f

full_name: CategoryTheory.Limits.imageSubobject_iso_comp
code: /-- Precomposing by an isomorphism does not change the image subobject. -/
theorem imageSubobject_iso_comp [HasEqualizers C] {X' : C} (h : X' ⟶ X) [IsIso h] (f : X ⟶ Y)
    [HasImage f] : imageSubobject (h ≫ f) = imageSubobject f 
goal: CategoryTheory.Limits.imageSubobject (h ≫ f) = CategoryTheory.Limits.imageSubobject f

full_name: CategoryTheory.Limits.imageSubobject_le
code: theorem imageSubobject_le {A B : C} {X : Subobject B} (f : A ⟶ B) [HasImage f] (h : A ⟶ X)
    (w : h ≫ X.arrow = f) : imageSubobject f ≤ X 
goal: CategoryTheory.Limits.imageSubobject f ≤ X

full_name: CategoryTheory.Limits.imageSubobject_le_mk
code: theorem imageSubobject_le_mk {A B : C} {X : C} (g : X ⟶ B) [Mono g] (f : A ⟶ B) [HasImage f]
    (h : A ⟶ X) (w : h ≫ g = f) : imageSubobject f ≤ Subobject.mk g 
goal: CategoryTheory.Limits.imageSubobject f ≤ CategoryTheory.Subobject.mk g

full_name: CategoryTheory.Limits.imageSubobjectMap
code: /-- Given a commutative square between morphisms `f` and `g`,
we have a morphism in the category from `imageSubobject f` to `imageSubobject g`. -/
def imageSubobjectMap {W X Y Z : C} {f : W ⟶ X} [HasImage f] {g : Y ⟶ Z} [HasImage g]
    (sq : Arrow.mk f ⟶ Arrow.mk g) [HasImageMap sq] :
    (imageSubobject f : C) ⟶ (imageSubobject g : C) 
goal: CategoryTheory.Subobject.underlying.obj (CategoryTheory.Limits.imageSubobject f) ⟶
  CategoryTheory.Subobject.underlying.obj (CategoryTheory.Limits.imageSubobject g)

full_name: CategoryTheory.Limits.imageSubobjectMap_arrow
code: @[reassoc (attr := simp)]
theorem imageSubobjectMap_arrow {W X Y Z : C} {f : W ⟶ X} [HasImage f] {g : Y ⟶ Z} [HasImage g]
    (sq : Arrow.mk f ⟶ Arrow.mk g) [HasImageMap sq] :
    imageSubobjectMap sq ≫ (imageSubobject g).arrow = (imageSubobject f).arrow ≫ sq.right 
goal: CategoryTheory.Limits.imageSubobjectMap sq ≫ (CategoryTheory.Limits.imageSubobject g).arrow =
  (CategoryTheory.Limits.imageSubobject f).arrow ≫ sq.right

full_name: CategoryTheory.Limits.image_map_comp_imageSubobjectIso_inv
code: theorem image_map_comp_imageSubobjectIso_inv {W X Y Z : C} {f : W ⟶ X} [HasImage f] {g : Y ⟶ Z}
    [HasImage g] (sq : Arrow.mk f ⟶ Arrow.mk g) [HasImageMap sq] :
    image.map sq ≫ (imageSubobjectIso _).inv =
      (imageSubobjectIso _).inv ≫ imageSubobjectMap sq 
goal: CategoryTheory.Limits.image.map sq ≫ (CategoryTheory.Limits.imageSubobjectIso (CategoryTheory.Arrow.mk g).hom).inv =
  (CategoryTheory.Limits.imageSubobjectIso f).inv ≫ CategoryTheory.Limits.imageSubobjectMap sq

full_name: CategoryTheory.Limits.imageSubobjectIso_comp_image_map
code: theorem imageSubobjectIso_comp_image_map {W X Y Z : C} {f : W ⟶ X} [HasImage f] {g : Y ⟶ Z}
    [HasImage g] (sq : Arrow.mk f ⟶ Arrow.mk g) [HasImageMap sq] :
    (imageSubobjectIso _).hom ≫ image.map sq =
      imageSubobjectMap sq ≫ (imageSubobjectIso _).hom 
goal: (CategoryTheory.Limits.imageSubobjectIso (CategoryTheory.Arrow.mk f).hom).hom ≫ CategoryTheory.Limits.image.map sq =
  CategoryTheory.Limits.imageSubobjectMap sq ≫ (CategoryTheory.Limits.imageSubobjectIso g).hom