ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.MonoidalClosed.ofEquiv_curry_def
theorem ofEquiv_curry_def {X Y Z : C} (f : X ⊗ Y ⟶ Z) :
    letI := ofEquiv F adj
    MonoidalClosed.curry f =
      adj.homEquiv Y ((ihom (F.obj X)).obj (F.obj Z))
        (MonoidalClosed.curry (adj.toEquivalence.symm.toAdjunction.homEquiv (F.obj X ⊗ F.obj Y) Z
        ((Iso.compInverseIso (H := adj.toEquivalence)
          (MonoidalFunctor.commTensorLeft F X)).hom.app Y ≫ f))) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.MonoidalCategory C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] (F : CategoryTheory.MonoidalFunctor C D) {G : CategoryTheory.Functor D C} (adj : F.toFunctor ⊣ G) [F.IsEquivalence] [CategoryTheory.MonoidalClosed D] {X Y Z : C} (f : CategoryTheory.MonoidalCategory.tensorObj X Y ⟶ Z)
Goal: CategoryTheory.MonoidalClosed.curry f =
  (adj.homEquiv Y ((CategoryTheory.ihom (F.obj X)).obj (F.obj Z)))
    (CategoryTheory.MonoidalClosed.curry
      ((adj.toEquivalence.symm.toAdjunction.homEquiv (CategoryTheory.MonoidalCategory.tensorObj (F.obj X) (F.obj Y)) Z)
        (CategoryTheory.CategoryStruct.comp ((F.commTensorLeft X).compInverseIso.hom.app Y) f)))
-- CategoryTheory.MonoidalClosed.ofEquiv_uncurry_def
theorem ofEquiv_uncurry_def {X Y Z : C} :
    letI := ofEquiv F adj
    ∀ (f : Y ⟶ (ihom X).obj Z), MonoidalClosed.uncurry f =
      ((Iso.compInverseIso (H := adj.toEquivalence)
          (MonoidalFunctor.commTensorLeft F X)).inv.app Y) ≫
            (adj.toEquivalence.symm.toAdjunction.homEquiv _ _).symm
              (MonoidalClosed.uncurry ((adj.homEquiv _ _).symm f)) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.MonoidalCategory C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] (F : CategoryTheory.MonoidalFunctor C D) {G : CategoryTheory.Functor D C} (adj : F.toFunctor ⊣ G) [F.IsEquivalence] [CategoryTheory.MonoidalClosed D] {X Y Z : C} (f : Y ⟶ (CategoryTheory.ihom X).obj Z)
Goal: CategoryTheory.MonoidalClosed.uncurry f =
  CategoryTheory.CategoryStruct.comp ((F.commTensorLeft X).compInverseIso.inv.app Y)
    ((adj.toEquivalence.symm.toAdjunction.homEquiv
          ((F.comp (CategoryTheory.MonoidalCategory.tensorLeft (F.obj X))).obj Y) Z).symm
      (CategoryTheory.MonoidalClosed.uncurry
        ((adj.homEquiv Y ((CategoryTheory.ihom (F.obj X)).obj (adj.toEquivalence.symm.inverse.obj Z))).symm f)))
-- CategoryTheory.Subobject.ind
protected theorem ind {X : C} (p : Subobject X → Prop)
    (h : ∀ ⦃A : C⦄ (f : A ⟶ X) [Mono f], p (Subobject.mk f)) (P : Subobject X) : p P 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} (p : CategoryTheory.Subobject X → Prop) (h : ∀ ⦃A : C⦄ (f : A ⟶ X) [inst : CategoryTheory.Mono f], p (CategoryTheory.Subobject.mk f)) (P : CategoryTheory.Subobject X)
