ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.FunctorToTypes.jointly_surjective'
theorem jointly_surjective' (k : K) (x : (colimit F).obj k) : ∃ j y, x = (colimit.ι F j).app k y 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] (F : CategoryTheory.Functor J (CategoryTheory.Functor K TypeMax)) (k : K) (x : (CategoryTheory.Limits.colimit F).obj k)
Goal: ∃ j y, x = (CategoryTheory.Limits.colimit.ι F j).app k y
-- CategoryTheory.Limits.Concrete.small_sections_of_hasLimit
lemma small_sections_of_hasLimit
    {C : Type u} [Category.{v} C] [ConcreteCategory.{v} C]
    [(forget C).Corepresentable] {J : Type w} [Category.{t} J] (G : J ⥤ C) [HasLimit G] :
    Small.{v} (G ⋙ forget C).sections 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.ConcreteCategory C] [(CategoryTheory.forget C).Corepresentable] {J : Type w} [CategoryTheory.Category.{t, w} J] (G : J ⥤ C) [CategoryTheory.Limits.HasLimit G]
Goal: Small.{v, max v w} ↑(G ⋙ CategoryTheory.forget C).sections
-- CategoryTheory.Limits.Concrete.to_product_injective_of_isLimit
theorem to_product_injective_of_isLimit {D : Cone F} (hD : IsLimit D) :
    Function.Injective fun (x : D.pt) (j : J) => D.π.app j x 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.ConcreteCategory C] {J : Type w} [CategoryTheory.Category.{t, w} J] (F : J ⥤ C) [CategoryTheory.Limits.PreservesLimit F (CategoryTheory.forget C)] {D : CategoryTheory.Limits.Cone F} (hD : CategoryTheory.Limits.IsLimit D)
Goal: Function.Injective fun x j => (D.π.app j) x
-- CategoryTheory.Limits.Concrete.isLimit_ext
theorem isLimit_ext {D : Cone F} (hD : IsLimit D) (x y : D.pt) :
    (∀ j, D.π.app j x = D.π.app j y) → x = y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.ConcreteCategory C] {J : Type w} [CategoryTheory.Category.{t, w} J] (F : J ⥤ C) [CategoryTheory.Limits.PreservesLimit F (CategoryTheory.forget C)] {D : CategoryTheory.Limits.Cone F} (hD : CategoryTheory.Limits.IsLimit D) (x y : (CategoryTheory.forget C).obj D.pt)
Goal: (∀ (j : J), (D.π.app j) x = (D.π.app j) y) → x = y
-- CategoryTheory.Limits.Concrete.limit_ext
theorem limit_ext [HasLimit F] (x y : ↑(limit F)) :
    (∀ j, limit.π F j x = limit.π F j y) → x = y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.ConcreteCategory C] {J : Type w} [CategoryTheory.Category.{t, w} J] (F : J ⥤ C) [CategoryTheory.Limits.PreservesLimit F (CategoryTheory.forget C)] [CategoryTheory.Limits.HasLimit F] (x y : (CategoryTheory.forget C).obj (CategoryTheory.Limits.limit F))
Goal: (∀ (j : J), (CategoryTheory.Limits.limit.π F j) x = (CategoryTheory.Limits.limit.π F j) y) → x = y
-- CategoryTheory.Limits.Concrete.surjective_π_app_zero_of_surjective_map
lemma surjective_π_app_zero_of_surjective_map {C : Type u} [Category.{v} C] [ConcreteCategory.{v} C]
    [PreservesLimitsOfShape ℕᵒᵖ (forget C)] {F : ℕᵒᵖ ⥤ C} {c : Cone F}
    (hc : IsLimit c) (hF : ∀ n, Function.Surjective (F.map (homOfLE (Nat.le_succ n)).op)) :
    Function.Surjective (c.π.app ⟨0⟩) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.ConcreteCategory C] [CategoryTheory.Limits.PreservesLimitsOfShape ℕᵒᵖ (CategoryTheory.forget C)] {F : ℕᵒᵖ ⥤ C} {c : CategoryTheory.Limits.Cone F} (hc : CategoryTheory.Limits.IsLimit c) (hF : ∀ (n : ℕ), Function.Surjective ⇑(F.map (CategoryTheory.homOfLE ⋯).op))
