File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Biproducts.lean

full_name: CategoryTheory.Functor.mapBicone_π
code: /-- The image of a bicone under a functor. -/
@[simps]
def mapBicone {f : J → C} (b : Bicone f) : Bicone (F.obj ∘ f) 
goal: (F.mapBicone b).π j = F.map (b.π j)

full_name: CategoryTheory.Functor.mapBicone
code: /-- The image of a bicone under a functor. -/
@[simps]
def mapBicone {f : J → C} (b : Bicone f) : Bicone (F.obj ∘ f) 
goal: CategoryTheory.Limits.Bicone (F.obj ∘ f)

full_name: CategoryTheory.Functor.mapBicone_ι
code: /-- The image of a bicone under a functor. -/
@[simps]
def mapBicone {f : J → C} (b : Bicone f) : Bicone (F.obj ∘ f) 
goal: (F.mapBicone b).ι j = F.map (b.ι j)

full_name: CategoryTheory.Functor.mapBicone_pt
code: /-- The image of a bicone under a functor. -/
@[simps]
def mapBicone {f : J → C} (b : Bicone f) : Bicone (F.obj ∘ f) 
goal: (F.mapBicone b).pt = F.obj b.pt

full_name: CategoryTheory.Functor.mapBicone_whisker
code: theorem mapBicone_whisker {K : Type w₂} {g : K ≃ J} {f : J → C} (c : Bicone f) :
    F.mapBicone (c.whisker g) = (F.mapBicone c).whisker g 
goal: F.mapBicone (c.whisker g) = (F.mapBicone c).whisker g

full_name: CategoryTheory.Functor.mapBinaryBicone
code: /-- The image of a binary bicone under a functor. -/
@[simps!]
def mapBinaryBicone {X Y : C} (b : BinaryBicone X Y) : BinaryBicone (F.obj X) (F.obj Y) 
goal: CategoryTheory.Limits.BinaryBicone (F.obj X) (F.obj Y)

full_name: CategoryTheory.Functor.mapBinaryBicone_inl
code: /-- The image of a binary bicone under a functor. -/
@[simps!]
def mapBinaryBicone {X Y : C} (b : BinaryBicone X Y) : BinaryBicone (F.obj X) (F.obj Y) 
goal: (F.mapBinaryBicone b).inl = F.map b.inl

full_name: CategoryTheory.Functor.mapBinaryBicone_snd
code: /-- The image of a binary bicone under a functor. -/
@[simps!]
def mapBinaryBicone {X Y : C} (b : BinaryBicone X Y) : BinaryBicone (F.obj X) (F.obj Y) 
goal: (F.mapBinaryBicone b).snd = F.map b.snd

full_name: CategoryTheory.Functor.mapBinaryBicone_fst
code: /-- The image of a binary bicone under a functor. -/
@[simps!]
def mapBinaryBicone {X Y : C} (b : BinaryBicone X Y) : BinaryBicone (F.obj X) (F.obj Y) 
goal: (F.mapBinaryBicone b).fst = F.map b.fst

full_name: CategoryTheory.Functor.mapBinaryBicone_inr
code: /-- The image of a binary bicone under a functor. -/
@[simps!]
def mapBinaryBicone {X Y : C} (b : BinaryBicone X Y) : BinaryBicone (F.obj X) (F.obj Y) 
goal: (F.mapBinaryBicone b).inr = F.map b.inr

full_name: CategoryTheory.Functor.mapBinaryBicone_pt
code: /-- The image of a binary bicone under a functor. -/
@[simps!]
def mapBinaryBicone {X Y : C} (b : BinaryBicone X Y) : BinaryBicone (F.obj X) (F.obj Y) 
goal: (F.mapBinaryBicone b).pt = F.obj b.pt

full_name: CategoryTheory.Limits.PreservesBiproduct
code: /-- A functor `F` preserves biproducts of `f` if `F` maps every bilimit bicone over `f` to a
    bilimit bicone over `F.obj ∘ f`. -/
class PreservesBiproduct (f : J → C) (F : C ⥤ D) [PreservesZeroMorphisms F] where
  preserves : ∀ {b : Bicone f}, b.IsBilimit → (F.mapBicone b).IsBilimit
