ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.MorphismProperty.op_unop
theorem op_unop (P : MorphismProperty Cᵒᵖ) : P.unop.op = P 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (P : CategoryTheory.MorphismProperty Cᵒᵖ)
Goal: P.unop.op = P
-- CategoryTheory.MorphismProperty.inverseImage_iff
@[simp]
lemma inverseImage_iff (P : MorphismProperty D) (F : C ⥤ D) {X Y : C} (f : X ⟶ Y) :
    P.inverseImage F f ↔ P (F.map f) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] (P : CategoryTheory.MorphismProperty D) (F : C ⥤ D) {X Y : C} (f : X ⟶ Y)
Goal: P.inverseImage F f ↔ P (F.map f)
-- CategoryTheory.MorphismProperty.map_mem_map
lemma map_mem_map (P : MorphismProperty C) (F : C ⥤ D) {X Y : C} (f : X ⟶ Y) (hf : P f) :
    (P.map F) (F.map f) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] (P : CategoryTheory.MorphismProperty C) (F : C ⥤ D) {X Y : C} (f : X ⟶ Y) (hf : P f)
Goal: P.map F (F.map f)
-- CategoryTheory.MorphismProperty.monotone_map
lemma monotone_map (F : C ⥤ D) :
    Monotone (map · F) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] (F : C ⥤ D)
Goal: Monotone fun x => x.map F
-- CategoryTheory.MorphismProperty.RespectsIso.postcomp
class RespectsIso (P : MorphismProperty C) : Prop where
  precomp {X Y Z} (e : X ≅ Y) (f : Y ⟶ Z) (hf : P f) : P (e.hom ≫ f)
  postcomp {X Y Z} (e : Y ≅ Z) (f : X ⟶ Y) (hf : P f) : P (f ≫ e.hom)
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {P : CategoryTheory.MorphismProperty C} [self : P.RespectsIso] {X Y Z : C} (e : Y ≅ Z) (f : X ⟶ Y) (hf : P f)
Goal: P (f ≫ e.hom)
-- CategoryTheory.MorphismProperty.RespectsIso.precomp
class RespectsIso (P : MorphismProperty C) : Prop where
  precomp {X Y Z} (e : X ≅ Y) (f : Y ⟶ Z) (hf : P f) : P (e.hom ≫ f)
  postcomp {X Y Z} (e : Y ≅ Z) (f : X ⟶ Y) (hf : P f) : P (f ≫ e.hom)
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {P : CategoryTheory.MorphismProperty C} [self : P.RespectsIso] {X Y Z : C} (e : X ≅ Y) (f : Y ⟶ Z) (hf : P f)
Goal: P (e.hom ≫ f)
-- CategoryTheory.MorphismProperty.le_isoClosure
lemma le_isoClosure (P : MorphismProperty C) : P ≤ P.isoClosure 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (P : CategoryTheory.MorphismProperty C)
Goal: P ≤ P.isoClosure
-- CategoryTheory.MorphismProperty.monotone_isoClosure
lemma monotone_isoClosure : Monotone (isoClosure (C := C)) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: Monotone CategoryTheory.MorphismProperty.isoClosure
-- CategoryTheory.MorphismProperty.cancel_left_of_respectsIso
theorem cancel_left_of_respectsIso (P : MorphismProperty C) [hP : RespectsIso P] {X Y Z : C}
    (f : X ⟶ Y) (g : Y ⟶ Z) [IsIso f] : P (f ≫ g) ↔ P g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (P : CategoryTheory.MorphismProperty C) [hP : P.RespectsIso] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) [CategoryTheory.IsIso f]
Goal: P (f ≫ g) ↔ P g
-- CategoryTheory.MorphismProperty.cancel_right_of_respectsIso
theorem cancel_right_of_respectsIso (P : MorphismProperty C) [hP : RespectsIso P] {X Y Z : C}
    (f : X ⟶ Y) (g : Y ⟶ Z) [IsIso g] : P (f ≫ g) ↔ P f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (P : CategoryTheory.MorphismProperty C) [hP : P.RespectsIso] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) [CategoryTheory.IsIso g]