Goal: p P
-- CategoryTheory.Subobject.ind₂
protected theorem ind₂ {X : C} (p : Subobject X → Subobject X → Prop)
    (h : ∀ ⦃A B : C⦄ (f : A ⟶ X) (g : B ⟶ X) [Mono f] [Mono g],
      p (Subobject.mk f) (Subobject.mk g))
    (P Q : Subobject X) : p P Q 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} (p : CategoryTheory.Subobject X → CategoryTheory.Subobject X → Prop) (h :
  ∀ ⦃A B : C⦄ (f : A ⟶ X) (g : B ⟶ X) [inst : CategoryTheory.Mono f] [inst_1 : CategoryTheory.Mono g],
    p (CategoryTheory.Subobject.mk f) (CategoryTheory.Subobject.mk g)) (P Q : CategoryTheory.Subobject X)
Goal: p P Q
-- CategoryTheory.Subobject.lift_mk
@[simp]
protected theorem lift_mk {α : Sort*} {X : C} (F : ∀ ⦃A : C⦄ (f : A ⟶ X) [Mono f], α) {h A}
    (f : A ⟶ X) [Mono f] : Subobject.lift F h (Subobject.mk f) = F f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {α : Sort u_1} {X : C} (F : ⦃A : C⦄ → (f : A ⟶ X) → [inst : CategoryTheory.Mono f] → α) {h :
  ∀ ⦃A B : C⦄ (f : A ⟶ X) (g : B ⟶ X) [inst : CategoryTheory.Mono f] [inst_1 : CategoryTheory.Mono g] (i : A ≅ B),
    CategoryTheory.CategoryStruct.comp i.hom g = f → F f = F g} {A : C} (f : A ⟶ X) [CategoryTheory.Mono f]
Goal: CategoryTheory.Subobject.lift F h (CategoryTheory.Subobject.mk f) = F f
-- CategoryTheory.Subobject.arrow_congr
@[simp]
theorem arrow_congr {A : C} (X Y : Subobject A) (h : X = Y) :
    eqToHom (congr_arg (fun X : Subobject A => (X : C)) h) ≫ Y.arrow = X.arrow 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : C} (X Y : CategoryTheory.Subobject A) (h : X = Y)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯) Y.arrow = X.arrow
-- CategoryTheory.Subobject.representative_coe
@[simp]
theorem representative_coe (Y : Subobject X) : (representative.obj Y : C) = (Y : C) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} (Y : CategoryTheory.Subobject X)
Goal: (CategoryTheory.Subobject.representative.obj Y).obj.left = CategoryTheory.Subobject.underlying.obj Y
-- CategoryTheory.Subobject.representative_arrow
@[simp]
theorem representative_arrow (Y : Subobject X) : (representative.obj Y).arrow = Y.arrow 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} (Y : CategoryTheory.Subobject X)
Goal: (CategoryTheory.Subobject.representative.obj Y).arrow = Y.arrow
-- CategoryTheory.Subobject.underlying_arrow
@[reassoc (attr := simp)]
theorem underlying_arrow {X : C} {Y Z : Subobject X} (f : Y ⟶ Z) :
    underlying.map f ≫ arrow Z = arrow Y 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} {Y Z : CategoryTheory.Subobject X} (f : Y ⟶ Z)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Subobject.underlying.map f) Z.arrow = Y.arrow
-- CategoryTheory.Subobject.underlyingIso_arrow
@[reassoc (attr := simp), elementwise (attr := simp)]
theorem underlyingIso_arrow {X Y : C} (f : X ⟶ Y) [Mono f] :
    (underlyingIso f).inv ≫ (Subobject.mk f).arrow = f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Mono f]
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Subobject.underlyingIso f).inv
    (CategoryTheory.Subobject.mk f).arrow =
  f
-- CategoryTheory.Subobject.underlyingIso_hom_comp_eq_mk
@[reassoc (attr := simp)]
theorem underlyingIso_hom_comp_eq_mk {X Y : C} (f : X ⟶ Y) [Mono f] :
    (underlyingIso f).hom ≫ f = (mk f).arrow 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Mono f]
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Subobject.underlyingIso f).hom f =
  (CategoryTheory.Subobject.mk f).arrow
