[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
F : J → C
B : Bicone F
j : J
⊢ Bicone.ι B j ≫ Bicone.π B j = 𝟙 (F j)
[PROOFSTEP]
simpa using B.ι_π j j
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
F : J → C
B : Bicone F
j j' : J
h : j ≠ j'
⊢ Bicone.ι B j ≫ Bicone.π B j' = 0
[PROOFSTEP]
simpa [h] using B.ι_π j j'
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
F : J → C
B : Bicone F
⊢ ∀ ⦃X Y : Discrete J⦄ (f : X ⟶ Y),
    (Discrete.functor F).map f ≫ (fun j => ι B j.as) Y = (fun j => ι B j.as) X ≫ ((const (Discrete J)).obj B.pt).map f
[PROOFSTEP]
intro ⟨j⟩ ⟨j'⟩ ⟨⟨f⟩⟩
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
F : J → C
B : Bicone F
j j' : J
f : { as := j }.as = { as := j' }.as
⊢ (Discrete.functor F).map { down := { down := f } } ≫ (fun j => ι B j.as) { as := j' } =
    (fun j => ι B j.as) { as := j } ≫ ((const (Discrete J)).obj B.pt).map { down := { down := f } }
[PROOFSTEP]
cases f
[GOAL]
case refl
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
F : J → C
B : Bicone F
j : J
⊢ (Discrete.functor F).map { down := { down := (_ : { as := j }.as = { as := j }.as) } } ≫
      (fun j => ι B j.as) { as := j } =
    (fun j => ι B j.as) { as := j } ≫
      ((const (Discrete J)).obj B.pt).map { down := { down := (_ : { as := j }.as = { as := j }.as) } }
[PROOFSTEP]
simp
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
F f : J → C
t : Cone (Discrete.functor f)
ht : IsLimit t
j j' : J
⊢ (fun j => IsLimit.lift ht (Fan.mk (f j) fun j' => if h : j = j' then eqToHom (_ : f j = f j') else 0)) j ≫
      (fun j => NatTrans.app t.π { as := j }) j' =
    if h : j = j' then eqToHom (_ : f j = f j') else 0
[PROOFSTEP]
simp
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
F f : J → C
t : Bicone f
ht : IsLimit (toCone t)
j : J
j' : Discrete J
⊢ ι t j ≫ NatTrans.app (toCone t).π j' =
    IsLimit.lift ht (Fan.mk (f j) fun j' => if h : j = j' then eqToHom (_ : f j = f j') else 0) ≫
      NatTrans.app (toCone t).π j'
[PROOFSTEP]
rw [ht.fac]
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
F f : J → C
t : Bicone f
ht : IsLimit (toCone t)
j : J
j' : Discrete J
⊢ ι t j ≫ NatTrans.app (toCone t).π j' =
    NatTrans.app (Fan.mk (f j) fun j' => if h : j = j' then eqToHom (_ : f j = f j') else 0).π j'
[PROOFSTEP]
simp [t.ι_π]
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
F f : J → C
t : Cocone (Discrete.functor f)
ht : IsColimit t
j j' : J
⊢ (fun j => NatTrans.app t.ι { as := j }) j ≫
      (fun j => IsColimit.desc ht (Cofan.mk (f j) fun j' => if h : j' = j then eqToHom (_ : f j' = f j) else 0)) j' =
    if h : j = j' then eqToHom (_ : f j = f j') else 0
[PROOFSTEP]
simp
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
F f : J → C
t : Bicone f
ht : IsColimit (toCocone t)
j : J
j' : Discrete J
⊢ NatTrans.app (toCocone t).ι j' ≫ π t j =
    NatTrans.app (toCocone t).ι j' ≫
      IsColimit.desc ht (Cofan.mk (f j) fun j' => if h : j' = j then eqToHom (_ : f j' = f j) else 0)
[PROOFSTEP]
rw [ht.fac]
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
F f : J → C
t : Bicone f
ht : IsColimit (toCocone t)
j : J
j' : Discrete J
⊢ NatTrans.app (toCocone t).ι j' ≫ π t j =
    NatTrans.app (Cofan.mk (f j) fun j' => if h : j' = j then eqToHom (_ : f j' = f j) else 0).ι j'
[PROOFSTEP]
simp [t.ι_π]
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
F : J → C
K : Type w'
f : J → C
c : Bicone f
g : K ≃ J
k k' : K
⊢ (fun k => ι c (↑g k)) k ≫ (fun k => π c (↑g k)) k' = if h : k = k' then eqToHom (_ : (f ∘ ↑g) k = (f ∘ ↑g) k') else 0
[PROOFSTEP]
simp only [c.ι_π]
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
F : J → C
K : Type w'
f : J → C
c : Bicone f
g : K ≃ J
k k' : K
⊢ (if h : ↑g k = ↑g k' then eqToHom (_ : f (↑g k) = f (↑g k')) else 0) =
    if h : k = k' then eqToHom (_ : (f ∘ ↑g) k = (f ∘ ↑g) k') else 0
[PROOFSTEP]
split_ifs with h h' h'
[GOAL]
case pos
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
F : J → C
K : Type w'
f : J → C
c : Bicone f
g : K ≃ J
k k' : K
h : ↑g k = ↑g k'
h' : k = k'
⊢ eqToHom (_ : f (↑g k) = f (↑g k')) = eqToHom (_ : (f ∘ ↑g) k = (f ∘ ↑g) k')
[PROOFSTEP]
simp [Equiv.apply_eq_iff_eq g] at h h'
[GOAL]
case neg
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
F : J → C
K : Type w'
f : J → C
c : Bicone f
g : K ≃ J
k k' : K
h : ↑g k = ↑g k'
h' : ¬k = k'
⊢ eqToHom (_ : f (↑g k) = f (↑g k')) = 0
[PROOFSTEP]
simp [Equiv.apply_eq_iff_eq g] at h h'
[GOAL]
case pos
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
F : J → C
K : Type w'
f : J → C
c : Bicone f
g : K ≃ J
k k' : K
h : ¬↑g k = ↑g k'
h' : k = k'
⊢ 0 = eqToHom (_ : (f ∘ ↑g) k = (f ∘ ↑g) k')
[PROOFSTEP]
simp [Equiv.apply_eq_iff_eq g] at h h'
[GOAL]
case neg
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
F : J → C
K : Type w'
f : J → C
c : Bicone f
g : K ≃ J
k k' : K
h : ¬↑g k = ↑g k'
h' : ¬k = k'
⊢ 0 = 0
[PROOFSTEP]
simp [Equiv.apply_eq_iff_eq g] at h h'
[GOAL]
case pos
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
F : J → C
K : Type w'
f : J → C
c : Bicone f
g : K ≃ J
k k' : K
h✝ : ↑g k = ↑g k'
h' h : k = k'
⊢ eqToHom (_ : f (↑g k) = f (↑g k')) = eqToHom (_ : (f ∘ ↑g) k = (f ∘ ↑g) k')
[PROOFSTEP]
tauto
[GOAL]
case neg
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
F : J → C
K : Type w'
f : J → C
c : Bicone f
g : K ≃ J
k k' : K
h✝ : ↑g k = ↑g k'
h' : ¬k = k'
h : k = k'
⊢ eqToHom (_ : f (↑g k) = f (↑g k')) = 0
[PROOFSTEP]
tauto
[GOAL]
case pos
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
F : J → C
K : Type w'
f : J → C
c : Bicone f
g : K ≃ J
k k' : K
h' : k = k'
h : ¬k = k'
⊢ 0 = eqToHom (_ : (f ∘ ↑g) k = (f ∘ ↑g) k')
[PROOFSTEP]
tauto
[GOAL]
case neg
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
F : J → C
K : Type w'
f : J → C
c : Bicone f
g : K ≃ J
k k' : K
h' h : ¬k = k'
⊢ 0 = 0
[PROOFSTEP]
tauto
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
F : J → C
K : Type w'
f : J → C
c : Bicone f
g : K ≃ J
⊢ ∀ (j : Discrete K),
    NatTrans.app (toCone (whisker c g)).π j =
      (Iso.refl (toCone (whisker c g)).pt).hom ≫
        NatTrans.app
          ((Cones.postcompose (Discrete.functorComp f ↑g).inv).obj
              (Cone.whisker (Discrete.functor (Discrete.mk ∘ ↑g)) (toCone c))).π
          j
[PROOFSTEP]
aesop_cat
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
F : J → C
K : Type w'
f : J → C
c : Bicone f
g : K ≃ J
⊢ ∀ (j : Discrete K),
    NatTrans.app (toCocone (whisker c g)).ι j ≫ (Iso.refl (toCocone (whisker c g)).pt).hom =
      NatTrans.app
        ((Cocones.precompose (Discrete.functorComp f ↑g).hom).obj
            (Cocone.whisker (Discrete.functor (Discrete.mk ∘ ↑g)) (toCocone c))).ι
        j
[PROOFSTEP]
aesop_cat
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
F : J → C
K : Type w'
f : J → C
c : Bicone f
g : K ≃ J
⊢ IsBilimit (whisker c g) ≃ IsBilimit c
[PROOFSTEP]
refine' equivOfSubsingletonOfSubsingleton (fun hc => ⟨_, _⟩) fun hc => ⟨_, _⟩
[GOAL]
case refine'_1
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
F : J → C
K : Type w'
f : J → C
c : Bicone f
g : K ≃ J
hc : IsBilimit (whisker c g)
⊢ IsLimit (toCone c)
[PROOFSTEP]
let this := IsLimit.ofIsoLimit hc.isLimit (Bicone.whiskerToCone c g)
[GOAL]
case refine'_1
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
F : J → C
K : Type w'
f : J → C
c : Bicone f
g : K ≃ J
hc : IsBilimit (whisker c g)
this : IsLimit
  ((Cones.postcompose (Discrete.functorComp f ↑g).inv).obj
    (Cone.whisker (Discrete.functor (Discrete.mk ∘ ↑g)) (toCone c))) :=
  IsLimit.ofIsoLimit hc.isLimit (whiskerToCone c g)
⊢ IsLimit (toCone c)
[PROOFSTEP]
let this := (IsLimit.postcomposeHomEquiv (Discrete.functorComp f g).symm _) this
[GOAL]
case refine'_1
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
F : J → C
K : Type w'
f : J → C
c : Bicone f
g : K ≃ J
hc : IsBilimit (whisker c g)
this✝ : IsLimit
  ((Cones.postcompose (Discrete.functorComp f ↑g).inv).obj
    (Cone.whisker (Discrete.functor (Discrete.mk ∘ ↑g)) (toCone c))) :=
  IsLimit.ofIsoLimit hc.isLimit (whiskerToCone c g)
this : (fun x => IsLimit (Cone.whisker (Discrete.functor (Discrete.mk ∘ ↑g)) (toCone c))) this✝ :=
  ↑(IsLimit.postcomposeHomEquiv (Discrete.functorComp f ↑g).symm
        (Cone.whisker (Discrete.functor (Discrete.mk ∘ ↑g)) (toCone c)))
    this✝
⊢ IsLimit (toCone c)
[PROOFSTEP]
exact IsLimit.ofWhiskerEquivalence (Discrete.equivalence g) this
[GOAL]
case refine'_2
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
F : J → C
K : Type w'
f : J → C
c : Bicone f
g : K ≃ J
hc : IsBilimit (whisker c g)
⊢ IsColimit (toCocone c)
[PROOFSTEP]
let this := IsColimit.ofIsoColimit hc.isColimit (Bicone.whiskerToCocone c g)
[GOAL]
case refine'_2
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
F : J → C
K : Type w'
f : J → C
c : Bicone f
g : K ≃ J
hc : IsBilimit (whisker c g)
this : IsColimit
  ((Cocones.precompose (Discrete.functorComp f ↑g).hom).obj
    (Cocone.whisker (Discrete.functor (Discrete.mk ∘ ↑g)) (toCocone c))) :=
  IsColimit.ofIsoColimit hc.isColimit (whiskerToCocone c g)
⊢ IsColimit (toCocone c)
[PROOFSTEP]
let this := (IsColimit.precomposeHomEquiv (Discrete.functorComp f g) _) this
[GOAL]
case refine'_2
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
F : J → C
K : Type w'
f : J → C
c : Bicone f
g : K ≃ J
hc : IsBilimit (whisker c g)
this✝ : IsColimit
  ((Cocones.precompose (Discrete.functorComp f ↑g).hom).obj
    (Cocone.whisker (Discrete.functor (Discrete.mk ∘ ↑g)) (toCocone c))) :=
  IsColimit.ofIsoColimit hc.isColimit (whiskerToCocone c g)
this : (fun x => IsColimit (Cocone.whisker (Discrete.functor (Discrete.mk ∘ ↑g)) (toCocone c))) this✝ :=
  ↑(IsColimit.precomposeHomEquiv (Discrete.functorComp f ↑g)
        (Cocone.whisker (Discrete.functor (Discrete.mk ∘ ↑g)) (toCocone c)))
    this✝
⊢ IsColimit (toCocone c)
[PROOFSTEP]
exact IsColimit.ofWhiskerEquivalence (Discrete.equivalence g) this
[GOAL]
case refine'_3
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
F : J → C
K : Type w'
f : J → C
c : Bicone f
g : K ≃ J
hc : IsBilimit c
⊢ IsLimit (toCone (whisker c g))
[PROOFSTEP]
apply IsLimit.ofIsoLimit _ (Bicone.whiskerToCone c g).symm
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
F : J → C
K : Type w'
f : J → C
c : Bicone f
g : K ≃ J
hc : IsBilimit c
⊢ IsLimit
    ((Cones.postcompose (Discrete.functorComp f ↑g).inv).obj
      (Cone.whisker (Discrete.functor (Discrete.mk ∘ ↑g)) (toCone c)))
[PROOFSTEP]
apply (IsLimit.postcomposeHomEquiv (Discrete.functorComp f g).symm _).symm _
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
F : J → C
K : Type w'
f : J → C
c : Bicone f
g : K ≃ J
hc : IsBilimit c
⊢ IsLimit (Cone.whisker (Discrete.functor (Discrete.mk ∘ ↑g)) (toCone c))
[PROOFSTEP]
exact IsLimit.whiskerEquivalence hc.isLimit (Discrete.equivalence g)
[GOAL]
case refine'_4
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
F : J → C
K : Type w'
f : J → C
c : Bicone f
g : K ≃ J
hc : IsBilimit c
⊢ IsColimit (toCocone (whisker c g))
[PROOFSTEP]
apply IsColimit.ofIsoColimit _ (Bicone.whiskerToCocone c g).symm
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
F : J → C
K : Type w'
f : J → C
c : Bicone f
g : K ≃ J
hc : IsBilimit c
⊢ IsColimit
    ((Cocones.precompose (Discrete.functorComp f ↑g).hom).obj
      (Cocone.whisker (Discrete.functor (Discrete.mk ∘ ↑g)) (toCocone c)))
[PROOFSTEP]
apply (IsColimit.precomposeHomEquiv (Discrete.functorComp f g) _).symm _
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
F : J → C
K : Type w'
f : J → C
c : Bicone f
g : K ≃ J
hc : IsBilimit c
⊢ IsColimit (Cocone.whisker (Discrete.functor (Discrete.mk ∘ ↑g)) (toCocone c))
[PROOFSTEP]
exact IsColimit.whiskerEquivalence hc.isColimit (Discrete.equivalence g)
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
F✝ : J → C
K : Type w'
inst✝ : HasBiproductsOfShape K C
e : J ≃ K
F : J → C
h : LimitBicone (F ∘ ↑e.symm)
c : Bicone (F ∘ ↑e.symm)
hc : Bicone.IsBilimit c
⊢ LimitBicone F
[PROOFSTEP]
simpa only [(· ∘ ·), e.symm_apply_apply] using LimitBicone.mk (c.whisker e) ((c.whiskerIsBilimitIff _).2 hc)
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
F : J → C
inst✝¹ : HasFiniteBiproducts C
inst✝ : Finite J
⊢ HasBiproductsOfShape J C
[PROOFSTEP]
rcases Finite.exists_equiv_fin J with ⟨n, ⟨e⟩⟩
[GOAL]
case intro.intro
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
F : J → C
inst✝¹ : HasFiniteBiproducts C
inst✝ : Finite J
n : ℕ
e : J ≃ Fin n
⊢ HasBiproductsOfShape J C
[PROOFSTEP]
haveI : HasBiproductsOfShape (Fin n) C := HasFiniteBiproducts.out n
[GOAL]
case intro.intro
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
F : J → C
inst✝¹ : HasFiniteBiproducts C
inst✝ : Finite J
n : ℕ
e : J ≃ Fin n
this : HasBiproductsOfShape (Fin n) C
⊢ HasBiproductsOfShape J C
[PROOFSTEP]
exact hasBiproductsOfShape_of_equiv C e
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
inst✝¹ : DecidableEq J
f : J → C
inst✝ : HasBiproduct f
j j' : J
⊢ ι f j ≫ π f j' = if h : j = j' then eqToHom (_ : f j = f j') else 0
[PROOFSTEP]
convert (biproduct.bicone f).ι_π j j'
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
f : J → C
inst✝ : HasBiproduct f
j : J
⊢ ι f j ≫ π f j = 𝟙 (f j)
[PROOFSTEP]
simp [biproduct.ι_π]
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
f : J → C
inst✝ : HasBiproduct f
j j' : J
h : j ≠ j'
⊢ ι f j ≫ π f j' = 0
[PROOFSTEP]
simp [biproduct.ι_π, h]
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
f : J → C
inst✝ : HasBiproduct f
j j' : J
w : j = j'
⊢ f j = f j'
[PROOFSTEP]
simp [w]
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
f : J → C
inst✝ : HasBiproduct f
j j' : J
w : j = j'
⊢ eqToHom (_ : f j = f j') ≫ ι f j' = ι f j
[PROOFSTEP]
cases w
[GOAL]
case refl
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
f : J → C
inst✝ : HasBiproduct f
j : J
⊢ eqToHom (_ : f j = f j) ≫ ι f j = ι f j
[PROOFSTEP]
simp
  -- The `simpNF` linter incorrectly identifies these as simp lemmas that could never apply.
  -- https://github.com/leanprover-community/mathlib4/issues/5049
  -- They are used by `simp` in `biproduct.whisker_equiv` below.
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
f : J → C
inst✝ : HasBiproduct f
j j' : J
w : j = j'
⊢ f j = f j'
[PROOFSTEP]
simp [w]
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
f : J → C
inst✝ : HasBiproduct f
j j' : J
w : j = j'
⊢ π f j ≫ eqToHom (_ : f j = f j') = π f j'
[PROOFSTEP]
cases w
[GOAL]
case refl
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
f : J → C
inst✝ : HasBiproduct f
j : J
⊢ π f j ≫ eqToHom (_ : f j = f j) = π f j
[PROOFSTEP]
simp
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
f : J → C
inst✝ : HasBiproduct f
j : Discrete J
⊢ (isoProduct f).hom ≫ limit.π (Discrete.functor f) j = Pi.lift (π f) ≫ limit.π (Discrete.functor f) j
[PROOFSTEP]
simp [biproduct.isoProduct]
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
f : J → C
inst✝ : HasBiproduct f
j : J
⊢ (isoProduct f).inv ≫ π f j = lift (Pi.π f) ≫ π f j
[PROOFSTEP]
simp [Iso.inv_comp_eq]
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
f : J → C
inst✝ : HasBiproduct f
j : Discrete J
⊢ colimit.ι (Discrete.functor f) j ≫ (isoCoproduct f).inv = colimit.ι (Discrete.functor f) j ≫ Sigma.desc (ι f)
[PROOFSTEP]
simp [biproduct.isoCoproduct]
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
f : J → C
inst✝ : HasBiproduct f
j : J
⊢ ι f j ≫ (isoCoproduct f).hom = ι f j ≫ desc (Sigma.ι f)
[PROOFSTEP]
simp [← Iso.eq_comp_inv]
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f g : J → C
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
p : (b : J) → f b ⟶ g b
⊢ map p = map' p
[PROOFSTEP]
ext
[GOAL]
case w.w
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f g : J → C
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
p : (b : J) → f b ⟶ g b
j✝¹ j✝ : J
⊢ ι (fun b => f b) j✝ ≫ map p ≫ π (fun b => g b) j✝¹ = ι (fun b => f b) j✝ ≫ map' p ≫ π (fun b => g b) j✝¹
[PROOFSTEP]
dsimp
[GOAL]
case w.w
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f g : J → C
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
p : (b : J) → f b ⟶ g b
j✝¹ j✝ : J
⊢ ι (fun b => f b) j✝ ≫ map p ≫ π (fun b => g b) j✝¹ = ι (fun b => f b) j✝ ≫ map' p ≫ π (fun b => g b) j✝¹
[PROOFSTEP]
simp only [Discrete.natTrans_app, Limits.IsColimit.ι_map_assoc, Limits.IsLimit.map_π, Category.assoc, ←
  Bicone.toCone_π_app_mk, ← biproduct.bicone_π, ← Bicone.toCocone_ι_app_mk, ← biproduct.bicone_ι]
[GOAL]
case w.w
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f g : J → C
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
p : (b : J) → f b ⟶ g b
j✝¹ j✝ : J
⊢ NatTrans.app (Bicone.toCocone (bicone fun b => f b)).ι { as := j✝ } ≫
      NatTrans.app (Bicone.toCone (bicone fun b => f b)).π { as := j✝¹ } ≫ p j✝¹ =
    p j✝ ≫
      NatTrans.app (Bicone.toCocone (bicone fun b => g b)).ι { as := j✝ } ≫
        NatTrans.app (Bicone.toCone (bicone fun b => g b)).π { as := j✝¹ }
[PROOFSTEP]
dsimp
[GOAL]
case w.w
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f g : J → C
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
p : (b : J) → f b ⟶ g b
j✝¹ j✝ : J
⊢ ι (fun b => f b) j✝ ≫ π (fun b => f b) j✝¹ ≫ p j✝¹ = p j✝ ≫ ι (fun b => g b) j✝ ≫ π (fun b => g b) j✝¹
[PROOFSTEP]
rw [biproduct.ι_π_assoc, biproduct.ι_π]
[GOAL]
case w.w
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f g : J → C
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
p : (b : J) → f b ⟶ g b
j✝¹ j✝ : J
⊢ (if h : j✝ = j✝¹ then eqToHom (_ : f j✝ = f j✝¹) else 0) ≫ p j✝¹ =
    p j✝ ≫ if h : j✝ = j✝¹ then eqToHom (_ : g j✝ = g j✝¹) else 0
[PROOFSTEP]
split_ifs with h
[GOAL]
case pos
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f g : J → C
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
p : (b : J) → f b ⟶ g b
j✝¹ j✝ : J
h : j✝ = j✝¹
⊢ eqToHom (_ : f j✝ = f j✝¹) ≫ p j✝¹ = p j✝ ≫ eqToHom (_ : g j✝ = g j✝¹)
[PROOFSTEP]
subst h
[GOAL]
case pos
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f g : J → C
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
p : (b : J) → f b ⟶ g b
j✝ : J
⊢ eqToHom (_ : f j✝ = f j✝) ≫ p j✝ = p j✝ ≫ eqToHom (_ : g j✝ = g j✝)
[PROOFSTEP]
rw [eqToHom_refl, Category.id_comp]
[GOAL]
case pos
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f g : J → C
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
p : (b : J) → f b ⟶ g b
j✝ : J
⊢ p j✝ = p j✝ ≫ eqToHom (_ : g j✝ = g j✝)
[PROOFSTEP]
erw [Category.comp_id]
[GOAL]
case neg
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f g : J → C
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
p : (b : J) → f b ⟶ g b
j✝¹ j✝ : J
h : ¬j✝ = j✝¹
⊢ 0 ≫ p j✝¹ = p j✝ ≫ 0
[PROOFSTEP]
simp
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f g : J → C
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
p : (j : J) → f j ⟶ g j
j : J
⊢ ι f j ≫ map p = p j ≫ ι g j
[PROOFSTEP]
rw [biproduct.map_eq_map']
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f g : J → C
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
p : (j : J) → f j ⟶ g j
j : J
⊢ ι f j ≫ map' p = p j ≫ ι g j
[PROOFSTEP]
apply
  Limits.IsColimit.ι_map (biproduct.isColimit f) (biproduct.bicone g).toCocone (Discrete.natTrans fun j => p j.as)
    (Discrete.mk j)
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f g : J → C
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
p : (j : J) → f j ⟶ g j
P : C
k : (j : J) → g j ⟶ P
⊢ map p ≫ desc k = desc fun j => p j ≫ k j
[PROOFSTEP]
ext
[GOAL]
case w
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f g : J → C
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
p : (j : J) → f j ⟶ g j
P : C
k : (j : J) → g j ⟶ P
j✝ : J
⊢ ι (fun b => f b) j✝ ≫ map p ≫ desc k = ι (fun b => f b) j✝ ≫ desc fun j => p j ≫ k j
[PROOFSTEP]
simp
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f g : J → C
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
P : C
k : (j : J) → P ⟶ f j
p : (j : J) → f j ⟶ g j
⊢ lift k ≫ map p = lift fun j => k j ≫ p j
[PROOFSTEP]
ext
[GOAL]
case w
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f g : J → C
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
P : C
k : (j : J) → P ⟶ f j
p : (j : J) → f j ⟶ g j
j✝ : J
⊢ (lift k ≫ map p) ≫ π (fun b => g b) j✝ = (lift fun j => k j ≫ p j) ≫ π (fun b => g b) j✝
[PROOFSTEP]
simp
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type ?u.108203
f : J → C
g : K → C
e : J ≃ K
w : (j : J) → g (↑e j) ≅ f j
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
k : K
⊢ g k = g (↑e (↑e.symm k))
[PROOFSTEP]
simp
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type ?u.124125
f : J → C
g : K → C
e : J ≃ K
w : (j : J) → g (↑e j) ≅ f j
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
k : K
⊢ g (↑e (↑e.symm k)) = g k
[PROOFSTEP]
simp
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type u_1
f : J → C
g : K → C
e : J ≃ K
w : (j : J) → g (↑e j) ≅ f j
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
⊢ (whisker_equiv e w).hom = lift fun k => π f (↑e.symm k) ≫ (w (↑e.symm k)).inv ≫ eqToHom (_ : g (↑e (↑e.symm k)) = g k)
[PROOFSTEP]
simp only [whisker_equiv_hom]
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type u_1
f : J → C
g : K → C
e : J ≃ K
w : (j : J) → g (↑e j) ≅ f j
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
⊢ (desc fun j => (w j).inv ≫ ι g (↑e j)) =
    lift fun k => π f (↑e.symm k) ≫ (w (↑e.symm k)).inv ≫ eqToHom (_ : g (↑e (↑e.symm k)) = g k)
[PROOFSTEP]
ext k j
[GOAL]
case w.w
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type u_1
f : J → C
g : K → C
e : J ≃ K
w : (j : J) → g (↑e j) ≅ f j
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
k : K
j : J
⊢ ι (fun j => f j) j ≫ (desc fun j => (w j).inv ≫ ι g (↑e j)) ≫ π g k =
    ι (fun j => f j) j ≫
      (lift fun k => π f (↑e.symm k) ≫ (w (↑e.symm k)).inv ≫ eqToHom (_ : g (↑e (↑e.symm k)) = g k)) ≫ π g k
[PROOFSTEP]
by_cases h : k = e j
[GOAL]
case pos
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type u_1
f : J → C
g : K → C
e : J ≃ K
w : (j : J) → g (↑e j) ≅ f j
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
k : K
j : J
h : k = ↑e j
⊢ ι (fun j => f j) j ≫ (desc fun j => (w j).inv ≫ ι g (↑e j)) ≫ π g k =
    ι (fun j => f j) j ≫
      (lift fun k => π f (↑e.symm k) ≫ (w (↑e.symm k)).inv ≫ eqToHom (_ : g (↑e (↑e.symm k)) = g k)) ≫ π g k
[PROOFSTEP]
subst h
[GOAL]
case pos
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type u_1
f : J → C
g : K → C
e : J ≃ K
w : (j : J) → g (↑e j) ≅ f j
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
j : J
⊢ ι (fun j => f j) j ≫ (desc fun j => (w j).inv ≫ ι g (↑e j)) ≫ π g (↑e j) =
    ι (fun j => f j) j ≫
      (lift fun k => π f (↑e.symm k) ≫ (w (↑e.symm k)).inv ≫ eqToHom (_ : g (↑e (↑e.symm k)) = g k)) ≫ π g (↑e j)
[PROOFSTEP]
simp
[GOAL]
case neg
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type u_1
f : J → C
g : K → C
e : J ≃ K
w : (j : J) → g (↑e j) ≅ f j
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
k : K
j : J
h : ¬k = ↑e j
⊢ ι (fun j => f j) j ≫ (desc fun j => (w j).inv ≫ ι g (↑e j)) ≫ π g k =
    ι (fun j => f j) j ≫
      (lift fun k => π f (↑e.symm k) ≫ (w (↑e.symm k)).inv ≫ eqToHom (_ : g (↑e (↑e.symm k)) = g k)) ≫ π g k
[PROOFSTEP]
simp only [ι_desc_assoc, Category.assoc, ne_eq, lift_π]
[GOAL]
case neg
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type u_1
f : J → C
g : K → C
e : J ≃ K
w : (j : J) → g (↑e j) ≅ f j
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
k : K
j : J
h : ¬k = ↑e j
⊢ (w j).inv ≫ ι g (↑e j) ≫ π g k =
    ι (fun j => f j) j ≫ π f (↑e.symm k) ≫ (w (↑e.symm k)).inv ≫ eqToHom (_ : g (↑e (↑e.symm k)) = g k)
[PROOFSTEP]
rw [biproduct.ι_π_ne, biproduct.ι_π_ne_assoc]
[GOAL]
case neg
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type u_1
f : J → C
g : K → C
e : J ≃ K
w : (j : J) → g (↑e j) ≅ f j
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
k : K
j : J
h : ¬k = ↑e j
⊢ (w j).inv ≫ 0 = 0 ≫ (w (↑e.symm k)).inv ≫ eqToHom (_ : g (↑e (↑e.symm k)) = g k)
[PROOFSTEP]
simp
[GOAL]
case neg.h
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type u_1
f : J → C
g : K → C
e : J ≃ K
w : (j : J) → g (↑e j) ≅ f j
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
k : K
j : J
h : ¬k = ↑e j
⊢ j ≠ ↑e.symm k
[PROOFSTEP]
rintro rfl
[GOAL]
case neg.h
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type u_1
f : J → C
g : K → C
e : J ≃ K
w : (j : J) → g (↑e j) ≅ f j
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
k : K
h : ¬k = ↑e (↑e.symm k)
⊢ False
[PROOFSTEP]
simp at h
[GOAL]
case neg.h
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type u_1
f : J → C
g : K → C
e : J ≃ K
w : (j : J) → g (↑e j) ≅ f j
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
k : K
j : J
h : ¬k = ↑e j
⊢ ↑e j ≠ k
[PROOFSTEP]
exact Ne.symm h
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type u_1
f : J → C
g : K → C
e : J ≃ K
w : (j : J) → g (↑e j) ≅ f j
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
⊢ (whisker_equiv e w).inv = lift fun j => π g (↑e j) ≫ (w j).hom
[PROOFSTEP]
simp only [whisker_equiv_inv]
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type u_1
f : J → C
g : K → C
e : J ≃ K
w : (j : J) → g (↑e j) ≅ f j
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
⊢ (desc fun k => eqToHom (_ : g k = g (↑e (↑e.symm k))) ≫ (w (↑e.symm k)).hom ≫ ι (fun j => f j) (↑e.symm k)) =
    lift fun j => π g (↑e j) ≫ (w j).hom
[PROOFSTEP]
ext j k
[GOAL]
case w.w
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type u_1
f : J → C
g : K → C
e : J ≃ K
w : (j : J) → g (↑e j) ≅ f j
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
j : J
k : K
⊢ ι g k ≫
      (desc fun k => eqToHom (_ : g k = g (↑e (↑e.symm k))) ≫ (w (↑e.symm k)).hom ≫ ι (fun j => f j) (↑e.symm k)) ≫
        π (fun j => f j) j =
    ι g k ≫ (lift fun j => π g (↑e j) ≫ (w j).hom) ≫ π (fun j => f j) j
[PROOFSTEP]
by_cases h : k = e j
[GOAL]
case pos
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type u_1
f : J → C
g : K → C
e : J ≃ K
w : (j : J) → g (↑e j) ≅ f j
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
j : J
k : K
h : k = ↑e j
⊢ ι g k ≫
      (desc fun k => eqToHom (_ : g k = g (↑e (↑e.symm k))) ≫ (w (↑e.symm k)).hom ≫ ι (fun j => f j) (↑e.symm k)) ≫
        π (fun j => f j) j =
    ι g k ≫ (lift fun j => π g (↑e j) ≫ (w j).hom) ≫ π (fun j => f j) j
[PROOFSTEP]
subst h
[GOAL]
case pos
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type u_1
f : J → C
g : K → C
e : J ≃ K
w : (j : J) → g (↑e j) ≅ f j
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
j : J
⊢ ι g (↑e j) ≫
      (desc fun k => eqToHom (_ : g k = g (↑e (↑e.symm k))) ≫ (w (↑e.symm k)).hom ≫ ι (fun j => f j) (↑e.symm k)) ≫
        π (fun j => f j) j =
    ι g (↑e j) ≫ (lift fun j => π g (↑e j) ≫ (w j).hom) ≫ π (fun j => f j) j
[PROOFSTEP]
simp only [ι_desc_assoc, ← eqToHom_iso_hom_naturality_assoc w (e.symm_apply_apply j).symm, Equiv.symm_apply_apply,
  eqToHom_comp_ι, Category.assoc, bicone_ι_π_self, Category.comp_id, lift_π, bicone_ι_π_self_assoc]
[GOAL]
case neg
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type u_1
f : J → C
g : K → C
e : J ≃ K
w : (j : J) → g (↑e j) ≅ f j
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
j : J
k : K
h : ¬k = ↑e j
⊢ ι g k ≫
      (desc fun k => eqToHom (_ : g k = g (↑e (↑e.symm k))) ≫ (w (↑e.symm k)).hom ≫ ι (fun j => f j) (↑e.symm k)) ≫
        π (fun j => f j) j =
    ι g k ≫ (lift fun j => π g (↑e j) ≫ (w j).hom) ≫ π (fun j => f j) j
[PROOFSTEP]
simp only [ι_desc_assoc, Category.assoc, ne_eq, lift_π]
[GOAL]
case neg
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type u_1
f : J → C
g : K → C
e : J ≃ K
w : (j : J) → g (↑e j) ≅ f j
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
j : J
k : K
h : ¬k = ↑e j
⊢ eqToHom (_ : g k = g (↑e (↑e.symm k))) ≫ (w (↑e.symm k)).hom ≫ ι (fun j => f j) (↑e.symm k) ≫ π (fun j => f j) j =
    ι g k ≫ π g (↑e j) ≫ (w j).hom
[PROOFSTEP]
rw [biproduct.ι_π_ne, biproduct.ι_π_ne_assoc]
[GOAL]
case neg
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type u_1
f : J → C
g : K → C
e : J ≃ K
w : (j : J) → g (↑e j) ≅ f j
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
j : J
k : K
h : ¬k = ↑e j
⊢ eqToHom (_ : g k = g (↑e (↑e.symm k))) ≫ (w (↑e.symm k)).hom ≫ 0 = 0 ≫ (w j).hom
[PROOFSTEP]
simp
[GOAL]
case neg.h
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type u_1
f : J → C
g : K → C
e : J ≃ K
w : (j : J) → g (↑e j) ≅ f j
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
j : J
k : K
h : ¬k = ↑e j
⊢ k ≠ ↑e j
[PROOFSTEP]
exact h
[GOAL]
case neg.h
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type u_1
f : J → C
g : K → C
e : J ≃ K
w : (j : J) → g (↑e j) ≅ f j
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
j : J
k : K
h : ¬k = ↑e j
⊢ ↑e.symm k ≠ j
[PROOFSTEP]
rintro rfl
[GOAL]
case neg.h
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type u_1
f : J → C
g : K → C
e : J ≃ K
w : (j : J) → g (↑e j) ≅ f j
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
k : K
h : ¬k = ↑e (↑e.symm k)
⊢ False
[PROOFSTEP]
simp at h
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
ι : Type ?u.135486
f : ι → Type u_1
g : (i : ι) → f i → C
inst✝¹ : ∀ (i : ι), HasBiproduct (g i)
inst✝ : HasBiproduct fun i => ⨁ g i
x✝¹ x✝ : (i : ι) × f i
j : ι
x : f j
j' : ι
y : f j'
⊢ (fun X => biproduct.ι (g X.fst) X.snd ≫ biproduct.ι (fun i => ⨁ g i) X.fst) { fst := j, snd := x } ≫
      (fun X => biproduct.π (fun i => ⨁ g i) X.fst ≫ biproduct.π (g X.fst) X.snd) { fst := j', snd := y } =
    if h : { fst := j, snd := x } = { fst := j', snd := y } then
      eqToHom
        (_ :
          g { fst := j, snd := x }.fst { fst := j, snd := x }.snd =
            g { fst := j', snd := y }.fst { fst := j', snd := y }.snd)
    else 0
[PROOFSTEP]
split_ifs with h
[GOAL]
case pos
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
ι : Type ?u.135486
f : ι → Type u_1
g : (i : ι) → f i → C
inst✝¹ : ∀ (i : ι), HasBiproduct (g i)
inst✝ : HasBiproduct fun i => ⨁ g i
x✝¹ x✝ : (i : ι) × f i
j : ι
x : f j
j' : ι
y : f j'
h : { fst := j, snd := x } = { fst := j', snd := y }
⊢ (fun X => biproduct.ι (g X.fst) X.snd ≫ biproduct.ι (fun i => ⨁ g i) X.fst) { fst := j, snd := x } ≫
      (fun X => biproduct.π (fun i => ⨁ g i) X.fst ≫ biproduct.π (g X.fst) X.snd) { fst := j', snd := y } =
    eqToHom
      (_ :
        g { fst := j, snd := x }.fst { fst := j, snd := x }.snd =
          g { fst := j', snd := y }.fst { fst := j', snd := y }.snd)
[PROOFSTEP]
obtain ⟨rfl, rfl⟩ := h
[GOAL]
case pos.refl
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
ι : Type ?u.135486
f : ι → Type u_1
g : (i : ι) → f i → C
inst✝¹ : ∀ (i : ι), HasBiproduct (g i)
inst✝ : HasBiproduct fun i => ⨁ g i
x✝¹ x✝ : (i : ι) × f i
j : ι
x : f j
⊢ (fun X => biproduct.ι (g X.fst) X.snd ≫ biproduct.ι (fun i => ⨁ g i) X.fst) { fst := j, snd := x } ≫
      (fun X => biproduct.π (fun i => ⨁ g i) X.fst ≫ biproduct.π (g X.fst) X.snd) { fst := j, snd := x } =
    eqToHom
      (_ :
        g { fst := j, snd := x }.fst { fst := j, snd := x }.snd =
          g { fst := j, snd := x }.fst { fst := j, snd := x }.snd)
[PROOFSTEP]
simp
[GOAL]
case neg
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
ι : Type ?u.135486
f : ι → Type u_1
g : (i : ι) → f i → C
inst✝¹ : ∀ (i : ι), HasBiproduct (g i)
inst✝ : HasBiproduct fun i => ⨁ g i
x✝¹ x✝ : (i : ι) × f i
j : ι
x : f j
j' : ι
y : f j'
h : ¬{ fst := j, snd := x } = { fst := j', snd := y }
⊢ (fun X => biproduct.ι (g X.fst) X.snd ≫ biproduct.ι (fun i => ⨁ g i) X.fst) { fst := j, snd := x } ≫
      (fun X => biproduct.π (fun i => ⨁ g i) X.fst ≫ biproduct.π (g X.fst) X.snd) { fst := j', snd := y } =
    0
[PROOFSTEP]
simp at h
[GOAL]
case neg
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
ι : Type ?u.135486
f : ι → Type u_1
g : (i : ι) → f i → C
inst✝¹ : ∀ (i : ι), HasBiproduct (g i)
inst✝ : HasBiproduct fun i => ⨁ g i
x✝¹ x✝ : (i : ι) × f i
j : ι
x : f j
j' : ι
y : f j'
h : j = j' → ¬HEq x y
⊢ (fun X => biproduct.ι (g X.fst) X.snd ≫ biproduct.ι (fun i => ⨁ g i) X.fst) { fst := j, snd := x } ≫
      (fun X => biproduct.π (fun i => ⨁ g i) X.fst ≫ biproduct.π (g X.fst) X.snd) { fst := j', snd := y } =
    0
[PROOFSTEP]
by_cases w : j = j'
[GOAL]
case pos
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
ι : Type ?u.135486
f : ι → Type u_1
g : (i : ι) → f i → C
inst✝¹ : ∀ (i : ι), HasBiproduct (g i)
inst✝ : HasBiproduct fun i => ⨁ g i
x✝¹ x✝ : (i : ι) × f i
j : ι
x : f j
j' : ι
y : f j'
h : j = j' → ¬HEq x y
w : j = j'
⊢ (fun X => biproduct.ι (g X.fst) X.snd ≫ biproduct.ι (fun i => ⨁ g i) X.fst) { fst := j, snd := x } ≫
      (fun X => biproduct.π (fun i => ⨁ g i) X.fst ≫ biproduct.π (g X.fst) X.snd) { fst := j', snd := y } =
    0
[PROOFSTEP]
cases w
[GOAL]
case pos.refl
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
ι : Type ?u.135486
f : ι → Type u_1
g : (i : ι) → f i → C
inst✝¹ : ∀ (i : ι), HasBiproduct (g i)
inst✝ : HasBiproduct fun i => ⨁ g i
x✝¹ x✝ : (i : ι) × f i
j : ι
x y : f j
h : j = j → ¬HEq x y
⊢ (fun X => biproduct.ι (g X.fst) X.snd ≫ biproduct.ι (fun i => ⨁ g i) X.fst) { fst := j, snd := x } ≫
      (fun X => biproduct.π (fun i => ⨁ g i) X.fst ≫ biproduct.π (g X.fst) X.snd) { fst := j, snd := y } =
    0
[PROOFSTEP]
simp at h
[GOAL]
case pos.refl
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
ι : Type ?u.135486
f : ι → Type u_1
g : (i : ι) → f i → C
inst✝¹ : ∀ (i : ι), HasBiproduct (g i)
inst✝ : HasBiproduct fun i => ⨁ g i
x✝¹ x✝ : (i : ι) × f i
j : ι
x y : f j
h : ¬x = y
⊢ (fun X => biproduct.ι (g X.fst) X.snd ≫ biproduct.ι (fun i => ⨁ g i) X.fst) { fst := j, snd := x } ≫
      (fun X => biproduct.π (fun i => ⨁ g i) X.fst ≫ biproduct.π (g X.fst) X.snd) { fst := j, snd := y } =
    0
[PROOFSTEP]
simp [biproduct.ι_π_ne _ h]
[GOAL]
case neg
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
ι : Type ?u.135486
f : ι → Type u_1
g : (i : ι) → f i → C
inst✝¹ : ∀ (i : ι), HasBiproduct (g i)
inst✝ : HasBiproduct fun i => ⨁ g i
x✝¹ x✝ : (i : ι) × f i
j : ι
x : f j
j' : ι
y : f j'
h : j = j' → ¬HEq x y
w : ¬j = j'
⊢ (fun X => biproduct.ι (g X.fst) X.snd ≫ biproduct.ι (fun i => ⨁ g i) X.fst) { fst := j, snd := x } ≫
      (fun X => biproduct.π (fun i => ⨁ g i) X.fst ≫ biproduct.π (g X.fst) X.snd) { fst := j', snd := y } =
    0
[PROOFSTEP]
simp [biproduct.ι_π_ne_assoc _ w]
[GOAL]
J : Type w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
j : J
⊢ fromSubtype f p ≫ π f j = if h : p j then π (Subtype.restrict p f) { val := j, property := h } else 0
[PROOFSTEP]
ext i
[GOAL]
case w
J : Type w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
j : J
i : Subtype p
⊢ ι (Subtype.restrict p f) i ≫ fromSubtype f p ≫ π f j =
    ι (Subtype.restrict p f) i ≫ if h : p j then π (Subtype.restrict p f) { val := j, property := h } else 0
[PROOFSTEP]
dsimp
[GOAL]
case w
J : Type w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
j : J
i : Subtype p
⊢ ι (Subtype.restrict p f) i ≫ fromSubtype f p ≫ π f j =
    ι (Subtype.restrict p f) i ≫ if h : p j then π (Subtype.restrict p f) { val := j, property := h } else 0
[PROOFSTEP]
rw [biproduct.fromSubtype, biproduct.ι_desc_assoc, biproduct.ι_π]
[GOAL]
case w
J : Type w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
j : J
i : Subtype p
⊢ (if h : ↑i = j then eqToHom (_ : f ↑i = f j) else 0) =
    ι (Subtype.restrict p f) i ≫ if h : p j then π (Subtype.restrict p f) { val := j, property := h } else 0
[PROOFSTEP]
by_cases h : p j
[GOAL]
case pos
J : Type w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
j : J
i : Subtype p
h : p j
⊢ (if h : ↑i = j then eqToHom (_ : f ↑i = f j) else 0) =
    ι (Subtype.restrict p f) i ≫ if h : p j then π (Subtype.restrict p f) { val := j, property := h } else 0
[PROOFSTEP]
rw [dif_pos h, biproduct.ι_π]
[GOAL]
case pos
J : Type w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
j : J
i : Subtype p
h : p j
⊢ (if h : ↑i = j then eqToHom (_ : f ↑i = f j) else 0) =
    if h_1 : i = { val := j, property := h } then
      eqToHom (_ : Subtype.restrict p f i = Subtype.restrict p f { val := j, property := h })
    else 0
[PROOFSTEP]
split_ifs with h₁ h₂ h₂
[GOAL]
case pos
J : Type w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
j : J
i : Subtype p
h : p j
h₁ : ↑i = j
h₂ : i = { val := j, property := h }
⊢ eqToHom (_ : f ↑i = f j) = eqToHom (_ : Subtype.restrict p f i = Subtype.restrict p f { val := j, property := h })
case neg
J : Type w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
j : J
i : Subtype p
h : p j
h₁ : ↑i = j
h₂ : ¬i = { val := j, property := h }
⊢ eqToHom (_ : f ↑i = f j) = 0
case pos
J : Type w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
j : J
i : Subtype p
h : p j
h₁ : ¬↑i = j
h₂ : i = { val := j, property := h }
⊢ 0 = eqToHom (_ : Subtype.restrict p f i = Subtype.restrict p f { val := j, property := h })
case neg
J : Type w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
j : J
i : Subtype p
h : p j
h₁ : ¬↑i = j
h₂ : ¬i = { val := j, property := h }
⊢ 0 = 0
[PROOFSTEP]
exacts [rfl, False.elim (h₂ (Subtype.ext h₁)), False.elim (h₁ (congr_arg Subtype.val h₂)), rfl]
[GOAL]
case neg
J : Type w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
j : J
i : Subtype p
h : ¬p j
⊢ (if h : ↑i = j then eqToHom (_ : f ↑i = f j) else 0) =
    ι (Subtype.restrict p f) i ≫ if h : p j then π (Subtype.restrict p f) { val := j, property := h } else 0
[PROOFSTEP]
rw [dif_neg h, dif_neg (show (i : J) ≠ j from fun h₂ => h (h₂ ▸ i.2)), comp_zero]
[GOAL]
J : Type w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
⊢ ∀ (j : J),
    fromSubtype f p ≫ π f j =
      (lift fun j => if h : p j then π (Subtype.restrict p f) { val := j, property := h } else 0) ≫ π f j
[PROOFSTEP]
simp
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
inst✝¹ : HasBiproduct f
p : J → Prop
inst✝ : HasBiproduct (Subtype.restrict p f)
j : Subtype p
⊢ fromSubtype f p ≫ π f ↑j = π (Subtype.restrict p f) j
[PROOFSTEP]
ext
[GOAL]
case w
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
inst✝¹ : HasBiproduct f
p : J → Prop
inst✝ : HasBiproduct (Subtype.restrict p f)
j j✝ : Subtype p
⊢ ι (Subtype.restrict p f) j✝ ≫ fromSubtype f p ≫ π f ↑j = ι (Subtype.restrict p f) j✝ ≫ π (Subtype.restrict p f) j
[PROOFSTEP]
rw [biproduct.fromSubtype, biproduct.ι_desc_assoc, biproduct.ι_π, biproduct.ι_π]
[GOAL]
case w
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
inst✝¹ : HasBiproduct f
p : J → Prop
inst✝ : HasBiproduct (Subtype.restrict p f)
j j✝ : Subtype p
⊢ (if h : ↑j✝ = ↑j then eqToHom (_ : f ↑j✝ = f ↑j) else 0) =
    if h : j✝ = j then eqToHom (_ : Subtype.restrict p f j✝ = Subtype.restrict p f j) else 0
[PROOFSTEP]
split_ifs with h₁ h₂ h₂
[GOAL]
case pos
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
inst✝¹ : HasBiproduct f
p : J → Prop
inst✝ : HasBiproduct (Subtype.restrict p f)
j j✝ : Subtype p
h₁ : ↑j✝ = ↑j
h₂ : j✝ = j
⊢ eqToHom (_ : f ↑j✝ = f ↑j) = eqToHom (_ : Subtype.restrict p f j✝ = Subtype.restrict p f j)
case neg
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
inst✝¹ : HasBiproduct f
p : J → Prop
inst✝ : HasBiproduct (Subtype.restrict p f)
j j✝ : Subtype p
h₁ : ↑j✝ = ↑j
h₂ : ¬j✝ = j
⊢ eqToHom (_ : f ↑j✝ = f ↑j) = 0
case pos
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
inst✝¹ : HasBiproduct f
p : J → Prop
inst✝ : HasBiproduct (Subtype.restrict p f)
j j✝ : Subtype p
h₁ : ¬↑j✝ = ↑j
h₂ : j✝ = j
⊢ 0 = eqToHom (_ : Subtype.restrict p f j✝ = Subtype.restrict p f j)
case neg
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
inst✝¹ : HasBiproduct f
p : J → Prop
inst✝ : HasBiproduct (Subtype.restrict p f)
j j✝ : Subtype p
h₁ : ¬↑j✝ = ↑j
h₂ : ¬j✝ = j
⊢ 0 = 0
[PROOFSTEP]
exacts [rfl, False.elim (h₂ (Subtype.ext h₁)), False.elim (h₁ (congr_arg Subtype.val h₂)), rfl]
[GOAL]
J : Type w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
j : J
⊢ ι f j ≫ toSubtype f p = if h : p j then ι (Subtype.restrict p f) { val := j, property := h } else 0
[PROOFSTEP]
ext i
[GOAL]
case w
J : Type w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
j : J
i : Subtype p
⊢ (ι f j ≫ toSubtype f p) ≫ π (Subtype.restrict p f) i =
    (if h : p j then ι (Subtype.restrict p f) { val := j, property := h } else 0) ≫ π (Subtype.restrict p f) i
[PROOFSTEP]
rw [biproduct.toSubtype, Category.assoc, biproduct.lift_π, biproduct.ι_π]
[GOAL]
case w
J : Type w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
j : J
i : Subtype p
⊢ (if h : j = ↑i then eqToHom (_ : f j = f ↑i) else 0) =
    (if h : p j then ι (Subtype.restrict p f) { val := j, property := h } else 0) ≫ π (Subtype.restrict p f) i
[PROOFSTEP]
by_cases h : p j
[GOAL]
case pos
J : Type w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
j : J
i : Subtype p
h : p j
⊢ (if h : j = ↑i then eqToHom (_ : f j = f ↑i) else 0) =
    (if h : p j then ι (Subtype.restrict p f) { val := j, property := h } else 0) ≫ π (Subtype.restrict p f) i
[PROOFSTEP]
rw [dif_pos h, biproduct.ι_π]
[GOAL]
case pos
J : Type w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
j : J
i : Subtype p
h : p j
⊢ (if h : j = ↑i then eqToHom (_ : f j = f ↑i) else 0) =
    if h_1 : { val := j, property := h } = i then
      eqToHom (_ : Subtype.restrict p f { val := j, property := h } = Subtype.restrict p f i)
    else 0
[PROOFSTEP]
split_ifs with h₁ h₂ h₂
[GOAL]
case pos
J : Type w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
j : J
i : Subtype p
h : p j
h₁ : j = ↑i
h₂ : { val := j, property := h } = i
⊢ eqToHom (_ : f j = f ↑i) = eqToHom (_ : Subtype.restrict p f { val := j, property := h } = Subtype.restrict p f i)
case neg
J : Type w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
j : J
i : Subtype p
h : p j
h₁ : j = ↑i
h₂ : ¬{ val := j, property := h } = i
⊢ eqToHom (_ : f j = f ↑i) = 0
case pos
J : Type w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
j : J
i : Subtype p
h : p j
h₁ : ¬j = ↑i
h₂ : { val := j, property := h } = i
⊢ 0 = eqToHom (_ : Subtype.restrict p f { val := j, property := h } = Subtype.restrict p f i)
case neg
J : Type w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
j : J
i : Subtype p
h : p j
h₁ : ¬j = ↑i
h₂ : ¬{ val := j, property := h } = i
⊢ 0 = 0
[PROOFSTEP]
exacts [rfl, False.elim (h₂ (Subtype.ext h₁)), False.elim (h₁ (congr_arg Subtype.val h₂)), rfl]
[GOAL]
case neg
J : Type w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
j : J
i : Subtype p
h : ¬p j
⊢ (if h : j = ↑i then eqToHom (_ : f j = f ↑i) else 0) =
    (if h : p j then ι (Subtype.restrict p f) { val := j, property := h } else 0) ≫ π (Subtype.restrict p f) i
[PROOFSTEP]
rw [dif_neg h, dif_neg (show j ≠ i from fun h₂ => h (h₂.symm ▸ i.2)), zero_comp]
[GOAL]
J : Type w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
⊢ ∀ (j : J),
    ι f j ≫ toSubtype f p =
      ι f j ≫ desc fun j => if h : p j then ι (Subtype.restrict p f) { val := j, property := h } else 0
[PROOFSTEP]
simp
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
inst✝¹ : HasBiproduct f
p : J → Prop
inst✝ : HasBiproduct (Subtype.restrict p f)
j : Subtype p
⊢ ι f ↑j ≫ toSubtype f p = ι (Subtype.restrict p f) j
[PROOFSTEP]
ext
[GOAL]
case w
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
inst✝¹ : HasBiproduct f
p : J → Prop
inst✝ : HasBiproduct (Subtype.restrict p f)
j j✝ : Subtype p
⊢ (ι f ↑j ≫ toSubtype f p) ≫ π (Subtype.restrict p f) j✝ = ι (Subtype.restrict p f) j ≫ π (Subtype.restrict p f) j✝
[PROOFSTEP]
rw [biproduct.toSubtype, Category.assoc, biproduct.lift_π, biproduct.ι_π, biproduct.ι_π]
[GOAL]
case w
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
inst✝¹ : HasBiproduct f
p : J → Prop
inst✝ : HasBiproduct (Subtype.restrict p f)
j j✝ : Subtype p
⊢ (if h : ↑j = ↑j✝ then eqToHom (_ : f ↑j = f ↑j✝) else 0) =
    if h : j = j✝ then eqToHom (_ : Subtype.restrict p f j = Subtype.restrict p f j✝) else 0
[PROOFSTEP]
split_ifs with h₁ h₂ h₂
[GOAL]
case pos
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
inst✝¹ : HasBiproduct f
p : J → Prop
inst✝ : HasBiproduct (Subtype.restrict p f)
j j✝ : Subtype p
h₁ : ↑j = ↑j✝
h₂ : j = j✝
⊢ eqToHom (_ : f ↑j = f ↑j✝) = eqToHom (_ : Subtype.restrict p f j = Subtype.restrict p f j✝)
case neg
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
inst✝¹ : HasBiproduct f
p : J → Prop
inst✝ : HasBiproduct (Subtype.restrict p f)
j j✝ : Subtype p
h₁ : ↑j = ↑j✝
h₂ : ¬j = j✝
⊢ eqToHom (_ : f ↑j = f ↑j✝) = 0
case pos
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
inst✝¹ : HasBiproduct f
p : J → Prop
inst✝ : HasBiproduct (Subtype.restrict p f)
j j✝ : Subtype p
h₁ : ¬↑j = ↑j✝
h₂ : j = j✝
⊢ 0 = eqToHom (_ : Subtype.restrict p f j = Subtype.restrict p f j✝)
case neg
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
inst✝¹ : HasBiproduct f
p : J → Prop
inst✝ : HasBiproduct (Subtype.restrict p f)
j j✝ : Subtype p
h₁ : ¬↑j = ↑j✝
h₂ : ¬j = j✝
⊢ 0 = 0
[PROOFSTEP]
exacts [rfl, False.elim (h₂ (Subtype.ext h₁)), False.elim (h₁ (congr_arg Subtype.val h₂)), rfl]
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
inst✝¹ : HasBiproduct f
p : J → Prop
inst✝ : HasBiproduct (Subtype.restrict p f)
⊢ fromSubtype f p ≫ toSubtype f p = 𝟙 (⨁ Subtype.restrict p f)
[PROOFSTEP]
refine' biproduct.hom_ext _ _ fun j => _
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
inst✝¹ : HasBiproduct f
p : J → Prop
inst✝ : HasBiproduct (Subtype.restrict p f)
j : Subtype p
⊢ (fromSubtype f p ≫ toSubtype f p) ≫ π (Subtype.restrict p f) j =
    𝟙 (⨁ Subtype.restrict p f) ≫ π (Subtype.restrict p f) j
[PROOFSTEP]
rw [Category.assoc, biproduct.toSubtype_π, biproduct.fromSubtype_π_subtype, Category.id_comp]
[GOAL]
J : Type w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
⊢ toSubtype f p ≫ fromSubtype f p = map fun j => if p j then 𝟙 (f j) else 0
[PROOFSTEP]
ext1 i
[GOAL]
case w
J : Type w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
i : J
⊢ (toSubtype f p ≫ fromSubtype f p) ≫ π f i = (map fun j => if p j then 𝟙 (f j) else 0) ≫ π f i
[PROOFSTEP]
by_cases h : p i
[GOAL]
case pos
J : Type w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
i : J
h : p i
⊢ (toSubtype f p ≫ fromSubtype f p) ≫ π f i = (map fun j => if p j then 𝟙 (f j) else 0) ≫ π f i
[PROOFSTEP]
simp [h]
[GOAL]
case neg
J : Type w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
i : J
h : ¬p i
⊢ (toSubtype f p ≫ fromSubtype f p) ≫ π f i = (map fun j => if p j then 𝟙 (f j) else 0) ≫ π f i
[PROOFSTEP]
simp [h]
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
i : J
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct (Subtype.restrict (fun j => j ≠ i) f)
⊢ (fromSubtype f fun j => j ≠ i) ≫ π f i = 0
[PROOFSTEP]
simp
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
i : J
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct (Subtype.restrict (fun j => j ≠ i) f)
s : Fork (π f i) 0
⊢ (Fork.ι s ≫ toSubtype f fun j => j ≠ i) ≫
      Fork.ι (KernelFork.ofι (fromSubtype f fun j => j ≠ i) (_ : (fromSubtype f fun j => ¬j = i) ≫ π f i = 0)) =
    Fork.ι s
[PROOFSTEP]
apply biproduct.hom_ext
[GOAL]
case w
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
i : J
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct (Subtype.restrict (fun j => j ≠ i) f)
s : Fork (π f i) 0
⊢ ∀ (j : J),
    ((Fork.ι s ≫ toSubtype f fun j => j ≠ i) ≫
          Fork.ι (KernelFork.ofι (fromSubtype f fun j => j ≠ i) (_ : (fromSubtype f fun j => ¬j = i) ≫ π f i = 0))) ≫
        π f j =
      Fork.ι s ≫ π f j
[PROOFSTEP]
intro j
[GOAL]
case w
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
i : J
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct (Subtype.restrict (fun j => j ≠ i) f)
s : Fork (π f i) 0
j : J
⊢ ((Fork.ι s ≫ toSubtype f fun j => j ≠ i) ≫
        Fork.ι (KernelFork.ofι (fromSubtype f fun j => j ≠ i) (_ : (fromSubtype f fun j => ¬j = i) ≫ π f i = 0))) ≫
      π f j =
    Fork.ι s ≫ π f j
[PROOFSTEP]
rw [KernelFork.ι_ofι, Category.assoc, Category.assoc, biproduct.toSubtype_fromSubtype_assoc, biproduct.map_π]
[GOAL]
case w
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
i : J
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct (Subtype.restrict (fun j => j ≠ i) f)
s : Fork (π f i) 0
j : J
⊢ (Fork.ι s ≫ π (fun j => f j) j ≫ if j ≠ i then 𝟙 (f j) else 0) = Fork.ι s ≫ π f j
[PROOFSTEP]
rcases Classical.em (i = j) with (rfl | h)
[GOAL]
case w.inl
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
i : J
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct (Subtype.restrict (fun j => j ≠ i) f)
s : Fork (π f i) 0
⊢ (Fork.ι s ≫ π (fun j => f j) i ≫ if i ≠ i then 𝟙 (f i) else 0) = Fork.ι s ≫ π f i
[PROOFSTEP]
rw [if_neg (Classical.not_not.2 rfl), comp_zero, comp_zero, KernelFork.condition]
[GOAL]
case w.inr
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
i : J
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct (Subtype.restrict (fun j => j ≠ i) f)
s : Fork (π f i) 0
j : J
h : ¬i = j
⊢ (Fork.ι s ≫ π (fun j => f j) j ≫ if j ≠ i then 𝟙 (f j) else 0) = Fork.ι s ≫ π f j
[PROOFSTEP]
rw [if_pos (Ne.symm h), Category.comp_id]
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
i : J
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct (Subtype.restrict (fun j => j ≠ i) f)
s : Fork (π f i) 0
⊢ ∀
    {m :
      ((const WalkingParallelPair).obj s.pt).obj WalkingParallelPair.zero ⟶
        ((const WalkingParallelPair).obj
              (KernelFork.ofι (fromSubtype f fun j => j ≠ i) (_ : (fromSubtype f fun j => ¬j = i) ≫ π f i = 0)).pt).obj
          WalkingParallelPair.zero},
    m ≫ Fork.ι (KernelFork.ofι (fromSubtype f fun j => j ≠ i) (_ : (fromSubtype f fun j => ¬j = i) ≫ π f i = 0)) =
        Fork.ι s →
      m = Fork.ι s ≫ toSubtype f fun j => j ≠ i
[PROOFSTEP]
intro m hm
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
i : J
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct (Subtype.restrict (fun j => j ≠ i) f)
s : Fork (π f i) 0
m :
  ((const WalkingParallelPair).obj s.pt).obj WalkingParallelPair.zero ⟶
    ((const WalkingParallelPair).obj
          (KernelFork.ofι (fromSubtype f fun j => j ≠ i) (_ : (fromSubtype f fun j => ¬j = i) ≫ π f i = 0)).pt).obj
      WalkingParallelPair.zero
hm :
  m ≫ Fork.ι (KernelFork.ofι (fromSubtype f fun j => j ≠ i) (_ : (fromSubtype f fun j => ¬j = i) ≫ π f i = 0)) =
    Fork.ι s
⊢ m = Fork.ι s ≫ toSubtype f fun j => j ≠ i
[PROOFSTEP]
rw [← hm, KernelFork.ι_ofι, Category.assoc, biproduct.fromSubtype_toSubtype]
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
i : J
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct (Subtype.restrict (fun j => j ≠ i) f)
s : Fork (π f i) 0
m :
  ((const WalkingParallelPair).obj s.pt).obj WalkingParallelPair.zero ⟶
    ((const WalkingParallelPair).obj
          (KernelFork.ofι (fromSubtype f fun j => j ≠ i) (_ : (fromSubtype f fun j => ¬j = i) ≫ π f i = 0)).pt).obj
      WalkingParallelPair.zero
hm :
  m ≫ Fork.ι (KernelFork.ofι (fromSubtype f fun j => j ≠ i) (_ : (fromSubtype f fun j => ¬j = i) ≫ π f i = 0)) =
    Fork.ι s
⊢ m = m ≫ 𝟙 (⨁ Subtype.restrict (fun j => j ≠ i) f)
[PROOFSTEP]
exact (Category.comp_id _).symm
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
i : J
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct (Subtype.restrict (fun j => j ≠ i) f)
⊢ (ι f i ≫ toSubtype f fun j => j ≠ i) = 0
[PROOFSTEP]
simp
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
i : J
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct (Subtype.restrict (fun j => j ≠ i) f)
s : Cofork (ι f i) 0
⊢ Cofork.π (CokernelCofork.ofπ (toSubtype f fun j => j ≠ i) (_ : (ι f i ≫ toSubtype f fun j => ¬j = i) = 0)) ≫
      (fromSubtype f fun j => j ≠ i) ≫ Cofork.π s =
    Cofork.π s
[PROOFSTEP]
apply biproduct.hom_ext'
[GOAL]
case w
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
i : J
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct (Subtype.restrict (fun j => j ≠ i) f)
s : Cofork (ι f i) 0
⊢ ∀ (j : J),
    ι f j ≫
        Cofork.π (CokernelCofork.ofπ (toSubtype f fun j => j ≠ i) (_ : (ι f i ≫ toSubtype f fun j => ¬j = i) = 0)) ≫
          (fromSubtype f fun j => j ≠ i) ≫ Cofork.π s =
      ι f j ≫ Cofork.π s
[PROOFSTEP]
intro j
[GOAL]
case w
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
i : J
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct (Subtype.restrict (fun j => j ≠ i) f)
s : Cofork (ι f i) 0
j : J
⊢ ι f j ≫
      Cofork.π (CokernelCofork.ofπ (toSubtype f fun j => j ≠ i) (_ : (ι f i ≫ toSubtype f fun j => ¬j = i) = 0)) ≫
        (fromSubtype f fun j => j ≠ i) ≫ Cofork.π s =
    ι f j ≫ Cofork.π s
[PROOFSTEP]
rw [CokernelCofork.π_ofπ, biproduct.toSubtype_fromSubtype_assoc, biproduct.ι_map_assoc]
[GOAL]
case w
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
i : J
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct (Subtype.restrict (fun j => j ≠ i) f)
s : Cofork (ι f i) 0
j : J
⊢ (if j ≠ i then 𝟙 (f j) else 0) ≫ ι (fun j => f j) j ≫ Cofork.π s = ι f j ≫ Cofork.π s
[PROOFSTEP]
rcases Classical.em (i = j) with (rfl | h)
[GOAL]
case w.inl
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
i : J
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct (Subtype.restrict (fun j => j ≠ i) f)
s : Cofork (ι f i) 0
⊢ (if i ≠ i then 𝟙 (f i) else 0) ≫ ι (fun j => f j) i ≫ Cofork.π s = ι f i ≫ Cofork.π s
[PROOFSTEP]
rw [if_neg (Classical.not_not.2 rfl), zero_comp, CokernelCofork.condition]
[GOAL]
case w.inr
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
i : J
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct (Subtype.restrict (fun j => j ≠ i) f)
s : Cofork (ι f i) 0
j : J
h : ¬i = j
⊢ (if j ≠ i then 𝟙 (f j) else 0) ≫ ι (fun j => f j) j ≫ Cofork.π s = ι f j ≫ Cofork.π s
[PROOFSTEP]
rw [if_pos (Ne.symm h), Category.id_comp]
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
i : J
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct (Subtype.restrict (fun j => j ≠ i) f)
s : Cofork (ι f i) 0
⊢ ∀
    {m :
      ((const WalkingParallelPair).obj
              (CokernelCofork.ofπ (toSubtype f fun j => j ≠ i) (_ : (ι f i ≫ toSubtype f fun j => ¬j = i) = 0)).pt).obj
          WalkingParallelPair.one ⟶
        ((const WalkingParallelPair).obj s.pt).obj WalkingParallelPair.one},
    Cofork.π (CokernelCofork.ofπ (toSubtype f fun j => j ≠ i) (_ : (ι f i ≫ toSubtype f fun j => ¬j = i) = 0)) ≫ m =
        Cofork.π s →
      m = (fromSubtype f fun j => j ≠ i) ≫ Cofork.π s
[PROOFSTEP]
intro m hm
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
i : J
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct (Subtype.restrict (fun j => j ≠ i) f)
s : Cofork (ι f i) 0
m :
  ((const WalkingParallelPair).obj
          (CokernelCofork.ofπ (toSubtype f fun j => j ≠ i) (_ : (ι f i ≫ toSubtype f fun j => ¬j = i) = 0)).pt).obj
      WalkingParallelPair.one ⟶
    ((const WalkingParallelPair).obj s.pt).obj WalkingParallelPair.one
hm :
  Cofork.π (CokernelCofork.ofπ (toSubtype f fun j => j ≠ i) (_ : (ι f i ≫ toSubtype f fun j => ¬j = i) = 0)) ≫ m =
    Cofork.π s
⊢ m = (fromSubtype f fun j => j ≠ i) ≫ Cofork.π s
[PROOFSTEP]
rw [← hm, CokernelCofork.π_ofπ, ← Category.assoc, biproduct.fromSubtype_toSubtype]
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
i : J
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct (Subtype.restrict (fun j => j ≠ i) f)
s : Cofork (ι f i) 0
m :
  ((const WalkingParallelPair).obj
          (CokernelCofork.ofπ (toSubtype f fun j => j ≠ i) (_ : (ι f i ≫ toSubtype f fun j => ¬j = i) = 0)).pt).obj
      WalkingParallelPair.one ⟶
    ((const WalkingParallelPair).obj s.pt).obj WalkingParallelPair.one
hm :
  Cofork.π (CokernelCofork.ofπ (toSubtype f fun j => j ≠ i) (_ : (ι f i ≫ toSubtype f fun j => ¬j = i) = 0)) ≫ m =
    Cofork.π s
⊢ m = 𝟙 (⨁ Subtype.restrict (fun j => j ≠ i) f) ≫ m
[PROOFSTEP]
exact (Category.id_comp _).symm
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type
inst✝¹ : Fintype K
inst✝ : HasFiniteBiproducts C
f : K → C
p : Set K
⊢ biproduct.fromSubtype f pᶜ ≫ biproduct.toSubtype f p = 0
[PROOFSTEP]
ext j k
[GOAL]
case w.w
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type
inst✝¹ : Fintype K
inst✝ : HasFiniteBiproducts C
f : K → C
p : Set K
j : Subtype p
k : Subtype pᶜ
⊢ biproduct.ι (Subtype.restrict pᶜ f) k ≫
      (biproduct.fromSubtype f pᶜ ≫ biproduct.toSubtype f p) ≫ biproduct.π (Subtype.restrict p f) j =
    biproduct.ι (Subtype.restrict pᶜ f) k ≫ 0 ≫ biproduct.π (Subtype.restrict p f) j
[PROOFSTEP]
simp only [Category.assoc, biproduct.ι_fromSubtype_assoc, biproduct.ι_toSubtype_assoc, comp_zero, zero_comp]
[GOAL]
case w.w
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type
inst✝¹ : Fintype K
inst✝ : HasFiniteBiproducts C
f : K → C
p : Set K
j : Subtype p
k : Subtype pᶜ
⊢ (if h : p ↑k then biproduct.ι (Subtype.restrict p f) { val := ↑k, property := h } else 0) ≫
      biproduct.π (Subtype.restrict p f) j =
    0
[PROOFSTEP]
erw [dif_neg k.2]
[GOAL]
case w.w
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type
inst✝¹ : Fintype K
inst✝ : HasFiniteBiproducts C
f : K → C
p : Set K
j : Subtype p
k : Subtype pᶜ
⊢ 0 ≫ biproduct.π (Subtype.restrict p f) j = 0
[PROOFSTEP]
simp only [zero_comp]
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type
inst✝¹ : Fintype K
inst✝ : HasFiniteBiproducts C
f : K → C
p : Set K
⊢ ∀ {W' : C} (g' : W' ⟶ ⨁ f) (eq' : g' ≫ biproduct.toSubtype f p = 0),
    (fun {W} g x => g ≫ biproduct.toSubtype f pᶜ) g' eq' ≫ biproduct.fromSubtype f pᶜ = g'
[PROOFSTEP]
intro W' g' w
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type
inst✝¹ : Fintype K
inst✝ : HasFiniteBiproducts C
f : K → C
p : Set K
W' : C
g' : W' ⟶ ⨁ f
w : g' ≫ biproduct.toSubtype f p = 0
⊢ (fun {W} g x => g ≫ biproduct.toSubtype f pᶜ) g' w ≫ biproduct.fromSubtype f pᶜ = g'
[PROOFSTEP]
ext j
[GOAL]
case w
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type
inst✝¹ : Fintype K
inst✝ : HasFiniteBiproducts C
f : K → C
p : Set K
W' : C
g' : W' ⟶ ⨁ f
w : g' ≫ biproduct.toSubtype f p = 0
j : K
⊢ ((fun {W} g x => g ≫ biproduct.toSubtype f pᶜ) g' w ≫ biproduct.fromSubtype f pᶜ) ≫ biproduct.π f j =
    g' ≫ biproduct.π f j
[PROOFSTEP]
simp only [Category.assoc, biproduct.toSubtype_fromSubtype, Pi.compl_apply, biproduct.map_π]
[GOAL]
case w
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type
inst✝¹ : Fintype K
inst✝ : HasFiniteBiproducts C
f : K → C
p : Set K
W' : C
g' : W' ⟶ ⨁ f
w : g' ≫ biproduct.toSubtype f p = 0
j : K
⊢ (g' ≫ biproduct.π (fun b => f b) j ≫ if (p j)ᶜ then 𝟙 (f j) else 0) = g' ≫ biproduct.π f j
[PROOFSTEP]
split_ifs with h
[GOAL]
case pos
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type
inst✝¹ : Fintype K
inst✝ : HasFiniteBiproducts C
f : K → C
p : Set K
W' : C
g' : W' ⟶ ⨁ f
w : g' ≫ biproduct.toSubtype f p = 0
j : K
h : (p j)ᶜ
⊢ g' ≫ biproduct.π (fun b => f b) j ≫ 𝟙 (f j) = g' ≫ biproduct.π f j
[PROOFSTEP]
simp
[GOAL]
case neg
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type
inst✝¹ : Fintype K
inst✝ : HasFiniteBiproducts C
f : K → C
p : Set K
W' : C
g' : W' ⟶ ⨁ f
w : g' ≫ biproduct.toSubtype f p = 0
j : K
h : ¬(p j)ᶜ
⊢ g' ≫ biproduct.π (fun b => f b) j ≫ 0 = g' ≫ biproduct.π f j
[PROOFSTEP]
replace w := w =≫ biproduct.π _ ⟨j, not_not.mp h⟩
[GOAL]
case neg
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type
inst✝¹ : Fintype K
inst✝ : HasFiniteBiproducts C
f : K → C
p : Set K
W' : C
g' : W' ⟶ ⨁ f
j : K
h : ¬(p j)ᶜ
w :
  (g' ≫ biproduct.toSubtype f p) ≫ biproduct.π (Subtype.restrict p f) { val := j, property := (_ : p j) } =
    0 ≫ biproduct.π (Subtype.restrict p f) { val := j, property := (_ : p j) }
⊢ g' ≫ biproduct.π (fun b => f b) j ≫ 0 = g' ≫ biproduct.π f j
[PROOFSTEP]
simpa using w.symm
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type
inst✝¹ : Fintype K
inst✝ : HasFiniteBiproducts C
f : K → C
p : Set K
⊢ ∀ {W' : C} (g' : W' ⟶ ⨁ f) (eq' : g' ≫ biproduct.toSubtype f p = 0) (m : W' ⟶ ⨁ Subtype.restrict pᶜ f),
    m ≫ biproduct.fromSubtype f pᶜ = g' → m = (fun {W} g x => g ≫ biproduct.toSubtype f pᶜ) g' eq'
[PROOFSTEP]
aesop_cat
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type
inst✝¹ : Fintype K
inst✝ : HasFiniteBiproducts C
f : K → C
p : Set K
⊢ biproduct.fromSubtype f p ≫ biproduct.toSubtype f pᶜ = 0
[PROOFSTEP]
ext j k
[GOAL]
case w.w
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type
inst✝¹ : Fintype K
inst✝ : HasFiniteBiproducts C
f : K → C
p : Set K
j : Subtype pᶜ
k : Subtype p
⊢ biproduct.ι (Subtype.restrict p f) k ≫
      (biproduct.fromSubtype f p ≫ biproduct.toSubtype f pᶜ) ≫ biproduct.π (Subtype.restrict pᶜ f) j =
    biproduct.ι (Subtype.restrict p f) k ≫ 0 ≫ biproduct.π (Subtype.restrict pᶜ f) j
[PROOFSTEP]
simp only [Category.assoc, Pi.compl_apply, biproduct.ι_fromSubtype_assoc, biproduct.ι_toSubtype_assoc, comp_zero,
  zero_comp]
[GOAL]
case w.w
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type
inst✝¹ : Fintype K
inst✝ : HasFiniteBiproducts C
f : K → C
p : Set K
j : Subtype pᶜ
k : Subtype p
⊢ (if h : (p ↑k)ᶜ then biproduct.ι (Subtype.restrict pᶜ f) { val := ↑k, property := (_ : (p ↑k)ᶜ) } else 0) ≫
      biproduct.π (Subtype.restrict pᶜ f) j =
    0
[PROOFSTEP]
rw [dif_neg]
[GOAL]
case w.w
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type
inst✝¹ : Fintype K
inst✝ : HasFiniteBiproducts C
f : K → C
p : Set K
j : Subtype pᶜ
k : Subtype p
⊢ 0 ≫ biproduct.π (Subtype.restrict pᶜ f) j = 0
case w.w.hnc
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type
inst✝¹ : Fintype K
inst✝ : HasFiniteBiproducts C
f : K → C
p : Set K
j : Subtype pᶜ
k : Subtype p
⊢ ¬(p ↑k)ᶜ
[PROOFSTEP]
simp only [zero_comp]
[GOAL]
case w.w.hnc
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type
inst✝¹ : Fintype K
inst✝ : HasFiniteBiproducts C
f : K → C
p : Set K
j : Subtype pᶜ
k : Subtype p
⊢ ¬(p ↑k)ᶜ
[PROOFSTEP]
exact not_not.mpr k.2
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type
inst✝¹ : Fintype K
inst✝ : HasFiniteBiproducts C
f : K → C
p : Set K
⊢ ∀ {Z' : C} (g' : ⨁ f ⟶ Z') (eq' : biproduct.fromSubtype f p ≫ g' = 0),
    biproduct.toSubtype f pᶜ ≫ (fun {W} g x => biproduct.fromSubtype f pᶜ ≫ g) g' eq' = g'
[PROOFSTEP]
intro W g' w
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type
inst✝¹ : Fintype K
inst✝ : HasFiniteBiproducts C
f : K → C
p : Set K
W : C
g' : ⨁ f ⟶ W
w : biproduct.fromSubtype f p ≫ g' = 0
⊢ biproduct.toSubtype f pᶜ ≫ (fun {W} g x => biproduct.fromSubtype f pᶜ ≫ g) g' w = g'
[PROOFSTEP]
ext j
[GOAL]
case w
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type
inst✝¹ : Fintype K
inst✝ : HasFiniteBiproducts C
f : K → C
p : Set K
W : C
g' : ⨁ f ⟶ W
w : biproduct.fromSubtype f p ≫ g' = 0
j : K
⊢ biproduct.ι f j ≫ biproduct.toSubtype f pᶜ ≫ (fun {W} g x => biproduct.fromSubtype f pᶜ ≫ g) g' w =
    biproduct.ι f j ≫ g'
[PROOFSTEP]
simp only [biproduct.toSubtype_fromSubtype_assoc, Pi.compl_apply, biproduct.ι_map_assoc]
[GOAL]
case w
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type
inst✝¹ : Fintype K
inst✝ : HasFiniteBiproducts C
f : K → C
p : Set K
W : C
g' : ⨁ f ⟶ W
w : biproduct.fromSubtype f p ≫ g' = 0
j : K
⊢ (if (p j)ᶜ then 𝟙 (f j) else 0) ≫ biproduct.ι (fun b => f b) j ≫ g' = biproduct.ι f j ≫ g'
[PROOFSTEP]
split_ifs with h
[GOAL]
case pos
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type
inst✝¹ : Fintype K
inst✝ : HasFiniteBiproducts C
f : K → C
p : Set K
W : C
g' : ⨁ f ⟶ W
w : biproduct.fromSubtype f p ≫ g' = 0
j : K
h : (p j)ᶜ
⊢ 𝟙 (f j) ≫ biproduct.ι (fun b => f b) j ≫ g' = biproduct.ι f j ≫ g'
[PROOFSTEP]
simp
[GOAL]
case neg
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type
inst✝¹ : Fintype K
inst✝ : HasFiniteBiproducts C
f : K → C
p : Set K
W : C
g' : ⨁ f ⟶ W
w : biproduct.fromSubtype f p ≫ g' = 0
j : K
h : ¬(p j)ᶜ
⊢ 0 ≫ biproduct.ι (fun b => f b) j ≫ g' = biproduct.ι f j ≫ g'
[PROOFSTEP]
replace w := biproduct.ι _ (⟨j, not_not.mp h⟩ : p) ≫= w
[GOAL]
case neg
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type
inst✝¹ : Fintype K
inst✝ : HasFiniteBiproducts C
f : K → C
p : Set K
W : C
g' : ⨁ f ⟶ W
j : K
h : ¬(p j)ᶜ
w :
  biproduct.ι (Subtype.restrict p f) { val := j, property := (_ : j ∈ p) } ≫ biproduct.fromSubtype f p ≫ g' =
    biproduct.ι (Subtype.restrict p f) { val := j, property := (_ : j ∈ p) } ≫ 0
⊢ 0 ≫ biproduct.ι (fun b => f b) j ≫ g' = biproduct.ι f j ≫ g'
[PROOFSTEP]
simpa using w.symm
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
K : Type
inst✝¹ : Fintype K
inst✝ : HasFiniteBiproducts C
f : K → C
p : Set K
⊢ ∀ {Z' : C} (g' : ⨁ f ⟶ Z') (eq' : biproduct.fromSubtype f p ≫ g' = 0) (m : ⨁ Subtype.restrict pᶜ f ⟶ Z'),
    biproduct.toSubtype f pᶜ ≫ m = g' → m = (fun {W} g x => biproduct.fromSubtype f pᶜ ≫ g) g' eq'
[PROOFSTEP]
aesop_cat
[GOAL]
J : Type
inst✝⁴ : Fintype J
K : Type
inst✝³ : Fintype K
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasFiniteBiproducts C
f : J → C
g : K → C
m : (j : J) → (k : K) → f j ⟶ g k
k : K
⊢ matrix m ≫ π g k = desc fun j => m j k
[PROOFSTEP]
ext
[GOAL]
case w
J : Type
inst✝⁴ : Fintype J
K : Type
inst✝³ : Fintype K
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasFiniteBiproducts C
f : J → C
g : K → C
m : (j : J) → (k : K) → f j ⟶ g k
k : K
j✝ : J
⊢ ι (fun j => f j) j✝ ≫ matrix m ≫ π g k = ι (fun j => f j) j✝ ≫ desc fun j => m j k
[PROOFSTEP]
simp [biproduct.matrix]
[GOAL]
J : Type
inst✝⁴ : Fintype J
K : Type
inst✝³ : Fintype K
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasFiniteBiproducts C
f : J → C
g : K → C
m : (j : J) → (k : K) → f j ⟶ g k
j : J
⊢ ι f j ≫ matrix m = lift fun k => m j k
[PROOFSTEP]
ext
[GOAL]
case w
J : Type
inst✝⁴ : Fintype J
K : Type
inst✝³ : Fintype K
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasFiniteBiproducts C
f : J → C
g : K → C
m : (j : J) → (k : K) → f j ⟶ g k
j : J
j✝ : K
⊢ (ι f j ≫ matrix m) ≫ π (fun k => g k) j✝ = (lift fun k => m j k) ≫ π (fun k => g k) j✝
[PROOFSTEP]
simp [biproduct.matrix]
[GOAL]
J : Type
inst✝⁴ : Fintype J
K : Type
inst✝³ : Fintype K
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasFiniteBiproducts C
f : J → C
g : K → C
m : (j : J) → (k : K) → f j ⟶ g k
j : J
k : K
⊢ components (matrix m) j k = m j k
[PROOFSTEP]
simp [biproduct.components]
[GOAL]
J : Type
inst✝⁴ : Fintype J
K : Type
inst✝³ : Fintype K
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasFiniteBiproducts C
f : J → C
g : K → C
m : ⨁ f ⟶ ⨁ g
⊢ (matrix fun j k => components m j k) = m
[PROOFSTEP]
ext
[GOAL]
case w.w
J : Type
inst✝⁴ : Fintype J
K : Type
inst✝³ : Fintype K
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasFiniteBiproducts C
f : J → C
g : K → C
m : ⨁ f ⟶ ⨁ g
j✝¹ : K
j✝ : J
⊢ ι (fun j => f j) j✝ ≫ (matrix fun j k => components m j k) ≫ π (fun k => g k) j✝¹ =
    ι (fun j => f j) j✝ ≫ m ≫ π (fun k => g k) j✝¹
[PROOFSTEP]
simp [biproduct.components]
[GOAL]
J : Type
inst✝⁴ : Fintype J
K : Type
inst✝³ : Fintype K
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasFiniteBiproducts C
f : J → C
g : K → C
m : (j : J) → (k : K) → f j ⟶ g k
⊢ components (matrix m) = m
[PROOFSTEP]
ext
[GOAL]
case h.h
J : Type
inst✝⁴ : Fintype J
K : Type
inst✝³ : Fintype K
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasFiniteBiproducts C
f : J → C
g : K → C
m : (j : J) → (k : K) → f j ⟶ g k
x✝¹ : J
x✝ : K
⊢ components (matrix m) x✝¹ x✝ = m x✝¹ x✝
[PROOFSTEP]
apply biproduct.matrix_components
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
f : J → C
inst✝ : HasBiproduct f
b : Bicone f
hb : Bicone.IsBilimit b
⊢ (IsLimit.conePointUniqueUpToIso hb.isLimit (isLimit f)).inv = desc b.ι
[PROOFSTEP]
refine' biproduct.hom_ext' _ _ fun j => hb.isLimit.hom_ext fun j' => _
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
f : J → C
inst✝ : HasBiproduct f
b : Bicone f
hb : Bicone.IsBilimit b
j : J
j' : Discrete J
⊢ (ι f j ≫ (IsLimit.conePointUniqueUpToIso hb.isLimit (isLimit f)).inv) ≫ NatTrans.app (Bicone.toCone b).π j' =
    (ι f j ≫ desc b.ι) ≫ NatTrans.app (Bicone.toCone b).π j'
[PROOFSTEP]
rw [Category.assoc, IsLimit.conePointUniqueUpToIso_inv_comp, Bicone.toCone_π_app, biproduct.bicone_π, biproduct.ι_desc,
  biproduct.ι_π, b.toCone_π_app, b.ι_π]
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
f : J → C
inst✝ : HasBiproduct f
b : Bicone f
hb : Bicone.IsBilimit b
⊢ lift b.π ≫ desc b.ι = 𝟙 b.pt
[PROOFSTEP]
rw [← biproduct.conePointUniqueUpToIso_hom f hb, ← biproduct.conePointUniqueUpToIso_inv f hb, Iso.hom_inv_id]
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
f : J → C
inst✝ : HasBiproduct f
b : Bicone f
hb : Bicone.IsBilimit b
⊢ desc b.ι ≫ lift b.π = 𝟙 (⨁ f)
[PROOFSTEP]
rw [← biproduct.conePointUniqueUpToIso_hom f hb, ← biproduct.conePointUniqueUpToIso_inv f hb, Iso.inv_hom_id]
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasFiniteBiproducts C
⊢ HasZeroObject C
[PROOFSTEP]
refine' ⟨⟨biproduct Empty.elim, fun X => ⟨⟨⟨0⟩, _⟩⟩, fun X => ⟨⟨⟨0⟩, _⟩⟩⟩⟩
[GOAL]
case refine'_1
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasFiniteBiproducts C
X : C
⊢ ∀ (a : ⨁ Empty.elim ⟶ X), a = default
[PROOFSTEP]
intro a
[GOAL]
case refine'_1
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasFiniteBiproducts C
X : C
a : ⨁ Empty.elim ⟶ X
⊢ a = default
[PROOFSTEP]
apply biproduct.hom_ext'
[GOAL]
case refine'_1.w
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasFiniteBiproducts C
X : C
a : ⨁ Empty.elim ⟶ X
⊢ ∀ (j : Empty), biproduct.ι Empty.elim j ≫ a = biproduct.ι Empty.elim j ≫ default
[PROOFSTEP]
simp
[GOAL]
case refine'_2
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasFiniteBiproducts C
X : C
⊢ ∀ (a : X ⟶ ⨁ Empty.elim), a = default
[PROOFSTEP]
intro a
[GOAL]
case refine'_2
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasFiniteBiproducts C
X : C
a : X ⟶ ⨁ Empty.elim
⊢ a = default
[PROOFSTEP]
apply biproduct.hom_ext
[GOAL]
case refine'_2.w
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasFiniteBiproducts C
X : C
a : X ⟶ ⨁ Empty.elim
⊢ ∀ (j : Empty), a ≫ biproduct.π Empty.elim j = default ≫ biproduct.π Empty.elim j
[PROOFSTEP]
simp
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : Unique J
f : J → C
j : J
⊢ f default = f j
[PROOFSTEP]
congr
[GOAL]
case e_a
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : Unique J
f : J → C
j : J
⊢ default = j
[PROOFSTEP]
rw [← Unique.uniq]
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : Unique J
f : J → C
j : J
⊢ f j = f default
[PROOFSTEP]
congr
[GOAL]
case e_a
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : Unique J
f : J → C
j : J
⊢ j = default
[PROOFSTEP]
rw [← Unique.uniq]
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
P Q X Y : C
b : BinaryBicone X Y
j j' : WalkingPair
⊢ (fun j => WalkingPair.casesOn j b.inl b.inr) j ≫ (fun j => WalkingPair.casesOn j b.fst b.snd) j' =
    if h : j = j' then eqToHom (_ : pairFunction X Y j = pairFunction X Y j') else 0
[PROOFSTEP]
rcases j with ⟨⟩
[GOAL]
case left
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
P Q X Y : C
b : BinaryBicone X Y
j' : WalkingPair
⊢ (fun j => WalkingPair.casesOn j b.inl b.inr) WalkingPair.left ≫ (fun j => WalkingPair.casesOn j b.fst b.snd) j' =
    if h : WalkingPair.left = j' then eqToHom (_ : pairFunction X Y WalkingPair.left = pairFunction X Y j') else 0
[PROOFSTEP]
rcases j' with ⟨⟩
[GOAL]
case right
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
P Q X Y : C
b : BinaryBicone X Y
j' : WalkingPair
⊢ (fun j => WalkingPair.casesOn j b.inl b.inr) WalkingPair.right ≫ (fun j => WalkingPair.casesOn j b.fst b.snd) j' =
    if h : WalkingPair.right = j' then eqToHom (_ : pairFunction X Y WalkingPair.right = pairFunction X Y j') else 0
[PROOFSTEP]
rcases j' with ⟨⟩
[GOAL]
case left.left
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
P Q X Y : C
b : BinaryBicone X Y
⊢ (fun j => WalkingPair.casesOn j b.inl b.inr) WalkingPair.left ≫
      (fun j => WalkingPair.casesOn j b.fst b.snd) WalkingPair.left =
    if h : WalkingPair.left = WalkingPair.left then
      eqToHom (_ : pairFunction X Y WalkingPair.left = pairFunction X Y WalkingPair.left)
    else 0
[PROOFSTEP]
simp
[GOAL]
case left.right
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
P Q X Y : C
b : BinaryBicone X Y
⊢ (fun j => WalkingPair.casesOn j b.inl b.inr) WalkingPair.left ≫
      (fun j => WalkingPair.casesOn j b.fst b.snd) WalkingPair.right =
    if h : WalkingPair.left = WalkingPair.right then
      eqToHom (_ : pairFunction X Y WalkingPair.left = pairFunction X Y WalkingPair.right)
    else 0
[PROOFSTEP]
simp
[GOAL]
case right.left
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
P Q X Y : C
b : BinaryBicone X Y
⊢ (fun j => WalkingPair.casesOn j b.inl b.inr) WalkingPair.right ≫
      (fun j => WalkingPair.casesOn j b.fst b.snd) WalkingPair.left =
    if h : WalkingPair.right = WalkingPair.left then
      eqToHom (_ : pairFunction X Y WalkingPair.right = pairFunction X Y WalkingPair.left)
    else 0
[PROOFSTEP]
simp
[GOAL]
case right.right
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
P Q X Y : C
b : BinaryBicone X Y
⊢ (fun j => WalkingPair.casesOn j b.inl b.inr) WalkingPair.right ≫
      (fun j => WalkingPair.casesOn j b.fst b.snd) WalkingPair.right =
    if h : WalkingPair.right = WalkingPair.right then
      eqToHom (_ : pairFunction X Y WalkingPair.right = pairFunction X Y WalkingPair.right)
    else 0
[PROOFSTEP]
simp
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
P Q X Y : C
b : BinaryBicone X Y
j : Discrete WalkingPair
⊢ NatTrans.app (Bicone.toCone (toBicone b)).π j =
    (Iso.refl (Bicone.toCone (toBicone b)).pt).hom ≫ NatTrans.app (toCone b).π j
[PROOFSTEP]
cases' j with as
[GOAL]
case mk
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
P Q X Y : C
b : BinaryBicone X Y
as : WalkingPair
⊢ NatTrans.app (Bicone.toCone (toBicone b)).π { as := as } =
    (Iso.refl (Bicone.toCone (toBicone b)).pt).hom ≫ NatTrans.app (toCone b).π { as := as }
[PROOFSTEP]
cases as
[GOAL]
case mk.left
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
P Q X Y : C
b : BinaryBicone X Y
⊢ NatTrans.app (Bicone.toCone (toBicone b)).π { as := WalkingPair.left } =
    (Iso.refl (Bicone.toCone (toBicone b)).pt).hom ≫ NatTrans.app (toCone b).π { as := WalkingPair.left }
[PROOFSTEP]
simp
[GOAL]
case mk.right
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
P Q X Y : C
b : BinaryBicone X Y
⊢ NatTrans.app (Bicone.toCone (toBicone b)).π { as := WalkingPair.right } =
    (Iso.refl (Bicone.toCone (toBicone b)).pt).hom ≫ NatTrans.app (toCone b).π { as := WalkingPair.right }
[PROOFSTEP]
simp
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
P Q X Y : C
b : BinaryBicone X Y
j : Discrete WalkingPair
⊢ NatTrans.app (Bicone.toCocone (toBicone b)).ι j ≫ (Iso.refl (Bicone.toCocone (toBicone b)).pt).hom =
    NatTrans.app (toCocone b).ι j
[PROOFSTEP]
cases' j with as
[GOAL]
case mk
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
P Q X Y : C
b : BinaryBicone X Y
as : WalkingPair
⊢ NatTrans.app (Bicone.toCocone (toBicone b)).ι { as := as } ≫ (Iso.refl (Bicone.toCocone (toBicone b)).pt).hom =
    NatTrans.app (toCocone b).ι { as := as }
[PROOFSTEP]
cases as
[GOAL]
case mk.left
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
P Q X Y : C
b : BinaryBicone X Y
⊢ NatTrans.app (Bicone.toCocone (toBicone b)).ι { as := WalkingPair.left } ≫
      (Iso.refl (Bicone.toCocone (toBicone b)).pt).hom =
    NatTrans.app (toCocone b).ι { as := WalkingPair.left }
[PROOFSTEP]
simp
[GOAL]
case mk.right
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
P Q X Y : C
b : BinaryBicone X Y
⊢ NatTrans.app (Bicone.toCocone (toBicone b)).ι { as := WalkingPair.right } ≫
      (Iso.refl (Bicone.toCocone (toBicone b)).pt).hom =
    NatTrans.app (toCocone b).ι { as := WalkingPair.right }
[PROOFSTEP]
simp
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X Y : C
b : Bicone (pairFunction X Y)
⊢ ι b WalkingPair.left ≫ π b WalkingPair.left = 𝟙 X
[PROOFSTEP]
simp [Bicone.ι_π]
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X Y : C
b : Bicone (pairFunction X Y)
⊢ ι b WalkingPair.left ≫ π b WalkingPair.right = 0
[PROOFSTEP]
simp [Bicone.ι_π]
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X Y : C
b : Bicone (pairFunction X Y)
⊢ ι b WalkingPair.right ≫ π b WalkingPair.left = 0
[PROOFSTEP]
simp [Bicone.ι_π]
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X Y : C
b : Bicone (pairFunction X Y)
⊢ ι b WalkingPair.right ≫ π b WalkingPair.right = 𝟙 Y
[PROOFSTEP]
simp [Bicone.ι_π]
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X Y : C
b : Bicone (pairFunction X Y)
j : Discrete WalkingPair
⊢ NatTrans.app (BinaryBicone.toCone (toBinaryBicone b)).π j =
    (Iso.refl (BinaryBicone.toCone (toBinaryBicone b)).pt).hom ≫ NatTrans.app (toCone b).π j
[PROOFSTEP]
rcases j with ⟨⟨⟩⟩
[GOAL]
case mk.left
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X Y : C
b : Bicone (pairFunction X Y)
⊢ NatTrans.app (BinaryBicone.toCone (toBinaryBicone b)).π { as := WalkingPair.left } =
    (Iso.refl (BinaryBicone.toCone (toBinaryBicone b)).pt).hom ≫ NatTrans.app (toCone b).π { as := WalkingPair.left }
[PROOFSTEP]
simp
[GOAL]
case mk.right
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X Y : C
b : Bicone (pairFunction X Y)
⊢ NatTrans.app (BinaryBicone.toCone (toBinaryBicone b)).π { as := WalkingPair.right } =
    (Iso.refl (BinaryBicone.toCone (toBinaryBicone b)).pt).hom ≫ NatTrans.app (toCone b).π { as := WalkingPair.right }
[PROOFSTEP]
simp
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X Y : C
b : Bicone (pairFunction X Y)
j : Discrete WalkingPair
⊢ NatTrans.app (BinaryBicone.toCocone (toBinaryBicone b)).ι j ≫
      (Iso.refl (BinaryBicone.toCocone (toBinaryBicone b)).pt).hom =
    NatTrans.app (toCocone b).ι j
[PROOFSTEP]
rcases j with ⟨⟨⟩⟩
[GOAL]
case mk.left
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X Y : C
b : Bicone (pairFunction X Y)
⊢ NatTrans.app (BinaryBicone.toCocone (toBinaryBicone b)).ι { as := WalkingPair.left } ≫
      (Iso.refl (BinaryBicone.toCocone (toBinaryBicone b)).pt).hom =
    NatTrans.app (toCocone b).ι { as := WalkingPair.left }
[PROOFSTEP]
simp
[GOAL]
case mk.right
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X Y : C
b : Bicone (pairFunction X Y)
⊢ NatTrans.app (BinaryBicone.toCocone (toBinaryBicone b)).ι { as := WalkingPair.right } ≫
      (Iso.refl (BinaryBicone.toCocone (toBinaryBicone b)).pt).hom =
    NatTrans.app (toCocone b).ι { as := WalkingPair.right }
[PROOFSTEP]
simp
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X Y : C
b : BinaryBicone X Y
x✝ : Bicone.IsBilimit (toBicone b)
h : IsLimit (Bicone.toCone (toBicone b))
h' : IsColimit (Bicone.toCocone (toBicone b))
⊢ (fun h => { isLimit := ↑(toBiconeIsLimit b).symm h.isLimit, isColimit := ↑(toBiconeIsColimit b).symm h.isColimit })
      ((fun h => { isLimit := ↑(toBiconeIsLimit b) h.isLimit, isColimit := ↑(toBiconeIsColimit b) h.isColimit })
        { isLimit := h, isColimit := h' }) =
    { isLimit := h, isColimit := h' }
[PROOFSTEP]
dsimp only
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X Y : C
b : BinaryBicone X Y
x✝ : Bicone.IsBilimit (toBicone b)
h : IsLimit (Bicone.toCone (toBicone b))
h' : IsColimit (Bicone.toCocone (toBicone b))
⊢ { isLimit := ↑(toBiconeIsLimit b).symm (↑(toBiconeIsLimit b) h),
      isColimit := ↑(toBiconeIsColimit b).symm (↑(toBiconeIsColimit b) h') } =
    { isLimit := h, isColimit := h' }
[PROOFSTEP]
simp
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X Y : C
b : BinaryBicone X Y
x✝ : IsBilimit b
h : IsLimit (toCone b)
h' : IsColimit (toCocone b)
⊢ (fun h => { isLimit := ↑(toBiconeIsLimit b) h.isLimit, isColimit := ↑(toBiconeIsColimit b) h.isColimit })
      ((fun h =>
          { isLimit := ↑(toBiconeIsLimit b).symm h.isLimit, isColimit := ↑(toBiconeIsColimit b).symm h.isColimit })
        { isLimit := h, isColimit := h' }) =
    { isLimit := h, isColimit := h' }
[PROOFSTEP]
dsimp only
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X Y : C
b : BinaryBicone X Y
x✝ : IsBilimit b
h : IsLimit (toCone b)
h' : IsColimit (toCocone b)
⊢ { isLimit := ↑(toBiconeIsLimit b) (↑(toBiconeIsLimit b).symm h),
      isColimit := ↑(toBiconeIsColimit b) (↑(toBiconeIsColimit b).symm h') } =
    { isLimit := h, isColimit := h' }
[PROOFSTEP]
simp
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X Y : C
b : Bicone (pairFunction X Y)
x✝ : BinaryBicone.IsBilimit (toBinaryBicone b)
h : IsLimit (BinaryBicone.toCone (toBinaryBicone b))
h' : IsColimit (BinaryBicone.toCocone (toBinaryBicone b))
⊢ (fun h =>
        { isLimit := ↑(toBinaryBiconeIsLimit b).symm h.isLimit,
          isColimit := ↑(toBinaryBiconeIsColimit b).symm h.isColimit })
      ((fun h =>
          { isLimit := ↑(toBinaryBiconeIsLimit b) h.isLimit, isColimit := ↑(toBinaryBiconeIsColimit b) h.isColimit })
        { isLimit := h, isColimit := h' }) =
    { isLimit := h, isColimit := h' }
[PROOFSTEP]
dsimp only
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X Y : C
b : Bicone (pairFunction X Y)
x✝ : BinaryBicone.IsBilimit (toBinaryBicone b)
h : IsLimit (BinaryBicone.toCone (toBinaryBicone b))
h' : IsColimit (BinaryBicone.toCocone (toBinaryBicone b))
⊢ { isLimit := ↑(toBinaryBiconeIsLimit b).symm (↑(toBinaryBiconeIsLimit b) h),
      isColimit := ↑(toBinaryBiconeIsColimit b).symm (↑(toBinaryBiconeIsColimit b) h') } =
    { isLimit := h, isColimit := h' }
[PROOFSTEP]
simp
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X Y : C
b : Bicone (pairFunction X Y)
x✝ : IsBilimit b
h : IsLimit (toCone b)
h' : IsColimit (toCocone b)
⊢ (fun h => { isLimit := ↑(toBinaryBiconeIsLimit b) h.isLimit, isColimit := ↑(toBinaryBiconeIsColimit b) h.isColimit })
      ((fun h =>
          { isLimit := ↑(toBinaryBiconeIsLimit b).symm h.isLimit,
            isColimit := ↑(toBinaryBiconeIsColimit b).symm h.isColimit })
        { isLimit := h, isColimit := h' }) =
    { isLimit := h, isColimit := h' }
[PROOFSTEP]
dsimp only
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X Y : C
b : Bicone (pairFunction X Y)
x✝ : IsBilimit b
h : IsLimit (toCone b)
h' : IsColimit (toCocone b)
⊢ { isLimit := ↑(toBinaryBiconeIsLimit b) (↑(toBinaryBiconeIsLimit b).symm h),
      isColimit := ↑(toBinaryBiconeIsColimit b) (↑(toBinaryBiconeIsColimit b).symm h') } =
    { isLimit := h, isColimit := h' }
[PROOFSTEP]
simp
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
⊢ (isoProd X Y).hom = prod.lift fst snd
[PROOFSTEP]
ext
[GOAL]
case h₁.h₀
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
⊢ inl ≫ (isoProd X Y).hom ≫ prod.fst = inl ≫ prod.lift fst snd ≫ prod.fst
[PROOFSTEP]
simp [biprod.isoProd]
[GOAL]
case h₁.h₁
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
⊢ inr ≫ (isoProd X Y).hom ≫ prod.fst = inr ≫ prod.lift fst snd ≫ prod.fst
[PROOFSTEP]
simp [biprod.isoProd]
[GOAL]
case h₂.h₀
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
⊢ inl ≫ (isoProd X Y).hom ≫ prod.snd = inl ≫ prod.lift fst snd ≫ prod.snd
[PROOFSTEP]
simp [biprod.isoProd]
[GOAL]
case h₂.h₁
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
⊢ inr ≫ (isoProd X Y).hom ≫ prod.snd = inr ≫ prod.lift fst snd ≫ prod.snd
[PROOFSTEP]
simp [biprod.isoProd]
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
⊢ (isoProd X Y).inv = lift prod.fst prod.snd
[PROOFSTEP]
ext
[GOAL]
case h₀
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
⊢ (isoProd X Y).inv ≫ fst = lift prod.fst prod.snd ≫ fst
[PROOFSTEP]
simp [Iso.inv_comp_eq]
[GOAL]
case h₁
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
⊢ (isoProd X Y).inv ≫ snd = lift prod.fst prod.snd ≫ snd
[PROOFSTEP]
simp [Iso.inv_comp_eq]
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
⊢ (isoCoprod X Y).inv = coprod.desc inl inr
[PROOFSTEP]
ext
[GOAL]
case h₁.h₀
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
⊢ (coprod.inl ≫ (isoCoprod X Y).inv) ≫ fst = (coprod.inl ≫ coprod.desc inl inr) ≫ fst
[PROOFSTEP]
simp [biprod.isoCoprod]
[GOAL]
case h₁.h₁
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
⊢ (coprod.inl ≫ (isoCoprod X Y).inv) ≫ snd = (coprod.inl ≫ coprod.desc inl inr) ≫ snd
[PROOFSTEP]
simp [biprod.isoCoprod]
[GOAL]
case h₂.h₀
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
⊢ (coprod.inr ≫ (isoCoprod X Y).inv) ≫ fst = (coprod.inr ≫ coprod.desc inl inr) ≫ fst
[PROOFSTEP]
simp [biprod.isoCoprod]
[GOAL]
case h₂.h₁
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
⊢ (coprod.inr ≫ (isoCoprod X Y).inv) ≫ snd = (coprod.inr ≫ coprod.desc inl inr) ≫ snd
[PROOFSTEP]
simp [biprod.isoCoprod]
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
⊢ (biprod.isoCoprod X Y).hom = biprod.desc coprod.inl coprod.inr
[PROOFSTEP]
ext
[GOAL]
case h₀
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
⊢ biprod.inl ≫ (biprod.isoCoprod X Y).hom = biprod.inl ≫ biprod.desc coprod.inl coprod.inr
[PROOFSTEP]
simp [← Iso.eq_comp_inv]
[GOAL]
case h₁
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
⊢ biprod.inr ≫ (biprod.isoCoprod X Y).hom = biprod.inr ≫ biprod.desc coprod.inl coprod.inr
[PROOFSTEP]
simp [← Iso.eq_comp_inv]
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
P Q W X Y Z : C
inst✝¹ : HasBinaryBiproduct W X
inst✝ : HasBinaryBiproduct Y Z
f : W ⟶ Y
g : X ⟶ Z
⊢ map f g = map' f g
[PROOFSTEP]
ext
[GOAL]
case h₀.h₀
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
P Q W X Y Z : C
inst✝¹ : HasBinaryBiproduct W X
inst✝ : HasBinaryBiproduct Y Z
f : W ⟶ Y
g : X ⟶ Z
⊢ (inl ≫ map f g) ≫ fst = (inl ≫ map' f g) ≫ fst
[PROOFSTEP]
simp only [mapPair_left, IsColimit.ι_map, IsLimit.map_π, biprod.inl_fst_assoc, Category.assoc, ←
  BinaryBicone.toCone_π_app_left, ← BinaryBiproduct.bicone_fst, ← BinaryBicone.toCocone_ι_app_left, ←
  BinaryBiproduct.bicone_inl]
[GOAL]
case h₀.h₀
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
P Q W X Y Z : C
inst✝¹ : HasBinaryBiproduct W X
inst✝ : HasBinaryBiproduct Y Z
f : W ⟶ Y
g : X ⟶ Z
⊢ NatTrans.app (BinaryBicone.toCocone (BinaryBiproduct.bicone W X)).ι { as := WalkingPair.left } ≫
      NatTrans.app (BinaryBicone.toCone (BinaryBiproduct.bicone W X)).π { as := WalkingPair.left } ≫ f =
    f ≫
      NatTrans.app (BinaryBicone.toCocone (BinaryBiproduct.bicone Y Z)).ι { as := WalkingPair.left } ≫
        NatTrans.app (BinaryBicone.toCone (BinaryBiproduct.bicone Y Z)).π { as := WalkingPair.left }
[PROOFSTEP]
dsimp
[GOAL]
case h₀.h₀
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
P Q W X Y Z : C
inst✝¹ : HasBinaryBiproduct W X
inst✝ : HasBinaryBiproduct Y Z
f : W ⟶ Y
g : X ⟶ Z
⊢ inl ≫ fst ≫ f = f ≫ inl ≫ fst
[PROOFSTEP]
simp
[GOAL]
case h₀.h₁
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
P Q W X Y Z : C
inst✝¹ : HasBinaryBiproduct W X
inst✝ : HasBinaryBiproduct Y Z
f : W ⟶ Y
g : X ⟶ Z
⊢ (inl ≫ map f g) ≫ snd = (inl ≫ map' f g) ≫ snd
[PROOFSTEP]
simp only [mapPair_left, IsColimit.ι_map, IsLimit.map_π, zero_comp, biprod.inl_snd_assoc, Category.assoc, ←
  BinaryBicone.toCone_π_app_right, ← BinaryBiproduct.bicone_snd, ← BinaryBicone.toCocone_ι_app_left, ←
  BinaryBiproduct.bicone_inl]
[GOAL]
case h₀.h₁
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
P Q W X Y Z : C
inst✝¹ : HasBinaryBiproduct W X
inst✝ : HasBinaryBiproduct Y Z
f : W ⟶ Y
g : X ⟶ Z
⊢ NatTrans.app (BinaryBicone.toCocone (BinaryBiproduct.bicone W X)).ι { as := WalkingPair.left } ≫
      NatTrans.app (BinaryBicone.toCone (BinaryBiproduct.bicone W X)).π { as := WalkingPair.right } ≫
        NatTrans.app (mapPair f g) { as := WalkingPair.right } =
    f ≫
      NatTrans.app (BinaryBicone.toCocone (BinaryBiproduct.bicone Y Z)).ι { as := WalkingPair.left } ≫
        NatTrans.app (BinaryBicone.toCone (BinaryBiproduct.bicone Y Z)).π { as := WalkingPair.right }
[PROOFSTEP]
simp
[GOAL]
case h₁.h₀
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
P Q W X Y Z : C
inst✝¹ : HasBinaryBiproduct W X
inst✝ : HasBinaryBiproduct Y Z
f : W ⟶ Y
g : X ⟶ Z
⊢ (inr ≫ map f g) ≫ fst = (inr ≫ map' f g) ≫ fst
[PROOFSTEP]
simp only [mapPair_right, biprod.inr_fst_assoc, IsColimit.ι_map, IsLimit.map_π, zero_comp, Category.assoc, ←
  BinaryBicone.toCone_π_app_left, ← BinaryBiproduct.bicone_fst, ← BinaryBicone.toCocone_ι_app_right, ←
  BinaryBiproduct.bicone_inr]
[GOAL]
case h₁.h₀
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
P Q W X Y Z : C
inst✝¹ : HasBinaryBiproduct W X
inst✝ : HasBinaryBiproduct Y Z
f : W ⟶ Y
g : X ⟶ Z
⊢ NatTrans.app (BinaryBicone.toCocone (BinaryBiproduct.bicone W X)).ι { as := WalkingPair.right } ≫
      NatTrans.app (BinaryBicone.toCone (BinaryBiproduct.bicone W X)).π { as := WalkingPair.left } ≫
        NatTrans.app (mapPair f g) { as := WalkingPair.left } =
    g ≫
      NatTrans.app (BinaryBicone.toCocone (BinaryBiproduct.bicone Y Z)).ι { as := WalkingPair.right } ≫
        NatTrans.app (BinaryBicone.toCone (BinaryBiproduct.bicone Y Z)).π { as := WalkingPair.left }
[PROOFSTEP]
simp
[GOAL]
case h₁.h₁
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
P Q W X Y Z : C
inst✝¹ : HasBinaryBiproduct W X
inst✝ : HasBinaryBiproduct Y Z
f : W ⟶ Y
g : X ⟶ Z
⊢ (inr ≫ map f g) ≫ snd = (inr ≫ map' f g) ≫ snd
[PROOFSTEP]
simp only [mapPair_right, IsColimit.ι_map, IsLimit.map_π, biprod.inr_snd_assoc, Category.assoc, ←
  BinaryBicone.toCone_π_app_right, ← BinaryBiproduct.bicone_snd, ← BinaryBicone.toCocone_ι_app_right, ←
  BinaryBiproduct.bicone_inr]
[GOAL]
case h₁.h₁
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
P Q W X Y Z : C
inst✝¹ : HasBinaryBiproduct W X
inst✝ : HasBinaryBiproduct Y Z
f : W ⟶ Y
g : X ⟶ Z
⊢ NatTrans.app (BinaryBicone.toCocone (BinaryBiproduct.bicone W X)).ι { as := WalkingPair.right } ≫
      NatTrans.app (BinaryBicone.toCone (BinaryBiproduct.bicone W X)).π { as := WalkingPair.right } ≫ g =
    g ≫
      NatTrans.app (BinaryBicone.toCocone (BinaryBiproduct.bicone Y Z)).ι { as := WalkingPair.right } ≫
        NatTrans.app (BinaryBicone.toCone (BinaryBiproduct.bicone Y Z)).π { as := WalkingPair.right }
[PROOFSTEP]
simp
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
P Q W X Y Z : C
inst✝¹ : HasBinaryBiproduct W X
inst✝ : HasBinaryBiproduct Y Z
f : W ⟶ Y
g : X ⟶ Z
⊢ inl ≫ map f g = f ≫ inl
[PROOFSTEP]
rw [biprod.map_eq_map']
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
P Q W X Y Z : C
inst✝¹ : HasBinaryBiproduct W X
inst✝ : HasBinaryBiproduct Y Z
f : W ⟶ Y
g : X ⟶ Z
⊢ inl ≫ map' f g = f ≫ inl
[PROOFSTEP]
exact IsColimit.ι_map (BinaryBiproduct.isColimit W X) _ _ ⟨WalkingPair.left⟩
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
P Q W X Y Z : C
inst✝¹ : HasBinaryBiproduct W X
inst✝ : HasBinaryBiproduct Y Z
f : W ⟶ Y
g : X ⟶ Z
⊢ inr ≫ map f g = g ≫ inr
[PROOFSTEP]
rw [biprod.map_eq_map']
[GOAL]
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
P Q W X Y Z : C
inst✝¹ : HasBinaryBiproduct W X
inst✝ : HasBinaryBiproduct Y Z
f : W ⟶ Y
g : X ⟶ Z
⊢ inr ≫ map' f g = g ≫ inr
[PROOFSTEP]
exact IsColimit.ι_map (BinaryBiproduct.isColimit W X) _ _ ⟨WalkingPair.right⟩
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
b : BinaryBicone X Y
hb : BinaryBicone.IsBilimit b
⊢ (IsLimit.conePointUniqueUpToIso hb.isLimit (BinaryBiproduct.isLimit X Y)).inv = desc b.inl b.inr
[PROOFSTEP]
refine' biprod.hom_ext' _ _ (hb.isLimit.hom_ext fun j => _) (hb.isLimit.hom_ext fun j => _)
[GOAL]
case refine'_1
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
b : BinaryBicone X Y
hb : BinaryBicone.IsBilimit b
j : Discrete WalkingPair
⊢ (inl ≫ (IsLimit.conePointUniqueUpToIso hb.isLimit (BinaryBiproduct.isLimit X Y)).inv) ≫
      NatTrans.app (BinaryBicone.toCone b).π j =
    (inl ≫ desc b.inl b.inr) ≫ NatTrans.app (BinaryBicone.toCone b).π j
case refine'_2
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
b : BinaryBicone X Y
hb : BinaryBicone.IsBilimit b
j : Discrete WalkingPair
⊢ (inr ≫ (IsLimit.conePointUniqueUpToIso hb.isLimit (BinaryBiproduct.isLimit X Y)).inv) ≫
      NatTrans.app (BinaryBicone.toCone b).π j =
    (inr ≫ desc b.inl b.inr) ≫ NatTrans.app (BinaryBicone.toCone b).π j
[PROOFSTEP]
all_goals
  simp only [Category.assoc, IsLimit.conePointUniqueUpToIso_inv_comp]
  rcases j with ⟨⟨⟩⟩
[GOAL]
case refine'_1
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
b : BinaryBicone X Y
hb : BinaryBicone.IsBilimit b
j : Discrete WalkingPair
⊢ (inl ≫ (IsLimit.conePointUniqueUpToIso hb.isLimit (BinaryBiproduct.isLimit X Y)).inv) ≫
      NatTrans.app (BinaryBicone.toCone b).π j =
    (inl ≫ desc b.inl b.inr) ≫ NatTrans.app (BinaryBicone.toCone b).π j
[PROOFSTEP]
simp only [Category.assoc, IsLimit.conePointUniqueUpToIso_inv_comp]
[GOAL]
case refine'_1
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
b : BinaryBicone X Y
hb : BinaryBicone.IsBilimit b
j : Discrete WalkingPair
⊢ inl ≫ NatTrans.app (BinaryBicone.toCone (BinaryBiproduct.bicone X Y)).π j =
    inl ≫ desc b.inl b.inr ≫ NatTrans.app (BinaryBicone.toCone b).π j
[PROOFSTEP]
rcases j with ⟨⟨⟩⟩
[GOAL]
case refine'_2
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
b : BinaryBicone X Y
hb : BinaryBicone.IsBilimit b
j : Discrete WalkingPair
⊢ (inr ≫ (IsLimit.conePointUniqueUpToIso hb.isLimit (BinaryBiproduct.isLimit X Y)).inv) ≫
      NatTrans.app (BinaryBicone.toCone b).π j =
    (inr ≫ desc b.inl b.inr) ≫ NatTrans.app (BinaryBicone.toCone b).π j
[PROOFSTEP]
simp only [Category.assoc, IsLimit.conePointUniqueUpToIso_inv_comp]
[GOAL]
case refine'_2
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
b : BinaryBicone X Y
hb : BinaryBicone.IsBilimit b
j : Discrete WalkingPair
⊢ inr ≫ NatTrans.app (BinaryBicone.toCone (BinaryBiproduct.bicone X Y)).π j =
    inr ≫ desc b.inl b.inr ≫ NatTrans.app (BinaryBicone.toCone b).π j
[PROOFSTEP]
rcases j with ⟨⟨⟩⟩
[GOAL]
case refine'_1.mk.left
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
b : BinaryBicone X Y
hb : BinaryBicone.IsBilimit b
⊢ inl ≫ NatTrans.app (BinaryBicone.toCone (BinaryBiproduct.bicone X Y)).π { as := WalkingPair.left } =
    inl ≫ desc b.inl b.inr ≫ NatTrans.app (BinaryBicone.toCone b).π { as := WalkingPair.left }
case refine'_1.mk.right
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
b : BinaryBicone X Y
hb : BinaryBicone.IsBilimit b
⊢ inl ≫ NatTrans.app (BinaryBicone.toCone (BinaryBiproduct.bicone X Y)).π { as := WalkingPair.right } =
    inl ≫ desc b.inl b.inr ≫ NatTrans.app (BinaryBicone.toCone b).π { as := WalkingPair.right }
case refine'_2.mk.left
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
b : BinaryBicone X Y
hb : BinaryBicone.IsBilimit b
⊢ inr ≫ NatTrans.app (BinaryBicone.toCone (BinaryBiproduct.bicone X Y)).π { as := WalkingPair.left } =
    inr ≫ desc b.inl b.inr ≫ NatTrans.app (BinaryBicone.toCone b).π { as := WalkingPair.left }
case refine'_2.mk.right
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
b : BinaryBicone X Y
hb : BinaryBicone.IsBilimit b
⊢ inr ≫ NatTrans.app (BinaryBicone.toCone (BinaryBiproduct.bicone X Y)).π { as := WalkingPair.right } =
    inr ≫ desc b.inl b.inr ≫ NatTrans.app (BinaryBicone.toCone b).π { as := WalkingPair.right }
[PROOFSTEP]
all_goals simp
[GOAL]
case refine'_1.mk.left
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
b : BinaryBicone X Y
hb : BinaryBicone.IsBilimit b
⊢ inl ≫ NatTrans.app (BinaryBicone.toCone (BinaryBiproduct.bicone X Y)).π { as := WalkingPair.left } =
    inl ≫ desc b.inl b.inr ≫ NatTrans.app (BinaryBicone.toCone b).π { as := WalkingPair.left }
[PROOFSTEP]
simp
[GOAL]
case refine'_1.mk.right
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
b : BinaryBicone X Y
hb : BinaryBicone.IsBilimit b
⊢ inl ≫ NatTrans.app (BinaryBicone.toCone (BinaryBiproduct.bicone X Y)).π { as := WalkingPair.right } =
    inl ≫ desc b.inl b.inr ≫ NatTrans.app (BinaryBicone.toCone b).π { as := WalkingPair.right }
[PROOFSTEP]
simp
[GOAL]
case refine'_2.mk.left
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
b : BinaryBicone X Y
hb : BinaryBicone.IsBilimit b
⊢ inr ≫ NatTrans.app (BinaryBicone.toCone (BinaryBiproduct.bicone X Y)).π { as := WalkingPair.left } =
    inr ≫ desc b.inl b.inr ≫ NatTrans.app (BinaryBicone.toCone b).π { as := WalkingPair.left }
[PROOFSTEP]
simp
[GOAL]
case refine'_2.mk.right
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
b : BinaryBicone X Y
hb : BinaryBicone.IsBilimit b
⊢ inr ≫ NatTrans.app (BinaryBicone.toCone (BinaryBiproduct.bicone X Y)).π { as := WalkingPair.right } =
    inr ≫ desc b.inl b.inr ≫ NatTrans.app (BinaryBicone.toCone b).π { as := WalkingPair.right }
[PROOFSTEP]
simp
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
b : BinaryBicone X Y
hb : BinaryBicone.IsBilimit b
⊢ lift b.fst b.snd ≫ desc b.inl b.inr = 𝟙 b.pt
[PROOFSTEP]
rw [← biprod.conePointUniqueUpToIso_hom X Y hb, ← biprod.conePointUniqueUpToIso_inv X Y hb, Iso.hom_inv_id]
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
b : BinaryBicone X Y
hb : BinaryBicone.IsBilimit b
⊢ desc b.inl b.inr ≫ lift b.fst b.snd = 𝟙 (X ⊞ Y)
[PROOFSTEP]
rw [← biprod.conePointUniqueUpToIso_hom X Y hb, ← biprod.conePointUniqueUpToIso_inv X Y hb, Iso.inv_hom_id]
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
⊢ IsIso inl ↔ 𝟙 (X ⊞ Y) = fst ≫ inl
[PROOFSTEP]
constructor
[GOAL]
case mp
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
⊢ IsIso inl → 𝟙 (X ⊞ Y) = fst ≫ inl
[PROOFSTEP]
intro h
[GOAL]
case mp
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
h : IsIso inl
⊢ 𝟙 (X ⊞ Y) = fst ≫ inl
[PROOFSTEP]
have := (cancel_epi (inv biprod.inl : X ⊞ Y ⟶ X)).2 <| @biprod.inl_fst _ _ _ X Y _
[GOAL]
case mp
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
h : IsIso inl
this : inv inl ≫ inl ≫ fst = inv inl ≫ 𝟙 X
⊢ 𝟙 (X ⊞ Y) = fst ≫ inl
[PROOFSTEP]
rw [IsIso.inv_hom_id_assoc, Category.comp_id] at this
[GOAL]
case mp
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
h : IsIso inl
this : fst = inv inl
⊢ 𝟙 (X ⊞ Y) = fst ≫ inl
[PROOFSTEP]
rw [this, IsIso.inv_hom_id]
[GOAL]
case mpr
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
⊢ 𝟙 (X ⊞ Y) = fst ≫ inl → IsIso inl
[PROOFSTEP]
intro h
[GOAL]
case mpr
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
h : 𝟙 (X ⊞ Y) = fst ≫ inl
⊢ IsIso inl
[PROOFSTEP]
exact ⟨⟨biprod.fst, biprod.inl_fst, h.symm⟩⟩
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
P Q X Y : C
c : BinaryBicone X Y
i : IsLimit (toCone c)
s : Fork c.fst 0
⊢ (Fork.ι s ≫ c.snd) ≫ Fork.ι (fstKernelFork c) = Fork.ι s
[PROOFSTEP]
apply BinaryFan.IsLimit.hom_ext i
[GOAL]
case h₁
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
P Q X Y : C
c : BinaryBicone X Y
i : IsLimit (toCone c)
s : Fork c.fst 0
⊢ ((Fork.ι s ≫ c.snd) ≫ Fork.ι (fstKernelFork c)) ≫ BinaryFan.fst (toCone c) = Fork.ι s ≫ BinaryFan.fst (toCone c)
[PROOFSTEP]
simp
[GOAL]
case h₂
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
P Q X Y : C
c : BinaryBicone X Y
i : IsLimit (toCone c)
s : Fork c.fst 0
⊢ ((Fork.ι s ≫ c.snd) ≫ Fork.ι (fstKernelFork c)) ≫ BinaryFan.snd (toCone c) = Fork.ι s ≫ BinaryFan.snd (toCone c)
[PROOFSTEP]
simp
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
P Q X Y : C
c : BinaryBicone X Y
i : IsLimit (toCone c)
s : Fork c.fst 0
m✝ :
  ((const WalkingParallelPair).obj s.pt).obj WalkingParallelPair.zero ⟶
    ((const WalkingParallelPair).obj (fstKernelFork c).pt).obj WalkingParallelPair.zero
hm : m✝ ≫ Fork.ι (fstKernelFork c) = Fork.ι s
⊢ m✝ = Fork.ι s ≫ c.snd
[PROOFSTEP]
simp [← hm]
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
P Q X Y : C
c : BinaryBicone X Y
i : IsLimit (toCone c)
s : Fork c.snd 0
⊢ (Fork.ι s ≫ c.fst) ≫ Fork.ι (sndKernelFork c) = Fork.ι s
[PROOFSTEP]
apply BinaryFan.IsLimit.hom_ext i
[GOAL]
case h₁
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
P Q X Y : C
c : BinaryBicone X Y
i : IsLimit (toCone c)
s : Fork c.snd 0
⊢ ((Fork.ι s ≫ c.fst) ≫ Fork.ι (sndKernelFork c)) ≫ BinaryFan.fst (toCone c) = Fork.ι s ≫ BinaryFan.fst (toCone c)
[PROOFSTEP]
simp
[GOAL]
case h₂
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
P Q X Y : C
c : BinaryBicone X Y
i : IsLimit (toCone c)
s : Fork c.snd 0
⊢ ((Fork.ι s ≫ c.fst) ≫ Fork.ι (sndKernelFork c)) ≫ BinaryFan.snd (toCone c) = Fork.ι s ≫ BinaryFan.snd (toCone c)
[PROOFSTEP]
simp
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
P Q X Y : C
c : BinaryBicone X Y
i : IsLimit (toCone c)
s : Fork c.snd 0
m✝ :
  ((const WalkingParallelPair).obj s.pt).obj WalkingParallelPair.zero ⟶
    ((const WalkingParallelPair).obj (sndKernelFork c).pt).obj WalkingParallelPair.zero
hm : m✝ ≫ Fork.ι (sndKernelFork c) = Fork.ι s
⊢ m✝ = Fork.ι s ≫ c.fst
[PROOFSTEP]
simp [← hm]
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
P Q X Y : C
c : BinaryBicone X Y
i : IsColimit (toCocone c)
s : Cofork c.inl 0
⊢ Cofork.π (inlCokernelCofork c) ≫ c.inr ≫ Cofork.π s = Cofork.π s
[PROOFSTEP]
apply BinaryCofan.IsColimit.hom_ext i
[GOAL]
case h₁
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
P Q X Y : C
c : BinaryBicone X Y
i : IsColimit (toCocone c)
s : Cofork c.inl 0
⊢ BinaryCofan.inl (toCocone c) ≫ Cofork.π (inlCokernelCofork c) ≫ c.inr ≫ Cofork.π s =
    BinaryCofan.inl (toCocone c) ≫ Cofork.π s
[PROOFSTEP]
simp
[GOAL]
case h₂
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
P Q X Y : C
c : BinaryBicone X Y
i : IsColimit (toCocone c)
s : Cofork c.inl 0
⊢ BinaryCofan.inr (toCocone c) ≫ Cofork.π (inlCokernelCofork c) ≫ c.inr ≫ Cofork.π s =
    BinaryCofan.inr (toCocone c) ≫ Cofork.π s
[PROOFSTEP]
simp
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
P Q X Y : C
c : BinaryBicone X Y
i : IsColimit (toCocone c)
s : Cofork c.inl 0
m✝ :
  ((const WalkingParallelPair).obj (inlCokernelCofork c).pt).obj WalkingParallelPair.one ⟶
    ((const WalkingParallelPair).obj s.pt).obj WalkingParallelPair.one
hm : Cofork.π (inlCokernelCofork c) ≫ m✝ = Cofork.π s
⊢ m✝ = c.inr ≫ Cofork.π s
[PROOFSTEP]
simp [← hm]
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
P Q X Y : C
c : BinaryBicone X Y
i : IsColimit (toCocone c)
s : Cofork c.inr 0
⊢ Cofork.π (inrCokernelCofork c) ≫ c.inl ≫ Cofork.π s = Cofork.π s
[PROOFSTEP]
apply BinaryCofan.IsColimit.hom_ext i
[GOAL]
case h₁
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
P Q X Y : C
c : BinaryBicone X Y
i : IsColimit (toCocone c)
s : Cofork c.inr 0
⊢ BinaryCofan.inl (toCocone c) ≫ Cofork.π (inrCokernelCofork c) ≫ c.inl ≫ Cofork.π s =
    BinaryCofan.inl (toCocone c) ≫ Cofork.π s
[PROOFSTEP]
simp
[GOAL]
case h₂
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
P Q X Y : C
c : BinaryBicone X Y
i : IsColimit (toCocone c)
s : Cofork c.inr 0
⊢ BinaryCofan.inr (toCocone c) ≫ Cofork.π (inrCokernelCofork c) ≫ c.inl ≫ Cofork.π s =
    BinaryCofan.inr (toCocone c) ≫ Cofork.π s
[PROOFSTEP]
simp
[GOAL]
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
P Q X Y : C
c : BinaryBicone X Y
i : IsColimit (toCocone c)
s : Cofork c.inr 0
m✝ :
  ((const WalkingParallelPair).obj (inrCokernelCofork c).pt).obj WalkingParallelPair.one ⟶
    ((const WalkingParallelPair).obj s.pt).obj WalkingParallelPair.one
hm : Cofork.π (inrCokernelCofork c) ≫ m✝ = Cofork.π s
⊢ m✝ = c.inl ≫ Cofork.π s
[PROOFSTEP]
simp [← hm]
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
hY : IsZero Y
⊢ biprod.fst ≫ biprod.inl = 𝟙 (X ⊞ Y)
[PROOFSTEP]
apply CategoryTheory.Limits.biprod.hom_ext
[GOAL]
case h₀
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
hY : IsZero Y
⊢ (biprod.fst ≫ biprod.inl) ≫ biprod.fst = 𝟙 (X ⊞ Y) ≫ biprod.fst
[PROOFSTEP]
simp only [Category.assoc, biprod.inl_fst, Category.comp_id, Category.id_comp, biprod.inl_snd, comp_zero]
[GOAL]
case h₁
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
hY : IsZero Y
⊢ (biprod.fst ≫ biprod.inl) ≫ biprod.snd = 𝟙 (X ⊞ Y) ≫ biprod.snd
[PROOFSTEP]
simp only [Category.assoc, biprod.inl_fst, Category.comp_id, Category.id_comp, biprod.inl_snd, comp_zero]
[GOAL]
case h₁
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
hY : IsZero Y
⊢ 0 = biprod.snd
[PROOFSTEP]
apply hY.eq_of_tgt
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
hY : IsZero X
⊢ biprod.snd ≫ biprod.inr = 𝟙 (X ⊞ Y)
[PROOFSTEP]
apply CategoryTheory.Limits.biprod.hom_ext
[GOAL]
case h₀
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
hY : IsZero X
⊢ (biprod.snd ≫ biprod.inr) ≫ biprod.fst = 𝟙 (X ⊞ Y) ≫ biprod.fst
[PROOFSTEP]
simp only [Category.assoc, biprod.inr_snd, Category.comp_id, Category.id_comp, biprod.inr_fst, comp_zero]
[GOAL]
case h₁
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
hY : IsZero X
⊢ (biprod.snd ≫ biprod.inr) ≫ biprod.snd = 𝟙 (X ⊞ Y) ≫ biprod.snd
[PROOFSTEP]
simp only [Category.assoc, biprod.inr_snd, Category.comp_id, Category.id_comp, biprod.inr_fst, comp_zero]
[GOAL]
case h₀
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
hY : IsZero X
⊢ 0 = biprod.fst
[PROOFSTEP]
apply hY.eq_of_tgt
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P✝ Q✝ : C
inst✝ : HasBinaryBiproducts C
P Q : C
⊢ braiding' P Q = braiding P Q
[PROOFSTEP]
aesop_cat
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q : C
inst✝ : HasBinaryBiproducts C
W X Y Z : C
f : X ⟶ Y
g : Z ⟶ W
⊢ map f g ≫ (braiding Y W).hom = (braiding X Z).hom ≫ map g f
[PROOFSTEP]
aesop_cat
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P Q : C
inst✝ : HasBinaryBiproducts C
W X Y Z : C
f : W ⟶ Y
g : X ⟶ Z
⊢ (braiding X W).hom ≫ map f g ≫ (braiding Y Z).hom = map g f
[PROOFSTEP]
aesop_cat
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P✝ Q✝ : C
inst✝ : HasBinaryBiproducts C
P Q : C
⊢ lift snd fst ≫ lift snd fst = 𝟙 (P ⊞ Q)
[PROOFSTEP]
aesop_cat
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
P✝ Q✝ : C
inst✝ : HasBinaryBiproducts C
P Q : C
⊢ (braiding P Q).hom ≫ (braiding Q P).hom = 𝟙 (P ⊞ Q)
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasBinaryBiproducts C
W X Y Z : C
f : W ⟶ Y
g : X ⟶ Z
inst✝ : IsIso (biprod.map f g)
⊢ f ≫ biprod.inl ≫ inv (biprod.map f g) ≫ biprod.fst = 𝟙 W
[PROOFSTEP]
have t := congrArg (fun p : W ⊞ X ⟶ W ⊞ X => biprod.inl ≫ p ≫ biprod.fst) (IsIso.hom_inv_id (biprod.map f g))
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasBinaryBiproducts C
W X Y Z : C
f : W ⟶ Y
g : X ⟶ Z
inst✝ : IsIso (biprod.map f g)
t :
  (fun p => biprod.inl ≫ p ≫ biprod.fst) (biprod.map f g ≫ inv (biprod.map f g)) =
    (fun p => biprod.inl ≫ p ≫ biprod.fst) (𝟙 (W ⊞ X))
⊢ f ≫ biprod.inl ≫ inv (biprod.map f g) ≫ biprod.fst = 𝟙 W
[PROOFSTEP]
simp only [Category.id_comp, Category.assoc, biprod.inl_map_assoc] at t
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasBinaryBiproducts C
W X Y Z : C
f : W ⟶ Y
g : X ⟶ Z
inst✝ : IsIso (biprod.map f g)
t : f ≫ biprod.inl ≫ inv (biprod.map f g) ≫ biprod.fst = biprod.inl ≫ biprod.fst
⊢ f ≫ biprod.inl ≫ inv (biprod.map f g) ≫ biprod.fst = 𝟙 W
[PROOFSTEP]
simp [t]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasBinaryBiproducts C
W X Y Z : C
f : W ⟶ Y
g : X ⟶ Z
inst✝ : IsIso (biprod.map f g)
⊢ (biprod.inl ≫ inv (biprod.map f g) ≫ biprod.fst) ≫ f = 𝟙 Y
[PROOFSTEP]
have t := congrArg (fun p : Y ⊞ Z ⟶ Y ⊞ Z => biprod.inl ≫ p ≫ biprod.fst) (IsIso.inv_hom_id (biprod.map f g))
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasBinaryBiproducts C
W X Y Z : C
f : W ⟶ Y
g : X ⟶ Z
inst✝ : IsIso (biprod.map f g)
t :
  (fun p => biprod.inl ≫ p ≫ biprod.fst) (inv (biprod.map f g) ≫ biprod.map f g) =
    (fun p => biprod.inl ≫ p ≫ biprod.fst) (𝟙 (Y ⊞ Z))
⊢ (biprod.inl ≫ inv (biprod.map f g) ≫ biprod.fst) ≫ f = 𝟙 Y
[PROOFSTEP]
simp only [Category.id_comp, Category.assoc, biprod.map_fst] at t
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasBinaryBiproducts C
W X Y Z : C
f : W ⟶ Y
g : X ⟶ Z
inst✝ : IsIso (biprod.map f g)
t : biprod.inl ≫ inv (biprod.map f g) ≫ biprod.fst ≫ f = biprod.inl ≫ biprod.fst
⊢ (biprod.inl ≫ inv (biprod.map f g) ≫ biprod.fst) ≫ f = 𝟙 Y
[PROOFSTEP]
simp only [Category.assoc]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasBinaryBiproducts C
W X Y Z : C
f : W ⟶ Y
g : X ⟶ Z
inst✝ : IsIso (biprod.map f g)
t : biprod.inl ≫ inv (biprod.map f g) ≫ biprod.fst ≫ f = biprod.inl ≫ biprod.fst
⊢ biprod.inl ≫ inv (biprod.map f g) ≫ biprod.fst ≫ f = 𝟙 Y
[PROOFSTEP]
simp [t]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasBinaryBiproducts C
W X Y Z : C
f : W ⟶ Y
g : X ⟶ Z
inst✝ : IsIso (biprod.map f g)
⊢ IsIso (biprod.map g f)
[PROOFSTEP]
rw [← biprod.braiding_map_braiding]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasBinaryBiproducts C
W X Y Z : C
f : W ⟶ Y
g : X ⟶ Z
inst✝ : IsIso (biprod.map f g)
⊢ IsIso ((biprod.braiding X W).hom ≫ biprod.map f g ≫ (biprod.braiding Y Z).hom)
[PROOFSTEP]
infer_instance