Goal: P (f ≫ g) ↔ P f
-- CategoryTheory.MorphismProperty.arrow_iso_iff
theorem arrow_iso_iff (P : MorphismProperty C) [RespectsIso P] {f g : Arrow C}
    (e : f ≅ g) : P f.hom ↔ P g.hom 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (P : CategoryTheory.MorphismProperty C) [P.RespectsIso] {f g : CategoryTheory.Arrow C} (e : f ≅ g)
Goal: P f.hom ↔ P g.hom
-- CategoryTheory.MorphismProperty.arrow_mk_iso_iff
theorem arrow_mk_iso_iff (P : MorphismProperty C) [RespectsIso P] {W X Y Z : C}
    {f : W ⟶ X} {g : Y ⟶ Z} (e : Arrow.mk f ≅ Arrow.mk g) : P f ↔ P g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (P : CategoryTheory.MorphismProperty C) [P.RespectsIso] {W X Y Z : C} {f : W ⟶ X} {g : Y ⟶ Z} (e : CategoryTheory.Arrow.mk f ≅ CategoryTheory.Arrow.mk g)
Goal: P f ↔ P g
-- CategoryTheory.MorphismProperty.RespectsIso.of_respects_arrow_iso
theorem RespectsIso.of_respects_arrow_iso (P : MorphismProperty C)
    (hP : ∀ (f g : Arrow C) (_ : f ≅ g) (_ : P f.hom), P g.hom) : RespectsIso P 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (P : CategoryTheory.MorphismProperty C) (hP : ∀ (f g : CategoryTheory.Arrow C), (f ≅ g) → P f.hom → P g.hom)
Goal: P.RespectsIso
-- CategoryTheory.MorphismProperty.isoClosure_eq_iff
lemma isoClosure_eq_iff (P : MorphismProperty C) :
    P.isoClosure = P ↔ P.RespectsIso 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (P : CategoryTheory.MorphismProperty C)
Goal: P.isoClosure = P ↔ P.RespectsIso
-- CategoryTheory.MorphismProperty.isoClosure_eq_self
lemma isoClosure_eq_self (P : MorphismProperty C) [P.RespectsIso] :
    P.isoClosure = P 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (P : CategoryTheory.MorphismProperty C) [P.RespectsIso]
Goal: P.isoClosure = P
-- CategoryTheory.MorphismProperty.isoClosure_isoClosure
@[simp]
lemma isoClosure_isoClosure (P : MorphismProperty C) :
    P.isoClosure.isoClosure = P.isoClosure 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (P : CategoryTheory.MorphismProperty C)
Goal: P.isoClosure.isoClosure = P.isoClosure
-- CategoryTheory.MorphismProperty.isoClosure_le_iff
lemma isoClosure_le_iff (P Q : MorphismProperty C) [Q.RespectsIso] :
    P.isoClosure ≤ Q ↔ P ≤ Q 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (P Q : CategoryTheory.MorphismProperty C) [Q.RespectsIso]
Goal: P.isoClosure ≤ Q ↔ P ≤ Q
-- CategoryTheory.MorphismProperty.map_le_iff
lemma map_le_iff (P : MorphismProperty C) {F : C ⥤ D} (Q : MorphismProperty D)
    [RespectsIso Q] :
    P.map F ≤ Q ↔ P ≤ Q.inverseImage F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] (P : CategoryTheory.MorphismProperty C) {F : C ⥤ D} (Q : CategoryTheory.MorphismProperty D) [Q.RespectsIso]
Goal: P.map F ≤ Q ↔ P ≤ Q.inverseImage F
-- CategoryTheory.MorphismProperty.map_isoClosure
@[simp]
lemma map_isoClosure (P : MorphismProperty C) (F : C ⥤ D) :
    P.isoClosure.map F = P.map F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] (P : CategoryTheory.MorphismProperty C) (F : C ⥤ D)
Goal: P.isoClosure.map F = P.map F
-- CategoryTheory.MorphismProperty.map_id_eq_isoClosure
lemma map_id_eq_isoClosure (P : MorphismProperty C) :
    P.map (𝟭 _) = P.isoClosure 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (P : CategoryTheory.MorphismProperty C)
