l3lab/ntp-mathlib huggingface dataset:
/-- A cocone over `Lan.diagram ι F x` used to define `Lan`. -/
@[simp]
def cocone {F : S ⥤ D} {G : L ⥤ D} (x : L) (f : F ⟶ ι ⋙ G) : Cocone (diagram ι F x)
    where
  pt := G.obj x
  ι :=
    { app := fun i => f.app i.left ≫ G.map i.hom
      naturality := by
        

Proof state:
S : Type u₁
L : Type u₂
D : Type u₃
inst✝² : Category.{v₁, u₁} S
inst✝¹ : Category.{v₂, u₂} L
inst✝ : Category.{v₃, u₃} D
ι : S ⥤ L
F : S ⥤ D
G : L ⥤ D
x : L
f : F ⟶ ι ⋙ G
⊢ ∀ ⦃X Y : CostructuredArrow ι x⦄ (f_1 : X ⟶ Y),
    (diagram ι F x).map f_1 ≫ (fun i => f.app i.left ≫ G.map i.hom) Y =
      (fun i => f.app i.left ≫ G.map i.hom) X ≫ ((Functor.const (CostructuredArrow ι x)).obj (G.obj x)).map f_1

Next tactic:
rintro ⟨ir, ⟨il⟩, i⟩ ⟨jl, ⟨jr⟩, j⟩ ⟨fl, ⟨⟨fl⟩⟩, ff⟩
/-- A cocone over `Lan.diagram ι F x` used to define `Lan`. -/
@[simp]
def cocone {F : S ⥤ D} {G : L ⥤ D} (x : L) (f : F ⟶ ι ⋙ G) : Cocone (diagram ι F x)
    where
  pt := G.obj x
  ι :=
    { app := fun i => f.app i.left ≫ G.map i.hom
      naturality := by
        rintro ⟨ir, ⟨il⟩, i⟩ ⟨jl, ⟨jr⟩, j⟩ ⟨fl, ⟨⟨fl⟩⟩, ff⟩
        

Proof state:
case mk.mk.mk.mk.mk.up.up
S : Type u₁
L : Type u₂
D : Type u₃
inst✝² : Category.{v₁, u₁} S
inst✝¹ : Category.{v₂, u₂} L
inst✝ : Category.{v₃, u₃} D
ι : S ⥤ L
F : S ⥤ D
G : L ⥤ D
x : L
f : F ⟶ ι ⋙ G
ir : S
il : PUnit.{1}
i : ι.obj ir ⟶ (Functor.fromPUnit x).obj { as := il }
jl : S
jr : PUnit.{1}
j : ι.obj jl ⟶ (Functor.fromPUnit x).obj { as := jr }
fl✝ : { left := ir, right := { as := il }, hom := i }.left ⟶ { left := jl, right := { as := jr }, hom := j }.left
fl : { left := ir, right := { as := il }, hom := i }.right.as = { left := jl, right := { as := jr }, hom := j }.right.as
ff :
  ι.map fl✝ ≫ { left := jl, right := { as := jr }, hom := j }.hom =
    { left := ir, right := { as := il }, hom := i }.hom ≫ (Functor.fromPUnit x).map { down := { down := fl } }
⊢ (diagram ι F x).map (CommaMorphism.mk fl✝ { down := { down := fl } }) ≫
      (fun i => f.app i.left ≫ G.map i.hom) { left := jl, right := { as := jr }, hom := j } =
    (fun i => f.app i.left ≫ G.map i.hom) { left := ir, right := { as := il }, hom := i } ≫
      ((Functor.const (CostructuredArrow ι x)).obj (G.obj x)).map (CommaMorphism.mk fl✝ { down := { down := fl } })

Next tactic:
dsimp at *
/-- A cocone over `Lan.diagram ι F x` used to define `Lan`. -/
@[simp]
def cocone {F : S ⥤ D} {G : L ⥤ D} (x : L) (f : F ⟶ ι ⋙ G) : Cocone (diagram ι F x)
    where
  pt := G.obj x
  ι :=
    { app := fun i => f.app i.left ≫ G.map i.hom
      naturality := by
        rintro ⟨ir, ⟨il⟩, i⟩ ⟨jl, ⟨jr⟩, j⟩ ⟨fl, ⟨⟨fl⟩⟩, ff⟩
        dsimp at *
        

Proof state:
case mk.mk.mk.mk.mk.up.up
S : Type u₁
L : Type u₂
D : Type u₃
inst✝² : Category.{v₁, u₁} S
inst✝¹ : Category.{v₂, u₂} L
inst✝ : Category.{v₃, u₃} D
ι : S ⥤ L
F : S ⥤ D
G : L ⥤ D
x : L
f : F ⟶ ι ⋙ G
ir : S
il : PUnit.{1}
i : ι.obj ir ⟶ (Functor.fromPUnit x).obj { as := il }
jl : S
jr : PUnit.{1}
j : ι.obj jl ⟶ (Functor.fromPUnit x).obj { as := jr }
fl✝ : { left := ir, right := { as := il }, hom := i }.left ⟶ { left := jl, right := { as := jr }, hom := j }.left
fl : { left := ir, right := { as := il }, hom := i }.right.as = { left := jl, right := { as := jr }, hom := j }.right.as
ff :
  ι.map fl✝ ≫ { left := jl, right := { as := jr }, hom := j }.hom =
    { left := ir, right := { as := il }, hom := i }.hom ≫ (Functor.fromPUnit x).map { down := { down := fl } }
⊢ F.map fl✝ ≫ f.app jl ≫ G.map j = (f.app ir ≫ G.map i) ≫ 𝟙 (G.obj x)

Next tactic:
simp only [Functor.comp_map, Category.comp_id, NatTrans.naturality_assoc]
/-- A cocone over `Lan.diagram ι F x` used to define `Lan`. -/
@[simp]
def cocone {F : S ⥤ D} {G : L ⥤ D} (x : L) (f : F ⟶ ι ⋙ G) : Cocone (diagram ι F x)
    where
  pt := G.obj x
  ι :=
    { app := fun i => f.app i.left ≫ G.map i.hom
      naturality := by
        rintro ⟨ir, ⟨il⟩, i⟩ ⟨jl, ⟨jr⟩, j⟩ ⟨fl, ⟨⟨fl⟩⟩, ff⟩
        dsimp at *
        simp only [Functor.comp_map, Category.comp_id, NatTrans.naturality_assoc]
        

Proof state:
case mk.mk.mk.mk.mk.up.up
S : Type u₁
L : Type u₂
D : Type u₃
inst✝² : Category.{v₁, u₁} S
inst✝¹ : Category.{v₂, u₂} L
inst✝ : Category.{v₃, u₃} D
ι : S ⥤ L
F : S ⥤ D
G : L ⥤ D
x : L
f : F ⟶ ι ⋙ G
ir : S
il : PUnit.{1}
i : ι.obj ir ⟶ (Functor.fromPUnit x).obj { as := il }
jl : S
jr : PUnit.{1}
j : ι.obj jl ⟶ (Functor.fromPUnit x).obj { as := jr }
fl✝ : { left := ir, right := { as := il }, hom := i }.left ⟶ { left := jl, right := { as := jr }, hom := j }.left
fl : { left := ir, right := { as := il }, hom := i }.right.as = { left := jl, right := { as := jr }, hom := j }.right.as
ff :
  ι.map fl✝ ≫ { left := jl, right := { as := jr }, hom := j }.hom =
    { left := ir, right := { as := il }, hom := i }.hom ≫ (Functor.fromPUnit x).map { down := { down := fl } }
⊢ f.app ir ≫ G.map (ι.map fl✝) ≫ G.map j = f.app ir ≫ G.map i

Next tactic:
rw [← G.map_comp, ff]
/-- A cocone over `Lan.diagram ι F x` used to define `Lan`. -/
@[simp]
def cocone {F : S ⥤ D} {G : L ⥤ D} (x : L) (f : F ⟶ ι ⋙ G) : Cocone (diagram ι F x)
    where
  pt := G.obj x
  ι :=
    { app := fun i => f.app i.left ≫ G.map i.hom
      naturality := by
        rintro ⟨ir, ⟨il⟩, i⟩ ⟨jl, ⟨jr⟩, j⟩ ⟨fl, ⟨⟨fl⟩⟩, ff⟩
        dsimp at *
        simp only [Functor.comp_map, Category.comp_id, NatTrans.naturality_assoc]
        rw [← G.map_comp, ff]
        

Proof state:
case mk.mk.mk.mk.mk.up.up
S : Type u₁
L : Type u₂
D : Type u₃
inst✝² : Category.{v₁, u₁} S
inst✝¹ : Category.{v₂, u₂} L
inst✝ : Category.{v₃, u₃} D
ι : S ⥤ L
F : S ⥤ D
G : L ⥤ D
x : L
f : F ⟶ ι ⋙ G
ir : S
il : PUnit.{1}
i : ι.obj ir ⟶ (Functor.fromPUnit x).obj { as := il }
jl : S
jr : PUnit.{1}
j : ι.obj jl ⟶ (Functor.fromPUnit x).obj { as := jr }
fl✝ : { left := ir, right := { as := il }, hom := i }.left ⟶ { left := jl, right := { as := jr }, hom := j }.left
fl : { left := ir, right := { as := il }, hom := i }.right.as = { left := jl, right := { as := jr }, hom := j }.right.as
ff :
  ι.map fl✝ ≫ { left := jl, right := { as := jr }, hom := j }.hom =
    { left := ir, right := { as := il }, hom := i }.hom ≫ (Functor.fromPUnit x).map { down := { down := fl } }
⊢ f.app ir ≫
      G.map
        ({ left := ir, right := { as := il }, hom := i }.hom ≫ (Functor.fromPUnit x).map { down := { down := fl } }) =
    f.app ir ≫ G.map i

Next tactic:
aesop_cat
/-- An auxiliary definition used to define `Lan`. -/
@[simps]
def loc (F : S ⥤ D) [I : ∀ x, HasColimit (diagram ι F x)] : L ⥤ D
    where
  obj x := colimit (diagram ι F x)
  map {x y} f :=
    haveI : HasColimit (CostructuredArrow.map f ⋙ diagram ι F y) := I _
    colimit.pre (diagram ι F y) (CostructuredArrow.map f)
  map_id := by
    

Proof state:
S : Type u₁
L : Type u₂
D : Type u₃
inst✝² : Category.{v₁, u₁} S
inst✝¹ : Category.{v₂, u₂} L
inst✝ : Category.{v₃, u₃} D
ι : S ⥤ L
F : S ⥤ D
I : ∀ (x : L), HasColimit (diagram ι F x)
⊢ ∀ (X : L),
    { obj := fun x => colimit (diagram ι F x),
            map := fun {x y} f => colimit.pre (diagram ι F y) (CostructuredArrow.map f) }.map
        (𝟙 X) =
      𝟙
        ({ obj := fun x => colimit (diagram ι F x),
              map := fun {x y} f => colimit.pre (diagram ι F y) (CostructuredArrow.map f) }.obj
          X)

Next tactic:
intro l
/-- An auxiliary definition used to define `Lan`. -/
@[simps]
def loc (F : S ⥤ D) [I : ∀ x, HasColimit (diagram ι F x)] : L ⥤ D
    where
  obj x := colimit (diagram ι F x)
  map {x y} f :=
    haveI : HasColimit (CostructuredArrow.map f ⋙ diagram ι F y) := I _
    colimit.pre (diagram ι F y) (CostructuredArrow.map f)
  map_id := by
    intro l
    

Proof state:
S : Type u₁
L : Type u₂
D : Type u₃
inst✝² : Category.{v₁, u₁} S
inst✝¹ : Category.{v₂, u₂} L
inst✝ : Category.{v₃, u₃} D
ι : S ⥤ L
F : S ⥤ D
I : ∀ (x : L), HasColimit (diagram ι F x)
l : L
⊢ { obj := fun x => colimit (diagram ι F x),
          map := fun {x y} f => colimit.pre (diagram ι F y) (CostructuredArrow.map f) }.map
      (𝟙 l) =
    𝟙
      ({ obj := fun x => colimit (diagram ι F x),
            map := fun {x y} f => colimit.pre (diagram ι F y) (CostructuredArrow.map f) }.obj
        l)

Next tactic:
dsimp
/-- An auxiliary definition used to define `Lan`. -/
@[simps]
def loc (F : S ⥤ D) [I : ∀ x, HasColimit (diagram ι F x)] : L ⥤ D
    where
  obj x := colimit (diagram ι F x)
  map {x y} f :=
    haveI : HasColimit (CostructuredArrow.map f ⋙ diagram ι F y) := I _
    colimit.pre (diagram ι F y) (CostructuredArrow.map f)
  map_id := by
    intro l
    dsimp
    

Proof state:
S : Type u₁
L : Type u₂
D : Type u₃
inst✝² : Category.{v₁, u₁} S
inst✝¹ : Category.{v₂, u₂} L
inst✝ : Category.{v₃, u₃} D
ι : S ⥤ L
F : S ⥤ D
I : ∀ (x : L), HasColimit (diagram ι F x)
l : L
⊢ colimit.pre (diagram ι F l) (CostructuredArrow.map (𝟙 l)) = 𝟙 (colimit (diagram ι F l))

Next tactic:
haveI : HasColimit (CostructuredArrow.map (𝟙 l) ⋙ diagram ι F l) := I _
/-- An auxiliary definition used to define `Lan`. -/
@[simps]
def loc (F : S ⥤ D) [I : ∀ x, HasColimit (diagram ι F x)] : L ⥤ D
    where
  obj x := colimit (diagram ι F x)
  map {x y} f :=
    haveI : HasColimit (CostructuredArrow.map f ⋙ diagram ι F y) := I _
    colimit.pre (diagram ι F y) (CostructuredArrow.map f)
  map_id := by
    intro l
    dsimp
    haveI : HasColimit (CostructuredArrow.map (𝟙 l) ⋙ diagram ι F l) := I _
    

Proof state:
S : Type u₁
L : Type u₂
D : Type u₃
inst✝² : Category.{v₁, u₁} S
inst✝¹ : Category.{v₂, u₂} L
inst✝ : Category.{v₃, u₃} D
ι : S ⥤ L
F : S ⥤ D
I : ∀ (x : L), HasColimit (diagram ι F x)
l : L
this : HasColimit (CostructuredArrow.map (𝟙 l) ⋙ diagram ι F l)
⊢ colimit.pre (diagram ι F l) (CostructuredArrow.map (𝟙 l)) = 𝟙 (colimit (diagram ι F l))

Next tactic:
ext j
/-- An auxiliary definition used to define `Lan`. -/
@[simps]
def loc (F : S ⥤ D) [I : ∀ x, HasColimit (diagram ι F x)] : L ⥤ D
    where
  obj x := colimit (diagram ι F x)
  map {x y} f :=
    haveI : HasColimit (CostructuredArrow.map f ⋙ diagram ι F y) := I _
    colimit.pre (diagram ι F y) (CostructuredArrow.map f)
  map_id := by
    intro l
    dsimp
    haveI : HasColimit (CostructuredArrow.map (𝟙 l) ⋙ diagram ι F l) := I _
    ext j
    

Proof state:
case w
S : Type u₁
L : Type u₂
D : Type u₃
inst✝² : Category.{v₁, u₁} S
inst✝¹ : Category.{v₂, u₂} L
inst✝ : Category.{v₃, u₃} D
ι : S ⥤ L
F : S ⥤ D
I : ∀ (x : L), HasColimit (diagram ι F x)
l : L
this : HasColimit (CostructuredArrow.map (𝟙 l) ⋙ diagram ι F l)
j : CostructuredArrow ι l
⊢ colimit.ι (CostructuredArrow.map (𝟙 l) ⋙ diagram ι F l) j ≫
      colimit.pre (diagram ι F l) (CostructuredArrow.map (𝟙 l)) =
    colimit.ι (CostructuredArrow.map (𝟙 l) ⋙ diagram ι F l) j ≫ 𝟙 (colimit (diagram ι F l))

Next tactic:
erw [colimit.ι_pre, Category.comp_id]
/-- An auxiliary definition used to define `Lan`. -/
@[simps]
def loc (F : S ⥤ D) [I : ∀ x, HasColimit (diagram ι F x)] : L ⥤ D
    where
  obj x := colimit (diagram ι F x)
  map {x y} f :=
    haveI : HasColimit (CostructuredArrow.map f ⋙ diagram ι F y) := I _
    colimit.pre (diagram ι F y) (CostructuredArrow.map f)
  map_id := by
    intro l
    dsimp
    haveI : HasColimit (CostructuredArrow.map (𝟙 l) ⋙ diagram ι F l) := I _
    ext j
    erw [colimit.ι_pre, Category.comp_id]
    

Proof state:
case w
S : Type u₁
L : Type u₂
D : Type u₃
inst✝² : Category.{v₁, u₁} S
inst✝¹ : Category.{v₂, u₂} L
inst✝ : Category.{v₃, u₃} D
ι : S ⥤ L
F : S ⥤ D
I : ∀ (x : L), HasColimit (diagram ι F x)
l : L
this : HasColimit (CostructuredArrow.map (𝟙 l) ⋙ diagram ι F l)
j : CostructuredArrow ι l
⊢ colimit.ι (diagram ι F l) ((CostructuredArrow.map (𝟙 l)).obj j) =
    colimit.ι (CostructuredArrow.map (𝟙 l) ⋙ diagram ι F l) j

Next tactic:
congr 1
/-- An auxiliary definition used to define `Lan`. -/
@[simps]
def loc (F : S ⥤ D) [I : ∀ x, HasColimit (diagram ι F x)] : L ⥤ D
    where
  obj x := colimit (diagram ι F x)
  map {x y} f :=
    haveI : HasColimit (CostructuredArrow.map f ⋙ diagram ι F y) := I _
    colimit.pre (diagram ι F y) (CostructuredArrow.map f)
  map_id := by
    intro l
    dsimp
    haveI : HasColimit (CostructuredArrow.map (𝟙 l) ⋙ diagram ι F l) := I _
    ext j
    erw [colimit.ι_pre, Category.comp_id]
    congr 1
    

Proof state:
case w.h.e_7.h
S : Type u₁
L : Type u₂
D : Type u₃
inst✝² : Category.{v₁, u₁} S
inst✝¹ : Category.{v₂, u₂} L
inst✝ : Category.{v₃, u₃} D
ι : S ⥤ L
F : S ⥤ D
I : ∀ (x : L), HasColimit (diagram ι F x)
l : L
this : HasColimit (CostructuredArrow.map (𝟙 l) ⋙ diagram ι F l)
j : CostructuredArrow ι l
⊢ (CostructuredArrow.map (𝟙 l)).obj j = j

Next tactic:
simp
/-- An auxiliary definition used to define `Lan`. -/
@[simps]
def loc (F : S ⥤ D) [I : ∀ x, HasColimit (diagram ι F x)] : L ⥤ D
    where
  obj x := colimit (diagram ι F x)
  map {x y} f :=
    haveI : HasColimit (CostructuredArrow.map f ⋙ diagram ι F y) := I _
    colimit.pre (diagram ι F y) (CostructuredArrow.map f)
  map_id := by
    intro l
    dsimp
    haveI : HasColimit (CostructuredArrow.map (𝟙 l) ⋙ diagram ι F l) := I _
    ext j
    erw [colimit.ι_pre, Category.comp_id]
    congr 1
    simp
  map_comp := by
    

Proof state:
S : Type u₁
L : Type u₂
D : Type u₃
inst✝² : Category.{v₁, u₁} S
inst✝¹ : Category.{v₂, u₂} L
inst✝ : Category.{v₃, u₃} D
ι : S ⥤ L
F : S ⥤ D
I : ∀ (x : L), HasColimit (diagram ι F x)
⊢ ∀ {X Y Z : L} (f : X ⟶ Y) (g : Y ⟶ Z),
    { obj := fun x => colimit (diagram ι F x),
            map := fun {x y} f => colimit.pre (diagram ι F y) (CostructuredArrow.map f) }.map
        (f ≫ g) =
      { obj := fun x => colimit (diagram ι F x),
              map := fun {x y} f => colimit.pre (diagram ι F y) (CostructuredArrow.map f) }.map
          f ≫
        { obj := fun x => colimit (diagram ι F x),
              map := fun {x y} f => colimit.pre (diagram ι F y) (CostructuredArrow.map f) }.map
          g

Next tactic:
intro x y z f g
/-- An auxiliary definition used to define `Lan`. -/
@[simps]
def loc (F : S ⥤ D) [I : ∀ x, HasColimit (diagram ι F x)] : L ⥤ D
    where
  obj x := colimit (diagram ι F x)
  map {x y} f :=
    haveI : HasColimit (CostructuredArrow.map f ⋙ diagram ι F y) := I _
    colimit.pre (diagram ι F y) (CostructuredArrow.map f)
  map_id := by
    intro l
    dsimp
    haveI : HasColimit (CostructuredArrow.map (𝟙 l) ⋙ diagram ι F l) := I _
    ext j
    erw [colimit.ι_pre, Category.comp_id]
    congr 1
    simp
  map_comp := by
    intro x y z f g
    

Proof state:
S : Type u₁
L : Type u₂
D : Type u₃
inst✝² : Category.{v₁, u₁} S
inst✝¹ : Category.{v₂, u₂} L
inst✝ : Category.{v₃, u₃} D
ι : S ⥤ L
F : S ⥤ D
I : ∀ (x : L), HasColimit (diagram ι F x)
x y z : L
f : x ⟶ y
g : y ⟶ z
⊢ { obj := fun x => colimit (diagram ι F x),
          map := fun {x y} f => colimit.pre (diagram ι F y) (CostructuredArrow.map f) }.map
      (f ≫ g) =
    { obj := fun x => colimit (diagram ι F x),
            map := fun {x y} f => colimit.pre (diagram ι F y) (CostructuredArrow.map f) }.map
        f ≫
      { obj := fun x => colimit (diagram ι F x),
            map := fun {x y} f => colimit.pre (diagram ι F y) (CostructuredArrow.map f) }.map
        g

Next tactic:
dsimp
/-- An auxiliary definition used to define `Lan`. -/
@[simps]
def loc (F : S ⥤ D) [I : ∀ x, HasColimit (diagram ι F x)] : L ⥤ D
    where
  obj x := colimit (diagram ι F x)
  map {x y} f :=
    haveI : HasColimit (CostructuredArrow.map f ⋙ diagram ι F y) := I _
    colimit.pre (diagram ι F y) (CostructuredArrow.map f)
  map_id := by
    intro l
    dsimp
    haveI : HasColimit (CostructuredArrow.map (𝟙 l) ⋙ diagram ι F l) := I _
    ext j
    erw [colimit.ι_pre, Category.comp_id]
    congr 1
    simp
  map_comp := by
    intro x y z f g
    dsimp
    

Proof state:
S : Type u₁
L : Type u₂
D : Type u₃
inst✝² : Category.{v₁, u₁} S
inst✝¹ : Category.{v₂, u₂} L
inst✝ : Category.{v₃, u₃} D
ι : S ⥤ L
F : S ⥤ D
I : ∀ (x : L), HasColimit (diagram ι F x)
x y z : L
f : x ⟶ y
g : y ⟶ z
⊢ colimit.pre (diagram ι F z) (CostructuredArrow.map (f ≫ g)) =
    colimit.pre (diagram ι F y) (CostructuredArrow.map f) ≫ colimit.pre (diagram ι F z) (CostructuredArrow.map g)

Next tactic:
haveI : HasColimit (CostructuredArrow.map (f ≫ g) ⋙ diagram ι F z) := I _
/-- An auxiliary definition used to define `Lan`. -/
@[simps]
def loc (F : S ⥤ D) [I : ∀ x, HasColimit (diagram ι F x)] : L ⥤ D
    where
  obj x := colimit (diagram ι F x)
  map {x y} f :=
    haveI : HasColimit (CostructuredArrow.map f ⋙ diagram ι F y) := I _
    colimit.pre (diagram ι F y) (CostructuredArrow.map f)
  map_id := by
    intro l
    dsimp
    haveI : HasColimit (CostructuredArrow.map (𝟙 l) ⋙ diagram ι F l) := I _
    ext j
    erw [colimit.ι_pre, Category.comp_id]
    congr 1
    simp
  map_comp := by
    intro x y z f g
    dsimp
    haveI : HasColimit (CostructuredArrow.map (f ≫ g) ⋙ diagram ι F z) := I _
    

Proof state:
S : Type u₁
L : Type u₂
D : Type u₃
inst✝² : Category.{v₁, u₁} S
inst✝¹ : Category.{v₂, u₂} L
inst✝ : Category.{v₃, u₃} D
ι : S ⥤ L
F : S ⥤ D
I : ∀ (x : L), HasColimit (diagram ι F x)
x y z : L
f : x ⟶ y
g : y ⟶ z
this : HasColimit (CostructuredArrow.map (f ≫ g) ⋙ diagram ι F z)
⊢ colimit.pre (diagram ι F z) (CostructuredArrow.map (f ≫ g)) =
    colimit.pre (diagram ι F y) (CostructuredArrow.map f) ≫ colimit.pre (diagram ι F z) (CostructuredArrow.map g)

Next tactic:
ext j
/-- An auxiliary definition used to define `Lan`. -/
@[simps]
def loc (F : S ⥤ D) [I : ∀ x, HasColimit (diagram ι F x)] : L ⥤ D
    where
  obj x := colimit (diagram ι F x)
  map {x y} f :=
    haveI : HasColimit (CostructuredArrow.map f ⋙ diagram ι F y) := I _
    colimit.pre (diagram ι F y) (CostructuredArrow.map f)
  map_id := by
    intro l
    dsimp
    haveI : HasColimit (CostructuredArrow.map (𝟙 l) ⋙ diagram ι F l) := I _
    ext j
    erw [colimit.ι_pre, Category.comp_id]
    congr 1
    simp
  map_comp := by
    intro x y z f g
    dsimp
    haveI : HasColimit (CostructuredArrow.map (f ≫ g) ⋙ diagram ι F z) := I _
    ext j
    

Proof state:
case w
S : Type u₁
L : Type u₂
D : Type u₃
inst✝² : Category.{v₁, u₁} S
inst✝¹ : Category.{v₂, u₂} L
inst✝ : Category.{v₃, u₃} D
ι : S ⥤ L
F : S ⥤ D
I : ∀ (x : L), HasColimit (diagram ι F x)
x y z : L
f : x ⟶ y
g : y ⟶ z
this : HasColimit (CostructuredArrow.map (f ≫ g) ⋙ diagram ι F z)
j : CostructuredArrow ι x
⊢ colimit.ι (CostructuredArrow.map (f ≫ g) ⋙ diagram ι F z) j ≫
      colimit.pre (diagram ι F z) (CostructuredArrow.map (f ≫ g)) =
    colimit.ι (CostructuredArrow.map (f ≫ g) ⋙ diagram ι F z) j ≫
      colimit.pre (diagram ι F y) (CostructuredArrow.map f) ≫ colimit.pre (diagram ι F z) (CostructuredArrow.map g)

Next tactic:
let ff : CostructuredArrow ι _ ⥤ _ := CostructuredArrow.map f
/-- An auxiliary definition used to define `Lan`. -/
@[simps]
def loc (F : S ⥤ D) [I : ∀ x, HasColimit (diagram ι F x)] : L ⥤ D
    where
  obj x := colimit (diagram ι F x)
  map {x y} f :=
    haveI : HasColimit (CostructuredArrow.map f ⋙ diagram ι F y) := I _
    colimit.pre (diagram ι F y) (CostructuredArrow.map f)
  map_id := by
    intro l
    dsimp
    haveI : HasColimit (CostructuredArrow.map (𝟙 l) ⋙ diagram ι F l) := I _
    ext j
    erw [colimit.ι_pre, Category.comp_id]
    congr 1
    simp
  map_comp := by
    intro x y z f g
    dsimp
    haveI : HasColimit (CostructuredArrow.map (f ≫ g) ⋙ diagram ι F z) := I _
    ext j
    let ff : CostructuredArrow ι _ ⥤ _ := CostructuredArrow.map f
    

Proof state:
case w
S : Type u₁
L : Type u₂
D : Type u₃
inst✝² : Category.{v₁, u₁} S
inst✝¹ : Category.{v₂, u₂} L
inst✝ : Category.{v₃, u₃} D
ι : S ⥤ L
F : S ⥤ D
I : ∀ (x : L), HasColimit (diagram ι F x)
x y z : L
f : x ⟶ y
g : y ⟶ z
this : HasColimit (CostructuredArrow.map (f ≫ g) ⋙ diagram ι F z)
j : CostructuredArrow ι x
ff : CostructuredArrow ι x ⥤ CostructuredArrow ι y := CostructuredArrow.map f
⊢ colimit.ι (CostructuredArrow.map (f ≫ g) ⋙ diagram ι F z) j ≫
      colimit.pre (diagram ι F z) (CostructuredArrow.map (f ≫ g)) =
    colimit.ι (CostructuredArrow.map (f ≫ g) ⋙ diagram ι F z) j ≫
      colimit.pre (diagram ι F y) (CostructuredArrow.map f) ≫ colimit.pre (diagram ι F z) (CostructuredArrow.map g)

Next tactic:
let gg : CostructuredArrow ι _ ⥤ _ := CostructuredArrow.map g
/-- An auxiliary definition used to define `Lan`. -/
@[simps]
def loc (F : S ⥤ D) [I : ∀ x, HasColimit (diagram ι F x)] : L ⥤ D
    where
  obj x := colimit (diagram ι F x)
  map {x y} f :=
    haveI : HasColimit (CostructuredArrow.map f ⋙ diagram ι F y) := I _
    colimit.pre (diagram ι F y) (CostructuredArrow.map f)
  map_id := by
    intro l
    dsimp
    haveI : HasColimit (CostructuredArrow.map (𝟙 l) ⋙ diagram ι F l) := I _
    ext j
    erw [colimit.ι_pre, Category.comp_id]
    congr 1
    simp
  map_comp := by
    intro x y z f g
    dsimp
    haveI : HasColimit (CostructuredArrow.map (f ≫ g) ⋙ diagram ι F z) := I _
    ext j
    let ff : CostructuredArrow ι _ ⥤ _ := CostructuredArrow.map f
    let gg : CostructuredArrow ι _ ⥤ _ := CostructuredArrow.map g
    

Proof state:
case w
S : Type u₁
L : Type u₂
D : Type u₃
inst✝² : Category.{v₁, u₁} S
inst✝¹ : Category.{v₂, u₂} L
inst✝ : Category.{v₃, u₃} D
ι : S ⥤ L
F : S ⥤ D
I : ∀ (x : L), HasColimit (diagram ι F x)
x y z : L
f : x ⟶ y
g : y ⟶ z
this : HasColimit (CostructuredArrow.map (f ≫ g) ⋙ diagram ι F z)
j : CostructuredArrow ι x
ff : CostructuredArrow ι x ⥤ CostructuredArrow ι y := CostructuredArrow.map f
gg : CostructuredArrow ι y ⥤ CostructuredArrow ι z := CostructuredArrow.map g
⊢ colimit.ι (CostructuredArrow.map (f ≫ g) ⋙ diagram ι F z) j ≫
      colimit.pre (diagram ι F z) (CostructuredArrow.map (f ≫ g)) =
    colimit.ι (CostructuredArrow.map (f ≫ g) ⋙ diagram ι F z) j ≫
      colimit.pre (diagram ι F y) (CostructuredArrow.map f) ≫ colimit.pre (diagram ι F z) (CostructuredArrow.map g)

Next tactic:
let dd := diagram ι F z
/-- An auxiliary definition used to define `Lan`. -/
@[simps]
def loc (F : S ⥤ D) [I : ∀ x, HasColimit (diagram ι F x)] : L ⥤ D
    where
  obj x := colimit (diagram ι F x)
  map {x y} f :=
    haveI : HasColimit (CostructuredArrow.map f ⋙ diagram ι F y) := I _
    colimit.pre (diagram ι F y) (CostructuredArrow.map f)
  map_id := by
    intro l
    dsimp
    haveI : HasColimit (CostructuredArrow.map (𝟙 l) ⋙ diagram ι F l) := I _
    ext j
    erw [colimit.ι_pre, Category.comp_id]
    congr 1
    simp
  map_comp := by
    intro x y z f g
    dsimp
    haveI : HasColimit (CostructuredArrow.map (f ≫ g) ⋙ diagram ι F z) := I _
    ext j
    let ff : CostructuredArrow ι _ ⥤ _ := CostructuredArrow.map f
    let gg : CostructuredArrow ι _ ⥤ _ := CostructuredArrow.map g
    let dd := diagram ι F z
    -- Porting note: It seems that even Lean3 had some trouble with instances in this case.
    -- I don't know why lean can't deduce the following three instances...
    

Proof state:
case w
S : Type u₁
L : Type u₂
D : Type u₃
inst✝² : Category.{v₁, u₁} S
inst✝¹ : Category.{v₂, u₂} L
inst✝ : Category.{v₃, u₃} D
ι : S ⥤ L
F : S ⥤ D
I : ∀ (x : L), HasColimit (diagram ι F x)
x y z : L
f : x ⟶ y
g : y ⟶ z
this : HasColimit (CostructuredArrow.map (f ≫ g) ⋙ diagram ι F z)
j : CostructuredArrow ι x
ff : CostructuredArrow ι x ⥤ CostructuredArrow ι y := CostructuredArrow.map f
gg : CostructuredArrow ι y ⥤ CostructuredArrow ι z := CostructuredArrow.map g
dd : CostructuredArrow ι z ⥤ D := diagram ι F z
⊢ colimit.ι (CostructuredArrow.map (f ≫ g) ⋙ diagram ι F z) j ≫
      colimit.pre (diagram ι F z) (CostructuredArrow.map (f ≫ g)) =
    colimit.ι (CostructuredArrow.map (f ≫ g) ⋙ diagram ι F z) j ≫
      colimit.pre (diagram ι F y) (CostructuredArrow.map f) ≫ colimit.pre (diagram ι F z) (CostructuredArrow.map g)

Next tactic:
haveI : HasColimit (ff ⋙ gg ⋙ dd) := I _