-- CategoryTheory.Subobject.eq_of_comp_arrow_eq
@[ext]
theorem eq_of_comp_arrow_eq {X Y : C} {P : Subobject Y} {f g : X ⟶ P}
    (h : f ≫ P.arrow = g ≫ P.arrow) : f = g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {P : CategoryTheory.Subobject Y} {f g : X ⟶ CategoryTheory.Subobject.underlying.obj P} (h : CategoryTheory.CategoryStruct.comp f P.arrow = CategoryTheory.CategoryStruct.comp g P.arrow)
Goal: f = g
-- CategoryTheory.Subobject.mk_le_mk_of_comm
theorem mk_le_mk_of_comm {B A₁ A₂ : C} {f₁ : A₁ ⟶ B} {f₂ : A₂ ⟶ B} [Mono f₁] [Mono f₂] (g : A₁ ⟶ A₂)
    (w : g ≫ f₂ = f₁) : mk f₁ ≤ mk f₂ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {B A₁ A₂ : C} {f₁ : A₁ ⟶ B} {f₂ : A₂ ⟶ B} [CategoryTheory.Mono f₁] [CategoryTheory.Mono f₂] (g : A₁ ⟶ A₂) (w : CategoryTheory.CategoryStruct.comp g f₂ = f₁)
Goal: CategoryTheory.Subobject.mk f₁ ≤ CategoryTheory.Subobject.mk f₂
-- CategoryTheory.Subobject.mk_arrow
@[simp]
theorem mk_arrow (P : Subobject X) : mk P.arrow = P 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} (P : CategoryTheory.Subobject X)
Goal: CategoryTheory.Subobject.mk P.arrow = P
-- CategoryTheory.Subobject.le_of_comm
theorem le_of_comm {B : C} {X Y : Subobject B} (f : (X : C) ⟶ (Y : C)) (w : f ≫ Y.arrow = X.arrow) :
    X ≤ Y 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {B : C} {X Y : CategoryTheory.Subobject B} (f : CategoryTheory.Subobject.underlying.obj X ⟶ CategoryTheory.Subobject.underlying.obj Y) (w : CategoryTheory.CategoryStruct.comp f Y.arrow = X.arrow)
Goal: X ≤ Y
-- CategoryTheory.Subobject.le_mk_of_comm
theorem le_mk_of_comm {B A : C} {X : Subobject B} {f : A ⟶ B} [Mono f] (g : (X : C) ⟶ A)
    (w : g ≫ f = X.arrow) : X ≤ mk f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {B A : C} {X : CategoryTheory.Subobject B} {f : A ⟶ B} [CategoryTheory.Mono f] (g : CategoryTheory.Subobject.underlying.obj X ⟶ A) (w : CategoryTheory.CategoryStruct.comp g f = X.arrow)
Goal: X ≤ CategoryTheory.Subobject.mk f
-- CategoryTheory.Subobject.mk_le_of_comm
theorem mk_le_of_comm {B A : C} {X : Subobject B} {f : A ⟶ B} [Mono f] (g : A ⟶ (X : C))
    (w : g ≫ X.arrow = f) : mk f ≤ X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {B A : C} {X : CategoryTheory.Subobject B} {f : A ⟶ B} [CategoryTheory.Mono f] (g : A ⟶ CategoryTheory.Subobject.underlying.obj X) (w : CategoryTheory.CategoryStruct.comp g X.arrow = f)
Goal: CategoryTheory.Subobject.mk f ≤ X
-- CategoryTheory.Subobject.eq_of_comm
@[ext]
theorem eq_of_comm {B : C} {X Y : Subobject B} (f : (X : C) ≅ (Y : C))
    (w : f.hom ≫ Y.arrow = X.arrow) : X = Y 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {B : C} {X Y : CategoryTheory.Subobject B} (f : CategoryTheory.Subobject.underlying.obj X ≅ CategoryTheory.Subobject.underlying.obj Y) (w : CategoryTheory.CategoryStruct.comp f.hom Y.arrow = X.arrow)