Goal: P.map (𝟭 C) = P.isoClosure
-- CategoryTheory.MorphismProperty.map_id
lemma map_id (P : MorphismProperty C) [RespectsIso P] :
    P.map (𝟭 _) = P 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (P : CategoryTheory.MorphismProperty C) [P.RespectsIso]
Goal: P.map (𝟭 C) = P
-- CategoryTheory.MorphismProperty.map_map
@[simp]
lemma map_map (P : MorphismProperty C) (F : C ⥤ D) {E : Type*} [Category E] (G : D ⥤ E) :
    (P.map F).map G = P.map (F ⋙ G) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_3, u_1} D] (P : CategoryTheory.MorphismProperty C) (F : C ⥤ D) {E : Type u_2} [CategoryTheory.Category.{u_4, u_2} E] (G : D ⥤ E)
Goal: (P.map F).map G = P.map (F ⋙ G)
-- CategoryTheory.MorphismProperty.map_eq_of_iso
lemma map_eq_of_iso (P : MorphismProperty C) {F G : C ⥤ D} (e : F ≅ G) :
    P.map F = P.map G 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] (P : CategoryTheory.MorphismProperty C) {F G : C ⥤ D} (e : F ≅ G)
Goal: P.map F = P.map G
-- CategoryTheory.MorphismProperty.map_inverseImage_le
lemma map_inverseImage_le (P : MorphismProperty D) (F : C ⥤ D) :
    (P.inverseImage F).map F ≤ P.isoClosure 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] (P : CategoryTheory.MorphismProperty D) (F : C ⥤ D)
Goal: (P.inverseImage F).map F ≤ P.isoClosure
-- CategoryTheory.MorphismProperty.inverseImage_equivalence_inverse_eq_map_functor
lemma inverseImage_equivalence_inverse_eq_map_functor
    (P : MorphismProperty D) [RespectsIso P] (E : C ≌ D) :
    P.inverseImage E.functor = P.map E.inverse 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] (P : CategoryTheory.MorphismProperty D) [P.RespectsIso] (E : C ≌ D)
Goal: P.inverseImage E.functor = P.map E.inverse
-- CategoryTheory.MorphismProperty.inverseImage_equivalence_functor_eq_map_inverse
lemma inverseImage_equivalence_functor_eq_map_inverse
    (Q : MorphismProperty C) [RespectsIso Q] (E : C ≌ D) :
    Q.inverseImage E.inverse = Q.map E.functor 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] (Q : CategoryTheory.MorphismProperty C) [Q.RespectsIso] (E : C ≌ D)
Goal: Q.inverseImage E.inverse = Q.map E.functor
-- CategoryTheory.MorphismProperty.map_inverseImage_eq_of_isEquivalence
lemma map_inverseImage_eq_of_isEquivalence
    (P : MorphismProperty D) [P.RespectsIso] (F : C ⥤ D) [F.IsEquivalence] :
    (P.inverseImage F).map F = P 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] (P : CategoryTheory.MorphismProperty D) [P.RespectsIso] (F : C ⥤ D) [F.IsEquivalence]
Goal: (P.inverseImage F).map F = P
-- CategoryTheory.MorphismProperty.inverseImage_map_eq_of_isEquivalence
lemma inverseImage_map_eq_of_isEquivalence
    (P : MorphismProperty C) [P.RespectsIso] (F : C ⥤ D) [F.IsEquivalence] :
    (P.map F).inverseImage F = P 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] (P : CategoryTheory.MorphismProperty C) [P.RespectsIso] (F : C ⥤ D) [F.IsEquivalence]
