ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Limits.Pi.whiskerEquiv_inv
@[simps]
def Pi.whiskerEquiv {J K : Type*} {f : J → C} {g : K → C} (e : J ≃ K) (w : ∀ j, g (e j) ≅ f j)
    [HasProduct f] [HasProduct g] : ∏ᶜ f ≅ ∏ᶜ g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type u_1} {K : Type u_2} {f : J → C} {g : K → C} (e : J ≃ K) (w : (j : J) → g (e j) ≅ f j) [CategoryTheory.Limits.HasProduct f] [CategoryTheory.Limits.HasProduct g]
Goal: (CategoryTheory.Limits.Pi.whiskerEquiv e w).inv = CategoryTheory.Limits.Pi.map' ⇑e fun j => (w j).hom
-- CategoryTheory.Limits.Sigma.whiskerEquiv_inv
@[simps]
def Sigma.whiskerEquiv {J K : Type*} {f : J → C} {g : K → C} (e : J ≃ K) (w : ∀ j, g (e j) ≅ f j)
    [HasCoproduct f] [HasCoproduct g] : ∐ f ≅ ∐ g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type u_1} {K : Type u_2} {f : J → C} {g : K → C} (e : J ≃ K) (w : (j : J) → g (e j) ≅ f j) [CategoryTheory.Limits.HasCoproduct f] [CategoryTheory.Limits.HasCoproduct g]
Goal: (CategoryTheory.Limits.Sigma.whiskerEquiv e w).inv =
  CategoryTheory.Limits.Sigma.map' ⇑e.symm fun k => CategoryTheory.eqToHom ⋯ ≫ (w (e.symm k)).hom
-- CategoryTheory.Limits.Sigma.whiskerEquiv_hom
@[simps]
def Sigma.whiskerEquiv {J K : Type*} {f : J → C} {g : K → C} (e : J ≃ K) (w : ∀ j, g (e j) ≅ f j)
    [HasCoproduct f] [HasCoproduct g] : ∐ f ≅ ∐ g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type u_1} {K : Type u_2} {f : J → C} {g : K → C} (e : J ≃ K) (w : (j : J) → g (e j) ≅ f j) [CategoryTheory.Limits.HasCoproduct f] [CategoryTheory.Limits.HasCoproduct g]
Goal: (CategoryTheory.Limits.Sigma.whiskerEquiv e w).hom = CategoryTheory.Limits.Sigma.map' ⇑e fun j => (w j).inv
-- CategoryTheory.Limits.piPiIso_inv
@[simps]
def piPiIso {ι : Type*} (f : ι → Type*) (g : (i : ι) → (f i) → C)
    [∀ i, HasProduct (g i)] [HasProduct fun i => ∏ᶜ g i] :
    (∏ᶜ fun i => ∏ᶜ g i) ≅ (∏ᶜ fun p : Σ i, f i => g p.1 p.2) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {ι : Type u_1} (f : ι → Type u_2) (g : (i : ι) → f i → C) [∀ (i : ι), CategoryTheory.Limits.HasProduct (g i)] [CategoryTheory.Limits.HasProduct fun i => ∏ᶜ g i]
Goal: (CategoryTheory.Limits.piPiIso f g).inv =
  CategoryTheory.Limits.Pi.lift fun i =>
    CategoryTheory.Limits.Pi.lift fun x => CategoryTheory.Limits.Pi.π (fun p => g p.fst p.snd) ⟨i, x⟩
-- CategoryTheory.Limits.piPiIso_hom
@[simps]
def piPiIso {ι : Type*} (f : ι → Type*) (g : (i : ι) → (f i) → C)
    [∀ i, HasProduct (g i)] [HasProduct fun i => ∏ᶜ g i] :
    (∏ᶜ fun i => ∏ᶜ g i) ≅ (∏ᶜ fun p : Σ i, f i => g p.1 p.2) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {ι : Type u_1} (f : ι → Type u_2) (g : (i : ι) → f i → C) [∀ (i : ι), CategoryTheory.Limits.HasProduct (g i)] [CategoryTheory.Limits.HasProduct fun i => ∏ᶜ g i]
