ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Iso.eq_comp_inv
theorem eq_comp_inv (α : X ≅ Y) {f : Z ⟶ Y} {g : Z ⟶ X} : g = f ≫ α.inv ↔ g ≫ α.hom = f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : Z ⟶ Y} {g : Z ⟶ X}
Goal: g = CategoryTheory.CategoryStruct.comp f α.inv ↔ CategoryTheory.CategoryStruct.comp g α.hom = f
-- CategoryTheory.Iso.inv_eq_inv
theorem inv_eq_inv (f g : X ≅ Y) : f.inv = g.inv ↔ f.hom = g.hom 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ≅ Y)
Goal: f.inv = g.inv ↔ f.hom = g.hom
-- CategoryTheory.Iso.hom_comp_eq_id
theorem hom_comp_eq_id (α : X ≅ Y) {f : Y ⟶ X} : α.hom ≫ f = 𝟙 X ↔ f = α.inv 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y) {f : Y ⟶ X}
Goal: CategoryTheory.CategoryStruct.comp α.hom f = CategoryTheory.CategoryStruct.id X ↔ f = α.inv
-- CategoryTheory.Iso.comp_hom_eq_id
theorem comp_hom_eq_id (α : X ≅ Y) {f : Y ⟶ X} : f ≫ α.hom = 𝟙 Y ↔ f = α.inv 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y) {f : Y ⟶ X}
Goal: CategoryTheory.CategoryStruct.comp f α.hom = CategoryTheory.CategoryStruct.id Y ↔ f = α.inv
-- CategoryTheory.Iso.inv_comp_eq_id
theorem inv_comp_eq_id (α : X ≅ Y) {f : X ⟶ Y} : α.inv ≫ f = 𝟙 Y ↔ f = α.hom 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y) {f : X ⟶ Y}
Goal: CategoryTheory.CategoryStruct.comp α.inv f = CategoryTheory.CategoryStruct.id Y ↔ f = α.hom
-- CategoryTheory.Iso.comp_inv_eq_id
theorem comp_inv_eq_id (α : X ≅ Y) {f : X ⟶ Y} : f ≫ α.inv = 𝟙 X ↔ f = α.hom 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y) {f : X ⟶ Y}
Goal: CategoryTheory.CategoryStruct.comp f α.inv = CategoryTheory.CategoryStruct.id X ↔ f = α.hom
-- CategoryTheory.Iso.hom_eq_inv
theorem hom_eq_inv (α : X ≅ Y) (β : Y ≅ X) : α.hom = β.inv ↔ β.hom = α.inv 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y) (β : Y ≅ X)
Goal: α.hom = β.inv ↔ β.hom = α.inv
-- CategoryTheory.Iso.homToEquiv_symm_apply
@[simps]
def homToEquiv (α : X ≅ Y) {Z : C} : (Z ⟶ X) ≃ (Z ⟶ Y) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y) {Z : C} (g : Z ⟶ Y)
Goal: α.homToEquiv.symm g = CategoryTheory.CategoryStruct.comp g α.inv
-- CategoryTheory.Iso.homToEquiv_apply
@[simps]
def homToEquiv (α : X ≅ Y) {Z : C} : (Z ⟶ X) ≃ (Z ⟶ Y) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y) {Z : C} (f : Z ⟶ X)
Goal: α.homToEquiv f = CategoryTheory.CategoryStruct.comp f α.hom
-- CategoryTheory.Iso.homFromEquiv_symm_apply
@[simps]
def homFromEquiv (α : X ≅ Y) {Z : C} : (X ⟶ Z) ≃ (Y ⟶ Z) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y) {Z : C} (g : Y ⟶ Z)
Goal: α.homFromEquiv.symm g = CategoryTheory.CategoryStruct.comp α.hom g
-- CategoryTheory.Iso.homFromEquiv_apply
@[simps]
def homFromEquiv (α : X ≅ Y) {Z : C} : (X ⟶ Z) ≃ (Y ⟶ Z) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y) {Z : C} (f : X ⟶ Z)
Goal: α.homFromEquiv f = CategoryTheory.CategoryStruct.comp α.inv f
-- CategoryTheory.IsIso.out
class IsIso (f : X ⟶ Y) : Prop where
    out : ∃ inv : Y ⟶ X, f ≫ inv = 𝟙 X ∧ inv ≫ f = 𝟙 Y
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} [self : CategoryTheory.IsIso f]
Goal: ∃ inv,
  CategoryTheory.CategoryStruct.comp f inv = CategoryTheory.CategoryStruct.id X ∧
    CategoryTheory.CategoryStruct.comp inv f = CategoryTheory.CategoryStruct.id Y
