l3lab/ntp-mathlib huggingface dataset:
/-- 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...
    haveI : HasColimit (ff ⋙ gg ⋙ dd) := I _
    

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
this : HasColimit (ff ⋙ gg ⋙ dd)
⊢ 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 _
/-- 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...
    haveI : HasColimit (ff ⋙ gg ⋙ dd) := I _
    haveI : HasColimit ((ff ⋙ gg) ⋙ dd) := I _
    

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
this✝ : HasColimit (ff ⋙ gg ⋙ dd)
this : HasColimit ((ff ⋙ gg) ⋙ dd)
⊢ 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 (gg ⋙ dd) := 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 _
    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...
    haveI : HasColimit (ff ⋙ gg ⋙ dd) := I _
    haveI : HasColimit ((ff ⋙ gg) ⋙ dd) := I _
    haveI : HasColimit (gg ⋙ dd) := I _
    

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
this✝¹ : HasColimit (ff ⋙ gg ⋙ dd)
this✝ : HasColimit ((ff ⋙ gg) ⋙ dd)
this : HasColimit (gg ⋙ dd)
⊢ 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:
change _ = colimit.ι ((ff ⋙ gg) ⋙ dd) 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
    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...
    haveI : HasColimit (ff ⋙ gg ⋙ dd) := I _
    haveI : HasColimit ((ff ⋙ gg) ⋙ dd) := I _
    haveI : HasColimit (gg ⋙ dd) := I _
    change _ = colimit.ι ((ff ⋙ gg) ⋙ dd) 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
ff : CostructuredArrow ι x ⥤ CostructuredArrow ι y := CostructuredArrow.map f
gg : CostructuredArrow ι y ⥤ CostructuredArrow ι z := CostructuredArrow.map g
dd : CostructuredArrow ι z ⥤ D := diagram ι F z
this✝¹ : HasColimit (ff ⋙ gg ⋙ dd)
this✝ : HasColimit ((ff ⋙ gg) ⋙ dd)
this : HasColimit (gg ⋙ dd)
⊢ colimit.ι (CostructuredArrow.map (f ≫ g) ⋙ diagram ι F z) j ≫
      colimit.pre (diagram ι F z) (CostructuredArrow.map (f ≫ g)) =
    colimit.ι ((ff ⋙ gg) ⋙ dd) j ≫
      colimit.pre (diagram ι F y) (CostructuredArrow.map f) ≫ colimit.pre (diagram ι F z) (CostructuredArrow.map g)

Next tactic:
erw [colimit.pre_pre dd gg ff, colimit.ι_pre, colimit.ι_pre]
/-- 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...
    haveI : HasColimit (ff ⋙ gg ⋙ dd) := I _
    haveI : HasColimit ((ff ⋙ gg) ⋙ dd) := I _
    haveI : HasColimit (gg ⋙ dd) := I _
    change _ = colimit.ι ((ff ⋙ gg) ⋙ dd) j ≫ _ ≫ _
    erw [colimit.pre_pre dd gg ff, colimit.ι_pre, colimit.ι_pre]
    

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
this✝¹ : HasColimit (ff ⋙ gg ⋙ dd)
this✝ : HasColimit ((ff ⋙ gg) ⋙ dd)
this : HasColimit (gg ⋙ dd)
⊢ colimit.ι (diagram ι F z) ((CostructuredArrow.map (f ≫ g)).obj j) = colimit.ι dd ((ff ⋙ gg).obj 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
    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...
    haveI : HasColimit (ff ⋙ gg ⋙ dd) := I _
    haveI : HasColimit ((ff ⋙ gg) ⋙ dd) := I _
    haveI : HasColimit (gg ⋙ dd) := I _
    change _ = colimit.ι ((ff ⋙ gg) ⋙ dd) j ≫ _ ≫ _
    erw [colimit.pre_pre dd gg ff, colimit.ι_pre, colimit.ι_pre]
    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)
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
this✝¹ : HasColimit (ff ⋙ gg ⋙ dd)
this✝ : HasColimit ((ff ⋙ gg) ⋙ dd)
this : HasColimit (gg ⋙ dd)
⊢ (CostructuredArrow.map (f ≫ g)).obj j = (ff ⋙ gg).obj j