Goal: (CategoryTheory.Limits.piPiIso f g).hom =
  CategoryTheory.Limits.Pi.lift fun x =>
    match x with
    | ⟨i, x⟩ => CategoryTheory.Limits.Pi.π (fun i => ∏ᶜ g i) i ≫ CategoryTheory.Limits.Pi.π (g i) x
-- CategoryTheory.Limits.sigmaSigmaIso_hom
@[simps]
def sigmaSigmaIso {ι : Type*} (f : ι → Type*) (g : (i : ι) → (f i) → C)
    [∀ i, HasCoproduct (g i)] [HasCoproduct fun i => ∐ g i] :
    (∐ fun i => ∐ g i) ≅ (∐ fun p : Σ i, f i => g p.1 p.2) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {ι : Type u_1} (f : ι → Type u_2) (g : (i : ι) → f i → C) [∀ (i : ι), CategoryTheory.Limits.HasCoproduct (g i)] [CategoryTheory.Limits.HasCoproduct fun i => ∐ g i]
Goal: (CategoryTheory.Limits.sigmaSigmaIso f g).hom =
  CategoryTheory.Limits.Sigma.desc fun i =>
    CategoryTheory.Limits.Sigma.desc fun x => CategoryTheory.Limits.Sigma.ι (fun p => g p.fst p.snd) ⟨i, x⟩
-- CategoryTheory.Limits.sigmaSigmaIso_inv
@[simps]
def sigmaSigmaIso {ι : Type*} (f : ι → Type*) (g : (i : ι) → (f i) → C)
    [∀ i, HasCoproduct (g i)] [HasCoproduct fun i => ∐ g i] :
    (∐ fun i => ∐ g i) ≅ (∐ fun p : Σ i, f i => g p.1 p.2) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {ι : Type u_1} (f : ι → Type u_2) (g : (i : ι) → f i → C) [∀ (i : ι), CategoryTheory.Limits.HasCoproduct (g i)] [CategoryTheory.Limits.HasCoproduct fun i => ∐ g i]
Goal: (CategoryTheory.Limits.sigmaSigmaIso f g).inv =
  CategoryTheory.Limits.Sigma.desc fun x =>
    match x with
    | ⟨i, x⟩ => CategoryTheory.Limits.Sigma.ι (g i) x ≫ CategoryTheory.Limits.Sigma.ι (fun i => ∐ g i) i
-- CategoryTheory.Limits.piComparison_comp_π
@[reassoc (attr := simp)]
theorem piComparison_comp_π [HasProduct f] [HasProduct fun b => G.obj (f b)] (b : β) :
    piComparison G f ≫ Pi.π _ b = G.map (Pi.π f b) 
Arguments: {β : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) (f : β → C) [CategoryTheory.Limits.HasProduct f] [CategoryTheory.Limits.HasProduct fun b => G.obj (f b)] (b : β)
Goal: CategoryTheory.Limits.piComparison G f ≫ CategoryTheory.Limits.Pi.π (fun b => G.obj (f b)) b =
  G.map (CategoryTheory.Limits.Pi.π f b)
-- CategoryTheory.Limits.map_lift_piComparison
@[reassoc (attr := simp)]
theorem map_lift_piComparison [HasProduct f] [HasProduct fun b => G.obj (f b)] (P : C)
    (g : ∀ j, P ⟶ f j) : G.map (Pi.lift g) ≫ piComparison G f = Pi.lift fun j => G.map (g j) 
Arguments: {β : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) (f : β → C) [CategoryTheory.Limits.HasProduct f] [CategoryTheory.Limits.HasProduct fun b => G.obj (f b)] (P : C) (g : (j : β) → P ⟶ f j)
Goal: G.map (CategoryTheory.Limits.Pi.lift g) ≫ CategoryTheory.Limits.piComparison G f =
  CategoryTheory.Limits.Pi.lift fun j => G.map (g j)
