ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.DifferentialObject.d_squared
-- Porting note(#5171): removed `@[nolint has_nonempty_instance]`
structure DifferentialObject where
    obj : C
    d : obj ⟶ obj⟦(1 : S)⟧
    d_squared : d ≫ d⟦(1 : S)⟧' = 0 := by aesop_cat
Arguments: {S : Type u_1} [AddMonoidWithOne S] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.HasShift C S] (self : CategoryTheory.DifferentialObject S C)
Goal: CategoryTheory.CategoryStruct.comp self.d ((CategoryTheory.shiftFunctor C 1).map self.d) = 0
-- CategoryTheory.DifferentialObject.Hom.comm
@[ext] -- Porting note(#5171): removed `nolint has_nonempty_instance`
structure Hom (X Y : DifferentialObject S C) where
    f : X.obj ⟶ Y.obj
  comm : X.d ≫ f⟦1⟧' = f ≫ Y.d := by aesop_cat
Arguments: {S : Type u_1} [AddMonoidWithOne S] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.HasShift C S] {X Y : CategoryTheory.DifferentialObject S C} (self : X.Hom Y)
Goal: CategoryTheory.CategoryStruct.comp X.d ((CategoryTheory.shiftFunctor C 1).map self.f) =
  CategoryTheory.CategoryStruct.comp self.f Y.d
-- CategoryTheory.DifferentialObject.Hom.id_f
@[simps]
def id (X : DifferentialObject S C) : Hom X X 
Arguments: {S : Type u_1} [AddMonoidWithOne S] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.HasShift C S] (X : CategoryTheory.DifferentialObject S C)
Goal: (CategoryTheory.DifferentialObject.Hom.id X).f = CategoryTheory.CategoryStruct.id X.obj
-- CategoryTheory.DifferentialObject.Hom.comp_f
@[simps]
def comp {X Y Z : DifferentialObject S C} (f : Hom X Y) (g : Hom Y Z) : Hom X Z 
Arguments: {S : Type u_1} [AddMonoidWithOne S] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.HasShift C S] {X Y Z : CategoryTheory.DifferentialObject S C} (f : X.Hom Y) (g : Y.Hom Z)
Goal: (f.comp g).f = CategoryTheory.CategoryStruct.comp f.f g.f
-- CategoryTheory.DifferentialObject.ext
@[ext]
theorem ext {A B : DifferentialObject S C} {f g : A ⟶ B} (w : f.f = g.f := by aesop_cat) : f = g 
Arguments: {S : Type u_1} [AddMonoidWithOne S] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.HasShift C S] {A B : CategoryTheory.DifferentialObject S C} {f g : A ⟶ B} (w : f.f = g.f := by aesop_cat)
Goal: f = g
-- CategoryTheory.DifferentialObject.id_f
@[simp]
theorem id_f (X : DifferentialObject S C) : (𝟙 X : X ⟶ X).f = 𝟙 X.obj 
Arguments: {S : Type u_1} [AddMonoidWithOne S] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.HasShift C S] (X : CategoryTheory.DifferentialObject S C)
Goal: (CategoryTheory.CategoryStruct.id X).f = CategoryTheory.CategoryStruct.id X.obj
-- CategoryTheory.DifferentialObject.comp_f
@[simp]
theorem comp_f {X Y Z : DifferentialObject S C} (f : X ⟶ Y) (g : Y ⟶ Z) :
    (f ≫ g).f = f.f ≫ g.f 
Arguments: {S : Type u_1} [AddMonoidWithOne S] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.HasShift C S] {X Y Z : CategoryTheory.DifferentialObject S C} (f : X ⟶ Y) (g : Y ⟶ Z)
Goal: (CategoryTheory.CategoryStruct.comp f g).f = CategoryTheory.CategoryStruct.comp f.f g.f
-- CategoryTheory.DifferentialObject.eqToHom_f
@[simp]
theorem eqToHom_f {X Y : DifferentialObject S C} (h : X = Y) :
    Hom.f (eqToHom h) = eqToHom (congr_arg _ h) 