Goal: (P.map F).inverseImage F = P
-- CategoryTheory.MorphismProperty.isomorphisms.iff
@[simp]
theorem isomorphisms.iff : (isomorphisms C) f ↔ IsIso f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
Goal: CategoryTheory.MorphismProperty.isomorphisms C f ↔ CategoryTheory.IsIso f
-- CategoryTheory.MorphismProperty.monomorphisms.iff
@[simp]
theorem monomorphisms.iff : (monomorphisms C) f ↔ Mono f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
Goal: CategoryTheory.MorphismProperty.monomorphisms C f ↔ CategoryTheory.Mono f
-- CategoryTheory.MorphismProperty.epimorphisms.iff
@[simp]
theorem epimorphisms.iff : (epimorphisms C) f ↔ Epi f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
Goal: CategoryTheory.MorphismProperty.epimorphisms C f ↔ CategoryTheory.Epi f
-- CategoryTheory.MorphismProperty.isomorphisms.infer_property
theorem isomorphisms.infer_property [hf : IsIso f] : (isomorphisms C) f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [hf : CategoryTheory.IsIso f]
Goal: CategoryTheory.MorphismProperty.isomorphisms C f
-- CategoryTheory.MorphismProperty.monomorphisms.infer_property
theorem monomorphisms.infer_property [hf : Mono f] : (monomorphisms C) f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [hf : CategoryTheory.Mono f]
Goal: CategoryTheory.MorphismProperty.monomorphisms C f
-- CategoryTheory.MorphismProperty.epimorphisms.infer_property
theorem epimorphisms.infer_property [hf : Epi f] : (epimorphisms C) f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [hf : CategoryTheory.Epi f]
Goal: CategoryTheory.MorphismProperty.epimorphisms C f
-- CategoryTheory.NatTrans.isIso_app_iff_of_iso
lemma isIso_app_iff_of_iso {F G : C ⥤ D} (α : F ⟶ G) {X Y : C} (e : X ≅ Y) :
    IsIso (α.app X) ↔ IsIso (α.app Y) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] {F G : C ⥤ D} (α : F ⟶ G) {X Y : C} (e : X ≅ Y)
Goal: CategoryTheory.IsIso (α.app X) ↔ CategoryTheory.IsIso (α.app Y)
-- CategoryTheory.MorphismProperty.IsInvertedBy.of_le
lemma of_le (P Q : MorphismProperty C) (F : C ⥤ D) (hQ : Q.IsInvertedBy F) (h : P ≤ Q) :
    P.IsInvertedBy F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (P Q : CategoryTheory.MorphismProperty C) (F : CategoryTheory.Functor C D) (hQ : Q.IsInvertedBy F) (h : P ≤ Q)
Goal: P.IsInvertedBy F
-- CategoryTheory.MorphismProperty.IsInvertedBy.of_comp
theorem of_comp {C₁ C₂ C₃ : Type*} [Category C₁] [Category C₂] [Category C₃]
    (W : MorphismProperty C₁) (F : C₁ ⥤ C₂) (hF : W.IsInvertedBy F) (G : C₂ ⥤ C₃) :
    W.IsInvertedBy (F ⋙ G) 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} [CategoryTheory.Category.{u_4, u_1} C₁] [CategoryTheory.Category.{u_5, u_2} C₂] [CategoryTheory.Category.{u_6, u_3} C₃] (W : CategoryTheory.MorphismProperty C₁) (F : CategoryTheory.Functor C₁ C₂) (hF : W.IsInvertedBy F) (G : CategoryTheory.Functor C₂ C₃)
Goal: W.IsInvertedBy (F.comp G)
-- CategoryTheory.MorphismProperty.IsInvertedBy.op
theorem op {W : MorphismProperty C} {L : C ⥤ D} (h : W.IsInvertedBy L) : W.op.IsInvertedBy L.op 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] {W : CategoryTheory.MorphismProperty C} {L : CategoryTheory.Functor C D} (h : W.IsInvertedBy L)
Goal: W.op.IsInvertedBy L.op
-- CategoryTheory.MorphismProperty.IsInvertedBy.rightOp
theorem rightOp {W : MorphismProperty C} {L : Cᵒᵖ ⥤ D} (h : W.op.IsInvertedBy L) :
    W.IsInvertedBy L.rightOp 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] {W : CategoryTheory.MorphismProperty C} {L : CategoryTheory.Functor Cᵒᵖ D} (h : W.op.IsInvertedBy L)
Goal: W.IsInvertedBy L.rightOp
-- CategoryTheory.MorphismProperty.IsInvertedBy.leftOp
theorem leftOp {W : MorphismProperty C} {L : C ⥤ Dᵒᵖ} (h : W.IsInvertedBy L) :
    W.op.IsInvertedBy L.leftOp 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] {W : CategoryTheory.MorphismProperty C} {L : CategoryTheory.Functor C Dᵒᵖ} (h : W.IsInvertedBy L)
