ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Subobject.lowerEquivalence_functor
@[simps]
def lowerEquivalence {A : C} {B : D} (e : MonoOver A ≌ MonoOver B) : Subobject A ≌ Subobject B 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {A : C} {B : D} (e : CategoryTheory.MonoOver A ≌ CategoryTheory.MonoOver B)
Goal: (CategoryTheory.Subobject.lowerEquivalence e).functor = CategoryTheory.Subobject.lower e.functor
-- CategoryTheory.Subobject.pullback_id
theorem pullback_id (x : Subobject X) : (pullback (𝟙 X)).obj x = x 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} [CategoryTheory.Limits.HasPullbacks C] (x : CategoryTheory.Subobject X)
Goal: (CategoryTheory.Subobject.pullback (CategoryTheory.CategoryStruct.id X)).obj x = x
-- CategoryTheory.Subobject.pullback_comp
theorem pullback_comp (f : X ⟶ Y) (g : Y ⟶ Z) (x : Subobject Z) :
    (pullback (f ≫ g)).obj x = (pullback f).obj ((pullback g).obj x) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} [CategoryTheory.Limits.HasPullbacks C] (f : X ⟶ Y) (g : Y ⟶ Z) (x : CategoryTheory.Subobject Z)
Goal: (CategoryTheory.Subobject.pullback (CategoryTheory.CategoryStruct.comp f g)).obj x =
  (CategoryTheory.Subobject.pullback f).obj ((CategoryTheory.Subobject.pullback g).obj x)
-- CategoryTheory.Subobject.map_id
theorem map_id (x : Subobject X) : (map (𝟙 X)).obj x = x 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} (x : CategoryTheory.Subobject X)
Goal: (CategoryTheory.Subobject.map (CategoryTheory.CategoryStruct.id X)).obj x = x
-- CategoryTheory.Subobject.map_comp
theorem map_comp (f : X ⟶ Y) (g : Y ⟶ Z) [Mono f] [Mono g] (x : Subobject X) :
    (map (f ≫ g)).obj x = (map g).obj ((map f).obj x) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) [CategoryTheory.Mono f] [CategoryTheory.Mono g] (x : CategoryTheory.Subobject X)
Goal: (CategoryTheory.Subobject.map (CategoryTheory.CategoryStruct.comp f g)).obj x =
  (CategoryTheory.Subobject.map g).obj ((CategoryTheory.Subobject.map f).obj x)
-- CategoryTheory.Subobject.mapIsoToOrderIso_apply
@[simp]
theorem mapIsoToOrderIso_apply (e : X ≅ Y) (P : Subobject X) :
    mapIsoToOrderIso e P = (map e.hom).obj P 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (e : X ≅ Y) (P : CategoryTheory.Subobject X)
Goal: (CategoryTheory.Subobject.mapIsoToOrderIso e) P = (CategoryTheory.Subobject.map e.hom).obj P
-- CategoryTheory.Subobject.mapIsoToOrderIso_symm_apply
@[simp]
theorem mapIsoToOrderIso_symm_apply (e : X ≅ Y) (Q : Subobject Y) :
    (mapIsoToOrderIso e).symm Q = (map e.inv).obj Q 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (e : X ≅ Y) (Q : CategoryTheory.Subobject Y)
Goal: (CategoryTheory.Subobject.mapIsoToOrderIso e).symm Q = (CategoryTheory.Subobject.map e.inv).obj Q
-- CategoryTheory.Subobject.pullback_map_self
@[simp]
theorem pullback_map_self [HasPullbacks C] (f : X ⟶ Y) [Mono f] (g : Subobject X) :
    (pullback f).obj ((map f).obj g) = g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} [CategoryTheory.Limits.HasPullbacks C] (f : X ⟶ Y) [CategoryTheory.Mono f] (g : CategoryTheory.Subobject X)
Goal: (CategoryTheory.Subobject.pullback f).obj ((CategoryTheory.Subobject.map f).obj g) = g
-- CategoryTheory.Subobject.map_pullback
theorem map_pullback [HasPullbacks C] {X Y Z W : C} {f : X ⟶ Y} {g : X ⟶ Z} {h : Y ⟶ W} {k : Z ⟶ W}
    [Mono h] [Mono g] (comm : f ≫ h = g ≫ k) (t : IsLimit (PullbackCone.mk f g comm))
    (p : Subobject Y) : (map g).obj ((pullback f).obj p) = (pullback k).obj ((map h).obj p) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasPullbacks C] {X Y Z W : C} {f : X ⟶ Y} {g : X ⟶ Z} {h : Y ⟶ W} {k : Z ⟶ W} [CategoryTheory.Mono h] [CategoryTheory.Mono g] (comm : CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g k) (t : CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.PullbackCone.mk f g comm)) (p : CategoryTheory.Subobject Y)