-- CategoryTheory.Limits.ι_comp_sigmaComparison
@[reassoc (attr := simp)]
theorem ι_comp_sigmaComparison [HasCoproduct f] [HasCoproduct fun b => G.obj (f b)] (b : β) :
    Sigma.ι _ b ≫ sigmaComparison G f = G.map (Sigma.ι f b) 
Arguments: {β : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) (f : β → C) [CategoryTheory.Limits.HasCoproduct f] [CategoryTheory.Limits.HasCoproduct fun b => G.obj (f b)] (b : β)
Goal: CategoryTheory.Limits.Sigma.ι (fun b => G.obj (f b)) b ≫ CategoryTheory.Limits.sigmaComparison G f =
  G.map (CategoryTheory.Limits.Sigma.ι f b)
-- CategoryTheory.Limits.sigmaComparison_map_desc
@[reassoc (attr := simp)]
theorem sigmaComparison_map_desc [HasCoproduct f] [HasCoproduct fun b => G.obj (f b)] (P : C)
    (g : ∀ j, f j ⟶ P) :
    sigmaComparison G f ≫ G.map (Sigma.desc g) = Sigma.desc fun j => G.map (g j) 
Arguments: {β : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) (f : β → C) [CategoryTheory.Limits.HasCoproduct f] [CategoryTheory.Limits.HasCoproduct fun b => G.obj (f b)] (P : C) (g : (j : β) → f j ⟶ P)
Goal: CategoryTheory.Limits.sigmaComparison G f ≫ G.map (CategoryTheory.Limits.Sigma.desc g) =
  CategoryTheory.Limits.Sigma.desc fun j => G.map (g j)
-- CategoryTheory.Limits.has_smallest_products_of_hasProducts
theorem has_smallest_products_of_hasProducts [HasProducts.{w} C] : HasProducts.{0} C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasProducts C]
Goal: CategoryTheory.Limits.HasProducts C
-- CategoryTheory.Limits.has_smallest_coproducts_of_hasCoproducts
theorem has_smallest_coproducts_of_hasCoproducts [HasCoproducts.{w} C] : HasCoproducts.{0} C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasCoproducts C]
Goal: CategoryTheory.Limits.HasCoproducts C
-- CategoryTheory.Limits.hasProducts_of_limit_fans
theorem hasProducts_of_limit_fans (lf : ∀ {J : Type w} (f : J → C), Fan f)
    (lf_isLimit : ∀ {J : Type w} (f : J → C), IsLimit (lf f)) : HasProducts.{w} C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (lf : {J : Type w} → (f : J → C) → CategoryTheory.Limits.Fan f) (lf_isLimit : {J : Type w} → (f : J → C) → CategoryTheory.Limits.IsLimit (lf f))
Goal: CategoryTheory.Limits.HasProducts C
-- CategoryTheory.Limits.limitConeOfUnique_cone_pt
@[simps]
def limitConeOfUnique : LimitCone (Discrete.functor f) 
Arguments: {β : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] [Unique β] (f : β → C)
Goal: (CategoryTheory.Limits.limitConeOfUnique f).cone.pt = f default
-- CategoryTheory.Limits.limitConeOfUnique_cone_π
@[simps]
def limitConeOfUnique : LimitCone (Discrete.functor f) 
Arguments: {β : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] [Unique β] (f : β → C)
Goal: (CategoryTheory.Limits.limitConeOfUnique f).cone.π =
  CategoryTheory.Discrete.natTrans fun x =>
    match x with
    | { as := j } => CategoryTheory.eqToHom ⋯