-- CategoryTheory.IsIso.hom_inv_id
@[simp]
theorem hom_inv_id (f : X ⟶ Y) [I : IsIso f] : f ≫ inv f = 𝟙 X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [I : CategoryTheory.IsIso f]
Goal: CategoryTheory.CategoryStruct.comp f (CategoryTheory.inv f) = CategoryTheory.CategoryStruct.id X
-- CategoryTheory.IsIso.inv_hom_id
@[simp]
theorem inv_hom_id (f : X ⟶ Y) [I : IsIso f] : inv f ≫ f = 𝟙 Y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [I : CategoryTheory.IsIso f]
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.inv f) f = CategoryTheory.CategoryStruct.id Y
-- CategoryTheory.IsIso.hom_inv_id_assoc
@[simp]
theorem hom_inv_id_assoc (f : X ⟶ Y) [I : IsIso f] {Z} (g : X ⟶ Z) : f ≫ inv f ≫ g = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [I : CategoryTheory.IsIso f] {Z : C} (g : X ⟶ Z)
Goal: CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp (CategoryTheory.inv f) g) = g
-- CategoryTheory.IsIso.inv_hom_id_assoc
@[simp]
theorem inv_hom_id_assoc (f : X ⟶ Y) [I : IsIso f] {Z} (g : Y ⟶ Z) : inv f ≫ f ≫ g = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [I : CategoryTheory.IsIso f] {Z : C} (g : Y ⟶ Z)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.inv f) (CategoryTheory.CategoryStruct.comp f g) = g
-- CategoryTheory.Iso.isIso_hom
lemma Iso.isIso_hom (e : X ≅ Y) : IsIso e.hom 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (e : X ≅ Y)
Goal: CategoryTheory.IsIso e.hom
-- CategoryTheory.Iso.isIso_inv
lemma Iso.isIso_inv (e : X ≅ Y) : IsIso e.inv 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (e : X ≅ Y)
Goal: CategoryTheory.IsIso e.inv
-- CategoryTheory.asIso_hom
@[simp]
theorem asIso_hom (f : X ⟶ Y) {_ : IsIso f} : (asIso f).hom = f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
Goal: ∀ {x : CategoryTheory.IsIso f}, (CategoryTheory.asIso f).hom = f
-- CategoryTheory.asIso_inv
@[simp]
theorem asIso_inv (f : X ⟶ Y) {_ : IsIso f} : (asIso f).inv = inv f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
Goal: ∀ {x : CategoryTheory.IsIso f}, (CategoryTheory.asIso f).inv = CategoryTheory.inv f
-- CategoryTheory.IsIso.inv_eq_of_hom_inv_id
@[aesop apply safe (rule_sets := [CategoryTheory])]
theorem inv_eq_of_hom_inv_id {f : X ⟶ Y} [IsIso f] {g : Y ⟶ X} (hom_inv_id : f ≫ g = 𝟙 X) :
    inv f = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} [CategoryTheory.IsIso f] {g : Y ⟶ X} (hom_inv_id : CategoryTheory.CategoryStruct.comp f g = CategoryTheory.CategoryStruct.id X)