Arguments: {S : Type u_1} [AddMonoidWithOne S] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.HasShift C S] {X Y : CategoryTheory.DifferentialObject S C} (h : X = Y)
Goal: (CategoryTheory.eqToHom h).f = CategoryTheory.eqToHom ⋯
-- CategoryTheory.DifferentialObject.zero_f
@[simp]
theorem zero_f (P Q : DifferentialObject S C) : (0 : P ⟶ Q).f = 0 
Arguments: {S : Type u_1} [AddMonoidWithOne S] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.HasShift C S] [(CategoryTheory.shiftFunctor C 1).PreservesZeroMorphisms] (P Q : CategoryTheory.DifferentialObject S C)
Goal: CategoryTheory.DifferentialObject.Hom.f 0 = 0
-- CategoryTheory.DifferentialObject.isoApp_inv
@[simps]
def isoApp {X Y : DifferentialObject S C} (f : X ≅ Y) : X.obj ≅ Y.obj 
Arguments: {S : Type u_1} [AddMonoidWithOne S] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.HasShift C S] {X Y : CategoryTheory.DifferentialObject S C} (f : X ≅ Y)
Goal: (CategoryTheory.DifferentialObject.isoApp f).inv = f.inv.f
-- CategoryTheory.DifferentialObject.isoApp_hom
@[simps]
def isoApp {X Y : DifferentialObject S C} (f : X ≅ Y) : X.obj ≅ Y.obj 
Arguments: {S : Type u_1} [AddMonoidWithOne S] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.HasShift C S] {X Y : CategoryTheory.DifferentialObject S C} (f : X ≅ Y)
Goal: (CategoryTheory.DifferentialObject.isoApp f).hom = f.hom.f
-- CategoryTheory.DifferentialObject.isoApp_refl
@[simp]
theorem isoApp_refl (X : DifferentialObject S C) : isoApp (Iso.refl X) = Iso.refl X.obj 
Arguments: {S : Type u_1} [AddMonoidWithOne S] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.HasShift C S] (X : CategoryTheory.DifferentialObject S C)
Goal: CategoryTheory.DifferentialObject.isoApp (CategoryTheory.Iso.refl X) = CategoryTheory.Iso.refl X.obj
-- CategoryTheory.DifferentialObject.isoApp_symm
@[simp]
theorem isoApp_symm {X Y : DifferentialObject S C} (f : X ≅ Y) : isoApp f.symm = (isoApp f).symm 
Arguments: {S : Type u_1} [AddMonoidWithOne S] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.HasShift C S] {X Y : CategoryTheory.DifferentialObject S C} (f : X ≅ Y)
Goal: CategoryTheory.DifferentialObject.isoApp f.symm = (CategoryTheory.DifferentialObject.isoApp f).symm
-- CategoryTheory.DifferentialObject.isoApp_trans
@[simp]
theorem isoApp_trans {X Y Z : DifferentialObject S C} (f : X ≅ Y) (g : Y ≅ Z) :
    isoApp (f ≪≫ g) = isoApp f ≪≫ isoApp g 
Arguments: {S : Type u_1} [AddMonoidWithOne S] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.HasShift C S] {X Y Z : CategoryTheory.DifferentialObject S C} (f : X ≅ Y) (g : Y ≅ Z)
Goal: CategoryTheory.DifferentialObject.isoApp (f ≪≫ g) =
  CategoryTheory.DifferentialObject.isoApp f ≪≫ CategoryTheory.DifferentialObject.isoApp g
-- CategoryTheory.DifferentialObject.mkIso_inv_f
@[simps]
def mkIso {X Y : DifferentialObject S C} (f : X.obj ≅ Y.obj) (hf : X.d ≫ f.hom⟦1⟧' = f.hom ≫ Y.d) :
    X ≅ Y 
Arguments: {S : Type u_1} [AddMonoidWithOne S] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.HasShift C S] {X Y : CategoryTheory.DifferentialObject S C} (f : X.obj ≅ Y.obj) (hf :
  CategoryTheory.CategoryStruct.comp X.d ((CategoryTheory.shiftFunctor C 1).map f.hom) =
    CategoryTheory.CategoryStruct.comp f.hom Y.d)