-- CategoryTheory.Limits.limitConeOfUnique_isLimit_lift
@[simps]
def limitConeOfUnique : LimitCone (Discrete.functor f) 
Arguments: {β : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] [Unique β] (f : β → C) (s : CategoryTheory.Limits.Cone (CategoryTheory.Discrete.functor f))
Goal: (CategoryTheory.Limits.limitConeOfUnique f).isLimit.lift s = s.π.app default
-- CategoryTheory.Limits.productUniqueIso_hom
@[simps!]
def productUniqueIso : ∏ᶜ f ≅ f default 
Arguments: {β : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] [Unique β] (f : β → C)
Goal: (CategoryTheory.Limits.productUniqueIso f).hom =
  CategoryTheory.Limits.limit.π (CategoryTheory.Discrete.functor f) default
-- CategoryTheory.Limits.productUniqueIso_inv
@[simps!]
def productUniqueIso : ∏ᶜ f ≅ f default 
Arguments: {β : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] [Unique β] (f : β → C)
Goal: (CategoryTheory.Limits.productUniqueIso f).inv =
  CategoryTheory.Limits.limit.lift (CategoryTheory.Discrete.functor f) (CategoryTheory.Limits.limitConeOfUnique f).cone
-- CategoryTheory.Limits.colimitCoconeOfUnique_cocone_pt
@[simps]
def colimitCoconeOfUnique : ColimitCocone (Discrete.functor f) 
Arguments: {β : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] [Unique β] (f : β → C)
Goal: (CategoryTheory.Limits.colimitCoconeOfUnique f).cocone.pt = f default
-- CategoryTheory.Limits.colimitCoconeOfUnique_cocone_ι
@[simps]
def colimitCoconeOfUnique : ColimitCocone (Discrete.functor f) 
Arguments: {β : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] [Unique β] (f : β → C)
Goal: (CategoryTheory.Limits.colimitCoconeOfUnique f).cocone.ι =
  CategoryTheory.Discrete.natTrans fun x =>
    match x with
    | { as := j } => CategoryTheory.eqToHom ⋯
-- CategoryTheory.Limits.colimitCoconeOfUnique_isColimit_desc
@[simps]
def colimitCoconeOfUnique : ColimitCocone (Discrete.functor f) 
Arguments: {β : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] [Unique β] (f : β → C) (s : CategoryTheory.Limits.Cocone (CategoryTheory.Discrete.functor f))
Goal: (CategoryTheory.Limits.colimitCoconeOfUnique f).isColimit.desc s = s.ι.app default
-- CategoryTheory.Limits.coproductUniqueIso_inv
@[simps!]
def coproductUniqueIso : ∐ f ≅ f default 
Arguments: {β : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] [Unique β] (f : β → C)
Goal: (CategoryTheory.Limits.coproductUniqueIso f).inv =
  CategoryTheory.Limits.colimit.ι (CategoryTheory.Discrete.functor f) default
-- CategoryTheory.Limits.coproductUniqueIso_hom
@[simps!]
def coproductUniqueIso : ∐ f ≅ f default 
Arguments: {β : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] [Unique β] (f : β → C)
Goal: (CategoryTheory.Limits.coproductUniqueIso f).hom =
  CategoryTheory.Limits.colimit.desc (CategoryTheory.Discrete.functor f)
    (CategoryTheory.Limits.colimitCoconeOfUnique f).cocone