Goal: W.op.IsInvertedBy L.leftOp
-- CategoryTheory.MorphismProperty.IsInvertedBy.unop
theorem unop {W : MorphismProperty C} {L : Cᵒᵖ ⥤ Dᵒᵖ} (h : W.op.IsInvertedBy L) :
    W.IsInvertedBy L.unop 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] {W : CategoryTheory.MorphismProperty C} {L : CategoryTheory.Functor Cᵒᵖ Dᵒᵖ} (h : W.op.IsInvertedBy L)
Goal: W.IsInvertedBy L.unop
-- CategoryTheory.MorphismProperty.IsInvertedBy.prod
lemma prod {C₁ C₂ : Type*} [Category C₁] [Category C₂]
    {W₁ : MorphismProperty C₁} {W₂ : MorphismProperty C₂}
    {E₁ E₂ : Type*} [Category E₁] [Category E₂] {F₁ : C₁ ⥤ E₁} {F₂ : C₂ ⥤ E₂}
    (h₁ : W₁.IsInvertedBy F₁) (h₂ : W₂.IsInvertedBy F₂) :
    (W₁.prod W₂).IsInvertedBy (F₁.prod F₂) 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} [CategoryTheory.Category.{u_5, u_1} C₁] [CategoryTheory.Category.{u_6, u_2} C₂] {W₁ : CategoryTheory.MorphismProperty C₁} {W₂ : CategoryTheory.MorphismProperty C₂} {E₁ : Type u_3} {E₂ : Type u_4} [CategoryTheory.Category.{u_7, u_3} E₁] [CategoryTheory.Category.{u_8, u_4} E₂] {F₁ : CategoryTheory.Functor C₁ E₁} {F₂ : CategoryTheory.Functor C₂ E₂} (h₁ : W₁.IsInvertedBy F₁) (h₂ : W₂.IsInvertedBy F₂)