Goal: (CategoryTheory.DifferentialObject.mkIso f hf).inv.f = f.inv
-- CategoryTheory.DifferentialObject.mkIso_hom_f
@[simps]
def mkIso {X Y : DifferentialObject S C} (f : X.obj ≅ Y.obj) (hf : X.d ≫ f.hom⟦1⟧' = f.hom ≫ Y.d) :
    X ≅ Y 
Arguments: {S : Type u_1} [AddMonoidWithOne S] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.HasShift C S] {X Y : CategoryTheory.DifferentialObject S C} (f : X.obj ≅ Y.obj) (hf :
  CategoryTheory.CategoryStruct.comp X.d ((CategoryTheory.shiftFunctor C 1).map f.hom) =
    CategoryTheory.CategoryStruct.comp f.hom Y.d)
Goal: (CategoryTheory.DifferentialObject.mkIso f hf).hom.f = f.hom
-- CategoryTheory.Functor.mapDifferentialObject_obj_obj
@[simps]
def mapDifferentialObject (F : C ⥤ D)
    (η : (shiftFunctor C (1 : S)).comp F ⟶ F.comp (shiftFunctor D (1 : S)))
    (hF : ∀ c c', F.map (0 : c ⟶ c') = 0) : DifferentialObject S C ⥤ DifferentialObject S D 
Arguments: {S : Type u_1} [AddMonoidWithOne S] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.HasShift C S] (D : Type u') [CategoryTheory.Category.{v', u'} D] [CategoryTheory.Limits.HasZeroMorphisms D] [CategoryTheory.HasShift D S] (F : CategoryTheory.Functor C D) (η : (CategoryTheory.shiftFunctor C 1).comp F ⟶ F.comp (CategoryTheory.shiftFunctor D 1)) (hF : ∀ (c c' : C), F.map 0 = 0) (X : CategoryTheory.DifferentialObject S C)
Goal: ((CategoryTheory.Functor.mapDifferentialObject D F η hF).obj X).obj = F.obj X.obj
-- CategoryTheory.Functor.mapDifferentialObject_obj_d
@[simps]
def mapDifferentialObject (F : C ⥤ D)
    (η : (shiftFunctor C (1 : S)).comp F ⟶ F.comp (shiftFunctor D (1 : S)))
    (hF : ∀ c c', F.map (0 : c ⟶ c') = 0) : DifferentialObject S C ⥤ DifferentialObject S D 
Arguments: {S : Type u_1} [AddMonoidWithOne S] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.HasShift C S] (D : Type u') [CategoryTheory.Category.{v', u'} D] [CategoryTheory.Limits.HasZeroMorphisms D] [CategoryTheory.HasShift D S] (F : CategoryTheory.Functor C D) (η : (CategoryTheory.shiftFunctor C 1).comp F ⟶ F.comp (CategoryTheory.shiftFunctor D 1)) (hF : ∀ (c c' : C), F.map 0 = 0) (X : CategoryTheory.DifferentialObject S C)
Goal: ((CategoryTheory.Functor.mapDifferentialObject D F η hF).obj X).d =
  CategoryTheory.CategoryStruct.comp (F.map X.d) (η.app X.obj)
-- CategoryTheory.Functor.mapDifferentialObject_map_f
@[simps]
def mapDifferentialObject (F : C ⥤ D)
    (η : (shiftFunctor C (1 : S)).comp F ⟶ F.comp (shiftFunctor D (1 : S)))
    (hF : ∀ c c', F.map (0 : c ⟶ c') = 0) : DifferentialObject S C ⥤ DifferentialObject S D 
Arguments: {S : Type u_1} [AddMonoidWithOne S] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.HasShift C S] (D : Type u') [CategoryTheory.Category.{v', u'} D] [CategoryTheory.Limits.HasZeroMorphisms D] [CategoryTheory.HasShift D S] (F : CategoryTheory.Functor C D) (η : (CategoryTheory.shiftFunctor C 1).comp F ⟶ F.comp (CategoryTheory.shiftFunctor D 1)) (hF : ∀ (c c' : C), F.map 0 = 0)
Goal: ∀ {X Y : CategoryTheory.DifferentialObject S C} (f : X ⟶ Y),
  ((CategoryTheory.Functor.mapDifferentialObject D F η hF).map f).f = F.map f.f