Goal: CategoryTheory.inv f = g
-- CategoryTheory.IsIso.inv_eq_of_inv_hom_id
theorem inv_eq_of_inv_hom_id {f : X ⟶ Y} [IsIso f] {g : Y ⟶ X} (inv_hom_id : g ≫ f = 𝟙 Y) :
    inv f = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} [CategoryTheory.IsIso f] {g : Y ⟶ X} (inv_hom_id : CategoryTheory.CategoryStruct.comp g f = CategoryTheory.CategoryStruct.id Y)
Goal: CategoryTheory.inv f = g
-- CategoryTheory.IsIso.eq_inv_of_hom_inv_id
@[aesop apply safe (rule_sets := [CategoryTheory])]
theorem eq_inv_of_hom_inv_id {f : X ⟶ Y} [IsIso f] {g : Y ⟶ X} (hom_inv_id : f ≫ g = 𝟙 X) :
    g = inv f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} [CategoryTheory.IsIso f] {g : Y ⟶ X} (hom_inv_id : CategoryTheory.CategoryStruct.comp f g = CategoryTheory.CategoryStruct.id X)
Goal: g = CategoryTheory.inv f
-- CategoryTheory.IsIso.eq_inv_of_inv_hom_id
theorem eq_inv_of_inv_hom_id {f : X ⟶ Y} [IsIso f] {g : Y ⟶ X} (inv_hom_id : g ≫ f = 𝟙 Y) :
    g = inv f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} [CategoryTheory.IsIso f] {g : Y ⟶ X} (inv_hom_id : CategoryTheory.CategoryStruct.comp g f = CategoryTheory.CategoryStruct.id Y)
Goal: g = CategoryTheory.inv f
-- CategoryTheory.IsIso.inv_id
@[simp]
theorem inv_id : inv (𝟙 X) = 𝟙 X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C}
Goal: CategoryTheory.inv (CategoryTheory.CategoryStruct.id X) = CategoryTheory.CategoryStruct.id X
-- CategoryTheory.IsIso.inv_comp
@[simp]
theorem inv_comp [IsIso f] [IsIso h] : inv (f ≫ h) = inv h ≫ inv f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {h : Y ⟶ Z} [CategoryTheory.IsIso f] [CategoryTheory.IsIso h]
Goal: CategoryTheory.inv (CategoryTheory.CategoryStruct.comp f h) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.inv h) (CategoryTheory.inv f)
-- CategoryTheory.IsIso.inv_inv
@[simp]
theorem inv_inv [IsIso f] : inv (inv f) = f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} [CategoryTheory.IsIso f]
Goal: CategoryTheory.inv (CategoryTheory.inv f) = f
-- CategoryTheory.IsIso.Iso.inv_inv
@[simp]
theorem Iso.inv_inv (f : X ≅ Y) : inv f.inv = f.hom 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ≅ Y)
Goal: CategoryTheory.inv f.inv = f.hom
-- CategoryTheory.IsIso.Iso.inv_hom
@[simp]
theorem Iso.inv_hom (f : X ≅ Y) : inv f.hom = f.inv 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ≅ Y)
Goal: CategoryTheory.inv f.hom = f.inv
-- CategoryTheory.IsIso.inv_comp_eq
@[simp]
theorem inv_comp_eq (α : X ⟶ Y) [IsIso α] {f : X ⟶ Z} {g : Y ⟶ Z} : inv α ≫ f = g ↔ f = α ≫ g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ⟶ Y) [CategoryTheory.IsIso α] {f : X ⟶ Z} {g : Y ⟶ Z}
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.inv α) f = g ↔ f = CategoryTheory.CategoryStruct.comp α g
-- CategoryTheory.IsIso.eq_inv_comp
@[simp]
theorem eq_inv_comp (α : X ⟶ Y) [IsIso α] {f : X ⟶ Z} {g : Y ⟶ Z} : g = inv α ≫ f ↔ α ≫ g = f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ⟶ Y) [CategoryTheory.IsIso α] {f : X ⟶ Z} {g : Y ⟶ Z}
Goal: g = CategoryTheory.CategoryStruct.comp (CategoryTheory.inv α) f ↔ CategoryTheory.CategoryStruct.comp α g = f
-- CategoryTheory.IsIso.comp_inv_eq
@[simp]
theorem comp_inv_eq (α : X ⟶ Y) [IsIso α] {f : Z ⟶ Y} {g : Z ⟶ X} : f ≫ inv α = g ↔ f = g ≫ α 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ⟶ Y) [CategoryTheory.IsIso α] {f : Z ⟶ Y} {g : Z ⟶ X}
Goal: CategoryTheory.CategoryStruct.comp f (CategoryTheory.inv α) = g ↔ f = CategoryTheory.CategoryStruct.comp g α
-- CategoryTheory.IsIso.eq_comp_inv
@[simp]
theorem eq_comp_inv (α : X ⟶ Y) [IsIso α] {f : Z ⟶ Y} {g : Z ⟶ X} : g = f ≫ inv α ↔ g ≫ α = f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ⟶ Y) [CategoryTheory.IsIso α] {f : Z ⟶ Y} {g : Z ⟶ X}
Goal: g = CategoryTheory.CategoryStruct.comp f (CategoryTheory.inv α) ↔ CategoryTheory.CategoryStruct.comp g α = f
-- CategoryTheory.IsIso.of_isIso_comp_left
theorem of_isIso_comp_left {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) [IsIso f] [IsIso (f ≫ g)] :
    IsIso g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) [CategoryTheory.IsIso f] [CategoryTheory.IsIso (CategoryTheory.CategoryStruct.comp f g)]