Goal: X = Y
-- CategoryTheory.Subobject.eq_mk_of_comm
theorem eq_mk_of_comm {B A : C} {X : Subobject B} (f : A ⟶ B) [Mono f] (i : (X : C) ≅ A)
    (w : i.hom ≫ f = X.arrow) : X = mk f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {B A : C} {X : CategoryTheory.Subobject B} (f : A ⟶ B) [CategoryTheory.Mono f] (i : CategoryTheory.Subobject.underlying.obj X ≅ A) (w : CategoryTheory.CategoryStruct.comp i.hom f = X.arrow)
Goal: X = CategoryTheory.Subobject.mk f
-- CategoryTheory.Subobject.mk_eq_of_comm
theorem mk_eq_of_comm {B A : C} {X : Subobject B} (f : A ⟶ B) [Mono f] (i : A ≅ (X : C))
    (w : i.hom ≫ X.arrow = f) : mk f = X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {B A : C} {X : CategoryTheory.Subobject B} (f : A ⟶ B) [CategoryTheory.Mono f] (i : A ≅ CategoryTheory.Subobject.underlying.obj X) (w : CategoryTheory.CategoryStruct.comp i.hom X.arrow = f)
Goal: CategoryTheory.Subobject.mk f = X
-- CategoryTheory.Subobject.mk_eq_mk_of_comm
theorem mk_eq_mk_of_comm {B A₁ A₂ : C} (f : A₁ ⟶ B) (g : A₂ ⟶ B) [Mono f] [Mono g] (i : A₁ ≅ A₂)
    (w : i.hom ≫ g = f) : mk f = mk g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {B A₁ A₂ : C} (f : A₁ ⟶ B) (g : A₂ ⟶ B) [CategoryTheory.Mono f] [CategoryTheory.Mono g] (i : A₁ ≅ A₂) (w : CategoryTheory.CategoryStruct.comp i.hom g = f)
Goal: CategoryTheory.Subobject.mk f = CategoryTheory.Subobject.mk g
-- CategoryTheory.Subobject.ofLE_arrow
@[reassoc (attr := simp)]
theorem ofLE_arrow {B : C} {X Y : Subobject B} (h : X ≤ Y) : ofLE X Y h ≫ Y.arrow = X.arrow 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {B : C} {X Y : CategoryTheory.Subobject B} (h : X ≤ Y)
Goal: CategoryTheory.CategoryStruct.comp (X.ofLE Y h) Y.arrow = X.arrow
-- CategoryTheory.Subobject.ofLE_mk_le_mk_of_comm
theorem ofLE_mk_le_mk_of_comm {B A₁ A₂ : C} {f₁ : A₁ ⟶ B} {f₂ : A₂ ⟶ B} [Mono f₁] [Mono f₂]
    (g : A₁ ⟶ A₂) (w : g ≫ f₂ = f₁) :
    ofLE _ _ (mk_le_mk_of_comm g w) = (underlyingIso _).hom ≫ g ≫ (underlyingIso _).inv 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {B A₁ A₂ : C} {f₁ : A₁ ⟶ B} {f₂ : A₂ ⟶ B} [CategoryTheory.Mono f₁] [CategoryTheory.Mono f₂] (g : A₁ ⟶ A₂) (w : CategoryTheory.CategoryStruct.comp g f₂ = f₁)
Goal: (CategoryTheory.Subobject.mk f₁).ofLE (CategoryTheory.Subobject.mk f₂) ⋯ =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Subobject.underlyingIso f₁).hom
    (CategoryTheory.CategoryStruct.comp g (CategoryTheory.Subobject.underlyingIso f₂).inv)
-- CategoryTheory.Subobject.ofLEMk_comp
@[simp]
theorem ofLEMk_comp {B A : C} {X : Subobject B} {f : A ⟶ B} [Mono f] (h : X ≤ mk f) :
    ofLEMk X f h ≫ f = X.arrow 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {B A : C} {X : CategoryTheory.Subobject B} {f : A ⟶ B} [CategoryTheory.Mono f] (h : X ≤ CategoryTheory.Subobject.mk f)