-- CategoryTheory.DifferentialObject.shiftFunctor_obj_d
@[simps]
def shiftFunctor (n : S) : DifferentialObject S C ⥤ DifferentialObject S C 
Arguments: {S : Type u_1} [AddCommGroupWithOne S] (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.HasShift C S] (n : S) (X : CategoryTheory.DifferentialObject S C)
Goal: ((CategoryTheory.DifferentialObject.shiftFunctor C n).obj X).d =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctor C n).map X.d)
    (CategoryTheory.shiftComm X.obj 1 n).hom
-- CategoryTheory.DifferentialObject.shiftFunctor_obj_obj
@[simps]
def shiftFunctor (n : S) : DifferentialObject S C ⥤ DifferentialObject S C 
Arguments: {S : Type u_1} [AddCommGroupWithOne S] (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.HasShift C S] (n : S) (X : CategoryTheory.DifferentialObject S C)
Goal: ((CategoryTheory.DifferentialObject.shiftFunctor C n).obj X).obj = (CategoryTheory.shiftFunctor C n).obj X.obj
-- CategoryTheory.DifferentialObject.shiftFunctor_map_f
@[simps]
def shiftFunctor (n : S) : DifferentialObject S C ⥤ DifferentialObject S C 
Arguments: {S : Type u_1} [AddCommGroupWithOne S] (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.HasShift C S] (n : S)
Goal: ∀ {X Y : CategoryTheory.DifferentialObject S C} (f : X ⟶ Y),
  ((CategoryTheory.DifferentialObject.shiftFunctor C n).map f).f = (CategoryTheory.shiftFunctor C n).map f.f
-- CategoryTheory.DifferentialObject.shiftFunctorAdd_hom_app_f
@[simps!]
nonrec def shiftFunctorAdd (m n : S) :
    shiftFunctor C (m + n) ≅ shiftFunctor C m ⋙ shiftFunctor C n 
Arguments: {S : Type u_1} [AddCommGroupWithOne S] (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.HasShift C S] (m n : S) (X : CategoryTheory.DifferentialObject S C)
Goal: ((CategoryTheory.DifferentialObject.shiftFunctorAdd C m n).hom.app X).f =
  (CategoryTheory.shiftFunctorAdd C m n).hom.app X.obj
-- CategoryTheory.DifferentialObject.shiftFunctorAdd_inv_app_f
@[simps!]
nonrec def shiftFunctorAdd (m n : S) :
    shiftFunctor C (m + n) ≅ shiftFunctor C m ⋙ shiftFunctor C n 
Arguments: {S : Type u_1} [AddCommGroupWithOne S] (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.HasShift C S] (m n : S) (X : CategoryTheory.DifferentialObject S C)
Goal: ((CategoryTheory.DifferentialObject.shiftFunctorAdd C m n).inv.app X).f =
  (CategoryTheory.shiftFunctorAdd C m n).inv.app X.obj
-- CategoryTheory.DifferentialObject.shiftZero_hom_app_f
@[simps!]
def shiftZero : shiftFunctor C (0 : S) ≅ 𝟭 (DifferentialObject S C) 
Arguments: {S : Type u_1} [AddCommGroupWithOne S] (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.HasShift C S] (X : CategoryTheory.DifferentialObject S C)
Goal: ((CategoryTheory.DifferentialObject.shiftZero C).hom.app X).f = (CategoryTheory.shiftFunctorZero C S).hom.app X.obj
-- CategoryTheory.DifferentialObject.shiftZero_inv_app_f
@[simps!]
def shiftZero : shiftFunctor C (0 : S) ≅ 𝟭 (DifferentialObject S C) 
Arguments: {S : Type u_1} [AddCommGroupWithOne S] (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.HasShift C S] (X : CategoryTheory.DifferentialObject S C)
Goal: ((CategoryTheory.DifferentialObject.shiftZero C).inv.app X).f = (CategoryTheory.shiftFunctorZero C S).inv.app X.obj
-- CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.prod_uniq
lemma prod_uniq (F₁ F₂ : (W₁.Localization × W₂.Localization ⥤ E))
    (h : (W₁.Q.prod W₂.Q) ⋙ F₁ = (W₁.Q.prod W₂.Q) ⋙ F₂) :
      F₁ = F₂ 