Goal: Function.Surjective ⇑(c.π.app (Opposite.op 0))
-- CategoryTheory.Limits.Concrete.from_union_surjective_of_isColimit
theorem from_union_surjective_of_isColimit {D : Cocone F} (hD : IsColimit D) :
    let ff : (Σj : J, F.obj j) → D.pt := fun a => D.ι.app a.1 a.2
    Function.Surjective ff 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.ConcreteCategory C] {J : Type w} [CategoryTheory.Category.{r, w} J] (F : J ⥤ C) [CategoryTheory.Limits.PreservesColimit F (CategoryTheory.forget C)] {D : CategoryTheory.Limits.Cocone F} (hD : CategoryTheory.Limits.IsColimit D)
Goal: let ff := fun a => (D.ι.app a.fst) a.snd;
Function.Surjective ff
-- CategoryTheory.Limits.Concrete.isColimit_exists_rep
theorem isColimit_exists_rep {D : Cocone F} (hD : IsColimit D) (x : D.pt) :
    ∃ (j : J) (y : F.obj j), D.ι.app j y = x 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.ConcreteCategory C] {J : Type w} [CategoryTheory.Category.{r, w} J] (F : J ⥤ C) [CategoryTheory.Limits.PreservesColimit F (CategoryTheory.forget C)] {D : CategoryTheory.Limits.Cocone F} (hD : CategoryTheory.Limits.IsColimit D) (x : (CategoryTheory.forget C).obj D.pt)
Goal: ∃ j y, (D.ι.app j) y = x
-- CategoryTheory.Limits.Concrete.colimit_exists_rep
theorem colimit_exists_rep [HasColimit F] (x : ↑(colimit F)) :
    ∃ (j : J) (y : F.obj j), colimit.ι F j y = x 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.ConcreteCategory C] {J : Type w} [CategoryTheory.Category.{r, w} J] (F : J ⥤ C) [CategoryTheory.Limits.PreservesColimit F (CategoryTheory.forget C)] [CategoryTheory.Limits.HasColimit F] (x : (CategoryTheory.forget C).obj (CategoryTheory.Limits.colimit F))
Goal: ∃ j y, (CategoryTheory.Limits.colimit.ι F j) y = x
-- CategoryTheory.Limits.Concrete.isColimit_rep_eq_of_exists
theorem isColimit_rep_eq_of_exists {D : Cocone F} {i j : J} (x : F.obj i) (y : F.obj j)
    (h : ∃ (k : _) (f : i ⟶ k) (g : j ⟶ k), F.map f x = F.map g y) :
    D.ι.app i x = D.ι.app j y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.ConcreteCategory C] {J : Type w} [CategoryTheory.Category.{r, w} J] (F : J ⥤ C) {D : CategoryTheory.Limits.Cocone F} {i j : J} (x : (CategoryTheory.forget C).obj (F.obj i)) (y : (CategoryTheory.forget C).obj (F.obj j)) (h : ∃ k f g, (F.map f) x = (F.map g) y)
Goal: (D.ι.app i) x = (D.ι.app j) y
-- CategoryTheory.Limits.Concrete.colimit_rep_eq_of_exists
theorem colimit_rep_eq_of_exists [HasColimit F] {i j : J} (x : F.obj i) (y : F.obj j)
    (h : ∃ (k : _) (f : i ⟶ k) (g : j ⟶ k), F.map f x = F.map g y) :
    colimit.ι F i x = colimit.ι F j y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.ConcreteCategory C] {J : Type w} [CategoryTheory.Category.{r, w} J] (F : J ⥤ C) [CategoryTheory.Limits.HasColimit F] {i j : J} (x : (CategoryTheory.forget C).obj (F.obj i)) (y : (CategoryTheory.forget C).obj (F.obj j)) (h : ∃ k f g, (F.map f) x = (F.map g) y)
Goal: (CategoryTheory.Limits.colimit.ι F i) x = (CategoryTheory.Limits.colimit.ι F j) y
-- CategoryTheory.Limits.Concrete.isColimit_exists_of_rep_eq
theorem isColimit_exists_of_rep_eq {D : Cocone F} {i j : J} (hD : IsColimit D)
    (x : F.obj i) (y : F.obj j) (h : D.ι.app _ x = D.ι.app _ y) :
    ∃ (k : _) (f : i ⟶ k) (g : j ⟶ k), F.map f x = F.map g y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.ConcreteCategory C] {J : Type w} [CategoryTheory.Category.{r, w} J] (F : J ⥤ C) [CategoryTheory.Limits.PreservesColimit F (CategoryTheory.forget C)] [CategoryTheory.IsFiltered J] {D : CategoryTheory.Limits.Cocone F} {i j : J} (hD : CategoryTheory.Limits.IsColimit D) (x : (CategoryTheory.forget C).obj (F.obj i)) (y : (CategoryTheory.forget C).obj (F.obj j)) (h : (D.ι.app i) x = (D.ι.app j) y)