Goal: (CategoryTheory.Subobject.map g).obj ((CategoryTheory.Subobject.pullback f).obj p) =
  (CategoryTheory.Subobject.pullback k).obj ((CategoryTheory.Subobject.map h).obj p)
-- CategoryTheory.Subobject.exists_iso_map
theorem exists_iso_map (f : X ⟶ Y) [Mono f] : «exists» f = map f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} [CategoryTheory.Limits.HasImages C] (f : X ⟶ Y) [CategoryTheory.Mono f]
Goal: CategoryTheory.Subobject.exists f = CategoryTheory.Subobject.map f
-- subtype_val_mono
theorem subtype_val_mono {α : Type u} (s : Set α) : Mono (↾(Subtype.val : s → α)) 
Arguments: {α : Type u} (s : Set α)
Goal: CategoryTheory.Mono (↾Subtype.val)
-- Types.monoOverEquivalenceSet_inverse_obj
@[simps]
noncomputable def Types.monoOverEquivalenceSet (α : Type u) : MonoOver α ≌ Set α 
Arguments: (α : Type u) (s : Set α)
Goal: (Types.monoOverEquivalenceSet α).inverse.obj s = CategoryTheory.MonoOver.mk' Subtype.val
-- Types.monoOverEquivalenceSet_functor_map
@[simps]
noncomputable def Types.monoOverEquivalenceSet (α : Type u) : MonoOver α ≌ Set α 
Arguments: (α : Type u) {f g : CategoryTheory.MonoOver α} (t : f ⟶ g)
Goal: (Types.monoOverEquivalenceSet α).functor.map t = CategoryTheory.homOfLE ⋯
-- Types.monoOverEquivalenceSet_inverse_map
@[simps]
noncomputable def Types.monoOverEquivalenceSet (α : Type u) : MonoOver α ≌ Set α 
Arguments: (α : Type u) {s t : Set α} (b : s ⟶ t)
Goal: (Types.monoOverEquivalenceSet α).inverse.map b = CategoryTheory.MonoOver.homMk (fun w => ⟨↑w, ⋯⟩) ⋯
-- Types.monoOverEquivalenceSet_counitIso
@[simps]
noncomputable def Types.monoOverEquivalenceSet (α : Type u) : MonoOver α ≌ Set α 
Arguments: (α : Type u)
Goal: (Types.monoOverEquivalenceSet α).counitIso = CategoryTheory.NatIso.ofComponents (fun s => CategoryTheory.eqToIso ⋯) ⋯
-- Types.monoOverEquivalenceSet_unitIso
@[simps]
noncomputable def Types.monoOverEquivalenceSet (α : Type u) : MonoOver α ≌ Set α 
Arguments: (α : Type u)
Goal: (Types.monoOverEquivalenceSet α).unitIso =
  CategoryTheory.NatIso.ofComponents (fun f => CategoryTheory.MonoOver.isoMk (Equiv.ofInjective f.obj.hom ⋯).toIso ⋯) ⋯
-- Types.monoOverEquivalenceSet_functor_obj
@[simps]
noncomputable def Types.monoOverEquivalenceSet (α : Type u) : MonoOver α ≌ Set α 
Arguments: (α : Type u) (f : CategoryTheory.MonoOver α)
Goal: (Types.monoOverEquivalenceSet α).functor.obj f = Set.range f.obj.hom
-- CategoryTheory.Limits.equalizerSubobject_arrow
@[reassoc (attr := simp)]
theorem equalizerSubobject_arrow :
    (equalizerSubobjectIso f g).hom ≫ equalizer.ι f g = (equalizerSubobject f g).arrow 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ⟶ Y) [CategoryTheory.Limits.HasEqualizer f g]
Goal: (CategoryTheory.Limits.equalizerSubobjectIso f g).hom ≫ CategoryTheory.Limits.equalizer.ι f g =
  (CategoryTheory.Limits.equalizerSubobject f g).arrow