-- CategoryTheory.Limits.Pi.reindex_hom_π
@[reassoc (attr := simp)]
theorem Pi.reindex_hom_π (b : β) : (Pi.reindex ε f).hom ≫ Pi.π f (ε b) = Pi.π (f ∘ ε) b 
Arguments: {β : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {γ : Type w'} (ε : β ≃ γ) (f : γ → C) [CategoryTheory.Limits.HasProduct f] [CategoryTheory.Limits.HasProduct (f ∘ ⇑ε)] (b : β)
Goal: (CategoryTheory.Limits.Pi.reindex ε f).hom ≫ CategoryTheory.Limits.Pi.π f (ε b) = CategoryTheory.Limits.Pi.π (f ∘ ⇑ε) b
-- CategoryTheory.Limits.Pi.reindex_inv_π
@[reassoc (attr := simp)]
theorem Pi.reindex_inv_π (b : β) : (Pi.reindex ε f).inv ≫ Pi.π (f ∘ ε) b = Pi.π f (ε b) 
Arguments: {β : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {γ : Type w'} (ε : β ≃ γ) (f : γ → C) [CategoryTheory.Limits.HasProduct f] [CategoryTheory.Limits.HasProduct (f ∘ ⇑ε)] (b : β)
Goal: (CategoryTheory.Limits.Pi.reindex ε f).inv ≫ CategoryTheory.Limits.Pi.π (f ∘ ⇑ε) b = CategoryTheory.Limits.Pi.π f (ε b)
-- CategoryTheory.Limits.Sigma.ι_reindex_hom
@[reassoc (attr := simp)]
theorem Sigma.ι_reindex_hom (b : β) :
    Sigma.ι (f ∘ ε) b ≫ (Sigma.reindex ε f).hom = Sigma.ι f (ε b) 
Arguments: {β : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {γ : Type w'} (ε : β ≃ γ) (f : γ → C) [CategoryTheory.Limits.HasCoproduct f] [CategoryTheory.Limits.HasCoproduct (f ∘ ⇑ε)] (b : β)
Goal: CategoryTheory.Limits.Sigma.ι (f ∘ ⇑ε) b ≫ (CategoryTheory.Limits.Sigma.reindex ε f).hom =
  CategoryTheory.Limits.Sigma.ι f (ε b)
-- CategoryTheory.Limits.Sigma.ι_reindex_inv
@[reassoc (attr := simp)]
theorem Sigma.ι_reindex_inv (b : β) :
    Sigma.ι f (ε b) ≫ (Sigma.reindex ε f).inv = Sigma.ι (f ∘ ε) b 
Arguments: {β : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {γ : Type w'} (ε : β ≃ γ) (f : γ → C) [CategoryTheory.Limits.HasCoproduct f] [CategoryTheory.Limits.HasCoproduct (f ∘ ⇑ε)] (b : β)
Goal: CategoryTheory.Limits.Sigma.ι f (ε b) ≫ (CategoryTheory.Limits.Sigma.reindex ε f).inv =
  CategoryTheory.Limits.Sigma.ι (f ∘ ⇑ε) b
-- CategoryTheory.Limits.PullbackCone.π_app_left
@[simp]
theorem π_app_left (c : PullbackCone f g) : c.π.app WalkingCospan.left = c.fst 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} (c : CategoryTheory.Limits.PullbackCone f g)
Goal: c.π.app CategoryTheory.Limits.WalkingCospan.left = c.fst
-- CategoryTheory.Limits.PullbackCone.π_app_right
@[simp]
theorem π_app_right (c : PullbackCone f g) : c.π.app WalkingCospan.right = c.snd 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} (c : CategoryTheory.Limits.PullbackCone f g)
Goal: c.π.app CategoryTheory.Limits.WalkingCospan.right = c.snd
-- CategoryTheory.Limits.PullbackCone.condition_one
@[simp]
theorem condition_one (t : PullbackCone f g) : t.π.app WalkingCospan.one = t.fst ≫ f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} (t : CategoryTheory.Limits.PullbackCone f g)
Goal: t.π.app CategoryTheory.Limits.WalkingCospan.one = t.fst ≫ f
-- CategoryTheory.Limits.PullbackCone.mk_pt
@[simps]
def mk {W : C} (fst : W ⟶ X) (snd : W ⟶ Y) (eq : fst ≫ f = snd ≫ g) : PullbackCone f g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} {W : C} (fst : W ⟶ X) (snd : W ⟶ Y) (eq : fst ≫ f = snd ≫ g)
Goal: (CategoryTheory.Limits.PullbackCone.mk fst snd eq).pt = W
-- CategoryTheory.Limits.PullbackCone.mk_π_app
@[simps]
def mk {W : C} (fst : W ⟶ X) (snd : W ⟶ Y) (eq : fst ≫ f = snd ≫ g) : PullbackCone f g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} {W : C} (fst : W ⟶ X) (snd : W ⟶ Y) (eq : fst ≫ f = snd ≫ g) (j : CategoryTheory.Limits.WalkingCospan)
Goal: (CategoryTheory.Limits.PullbackCone.mk fst snd eq).π.app j =
  Option.casesOn j (fst ≫ f) fun j' => CategoryTheory.Limits.WalkingPair.casesOn j' fst snd
-- CategoryTheory.Limits.PullbackCone.mk_π_app_left
@[simp]
theorem mk_π_app_left {W : C} (fst : W ⟶ X) (snd : W ⟶ Y) (eq : fst ≫ f = snd ≫ g) :
    (mk fst snd eq).π.app WalkingCospan.left = fst 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} {W : C} (fst : W ⟶ X) (snd : W ⟶ Y) (eq : fst ≫ f = snd ≫ g)
Goal: (CategoryTheory.Limits.PullbackCone.mk fst snd eq).π.app CategoryTheory.Limits.WalkingCospan.left = fst
-- CategoryTheory.Limits.PullbackCone.mk_π_app_right
@[simp]
theorem mk_π_app_right {W : C} (fst : W ⟶ X) (snd : W ⟶ Y) (eq : fst ≫ f = snd ≫ g) :
    (mk fst snd eq).π.app WalkingCospan.right = snd 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} {W : C} (fst : W ⟶ X) (snd : W ⟶ Y) (eq : fst ≫ f = snd ≫ g)
Goal: (CategoryTheory.Limits.PullbackCone.mk fst snd eq).π.app CategoryTheory.Limits.WalkingCospan.right = snd
-- CategoryTheory.Limits.PullbackCone.mk_π_app_one
@[simp]
theorem mk_π_app_one {W : C} (fst : W ⟶ X) (snd : W ⟶ Y) (eq : fst ≫ f = snd ≫ g) :
    (mk fst snd eq).π.app WalkingCospan.one = fst ≫ f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} {W : C} (fst : W ⟶ X) (snd : W ⟶ Y) (eq : fst ≫ f = snd ≫ g)