goal: Type (max (max (max (max u₁ u₂) v₁) v₂) w₁)

full_name: CategoryTheory.Limits.PreservesBiproduct.preserves
code: /-- A functor `F` preserves biproducts of `f` if `F` maps every bilimit bicone over `f` to a
    bilimit bicone over `F.obj ∘ f`. -/
class PreservesBiproduct (f : J → C) (F : C ⥤ D) [PreservesZeroMorphisms F] where
  preserves : ∀ {b : Bicone f}, b.IsBilimit → (F.mapBicone b).IsBilimit
goal: b.IsBilimit → (F.mapBicone b).IsBilimit

full_name: CategoryTheory.Limits.isBilimitOfPreserves
code: /-- A functor `F` preserves biproducts of `f` if `F` maps every bilimit bicone over `f` to a
    bilimit bicone over `F.obj ∘ f`. -/
def isBilimitOfPreserves {f : J → C} (F : C ⥤ D) [PreservesZeroMorphisms F] [PreservesBiproduct f F]
    {b : Bicone f} (hb : b.IsBilimit) : (F.mapBicone b).IsBilimit 
goal: (F.mapBicone b).IsBilimit

full_name: CategoryTheory.Limits.PreservesBiproductsOfShape
code: /-- A functor `F` preserves biproducts of shape `J` if it preserves biproducts of `f` for every
    `f : J → C`. -/
class PreservesBiproductsOfShape (F : C ⥤ D) [PreservesZeroMorphisms F] where
  preserves : ∀ {f : J → C}, PreservesBiproduct f F
goal: Type (max (max (max (max u₁ u₂) v₁) v₂) w₁)

full_name: CategoryTheory.Limits.PreservesBiproductsOfShape.preserves
code: /-- A functor `F` preserves biproducts of shape `J` if it preserves biproducts of `f` for every
    `f : J → C`. -/
class PreservesBiproductsOfShape (F : C ⥤ D) [PreservesZeroMorphisms F] where
  preserves : ∀ {f : J → C}, PreservesBiproduct f F
goal: CategoryTheory.Limits.PreservesBiproduct f F

full_name: CategoryTheory.Limits.PreservesFiniteBiproducts
code: /-- A functor `F` preserves finite biproducts if it preserves biproducts of shape `J` whenever
    `J` is a fintype. -/
class PreservesFiniteBiproducts (F : C ⥤ D) [PreservesZeroMorphisms F] where
  preserves : ∀ {J : Type} [Fintype J], PreservesBiproductsOfShape J F
goal: Type (max (max (max (max 1 u₁) u₂) v₁) v₂)

full_name: CategoryTheory.Limits.PreservesFiniteBiproducts.preserves
code: /-- A functor `F` preserves finite biproducts if it preserves biproducts of shape `J` whenever
    `J` is a fintype. -/
class PreservesFiniteBiproducts (F : C ⥤ D) [PreservesZeroMorphisms F] where
  preserves : ∀ {J : Type} [Fintype J], PreservesBiproductsOfShape J F
goal: CategoryTheory.Limits.PreservesBiproductsOfShape J F

full_name: CategoryTheory.Limits.PreservesBiproducts.preserves
code: /-- A functor `F` preserves biproducts if it preserves biproducts of any shape `J` of size `w`.
    The usual notion of preservation of biproducts is recovered by choosing `w` to be the universe
    of the morphisms of `C`. -/
class PreservesBiproducts (F : C ⥤ D) [PreservesZeroMorphisms F] where
  preserves : ∀ {J : Type w₁}, PreservesBiproductsOfShape J F
goal: CategoryTheory.Limits.PreservesBiproductsOfShape J F

full_name: CategoryTheory.Limits.PreservesBiproducts
code: /-- A functor `F` preserves biproducts if it preserves biproducts of any shape `J` of size `w`.
    The usual notion of preservation of biproducts is recovered by choosing `w` to be the universe
    of the morphisms of `C`. -/
class PreservesBiproducts (F : C ⥤ D) [PreservesZeroMorphisms F] where
  preserves : ∀ {J : Type w₁}, PreservesBiproductsOfShape J F
goal: Type (max (max (max (max u₁ u₂) v₁) v₂) (w₁ + 1))