-- CategoryTheory.Limits.equalizerSubobject_arrow'
@[reassoc (attr := simp)]
theorem equalizerSubobject_arrow' :
    (equalizerSubobjectIso f g).inv ≫ (equalizerSubobject f g).arrow = equalizer.ι f g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ⟶ Y) [CategoryTheory.Limits.HasEqualizer f g]
Goal: (CategoryTheory.Limits.equalizerSubobjectIso f g).inv ≫ (CategoryTheory.Limits.equalizerSubobject f g).arrow =
  CategoryTheory.Limits.equalizer.ι f g
-- CategoryTheory.Limits.equalizerSubobject_arrow_comp
@[reassoc]
theorem equalizerSubobject_arrow_comp :
    (equalizerSubobject f g).arrow ≫ f = (equalizerSubobject f g).arrow ≫ g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ⟶ Y) [CategoryTheory.Limits.HasEqualizer f g]
Goal: (CategoryTheory.Limits.equalizerSubobject f g).arrow ≫ f = (CategoryTheory.Limits.equalizerSubobject f g).arrow ≫ g
-- CategoryTheory.Limits.equalizerSubobject_factors
theorem equalizerSubobject_factors {W : C} (h : W ⟶ X) (w : h ≫ f = h ≫ g) :
    (equalizerSubobject f g).Factors h 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ⟶ Y) [CategoryTheory.Limits.HasEqualizer f g] {W : C} (h : W ⟶ X) (w : h ≫ f = h ≫ g)
Goal: (CategoryTheory.Limits.equalizerSubobject f g).Factors h
-- CategoryTheory.Limits.equalizerSubobject_factors_iff
theorem equalizerSubobject_factors_iff {W : C} (h : W ⟶ X) :
    (equalizerSubobject f g).Factors h ↔ h ≫ f = h ≫ g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ⟶ Y) [CategoryTheory.Limits.HasEqualizer f g] {W : C} (h : W ⟶ X)
Goal: (CategoryTheory.Limits.equalizerSubobject f g).Factors h ↔ h ≫ f = h ≫ g
-- CategoryTheory.Limits.kernelSubobject_arrow
@[reassoc (attr := simp), elementwise (attr := simp)]
theorem kernelSubobject_arrow :
    (kernelSubobjectIso f).hom ≫ kernel.ι f = (kernelSubobject f).arrow 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} [CategoryTheory.Limits.HasZeroMorphisms C] (f : X ⟶ Y) [CategoryTheory.Limits.HasKernel f]
Goal: (CategoryTheory.Limits.kernelSubobjectIso f).hom ≫ CategoryTheory.Limits.kernel.ι f =
  (CategoryTheory.Limits.kernelSubobject f).arrow
-- CategoryTheory.Limits.kernelSubobject_arrow'
@[reassoc (attr := simp), elementwise (attr := simp)]
theorem kernelSubobject_arrow' :
    (kernelSubobjectIso f).inv ≫ (kernelSubobject f).arrow = kernel.ι f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} [CategoryTheory.Limits.HasZeroMorphisms C] (f : X ⟶ Y) [CategoryTheory.Limits.HasKernel f]
Goal: (CategoryTheory.Limits.kernelSubobjectIso f).inv ≫ (CategoryTheory.Limits.kernelSubobject f).arrow =
  CategoryTheory.Limits.kernel.ι f
-- CategoryTheory.Limits.kernelSubobject_arrow_comp
@[reassoc (attr := simp), elementwise (attr := simp)]
theorem kernelSubobject_arrow_comp : (kernelSubobject f).arrow ≫ f = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} [CategoryTheory.Limits.HasZeroMorphisms C] (f : X ⟶ Y) [CategoryTheory.Limits.HasKernel f]
Goal: (CategoryTheory.Limits.kernelSubobject f).arrow ≫ f = 0
-- CategoryTheory.Limits.kernelSubobject_factors
theorem kernelSubobject_factors {W : C} (h : W ⟶ X) (w : h ≫ f = 0) :
    (kernelSubobject f).Factors h 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} [CategoryTheory.Limits.HasZeroMorphisms C] (f : X ⟶ Y) [CategoryTheory.Limits.HasKernel f] {W : C} (h : W ⟶ X) (w : h ≫ f = 0)