Goal: CategoryTheory.IsIso g
-- CategoryTheory.IsIso.of_isIso_comp_right
theorem of_isIso_comp_right {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) [IsIso g] [IsIso (f ≫ g)] :
    IsIso f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) [CategoryTheory.IsIso g] [CategoryTheory.IsIso (CategoryTheory.CategoryStruct.comp f g)]
Goal: CategoryTheory.IsIso f
-- CategoryTheory.IsIso.of_isIso_fac_left
theorem of_isIso_fac_left {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z} {h : X ⟶ Z} [IsIso f]
    [hh : IsIso h] (w : f ≫ g = h) : IsIso g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z} {h : X ⟶ Z} [CategoryTheory.IsIso f] [hh : CategoryTheory.IsIso h] (w : CategoryTheory.CategoryStruct.comp f g = h)
Goal: CategoryTheory.IsIso g
-- CategoryTheory.IsIso.of_isIso_fac_right
theorem of_isIso_fac_right {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z} {h : X ⟶ Z} [IsIso g]
    [hh : IsIso h] (w : f ≫ g = h) : IsIso f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z} {h : X ⟶ Z} [CategoryTheory.IsIso g] [hh : CategoryTheory.IsIso h] (w : CategoryTheory.CategoryStruct.comp f g = h)
