ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Coyoneda.fullyFaithful_preimage
lemma fullyFaithful_preimage {X Y : Cᵒᵖ} (f : coyoneda.obj X ⟶ coyoneda.obj Y) :
    fullyFaithful.preimage f = (f.app X.unop (𝟙 X.unop)).op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : Cᵒᵖ} (f : CategoryTheory.coyoneda.obj X ⟶ CategoryTheory.coyoneda.obj Y)
Goal: CategoryTheory.Coyoneda.fullyFaithful.preimage f =
  Quiver.Hom.op (f.app (Opposite.unop X) (CategoryTheory.CategoryStruct.id (Opposite.unop X)))
-- CategoryTheory.Coyoneda.isIso
theorem isIso {X Y : Cᵒᵖ} (f : X ⟶ Y) [IsIso (coyoneda.map f)] : IsIso f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : Cᵒᵖ} (f : X ⟶ Y) [CategoryTheory.IsIso (CategoryTheory.coyoneda.map f)]
Goal: CategoryTheory.IsIso f
-- CategoryTheory.Coyoneda.objOpOp_inv_app
@[simps!]
def objOpOp (X : C) : coyoneda.obj (op (op X)) ≅ yoneda.obj X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (X : C)
Goal: ∀ (X_1 : Cᵒᵖ) (a : (CategoryTheory.yoneda.obj X).obj X_1),
  (CategoryTheory.Coyoneda.objOpOp X).inv.app X_1 a = (CategoryTheory.opEquiv (Opposite.op X) X_1).symm a
-- CategoryTheory.Coyoneda.objOpOp_hom_app
@[simps!]
def objOpOp (X : C) : coyoneda.obj (op (op X)) ≅ yoneda.obj X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (X : C)
Goal: ∀ (X_1 : Cᵒᵖ) (a : (CategoryTheory.coyoneda.obj (Opposite.op (Opposite.op X))).obj X_1),
  (CategoryTheory.Coyoneda.objOpOp X).hom.app X_1 a = (CategoryTheory.opEquiv (Opposite.op X) X_1) a
-- CategoryTheory.Functor.Representable.has_representation
class Representable (F : Cᵒᵖ ⥤ Type v₁) : Prop where
    has_representation : ∃ (X : _), Nonempty (yoneda.obj X ≅ F)
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {F : CategoryTheory.Functor Cᵒᵖ (Type v₁)} [self : F.Representable]
Goal: ∃ X, Nonempty (CategoryTheory.yoneda.obj X ≅ F)
-- CategoryTheory.Functor.Corepresentable.has_corepresentation
class Corepresentable (F : C ⥤ Type v₁) : Prop where
    has_corepresentation : ∃ (X : _), Nonempty (coyoneda.obj X ≅ F)
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {F : CategoryTheory.Functor C (Type v₁)} [self : F.Corepresentable]
Goal: ∃ X, Nonempty (CategoryTheory.coyoneda.obj X ≅ F)
-- CategoryTheory.Functor.reprW_app_hom
theorem reprW_app_hom (X : Cᵒᵖ) (f : unop X ⟶ F.reprX) :
    (F.reprW.app X).hom f = F.map f.op F.reprx 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (F : CategoryTheory.Functor Cᵒᵖ (Type v₁)) [hF : F.Representable] (X : Cᵒᵖ) (f : Opposite.unop X ⟶ F.reprX)
Goal: (F.reprW.app X).hom f = F.map f.op F.reprx
-- CategoryTheory.Functor.coreprW_app_hom
theorem coreprW_app_hom (X : C) (f : F.coreprX ⟶ X) :
    (F.coreprW.app X).hom f = F.map f F.coreprx 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (F : CategoryTheory.Functor C (Type v₁)) [hF : F.Corepresentable] (X : C) (f : F.coreprX ⟶ X)
Goal: (F.coreprW.app X).hom f = F.map f F.coreprx
-- CategoryTheory.representable_of_natIso
theorem representable_of_natIso (F : Cᵒᵖ ⥤ Type v₁) {G} (i : F ≅ G) [F.Representable] :
    G.Representable 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (F : CategoryTheory.Functor Cᵒᵖ (Type v₁)) {G : CategoryTheory.Functor Cᵒᵖ (Type v₁)} (i : F ≅ G) [F.Representable]