Goal: CategoryTheory.CategoryStruct.comp (X.ofLEMk f h) f = X.arrow
-- CategoryTheory.Subobject.ofMkLE_arrow
@[simp]
theorem ofMkLE_arrow {B A : C} {f : A ⟶ B} [Mono f] {X : Subobject B} (h : mk f ≤ X) :
    ofMkLE f X h ≫ X.arrow = f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {B A : C} {f : A ⟶ B} [CategoryTheory.Mono f] {X : CategoryTheory.Subobject B} (h : CategoryTheory.Subobject.mk f ≤ X)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Subobject.ofMkLE f X h) X.arrow = f
-- CategoryTheory.Subobject.ofMkLEMk_comp
@[simp]
theorem ofMkLEMk_comp {B A₁ A₂ : C} {f : A₁ ⟶ B} {g : A₂ ⟶ B} [Mono f] [Mono g] (h : mk f ≤ mk g) :
    ofMkLEMk f g h ≫ g = f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {B A₁ A₂ : C} {f : A₁ ⟶ B} {g : A₂ ⟶ B} [CategoryTheory.Mono f] [CategoryTheory.Mono g] (h : CategoryTheory.Subobject.mk f ≤ CategoryTheory.Subobject.mk g)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Subobject.ofMkLEMk f g h) g = f
-- CategoryTheory.Subobject.ofLE_comp_ofLE
@[reassoc (attr := simp)]
theorem ofLE_comp_ofLE {B : C} (X Y Z : Subobject B) (h₁ : X ≤ Y) (h₂ : Y ≤ Z) :
    ofLE X Y h₁ ≫ ofLE Y Z h₂ = ofLE X Z (h₁.trans h₂) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {B : C} (X Y Z : CategoryTheory.Subobject B) (h₁ : X ≤ Y) (h₂ : Y ≤ Z)
Goal: CategoryTheory.CategoryStruct.comp (X.ofLE Y h₁) (Y.ofLE Z h₂) = X.ofLE Z ⋯
-- CategoryTheory.Subobject.ofLE_comp_ofLEMk
@[reassoc (attr := simp)]
theorem ofLE_comp_ofLEMk {B A : C} (X Y : Subobject B) (f : A ⟶ B) [Mono f] (h₁ : X ≤ Y)
    (h₂ : Y ≤ mk f) : ofLE X Y h₁ ≫ ofLEMk Y f h₂ = ofLEMk X f (h₁.trans h₂) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {B A : C} (X Y : CategoryTheory.Subobject B) (f : A ⟶ B) [CategoryTheory.Mono f] (h₁ : X ≤ Y) (h₂ : Y ≤ CategoryTheory.Subobject.mk f)
Goal: CategoryTheory.CategoryStruct.comp (X.ofLE Y h₁) (Y.ofLEMk f h₂) = X.ofLEMk f ⋯
-- CategoryTheory.Subobject.ofLEMk_comp_ofMkLE
@[reassoc (attr := simp)]
theorem ofLEMk_comp_ofMkLE {B A : C} (X : Subobject B) (f : A ⟶ B) [Mono f] (Y : Subobject B)
    (h₁ : X ≤ mk f) (h₂ : mk f ≤ Y) : ofLEMk X f h₁ ≫ ofMkLE f Y h₂ = ofLE X Y (h₁.trans h₂) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {B A : C} (X : CategoryTheory.Subobject B) (f : A ⟶ B) [CategoryTheory.Mono f] (Y : CategoryTheory.Subobject B) (h₁ : X ≤ CategoryTheory.Subobject.mk f) (h₂ : CategoryTheory.Subobject.mk f ≤ Y)