full_name: CategoryTheory.Limits.preservesBiproductsShrink
code: /-- Preserving biproducts at a bigger universe level implies preserving biproducts at a
smaller universe level. -/
def preservesBiproductsShrink (F : C ⥤ D) [PreservesZeroMorphisms F]
    [PreservesBiproducts.{max w₁ w₂} F] : PreservesBiproducts.{w₁} F 
goal: CategoryTheory.Limits.PreservesBiproducts F

full_name: CategoryTheory.Limits.preservesFiniteBiproductsOfPreservesBiproducts
code: instance (priority := 100) preservesFiniteBiproductsOfPreservesBiproducts (F : C ⥤ D)
    [PreservesZeroMorphisms F] [PreservesBiproducts.{w₁} F] : PreservesFiniteBiproducts F 
goal: CategoryTheory.Limits.PreservesFiniteBiproducts F

full_name: CategoryTheory.Limits.PreservesBinaryBiproduct.preserves
code: /-- A functor `F` preserves binary biproducts of `X` and `Y` if `F` maps every bilimit bicone over
    `X` and `Y` to a bilimit bicone over `F.obj X` and `F.obj Y`. -/
class PreservesBinaryBiproduct (X Y : C) (F : C ⥤ D) [PreservesZeroMorphisms F] where
  preserves : ∀ {b : BinaryBicone X Y}, b.IsBilimit → (F.mapBinaryBicone b).IsBilimit
goal: b.IsBilimit → (F.mapBinaryBicone b).IsBilimit

full_name: CategoryTheory.Limits.PreservesBinaryBiproduct
code: /-- A functor `F` preserves binary biproducts of `X` and `Y` if `F` maps every bilimit bicone over
    `X` and `Y` to a bilimit bicone over `F.obj X` and `F.obj Y`. -/
class PreservesBinaryBiproduct (X Y : C) (F : C ⥤ D) [PreservesZeroMorphisms F] where
  preserves : ∀ {b : BinaryBicone X Y}, b.IsBilimit → (F.mapBinaryBicone b).IsBilimit
goal: Type (max (max (max u₁ u₂) v₁) v₂)

full_name: CategoryTheory.Limits.isBinaryBilimitOfPreserves
code: /-- A functor `F` preserves binary biproducts of `X` and `Y` if `F` maps every bilimit bicone over
    `X` and `Y` to a bilimit bicone over `F.obj X` and `F.obj Y`. -/
def isBinaryBilimitOfPreserves {X Y : C} (F : C ⥤ D) [PreservesZeroMorphisms F]
    [PreservesBinaryBiproduct X Y F] {b : BinaryBicone X Y} (hb : b.IsBilimit) :
    (F.mapBinaryBicone b).IsBilimit 
goal: (F.mapBinaryBicone b).IsBilimit

full_name: CategoryTheory.Limits.PreservesBinaryBiproducts
code: /-- A functor `F` preserves binary biproducts if it preserves the binary biproduct of `X` and `Y`
    for all `X` and `Y`. -/
class PreservesBinaryBiproducts (F : C ⥤ D) [PreservesZeroMorphisms F] where
  preserves : ∀ {X Y : C}, PreservesBinaryBiproduct X Y F := by infer_instance
goal: Type (max (max (max u₁ u₂) v₁) v₂)

full_name: CategoryTheory.Limits.PreservesBinaryBiproducts.preserves
code: /-- A functor `F` preserves binary biproducts if it preserves the binary biproduct of `X` and `Y`
    for all `X` and `Y`. -/
class PreservesBinaryBiproducts (F : C ⥤ D) [PreservesZeroMorphisms F] where
  preserves : ∀ {X Y : C}, PreservesBinaryBiproduct X Y F := by infer_instance
goal: CategoryTheory.Limits.PreservesBinaryBiproduct X Y F

full_name: CategoryTheory.Limits.preservesBinaryBiproductOfPreservesBiproduct
code: /-- A functor that preserves biproducts of a pair preserves binary biproducts. -/
def preservesBinaryBiproductOfPreservesBiproduct (F : C ⥤ D) [PreservesZeroMorphisms F] (X Y : C)
    [PreservesBiproduct (pairFunction X Y) F] : PreservesBinaryBiproduct X Y F 
goal: CategoryTheory.Limits.PreservesBinaryBiproduct X Y F