Goal: (W₁.prod W₂).IsInvertedBy (F₁.prod F₂)
-- CategoryTheory.MorphismProperty.IsInvertedBy.pi
lemma pi {J : Type w} {C : J → Type u} {D : J → Type u'}
    [∀ j, Category.{v} (C j)] [∀ j, Category.{v'} (D j)]
    (W : ∀ j, MorphismProperty (C j)) (F : ∀ j, C j ⥤ D j)
    (hF : ∀ j, (W j).IsInvertedBy (F j)) :
    (MorphismProperty.pi W).IsInvertedBy (Functor.pi F) 
Arguments: {J : Type w} {C : J → Type u} {D : J → Type u'} [(j : J) → CategoryTheory.Category.{v, u} (C j)] [(j : J) → CategoryTheory.Category.{v', u'} (D j)] (W : (j : J) → CategoryTheory.MorphismProperty (C j)) (F : (j : J) → CategoryTheory.Functor (C j) (D j)) (hF : ∀ (j : J), (W j).IsInvertedBy (F j))
Goal: (CategoryTheory.MorphismProperty.pi W).IsInvertedBy (CategoryTheory.Functor.pi F)
-- CategoryTheory.MorphismProperty.FunctorsInverting.ext
@[ext]
lemma FunctorsInverting.ext {W : MorphismProperty C} {F₁ F₂ : FunctorsInverting W D}
    (h : F₁.obj = F₂.obj) : F₁ = F₂ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] {W : CategoryTheory.MorphismProperty C} {F₁ F₂ : W.FunctorsInverting D} (h : F₁.obj = F₂.obj)
Goal: F₁ = F₂
-- CategoryTheory.MorphismProperty.FunctorsInverting.hom_ext
@[ext]
lemma FunctorsInverting.hom_ext {W : MorphismProperty C} {F₁ F₂ : FunctorsInverting W D}
    {α β : F₁ ⟶ F₂} (h : α.app = β.app) : α = β 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] {W : CategoryTheory.MorphismProperty C} {F₁ F₂ : W.FunctorsInverting D} {α β : F₁ ⟶ F₂} (h : α.app = β.app)
Goal: α = β
-- CategoryTheory.MorphismProperty.IsInvertedBy.iff_of_iso
theorem IsInvertedBy.iff_of_iso (W : MorphismProperty C) {F₁ F₂ : C ⥤ D} (e : F₁ ≅ F₂) :
    W.IsInvertedBy F₁ ↔ W.IsInvertedBy F₂ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (W : CategoryTheory.MorphismProperty C) {F₁ F₂ : CategoryTheory.Functor C D} (e : F₁ ≅ F₂)
Goal: W.IsInvertedBy F₁ ↔ W.IsInvertedBy F₂
-- CategoryTheory.MorphismProperty.IsInvertedBy.isoClosure_iff
@[simp]
lemma IsInvertedBy.isoClosure_iff (W : MorphismProperty C) (F : C ⥤ D) :
    W.isoClosure.IsInvertedBy F ↔ W.IsInvertedBy F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (W : CategoryTheory.MorphismProperty C) (F : CategoryTheory.Functor C D)
Goal: W.isoClosure.IsInvertedBy F ↔ W.IsInvertedBy F
-- CategoryTheory.MorphismProperty.IsInvertedBy.iff_comp
@[simp]
lemma IsInvertedBy.iff_comp {C₁ C₂ C₃ : Type*} [Category C₁] [Category C₂] [Category C₃]
    (W : MorphismProperty C₁) (F : C₁ ⥤ C₂) (G : C₂ ⥤ C₃) [G.ReflectsIsomorphisms] :
    W.IsInvertedBy (F ⋙ G) ↔ W.IsInvertedBy F 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} [CategoryTheory.Category.{u_4, u_1} C₁] [CategoryTheory.Category.{u_5, u_2} C₂] [CategoryTheory.Category.{u_6, u_3} C₃] (W : CategoryTheory.MorphismProperty C₁) (F : CategoryTheory.Functor C₁ C₂) (G : CategoryTheory.Functor C₂ C₃) [G.ReflectsIsomorphisms]
Goal: W.IsInvertedBy (F.comp G) ↔ W.IsInvertedBy F
-- CategoryTheory.MorphismProperty.IsInvertedBy.iff_le_inverseImage_isomorphisms
lemma IsInvertedBy.iff_le_inverseImage_isomorphisms (W : MorphismProperty C) (F : C ⥤ D) :
    W.IsInvertedBy F ↔ W ≤ (isomorphisms D).inverseImage F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (W : CategoryTheory.MorphismProperty C) (F : CategoryTheory.Functor C D)
Goal: W.IsInvertedBy F ↔ W ≤ (CategoryTheory.MorphismProperty.isomorphisms D).inverseImage F
-- CategoryTheory.MorphismProperty.IsInvertedBy.iff_map_le_isomorphisms
lemma IsInvertedBy.iff_map_le_isomorphisms (W : MorphismProperty C) (F : C ⥤ D) :
    W.IsInvertedBy F ↔ W.map F ≤ isomorphisms D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (W : CategoryTheory.MorphismProperty C) (F : CategoryTheory.Functor C D)
Goal: W.IsInvertedBy F ↔ W.map F ≤ CategoryTheory.MorphismProperty.isomorphisms D
-- CategoryTheory.MorphismProperty.IsInvertedBy.map_iff
lemma IsInvertedBy.map_iff {C₁ C₂ C₃ : Type*} [Category C₁] [Category C₂] [Category C₃]
    (W : MorphismProperty C₁) (F : C₁ ⥤ C₂) (G : C₂ ⥤ C₃) :
    (W.map F).IsInvertedBy G ↔ W.IsInvertedBy (F ⋙ G) 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} [CategoryTheory.Category.{u_4, u_1} C₁] [CategoryTheory.Category.{u_5, u_2} C₂] [CategoryTheory.Category.{u_6, u_3} C₃] (W : CategoryTheory.MorphismProperty C₁) (F : CategoryTheory.Functor C₁ C₂) (G : CategoryTheory.Functor C₂ C₃)