Goal: ∃ k f g, (F.map f) x = (F.map g) y
-- CategoryTheory.Limits.Concrete.isColimit_rep_eq_iff_exists
theorem isColimit_rep_eq_iff_exists {D : Cocone F} {i j : J} (hD : IsColimit D)
    (x : F.obj i) (y : F.obj j) :
    D.ι.app i x = D.ι.app j y ↔ ∃ (k : _) (f : i ⟶ k) (g : j ⟶ k), F.map f x = F.map g y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.ConcreteCategory C] {J : Type w} [CategoryTheory.Category.{r, w} J] (F : J ⥤ C) [CategoryTheory.Limits.PreservesColimit F (CategoryTheory.forget C)] [CategoryTheory.IsFiltered J] {D : CategoryTheory.Limits.Cocone F} {i j : J} (hD : CategoryTheory.Limits.IsColimit D) (x : (CategoryTheory.forget C).obj (F.obj i)) (y : (CategoryTheory.forget C).obj (F.obj j))
Goal: (D.ι.app i) x = (D.ι.app j) y ↔ ∃ k f g, (F.map f) x = (F.map g) y
-- CategoryTheory.Limits.Concrete.colimit_exists_of_rep_eq
theorem colimit_exists_of_rep_eq [HasColimit F] {i j : J} (x : F.obj i) (y : F.obj j)
    (h : colimit.ι F _ x = colimit.ι F _ y) :
    ∃ (k : _) (f : i ⟶ k) (g : j ⟶ k), F.map f x = F.map g y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.ConcreteCategory C] {J : Type w} [CategoryTheory.Category.{r, w} J] (F : J ⥤ C) [CategoryTheory.Limits.PreservesColimit F (CategoryTheory.forget C)] [CategoryTheory.IsFiltered J] [CategoryTheory.Limits.HasColimit F] {i j : J} (x : (CategoryTheory.forget C).obj (F.obj i)) (y : (CategoryTheory.forget C).obj (F.obj j)) (h : (CategoryTheory.Limits.colimit.ι F i) x = (CategoryTheory.Limits.colimit.ι F j) y)
Goal: ∃ k f g, (F.map f) x = (F.map g) y
-- CategoryTheory.Limits.Concrete.colimit_rep_eq_iff_exists
theorem colimit_rep_eq_iff_exists [HasColimit F] {i j : J} (x : F.obj i) (y : F.obj j) :
    colimit.ι F i x = colimit.ι F j y ↔ ∃ (k : _) (f : i ⟶ k) (g : j ⟶ k), F.map f x = F.map g y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.ConcreteCategory C] {J : Type w} [CategoryTheory.Category.{r, w} J] (F : J ⥤ C) [CategoryTheory.Limits.PreservesColimit F (CategoryTheory.forget C)] [CategoryTheory.IsFiltered J] [CategoryTheory.Limits.HasColimit F] {i j : J} (x : (CategoryTheory.forget C).obj (F.obj i)) (y : (CategoryTheory.forget C).obj (F.obj j))
Goal: (CategoryTheory.Limits.colimit.ι F i) x = (CategoryTheory.Limits.colimit.ι F j) y ↔ ∃ k f g, (F.map f) x = (F.map g) y
-- CategoryTheory.pi.hasLimit_of_hasLimit_comp_eval
theorem hasLimit_of_hasLimit_comp_eval : HasLimit F 
Arguments: {I : Type v₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {J : Type v₁} [CategoryTheory.SmallCategory J] {F : J ⥤ ((i : I) → C i)} [∀ (i : I), CategoryTheory.Limits.HasLimit (F ⋙ CategoryTheory.Pi.eval C i)]
Goal: CategoryTheory.Limits.HasLimit F
-- CategoryTheory.pi.hasColimit_of_hasColimit_comp_eval
theorem hasColimit_of_hasColimit_comp_eval : HasColimit F 
Arguments: {I : Type v₁} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {J : Type v₁} [CategoryTheory.SmallCategory J] {F : J ⥤ ((i : I) → C i)} [∀ (i : I), CategoryTheory.Limits.HasColimit (F ⋙ CategoryTheory.Pi.eval C i)]
Goal: CategoryTheory.Limits.HasColimit F
-- CategoryTheory.Limits.IsBilimit.total
theorem IsBilimit.total {f : J → C} {b : Bicone f} (i : b.IsBilimit) :
    ∑ j : J, b.π j ≫ b.ι j = 𝟙 b.pt 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] {J : Type} [Fintype J] {f : J → C} {b : CategoryTheory.Limits.Bicone f} (i : b.IsBilimit)