Goal: G.Representable
-- CategoryTheory.corepresentable_of_natIso
theorem corepresentable_of_natIso (F : C ⥤ Type v₁) {G} (i : F ≅ G) [F.Corepresentable] :
    G.Corepresentable 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (F : CategoryTheory.Functor C (Type v₁)) {G : CategoryTheory.Functor C (Type v₁)} (i : F ≅ G) [F.Corepresentable]
Goal: G.Corepresentable
-- CategoryTheory.yonedaEquiv_apply
theorem yonedaEquiv_apply {X : C} {F : Cᵒᵖ ⥤ Type v₁} (f : yoneda.obj X ⟶ F) :
    yonedaEquiv f = f.app (op X) (𝟙 X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} {F : CategoryTheory.Functor Cᵒᵖ (Type v₁)} (f : CategoryTheory.yoneda.obj X ⟶ F)
Goal: CategoryTheory.yonedaEquiv f = f.app (Opposite.op X) (CategoryTheory.CategoryStruct.id X)
-- CategoryTheory.yonedaEquiv_symm_app_apply
@[simp]
theorem yonedaEquiv_symm_app_apply {X : C} {F : Cᵒᵖ ⥤ Type v₁} (x : F.obj (op X)) (Y : Cᵒᵖ)
    (f : Y.unop ⟶ X) : (yonedaEquiv.symm x).app Y f = F.map f.op x 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} {F : CategoryTheory.Functor Cᵒᵖ (Type v₁)} (x : F.obj (Opposite.op X)) (Y : Cᵒᵖ) (f : Opposite.unop Y ⟶ X)
Goal: (CategoryTheory.yonedaEquiv.symm x).app Y f = F.map f.op x
-- CategoryTheory.yonedaEquiv_naturality
lemma yonedaEquiv_naturality {X Y : C} {F : Cᵒᵖ ⥤ Type v₁} (f : yoneda.obj X ⟶ F)
    (g : Y ⟶ X) : F.map g.op (yonedaEquiv f) = yonedaEquiv (yoneda.map g ≫ f) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {F : CategoryTheory.Functor Cᵒᵖ (Type v₁)} (f : CategoryTheory.yoneda.obj X ⟶ F) (g : Y ⟶ X)
Goal: F.map g.op (CategoryTheory.yonedaEquiv f) =
  CategoryTheory.yonedaEquiv (CategoryTheory.CategoryStruct.comp (CategoryTheory.yoneda.map g) f)
-- CategoryTheory.yonedaEquiv_naturality'
lemma yonedaEquiv_naturality' {X Y : Cᵒᵖ} {F : Cᵒᵖ ⥤ Type v₁} (f : yoneda.obj (unop X) ⟶ F)
    (g : X ⟶ Y) : F.map g (yonedaEquiv f) = yonedaEquiv (yoneda.map g.unop ≫ f) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : Cᵒᵖ} {F : CategoryTheory.Functor Cᵒᵖ (Type v₁)} (f : CategoryTheory.yoneda.obj (Opposite.unop X) ⟶ F) (g : X ⟶ Y)
Goal: F.map g (CategoryTheory.yonedaEquiv f) =
  CategoryTheory.yonedaEquiv (CategoryTheory.CategoryStruct.comp (CategoryTheory.yoneda.map g.unop) f)
-- CategoryTheory.yonedaEquiv_comp
lemma yonedaEquiv_comp {X : C} {F G : Cᵒᵖ ⥤ Type v₁} (α : yoneda.obj X ⟶ F) (β : F ⟶ G) :
    yonedaEquiv (α ≫ β) = β.app _ (yonedaEquiv α) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} {F G : CategoryTheory.Functor Cᵒᵖ (Type v₁)} (α : CategoryTheory.yoneda.obj X ⟶ F) (β : F ⟶ G)
Goal: CategoryTheory.yonedaEquiv (CategoryTheory.CategoryStruct.comp α β) =
  β.app (Opposite.op X) (CategoryTheory.yonedaEquiv α)
-- CategoryTheory.yonedaEquiv_yoneda_map
lemma yonedaEquiv_yoneda_map {X Y : C} (f : X ⟶ Y) : yonedaEquiv (yoneda.map f) = f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y)
Goal: CategoryTheory.yonedaEquiv (CategoryTheory.yoneda.map f) = f
-- CategoryTheory.yonedaEquiv_symm_map
lemma yonedaEquiv_symm_map {X Y : Cᵒᵖ} (f : X ⟶ Y) {F : Cᵒᵖ ⥤ Type v₁} (t : F.obj X) :
    yonedaEquiv.symm (F.map f t) = yoneda.map f.unop ≫ yonedaEquiv.symm t 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : Cᵒᵖ} (f : X ⟶ Y) {F : CategoryTheory.Functor Cᵒᵖ (Type v₁)} (t : F.obj X)