Goal: CategoryTheory.IsIso f
-- CategoryTheory.eq_of_inv_eq_inv
theorem eq_of_inv_eq_inv {f g : X ⟶ Y} [IsIso f] [IsIso g] (p : inv f = inv g) : f = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} [CategoryTheory.IsIso f] [CategoryTheory.IsIso g] (p : CategoryTheory.inv f = CategoryTheory.inv g)
Goal: f = g
-- CategoryTheory.IsIso.inv_eq_inv
theorem IsIso.inv_eq_inv {f g : X ⟶ Y} [IsIso f] [IsIso g] : inv f = inv g ↔ f = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} [CategoryTheory.IsIso f] [CategoryTheory.IsIso g]
Goal: CategoryTheory.inv f = CategoryTheory.inv g ↔ f = g
-- CategoryTheory.hom_comp_eq_id
theorem hom_comp_eq_id (g : X ⟶ Y) [IsIso g] {f : Y ⟶ X} : g ≫ f = 𝟙 X ↔ f = inv g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (g : X ⟶ Y) [CategoryTheory.IsIso g] {f : Y ⟶ X}
Goal: CategoryTheory.CategoryStruct.comp g f = CategoryTheory.CategoryStruct.id X ↔ f = CategoryTheory.inv g
-- CategoryTheory.comp_hom_eq_id
theorem comp_hom_eq_id (g : X ⟶ Y) [IsIso g] {f : Y ⟶ X} : f ≫ g = 𝟙 Y ↔ f = inv g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (g : X ⟶ Y) [CategoryTheory.IsIso g] {f : Y ⟶ X}
Goal: CategoryTheory.CategoryStruct.comp f g = CategoryTheory.CategoryStruct.id Y ↔ f = CategoryTheory.inv g
-- CategoryTheory.inv_comp_eq_id
theorem inv_comp_eq_id (g : X ⟶ Y) [IsIso g] {f : X ⟶ Y} : inv g ≫ f = 𝟙 Y ↔ f = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (g : X ⟶ Y) [CategoryTheory.IsIso g] {f : X ⟶ Y}
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.inv g) f = CategoryTheory.CategoryStruct.id Y ↔ f = g
-- CategoryTheory.comp_inv_eq_id
theorem comp_inv_eq_id (g : X ⟶ Y) [IsIso g] {f : X ⟶ Y} : f ≫ inv g = 𝟙 X ↔ f = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (g : X ⟶ Y) [CategoryTheory.IsIso g] {f : X ⟶ Y}
Goal: CategoryTheory.CategoryStruct.comp f (CategoryTheory.inv g) = CategoryTheory.CategoryStruct.id X ↔ f = g
-- CategoryTheory.isIso_of_hom_comp_eq_id
theorem isIso_of_hom_comp_eq_id (g : X ⟶ Y) [IsIso g] {f : Y ⟶ X} (h : g ≫ f = 𝟙 X) : IsIso f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (g : X ⟶ Y) [CategoryTheory.IsIso g] {f : Y ⟶ X} (h : CategoryTheory.CategoryStruct.comp g f = CategoryTheory.CategoryStruct.id X)
Goal: CategoryTheory.IsIso f
-- CategoryTheory.isIso_of_comp_hom_eq_id
theorem isIso_of_comp_hom_eq_id (g : X ⟶ Y) [IsIso g] {f : Y ⟶ X} (h : f ≫ g = 𝟙 Y) : IsIso f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (g : X ⟶ Y) [CategoryTheory.IsIso g] {f : Y ⟶ X} (h : CategoryTheory.CategoryStruct.comp f g = CategoryTheory.CategoryStruct.id Y)
Goal: CategoryTheory.IsIso f
-- CategoryTheory.Iso.inv_ext
@[aesop apply safe (rule_sets := [CategoryTheory])]
theorem inv_ext {f : X ≅ Y} {g : Y ⟶ X} (hom_inv_id : f.hom ≫ g = 𝟙 X) : f.inv = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ≅ Y} {g : Y ⟶ X} (hom_inv_id : CategoryTheory.CategoryStruct.comp f.hom g = CategoryTheory.CategoryStruct.id X)
Goal: f.inv = g
-- CategoryTheory.Iso.inv_ext'
@[aesop apply safe (rule_sets := [CategoryTheory])]
theorem inv_ext' {f : X ≅ Y} {g : Y ⟶ X} (hom_inv_id : f.hom ≫ g = 𝟙 X) : g = f.inv 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ≅ Y} {g : Y ⟶ X} (hom_inv_id : CategoryTheory.CategoryStruct.comp f.hom g = CategoryTheory.CategoryStruct.id X)
Goal: g = f.inv
-- CategoryTheory.Iso.cancel_iso_hom_left
@[simp]
theorem cancel_iso_hom_left {X Y Z : C} (f : X ≅ Y) (g g' : Y ⟶ Z) :
    f.hom ≫ g = f.hom ≫ g' ↔ g = g' 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ≅ Y) (g g' : Y ⟶ Z)
Goal: CategoryTheory.CategoryStruct.comp f.hom g = CategoryTheory.CategoryStruct.comp f.hom g' ↔ g = g'
-- CategoryTheory.Iso.cancel_iso_inv_left
@[simp]
theorem cancel_iso_inv_left {X Y Z : C} (f : Y ≅ X) (g g' : Y ⟶ Z) :
    f.inv ≫ g = f.inv ≫ g' ↔ g = g' 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : Y ≅ X) (g g' : Y ⟶ Z)
Goal: CategoryTheory.CategoryStruct.comp f.inv g = CategoryTheory.CategoryStruct.comp f.inv g' ↔ g = g'
-- CategoryTheory.Iso.cancel_iso_hom_right
@[simp]
theorem cancel_iso_hom_right {X Y Z : C} (f f' : X ⟶ Y) (g : Y ≅ Z) :
    f ≫ g.hom = f' ≫ g.hom ↔ f = f' 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f f' : X ⟶ Y) (g : Y ≅ Z)
Goal: CategoryTheory.CategoryStruct.comp f g.hom = CategoryTheory.CategoryStruct.comp f' g.hom ↔ f = f'
-- CategoryTheory.Iso.cancel_iso_inv_right
@[simp]
theorem cancel_iso_inv_right {X Y Z : C} (f f' : X ⟶ Y) (g : Z ≅ Y) :
    f ≫ g.inv = f' ≫ g.inv ↔ f = f' 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f f' : X ⟶ Y) (g : Z ≅ Y)
Goal: CategoryTheory.CategoryStruct.comp f g.inv = CategoryTheory.CategoryStruct.comp f' g.inv ↔ f = f'
-- CategoryTheory.Iso.cancel_iso_hom_right_assoc
@[simp]
theorem cancel_iso_hom_right_assoc {W X X' Y Z : C} (f : W ⟶ X) (g : X ⟶ Y) (f' : W ⟶ X')
    (g' : X' ⟶ Y) (h : Y ≅ Z) : f ≫ g ≫ h.hom = f' ≫ g' ≫ h.hom ↔ f ≫ g = f' ≫ g' 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W X X' Y Z : C} (f : W ⟶ X) (g : X ⟶ Y) (f' : W ⟶ X') (g' : X' ⟶ Y) (h : Y ≅ Z)
Goal: CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g h.hom) =
    CategoryTheory.CategoryStruct.comp f' (CategoryTheory.CategoryStruct.comp g' h.hom) ↔
  CategoryTheory.CategoryStruct.comp f g = CategoryTheory.CategoryStruct.comp f' g'
-- CategoryTheory.Iso.cancel_iso_inv_right_assoc
@[simp]
theorem cancel_iso_inv_right_assoc {W X X' Y Z : C} (f : W ⟶ X) (g : X ⟶ Y) (f' : W ⟶ X')
    (g' : X' ⟶ Y) (h : Z ≅ Y) : f ≫ g ≫ h.inv = f' ≫ g' ≫ h.inv ↔ f ≫ g = f' ≫ g' 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W X X' Y Z : C} (f : W ⟶ X) (g : X ⟶ Y) (f' : W ⟶ X') (g' : X' ⟶ Y) (h : Z ≅ Y)
Goal: CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g h.inv) =
    CategoryTheory.CategoryStruct.comp f' (CategoryTheory.CategoryStruct.comp g' h.inv) ↔
  CategoryTheory.CategoryStruct.comp f g = CategoryTheory.CategoryStruct.comp f' g'
-- CategoryTheory.Iso.map_hom_inv_id
@[reassoc (attr := simp)]
lemma map_hom_inv_id (F : C ⥤ D) :
    F.map e.hom ≫ F.map e.inv = 𝟙 _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_3, u_1} D] {X Y : C} (e : X ≅ Y) (F : CategoryTheory.Functor C D)