full_name: CategoryTheory.Limits.preservesBinaryBiproductsOfPreservesBiproducts
code: /-- A functor that preserves biproducts of a pair preserves binary biproducts. -/
def preservesBinaryBiproductsOfPreservesBiproducts (F : C ⥤ D) [PreservesZeroMorphisms F]
    [PreservesBiproductsOfShape WalkingPair F] : PreservesBinaryBiproducts F 
goal: CategoryTheory.Limits.PreservesBinaryBiproducts F

full_name: CategoryTheory.Functor.biproductComparison
code: /-- As for products, any functor between categories with biproducts gives rise to a morphism
    `F.obj (⨁ f) ⟶ ⨁ (F.obj ∘ f)`. -/
def biproductComparison : F.obj (⨁ f) ⟶ ⨁ F.obj ∘ f 
goal: F.obj (⨁ f) ⟶ ⨁ F.obj ∘ f

full_name: CategoryTheory.Functor.biproductComparison_π
code: @[reassoc (attr := simp)]
theorem biproductComparison_π (j : J) :
    biproductComparison F f ≫ biproduct.π _ j = F.map (biproduct.π f j) 
goal: F.biproductComparison f ≫ CategoryTheory.Limits.biproduct.π (F.obj ∘ f) j =
  F.map (CategoryTheory.Limits.biproduct.π f j)

full_name: CategoryTheory.Functor.biproductComparison'
code: /-- As for coproducts, any functor between categories with biproducts gives rise to a morphism
    `⨁ (F.obj ∘ f) ⟶ F.obj (⨁ f)` -/
def biproductComparison' : ⨁ F.obj ∘ f ⟶ F.obj (⨁ f) 
goal: ⨁ F.obj ∘ f ⟶ F.obj (⨁ f)

full_name: CategoryTheory.Functor.ι_biproductComparison'
code: @[reassoc (attr := simp)]
theorem ι_biproductComparison' (j : J) :
    biproduct.ι _ j ≫ biproductComparison' F f = F.map (biproduct.ι f j) 
goal: CategoryTheory.Limits.biproduct.ι (F.obj ∘ f) j ≫ F.biproductComparison' f =
  F.map (CategoryTheory.Limits.biproduct.ι f j)

full_name: CategoryTheory.Functor.biproductComparison'_comp_biproductComparison
code: /-- The composition in the opposite direction is equal to the identity if and only if `F` preserves
    the biproduct, see `preservesBiproduct_of_monoBiproductComparison`.  -/
@[reassoc (attr := simp)]
theorem biproductComparison'_comp_biproductComparison :
    biproductComparison' F f ≫ biproductComparison F f = 𝟙 (⨁ F.obj ∘ f) 
goal: F.biproductComparison' f ≫ F.biproductComparison f = 𝟙 (⨁ F.obj ∘ f)

full_name: CategoryTheory.Functor.splitEpiBiproductComparison
code: /-- `biproduct_comparison F f` is a split epimorphism. -/
@[simps]
def splitEpiBiproductComparison : SplitEpi (biproductComparison F f) 
goal: CategoryTheory.SplitEpi (F.biproductComparison f)

full_name: CategoryTheory.Functor.splitEpiBiproductComparison_section_
code: /-- `biproduct_comparison F f` is a split epimorphism. -/
@[simps]
def splitEpiBiproductComparison : SplitEpi (biproductComparison F f) 
goal: (F.splitEpiBiproductComparison f).section_ = F.biproductComparison' f

full_name: CategoryTheory.Functor.instIsSplitEpiBiproductComparison
code: instance : IsSplitEpi (biproductComparison F f) 
goal: CategoryTheory.IsSplitEpi (F.biproductComparison f)