Goal: ∑ j : J, b.π j ≫ b.ι j = 𝟙 b.pt
-- CategoryTheory.Limits.hasBiproduct_of_total
theorem hasBiproduct_of_total {f : J → C} (b : Bicone f)
    (total : ∑ j : J, b.π j ≫ b.ι j = 𝟙 b.pt) : HasBiproduct f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] {J : Type} [Fintype J] {f : J → C} (b : CategoryTheory.Limits.Bicone f) (total : ∑ j : J, b.π j ≫ b.ι j = 𝟙 b.pt)
Goal: CategoryTheory.Limits.HasBiproduct f
-- CategoryTheory.Limits.HasBiproduct.of_hasProduct
theorem HasBiproduct.of_hasProduct (f : J → C) [HasProduct f] : HasBiproduct f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] {J : Type} [Finite J] (f : J → C) [CategoryTheory.Limits.HasProduct f]
Goal: CategoryTheory.Limits.HasBiproduct f
-- CategoryTheory.Limits.HasBiproduct.of_hasCoproduct
theorem HasBiproduct.of_hasCoproduct (f : J → C) [HasCoproduct f] : HasBiproduct f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] {J : Type} [Finite J] (f : J → C) [CategoryTheory.Limits.HasCoproduct f]
Goal: CategoryTheory.Limits.HasBiproduct f
-- CategoryTheory.Limits.HasFiniteBiproducts.of_hasFiniteProducts
theorem HasFiniteBiproducts.of_hasFiniteProducts [HasFiniteProducts C] : HasFiniteBiproducts C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasFiniteProducts C]
Goal: CategoryTheory.Limits.HasFiniteBiproducts C
-- CategoryTheory.Limits.HasFiniteBiproducts.of_hasFiniteCoproducts
theorem HasFiniteBiproducts.of_hasFiniteCoproducts [HasFiniteCoproducts C] :
    HasFiniteBiproducts C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasFiniteCoproducts C]
Goal: CategoryTheory.Limits.HasFiniteBiproducts C
-- CategoryTheory.Limits.biproduct.total
@[simp]
theorem biproduct.total : ∑ j : J, biproduct.π f j ≫ biproduct.ι f j = 𝟙 (⨁ f) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] {J : Type} [Fintype J] {f : J → C} [CategoryTheory.Limits.HasBiproduct f]
Goal: ∑ j : J, CategoryTheory.Limits.biproduct.π f j ≫ CategoryTheory.Limits.biproduct.ι f j = 𝟙 (⨁ f)
-- CategoryTheory.Limits.biproduct.lift_eq
theorem biproduct.lift_eq {T : C} {g : ∀ j, T ⟶ f j} :
    biproduct.lift g = ∑ j, g j ≫ biproduct.ι f j 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] {J : Type} [Fintype J] {f : J → C} [CategoryTheory.Limits.HasBiproduct f] {T : C} {g : (j : J) → T ⟶ f j}
Goal: CategoryTheory.Limits.biproduct.lift g = ∑ j : J, g j ≫ CategoryTheory.Limits.biproduct.ι f j
-- CategoryTheory.Limits.biproduct.desc_eq
theorem biproduct.desc_eq {T : C} {g : ∀ j, f j ⟶ T} :
    biproduct.desc g = ∑ j, biproduct.π f j ≫ g j 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] {J : Type} [Fintype J] {f : J → C} [CategoryTheory.Limits.HasBiproduct f] {T : C} {g : (j : J) → f j ⟶ T}