Goal: (W.map F).IsInvertedBy G ↔ W.IsInvertedBy (F.comp G)
-- CategoryTheory.Functor.star_map_down_down
@[simps!]
def star : C ⥤ Discrete PUnit.{w + 1} 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y : C} (x : X ⟶ Y), ⋯ = ⋯
-- CategoryTheory.Functor.star_obj_as
@[simps!]
def star : C ⥤ Discrete PUnit.{w + 1} 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C]
Goal: ∀ (x : C), ((CategoryTheory.Functor.star C).obj x).as = PUnit.unit
-- CategoryTheory.Functor.punitExt_hom_app_down_down
@[simps!]
def punitExt (F G : C ⥤ Discrete PUnit.{w + 1}) : F ≅ G 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (CategoryTheory.Discrete PUnit.{w + 1})) (X : C)
Goal: ⋯ = ⋯
-- CategoryTheory.Functor.punitExt_inv_app_down_down
@[simps!]
def punitExt (F G : C ⥤ Discrete PUnit.{w + 1}) : F ≅ G 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (CategoryTheory.Discrete PUnit.{w + 1})) (X : C)
Goal: ⋯ = ⋯
-- CategoryTheory.Functor.punit_ext'
theorem punit_ext' (F G : C ⥤ Discrete PUnit.{w + 1}) : F = G 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (CategoryTheory.Discrete PUnit.{w + 1}))
Goal: F = G
-- CategoryTheory.Functor.equiv_inverse
@[simps]
def equiv : Discrete PUnit.{w + 1} ⥤ C ≌ C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: CategoryTheory.Functor.equiv.inverse = CategoryTheory.Functor.const (CategoryTheory.Discrete PUnit.{w + 1})
-- CategoryTheory.Functor.equiv_counitIso
@[simps]
def equiv : Discrete PUnit.{w + 1} ⥤ C ≌ C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: CategoryTheory.Functor.equiv.counitIso = CategoryTheory.NatIso.ofComponents CategoryTheory.Iso.refl ⋯
-- CategoryTheory.Functor.equiv_unitIso
@[simps]
def equiv : Discrete PUnit.{w + 1} ⥤ C ≌ C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: CategoryTheory.Functor.equiv.unitIso =
  CategoryTheory.NatIso.ofComponents
    (fun X =>
      CategoryTheory.Discrete.natIso fun i =>
        CategoryTheory.Iso.refl
          (((CategoryTheory.Functor.id (CategoryTheory.Functor (CategoryTheory.Discrete PUnit.{w + 1}) C)).obj X).obj
            i))
    ⋯
-- CategoryTheory.Functor.equiv_functor_obj
@[simps]
def equiv : Discrete PUnit.{w + 1} ⥤ C ≌ C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor (CategoryTheory.Discrete PUnit.{w + 1}) C)
Goal: CategoryTheory.Functor.equiv.functor.obj F = F.obj { as := PUnit.unit }
-- CategoryTheory.Functor.equiv_functor_map
@[simps]
def equiv : Discrete PUnit.{w + 1} ⥤ C ≌ C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y : CategoryTheory.Functor (CategoryTheory.Discrete PUnit.{w + 1}) C} (θ : X ⟶ Y),
  CategoryTheory.Functor.equiv.functor.map θ = θ.app { as := PUnit.unit }
-- CategoryTheory.equiv_punit_iff_unique
theorem equiv_punit_iff_unique :
    Nonempty (C ≌ Discrete PUnit.{w + 1}) ↔ Nonempty C ∧ ∀ x y : C, Nonempty <| Unique (x ⟶ y) 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C]
Goal: Nonempty (C ≌ CategoryTheory.Discrete PUnit.{w + 1}) ↔ Nonempty C ∧ ∀ (x y : C), Nonempty (Unique (x ⟶ y))
-- UnivLE.ofEssSurj
theorem UnivLE.ofEssSurj (w : (uliftFunctor.{u, v} : Type v ⥤ Type max u v).EssSurj) :
    UnivLE.{max u v, v} 
Arguments: (w : CategoryTheory.uliftFunctor.{u, v}.EssSurj)
Goal: UnivLE.{max u v, v}
-- UnivLE_iff_essSurj
theorem UnivLE_iff_essSurj :
    UnivLE.{max u v, v} ↔ (uliftFunctor.{u, v} : Type v ⥤ Type max u v).EssSurj 
Goal: UnivLE.{max u v, v} ↔ CategoryTheory.uliftFunctor.{u, v}.EssSurj