Goal: CategoryTheory.yonedaEquiv.symm (F.map f t) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.yoneda.map f.unop) (CategoryTheory.yonedaEquiv.symm t)
-- CategoryTheory.hom_ext_yoneda
lemma hom_ext_yoneda {P Q : Cᵒᵖ ⥤ Type v₁} {f g : P ⟶ Q}
    (h : ∀ (X : C) (p : yoneda.obj X ⟶ P), p ≫ f = p ≫ g) :
    f = g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P Q : CategoryTheory.Functor Cᵒᵖ (Type v₁)} {f g : P ⟶ Q} (h :
  ∀ (X : C) (p : CategoryTheory.yoneda.obj X ⟶ P),
    CategoryTheory.CategoryStruct.comp p f = CategoryTheory.CategoryStruct.comp p g)
Goal: f = g
-- CategoryTheory.yonedaEvaluation_map_down
@[simp]
theorem yonedaEvaluation_map_down (P Q : Cᵒᵖ × (Cᵒᵖ ⥤ Type v₁)) (α : P ⟶ Q)
    (x : (yonedaEvaluation C).obj P) :
    ((yonedaEvaluation C).map α x).down = α.2.app Q.1 (P.2.map α.1 x.down) 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (P Q : Cᵒᵖ × CategoryTheory.Functor Cᵒᵖ (Type v₁)) (α : P ⟶ Q) (x : (CategoryTheory.yonedaEvaluation C).obj P)
Goal: ((CategoryTheory.yonedaEvaluation C).map α x).down = α.2.app Q.1 (P.2.map α.1 x.down)
-- CategoryTheory.yonedaPairingExt
@[ext]
lemma yonedaPairingExt {X : Cᵒᵖ × (Cᵒᵖ ⥤ Type v₁)} {x y : (yonedaPairing C).obj X}
    (w : ∀ Y, x.app Y = y.app Y) : x = y 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] {X : Cᵒᵖ × CategoryTheory.Functor Cᵒᵖ (Type v₁)} {x y : (CategoryTheory.yonedaPairing C).obj X} (w : ∀ (Y : Cᵒᵖ), x.app Y = y.app Y)
Goal: x = y
-- CategoryTheory.yonedaPairing_map
@[simp]
theorem yonedaPairing_map (P Q : Cᵒᵖ × (Cᵒᵖ ⥤ Type v₁)) (α : P ⟶ Q) (β : (yonedaPairing C).obj P) :
    (yonedaPairing C).map α β = yoneda.map α.1.unop ≫ β ≫ α.2 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (P Q : Cᵒᵖ × CategoryTheory.Functor Cᵒᵖ (Type v₁)) (α : P ⟶ Q) (β : (CategoryTheory.yonedaPairing C).obj P)
Goal: (CategoryTheory.yonedaPairing C).map α β =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.yoneda.map α.1.unop) (CategoryTheory.CategoryStruct.comp β α.2)
-- CategoryTheory.isIso_of_yoneda_map_bijective
lemma isIso_of_yoneda_map_bijective {X Y : C} (f : X ⟶ Y)
    (hf : ∀ (T : C), Function.Bijective (fun (x : T ⟶ X) => x ≫ f)) :
    IsIso f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) (hf : ∀ (T : C), Function.Bijective fun x => CategoryTheory.CategoryStruct.comp x f)
Goal: CategoryTheory.IsIso f
-- CategoryTheory.coyonedaEquiv_apply
theorem coyonedaEquiv_apply {X : C} {F : C ⥤ Type v₁} (f : coyoneda.obj (op X) ⟶ F) :
    coyonedaEquiv f = f.app X (𝟙 X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} {F : CategoryTheory.Functor C (Type v₁)} (f : CategoryTheory.coyoneda.obj (Opposite.op X) ⟶ F)