Goal: CategoryTheory.Limits.biproduct.desc g = ∑ j : J, CategoryTheory.Limits.biproduct.π f j ≫ g j
-- CategoryTheory.Limits.biproduct.lift_desc
@[reassoc]
theorem biproduct.lift_desc {T U : C} {g : ∀ j, T ⟶ f j} {h : ∀ j, f j ⟶ U} :
    biproduct.lift g ≫ biproduct.desc h = ∑ j : J, g j ≫ h j 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] {J : Type} [Fintype J] {f : J → C} [CategoryTheory.Limits.HasBiproduct f] {T U : C} {g : (j : J) → T ⟶ f j} {h : (j : J) → f j ⟶ U}
Goal: CategoryTheory.Limits.biproduct.lift g ≫ CategoryTheory.Limits.biproduct.desc h = ∑ j : J, g j ≫ h j
-- CategoryTheory.Limits.biproduct.map_eq
theorem biproduct.map_eq [HasFiniteBiproducts C] {f g : J → C} {h : ∀ j, f j ⟶ g j} :
    biproduct.map h = ∑ j : J, biproduct.π f j ≫ h j ≫ biproduct.ι g j 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] {J : Type} [Fintype J] [CategoryTheory.Limits.HasFiniteBiproducts C] {f g : J → C} {h : (j : J) → f j ⟶ g j}
Goal: CategoryTheory.Limits.biproduct.map h =
  ∑ j : J, CategoryTheory.Limits.biproduct.π f j ≫ h j ≫ CategoryTheory.Limits.biproduct.ι g j
-- CategoryTheory.Limits.biproduct.lift_matrix
@[reassoc]
theorem biproduct.lift_matrix {K : Type} [Finite K] [HasFiniteBiproducts C] {f : J → C} {g : K → C}
    {P} (x : ∀ j, P ⟶ f j) (m : ∀ j k, f j ⟶ g k) :
    biproduct.lift x ≫ biproduct.matrix m = biproduct.lift fun k => ∑ j, x j ≫ m j k 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] {J : Type} [Fintype J] {K : Type} [Finite K] [CategoryTheory.Limits.HasFiniteBiproducts C] {f : J → C} {g : K → C} {P : C} (x : (j : J) → P ⟶ f j) (m : (j : J) → (k : K) → f j ⟶ g k)
Goal: CategoryTheory.Limits.biproduct.lift x ≫ CategoryTheory.Limits.biproduct.matrix m =
  CategoryTheory.Limits.biproduct.lift fun k => ∑ j : J, x j ≫ m j k
-- CategoryTheory.Limits.biproduct.matrix_desc
@[reassoc]
theorem biproduct.matrix_desc [Fintype K] {f : J → C} {g : K → C}
    (m : ∀ j k, f j ⟶ g k) {P} (x : ∀ k, g k ⟶ P) :
    biproduct.matrix m ≫ biproduct.desc x = biproduct.desc fun j => ∑ k, m j k ≫ x k 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] {J K : Type} [Finite J] [CategoryTheory.Limits.HasFiniteBiproducts C] [Fintype K] {f : J → C} {g : K → C} (m : (j : J) → (k : K) → f j ⟶ g k) {P : C} (x : (k : K) → g k ⟶ P)
Goal: CategoryTheory.Limits.biproduct.matrix m ≫ CategoryTheory.Limits.biproduct.desc x =
  CategoryTheory.Limits.biproduct.desc fun j => ∑ k : K, m j k ≫ x k
-- CategoryTheory.Limits.biproduct.matrix_map
@[reassoc]
theorem biproduct.matrix_map {f : J → C} {g : K → C} {h : K → C} (m : ∀ j k, f j ⟶ g k)
    (n : ∀ k, g k ⟶ h k) :
    biproduct.matrix m ≫ biproduct.map n = biproduct.matrix fun j k => m j k ≫ n k 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] {J K : Type} [Finite J] [CategoryTheory.Limits.HasFiniteBiproducts C] [Finite K] {f : J → C} {g h : K → C} (m : (j : J) → (k : K) → f j ⟶ g k) (n : (k : K) → g k ⟶ h k)
Goal: CategoryTheory.Limits.biproduct.matrix m ≫ CategoryTheory.Limits.biproduct.map n =
  CategoryTheory.Limits.biproduct.matrix fun j k => m j k ≫ n k