Goal: (CategoryTheory.Limits.kernelSubobject f).Factors h
-- CategoryTheory.Limits.kernelSubobject_factors_iff
theorem kernelSubobject_factors_iff {W : C} (h : W ⟶ X) :
    (kernelSubobject f).Factors h ↔ h ≫ f = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} [CategoryTheory.Limits.HasZeroMorphisms C] (f : X ⟶ Y) [CategoryTheory.Limits.HasKernel f] {W : C} (h : W ⟶ X)
Goal: (CategoryTheory.Limits.kernelSubobject f).Factors h ↔ h ≫ f = 0
-- CategoryTheory.Limits.factorThruKernelSubobject_comp_arrow
@[simp]
theorem factorThruKernelSubobject_comp_arrow {W : C} (h : W ⟶ X) (w : h ≫ f = 0) :
    factorThruKernelSubobject f h w ≫ (kernelSubobject f).arrow = h 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} [CategoryTheory.Limits.HasZeroMorphisms C] (f : X ⟶ Y) [CategoryTheory.Limits.HasKernel f] {W : C} (h : W ⟶ X) (w : h ≫ f = 0)
Goal: CategoryTheory.Limits.factorThruKernelSubobject f h w ≫ (CategoryTheory.Limits.kernelSubobject f).arrow = h
-- CategoryTheory.Limits.factorThruKernelSubobject_comp_kernelSubobjectIso
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} [CategoryTheory.Limits.HasZeroMorphisms C] (f : X ⟶ Y) [CategoryTheory.Limits.HasKernel f] {W : C} (h : W ⟶ X) (w : h ≫ f = 0)
Goal: CategoryTheory.Limits.factorThruKernelSubobject f h w ≫ (CategoryTheory.Limits.kernelSubobjectIso f).hom =
  CategoryTheory.Limits.kernel.lift f h w
-- CategoryTheory.Limits.kernelSubobjectMap_arrow
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} [CategoryTheory.Limits.HasZeroMorphisms C] {f : X ⟶ Y} [CategoryTheory.Limits.HasKernel f] {X' Y' : C} {f' : X' ⟶ Y'} [CategoryTheory.Limits.HasKernel f'] (sq : CategoryTheory.Arrow.mk f ⟶ CategoryTheory.Arrow.mk f')
Goal: CategoryTheory.Limits.kernelSubobjectMap sq ≫ (CategoryTheory.Limits.kernelSubobject f').arrow =
  (CategoryTheory.Limits.kernelSubobject f).arrow ≫ sq.left
-- CategoryTheory.Limits.kernelSubobjectMap_id
@[simp]
theorem kernelSubobjectMap_id : kernelSubobjectMap (𝟙 (Arrow.mk f)) = 𝟙 _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} [CategoryTheory.Limits.HasZeroMorphisms C] {f : X ⟶ Y} [CategoryTheory.Limits.HasKernel f]
Goal: CategoryTheory.Limits.kernelSubobjectMap (𝟙 (CategoryTheory.Arrow.mk f)) =
  𝟙 (CategoryTheory.Subobject.underlying.obj (CategoryTheory.Limits.kernelSubobject f))
-- CategoryTheory.Limits.kernelSubobjectMap_comp
@[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' 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} [CategoryTheory.Limits.HasZeroMorphisms C] {f : X ⟶ Y} [CategoryTheory.Limits.HasKernel f] {X' Y' : C} {f' : X' ⟶ Y'} [CategoryTheory.Limits.HasKernel f'] {X'' Y'' : C} {f'' : X'' ⟶ Y''} [CategoryTheory.Limits.HasKernel f''] (sq : CategoryTheory.Arrow.mk f ⟶ CategoryTheory.Arrow.mk f') (sq' : CategoryTheory.Arrow.mk f' ⟶ CategoryTheory.Arrow.mk f'')
Goal: CategoryTheory.Limits.kernelSubobjectMap (sq ≫ sq') =
  CategoryTheory.Limits.kernelSubobjectMap sq ≫ CategoryTheory.Limits.kernelSubobjectMap sq'
-- CategoryTheory.Limits.kernel_map_comp_kernelSubobjectIso_inv
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} [CategoryTheory.Limits.HasZeroMorphisms C] {f : X ⟶ Y} [CategoryTheory.Limits.HasKernel f] {X' Y' : C} {f' : X' ⟶ Y'} [CategoryTheory.Limits.HasKernel f'] (sq : CategoryTheory.Arrow.mk f ⟶ CategoryTheory.Arrow.mk f')
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
-- CategoryTheory.Limits.kernelSubobjectIso_comp_kernel_map
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} [CategoryTheory.Limits.HasZeroMorphisms C] {f : X ⟶ Y} [CategoryTheory.Limits.HasKernel f] {X' Y' : C} {f' : X' ⟶ Y'} [CategoryTheory.Limits.HasKernel f'] (sq : CategoryTheory.Arrow.mk f ⟶ CategoryTheory.Arrow.mk f')
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
-- CategoryTheory.Limits.kernelSubobject_zero
@[simp]
theorem kernelSubobject_zero {A B : C} : kernelSubobject (0 : A ⟶ B) = ⊤ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {A B : C}
Goal: CategoryTheory.Limits.kernelSubobject 0 = ⊤
-- CategoryTheory.Limits.le_kernelSubobject
theorem le_kernelSubobject (A : Subobject X) (h : A.arrow ≫ f = 0) : A ≤ kernelSubobject f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} [CategoryTheory.Limits.HasZeroMorphisms C] (f : X ⟶ Y) [CategoryTheory.Limits.HasKernel f] (A : CategoryTheory.Subobject X) (h : A.arrow ≫ f = 0)
Goal: A ≤ CategoryTheory.Limits.kernelSubobject f
-- CategoryTheory.Limits.kernelSubobjectIsoComp_hom_arrow
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} [CategoryTheory.Limits.HasZeroMorphisms C] {X' : C} (f : X' ⟶ X) [CategoryTheory.IsIso f] (g : X ⟶ Y) [CategoryTheory.Limits.HasKernel g]
Goal: (CategoryTheory.Limits.kernelSubobjectIsoComp f g).hom ≫ (CategoryTheory.Limits.kernelSubobject g).arrow =
  (CategoryTheory.Limits.kernelSubobject (f ≫ g)).arrow ≫ f
