l3lab/ntp-mathlib huggingface dataset:
/-- A cocone in `HomologicalComplex C c` is colimit if the induced cocones obtained
by applying `eval C c i : HomologicalComplex C c ⥤ C` for all `i` are colimit. -/
def isColimitOfEval (s : Cocone F)
    (hs : ∀ (i : ι), IsColimit ((eval C c i).mapCocone s)) : IsColimit s where
  desc t :=
    { f := fun i => (hs i).desc ((eval C c i).mapCocone t)
      comm' := fun i i' _ => by
        apply IsColimit.hom_ext (hs i)
        intro j
        

Proof state:
C : Type u_1
ι : Type u_2
J : Type u_3
inst✝² : Category.{?u.39790, u_1} C
inst✝¹ : Category.{?u.39794, u_3} J
c : ComplexShape ι
inst✝ : HasZeroMorphisms C
F : J ⥤ HomologicalComplex C c
s : Cocone F
hs : (i : ι) → IsColimit ((eval C c i).mapCocone s)
t : Cocone F
i i' : ι
x✝ : ComplexShape.Rel c i i'
j : J
⊢ ((eval C c i).mapCocone s).ι.app j ≫ (fun i => IsColimit.desc (hs i) ((eval C c i).mapCocone t)) i ≫ d t.pt i i' =
    ((eval C c i).mapCocone s).ι.app j ≫ d s.pt i i' ≫ (fun i => IsColimit.desc (hs i) ((eval C c i).mapCocone t)) i'

Next tactic:
have eq := fun k => (hs k).fac ((eval C c k).mapCocone t)
/-- A cocone in `HomologicalComplex C c` is colimit if the induced cocones obtained
by applying `eval C c i : HomologicalComplex C c ⥤ C` for all `i` are colimit. -/
def isColimitOfEval (s : Cocone F)
    (hs : ∀ (i : ι), IsColimit ((eval C c i).mapCocone s)) : IsColimit s where
  desc t :=
    { f := fun i => (hs i).desc ((eval C c i).mapCocone t)
      comm' := fun i i' _ => by
        apply IsColimit.hom_ext (hs i)
        intro j
        have eq := fun k => (hs k).fac ((eval C c k).mapCocone t)
        

Proof state:
C : Type u_1
ι : Type u_2
J : Type u_3
inst✝² : Category.{?u.39790, u_1} C
inst✝¹ : Category.{?u.39794, u_3} J
c : ComplexShape ι
inst✝ : HasZeroMorphisms C
F : J ⥤ HomologicalComplex C c
s : Cocone F
hs : (i : ι) → IsColimit ((eval C c i).mapCocone s)
t : Cocone F
i i' : ι
x✝ : ComplexShape.Rel c i i'
j : J
eq :
  ∀ (k : ι) (j : J),
    ((eval C c k).mapCocone s).ι.app j ≫ IsColimit.desc (hs k) ((eval C c k).mapCocone t) =
      ((eval C c k).mapCocone t).ι.app j
⊢ ((eval C c i).mapCocone s).ι.app j ≫ (fun i => IsColimit.desc (hs i) ((eval C c i).mapCocone t)) i ≫ d t.pt i i' =
    ((eval C c i).mapCocone s).ι.app j ≫ d s.pt i i' ≫ (fun i => IsColimit.desc (hs i) ((eval C c i).mapCocone t)) i'

Next tactic:
simp only [Functor.mapCocone_ι_app, eval_map] at eq
/-- A cocone in `HomologicalComplex C c` is colimit if the induced cocones obtained
by applying `eval C c i : HomologicalComplex C c ⥤ C` for all `i` are colimit. -/
def isColimitOfEval (s : Cocone F)
    (hs : ∀ (i : ι), IsColimit ((eval C c i).mapCocone s)) : IsColimit s where
  desc t :=
    { f := fun i => (hs i).desc ((eval C c i).mapCocone t)
      comm' := fun i i' _ => by
        apply IsColimit.hom_ext (hs i)
        intro j
        have eq := fun k => (hs k).fac ((eval C c k).mapCocone t)
        simp only [Functor.mapCocone_ι_app, eval_map] at eq
        

Proof state:
C : Type u_1
ι : Type u_2
J : Type u_3
inst✝² : Category.{?u.39790, u_1} C
inst✝¹ : Category.{?u.39794, u_3} J
c : ComplexShape ι
inst✝ : HasZeroMorphisms C
F : J ⥤ HomologicalComplex C c
s : Cocone F
hs : (i : ι) → IsColimit ((eval C c i).mapCocone s)
t : Cocone F
i i' : ι
x✝ : ComplexShape.Rel c i i'
j : J
eq : ∀ (k : ι) (j : J), Hom.f (s.ι.app j) k ≫ IsColimit.desc (hs k) ((eval C c k).mapCocone t) = Hom.f (t.ι.app j) k
⊢ ((eval C c i).mapCocone s).ι.app j ≫ (fun i => IsColimit.desc (hs i) ((eval C c i).mapCocone t)) i ≫ d t.pt i i' =
    ((eval C c i).mapCocone s).ι.app j ≫ d s.pt i i' ≫ (fun i => IsColimit.desc (hs i) ((eval C c i).mapCocone t)) i'

Next tactic:
simp only [Functor.mapCocone_ι_app, eval_map, assoc]
/-- A cocone in `HomologicalComplex C c` is colimit if the induced cocones obtained
by applying `eval C c i : HomologicalComplex C c ⥤ C` for all `i` are colimit. -/
def isColimitOfEval (s : Cocone F)
    (hs : ∀ (i : ι), IsColimit ((eval C c i).mapCocone s)) : IsColimit s where
  desc t :=
    { f := fun i => (hs i).desc ((eval C c i).mapCocone t)
      comm' := fun i i' _ => by
        apply IsColimit.hom_ext (hs i)
        intro j
        have eq := fun k => (hs k).fac ((eval C c k).mapCocone t)
        simp only [Functor.mapCocone_ι_app, eval_map] at eq
        simp only [Functor.mapCocone_ι_app, eval_map, assoc]
        

Proof state:
C : Type u_1
ι : Type u_2
J : Type u_3
inst✝² : Category.{?u.39790, u_1} C
inst✝¹ : Category.{?u.39794, u_3} J
c : ComplexShape ι
inst✝ : HasZeroMorphisms C
F : J ⥤ HomologicalComplex C c
s : Cocone F
hs : (i : ι) → IsColimit ((eval C c i).mapCocone s)
t : Cocone F
i i' : ι
x✝ : ComplexShape.Rel c i i'
j : J
eq : ∀ (k : ι) (j : J), Hom.f (s.ι.app j) k ≫ IsColimit.desc (hs k) ((eval C c k).mapCocone t) = Hom.f (t.ι.app j) k
⊢ Hom.f (s.ι.app j) i ≫ IsColimit.desc (hs i) ((eval C c i).mapCocone t) ≫ d t.pt i i' =
    Hom.f (s.ι.app j) i ≫ d s.pt i i' ≫ IsColimit.desc (hs i') ((eval C c i').mapCocone t)

Next tactic:
rw [reassoc_of% (eq i), Hom.comm_assoc, eq i', Hom.comm]
/-- A cocone in `HomologicalComplex C c` is colimit if the induced cocones obtained
by applying `eval C c i : HomologicalComplex C c ⥤ C` for all `i` are colimit. -/
def isColimitOfEval (s : Cocone F)
    (hs : ∀ (i : ι), IsColimit ((eval C c i).mapCocone s)) : IsColimit s where
  desc t :=
    { f := fun i => (hs i).desc ((eval C c i).mapCocone t)
      comm' := fun i i' _ => by
        apply IsColimit.hom_ext (hs i)
        intro j
        have eq := fun k => (hs k).fac ((eval C c k).mapCocone t)
        simp only [Functor.mapCocone_ι_app, eval_map] at eq
        simp only [Functor.mapCocone_ι_app, eval_map, assoc]
        rw [reassoc_of% (eq i), Hom.comm_assoc, eq i', Hom.comm] }
  fac t j := by
    

Proof state:
C : Type u_1
ι : Type u_2
J : Type u_3
inst✝² : Category.{?u.39790, u_1} C
inst✝¹ : Category.{?u.39794, u_3} J
c : ComplexShape ι
inst✝ : HasZeroMorphisms C
F : J ⥤ HomologicalComplex C c
s : Cocone F
hs : (i : ι) → IsColimit ((eval C c i).mapCocone s)
t : Cocone F
j : J
⊢ s.ι.app j ≫ (fun t => Hom.mk fun i => IsColimit.desc (hs i) ((eval C c i).mapCocone t)) t = t.ι.app j

Next tactic:
ext i
/-- A cocone in `HomologicalComplex C c` is colimit if the induced cocones obtained
by applying `eval C c i : HomologicalComplex C c ⥤ C` for all `i` are colimit. -/
def isColimitOfEval (s : Cocone F)
    (hs : ∀ (i : ι), IsColimit ((eval C c i).mapCocone s)) : IsColimit s where
  desc t :=
    { f := fun i => (hs i).desc ((eval C c i).mapCocone t)
      comm' := fun i i' _ => by
        apply IsColimit.hom_ext (hs i)
        intro j
        have eq := fun k => (hs k).fac ((eval C c k).mapCocone t)
        simp only [Functor.mapCocone_ι_app, eval_map] at eq
        simp only [Functor.mapCocone_ι_app, eval_map, assoc]
        rw [reassoc_of% (eq i), Hom.comm_assoc, eq i', Hom.comm] }
  fac t j := by
    ext i
    

Proof state:
case h
C : Type u_1
ι : Type u_2
J : Type u_3
inst✝² : Category.{?u.39790, u_1} C
inst✝¹ : Category.{?u.39794, u_3} J
c : ComplexShape ι
inst✝ : HasZeroMorphisms C
F : J ⥤ HomologicalComplex C c
s : Cocone F
hs : (i : ι) → IsColimit ((eval C c i).mapCocone s)
t : Cocone F
j : J
i : ι
⊢ Hom.f (s.ι.app j ≫ (fun t => Hom.mk fun i => IsColimit.desc (hs i) ((eval C c i).mapCocone t)) t) i =
    Hom.f (t.ι.app j) i

Next tactic:
apply (hs i).fac
/-- A cocone in `HomologicalComplex C c` is colimit if the induced cocones obtained
by applying `eval C c i : HomologicalComplex C c ⥤ C` for all `i` are colimit. -/
def isColimitOfEval (s : Cocone F)
    (hs : ∀ (i : ι), IsColimit ((eval C c i).mapCocone s)) : IsColimit s where
  desc t :=
    { f := fun i => (hs i).desc ((eval C c i).mapCocone t)
      comm' := fun i i' _ => by
        apply IsColimit.hom_ext (hs i)
        intro j
        have eq := fun k => (hs k).fac ((eval C c k).mapCocone t)
        simp only [Functor.mapCocone_ι_app, eval_map] at eq
        simp only [Functor.mapCocone_ι_app, eval_map, assoc]
        rw [reassoc_of% (eq i), Hom.comm_assoc, eq i', Hom.comm] }
  fac t j := by
    ext i
    apply (hs i).fac
  uniq t m hm := by
    

Proof state:
C : Type u_1
ι : Type u_2
J : Type u_3
inst✝² : Category.{?u.39790, u_1} C
inst✝¹ : Category.{?u.39794, u_3} J
c : ComplexShape ι
inst✝ : HasZeroMorphisms C
F : J ⥤ HomologicalComplex C c
s : Cocone F
hs : (i : ι) → IsColimit ((eval C c i).mapCocone s)
t : Cocone F
m : s.pt ⟶ t.pt
hm : ∀ (j : J), s.ι.app j ≫ m = t.ι.app j
⊢ m = (fun t => Hom.mk fun i => IsColimit.desc (hs i) ((eval C c i).mapCocone t)) t

Next tactic:
ext i
/-- A cocone in `HomologicalComplex C c` is colimit if the induced cocones obtained
by applying `eval C c i : HomologicalComplex C c ⥤ C` for all `i` are colimit. -/
def isColimitOfEval (s : Cocone F)
    (hs : ∀ (i : ι), IsColimit ((eval C c i).mapCocone s)) : IsColimit s where
  desc t :=
    { f := fun i => (hs i).desc ((eval C c i).mapCocone t)
      comm' := fun i i' _ => by
        apply IsColimit.hom_ext (hs i)
        intro j
        have eq := fun k => (hs k).fac ((eval C c k).mapCocone t)
        simp only [Functor.mapCocone_ι_app, eval_map] at eq
        simp only [Functor.mapCocone_ι_app, eval_map, assoc]
        rw [reassoc_of% (eq i), Hom.comm_assoc, eq i', Hom.comm] }
  fac t j := by
    ext i
    apply (hs i).fac
  uniq t m hm := by
    ext i
    

Proof state:
case h
C : Type u_1
ι : Type u_2
J : Type u_3
inst✝² : Category.{?u.39790, u_1} C
inst✝¹ : Category.{?u.39794, u_3} J
c : ComplexShape ι
inst✝ : HasZeroMorphisms C
F : J ⥤ HomologicalComplex C c
s : Cocone F
hs : (i : ι) → IsColimit ((eval C c i).mapCocone s)
t : Cocone F
m : s.pt ⟶ t.pt
hm : ∀ (j : J), s.ι.app j ≫ m = t.ι.app j
i : ι
⊢ Hom.f m i = Hom.f ((fun t => Hom.mk fun i => IsColimit.desc (hs i) ((eval C c i).mapCocone t)) t) i

Next tactic:
apply (hs i).uniq ((eval C c i).mapCocone t)
/-- A cocone in `HomologicalComplex C c` is colimit if the induced cocones obtained
by applying `eval C c i : HomologicalComplex C c ⥤ C` for all `i` are colimit. -/
def isColimitOfEval (s : Cocone F)
    (hs : ∀ (i : ι), IsColimit ((eval C c i).mapCocone s)) : IsColimit s where
  desc t :=
    { f := fun i => (hs i).desc ((eval C c i).mapCocone t)
      comm' := fun i i' _ => by
        apply IsColimit.hom_ext (hs i)
        intro j
        have eq := fun k => (hs k).fac ((eval C c k).mapCocone t)
        simp only [Functor.mapCocone_ι_app, eval_map] at eq
        simp only [Functor.mapCocone_ι_app, eval_map, assoc]
        rw [reassoc_of% (eq i), Hom.comm_assoc, eq i', Hom.comm] }
  fac t j := by
    ext i
    apply (hs i).fac
  uniq t m hm := by
    ext i
    apply (hs i).uniq ((eval C c i).mapCocone t)
    

Proof state:
case h.x
C : Type u_1
ι : Type u_2
J : Type u_3
inst✝² : Category.{?u.39790, u_1} C
inst✝¹ : Category.{?u.39794, u_3} J
c : ComplexShape ι
inst✝ : HasZeroMorphisms C
F : J ⥤ HomologicalComplex C c
s : Cocone F
hs : (i : ι) → IsColimit ((eval C c i).mapCocone s)
t : Cocone F
m : s.pt ⟶ t.pt
hm : ∀ (j : J), s.ι.app j ≫ m = t.ι.app j
i : ι
⊢ ∀ (j : J), ((eval C c i).mapCocone s).ι.app j ≫ Hom.f m i = ((eval C c i).mapCocone t).ι.app j

Next tactic:
intro j
/-- A cocone in `HomologicalComplex C c` is colimit if the induced cocones obtained
by applying `eval C c i : HomologicalComplex C c ⥤ C` for all `i` are colimit. -/
def isColimitOfEval (s : Cocone F)
    (hs : ∀ (i : ι), IsColimit ((eval C c i).mapCocone s)) : IsColimit s where
  desc t :=
    { f := fun i => (hs i).desc ((eval C c i).mapCocone t)
      comm' := fun i i' _ => by
        apply IsColimit.hom_ext (hs i)
        intro j
        have eq := fun k => (hs k).fac ((eval C c k).mapCocone t)
        simp only [Functor.mapCocone_ι_app, eval_map] at eq
        simp only [Functor.mapCocone_ι_app, eval_map, assoc]
        rw [reassoc_of% (eq i), Hom.comm_assoc, eq i', Hom.comm] }
  fac t j := by
    ext i
    apply (hs i).fac
  uniq t m hm := by
    ext i
    apply (hs i).uniq ((eval C c i).mapCocone t)
    intro j
    

Proof state:
case h.x
C : Type u_1
ι : Type u_2
J : Type u_3
inst✝² : Category.{?u.39790, u_1} C
inst✝¹ : Category.{?u.39794, u_3} J
c : ComplexShape ι
inst✝ : HasZeroMorphisms C
F : J ⥤ HomologicalComplex C c
s : Cocone F
hs : (i : ι) → IsColimit ((eval C c i).mapCocone s)
t : Cocone F
m : s.pt ⟶ t.pt
hm : ∀ (j : J), s.ι.app j ≫ m = t.ι.app j
i : ι
j : J
⊢ ((eval C c i).mapCocone s).ι.app j ≫ Hom.f m i = ((eval C c i).mapCocone t).ι.app j

Next tactic:
dsimp
/-- A cocone in `HomologicalComplex C c` is colimit if the induced cocones obtained
by applying `eval C c i : HomologicalComplex C c ⥤ C` for all `i` are colimit. -/
def isColimitOfEval (s : Cocone F)
    (hs : ∀ (i : ι), IsColimit ((eval C c i).mapCocone s)) : IsColimit s where
  desc t :=
    { f := fun i => (hs i).desc ((eval C c i).mapCocone t)
      comm' := fun i i' _ => by
        apply IsColimit.hom_ext (hs i)
        intro j
        have eq := fun k => (hs k).fac ((eval C c k).mapCocone t)
        simp only [Functor.mapCocone_ι_app, eval_map] at eq
        simp only [Functor.mapCocone_ι_app, eval_map, assoc]
        rw [reassoc_of% (eq i), Hom.comm_assoc, eq i', Hom.comm] }
  fac t j := by
    ext i
    apply (hs i).fac
  uniq t m hm := by
    ext i
    apply (hs i).uniq ((eval C c i).mapCocone t)
    intro j
    dsimp
    

Proof state:
case h.x
C : Type u_1
ι : Type u_2
J : Type u_3
inst✝² : Category.{?u.39790, u_1} C
inst✝¹ : Category.{?u.39794, u_3} J
c : ComplexShape ι
inst✝ : HasZeroMorphisms C
F : J ⥤ HomologicalComplex C c
s : Cocone F
hs : (i : ι) → IsColimit ((eval C c i).mapCocone s)
t : Cocone F
m : s.pt ⟶ t.pt
hm : ∀ (j : J), s.ι.app j ≫ m = t.ι.app j
i : ι
j : J
⊢ Hom.f (s.ι.app j) i ≫ Hom.f m i = Hom.f (t.ι.app j) i

Next tactic:
simp only [← comp_f, hm]
/-- A cocone for a functor `F : J ⥤ HomologicalComplex C c` which is given in degree `n` by
the colimit of `F ⋙ eval C c n`. -/
@[simps]
noncomputable def coconeOfHasColimitEval : Cocone F where
  pt :=
    { X := fun n => colimit (F ⋙ eval C c n)
      d := fun n m => colimMap { app := fun j => (F.obj j).d n m }
      shape := fun {n m} h => by
        

Proof state:
C : Type u_1
ι : Type u_2
J : Type u_3
inst✝³ : Category.{?u.45485, u_1} C
inst✝² : Category.{?u.45489, u_3} J
c : ComplexShape ι
inst✝¹ : HasZeroMorphisms C
F : J ⥤ HomologicalComplex C c
inst✝ : ∀ (n : ι), HasColimit (F ⋙ eval C c n)
n m : ι
h : ¬ComplexShape.Rel c n m
⊢ (fun n m => colimMap (NatTrans.mk fun j => d (F.obj j) n m)) n m = 0

Next tactic:
ext j
/-- A cocone for a functor `F : J ⥤ HomologicalComplex C c` which is given in degree `n` by
the colimit of `F ⋙ eval C c n`. -/
@[simps]
noncomputable def coconeOfHasColimitEval : Cocone F where
  pt :=
    { X := fun n => colimit (F ⋙ eval C c n)
      d := fun n m => colimMap { app := fun j => (F.obj j).d n m }
      shape := fun {n m} h => by
        ext j
        

Proof state:
case w
C : Type u_1
ι : Type u_2
J : Type u_3
inst✝³ : Category.{?u.45485, u_1} C
inst✝² : Category.{?u.45489, u_3} J
c : ComplexShape ι
inst✝¹ : HasZeroMorphisms C
F : J ⥤ HomologicalComplex C c
inst✝ : ∀ (n : ι), HasColimit (F ⋙ eval C c n)
n m : ι
h : ¬ComplexShape.Rel c n m
j : J
⊢ colimit.ι (F ⋙ eval C c n) j ≫ (fun n m => colimMap (NatTrans.mk fun j => d (F.obj j) n m)) n m =
    colimit.ι (F ⋙ eval C c n) j ≫ 0

Next tactic:
rw [ι_colimMap]
/-- A cocone for a functor `F : J ⥤ HomologicalComplex C c` which is given in degree `n` by
the colimit of `F ⋙ eval C c n`. -/
@[simps]
noncomputable def coconeOfHasColimitEval : Cocone F where
  pt :=
    { X := fun n => colimit (F ⋙ eval C c n)
      d := fun n m => colimMap { app := fun j => (F.obj j).d n m }
      shape := fun {n m} h => by
        ext j
        rw [ι_colimMap]
        

Proof state:
case w
C : Type u_1
ι : Type u_2
J : Type u_3
inst✝³ : Category.{?u.45485, u_1} C
inst✝² : Category.{?u.45489, u_3} J
c : ComplexShape ι
inst✝¹ : HasZeroMorphisms C
F : J ⥤ HomologicalComplex C c
inst✝ : ∀ (n : ι), HasColimit (F ⋙ eval C c n)
n m : ι
h : ¬ComplexShape.Rel c n m
j : J
⊢ (NatTrans.mk fun j => d (F.obj j) n m).app j ≫ colimit.ι (F ⋙ eval C c m) j = colimit.ι (F ⋙ eval C c n) j ≫ 0

Next tactic:
dsimp
/-- A cocone for a functor `F : J ⥤ HomologicalComplex C c` which is given in degree `n` by
the colimit of `F ⋙ eval C c n`. -/
@[simps]
noncomputable def coconeOfHasColimitEval : Cocone F where
  pt :=
    { X := fun n => colimit (F ⋙ eval C c n)
      d := fun n m => colimMap { app := fun j => (F.obj j).d n m }
      shape := fun {n m} h => by
        ext j
        rw [ι_colimMap]
        dsimp
        

Proof state:
case w
C : Type u_1
ι : Type u_2
J : Type u_3
inst✝³ : Category.{?u.45485, u_1} C
inst✝² : Category.{?u.45489, u_3} J
c : ComplexShape ι
inst✝¹ : HasZeroMorphisms C
F : J ⥤ HomologicalComplex C c
inst✝ : ∀ (n : ι), HasColimit (F ⋙ eval C c n)
n m : ι
h : ¬ComplexShape.Rel c n m
j : J
⊢ d (F.obj j) n m ≫ colimit.ι (F ⋙ eval C c m) j = colimit.ι (F ⋙ eval C c n) j ≫ 0

Next tactic:
rw [(F.obj j).shape _ _ h, zero_comp, comp_zero]
/-- A cocone for a functor `F : J ⥤ HomologicalComplex C c` which is given in degree `n` by
the colimit of `F ⋙ eval C c n`. -/
@[simps]
noncomputable def coconeOfHasColimitEval : Cocone F where
  pt :=
    { X := fun n => colimit (F ⋙ eval C c n)
      d := fun n m => colimMap { app := fun j => (F.obj j).d n m }
      shape := fun {n m} h => by
        ext j
        rw [ι_colimMap]
        dsimp
        rw [(F.obj j).shape _ _ h, zero_comp, comp_zero] }
  ι :=
    { app := fun j => { f := fun n => colimit.ι (F ⋙ eval C c n) j }
      naturality := fun i j φ => by
        

Proof state:
C : Type u_1
ι : Type u_2
J : Type u_3
inst✝³ : Category.{?u.45485, u_1} C
inst✝² : Category.{?u.45489, u_3} J
c : ComplexShape ι
inst✝¹ : HasZeroMorphisms C
F : J ⥤ HomologicalComplex C c
inst✝ : ∀ (n : ι), HasColimit (F ⋙ eval C c n)
i j : J
φ : i ⟶ j
⊢ F.map φ ≫ (fun j => Hom.mk fun n => colimit.ι (F ⋙ eval C c n) j) j =
    (fun j => Hom.mk fun n => colimit.ι (F ⋙ eval C c n) j) i ≫
      ((Functor.const J).obj
            (mk (fun n => colimit (F ⋙ eval C c n)) fun n m => colimMap (NatTrans.mk fun j => d (F.obj j) n m))).map
        φ

Next tactic:
ext n
/-- A cocone for a functor `F : J ⥤ HomologicalComplex C c` which is given in degree `n` by
the colimit of `F ⋙ eval C c n`. -/
@[simps]
noncomputable def coconeOfHasColimitEval : Cocone F where
  pt :=
    { X := fun n => colimit (F ⋙ eval C c n)
      d := fun n m => colimMap { app := fun j => (F.obj j).d n m }
      shape := fun {n m} h => by
        ext j
        rw [ι_colimMap]
        dsimp
        rw [(F.obj j).shape _ _ h, zero_comp, comp_zero] }
  ι :=
    { app := fun j => { f := fun n => colimit.ι (F ⋙ eval C c n) j }
      naturality := fun i j φ => by
        ext n
        

Proof state:
case h
C : Type u_1
ι : Type u_2
J : Type u_3
inst✝³ : Category.{?u.45485, u_1} C
inst✝² : Category.{?u.45489, u_3} J
c : ComplexShape ι
inst✝¹ : HasZeroMorphisms C
F : J ⥤ HomologicalComplex C c
inst✝ : ∀ (n : ι), HasColimit (F ⋙ eval C c n)
i j : J
φ : i ⟶ j
n : ι
⊢ Hom.f (F.map φ ≫ (fun j => Hom.mk fun n => colimit.ι (F ⋙ eval C c n) j) j) n =
    Hom.f
      ((fun j => Hom.mk fun n => colimit.ι (F ⋙ eval C c n) j) i ≫
        ((Functor.const J).obj
              (mk (fun n => colimit (F ⋙ eval C c n)) fun n m => colimMap (NatTrans.mk fun j => d (F.obj j) n m))).map
          φ)
      n

Next tactic:
dsimp
/-- A cocone for a functor `F : J ⥤ HomologicalComplex C c` which is given in degree `n` by
the colimit of `F ⋙ eval C c n`. -/
@[simps]
noncomputable def coconeOfHasColimitEval : Cocone F where
  pt :=
    { X := fun n => colimit (F ⋙ eval C c n)
      d := fun n m => colimMap { app := fun j => (F.obj j).d n m }
      shape := fun {n m} h => by
        ext j
        rw [ι_colimMap]
        dsimp
        rw [(F.obj j).shape _ _ h, zero_comp, comp_zero] }
  ι :=
    { app := fun j => { f := fun n => colimit.ι (F ⋙ eval C c n) j }
      naturality := fun i j φ => by
        ext n
        dsimp
        

Proof state:
case h
C : Type u_1
ι : Type u_2
J : Type u_3
inst✝³ : Category.{?u.45485, u_1} C
inst✝² : Category.{?u.45489, u_3} J
c : ComplexShape ι
inst✝¹ : HasZeroMorphisms C
F : J ⥤ HomologicalComplex C c
inst✝ : ∀ (n : ι), HasColimit (F ⋙ eval C c n)
i j : J
φ : i ⟶ j
n : ι
⊢ Hom.f (F.map φ) n ≫ colimit.ι (F ⋙ eval C c n) j = colimit.ι (F ⋙ eval C c n) i ≫ 𝟙 (colimit (F ⋙ eval C c n))

Next tactic:
erw [colimit.w (F ⋙ eval C c n) φ, comp_id]
instance [HasFiniteColimits C] {K L : HomologicalComplex C c} (φ : K ⟶ L) [Epi φ] (n : ι) :
    Epi (φ.f n) := by
  

Proof state:
C : Type u_1
ι : Type u_2
J : Type u_3
inst✝⁴ : Category.{?u.75003, u_1} C
inst✝³ : Category.{?u.75007, u_3} J
c : ComplexShape ι
inst✝² : HasZeroMorphisms C
inst✝¹ : HasFiniteColimits C
K L : HomologicalComplex C c
φ : K ⟶ L
inst✝ : Epi φ
n : ι
⊢ Epi (Hom.f φ n)

Next tactic:
change Epi ((HomologicalComplex.eval C c n).map φ)
instance [HasFiniteColimits C] {K L : HomologicalComplex C c} (φ : K ⟶ L) [Epi φ] (n : ι) :
    Epi (φ.f n) := by
  change Epi ((HomologicalComplex.eval C c n).map φ)
  

Proof state:
C : Type u_1
ι : Type u_2
J : Type u_3
inst✝⁴ : Category.{?u.75003, u_1} C
inst✝³ : Category.{?u.75007, u_3} J
c : ComplexShape ι
inst✝² : HasZeroMorphisms C
inst✝¹ : HasFiniteColimits C
K L : HomologicalComplex C c
φ : K ⟶ L
inst✝ : Epi φ
n : ι
⊢ Epi ((eval C c n).map φ)

Next tactic:
infer_instance
/-- The partial sums of a formal multilinear series are continuous. -/
theorem partialSum_continuous (p : FormalMultilinearSeries 𝕜 E F) (n : ℕ) :
    Continuous (p.partialSum n) := by
  

Proof state:
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝¹⁰ : Ring 𝕜
inst✝⁹ : AddCommGroup E
inst✝⁸ : AddCommGroup F
inst✝⁷ : Module 𝕜 E
inst✝⁶ : Module 𝕜 F
inst✝⁵ : TopologicalSpace E
inst✝⁴ : TopologicalSpace F
inst✝³ : TopologicalAddGroup E
inst✝² : TopologicalAddGroup F
inst✝¹ : ContinuousConstSMul 𝕜 E
inst✝ : ContinuousConstSMul 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
n : ℕ
⊢ Continuous (partialSum p n)

Next tactic:
unfold partialSum
/-- The partial sums of a formal multilinear series are continuous. -/
theorem partialSum_continuous (p : FormalMultilinearSeries 𝕜 E F) (n : ℕ) :
    Continuous (p.partialSum n) := by
  unfold partialSum -- Porting note: added
  

Proof state:
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝¹⁰ : Ring 𝕜
inst✝⁹ : AddCommGroup E
inst✝⁸ : AddCommGroup F
inst✝⁷ : Module 𝕜 E
inst✝⁶ : Module 𝕜 F
inst✝⁵ : TopologicalSpace E
inst✝⁴ : TopologicalSpace F
inst✝³ : TopologicalAddGroup E
inst✝² : TopologicalAddGroup F
inst✝¹ : ContinuousConstSMul 𝕜 E
inst✝ : ContinuousConstSMul 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
n : ℕ
⊢ Continuous fun x => ∑ k in Finset.range n, (p k) fun x_1 => x

Next tactic:
continuity
theorem le_radius_of_eventually_le (C) (h : ∀ᶠ n in atTop, ‖p n‖ * (r : ℝ) ^ n ≤ C) :
    ↑r ≤ p.radius :=
  p.le_radius_of_isBigO <| IsBigO.of_bound C <| h.mono fun n hn => by 

Proof state:
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
p : FormalMultilinearSeries 𝕜 E F
r : ℝ≥0
C : ℝ
h : ∀ᶠ (n : ℕ) in atTop, ‖p n‖ * ↑r ^ n ≤ C
n : ℕ
hn : ‖p n‖ * ↑r ^ n ≤ C
⊢ ‖‖p n‖ * ↑r ^ n‖ ≤ C * ‖1‖

Next tactic:
simpa
theorem le_radius_of_summable (h : Summable fun n => ‖p n‖ * (r : ℝ) ^ n) : ↑r ≤ p.radius :=
  p.le_radius_of_summable_nnnorm <| by
    

Proof state:
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
p : FormalMultilinearSeries 𝕜 E F
r : ℝ≥0
h : Summable fun n => ‖p n‖ * ↑r ^ n
⊢ Summable fun n => ‖p n‖₊ * r ^ n

Next tactic:
simp only [← coe_nnnorm] at h
theorem le_radius_of_summable (h : Summable fun n => ‖p n‖ * (r : ℝ) ^ n) : ↑r ≤ p.radius :=
  p.le_radius_of_summable_nnnorm <| by
    simp only [← coe_nnnorm] at h
    

Proof state:
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
p : FormalMultilinearSeries 𝕜 E F
r : ℝ≥0
h : Summable fun n => ↑‖p n‖₊ * ↑r ^ n
⊢ Summable fun n => ‖p n‖₊ * r ^ n

Next tactic:
exact mod_cast h