Goal: (CategoryTheory.Limits.PullbackCone.mk fst snd eq).π.app CategoryTheory.Limits.WalkingCospan.one = fst ≫ f
-- CategoryTheory.Limits.PullbackCone.mk_fst
@[simp]
theorem mk_fst {W : C} (fst : W ⟶ X) (snd : W ⟶ Y) (eq : fst ≫ f = snd ≫ g) :
    (mk fst snd eq).fst = fst 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} {W : C} (fst : W ⟶ X) (snd : W ⟶ Y) (eq : fst ≫ f = snd ≫ g)
Goal: (CategoryTheory.Limits.PullbackCone.mk fst snd eq).fst = fst
-- CategoryTheory.Limits.PullbackCone.mk_snd
@[simp]
theorem mk_snd {W : C} (fst : W ⟶ X) (snd : W ⟶ Y) (eq : fst ≫ f = snd ≫ g) :
    (mk fst snd eq).snd = snd 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} {W : C} (fst : W ⟶ X) (snd : W ⟶ Y) (eq : fst ≫ f = snd ≫ g)
Goal: (CategoryTheory.Limits.PullbackCone.mk fst snd eq).snd = snd
-- CategoryTheory.Limits.PullbackCone.condition
@[reassoc]
theorem condition (t : PullbackCone f g) : fst t ≫ f = snd t ≫ g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} (t : CategoryTheory.Limits.PullbackCone f g)
Goal: t.fst ≫ f = t.snd ≫ g
-- CategoryTheory.Limits.PullbackCone.equalizer_ext
theorem equalizer_ext (t : PullbackCone f g) {W : C} {k l : W ⟶ t.pt} (h₀ : k ≫ fst t = l ≫ fst t)
    (h₁ : k ≫ snd t = l ≫ snd t) : ∀ j : WalkingCospan, k ≫ t.π.app j = l ≫ t.π.app j
  
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} (t : CategoryTheory.Limits.PullbackCone f g) {W : C} {k l : W ⟶ t.pt} (h₀ : k ≫ t.fst = l ≫ t.fst) (h₁ : k ≫ t.snd = l ≫ t.snd) (j : CategoryTheory.Limits.WalkingCospan)
Goal: k ≫ t.π.app j = l ≫ t.π.app j
-- CategoryTheory.Limits.PullbackCone.eta_hom_hom
@[simps!]
def eta (t : PullbackCone f g) : t ≅ mk t.fst t.snd t.condition 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} (t : CategoryTheory.Limits.PullbackCone f g)
Goal: t.eta.hom.hom = 𝟙 t.pt
-- CategoryTheory.Limits.PullbackCone.eta_inv_hom
@[simps!]
def eta (t : PullbackCone f g) : t ≅ mk t.fst t.snd t.condition 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} (t : CategoryTheory.Limits.PullbackCone f g)
Goal: t.eta.inv.hom = 𝟙 t.pt
-- CategoryTheory.Limits.PullbackCone.IsLimit.hom_ext
theorem IsLimit.hom_ext {t : PullbackCone f g} (ht : IsLimit t) {W : C} {k l : W ⟶ t.pt}
    (h₀ : k ≫ fst t = l ≫ fst t) (h₁ : k ≫ snd t = l ≫ snd t) : k = l 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} {t : CategoryTheory.Limits.PullbackCone f g} (ht : CategoryTheory.Limits.IsLimit t) {W : C} {k l : W ⟶ t.pt} (h₀ : k ≫ t.fst = l ≫ t.fst) (h₁ : k ≫ t.snd = l ≫ t.snd)