Goal: CategoryTheory.CategoryStruct.comp (X.ofLEMk f h₁) (CategoryTheory.Subobject.ofMkLE f Y h₂) = X.ofLE Y ⋯
-- CategoryTheory.Subobject.ofLEMk_comp_ofMkLEMk
@[reassoc (attr := simp)]
theorem ofLEMk_comp_ofMkLEMk {B A₁ A₂ : C} (X : Subobject B) (f : A₁ ⟶ B) [Mono f] (g : A₂ ⟶ B)
    [Mono g] (h₁ : X ≤ mk f) (h₂ : mk f ≤ mk g) :
    ofLEMk X f h₁ ≫ ofMkLEMk f g h₂ = ofLEMk X g (h₁.trans h₂) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {B A₁ A₂ : C} (X : CategoryTheory.Subobject B) (f : A₁ ⟶ B) [CategoryTheory.Mono f] (g : A₂ ⟶ B) [CategoryTheory.Mono g] (h₁ : X ≤ CategoryTheory.Subobject.mk f) (h₂ : CategoryTheory.Subobject.mk f ≤ CategoryTheory.Subobject.mk g)
Goal: CategoryTheory.CategoryStruct.comp (X.ofLEMk f h₁) (CategoryTheory.Subobject.ofMkLEMk f g h₂) = X.ofLEMk g ⋯
-- CategoryTheory.Subobject.ofMkLE_comp_ofLE
@[reassoc (attr := simp)]
theorem ofMkLE_comp_ofLE {B A₁ : C} (f : A₁ ⟶ B) [Mono f] (X Y : Subobject B) (h₁ : mk f ≤ X)
    (h₂ : X ≤ Y) : ofMkLE f X h₁ ≫ ofLE X Y h₂ = ofMkLE f Y (h₁.trans h₂) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {B A₁ : C} (f : A₁ ⟶ B) [CategoryTheory.Mono f] (X Y : CategoryTheory.Subobject B) (h₁ : CategoryTheory.Subobject.mk f ≤ X) (h₂ : X ≤ Y)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Subobject.ofMkLE f X h₁) (X.ofLE Y h₂) =
  CategoryTheory.Subobject.ofMkLE f Y ⋯
-- CategoryTheory.Subobject.ofMkLE_comp_ofLEMk
@[reassoc (attr := simp)]
theorem ofMkLE_comp_ofLEMk {B A₁ A₂ : C} (f : A₁ ⟶ B) [Mono f] (X : Subobject B) (g : A₂ ⟶ B)
    [Mono g] (h₁ : mk f ≤ X) (h₂ : X ≤ mk g) :
    ofMkLE f X h₁ ≫ ofLEMk X g h₂ = ofMkLEMk f g (h₁.trans h₂) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {B A₁ A₂ : C} (f : A₁ ⟶ B) [CategoryTheory.Mono f] (X : CategoryTheory.Subobject B) (g : A₂ ⟶ B) [CategoryTheory.Mono g] (h₁ : CategoryTheory.Subobject.mk f ≤ X) (h₂ : X ≤ CategoryTheory.Subobject.mk g)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Subobject.ofMkLE f X h₁) (X.ofLEMk g h₂) =
  CategoryTheory.Subobject.ofMkLEMk f g ⋯
-- CategoryTheory.Subobject.ofMkLEMk_comp_ofMkLE
@[reassoc (attr := simp)]
theorem ofMkLEMk_comp_ofMkLE {B A₁ A₂ : C} (f : A₁ ⟶ B) [Mono f] (g : A₂ ⟶ B) [Mono g]
    (X : Subobject B) (h₁ : mk f ≤ mk g) (h₂ : mk g ≤ X) :
    ofMkLEMk f g h₁ ≫ ofMkLE g X h₂ = ofMkLE f X (h₁.trans h₂) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {B A₁ A₂ : C} (f : A₁ ⟶ B) [CategoryTheory.Mono f] (g : A₂ ⟶ B) [CategoryTheory.Mono g] (X : CategoryTheory.Subobject B) (h₁ : CategoryTheory.Subobject.mk f ≤ CategoryTheory.Subobject.mk g) (h₂ : CategoryTheory.Subobject.mk g ≤ X)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Subobject.ofMkLEMk f g h₁) (CategoryTheory.Subobject.ofMkLE g X h₂) =
  CategoryTheory.Subobject.ofMkLE f X ⋯