-- CategoryTheory.Limits.kernelSubobjectIsoComp_inv_arrow
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} [CategoryTheory.Limits.HasZeroMorphisms C] {X' : C} (f : X' ⟶ X) [CategoryTheory.IsIso f] (g : X ⟶ Y) [CategoryTheory.Limits.HasKernel g]
Goal: (CategoryTheory.Limits.kernelSubobjectIsoComp f g).inv ≫ (CategoryTheory.Limits.kernelSubobject (f ≫ g)).arrow =
  (CategoryTheory.Limits.kernelSubobject g).arrow ≫ CategoryTheory.inv f
-- CategoryTheory.Limits.kernelSubobject_comp_le
theorem kernelSubobject_comp_le (f : X ⟶ Y) [HasKernel f] {Z : C} (h : Y ⟶ Z) [HasKernel (f ≫ h)] :
    kernelSubobject f ≤ kernelSubobject (f ≫ h) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} [CategoryTheory.Limits.HasZeroMorphisms C] (f : X ⟶ Y) [CategoryTheory.Limits.HasKernel f] {Z : C} (h : Y ⟶ Z) [CategoryTheory.Limits.HasKernel (f ≫ h)]
Goal: CategoryTheory.Limits.kernelSubobject f ≤ CategoryTheory.Limits.kernelSubobject (f ≫ h)
-- CategoryTheory.Limits.kernelSubobject_comp_mono
@[simp]
theorem kernelSubobject_comp_mono (f : X ⟶ Y) [HasKernel f] {Z : C} (h : Y ⟶ Z) [Mono h] :
    kernelSubobject (f ≫ h) = kernelSubobject f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} [CategoryTheory.Limits.HasZeroMorphisms C] (f : X ⟶ Y) [CategoryTheory.Limits.HasKernel f] {Z : C} (h : Y ⟶ Z) [CategoryTheory.Mono h]
Goal: CategoryTheory.Limits.kernelSubobject (f ≫ h) = CategoryTheory.Limits.kernelSubobject f
-- CategoryTheory.Limits.cokernelOrderHom_coe
@[simps]
def cokernelOrderHom [HasCokernels C] (X : C) : Subobject X →o (Subobject (op X))ᵒᵈ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.Limits.HasCokernels C] (X : C)
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
-- CategoryTheory.Limits.kernelOrderHom_coe
@[simps]
def kernelOrderHom [HasKernels C] (X : C) : (Subobject (op X))ᵒᵈ →o Subobject X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.Limits.HasKernels C] (X : C)
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
-- CategoryTheory.Limits.imageSubobject_arrow
@[reassoc (attr := simp)]
theorem imageSubobject_arrow :
    (imageSubobjectIso f).hom ≫ image.ι f = (imageSubobject f).arrow 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasImage f]