Goal: k = l
-- CategoryTheory.Limits.PullbackCone.IsLimit.lift_fst
@[reassoc (attr := simp)]
lemma IsLimit.lift_fst {t : PullbackCone f g} (ht : IsLimit t) {W : C} (h : W ⟶ X) (k : W ⟶ Y)
    (w : h ≫ f = k ≫ g) : IsLimit.lift ht h k w ≫ fst t = h 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} {t : CategoryTheory.Limits.PullbackCone f g} (ht : CategoryTheory.Limits.IsLimit t) {W : C} (h : W ⟶ X) (k : W ⟶ Y) (w : h ≫ f = k ≫ g)
Goal: CategoryTheory.Limits.PullbackCone.IsLimit.lift ht h k w ≫ t.fst = h
-- CategoryTheory.Limits.PullbackCone.IsLimit.lift_snd
@[reassoc (attr := simp)]
lemma IsLimit.lift_snd {t : PullbackCone f g} (ht : IsLimit t) {W : C} (h : W ⟶ X) (k : W ⟶ Y)
    (w : h ≫ f = k ≫ g) : IsLimit.lift ht h k w ≫ snd t = k 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} {t : CategoryTheory.Limits.PullbackCone f g} (ht : CategoryTheory.Limits.IsLimit t) {W : C} (h : W ⟶ X) (k : W ⟶ Y) (w : h ≫ f = k ≫ g)