-- CategoryTheory.Subobject.ofMkLEMk_comp_ofMkLEMk
@[reassoc (attr := simp)]
theorem ofMkLEMk_comp_ofMkLEMk {B A₁ A₂ A₃ : C} (f : A₁ ⟶ B) [Mono f] (g : A₂ ⟶ B) [Mono g]
    (h : A₃ ⟶ B) [Mono h] (h₁ : mk f ≤ mk g) (h₂ : mk g ≤ mk h) :
    ofMkLEMk f g h₁ ≫ ofMkLEMk g h h₂ = ofMkLEMk f h (h₁.trans h₂) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {B A₁ A₂ A₃ : C} (f : A₁ ⟶ B) [CategoryTheory.Mono f] (g : A₂ ⟶ B) [CategoryTheory.Mono g] (h : A₃ ⟶ B) [CategoryTheory.Mono h] (h₁ : CategoryTheory.Subobject.mk f ≤ CategoryTheory.Subobject.mk g) (h₂ : CategoryTheory.Subobject.mk g ≤ CategoryTheory.Subobject.mk h)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Subobject.ofMkLEMk f g h₁)
    (CategoryTheory.Subobject.ofMkLEMk g h h₂) =
  CategoryTheory.Subobject.ofMkLEMk f h ⋯
-- CategoryTheory.Subobject.ofLE_refl
@[simp]
theorem ofLE_refl {B : C} (X : Subobject B) : ofLE X X le_rfl = 𝟙 _ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {B : C} (X : CategoryTheory.Subobject B)
Goal: X.ofLE X ⋯ = CategoryTheory.CategoryStruct.id (CategoryTheory.Subobject.underlying.obj X)
-- CategoryTheory.Subobject.ofMkLEMk_refl
@[simp]
theorem ofMkLEMk_refl {B A₁ : C} (f : A₁ ⟶ B) [Mono f] : ofMkLEMk f f le_rfl = 𝟙 _ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {B A₁ : C} (f : A₁ ⟶ B) [CategoryTheory.Mono f]
Goal: CategoryTheory.Subobject.ofMkLEMk f f ⋯ = CategoryTheory.CategoryStruct.id A₁
-- CategoryTheory.Subobject.isoOfEq_hom
@[simps]
def isoOfEq {B : C} (X Y : Subobject B) (h : X = Y) : (X : C) ≅ (Y : C) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {B : C} (X Y : CategoryTheory.Subobject B) (h : X = Y)
Goal: (X.isoOfEq Y h).hom = X.ofLE Y ⋯
-- CategoryTheory.Subobject.isoOfEq_inv
@[simps]
def isoOfEq {B : C} (X Y : Subobject B) (h : X = Y) : (X : C) ≅ (Y : C) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {B : C} (X Y : CategoryTheory.Subobject B) (h : X = Y)
Goal: (X.isoOfEq Y h).inv = Y.ofLE X ⋯
-- CategoryTheory.Subobject.isoOfEqMk_inv
@[simps]
def isoOfEqMk {B A : C} (X : Subobject B) (f : A ⟶ B) [Mono f] (h : X = mk f) : (X : C) ≅ A 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {B A : C} (X : CategoryTheory.Subobject B) (f : A ⟶ B) [CategoryTheory.Mono f] (h : X = CategoryTheory.Subobject.mk f)
Goal: (X.isoOfEqMk f h).inv = CategoryTheory.Subobject.ofMkLE f X ⋯
-- CategoryTheory.Subobject.isoOfEqMk_hom
@[simps]
def isoOfEqMk {B A : C} (X : Subobject B) (f : A ⟶ B) [Mono f] (h : X = mk f) : (X : C) ≅ A 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {B A : C} (X : CategoryTheory.Subobject B) (f : A ⟶ B) [CategoryTheory.Mono f] (h : X = CategoryTheory.Subobject.mk f)
Goal: (X.isoOfEqMk f h).hom = X.ofLEMk f ⋯
-- CategoryTheory.Subobject.isoOfMkEq_hom
@[simps]
def isoOfMkEq {B A : C} (f : A ⟶ B) [Mono f] (X : Subobject B) (h : mk f = X) : A ≅ (X : C) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {B A : C} (f : A ⟶ B) [CategoryTheory.Mono f] (X : CategoryTheory.Subobject B) (h : CategoryTheory.Subobject.mk f = X)
Goal: (CategoryTheory.Subobject.isoOfMkEq f X h).hom = CategoryTheory.Subobject.ofMkLE f X ⋯
-- CategoryTheory.Subobject.isoOfMkEq_inv
@[simps]
def isoOfMkEq {B A : C} (f : A ⟶ B) [Mono f] (X : Subobject B) (h : mk f = X) : A ≅ (X : C) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {B A : C} (f : A ⟶ B) [CategoryTheory.Mono f] (X : CategoryTheory.Subobject B) (h : CategoryTheory.Subobject.mk f = X)
Goal: (CategoryTheory.Subobject.isoOfMkEq f X h).inv = X.ofLEMk f ⋯
-- CategoryTheory.Subobject.isoOfMkEqMk_inv
@[simps]
def isoOfMkEqMk {B A₁ A₂ : C} (f : A₁ ⟶ B) (g : A₂ ⟶ B) [Mono f] [Mono g] (h : mk f = mk g) :
    A₁ ≅ A₂ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {B A₁ A₂ : C} (f : A₁ ⟶ B) (g : A₂ ⟶ B) [CategoryTheory.Mono f] [CategoryTheory.Mono g] (h : CategoryTheory.Subobject.mk f = CategoryTheory.Subobject.mk g)