Goal: CategoryTheory.coyonedaEquiv f = f.app X (CategoryTheory.CategoryStruct.id X)
-- CategoryTheory.coyonedaEquiv_symm_app_apply
@[simp]
theorem coyonedaEquiv_symm_app_apply {X : C} {F : C ⥤ Type v₁} (x : F.obj X) (Y : C)
    (f : X ⟶ Y) : (coyonedaEquiv.symm x).app Y f = F.map f x 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} {F : CategoryTheory.Functor C (Type v₁)} (x : F.obj X) (Y : C) (f : X ⟶ Y)
Goal: (CategoryTheory.coyonedaEquiv.symm x).app Y f = F.map f x
-- CategoryTheory.coyonedaEquiv_naturality
lemma coyonedaEquiv_naturality {X Y : C} {F : C ⥤ Type v₁} (f : coyoneda.obj (op X) ⟶ F)
    (g : X ⟶ Y) : F.map g (coyonedaEquiv f) = coyonedaEquiv (coyoneda.map g.op ≫ f) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {F : CategoryTheory.Functor C (Type v₁)} (f : CategoryTheory.coyoneda.obj (Opposite.op X) ⟶ F) (g : X ⟶ Y)
Goal: F.map g (CategoryTheory.coyonedaEquiv f) =
  CategoryTheory.coyonedaEquiv (CategoryTheory.CategoryStruct.comp (CategoryTheory.coyoneda.map g.op) f)
-- CategoryTheory.coyonedaEquiv_comp
lemma coyonedaEquiv_comp {X : C} {F G : C ⥤ Type v₁} (α : coyoneda.obj (op X) ⟶ F) (β : F ⟶ G) :
    coyonedaEquiv (α ≫ β) = β.app _ (coyonedaEquiv α) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} {F G : CategoryTheory.Functor C (Type v₁)} (α : CategoryTheory.coyoneda.obj (Opposite.op X) ⟶ F) (β : F ⟶ G)
Goal: CategoryTheory.coyonedaEquiv (CategoryTheory.CategoryStruct.comp α β) = β.app X (CategoryTheory.coyonedaEquiv α)
-- CategoryTheory.coyonedaEquiv_coyoneda_map
lemma coyonedaEquiv_coyoneda_map {X Y : C} (f : X ⟶ Y) :
    coyonedaEquiv (coyoneda.map f.op) = f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y)
Goal: CategoryTheory.coyonedaEquiv (CategoryTheory.coyoneda.map f.op) = f
-- CategoryTheory.coyonedaEquiv_symm_map
lemma coyonedaEquiv_symm_map {X Y : C} (f : X ⟶ Y) {F : C ⥤ Type v₁} (t : F.obj X) :
    coyonedaEquiv.symm (F.map f t) = coyoneda.map f.op ≫ coyonedaEquiv.symm t 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) {F : CategoryTheory.Functor C (Type v₁)} (t : F.obj X)
Goal: CategoryTheory.coyonedaEquiv.symm (F.map f t) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.coyoneda.map f.op) (CategoryTheory.coyonedaEquiv.symm t)
-- CategoryTheory.coyonedaEvaluation_map_down
@[simp]
theorem coyonedaEvaluation_map_down (P Q : C × (C ⥤ Type v₁)) (α : P ⟶ Q)
    (x : (coyonedaEvaluation C).obj P) :
    ((coyonedaEvaluation C).map α x).down = α.2.app Q.1 (P.2.map α.1 x.down) 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (P Q : C × CategoryTheory.Functor C (Type v₁)) (α : P ⟶ Q) (x : (CategoryTheory.coyonedaEvaluation C).obj P)
Goal: ((CategoryTheory.coyonedaEvaluation C).map α x).down = α.2.app Q.1 (P.2.map α.1 x.down)
-- CategoryTheory.coyonedaPairingExt
@[ext]
lemma coyonedaPairingExt {X : C × (C ⥤ Type v₁)} {x y : (coyonedaPairing C).obj X}
    (w : ∀ Y, x.app Y = y.app Y) : x = y 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] {X : C × CategoryTheory.Functor C (Type v₁)} {x y : (CategoryTheory.coyonedaPairing C).obj X} (w : ∀ (Y : C), x.app Y = y.app Y)
Goal: x = y
-- CategoryTheory.coyonedaPairing_map
@[simp]
theorem coyonedaPairing_map (P Q : C × (C ⥤ Type v₁)) (α : P ⟶ Q) (β : (coyonedaPairing C).obj P) :
    (coyonedaPairing C).map α β = coyoneda.map α.1.op ≫ β ≫ α.2 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (P Q : C × CategoryTheory.Functor C (Type v₁)) (α : P ⟶ Q) (β : (CategoryTheory.coyonedaPairing C).obj P)