Goal: (CategoryTheory.Limits.imageSubobjectIso f).hom ≫ CategoryTheory.Limits.image.ι f =
  (CategoryTheory.Limits.imageSubobject f).arrow
-- CategoryTheory.Limits.imageSubobject_arrow'
@[reassoc (attr := simp)]
theorem imageSubobject_arrow' :
    (imageSubobjectIso f).inv ≫ (imageSubobject f).arrow = image.ι f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasImage f]
Goal: (CategoryTheory.Limits.imageSubobjectIso f).inv ≫ (CategoryTheory.Limits.imageSubobject f).arrow =
  CategoryTheory.Limits.image.ι f
-- CategoryTheory.Limits.imageSubobject_arrow_comp
@[reassoc (attr := simp), elementwise (attr := simp)]
theorem imageSubobject_arrow_comp : factorThruImageSubobject f ≫ (imageSubobject f).arrow = f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasImage f]
Goal: CategoryTheory.Limits.factorThruImageSubobject f ≫ (CategoryTheory.Limits.imageSubobject f).arrow = f
-- CategoryTheory.Limits.imageSubobject_arrow_comp_eq_zero
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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z} [CategoryTheory.Limits.HasImage f] [CategoryTheory.Epi (CategoryTheory.Limits.factorThruImageSubobject f)] (h : f ≫ g = 0)
Goal: (CategoryTheory.Limits.imageSubobject f).arrow ≫ g = 0
-- CategoryTheory.Limits.imageSubobject_factors_comp_self
theorem imageSubobject_factors_comp_self {W : C} (k : W ⟶ X) : (imageSubobject f).Factors (k ≫ f) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasImage f] {W : C} (k : W ⟶ X)
Goal: (CategoryTheory.Limits.imageSubobject f).Factors (k ≫ f)
-- CategoryTheory.Limits.factorThruImageSubobject_comp_self
@[simp]
theorem factorThruImageSubobject_comp_self {W : C} (k : W ⟶ X) (h) :
    (imageSubobject f).factorThru (k ≫ f) h = k ≫ factorThruImageSubobject f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasImage f] {W : C} (k : W ⟶ X) (h : (CategoryTheory.Limits.imageSubobject f).Factors (k ≫ f))
Goal: (CategoryTheory.Limits.imageSubobject f).factorThru (k ≫ f) h = k ≫ CategoryTheory.Limits.factorThruImageSubobject f
-- CategoryTheory.Limits.factorThruImageSubobject_comp_self_assoc
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasImage f] {W W' : C} (k : W ⟶ W') (k' : W' ⟶ X) (h : (CategoryTheory.Limits.imageSubobject f).Factors (k ≫ k' ≫ f))
Goal: (CategoryTheory.Limits.imageSubobject f).factorThru (k ≫ k' ≫ f) h =
  k ≫ k' ≫ CategoryTheory.Limits.factorThruImageSubobject f
-- CategoryTheory.Limits.imageSubobject_comp_le
theorem imageSubobject_comp_le {X' : C} (h : X' ⟶ X) (f : X ⟶ Y) [HasImage f] [HasImage (h ≫ f)] :
    imageSubobject (h ≫ f) ≤ imageSubobject f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y X' : C} (h : X' ⟶ X) (f : X ⟶ Y) [CategoryTheory.Limits.HasImage f] [CategoryTheory.Limits.HasImage (h ≫ f)]
Goal: CategoryTheory.Limits.imageSubobject (h ≫ f) ≤ CategoryTheory.Limits.imageSubobject f
-- CategoryTheory.Limits.imageSubobject_zero_arrow
@[simp]
theorem imageSubobject_zero_arrow : (imageSubobject (0 : X ⟶ Y)).arrow = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.Limits.HasZeroObject C]
Goal: (CategoryTheory.Limits.imageSubobject 0).arrow = 0
-- CategoryTheory.Limits.imageSubobject_zero
@[simp]
theorem imageSubobject_zero {A B : C} : imageSubobject (0 : A ⟶ B) = ⊥ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.Limits.HasZeroObject C] {A B : C}
Goal: CategoryTheory.Limits.imageSubobject 0 = ⊥