full_name: CategoryTheory.Functor.splitMonoBiproductComparison'_retraction
code: /-- `biproduct_comparison' F f` is a split monomorphism. -/
@[simps]
def splitMonoBiproductComparison' : SplitMono (biproductComparison' F f) 
goal: (F.splitMonoBiproductComparison' f).retraction = F.biproductComparison f

full_name: CategoryTheory.Functor.splitMonoBiproductComparison'
code: /-- `biproduct_comparison' F f` is a split monomorphism. -/
@[simps]
def splitMonoBiproductComparison' : SplitMono (biproductComparison' F f) 
goal: CategoryTheory.SplitMono (F.biproductComparison' f)

full_name: CategoryTheory.Functor.instIsSplitMonoBiproductComparison'
code: instance : IsSplitMono (biproductComparison' F f) 
goal: CategoryTheory.IsSplitMono (F.biproductComparison' f)

full_name: CategoryTheory.Functor.hasBiproduct_of_preserves
code: instance hasBiproduct_of_preserves : HasBiproduct (F.obj ∘ f) 
goal: CategoryTheory.Limits.HasBiproduct (F.obj ∘ f)

full_name: CategoryTheory.Functor.mapBiproduct
code: /-- If `F` preserves a biproduct, we get a definitionally nice isomorphism
    `F.obj (⨁ f) ≅ ⨁ (F.obj ∘ f)`. -/
@[simp]
def mapBiproduct : F.obj (⨁ f) ≅ ⨁ F.obj ∘ f 
goal: F.obj (⨁ f) ≅ ⨁ F.obj ∘ f

full_name: CategoryTheory.Functor.mapBiproduct_hom
code: theorem mapBiproduct_hom :
    haveI : HasBiproduct fun j => F.obj (f j) := hasBiproduct_of_preserves F f
    (mapBiproduct F f).hom = biproduct.lift fun j => F.map (biproduct.π f j) 
goal: (F.mapBiproduct f).hom = CategoryTheory.Limits.biproduct.lift fun j => F.map (CategoryTheory.Limits.biproduct.π f j)

full_name: CategoryTheory.Functor.mapBiproduct_inv
code: theorem mapBiproduct_inv :
    haveI : HasBiproduct fun j => F.obj (f j) := hasBiproduct_of_preserves F f
    (mapBiproduct F f).inv = biproduct.desc fun j => F.map (biproduct.ι f j) 
goal: (F.mapBiproduct f).inv = CategoryTheory.Limits.biproduct.desc fun j => F.map (CategoryTheory.Limits.biproduct.ι f j)

full_name: CategoryTheory.Functor.biprodComparison
code: /-- As for products, any functor between categories with binary biproducts gives rise to a
    morphism `F.obj (X ⊞ Y) ⟶ F.obj X ⊞ F.obj Y`. -/
def biprodComparison : F.obj (X ⊞ Y) ⟶ F.obj X ⊞ F.obj Y 
goal: F.obj (X ⊞ Y) ⟶ F.obj X ⊞ F.obj Y

full_name: CategoryTheory.Functor.biprodComparison_fst
code: @[reassoc (attr := simp)]
theorem biprodComparison_fst : biprodComparison F X Y ≫ biprod.fst = F.map biprod.fst 
goal: F.biprodComparison X Y ≫ CategoryTheory.Limits.biprod.fst = F.map CategoryTheory.Limits.biprod.fst

full_name: CategoryTheory.Functor.biprodComparison_snd
code: @[reassoc (attr := simp)]
theorem biprodComparison_snd : biprodComparison F X Y ≫ biprod.snd = F.map biprod.snd 
goal: F.biprodComparison X Y ≫ CategoryTheory.Limits.biprod.snd = F.map CategoryTheory.Limits.biprod.snd

full_name: CategoryTheory.Functor.biprodComparison'
code: /-- As for coproducts, any functor between categories with binary biproducts gives rise to a
    morphism `F.obj X ⊞ F.obj Y ⟶ F.obj (X ⊞ Y)`. -/
def biprodComparison' : F.obj X ⊞ F.obj Y ⟶ F.obj (X ⊞ Y) 
goal: F.obj X ⊞ F.obj Y ⟶ F.obj (X ⊞ Y)

full_name: CategoryTheory.Functor.inl_biprodComparison'
code: @[reassoc (attr := simp)]
theorem inl_biprodComparison' : biprod.inl ≫ biprodComparison' F X Y = F.map biprod.inl 
goal: CategoryTheory.Limits.biprod.inl ≫ F.biprodComparison' X Y = F.map CategoryTheory.Limits.biprod.inl

full_name: CategoryTheory.Functor.inr_biprodComparison'
code: @[reassoc (attr := simp)]
theorem inr_biprodComparison' : biprod.inr ≫ biprodComparison' F X Y = F.map biprod.inr 
goal: CategoryTheory.Limits.biprod.inr ≫ F.biprodComparison' X Y = F.map CategoryTheory.Limits.biprod.inr

full_name: CategoryTheory.Functor.biprodComparison'_comp_biprodComparison
code: /-- The composition in the opposite direction is equal to the identity if and only if `F` preserves
    the biproduct, see `preservesBinaryBiproduct_of_monoBiprodComparison`. -/
@[reassoc (attr := simp)]
theorem biprodComparison'_comp_biprodComparison :
    biprodComparison' F X Y ≫ biprodComparison F X Y = 𝟙 (F.obj X ⊞ F.obj Y) 
goal: F.biprodComparison' X Y ≫ F.biprodComparison X Y = 𝟙 (F.obj X ⊞ F.obj Y)

full_name: CategoryTheory.Functor.splitEpiBiprodComparison_section_
code: /-- `biprodComparison F X Y` is a split epi. -/
@[simps]
def splitEpiBiprodComparison : SplitEpi (biprodComparison F X Y) 
goal: (F.splitEpiBiprodComparison X Y).section_ = F.biprodComparison' X Y

full_name: CategoryTheory.Functor.splitEpiBiprodComparison
code: /-- `biprodComparison F X Y` is a split epi. -/
@[simps]
def splitEpiBiprodComparison : SplitEpi (biprodComparison F X Y) 
goal: CategoryTheory.SplitEpi (F.biprodComparison X Y)

full_name: CategoryTheory.Functor.instIsSplitEpiBiprodComparison
code: instance : IsSplitEpi (biprodComparison F X Y) 
goal: CategoryTheory.IsSplitEpi (F.biprodComparison X Y)

full_name: CategoryTheory.Functor.splitMonoBiprodComparison'_retraction
code: /-- `biprodComparison' F X Y` is a split mono. -/
@[simps]
def splitMonoBiprodComparison' : SplitMono (biprodComparison' F X Y) 
goal: (F.splitMonoBiprodComparison' X Y).retraction = F.biprodComparison X Y

full_name: CategoryTheory.Functor.splitMonoBiprodComparison'
code: /-- `biprodComparison' F X Y` is a split mono. -/
@[simps]
def splitMonoBiprodComparison' : SplitMono (biprodComparison' F X Y) 
goal: CategoryTheory.SplitMono (F.biprodComparison' X Y)

full_name: CategoryTheory.Functor.instIsSplitMonoBiprodComparison'
code: instance : IsSplitMono (biprodComparison' F X Y) 
goal: CategoryTheory.IsSplitMono (F.biprodComparison' X Y)

full_name: CategoryTheory.Functor.hasBinaryBiproduct_of_preserves
code: instance hasBinaryBiproduct_of_preserves : HasBinaryBiproduct (F.obj X) (F.obj Y) 
goal: CategoryTheory.Limits.HasBinaryBiproduct (F.obj X) (F.obj Y)

full_name: CategoryTheory.Functor.mapBiprod
code: /-- If `F` preserves a binary biproduct, we get a definitionally nice isomorphism
    `F.obj (X ⊞ Y) ≅ F.obj X ⊞ F.obj Y`. -/
@[simp]
def mapBiprod : F.obj (X ⊞ Y) ≅ F.obj X ⊞ F.obj Y 
goal: F.obj (X ⊞ Y) ≅ F.obj X ⊞ F.obj Y

full_name: CategoryTheory.Functor.mapBiprod_hom
code: theorem mapBiprod_hom : (mapBiprod F X Y).hom = biprod.lift (F.map biprod.fst) (F.map biprod.snd) 
goal: (F.mapBiprod X Y).hom =
  CategoryTheory.Limits.biprod.lift (F.map CategoryTheory.Limits.biprod.fst) (F.map CategoryTheory.Limits.biprod.snd)

full_name: CategoryTheory.Functor.mapBiprod_inv
code: theorem mapBiprod_inv : (mapBiprod F X Y).inv = biprod.desc (F.map biprod.inl) (F.map biprod.inr) 
goal: (F.mapBiprod X Y).inv =
  CategoryTheory.Limits.biprod.desc (F.map CategoryTheory.Limits.biprod.inl) (F.map CategoryTheory.Limits.biprod.inr)

full_name: CategoryTheory.Limits.biproduct.map_lift_mapBiprod
code: theorem biproduct.map_lift_mapBiprod (g : ∀ j, W ⟶ f j) :
    -- Porting note: twice we need haveI to tell Lean about hasBiproduct_of_preserves F f
    haveI : HasBiproduct fun j => F.obj (f j) := hasBiproduct_of_preserves F f
    F.map (biproduct.lift g) ≫ (F.mapBiproduct f).hom = biproduct.lift fun j => F.map (g j) 
goal: F.map (CategoryTheory.Limits.biproduct.lift g) ≫ (F.mapBiproduct f).hom =
  CategoryTheory.Limits.biproduct.lift fun j => F.map (g j)

full_name: CategoryTheory.Limits.biproduct.mapBiproduct_inv_map_desc
code: theorem biproduct.mapBiproduct_inv_map_desc (g : ∀ j, f j ⟶ W) :
    -- Porting note: twice we need haveI to tell Lean about hasBiproduct_of_preserves F f
    haveI : HasBiproduct fun j => F.obj (f j) := hasBiproduct_of_preserves F f
    (F.mapBiproduct f).inv ≫ F.map (biproduct.desc g) = biproduct.desc fun j => F.map (g j) 
goal: (F.mapBiproduct f).inv ≫ F.map (CategoryTheory.Limits.biproduct.desc g) =
  CategoryTheory.Limits.biproduct.desc fun j => F.map (g j)

full_name: CategoryTheory.Limits.biproduct.mapBiproduct_hom_desc
code: theorem biproduct.mapBiproduct_hom_desc (g : ∀ j, f j ⟶ W) :
    ((F.mapBiproduct f).hom ≫ biproduct.desc fun j => F.map (g j)) = F.map (biproduct.desc g) 
goal: ((F.mapBiproduct f).hom ≫ CategoryTheory.Limits.biproduct.desc fun j => F.map (g j)) =
  F.map (CategoryTheory.Limits.biproduct.desc g)

full_name: CategoryTheory.Limits.biprod.map_lift_mapBiprod
code: theorem biprod.map_lift_mapBiprod (f : W ⟶ X) (g : W ⟶ Y) :
    F.map (biprod.lift f g) ≫ (F.mapBiprod X Y).hom = biprod.lift (F.map f) (F.map g) 
goal: F.map (CategoryTheory.Limits.biprod.lift f g) ≫ (F.mapBiprod X Y).hom =
  CategoryTheory.Limits.biprod.lift (F.map f) (F.map g)

full_name: CategoryTheory.Limits.biprod.lift_mapBiprod
code: theorem biprod.lift_mapBiprod (f : W ⟶ X) (g : W ⟶ Y) :
    biprod.lift (F.map f) (F.map g) ≫ (F.mapBiprod X Y).inv = F.map (biprod.lift f g) 
goal: CategoryTheory.Limits.biprod.lift (F.map f) (F.map g) ≫ (F.mapBiprod X Y).inv =
  F.map (CategoryTheory.Limits.biprod.lift f g)

full_name: CategoryTheory.Limits.biprod.mapBiprod_inv_map_desc
code: theorem biprod.mapBiprod_inv_map_desc (f : X ⟶ W) (g : Y ⟶ W) :
    (F.mapBiprod X Y).inv ≫ F.map (biprod.desc f g) = biprod.desc (F.map f) (F.map g) 
goal: (F.mapBiprod X Y).inv ≫ F.map (CategoryTheory.Limits.biprod.desc f g) =
  CategoryTheory.Limits.biprod.desc (F.map f) (F.map g)

full_name: CategoryTheory.Limits.biprod.mapBiprod_hom_desc
code: theorem biprod.mapBiprod_hom_desc (f : X ⟶ W) (g : Y ⟶ W) :
    (F.mapBiprod X Y).hom ≫ biprod.desc (F.map f) (F.map g) = F.map (biprod.desc f g) 
goal: (F.mapBiprod X Y).hom ≫ CategoryTheory.Limits.biprod.desc (F.map f) (F.map g) =
  F.map (CategoryTheory.Limits.biprod.desc f g)