Goal: (CategoryTheory.coyonedaPairing C).map α β =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.coyoneda.map α.1.op) (CategoryTheory.CategoryStruct.comp β α.2)
-- CategoryTheory.isIso_of_coyoneda_map_bijective
lemma isIso_of_coyoneda_map_bijective {X Y : C} (f : X ⟶ Y)
    (hf : ∀ (T : C), Function.Bijective (fun (x : Y ⟶ T) => f ≫ x)) :
    IsIso f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) (hf : ∀ (T : C), Function.Bijective fun x => CategoryTheory.CategoryStruct.comp f x)
Goal: CategoryTheory.IsIso f
-- CategoryTheory.yonedaMap_app_apply
@[simp]
lemma yonedaMap_app_apply {Y : C} {X : Cᵒᵖ} (f : X.unop ⟶ Y) :
    (yonedaMap F Y).app X f = F.map f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u_1} [CategoryTheory.Category.{v₁, u_1} D] (F : CategoryTheory.Functor C D) {Y : C} {X : Cᵒᵖ} (f : Opposite.unop X ⟶ Y)
Goal: (CategoryTheory.yonedaMap F Y).app X f = F.map f
-- CategoryTheory.MorphismProperty.IsCompatibleWithShift.condition
class IsCompatibleWithShift : Prop :=
    condition : ∀ (a : A), W.inverseImage (shiftFunctor C a) = W
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {W : CategoryTheory.MorphismProperty C} {A : Type w} [AddMonoid A] [CategoryTheory.HasShift C A] [self : W.IsCompatibleWithShift A] (a : A)
Goal: W.inverseImage (CategoryTheory.shiftFunctor C a) = W
-- CategoryTheory.MorphismProperty.IsCompatibleWithShift.iff
lemma iff {X Y : C} (f : X ⟶ Y) (a : A) : W (f⟦a⟧') ↔ W f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (W : CategoryTheory.MorphismProperty C) {A : Type w} [AddMonoid A] [CategoryTheory.HasShift C A] [W.IsCompatibleWithShift A] {X Y : C} (f : X ⟶ Y) (a : A)
Goal: W ((CategoryTheory.shiftFunctor C a).map f) ↔ W f
-- CategoryTheory.MorphismProperty.IsCompatibleWithShift.shiftFunctor_comp_inverts
lemma shiftFunctor_comp_inverts (a : A) :
    W.IsInvertedBy (shiftFunctor C a ⋙ L) 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] (L : CategoryTheory.Functor C D) (W : CategoryTheory.MorphismProperty C) [L.IsLocalization W] {A : Type w} [AddMonoid A] [CategoryTheory.HasShift C A] [W.IsCompatibleWithShift A] (a : A)