Goal: CategoryTheory.CategoryStruct.comp (F.map e.hom) (F.map e.inv) = CategoryTheory.CategoryStruct.id (F.obj X)
-- CategoryTheory.Iso.map_inv_hom_id
@[reassoc (attr := simp)]
lemma map_inv_hom_id (F : C ⥤ D) :
    F.map e.inv ≫ F.map e.hom = 𝟙 _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_3, u_1} D] {X Y : C} (e : X ≅ Y) (F : CategoryTheory.Functor C D)
Goal: CategoryTheory.CategoryStruct.comp (F.map e.inv) (F.map e.hom) = CategoryTheory.CategoryStruct.id (F.obj Y)
-- CategoryTheory.Functor.mapIso_inv
@[simps]
def mapIso (F : C ⥤ D) {X Y : C} (i : X ≅ Y) : F.obj X ≅ F.obj Y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) {X Y : C} (i : X ≅ Y)
Goal: (F.mapIso i).inv = F.map i.inv
-- CategoryTheory.Functor.mapIso_hom
@[simps]
def mapIso (F : C ⥤ D) {X Y : C} (i : X ≅ Y) : F.obj X ≅ F.obj Y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) {X Y : C} (i : X ≅ Y)
Goal: (F.mapIso i).hom = F.map i.hom
-- CategoryTheory.Functor.mapIso_symm
@[simp]
theorem mapIso_symm (F : C ⥤ D) {X Y : C} (i : X ≅ Y) : F.mapIso i.symm = (F.mapIso i).symm 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) {X Y : C} (i : X ≅ Y)
Goal: F.mapIso i.symm = (F.mapIso i).symm
-- CategoryTheory.Functor.mapIso_trans
@[simp]
theorem mapIso_trans (F : C ⥤ D) {X Y Z : C} (i : X ≅ Y) (j : Y ≅ Z) :
    F.mapIso (i ≪≫ j) = F.mapIso i ≪≫ F.mapIso j 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) {X Y Z : C} (i : X ≅ Y) (j : Y ≅ Z)