Goal: (CategoryTheory.Subobject.isoOfMkEqMk f g h).inv = CategoryTheory.Subobject.ofMkLEMk g f ⋯
-- CategoryTheory.Subobject.isoOfMkEqMk_hom
@[simps]
def isoOfMkEqMk {B A₁ A₂ : C} (f : A₁ ⟶ B) (g : A₂ ⟶ B) [Mono f] [Mono g] (h : mk f = mk g) :
    A₁ ≅ A₂ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {B A₁ A₂ : C} (f : A₁ ⟶ B) (g : A₂ ⟶ B) [CategoryTheory.Mono f] [CategoryTheory.Mono g] (h : CategoryTheory.Subobject.mk f = CategoryTheory.Subobject.mk g)
Goal: (CategoryTheory.Subobject.isoOfMkEqMk f g h).hom = CategoryTheory.Subobject.ofMkLEMk f g ⋯
-- CategoryTheory.Subobject.lower_iso
theorem lower_iso (F₁ F₂ : MonoOver X ⥤ MonoOver Y) (h : F₁ ≅ F₂) : lower F₁ = lower F₂ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (F₁ F₂ : CategoryTheory.Functor (CategoryTheory.MonoOver X) (CategoryTheory.MonoOver Y)) (h : F₁ ≅ F₂)
Goal: CategoryTheory.Subobject.lower F₁ = CategoryTheory.Subobject.lower F₂
-- CategoryTheory.Subobject.lower_comm
@[simp]
theorem lower_comm (F : MonoOver Y ⥤ MonoOver X) :
    toThinSkeleton _ ⋙ lower F = F ⋙ toThinSkeleton _ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (F : CategoryTheory.Functor (CategoryTheory.MonoOver Y) (CategoryTheory.MonoOver X))
Goal: (CategoryTheory.toThinSkeleton (CategoryTheory.MonoOver Y)).comp (CategoryTheory.Subobject.lower F) =
  F.comp (CategoryTheory.toThinSkeleton (CategoryTheory.MonoOver X))
-- CategoryTheory.Subobject.lowerEquivalence_inverse
@[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).inverse = CategoryTheory.Subobject.lower e.inverse
-- CategoryTheory.Subobject.lowerEquivalence_unitIso
@[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).unitIso = CategoryTheory.eqToIso ⋯
-- CategoryTheory.Subobject.lowerEquivalence_counitIso
@[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).counitIso = CategoryTheory.eqToIso ⋯