-- CategoryTheory.Limits.biproduct.map_matrix
@[reassoc]
theorem biproduct.map_matrix {f : J → C} {g : J → C} {h : K → C} (m : ∀ k, f k ⟶ g k)
    (n : ∀ j k, g j ⟶ h k) :
    biproduct.map m ≫ biproduct.matrix n = biproduct.matrix fun j k => m j ≫ n j k 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] {J K : Type} [Finite J] [CategoryTheory.Limits.HasFiniteBiproducts C] [Finite K] {f g : J → C} {h : K → C} (m : (k : J) → f k ⟶ g k) (n : (j : J) → (k : K) → g j ⟶ h k)
Goal: CategoryTheory.Limits.biproduct.map m ≫ CategoryTheory.Limits.biproduct.matrix n =
  CategoryTheory.Limits.biproduct.matrix fun j k => m j ≫ n j k
-- CategoryTheory.Limits.biproduct.reindex_hom
@[simps]
def biproduct.reindex {β γ : Type} [Finite β] (ε : β ≃ γ)
    (f : γ → C) [HasBiproduct f] [HasBiproduct (f ∘ ε)] : ⨁ f ∘ ε ≅ ⨁ f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] {β γ : Type} [Finite β] (ε : β ≃ γ) (f : γ → C) [CategoryTheory.Limits.HasBiproduct f] [CategoryTheory.Limits.HasBiproduct (f ∘ ⇑ε)]
Goal: (CategoryTheory.Limits.biproduct.reindex ε f).hom =
  CategoryTheory.Limits.biproduct.desc fun b => CategoryTheory.Limits.biproduct.ι f (ε b)
-- CategoryTheory.Limits.biproduct.reindex_inv
@[simps]
def biproduct.reindex {β γ : Type} [Finite β] (ε : β ≃ γ)
    (f : γ → C) [HasBiproduct f] [HasBiproduct (f ∘ ε)] : ⨁ f ∘ ε ≅ ⨁ f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] {β γ : Type} [Finite β] (ε : β ≃ γ) (f : γ → C) [CategoryTheory.Limits.HasBiproduct f] [CategoryTheory.Limits.HasBiproduct (f ∘ ⇑ε)]
Goal: (CategoryTheory.Limits.biproduct.reindex ε f).inv =
  CategoryTheory.Limits.biproduct.lift fun b => CategoryTheory.Limits.biproduct.π f (ε b)
-- CategoryTheory.Limits.IsBilimit.binary_total
theorem IsBilimit.binary_total {X Y : C} {b : BinaryBicone X Y} (i : b.IsBilimit) :
    b.fst ≫ b.inl + b.snd ≫ b.inr = 𝟙 b.pt 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] {X Y : C} {b : CategoryTheory.Limits.BinaryBicone X Y} (i : b.IsBilimit)
Goal: b.fst ≫ b.inl + b.snd ≫ b.inr = 𝟙 b.pt
-- CategoryTheory.Limits.hasBinaryBiproduct_of_total
theorem hasBinaryBiproduct_of_total {X Y : C} (b : BinaryBicone X Y)
    (total : b.fst ≫ b.inl + b.snd ≫ b.inr = 𝟙 b.pt) : HasBinaryBiproduct X Y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] {X Y : C} (b : CategoryTheory.Limits.BinaryBicone X Y) (total : b.fst ≫ b.inl + b.snd ≫ b.inr = 𝟙 b.pt)
Goal: CategoryTheory.Limits.HasBinaryBiproduct X Y
-- CategoryTheory.Limits.BinaryBicone.ofLimitCone_inr
@[simps]
def BinaryBicone.ofLimitCone {X Y : C} {t : Cone (pair X Y)} (ht : IsLimit t) :
    BinaryBicone X Y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] {X Y : C} {t : CategoryTheory.Limits.Cone (CategoryTheory.Limits.pair X Y)} (ht : CategoryTheory.Limits.IsLimit t)
Goal: (CategoryTheory.Limits.BinaryBicone.ofLimitCone ht).inr = ht.lift (CategoryTheory.Limits.BinaryFan.mk 0 (𝟙 Y))
-- CategoryTheory.Limits.BinaryBicone.ofLimitCone_fst
@[simps]
def BinaryBicone.ofLimitCone {X Y : C} {t : Cone (pair X Y)} (ht : IsLimit t) :
    BinaryBicone X Y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] {X Y : C} {t : CategoryTheory.Limits.Cone (CategoryTheory.Limits.pair X Y)} (ht : CategoryTheory.Limits.IsLimit t)