Arguments: {C₁ : Type u₁} {C₂ : Type u₂} [CategoryTheory.Category.{v₁, u₁} C₁] [CategoryTheory.Category.{v₂, u₂} C₂] {W₁ : CategoryTheory.MorphismProperty C₁} {W₂ : CategoryTheory.MorphismProperty C₂} {E : Type u₅} [CategoryTheory.Category.{v₅, u₅} E] (F₁ F₂ : CategoryTheory.Functor (W₁.Localization × W₂.Localization) E) (h : (W₁.Q.prod W₂.Q).comp F₁ = (W₁.Q.prod W₂.Q).comp F₂)
Goal: F₁ = F₂
-- CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.prod_fac₁
lemma prod_fac₁ [W₂.ContainsIdentities] :
    W₁.Q ⋙ prodLift₁ F hF = curry.obj F 
Arguments: {C₁ : Type u₁} {C₂ : Type u₂} [CategoryTheory.Category.{v₁, u₁} C₁] [CategoryTheory.Category.{v₂, u₂} C₂] {W₁ : CategoryTheory.MorphismProperty C₁} {W₂ : CategoryTheory.MorphismProperty C₂} {E : Type u₅} [CategoryTheory.Category.{v₅, u₅} E] (F : CategoryTheory.Functor (C₁ × C₂) E) (hF : (W₁.prod W₂).IsInvertedBy F) [W₂.ContainsIdentities]
Goal: W₁.Q.comp (CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.prodLift₁ F hF) = CategoryTheory.curry.obj F
-- CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.prod_fac₂
lemma prod_fac₂ :
    W₂.Q ⋙ (curry.obj (prodLift F hF)).flip = (prodLift₁ F hF).flip 
Arguments: {C₁ : Type u₁} {C₂ : Type u₂} [CategoryTheory.Category.{v₁, u₁} C₁] [CategoryTheory.Category.{v₂, u₂} C₂] {W₁ : CategoryTheory.MorphismProperty C₁} {W₂ : CategoryTheory.MorphismProperty C₂} {E : Type u₅} [CategoryTheory.Category.{v₅, u₅} E] (F : CategoryTheory.Functor (C₁ × C₂) E) (hF : (W₁.prod W₂).IsInvertedBy F) [W₁.ContainsIdentities] [W₂.ContainsIdentities]
Goal: W₂.Q.comp
    (CategoryTheory.curry.obj (CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.prodLift F hF)).flip =
  (CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.prodLift₁ F hF).flip
-- CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.prod_fac
lemma prod_fac :
    (W₁.Q.prod W₂.Q) ⋙ prodLift F hF = F 
Arguments: {C₁ : Type u₁} {C₂ : Type u₂} [CategoryTheory.Category.{v₁, u₁} C₁] [CategoryTheory.Category.{v₂, u₂} C₂] {W₁ : CategoryTheory.MorphismProperty C₁} {W₂ : CategoryTheory.MorphismProperty C₂} {E : Type u₅} [CategoryTheory.Category.{v₅, u₅} E] (F : CategoryTheory.Functor (C₁ × C₂) E) (hF : (W₁.prod W₂).IsInvertedBy F) [W₁.ContainsIdentities] [W₂.ContainsIdentities]
Goal: (W₁.Q.prod W₂.Q).comp (CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.prodLift F hF) = F
-- CategoryTheory.Localization.Construction.prodIsLocalization
lemma Construction.prodIsLocalization :
    (W₁.Q.prod W₂.Q).IsLocalization (W₁.prod W₂) 
