l3lab/ntp-mathlib huggingface dataset:
@[simps]
instance Endofunctor.coalgebraPreadditive : Preadditive (Endofunctor.Coalgebra F) where
  homGroup A₁ A₂ :=
    { add := fun α β =>
        { f := α.f + β.f
          h := by simp only [Functor.map_add, comp_add, Endofunctor.Coalgebra.Hom.h, add_comp] }
      zero :=
        { f := 0
          h := by simp only [Functor.map_zero, zero_comp, comp_zero] }
      nsmul := fun n α =>
        { f := n • α.f
          h := by rw [Functor.map_nsmul, comp_nsmul, Endofunctor.Coalgebra.Hom.h, nsmul_comp] }
      neg := fun α =>
        { f := -α.f
          h := by simp only [Functor.map_neg, comp_neg, Endofunctor.Coalgebra.Hom.h, neg_comp] }
      sub := fun α β =>
        { f := α.f - β.f
          h := by simp only [Functor.map_sub, comp_sub, Endofunctor.Coalgebra.Hom.h, sub_comp] }
      zsmul := fun r α =>
        { f := r • α.f
          h := by rw [Functor.map_zsmul, comp_zsmul, Endofunctor.Coalgebra.Hom.h, zsmul_comp] }
      add_assoc := by
        intros
        apply Coalgebra.Hom.ext
        apply add_assoc
      zero_add := by
        intros
        apply Coalgebra.Hom.ext
        apply zero_add
      add_zero := by
        intros
        apply Coalgebra.Hom.ext
        apply add_zero
      nsmul_zero := by
        intros
        apply Coalgebra.Hom.ext
        apply zero_smul
      nsmul_succ := by
        intros
        apply Coalgebra.Hom.ext
        apply succ_nsmul
      sub_eq_add_neg := by
        intros
        apply Coalgebra.Hom.ext
        apply sub_eq_add_neg
      zsmul_zero' := by
        intros
        apply Coalgebra.Hom.ext
        apply zero_smul
      zsmul_succ' := by
        intros
        apply Coalgebra.Hom.ext
        dsimp
        simp only [coe_nat_zsmul, succ_nsmul]
        rfl
      zsmul_neg' := by
        intros
        apply Coalgebra.Hom.ext
        simp only [negSucc_zsmul, neg_inj, nsmul_eq_smul_cast ℤ]
      add_left_neg := by
        intros
        apply Coalgebra.Hom.ext
        apply add_left_neg
      add_comm := by
        

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Preadditive C
F : C ⥤ C
inst✝ : Functor.Additive F
A₁ A₂ : Coalgebra F
⊢ ∀ (a b : A₁ ⟶ A₂), a + b = b + a

Next tactic:
intros
@[simps]
instance Endofunctor.coalgebraPreadditive : Preadditive (Endofunctor.Coalgebra F) where
  homGroup A₁ A₂ :=
    { add := fun α β =>
        { f := α.f + β.f
          h := by simp only [Functor.map_add, comp_add, Endofunctor.Coalgebra.Hom.h, add_comp] }
      zero :=
        { f := 0
          h := by simp only [Functor.map_zero, zero_comp, comp_zero] }
      nsmul := fun n α =>
        { f := n • α.f
          h := by rw [Functor.map_nsmul, comp_nsmul, Endofunctor.Coalgebra.Hom.h, nsmul_comp] }
      neg := fun α =>
        { f := -α.f
          h := by simp only [Functor.map_neg, comp_neg, Endofunctor.Coalgebra.Hom.h, neg_comp] }
      sub := fun α β =>
        { f := α.f - β.f
          h := by simp only [Functor.map_sub, comp_sub, Endofunctor.Coalgebra.Hom.h, sub_comp] }
      zsmul := fun r α =>
        { f := r • α.f
          h := by rw [Functor.map_zsmul, comp_zsmul, Endofunctor.Coalgebra.Hom.h, zsmul_comp] }
      add_assoc := by
        intros
        apply Coalgebra.Hom.ext
        apply add_assoc
      zero_add := by
        intros
        apply Coalgebra.Hom.ext
        apply zero_add
      add_zero := by
        intros
        apply Coalgebra.Hom.ext
        apply add_zero
      nsmul_zero := by
        intros
        apply Coalgebra.Hom.ext
        apply zero_smul
      nsmul_succ := by
        intros
        apply Coalgebra.Hom.ext
        apply succ_nsmul
      sub_eq_add_neg := by
        intros
        apply Coalgebra.Hom.ext
        apply sub_eq_add_neg
      zsmul_zero' := by
        intros
        apply Coalgebra.Hom.ext
        apply zero_smul
      zsmul_succ' := by
        intros
        apply Coalgebra.Hom.ext
        dsimp
        simp only [coe_nat_zsmul, succ_nsmul]
        rfl
      zsmul_neg' := by
        intros
        apply Coalgebra.Hom.ext
        simp only [negSucc_zsmul, neg_inj, nsmul_eq_smul_cast ℤ]
      add_left_neg := by
        intros
        apply Coalgebra.Hom.ext
        apply add_left_neg
      add_comm := by
        intros
        

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Preadditive C
F : C ⥤ C
inst✝ : Functor.Additive F
A₁ A₂ : Coalgebra F
a✝ b✝ : A₁ ⟶ A₂
⊢ a✝ + b✝ = b✝ + a✝

Next tactic:
apply Coalgebra.Hom.ext
@[simps]
instance Endofunctor.coalgebraPreadditive : Preadditive (Endofunctor.Coalgebra F) where
  homGroup A₁ A₂ :=
    { add := fun α β =>
        { f := α.f + β.f
          h := by simp only [Functor.map_add, comp_add, Endofunctor.Coalgebra.Hom.h, add_comp] }
      zero :=
        { f := 0
          h := by simp only [Functor.map_zero, zero_comp, comp_zero] }
      nsmul := fun n α =>
        { f := n • α.f
          h := by rw [Functor.map_nsmul, comp_nsmul, Endofunctor.Coalgebra.Hom.h, nsmul_comp] }
      neg := fun α =>
        { f := -α.f
          h := by simp only [Functor.map_neg, comp_neg, Endofunctor.Coalgebra.Hom.h, neg_comp] }
      sub := fun α β =>
        { f := α.f - β.f
          h := by simp only [Functor.map_sub, comp_sub, Endofunctor.Coalgebra.Hom.h, sub_comp] }
      zsmul := fun r α =>
        { f := r • α.f
          h := by rw [Functor.map_zsmul, comp_zsmul, Endofunctor.Coalgebra.Hom.h, zsmul_comp] }
      add_assoc := by
        intros
        apply Coalgebra.Hom.ext
        apply add_assoc
      zero_add := by
        intros
        apply Coalgebra.Hom.ext
        apply zero_add
      add_zero := by
        intros
        apply Coalgebra.Hom.ext
        apply add_zero
      nsmul_zero := by
        intros
        apply Coalgebra.Hom.ext
        apply zero_smul
      nsmul_succ := by
        intros
        apply Coalgebra.Hom.ext
        apply succ_nsmul
      sub_eq_add_neg := by
        intros
        apply Coalgebra.Hom.ext
        apply sub_eq_add_neg
      zsmul_zero' := by
        intros
        apply Coalgebra.Hom.ext
        apply zero_smul
      zsmul_succ' := by
        intros
        apply Coalgebra.Hom.ext
        dsimp
        simp only [coe_nat_zsmul, succ_nsmul]
        rfl
      zsmul_neg' := by
        intros
        apply Coalgebra.Hom.ext
        simp only [negSucc_zsmul, neg_inj, nsmul_eq_smul_cast ℤ]
      add_left_neg := by
        intros
        apply Coalgebra.Hom.ext
        apply add_left_neg
      add_comm := by
        intros
        apply Coalgebra.Hom.ext
        

Proof state:
case f
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Preadditive C
F : C ⥤ C
inst✝ : Functor.Additive F
A₁ A₂ : Coalgebra F
a✝ b✝ : A₁ ⟶ A₂
⊢ (a✝ + b✝).f = (b✝ + a✝).f

Next tactic:
apply add_comm
@[simps]
instance Endofunctor.coalgebraPreadditive : Preadditive (Endofunctor.Coalgebra F) where
  homGroup A₁ A₂ :=
    { add := fun α β =>
        { f := α.f + β.f
          h := by simp only [Functor.map_add, comp_add, Endofunctor.Coalgebra.Hom.h, add_comp] }
      zero :=
        { f := 0
          h := by simp only [Functor.map_zero, zero_comp, comp_zero] }
      nsmul := fun n α =>
        { f := n • α.f
          h := by rw [Functor.map_nsmul, comp_nsmul, Endofunctor.Coalgebra.Hom.h, nsmul_comp] }
      neg := fun α =>
        { f := -α.f
          h := by simp only [Functor.map_neg, comp_neg, Endofunctor.Coalgebra.Hom.h, neg_comp] }
      sub := fun α β =>
        { f := α.f - β.f
          h := by simp only [Functor.map_sub, comp_sub, Endofunctor.Coalgebra.Hom.h, sub_comp] }
      zsmul := fun r α =>
        { f := r • α.f
          h := by rw [Functor.map_zsmul, comp_zsmul, Endofunctor.Coalgebra.Hom.h, zsmul_comp] }
      add_assoc := by
        intros
        apply Coalgebra.Hom.ext
        apply add_assoc
      zero_add := by
        intros
        apply Coalgebra.Hom.ext
        apply zero_add
      add_zero := by
        intros
        apply Coalgebra.Hom.ext
        apply add_zero
      nsmul_zero := by
        intros
        apply Coalgebra.Hom.ext
        apply zero_smul
      nsmul_succ := by
        intros
        apply Coalgebra.Hom.ext
        apply succ_nsmul
      sub_eq_add_neg := by
        intros
        apply Coalgebra.Hom.ext
        apply sub_eq_add_neg
      zsmul_zero' := by
        intros
        apply Coalgebra.Hom.ext
        apply zero_smul
      zsmul_succ' := by
        intros
        apply Coalgebra.Hom.ext
        dsimp
        simp only [coe_nat_zsmul, succ_nsmul]
        rfl
      zsmul_neg' := by
        intros
        apply Coalgebra.Hom.ext
        simp only [negSucc_zsmul, neg_inj, nsmul_eq_smul_cast ℤ]
      add_left_neg := by
        intros
        apply Coalgebra.Hom.ext
        apply add_left_neg
      add_comm := by
        intros
        apply Coalgebra.Hom.ext
        apply add_comm }
  add_comp := by
    

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Preadditive C
F : C ⥤ C
inst✝ : Functor.Additive F
⊢ ∀ (P Q R : Coalgebra F) (f f' : P ⟶ Q) (g : Q ⟶ R), (f + f') ≫ g = f ≫ g + f' ≫ g

Next tactic:
intros
@[simps]
instance Endofunctor.coalgebraPreadditive : Preadditive (Endofunctor.Coalgebra F) where
  homGroup A₁ A₂ :=
    { add := fun α β =>
        { f := α.f + β.f
          h := by simp only [Functor.map_add, comp_add, Endofunctor.Coalgebra.Hom.h, add_comp] }
      zero :=
        { f := 0
          h := by simp only [Functor.map_zero, zero_comp, comp_zero] }
      nsmul := fun n α =>
        { f := n • α.f
          h := by rw [Functor.map_nsmul, comp_nsmul, Endofunctor.Coalgebra.Hom.h, nsmul_comp] }
      neg := fun α =>
        { f := -α.f
          h := by simp only [Functor.map_neg, comp_neg, Endofunctor.Coalgebra.Hom.h, neg_comp] }
      sub := fun α β =>
        { f := α.f - β.f
          h := by simp only [Functor.map_sub, comp_sub, Endofunctor.Coalgebra.Hom.h, sub_comp] }
      zsmul := fun r α =>
        { f := r • α.f
          h := by rw [Functor.map_zsmul, comp_zsmul, Endofunctor.Coalgebra.Hom.h, zsmul_comp] }
      add_assoc := by
        intros
        apply Coalgebra.Hom.ext
        apply add_assoc
      zero_add := by
        intros
        apply Coalgebra.Hom.ext
        apply zero_add
      add_zero := by
        intros
        apply Coalgebra.Hom.ext
        apply add_zero
      nsmul_zero := by
        intros
        apply Coalgebra.Hom.ext
        apply zero_smul
      nsmul_succ := by
        intros
        apply Coalgebra.Hom.ext
        apply succ_nsmul
      sub_eq_add_neg := by
        intros
        apply Coalgebra.Hom.ext
        apply sub_eq_add_neg
      zsmul_zero' := by
        intros
        apply Coalgebra.Hom.ext
        apply zero_smul
      zsmul_succ' := by
        intros
        apply Coalgebra.Hom.ext
        dsimp
        simp only [coe_nat_zsmul, succ_nsmul]
        rfl
      zsmul_neg' := by
        intros
        apply Coalgebra.Hom.ext
        simp only [negSucc_zsmul, neg_inj, nsmul_eq_smul_cast ℤ]
      add_left_neg := by
        intros
        apply Coalgebra.Hom.ext
        apply add_left_neg
      add_comm := by
        intros
        apply Coalgebra.Hom.ext
        apply add_comm }
  add_comp := by
    intros
    

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Preadditive C
F : C ⥤ C
inst✝ : Functor.Additive F
P✝ Q✝ R✝ : Coalgebra F
f✝ f'✝ : P✝ ⟶ Q✝
g✝ : Q✝ ⟶ R✝
⊢ (f✝ + f'✝) ≫ g✝ = f✝ ≫ g✝ + f'✝ ≫ g✝

Next tactic:
apply Coalgebra.Hom.ext
@[simps]
instance Endofunctor.coalgebraPreadditive : Preadditive (Endofunctor.Coalgebra F) where
  homGroup A₁ A₂ :=
    { add := fun α β =>
        { f := α.f + β.f
          h := by simp only [Functor.map_add, comp_add, Endofunctor.Coalgebra.Hom.h, add_comp] }
      zero :=
        { f := 0
          h := by simp only [Functor.map_zero, zero_comp, comp_zero] }
      nsmul := fun n α =>
        { f := n • α.f
          h := by rw [Functor.map_nsmul, comp_nsmul, Endofunctor.Coalgebra.Hom.h, nsmul_comp] }
      neg := fun α =>
        { f := -α.f
          h := by simp only [Functor.map_neg, comp_neg, Endofunctor.Coalgebra.Hom.h, neg_comp] }
      sub := fun α β =>
        { f := α.f - β.f
          h := by simp only [Functor.map_sub, comp_sub, Endofunctor.Coalgebra.Hom.h, sub_comp] }
      zsmul := fun r α =>
        { f := r • α.f
          h := by rw [Functor.map_zsmul, comp_zsmul, Endofunctor.Coalgebra.Hom.h, zsmul_comp] }
      add_assoc := by
        intros
        apply Coalgebra.Hom.ext
        apply add_assoc
      zero_add := by
        intros
        apply Coalgebra.Hom.ext
        apply zero_add
      add_zero := by
        intros
        apply Coalgebra.Hom.ext
        apply add_zero
      nsmul_zero := by
        intros
        apply Coalgebra.Hom.ext
        apply zero_smul
      nsmul_succ := by
        intros
        apply Coalgebra.Hom.ext
        apply succ_nsmul
      sub_eq_add_neg := by
        intros
        apply Coalgebra.Hom.ext
        apply sub_eq_add_neg
      zsmul_zero' := by
        intros
        apply Coalgebra.Hom.ext
        apply zero_smul
      zsmul_succ' := by
        intros
        apply Coalgebra.Hom.ext
        dsimp
        simp only [coe_nat_zsmul, succ_nsmul]
        rfl
      zsmul_neg' := by
        intros
        apply Coalgebra.Hom.ext
        simp only [negSucc_zsmul, neg_inj, nsmul_eq_smul_cast ℤ]
      add_left_neg := by
        intros
        apply Coalgebra.Hom.ext
        apply add_left_neg
      add_comm := by
        intros
        apply Coalgebra.Hom.ext
        apply add_comm }
  add_comp := by
    intros
    apply Coalgebra.Hom.ext
    

Proof state:
case f
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Preadditive C
F : C ⥤ C
inst✝ : Functor.Additive F
P✝ Q✝ R✝ : Coalgebra F
f✝ f'✝ : P✝ ⟶ Q✝
g✝ : Q✝ ⟶ R✝
⊢ ((f✝ + f'✝) ≫ g✝).f = (f✝ ≫ g✝ + f'✝ ≫ g✝).f

Next tactic:
apply add_comp
@[simps]
instance Endofunctor.coalgebraPreadditive : Preadditive (Endofunctor.Coalgebra F) where
  homGroup A₁ A₂ :=
    { add := fun α β =>
        { f := α.f + β.f
          h := by simp only [Functor.map_add, comp_add, Endofunctor.Coalgebra.Hom.h, add_comp] }
      zero :=
        { f := 0
          h := by simp only [Functor.map_zero, zero_comp, comp_zero] }
      nsmul := fun n α =>
        { f := n • α.f
          h := by rw [Functor.map_nsmul, comp_nsmul, Endofunctor.Coalgebra.Hom.h, nsmul_comp] }
      neg := fun α =>
        { f := -α.f
          h := by simp only [Functor.map_neg, comp_neg, Endofunctor.Coalgebra.Hom.h, neg_comp] }
      sub := fun α β =>
        { f := α.f - β.f
          h := by simp only [Functor.map_sub, comp_sub, Endofunctor.Coalgebra.Hom.h, sub_comp] }
      zsmul := fun r α =>
        { f := r • α.f
          h := by rw [Functor.map_zsmul, comp_zsmul, Endofunctor.Coalgebra.Hom.h, zsmul_comp] }
      add_assoc := by
        intros
        apply Coalgebra.Hom.ext
        apply add_assoc
      zero_add := by
        intros
        apply Coalgebra.Hom.ext
        apply zero_add
      add_zero := by
        intros
        apply Coalgebra.Hom.ext
        apply add_zero
      nsmul_zero := by
        intros
        apply Coalgebra.Hom.ext
        apply zero_smul
      nsmul_succ := by
        intros
        apply Coalgebra.Hom.ext
        apply succ_nsmul
      sub_eq_add_neg := by
        intros
        apply Coalgebra.Hom.ext
        apply sub_eq_add_neg
      zsmul_zero' := by
        intros
        apply Coalgebra.Hom.ext
        apply zero_smul
      zsmul_succ' := by
        intros
        apply Coalgebra.Hom.ext
        dsimp
        simp only [coe_nat_zsmul, succ_nsmul]
        rfl
      zsmul_neg' := by
        intros
        apply Coalgebra.Hom.ext
        simp only [negSucc_zsmul, neg_inj, nsmul_eq_smul_cast ℤ]
      add_left_neg := by
        intros
        apply Coalgebra.Hom.ext
        apply add_left_neg
      add_comm := by
        intros
        apply Coalgebra.Hom.ext
        apply add_comm }
  add_comp := by
    intros
    apply Coalgebra.Hom.ext
    apply add_comp
  comp_add := by
    

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Preadditive C
F : C ⥤ C
inst✝ : Functor.Additive F
⊢ ∀ (P Q R : Coalgebra F) (f : P ⟶ Q) (g g' : Q ⟶ R), f ≫ (g + g') = f ≫ g + f ≫ g'

Next tactic:
intros
@[simps]
instance Endofunctor.coalgebraPreadditive : Preadditive (Endofunctor.Coalgebra F) where
  homGroup A₁ A₂ :=
    { add := fun α β =>
        { f := α.f + β.f
          h := by simp only [Functor.map_add, comp_add, Endofunctor.Coalgebra.Hom.h, add_comp] }
      zero :=
        { f := 0
          h := by simp only [Functor.map_zero, zero_comp, comp_zero] }
      nsmul := fun n α =>
        { f := n • α.f
          h := by rw [Functor.map_nsmul, comp_nsmul, Endofunctor.Coalgebra.Hom.h, nsmul_comp] }
      neg := fun α =>
        { f := -α.f
          h := by simp only [Functor.map_neg, comp_neg, Endofunctor.Coalgebra.Hom.h, neg_comp] }
      sub := fun α β =>
        { f := α.f - β.f
          h := by simp only [Functor.map_sub, comp_sub, Endofunctor.Coalgebra.Hom.h, sub_comp] }
      zsmul := fun r α =>
        { f := r • α.f
          h := by rw [Functor.map_zsmul, comp_zsmul, Endofunctor.Coalgebra.Hom.h, zsmul_comp] }
      add_assoc := by
        intros
        apply Coalgebra.Hom.ext
        apply add_assoc
      zero_add := by
        intros
        apply Coalgebra.Hom.ext
        apply zero_add
      add_zero := by
        intros
        apply Coalgebra.Hom.ext
        apply add_zero
      nsmul_zero := by
        intros
        apply Coalgebra.Hom.ext
        apply zero_smul
      nsmul_succ := by
        intros
        apply Coalgebra.Hom.ext
        apply succ_nsmul
      sub_eq_add_neg := by
        intros
        apply Coalgebra.Hom.ext
        apply sub_eq_add_neg
      zsmul_zero' := by
        intros
        apply Coalgebra.Hom.ext
        apply zero_smul
      zsmul_succ' := by
        intros
        apply Coalgebra.Hom.ext
        dsimp
        simp only [coe_nat_zsmul, succ_nsmul]
        rfl
      zsmul_neg' := by
        intros
        apply Coalgebra.Hom.ext
        simp only [negSucc_zsmul, neg_inj, nsmul_eq_smul_cast ℤ]
      add_left_neg := by
        intros
        apply Coalgebra.Hom.ext
        apply add_left_neg
      add_comm := by
        intros
        apply Coalgebra.Hom.ext
        apply add_comm }
  add_comp := by
    intros
    apply Coalgebra.Hom.ext
    apply add_comp
  comp_add := by
    intros
    

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Preadditive C
F : C ⥤ C
inst✝ : Functor.Additive F
P✝ Q✝ R✝ : Coalgebra F
f✝ : P✝ ⟶ Q✝
g✝ g'✝ : Q✝ ⟶ R✝
⊢ f✝ ≫ (g✝ + g'✝) = f✝ ≫ g✝ + f✝ ≫ g'✝

Next tactic:
apply Coalgebra.Hom.ext
@[simps]
instance Endofunctor.coalgebraPreadditive : Preadditive (Endofunctor.Coalgebra F) where
  homGroup A₁ A₂ :=
    { add := fun α β =>
        { f := α.f + β.f
          h := by simp only [Functor.map_add, comp_add, Endofunctor.Coalgebra.Hom.h, add_comp] }
      zero :=
        { f := 0
          h := by simp only [Functor.map_zero, zero_comp, comp_zero] }
      nsmul := fun n α =>
        { f := n • α.f
          h := by rw [Functor.map_nsmul, comp_nsmul, Endofunctor.Coalgebra.Hom.h, nsmul_comp] }
      neg := fun α =>
        { f := -α.f
          h := by simp only [Functor.map_neg, comp_neg, Endofunctor.Coalgebra.Hom.h, neg_comp] }
      sub := fun α β =>
        { f := α.f - β.f
          h := by simp only [Functor.map_sub, comp_sub, Endofunctor.Coalgebra.Hom.h, sub_comp] }
      zsmul := fun r α =>
        { f := r • α.f
          h := by rw [Functor.map_zsmul, comp_zsmul, Endofunctor.Coalgebra.Hom.h, zsmul_comp] }
      add_assoc := by
        intros
        apply Coalgebra.Hom.ext
        apply add_assoc
      zero_add := by
        intros
        apply Coalgebra.Hom.ext
        apply zero_add
      add_zero := by
        intros
        apply Coalgebra.Hom.ext
        apply add_zero
      nsmul_zero := by
        intros
        apply Coalgebra.Hom.ext
        apply zero_smul
      nsmul_succ := by
        intros
        apply Coalgebra.Hom.ext
        apply succ_nsmul
      sub_eq_add_neg := by
        intros
        apply Coalgebra.Hom.ext
        apply sub_eq_add_neg
      zsmul_zero' := by
        intros
        apply Coalgebra.Hom.ext
        apply zero_smul
      zsmul_succ' := by
        intros
        apply Coalgebra.Hom.ext
        dsimp
        simp only [coe_nat_zsmul, succ_nsmul]
        rfl
      zsmul_neg' := by
        intros
        apply Coalgebra.Hom.ext
        simp only [negSucc_zsmul, neg_inj, nsmul_eq_smul_cast ℤ]
      add_left_neg := by
        intros
        apply Coalgebra.Hom.ext
        apply add_left_neg
      add_comm := by
        intros
        apply Coalgebra.Hom.ext
        apply add_comm }
  add_comp := by
    intros
    apply Coalgebra.Hom.ext
    apply add_comp
  comp_add := by
    intros
    apply Coalgebra.Hom.ext
    

Proof state:
case f
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Preadditive C
F : C ⥤ C
inst✝ : Functor.Additive F
P✝ Q✝ R✝ : Coalgebra F
f✝ : P✝ ⟶ Q✝
g✝ g'✝ : Q✝ ⟶ R✝
⊢ (f✝ ≫ (g✝ + g'✝)).f = (f✝ ≫ g✝ + f✝ ≫ g'✝).f

Next tactic:
apply comp_add
/-- The definition of the "one" in the colimit is independent of the chosen object of `J`.
In particular, this lemma allows us to "unfold" the definition of `colimit_one` at a custom chosen
object `j`.
-/
@[to_additive
      "The definition of the \"zero\" in the colimit is independent of the chosen object
      of `J`. In particular, this lemma allows us to \"unfold\" the definition of `colimit_zero` at
      a custom chosen object `j`."]
theorem colimit_one_eq (j : J) : (1 : M.{v, u} F) = M.mk F ⟨j, 1⟩ := by
  

Proof state:
J : Type v
inst✝¹ : SmallCategory J
F : J ⥤ MonCat
inst✝ : IsFiltered J
j : J
⊢ 1 = M.mk F { fst := j, snd := 1 }

Next tactic:
apply M.mk_eq
/-- The definition of the "one" in the colimit is independent of the chosen object of `J`.
In particular, this lemma allows us to "unfold" the definition of `colimit_one` at a custom chosen
object `j`.
-/
@[to_additive
      "The definition of the \"zero\" in the colimit is independent of the chosen object
      of `J`. In particular, this lemma allows us to \"unfold\" the definition of `colimit_zero` at
      a custom chosen object `j`."]
theorem colimit_one_eq (j : J) : (1 : M.{v, u} F) = M.mk F ⟨j, 1⟩ := by
  apply M.mk_eq
  

Proof state:
case h
J : Type v
inst✝¹ : SmallCategory J
F : J ⥤ MonCat
inst✝ : IsFiltered J
j : J
⊢ ∃ k f g, (F.map f) { fst := Nonempty.some (_ : Nonempty J), snd := 1 }.snd = (F.map g) { fst := j, snd := 1 }.snd

Next tactic:
refine' ⟨max' _ j, IsFiltered.leftToMax _ j, IsFiltered.rightToMax _ j, _⟩
/-- The definition of the "one" in the colimit is independent of the chosen object of `J`.
In particular, this lemma allows us to "unfold" the definition of `colimit_one` at a custom chosen
object `j`.
-/
@[to_additive
      "The definition of the \"zero\" in the colimit is independent of the chosen object
      of `J`. In particular, this lemma allows us to \"unfold\" the definition of `colimit_zero` at
      a custom chosen object `j`."]
theorem colimit_one_eq (j : J) : (1 : M.{v, u} F) = M.mk F ⟨j, 1⟩ := by
  apply M.mk_eq
  refine' ⟨max' _ j, IsFiltered.leftToMax _ j, IsFiltered.rightToMax _ j, _⟩
  

Proof state:
case h
J : Type v
inst✝¹ : SmallCategory J
F : J ⥤ MonCat
inst✝ : IsFiltered J
j : J
⊢ (F.map (IsFiltered.leftToMax { fst := Nonempty.some (_ : Nonempty J), snd := 1 }.fst j))
      { fst := Nonempty.some (_ : Nonempty J), snd := 1 }.snd =
    (F.map (IsFiltered.rightToMax { fst := Nonempty.some (_ : Nonempty J), snd := 1 }.fst j)) { fst := j, snd := 1 }.snd

Next tactic:
simp
/-- Multiplication in the colimit is well-defined in the left argument. -/
@[to_additive "Addition in the colimit is well-defined in the left argument."]
theorem colimitMulAux_eq_of_rel_left {x x' y : Σ j, F.obj j}
    (hxx' : Types.FilteredColimit.Rel.{v, u} (F ⋙ forget MonCat) x x') :
    colimitMulAux.{v, u} F x y = colimitMulAux.{v, u} F x' y := by
  

Proof state:
J : Type v
inst✝¹ : SmallCategory J
F : J ⥤ MonCat
inst✝ : IsFiltered J
x x' y : (j : J) × ↑(F.obj j)
hxx' : Types.FilteredColimit.Rel (F ⋙ forget MonCat) x x'
⊢ colimitMulAux F x y = colimitMulAux F x' y

Next tactic:
cases' x with j₁ x