Goal: W.IsInvertedBy ((CategoryTheory.shiftFunctor C a).comp L)
-- CategoryTheory.Functor.commShiftOfLocalization.iso_hom_app
@[simp, reassoc]
lemma iso_hom_app (a : A) (X : C) :
    (commShiftOfLocalization.iso L W F F' a).hom.app (L.obj X) =
      F'.map ((L.commShiftIso a).inv.app X) ≫
      (Lifting.iso L W F F').hom.app (X⟦a⟧) ≫
        (F.commShiftIso a).hom.app X ≫
          (shiftFunctor E a).map ((Lifting.iso L W F F').inv.app X) 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (L : CategoryTheory.Functor C D) (W : CategoryTheory.MorphismProperty C) [L.IsLocalization W] {A : Type w} [AddMonoid A] [CategoryTheory.HasShift C A] (F : CategoryTheory.Functor C E) (F' : CategoryTheory.Functor D E) [CategoryTheory.Localization.Lifting L W F F'] [CategoryTheory.HasShift D A] [CategoryTheory.HasShift E A] [L.CommShift A] [F.CommShift A] (a : A) (X : C)
Goal: (CategoryTheory.Functor.commShiftOfLocalization.iso L W F F' a).hom.app (L.obj X) =
  CategoryTheory.CategoryStruct.comp (F'.map ((L.commShiftIso a).inv.app X))
    (CategoryTheory.CategoryStruct.comp
      ((CategoryTheory.Localization.Lifting.iso L W F F').hom.app ((CategoryTheory.shiftFunctor C a).obj X))
      (CategoryTheory.CategoryStruct.comp ((F.commShiftIso a).hom.app X)
        ((CategoryTheory.shiftFunctor E a).map ((CategoryTheory.Localization.Lifting.iso L W F F').inv.app X))))
-- CategoryTheory.Functor.commShiftOfLocalization.iso_inv_app
@[simp, reassoc]
lemma iso_inv_app (a : A) (X : C) :
    (commShiftOfLocalization.iso L W F F' a).inv.app (L.obj X) =
        (shiftFunctor E a).map ((Lifting.iso L W F F').hom.app X) ≫
        (F.commShiftIso a).inv.app X ≫
      (Lifting.iso L W F F').inv.app (X⟦a⟧) ≫
      F'.map ((L.commShiftIso a).hom.app X) 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (L : CategoryTheory.Functor C D) (W : CategoryTheory.MorphismProperty C) [L.IsLocalization W] {A : Type w} [AddMonoid A] [CategoryTheory.HasShift C A] (F : CategoryTheory.Functor C E) (F' : CategoryTheory.Functor D E) [CategoryTheory.Localization.Lifting L W F F'] [CategoryTheory.HasShift D A] [CategoryTheory.HasShift E A] [L.CommShift A] [F.CommShift A] (a : A) (X : C)
Goal: (CategoryTheory.Functor.commShiftOfLocalization.iso L W F F' a).inv.app (L.obj X) =
  CategoryTheory.CategoryStruct.comp
    ((CategoryTheory.shiftFunctor E a).map ((CategoryTheory.Localization.Lifting.iso L W F F').hom.app X))
    (CategoryTheory.CategoryStruct.comp ((F.commShiftIso a).inv.app X)
      (CategoryTheory.CategoryStruct.comp
        ((CategoryTheory.Localization.Lifting.iso L W F F').inv.app ((CategoryTheory.shiftFunctor C a).obj X))
        (F'.map ((L.commShiftIso a).hom.app X))))
-- CategoryTheory.Functor.commShiftOfLocalization_iso_hom_app
lemma commShiftOfLocalization_iso_hom_app (a : A) (X : C) :
    letI := Functor.commShiftOfLocalization L W A F F'
    (F'.commShiftIso a).hom.app (L.obj X) =
      F'.map ((L.commShiftIso a).inv.app X) ≫ (Lifting.iso L W F F').hom.app (X⟦a⟧) ≫
        (F.commShiftIso a).hom.app X ≫
          (shiftFunctor E a).map ((Lifting.iso L W F F').inv.app X) 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (L : CategoryTheory.Functor C D) (W : CategoryTheory.MorphismProperty C) [L.IsLocalization W] {A : Type w} [AddMonoid A] [CategoryTheory.HasShift C A] (F : CategoryTheory.Functor C E) (F' : CategoryTheory.Functor D E) [CategoryTheory.Localization.Lifting L W F F'] [CategoryTheory.HasShift D A] [CategoryTheory.HasShift E A] [L.CommShift A] [F.CommShift A] (a : A) (X : C)
Goal: (F'.commShiftIso a).hom.app (L.obj X) =
  CategoryTheory.CategoryStruct.comp (F'.map ((L.commShiftIso a).inv.app X))
    (CategoryTheory.CategoryStruct.comp
      ((CategoryTheory.Localization.Lifting.iso L W F F').hom.app ((CategoryTheory.shiftFunctor C a).obj X))
      (CategoryTheory.CategoryStruct.comp ((F.commShiftIso a).hom.app X)
        ((CategoryTheory.shiftFunctor E a).map ((CategoryTheory.Localization.Lifting.iso L W F F').inv.app X))))
-- CategoryTheory.Functor.commShiftOfLocalization_iso_inv_app
lemma commShiftOfLocalization_iso_inv_app (a : A) (X : C) :
    letI := Functor.commShiftOfLocalization L W A F F'
    (F'.commShiftIso a).inv.app (L.obj X) =
      (shiftFunctor E a).map ((Lifting.iso L W F F').hom.app X) ≫
      (F.commShiftIso a).inv.app X ≫ (Lifting.iso L W F F').inv.app (X⟦a⟧) ≫
     F'.map ((L.commShiftIso a).hom.app X) 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (L : CategoryTheory.Functor C D) (W : CategoryTheory.MorphismProperty C) [L.IsLocalization W] {A : Type w} [AddMonoid A] [CategoryTheory.HasShift C A] (F : CategoryTheory.Functor C E) (F' : CategoryTheory.Functor D E) [CategoryTheory.Localization.Lifting L W F F'] [CategoryTheory.HasShift D A] [CategoryTheory.HasShift E A] [L.CommShift A] [F.CommShift A] (a : A) (X : C)
Goal: (F'.commShiftIso a).inv.app (L.obj X) =
  CategoryTheory.CategoryStruct.comp
    ((CategoryTheory.shiftFunctor E a).map ((CategoryTheory.Localization.Lifting.iso L W F F').hom.app X))
    (CategoryTheory.CategoryStruct.comp ((F.commShiftIso a).inv.app X)
      (CategoryTheory.CategoryStruct.comp
        ((CategoryTheory.Localization.Lifting.iso L W F F').inv.app ((CategoryTheory.shiftFunctor C a).obj X))
        (F'.map ((L.commShiftIso a).hom.app X))))
-- CategoryTheory.preserves_mono_of_preservesLimit
theorem preserves_mono_of_preservesLimit {X Y : C} (f : X ⟶ Y) [PreservesLimit (cospan f f) F]
    [Mono f] : Mono (F.map f) 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f f) F] [CategoryTheory.Mono f]
Goal: CategoryTheory.Mono (F.map f)
-- CategoryTheory.reflects_mono_of_reflectsLimit
theorem reflects_mono_of_reflectsLimit {X Y : C} (f : X ⟶ Y) [ReflectsLimit (cospan f f) F]
    [Mono (F.map f)] : Mono f 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.ReflectsLimit (CategoryTheory.Limits.cospan f f) F] [CategoryTheory.Mono (F.map f)]
Goal: CategoryTheory.Mono f
-- CategoryTheory.preserves_epi_of_preservesColimit
theorem preserves_epi_of_preservesColimit {X Y : C} (f : X ⟶ Y) [PreservesColimit (span f f) F]
    [Epi f] : Epi (F.map f) 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.span f f) F] [CategoryTheory.Epi f]
Goal: CategoryTheory.Epi (F.map f)
-- CategoryTheory.reflects_epi_of_reflectsColimit
theorem reflects_epi_of_reflectsColimit {X Y : C} (f : X ⟶ Y) [ReflectsColimit (span f f) F]
    [Epi (F.map f)] : Epi f 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.ReflectsColimit (CategoryTheory.Limits.span f f) F] [CategoryTheory.Epi (F.map f)]
Goal: CategoryTheory.Epi f
-- CategoryTheory.Discrete.mk_as
@[simp]
theorem Discrete.mk_as {α : Type u₁} (X : Discrete α) : Discrete.mk X.as = X 
Arguments: {α : Type u₁} (X : CategoryTheory.Discrete α)
Goal: { as := X.as } = X
-- CategoryTheory.discreteEquiv_symm_apply_as
@[simps]
def discreteEquiv {α : Type u₁} : Discrete α ≃ α 
Arguments: {α : Type u₁} (as : α)
Goal: (CategoryTheory.discreteEquiv.symm as).as = as
-- CategoryTheory.discreteEquiv_apply
@[simps]
def discreteEquiv {α : Type u₁} : Discrete α ≃ α 
Arguments: {α : Type u₁} (self : CategoryTheory.Discrete α)
Goal: CategoryTheory.discreteEquiv self = self.as
-- CategoryTheory.Discrete.eq_of_hom
theorem eq_of_hom {X Y : Discrete α} (i : X ⟶ Y) : X.as = Y.as 
Arguments: {α : Type u₁} {X Y : CategoryTheory.Discrete α} (i : X ⟶ Y)
Goal: X.as = Y.as
-- CategoryTheory.Discrete.id_def
@[simp]
theorem id_def (X : Discrete α) : ULift.up (PLift.up (Eq.refl X.as)) = 𝟙 X 
Arguments: {α : Type u₁} (X : CategoryTheory.Discrete α)
Goal: { down := { down := ⋯ } } = CategoryTheory.CategoryStruct.id X
-- CategoryTheory.Discrete.functor_obj
@[simp]
theorem functor_obj {I : Type u₁} (F : I → C) (i : I) :
    (Discrete.functor F).obj (Discrete.mk i) = F i 
Arguments: {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {I : Type u₁} (F : I → C) (i : I)
Goal: (CategoryTheory.Discrete.functor F).obj { as := i } = F i