Goal: (CategoryTheory.Limits.BinaryBicone.ofLimitCone ht).fst = t.π.app { as := CategoryTheory.Limits.WalkingPair.left }
-- CategoryTheory.Limits.BinaryBicone.ofLimitCone_pt
@[simps]
def BinaryBicone.ofLimitCone {X Y : C} {t : Cone (pair X Y)} (ht : IsLimit t) :
    BinaryBicone X Y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] {X Y : C} {t : CategoryTheory.Limits.Cone (CategoryTheory.Limits.pair X Y)} (ht : CategoryTheory.Limits.IsLimit t)
Goal: (CategoryTheory.Limits.BinaryBicone.ofLimitCone ht).pt = t.pt
-- CategoryTheory.Limits.BinaryBicone.ofLimitCone_inl
@[simps]
def BinaryBicone.ofLimitCone {X Y : C} {t : Cone (pair X Y)} (ht : IsLimit t) :
    BinaryBicone X Y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] {X Y : C} {t : CategoryTheory.Limits.Cone (CategoryTheory.Limits.pair X Y)} (ht : CategoryTheory.Limits.IsLimit t)
Goal: (CategoryTheory.Limits.BinaryBicone.ofLimitCone ht).inl = ht.lift (CategoryTheory.Limits.BinaryFan.mk (𝟙 X) 0)
-- CategoryTheory.Limits.BinaryBicone.ofLimitCone_snd
@[simps]
def BinaryBicone.ofLimitCone {X Y : C} {t : Cone (pair X Y)} (ht : IsLimit t) :
    BinaryBicone X Y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] {X Y : C} {t : CategoryTheory.Limits.Cone (CategoryTheory.Limits.pair X Y)} (ht : CategoryTheory.Limits.IsLimit t)
Goal: (CategoryTheory.Limits.BinaryBicone.ofLimitCone ht).snd = t.π.app { as := CategoryTheory.Limits.WalkingPair.right }
-- CategoryTheory.Limits.inl_of_isLimit
theorem inl_of_isLimit {X Y : C} {t : BinaryBicone X Y} (ht : IsLimit t.toCone) :
    t.inl = ht.lift (BinaryFan.mk (𝟙 X) 0) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] {X Y : C} {t : CategoryTheory.Limits.BinaryBicone X Y} (ht : CategoryTheory.Limits.IsLimit t.toCone)
Goal: t.inl = ht.lift (CategoryTheory.Limits.BinaryFan.mk (𝟙 X) 0)
-- CategoryTheory.Limits.inr_of_isLimit
theorem inr_of_isLimit {X Y : C} {t : BinaryBicone X Y} (ht : IsLimit t.toCone) :
    t.inr = ht.lift (BinaryFan.mk 0 (𝟙 Y)) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] {X Y : C} {t : CategoryTheory.Limits.BinaryBicone X Y} (ht : CategoryTheory.Limits.IsLimit t.toCone)
Goal: t.inr = ht.lift (CategoryTheory.Limits.BinaryFan.mk 0 (𝟙 Y))
-- CategoryTheory.Limits.HasBinaryBiproduct.of_hasBinaryProduct
theorem HasBinaryBiproduct.of_hasBinaryProduct (X Y : C) [HasBinaryProduct X Y] :
    HasBinaryBiproduct X Y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] (X Y : C) [CategoryTheory.Limits.HasBinaryProduct X Y]
Goal: CategoryTheory.Limits.HasBinaryBiproduct X Y
-- CategoryTheory.Limits.HasBinaryBiproducts.of_hasBinaryProducts
theorem HasBinaryBiproducts.of_hasBinaryProducts [HasBinaryProducts C] : HasBinaryBiproducts C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasBinaryProducts C]
Goal: CategoryTheory.Limits.HasBinaryBiproducts C
-- CategoryTheory.Limits.BinaryBicone.ofColimitCocone_pt
@[simps]
def BinaryBicone.ofColimitCocone {X Y : C} {t : Cocone (pair X Y)} (ht : IsColimit t) :
    BinaryBicone X Y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] {X Y : C} {t : CategoryTheory.Limits.Cocone (CategoryTheory.Limits.pair X Y)} (ht : CategoryTheory.Limits.IsColimit t)
Goal: (CategoryTheory.Limits.BinaryBicone.ofColimitCocone ht).pt = t.pt