Next tactic:
simp
/-- An auxiliary definition used to define `Lan` and `Lan.adjunction`. -/
@[simps]
def equiv (F : S ⥤ D) [I : ∀ x, HasColimit (diagram ι F x)] (G : L ⥤ D) :
    (loc ι F ⟶ G) ≃ (F ⟶ ((whiskeringLeft _ _ _).obj ι).obj G)
    where
  toFun f :=
    { app := fun x => colimit.ι (diagram ι F (ι.obj x)) (CostructuredArrow.mk (𝟙 _)) ≫ f.app _
      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
I : ∀ (x : L), HasColimit (diagram ι F x)
G : L ⥤ D
f : loc ι F ⟶ G
⊢ ∀ ⦃X Y : S⦄ (f_1 : X ⟶ Y),
    F.map f_1 ≫ (fun x => colimit.ι (diagram ι F (ι.obj x)) (CostructuredArrow.mk (𝟙 (ι.obj x))) ≫ f.app (ι.obj x)) Y =
      (fun x => colimit.ι (diagram ι F (ι.obj x)) (CostructuredArrow.mk (𝟙 (ι.obj x))) ≫ f.app (ι.obj x)) X ≫
        (((whiskeringLeft S L D).obj ι).obj G).map f_1

Next tactic:
intro x y ff
/-- An auxiliary definition used to define `Lan` and `Lan.adjunction`. -/
@[simps]
def equiv (F : S ⥤ D) [I : ∀ x, HasColimit (diagram ι F x)] (G : L ⥤ D) :
    (loc ι F ⟶ G) ≃ (F ⟶ ((whiskeringLeft _ _ _).obj ι).obj G)
    where
  toFun f :=
    { app := fun x => colimit.ι (diagram ι F (ι.obj x)) (CostructuredArrow.mk (𝟙 _)) ≫ f.app _
      naturality := by
        intro x y ff
        

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)
G : L ⥤ D
f : loc ι F ⟶ G
x y : S
ff : x ⟶ y
⊢ F.map ff ≫ (fun x => colimit.ι (diagram ι F (ι.obj x)) (CostructuredArrow.mk (𝟙 (ι.obj x))) ≫ f.app (ι.obj x)) y =
    (fun x => colimit.ι (diagram ι F (ι.obj x)) (CostructuredArrow.mk (𝟙 (ι.obj x))) ≫ f.app (ι.obj x)) x ≫
      (((whiskeringLeft S L D).obj ι).obj G).map ff

Next tactic:
dsimp only [whiskeringLeft]
/-- An auxiliary definition used to define `Lan` and `Lan.adjunction`. -/
@[simps]
def equiv (F : S ⥤ D) [I : ∀ x, HasColimit (diagram ι F x)] (G : L ⥤ D) :
    (loc ι F ⟶ G) ≃ (F ⟶ ((whiskeringLeft _ _ _).obj ι).obj G)
    where
  toFun f :=
    { app := fun x => colimit.ι (diagram ι F (ι.obj x)) (CostructuredArrow.mk (𝟙 _)) ≫ f.app _
      naturality := by
        intro x y ff
        dsimp only [whiskeringLeft]
        

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)
G : L ⥤ D
f : loc ι F ⟶ G
x y : S
ff : x ⟶ y
⊢ F.map ff ≫ colimit.ι (diagram ι F (ι.obj y)) (CostructuredArrow.mk (𝟙 (ι.obj y))) ≫ f.app (ι.obj y) =
    (colimit.ι (diagram ι F (ι.obj x)) (CostructuredArrow.mk (𝟙 (ι.obj x))) ≫ f.app (ι.obj x)) ≫ (ι ⋙ G).map ff

Next tactic:
simp only [Functor.comp_map, Category.assoc]
/-- An auxiliary definition used to define `Lan` and `Lan.adjunction`. -/
@[simps]
def equiv (F : S ⥤ D) [I : ∀ x, HasColimit (diagram ι F x)] (G : L ⥤ D) :
    (loc ι F ⟶ G) ≃ (F ⟶ ((whiskeringLeft _ _ _).obj ι).obj G)
    where
  toFun f :=
    { app := fun x => colimit.ι (diagram ι F (ι.obj x)) (CostructuredArrow.mk (𝟙 _)) ≫ f.app _
      naturality := by
        intro x y ff
        dsimp only [whiskeringLeft]
        simp only [Functor.comp_map, Category.assoc]
        

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)
G : L ⥤ D
f : loc ι F ⟶ G
x y : S
ff : x ⟶ y
⊢ F.map ff ≫ colimit.ι (diagram ι F (ι.obj y)) (CostructuredArrow.mk (𝟙 (ι.obj y))) ≫ f.app (ι.obj y) =
    colimit.ι (diagram ι F (ι.obj x)) (CostructuredArrow.mk (𝟙 (ι.obj x))) ≫ f.app (ι.obj x) ≫ G.map (ι.map ff)

Next tactic:
rw [← f.naturality (ι.map ff), ← Category.assoc, ← Category.assoc]
/-- An auxiliary definition used to define `Lan` and `Lan.adjunction`. -/
@[simps]
def equiv (F : S ⥤ D) [I : ∀ x, HasColimit (diagram ι F x)] (G : L ⥤ D) :
    (loc ι F ⟶ G) ≃ (F ⟶ ((whiskeringLeft _ _ _).obj ι).obj G)
    where
  toFun f :=
    { app := fun x => colimit.ι (diagram ι F (ι.obj x)) (CostructuredArrow.mk (𝟙 _)) ≫ f.app _
      naturality := by
        intro x y ff
        dsimp only [whiskeringLeft]
        simp only [Functor.comp_map, Category.assoc]
        rw [← f.naturality (ι.map ff), ← Category.assoc, ← Category.assoc]
        

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)
G : L ⥤ D
f : loc ι F ⟶ G
x y : S
ff : x ⟶ y
⊢ (F.map ff ≫ colimit.ι (diagram ι F (ι.obj y)) (CostructuredArrow.mk (𝟙 (ι.obj y)))) ≫ f.app (ι.obj y) =
    (colimit.ι (diagram ι F (ι.obj x)) (CostructuredArrow.mk (𝟙 (ι.obj x))) ≫ (loc ι F).map (ι.map ff)) ≫
      f.app (ι.obj y)

Next tactic:
let fff : CostructuredArrow ι _ ⥤ _ := CostructuredArrow.map (ι.map ff)
/-- An auxiliary definition used to define `Lan` and `Lan.adjunction`. -/
@[simps]
def equiv (F : S ⥤ D) [I : ∀ x, HasColimit (diagram ι F x)] (G : L ⥤ D) :
    (loc ι F ⟶ G) ≃ (F ⟶ ((whiskeringLeft _ _ _).obj ι).obj G)
    where
  toFun f :=
    { app := fun x => colimit.ι (diagram ι F (ι.obj x)) (CostructuredArrow.mk (𝟙 _)) ≫ f.app _
      naturality := by
        intro x y ff
        dsimp only [whiskeringLeft]
        simp only [Functor.comp_map, Category.assoc]
        rw [← f.naturality (ι.map ff), ← Category.assoc, ← Category.assoc]
        let fff : CostructuredArrow ι _ ⥤ _ := CostructuredArrow.map (ι.map ff)
        -- same issue :-(
        

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)
G : L ⥤ D
f : loc ι F ⟶ G
x y : S
ff : x ⟶ y
fff : CostructuredArrow ι (ι.obj x) ⥤ CostructuredArrow ι (ι.obj y) := CostructuredArrow.map (ι.map ff)
⊢ (F.map ff ≫ colimit.ι (diagram ι F (ι.obj y)) (CostructuredArrow.mk (𝟙 (ι.obj y)))) ≫ f.app (ι.obj y) =
    (colimit.ι (diagram ι F (ι.obj x)) (CostructuredArrow.mk (𝟙 (ι.obj x))) ≫ (loc ι F).map (ι.map ff)) ≫
      f.app (ι.obj y)

Next tactic:
haveI : HasColimit (fff ⋙ diagram ι F (ι.obj y)) := I _
/-- An auxiliary definition used to define `Lan` and `Lan.adjunction`. -/
@[simps]
def equiv (F : S ⥤ D) [I : ∀ x, HasColimit (diagram ι F x)] (G : L ⥤ D) :
    (loc ι F ⟶ G) ≃ (F ⟶ ((whiskeringLeft _ _ _).obj ι).obj G)
    where
  toFun f :=
    { app := fun x => colimit.ι (diagram ι F (ι.obj x)) (CostructuredArrow.mk (𝟙 _)) ≫ f.app _
      naturality := by
        intro x y ff
        dsimp only [whiskeringLeft]
        simp only [Functor.comp_map, Category.assoc]
        rw [← f.naturality (ι.map ff), ← Category.assoc, ← Category.assoc]
        let fff : CostructuredArrow ι _ ⥤ _ := CostructuredArrow.map (ι.map ff)
        -- same issue :-(
        haveI : HasColimit (fff ⋙ diagram ι F (ι.obj y)) := 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)
G : L ⥤ D
f : loc ι F ⟶ G
x y : S
ff : x ⟶ y
fff : CostructuredArrow ι (ι.obj x) ⥤ CostructuredArrow ι (ι.obj y) := CostructuredArrow.map (ι.map ff)
this : HasColimit (fff ⋙ diagram ι F (ι.obj y))
⊢ (F.map ff ≫ colimit.ι (diagram ι F (ι.obj y)) (CostructuredArrow.mk (𝟙 (ι.obj y)))) ≫ f.app (ι.obj y) =
    (colimit.ι (diagram ι F (ι.obj x)) (CostructuredArrow.mk (𝟙 (ι.obj x))) ≫ (loc ι F).map (ι.map ff)) ≫
      f.app (ι.obj y)

Next tactic:
erw [colimit.ι_pre (diagram ι F (ι.obj y)) fff (CostructuredArrow.mk (𝟙 _))]
/-- An auxiliary definition used to define `Lan` and `Lan.adjunction`. -/
@[simps]
def equiv (F : S ⥤ D) [I : ∀ x, HasColimit (diagram ι F x)] (G : L ⥤ D) :
    (loc ι F ⟶ G) ≃ (F ⟶ ((whiskeringLeft _ _ _).obj ι).obj G)
    where
  toFun f :=
    { app := fun x => colimit.ι (diagram ι F (ι.obj x)) (CostructuredArrow.mk (𝟙 _)) ≫ f.app _
      naturality := by
        intro x y ff
        dsimp only [whiskeringLeft]
        simp only [Functor.comp_map, Category.assoc]
        rw [← f.naturality (ι.map ff), ← Category.assoc, ← Category.assoc]
        let fff : CostructuredArrow ι _ ⥤ _ := CostructuredArrow.map (ι.map ff)
        -- same issue :-(
        haveI : HasColimit (fff ⋙ diagram ι F (ι.obj y)) := I _
        erw [colimit.ι_pre (diagram ι F (ι.obj y)) fff (CostructuredArrow.mk (𝟙 _))]
        

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)
G : L ⥤ D
f : loc ι F ⟶ G
x y : S
ff : x ⟶ y
fff : CostructuredArrow ι (ι.obj x) ⥤ CostructuredArrow ι (ι.obj y) := CostructuredArrow.map (ι.map ff)
this : HasColimit (fff ⋙ diagram ι F (ι.obj y))
⊢ (F.map ff ≫ colimit.ι (diagram ι F (ι.obj y)) (CostructuredArrow.mk (𝟙 (ι.obj y)))) ≫ f.app (ι.obj y) =
    colimit.ι (diagram ι F (ι.obj y)) (fff.obj (CostructuredArrow.mk (𝟙 (ι.obj x)))) ≫ f.app (ι.obj y)

Next tactic:
let xx : CostructuredArrow ι (ι.obj y) := CostructuredArrow.mk (ι.map ff)
/-- An auxiliary definition used to define `Lan` and `Lan.adjunction`. -/
@[simps]
def equiv (F : S ⥤ D) [I : ∀ x, HasColimit (diagram ι F x)] (G : L ⥤ D) :
    (loc ι F ⟶ G) ≃ (F ⟶ ((whiskeringLeft _ _ _).obj ι).obj G)
    where
  toFun f :=
    { app := fun x => colimit.ι (diagram ι F (ι.obj x)) (CostructuredArrow.mk (𝟙 _)) ≫ f.app _
      naturality := by
        intro x y ff
        dsimp only [whiskeringLeft]
        simp only [Functor.comp_map, Category.assoc]
        rw [← f.naturality (ι.map ff), ← Category.assoc, ← Category.assoc]
        let fff : CostructuredArrow ι _ ⥤ _ := CostructuredArrow.map (ι.map ff)
        -- same issue :-(
        haveI : HasColimit (fff ⋙ diagram ι F (ι.obj y)) := I _
        erw [colimit.ι_pre (diagram ι F (ι.obj y)) fff (CostructuredArrow.mk (𝟙 _))]
        let xx : CostructuredArrow ι (ι.obj y) := CostructuredArrow.mk (ι.map ff)
        

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)
G : L ⥤ D
f : loc ι F ⟶ G
x y : S
ff : x ⟶ y
fff : CostructuredArrow ι (ι.obj x) ⥤ CostructuredArrow ι (ι.obj y) := CostructuredArrow.map (ι.map ff)
this : HasColimit (fff ⋙ diagram ι F (ι.obj y))
xx : CostructuredArrow ι (ι.obj y) := CostructuredArrow.mk (ι.map ff)
⊢ (F.map ff ≫ colimit.ι (diagram ι F (ι.obj y)) (CostructuredArrow.mk (𝟙 (ι.obj y)))) ≫ f.app (ι.obj y) =
    colimit.ι (diagram ι F (ι.obj y)) (fff.obj (CostructuredArrow.mk (𝟙 (ι.obj x)))) ≫ f.app (ι.obj y)

Next tactic:
let yy : CostructuredArrow ι (ι.obj y) := CostructuredArrow.mk (𝟙 _)