Goal: CategoryTheory.Limits.PullbackCone.IsLimit.lift ht h k w ≫ t.snd = k
-- CategoryTheory.Limits.PullbackCone.flip_pt
@[simp] lemma flip_pt : t.flip.pt = t.pt 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} (t : CategoryTheory.Limits.PullbackCone f g)
Goal: t.flip.pt = t.pt
-- CategoryTheory.Limits.PullbackCone.flip_fst
@[simp] lemma flip_fst : t.flip.fst = t.snd 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} (t : CategoryTheory.Limits.PullbackCone f g)
Goal: t.flip.fst = t.snd
-- CategoryTheory.Limits.PullbackCone.flip_snd
@[simp] lemma flip_snd : t.flip.snd = t.fst 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} (t : CategoryTheory.Limits.PullbackCone f g)
Goal: t.flip.snd = t.fst
-- CategoryTheory.Limits.Cone.ofPullbackCone_pt
@[simps]
def Cone.ofPullbackCone {F : WalkingCospan ⥤ C} (t : PullbackCone (F.map inl) (F.map inr)) :
    Cone F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Limits.WalkingCospan ⥤ C} (t :
  CategoryTheory.Limits.PullbackCone (F.map CategoryTheory.Limits.WalkingCospan.Hom.inl)
    (F.map CategoryTheory.Limits.WalkingCospan.Hom.inr))
Goal: (CategoryTheory.Limits.Cone.ofPullbackCone t).pt = t.pt
-- CategoryTheory.Limits.Cone.ofPullbackCone_π
@[simps]
def Cone.ofPullbackCone {F : WalkingCospan ⥤ C} (t : PullbackCone (F.map inl) (F.map inr)) :
    Cone F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Limits.WalkingCospan ⥤ C} (t :
  CategoryTheory.Limits.PullbackCone (F.map CategoryTheory.Limits.WalkingCospan.Hom.inl)
    (F.map CategoryTheory.Limits.WalkingCospan.Hom.inr))
Goal: (CategoryTheory.Limits.Cone.ofPullbackCone t).π = t.π ≫ (CategoryTheory.Limits.diagramIsoCospan F).inv
-- CategoryTheory.Limits.PullbackCone.ofCone_π
@[simps]
def PullbackCone.ofCone {F : WalkingCospan ⥤ C} (t : Cone F) :
    PullbackCone (F.map inl) (F.map inr) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Limits.WalkingCospan ⥤ C} (t : CategoryTheory.Limits.Cone F)
Goal: (CategoryTheory.Limits.PullbackCone.ofCone t).π = t.π ≫ (CategoryTheory.Limits.diagramIsoCospan F).hom
-- CategoryTheory.Limits.PullbackCone.ofCone_pt
@[simps]
def PullbackCone.ofCone {F : WalkingCospan ⥤ C} (t : Cone F) :
    PullbackCone (F.map inl) (F.map inr) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Limits.WalkingCospan ⥤ C} (t : CategoryTheory.Limits.Cone F)
Goal: (CategoryTheory.Limits.PullbackCone.ofCone t).pt = t.pt
-- CategoryTheory.Limits.PullbackCone.isoMk_hom_hom
@[simps!]
def PullbackCone.isoMk {F : WalkingCospan ⥤ C} (t : Cone F) :
    (Cones.postcompose (diagramIsoCospan.{v} _).hom).obj t ≅
      PullbackCone.mk (t.π.app WalkingCospan.left) (t.π.app WalkingCospan.right)
        ((t.π.naturality inl).symm.trans (t.π.naturality inr : _)) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Limits.WalkingCospan ⥤ C} (t : CategoryTheory.Limits.Cone F)
Goal: (CategoryTheory.Limits.PullbackCone.isoMk t).hom.hom = 𝟙 t.pt
-- CategoryTheory.Limits.PullbackCone.isoMk_inv_hom
@[simps!]
def PullbackCone.isoMk {F : WalkingCospan ⥤ C} (t : Cone F) :
    (Cones.postcompose (diagramIsoCospan.{v} _).hom).obj t ≅
      PullbackCone.mk (t.π.app WalkingCospan.left) (t.π.app WalkingCospan.right)
        ((t.π.naturality inl).symm.trans (t.π.naturality inr : _)) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Limits.WalkingCospan ⥤ C} (t : CategoryTheory.Limits.Cone F)
Goal: (CategoryTheory.Limits.PullbackCone.isoMk t).inv.hom = 𝟙 t.pt