Arguments: {C₁ : Type u₁} {C₂ : Type u₂} [CategoryTheory.Category.{v₁, u₁} C₁] [CategoryTheory.Category.{v₂, u₂} C₂] (W₁ : CategoryTheory.MorphismProperty C₁) (W₂ : CategoryTheory.MorphismProperty C₂) [W₁.ContainsIdentities] [W₂.ContainsIdentities]
Goal: (W₁.Q.prod W₂.Q).IsLocalization (W₁.prod W₂)
-- CategoryTheory.Localization.structuredArrowEquiv_apply
@[simps]
noncomputable def structuredArrowEquiv :
    StructuredArrow (L.obj X) L ≃ StructuredArrow (L'.obj X) L' 
Arguments: {C : Type u_1} {D : Type u_2} {D' : Type u_3} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_5, u_2} D] [CategoryTheory.Category.{u_6, u_3} D'] (W : CategoryTheory.MorphismProperty C) (L : CategoryTheory.Functor C D) (L' : CategoryTheory.Functor C D') [L.IsLocalization W] [L'.IsLocalization W] {X : C} (f : CategoryTheory.StructuredArrow (L.obj X) L)
Goal: (CategoryTheory.Localization.structuredArrowEquiv W L L') f =
  CategoryTheory.StructuredArrow.mk ((CategoryTheory.Localization.homEquiv W L L') f.hom)
-- CategoryTheory.Localization.structuredArrowEquiv_symm_apply
@[simps]
noncomputable def structuredArrowEquiv :
    StructuredArrow (L.obj X) L ≃ StructuredArrow (L'.obj X) L' 
Arguments: {C : Type u_1} {D : Type u_2} {D' : Type u_3} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_5, u_2} D] [CategoryTheory.Category.{u_6, u_3} D'] (W : CategoryTheory.MorphismProperty C) (L : CategoryTheory.Functor C D) (L' : CategoryTheory.Functor C D') [L.IsLocalization W] [L'.IsLocalization W] {X : C} (f : CategoryTheory.StructuredArrow (L'.obj X) L')
Goal: (CategoryTheory.Localization.structuredArrowEquiv W L L').symm f =
  CategoryTheory.StructuredArrow.mk ((CategoryTheory.Localization.homEquiv W L' L) f.hom)
-- _private.Mathlib.CategoryTheory.Localization.StructuredArrow.0.CategoryTheory.Localization.induction_structuredArrow'
private lemma induction_structuredArrow' (g : StructuredArrow (W.Q.obj X) W.Q) : P g 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_4, u_1} C] (W : CategoryTheory.MorphismProperty C) {X : C} (P : CategoryTheory.StructuredArrow (W.Q.obj X) W.Q → Prop) (hP₀ : P (CategoryTheory.StructuredArrow.mk (CategoryTheory.CategoryStruct.id (W.Q.obj X)))) (hP₁ :
  ∀ ⦃Y₁ Y₂ : C⦄ (f : Y₁ ⟶ Y₂) (φ : W.Q.obj X ⟶ W.Q.obj Y₁),
    P (CategoryTheory.StructuredArrow.mk φ) →
      P (CategoryTheory.StructuredArrow.mk (CategoryTheory.CategoryStruct.comp φ (W.Q.map f)))) (hP₂ :
  ∀ ⦃Y₁ Y₂ : C⦄ (w : Y₁ ⟶ Y₂) (hw : W w) (φ : W.Q.obj X ⟶ W.Q.obj Y₂),
    P (CategoryTheory.StructuredArrow.mk φ) →
      P
        (CategoryTheory.StructuredArrow.mk
          (CategoryTheory.CategoryStruct.comp φ (CategoryTheory.Localization.isoOfHom W.Q W w hw).inv))) (g : CategoryTheory.StructuredArrow (W.Q.obj X) W.Q)
Goal: P g
-- CategoryTheory.Localization.induction_structuredArrow
@[elab_as_elim]
lemma induction_structuredArrow (g : StructuredArrow (L.obj X) L) : P g 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_5, u_2} D] (L : CategoryTheory.Functor C D) (W : CategoryTheory.MorphismProperty C) [L.IsLocalization W] {X : C} (P : CategoryTheory.StructuredArrow (L.obj X) L → Prop) (hP₀ : P (CategoryTheory.StructuredArrow.mk (CategoryTheory.CategoryStruct.id (L.obj X)))) (hP₁ :
  ∀ ⦃Y₁ Y₂ : C⦄ (f : Y₁ ⟶ Y₂) (φ : L.obj X ⟶ L.obj Y₁),
    P (CategoryTheory.StructuredArrow.mk φ) →
      P (CategoryTheory.StructuredArrow.mk (CategoryTheory.CategoryStruct.comp φ (L.map f)))) (hP₂ :
  ∀ ⦃Y₁ Y₂ : C⦄ (w : Y₁ ⟶ Y₂) (hw : W w) (φ : L.obj X ⟶ L.obj Y₂),
    P (CategoryTheory.StructuredArrow.mk φ) →
      P
        (CategoryTheory.StructuredArrow.mk
          (CategoryTheory.CategoryStruct.comp φ (CategoryTheory.Localization.isoOfHom L W w hw).inv))) (g : CategoryTheory.StructuredArrow (L.obj X) L)
Goal: P g
-- CategoryTheory.Localization.induction_costructuredArrow
@[elab_as_elim]
lemma induction_costructuredArrow (g : CostructuredArrow L (L.obj Y)) : P g 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_5, u_2} D] (L : CategoryTheory.Functor C D) (W : CategoryTheory.MorphismProperty C) [L.IsLocalization W] {Y : C} (P : CategoryTheory.CostructuredArrow L (L.obj Y) → Prop) (hP₀ : P (CategoryTheory.CostructuredArrow.mk (CategoryTheory.CategoryStruct.id (L.obj Y)))) (hP₁ :
  ∀ ⦃X₁ X₂ : C⦄ (f : X₁ ⟶ X₂) (φ : L.obj X₂ ⟶ L.obj Y),
    P (CategoryTheory.CostructuredArrow.mk φ) →
      P (CategoryTheory.CostructuredArrow.mk (CategoryTheory.CategoryStruct.comp (L.map f) φ))) (hP₂ :
  ∀ ⦃X₁ X₂ : C⦄ (w : X₁ ⟶ X₂) (hw : W w) (φ : L.obj X₁ ⟶ L.obj Y),
    P (CategoryTheory.CostructuredArrow.mk φ) →
      P
        (CategoryTheory.CostructuredArrow.mk
          (CategoryTheory.CategoryStruct.comp (CategoryTheory.Localization.isoOfHom L W w hw).inv φ))) (g : CategoryTheory.CostructuredArrow L (L.obj Y))
Goal: P g
-- CategoryTheory.MorphismProperty.HasLocalization.hL
class HasLocalization where
    {D : Type u}
    [hD : Category.{w} D]
    L : C ⥤ D
  [hL : L.IsLocalization W]
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C} [self : W.HasLocalization]
Goal: CategoryTheory.MorphismProperty.HasLocalization.L.IsLocalization W
-- CategoryTheory.GrothendieckTopology.diagram_obj
@[simps]
def diagram (X : C) : (J.Cover X)ᵒᵖ ⥤ D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type w} [CategoryTheory.Category.{max v u, w} D] [∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : J.Cover X), CategoryTheory.Limits.HasMultiequalizer (S.index P)] (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : (J.Cover X)ᵒᵖ)
Goal: (J.diagram P X).obj S = CategoryTheory.Limits.multiequalizer ((Opposite.unop S).index P)
-- CategoryTheory.GrothendieckTopology.diagram_map
@[simps]
def diagram (X : C) : (J.Cover X)ᵒᵖ ⥤ D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type w} [CategoryTheory.Category.{max v u, w} D] [∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : J.Cover X), CategoryTheory.Limits.HasMultiequalizer (S.index P)] (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) {S T : (J.Cover X)ᵒᵖ} (f : S ⟶ T)
Goal: (J.diagram P X).map f =
  CategoryTheory.Limits.Multiequalizer.lift ((Opposite.unop T).index P)
    ((fun S => CategoryTheory.Limits.multiequalizer ((Opposite.unop S).index P)) S)
    (fun I =>
      CategoryTheory.Limits.Multiequalizer.ι ((Opposite.unop S).index P)
        (CategoryTheory.GrothendieckTopology.Cover.Arrow.map I f.unop))
    ⋯
-- CategoryTheory.GrothendieckTopology.diagramPullback_app
@[simps]
def diagramPullback {X Y : C} (f : X ⟶ Y) : J.diagram P Y ⟶ (J.pullback f).op ⋙ J.diagram P X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type w} [CategoryTheory.Category.{max v u, w} D] [∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : J.Cover X), CategoryTheory.Limits.HasMultiequalizer (S.index P)] (P : CategoryTheory.Functor Cᵒᵖ D) {X Y : C} (f : X ⟶ Y) (S : (J.Cover Y)ᵒᵖ)
Goal: (J.diagramPullback P f).app S =
  CategoryTheory.Limits.Multiequalizer.lift ((Opposite.unop ((J.pullback f).op.obj S)).index P) ((J.diagram P Y).obj S)
    (fun I =>
      CategoryTheory.Limits.Multiequalizer.ι ((Opposite.unop S).index P)
        (CategoryTheory.GrothendieckTopology.Cover.Arrow.base I))
    ⋯