Goal: F.mapIso (i ≪≫ j) = F.mapIso i ≪≫ F.mapIso j
-- CategoryTheory.Functor.mapIso_refl
@[simp]
theorem mapIso_refl (F : C ⥤ D) (X : C) : F.mapIso (Iso.refl X) = Iso.refl (F.obj X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (X : C)
Goal: F.mapIso (CategoryTheory.Iso.refl X) = CategoryTheory.Iso.refl (F.obj X)
-- CategoryTheory.Functor.map_inv
@[simp]
theorem map_inv (F : C ⥤ D) {X Y : C} (f : X ⟶ Y) [IsIso f] : F.map (inv f) = inv (F.map f) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) {X Y : C} (f : X ⟶ Y) [CategoryTheory.IsIso f]
Goal: F.map (CategoryTheory.inv f) = CategoryTheory.inv (F.map f)
-- CategoryTheory.Functor.map_hom_inv
@[reassoc]
theorem map_hom_inv (F : C ⥤ D) {X Y : C} (f : X ⟶ Y) [IsIso f] :
    F.map f ≫ F.map (inv f) = 𝟙 (F.obj X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) {X Y : C} (f : X ⟶ Y) [CategoryTheory.IsIso f]
Goal: CategoryTheory.CategoryStruct.comp (F.map f) (F.map (CategoryTheory.inv f)) = CategoryTheory.CategoryStruct.id (F.obj X)
-- CategoryTheory.Functor.map_inv_hom
@[reassoc]
theorem map_inv_hom (F : C ⥤ D) {X Y : C} (f : X ⟶ Y) [IsIso f] :
    F.map (inv f) ≫ F.map f = 𝟙 (F.obj Y) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) {X Y : C} (f : X ⟶ Y) [CategoryTheory.IsIso f]
Goal: CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.inv f)) (F.map f) = CategoryTheory.CategoryStruct.id (F.obj Y)
-- MeasureTheory.Conservative.exists_mem_iterate_mem'
structure Conservative (f : α → α) (μ : Measure α) extends QuasiMeasurePreserving f μ μ : Prop where
    exists_mem_iterate_mem' : ∀ ⦃s⦄, MeasurableSet s → μ s ≠ 0 → ∃ x ∈ s, ∃ m ≠ 0, f^[m] x ∈ s
Arguments: {α : Type u_2} [MeasurableSpace α] {f : α → α} {μ : MeasureTheory.Measure α} (self : MeasureTheory.Conservative f μ) ⦃s : Set α⦄
Goal: MeasurableSet s → μ s ≠ 0 → ∃ x ∈ s, ∃ m, m ≠ 0 ∧ f^[m] x ∈ s
-- MeasureTheory.MeasurePreserving.conservative
protected theorem MeasurePreserving.conservative [IsFiniteMeasure μ] (h : MeasurePreserving f μ μ) :
    Conservative f μ 
Arguments: {α : Type u_2} [MeasurableSpace α] {f : α → α} {μ : MeasureTheory.Measure α} [MeasureTheory.IsFiniteMeasure μ] (h : MeasureTheory.MeasurePreserving f μ μ)
Goal: MeasureTheory.Conservative f μ
-- MeasureTheory.Conservative.id
protected theorem id (μ : Measure α) : Conservative id μ 
Arguments: {α : Type u_2} [MeasurableSpace α] (μ : MeasureTheory.Measure α)
Goal: MeasureTheory.Conservative id μ
-- MeasureTheory.Conservative.exists_mem_iterate_mem
theorem exists_mem_iterate_mem (hf : Conservative f μ)
    (hsm : NullMeasurableSet s μ) (hs₀ : μ s ≠ 0) :
    ∃ x ∈ s, ∃ m ≠ 0, f^[m] x ∈ s 
Arguments: {α : Type u_2} [MeasurableSpace α] {f : α → α} {s : Set α} {μ : MeasureTheory.Measure α} (hf : MeasureTheory.Conservative f μ) (hsm : MeasureTheory.NullMeasurableSet s μ) (hs₀ : μ s ≠ 0)
Goal: ∃ x ∈ s, ∃ m, m ≠ 0 ∧ f^[m] x ∈ s
-- MeasureTheory.Conservative.frequently_measure_inter_ne_zero
theorem frequently_measure_inter_ne_zero (hf : Conservative f μ) (hs : NullMeasurableSet s μ)
    (h0 : μ s ≠ 0) : ∃ᶠ m in atTop, μ (s ∩ f^[m] ⁻¹' s) ≠ 0 
Arguments: {α : Type u_2} [MeasurableSpace α] {f : α → α} {s : Set α} {μ : MeasureTheory.Measure α} (hf : MeasureTheory.Conservative f μ) (hs : MeasureTheory.NullMeasurableSet s μ) (h0 : μ s ≠ 0)
Goal: ∃ᶠ (m : ℕ) in Filter.atTop, μ (s ∩ f^[m] ⁻¹' s) ≠ 0
-- MeasureTheory.Conservative.exists_gt_measure_inter_ne_zero
theorem exists_gt_measure_inter_ne_zero (hf : Conservative f μ) (hs : NullMeasurableSet s μ)
    (h0 : μ s ≠ 0) (N : ℕ) : ∃ m > N, μ (s ∩ f^[m] ⁻¹' s) ≠ 0 
Arguments: {α : Type u_2} [MeasurableSpace α] {f : α → α} {s : Set α} {μ : MeasureTheory.Measure α} (hf : MeasureTheory.Conservative f μ) (hs : MeasureTheory.NullMeasurableSet s μ) (h0 : μ s ≠ 0) (N : ℕ)
Goal: ∃ m > N, μ (s ∩ f^[m] ⁻¹' s) ≠ 0