l3lab/ntp-mathlib huggingface dataset:
/-- The diagram of the image of a `GlueData` under a functor `F` is naturally isomorphic to the
original diagram of the `GlueData` via `F`.
-/
def diagramIso : D.diagram.multispan ⋙ F ≅ (D.mapGlueData F).diagram.multispan :=
  NatIso.ofComponents
    (fun x =>
      match x with
      | WalkingMultispan.left a => Iso.refl _
      | WalkingMultispan.right b => Iso.refl _)
    (by
      rintro (⟨_, _⟩ | _) _ (_ | _ | _)
      · erw [Category.comp_id, Category.id_comp, Functor.map_id]
        rfl
      · erw [Category.comp_id, Category.id_comp]
        rfl
      · 

Proof state:
case left.mk.snd
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
fst✝ snd✝ : D.J
⊢ (MultispanIndex.multispan (diagram D) ⋙ F).map (WalkingMultispan.Hom.snd (fst✝, snd✝)) ≫
      ((fun x =>
            match x with
            | WalkingMultispan.left a =>
              Iso.refl ((MultispanIndex.multispan (diagram D) ⋙ F).obj (WalkingMultispan.left a))
            | WalkingMultispan.right b =>
              Iso.refl ((MultispanIndex.multispan (diagram D) ⋙ F).obj (WalkingMultispan.right b)))
          (WalkingMultispan.right (MultispanIndex.sndFrom (diagram D) (fst✝, snd✝)))).hom =
    ((fun x =>
            match x with
            | WalkingMultispan.left a =>
              Iso.refl ((MultispanIndex.multispan (diagram D) ⋙ F).obj (WalkingMultispan.left a))
            | WalkingMultispan.right b =>
              Iso.refl ((MultispanIndex.multispan (diagram D) ⋙ F).obj (WalkingMultispan.right b)))
          (WalkingMultispan.left (fst✝, snd✝))).hom ≫
      (MultispanIndex.multispan (diagram (mapGlueData D F))).map (WalkingMultispan.Hom.snd (fst✝, snd✝))

Next tactic:
erw [Category.comp_id, Category.id_comp, Functor.map_comp]
/-- The diagram of the image of a `GlueData` under a functor `F` is naturally isomorphic to the
original diagram of the `GlueData` via `F`.
-/
def diagramIso : D.diagram.multispan ⋙ F ≅ (D.mapGlueData F).diagram.multispan :=
  NatIso.ofComponents
    (fun x =>
      match x with
      | WalkingMultispan.left a => Iso.refl _
      | WalkingMultispan.right b => Iso.refl _)
    (by
      rintro (⟨_, _⟩ | _) _ (_ | _ | _)
      · erw [Category.comp_id, Category.id_comp, Functor.map_id]
        rfl
      · erw [Category.comp_id, Category.id_comp]
        rfl
      · erw [Category.comp_id, Category.id_comp, Functor.map_comp]
        

Proof state:
case left.mk.snd
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
fst✝ snd✝ : D.J
⊢ F.map (t D fst✝ snd✝) ≫ F.map (f D snd✝ fst✝) =
    (MultispanIndex.multispan (diagram (mapGlueData D F))).map (WalkingMultispan.Hom.snd (fst✝, snd✝))

Next tactic:
rfl
/-- The diagram of the image of a `GlueData` under a functor `F` is naturally isomorphic to the
original diagram of the `GlueData` via `F`.
-/
def diagramIso : D.diagram.multispan ⋙ F ≅ (D.mapGlueData F).diagram.multispan :=
  NatIso.ofComponents
    (fun x =>
      match x with
      | WalkingMultispan.left a => Iso.refl _
      | WalkingMultispan.right b => Iso.refl _)
    (by
      rintro (⟨_, _⟩ | _) _ (_ | _ | _)
      · erw [Category.comp_id, Category.id_comp, Functor.map_id]
        rfl
      · erw [Category.comp_id, Category.id_comp]
        rfl
      · erw [Category.comp_id, Category.id_comp, Functor.map_comp]
        rfl
      · 

Proof state:
case right.id
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
a✝ : (diagram D).R
⊢ (MultispanIndex.multispan (diagram D) ⋙ F).map (WalkingMultispan.Hom.id (WalkingMultispan.right a✝)) ≫
      ((fun x =>
            match x with
            | WalkingMultispan.left a =>
              Iso.refl ((MultispanIndex.multispan (diagram D) ⋙ F).obj (WalkingMultispan.left a))
            | WalkingMultispan.right b =>
              Iso.refl ((MultispanIndex.multispan (diagram D) ⋙ F).obj (WalkingMultispan.right b)))
          (WalkingMultispan.right a✝)).hom =
    ((fun x =>
            match x with
            | WalkingMultispan.left a =>
              Iso.refl ((MultispanIndex.multispan (diagram D) ⋙ F).obj (WalkingMultispan.left a))
            | WalkingMultispan.right b =>
              Iso.refl ((MultispanIndex.multispan (diagram D) ⋙ F).obj (WalkingMultispan.right b)))
          (WalkingMultispan.right a✝)).hom ≫
      (MultispanIndex.multispan (diagram (mapGlueData D F))).map (WalkingMultispan.Hom.id (WalkingMultispan.right a✝))

Next tactic:
erw [Category.comp_id, Category.id_comp, Functor.map_id]
/-- The diagram of the image of a `GlueData` under a functor `F` is naturally isomorphic to the
original diagram of the `GlueData` via `F`.
-/
def diagramIso : D.diagram.multispan ⋙ F ≅ (D.mapGlueData F).diagram.multispan :=
  NatIso.ofComponents
    (fun x =>
      match x with
      | WalkingMultispan.left a => Iso.refl _
      | WalkingMultispan.right b => Iso.refl _)
    (by
      rintro (⟨_, _⟩ | _) _ (_ | _ | _)
      · erw [Category.comp_id, Category.id_comp, Functor.map_id]
        rfl
      · erw [Category.comp_id, Category.id_comp]
        rfl
      · erw [Category.comp_id, Category.id_comp, Functor.map_comp]
        rfl
      · erw [Category.comp_id, Category.id_comp, Functor.map_id]
        

Proof state:
case right.id
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
a✝ : (diagram D).R
⊢ 𝟙 ((MultispanIndex.multispan (diagram D) ⋙ F).obj (WalkingMultispan.right a✝)) =
    (MultispanIndex.multispan (diagram (mapGlueData D F))).map (WalkingMultispan.Hom.id (WalkingMultispan.right a✝))

Next tactic:
rfl
@[reassoc (attr := simp)]
theorem ι_gluedIso_hom (i : D.J) : F.map (D.ι i) ≫ (D.gluedIso F).hom = (D.mapGlueData F).ι i := by
  

Proof state:
C : Type u₁
inst✝³ : Category.{v, u₁} C
C' : Type u₂
inst✝² : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝¹ : HasMulticoequalizer (diagram D)
inst✝ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i : D.J
⊢ F.map (ι D i) ≫ (gluedIso D F).hom = ι (mapGlueData D F) i

Next tactic:
haveI : HasColimit (MultispanIndex.multispan (diagram (mapGlueData D F))) := inferInstance
@[reassoc (attr := simp)]
theorem ι_gluedIso_hom (i : D.J) : F.map (D.ι i) ≫ (D.gluedIso F).hom = (D.mapGlueData F).ι i := by
  haveI : HasColimit (MultispanIndex.multispan (diagram (mapGlueData D F))) := inferInstance
  

Proof state:
C : Type u₁
inst✝³ : Category.{v, u₁} C
C' : Type u₂
inst✝² : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝¹ : HasMulticoequalizer (diagram D)
inst✝ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i : D.J
this : HasColimit (MultispanIndex.multispan (diagram (mapGlueData D F)))
⊢ F.map (ι D i) ≫ (gluedIso D F).hom = ι (mapGlueData D F) i

Next tactic:
erw [ι_preservesColimitsIso_hom_assoc]
@[reassoc (attr := simp)]
theorem ι_gluedIso_hom (i : D.J) : F.map (D.ι i) ≫ (D.gluedIso F).hom = (D.mapGlueData F).ι i := by
  haveI : HasColimit (MultispanIndex.multispan (diagram (mapGlueData D F))) := inferInstance
  erw [ι_preservesColimitsIso_hom_assoc]
  

Proof state:
C : Type u₁
inst✝³ : Category.{v, u₁} C
C' : Type u₂
inst✝² : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝¹ : HasMulticoequalizer (diagram D)
inst✝ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i : D.J
this : HasColimit (MultispanIndex.multispan (diagram (mapGlueData D F)))
⊢ colimit.ι (MultispanIndex.multispan (diagram D) ⋙ F) (WalkingMultispan.right i) ≫
      (HasColimit.isoOfNatIso (diagramIso D F)).hom =
    ι (mapGlueData D F) i

Next tactic:
rw [HasColimit.isoOfNatIso_ι_hom]
@[reassoc (attr := simp)]
theorem ι_gluedIso_hom (i : D.J) : F.map (D.ι i) ≫ (D.gluedIso F).hom = (D.mapGlueData F).ι i := by
  haveI : HasColimit (MultispanIndex.multispan (diagram (mapGlueData D F))) := inferInstance
  erw [ι_preservesColimitsIso_hom_assoc]
  rw [HasColimit.isoOfNatIso_ι_hom]
  

Proof state:
C : Type u₁
inst✝³ : Category.{v, u₁} C
C' : Type u₂
inst✝² : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝¹ : HasMulticoequalizer (diagram D)
inst✝ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i : D.J
this : HasColimit (MultispanIndex.multispan (diagram (mapGlueData D F)))
⊢ (diagramIso D F).hom.app (WalkingMultispan.right i) ≫
      colimit.ι (MultispanIndex.multispan (diagram (mapGlueData D F))) (WalkingMultispan.right i) =
    ι (mapGlueData D F) i

Next tactic:
erw [Category.id_comp]
@[reassoc (attr := simp)]
theorem ι_gluedIso_hom (i : D.J) : F.map (D.ι i) ≫ (D.gluedIso F).hom = (D.mapGlueData F).ι i := by
  haveI : HasColimit (MultispanIndex.multispan (diagram (mapGlueData D F))) := inferInstance
  erw [ι_preservesColimitsIso_hom_assoc]
  rw [HasColimit.isoOfNatIso_ι_hom]
  erw [Category.id_comp]
  

Proof state:
C : Type u₁
inst✝³ : Category.{v, u₁} C
C' : Type u₂
inst✝² : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝¹ : HasMulticoequalizer (diagram D)
inst✝ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i : D.J
this : HasColimit (MultispanIndex.multispan (diagram (mapGlueData D F)))
⊢ colimit.ι (MultispanIndex.multispan (diagram (mapGlueData D F))) (WalkingMultispan.right i) = ι (mapGlueData D F) i

Next tactic:
rfl
@[reassoc (attr := simp)]
theorem ι_gluedIso_inv (i : D.J) : (D.mapGlueData F).ι i ≫ (D.gluedIso F).inv = F.map (D.ι i) := by
  

Proof state:
C : Type u₁
inst✝³ : Category.{v, u₁} C
C' : Type u₂
inst✝² : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝¹ : HasMulticoequalizer (diagram D)
inst✝ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i : D.J
⊢ ι (mapGlueData D F) i ≫ (gluedIso D F).inv = F.map (ι D i)

Next tactic:
rw [Iso.comp_inv_eq, ι_gluedIso_hom]
/-- If `F` preserves the gluing, and reflects the pullback of `U i ⟶ glued` and `U j ⟶ glued`,
then `F` reflects the fact that `V_pullback_cone` is a pullback. -/
def vPullbackConeIsLimitOfMap (i j : D.J) [ReflectsLimit (cospan (D.ι i) (D.ι j)) F]
    (hc : IsLimit ((D.mapGlueData F).vPullbackCone i j)) : IsLimit (D.vPullbackCone i j) := by
  

Proof state:
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
⊢ IsLimit (vPullbackCone D i j)

Next tactic:
apply isLimitOfReflects F
/-- If `F` preserves the gluing, and reflects the pullback of `U i ⟶ glued` and `U j ⟶ glued`,
then `F` reflects the fact that `V_pullback_cone` is a pullback. -/
def vPullbackConeIsLimitOfMap (i j : D.J) [ReflectsLimit (cospan (D.ι i) (D.ι j)) F]
    (hc : IsLimit ((D.mapGlueData F).vPullbackCone i j)) : IsLimit (D.vPullbackCone i j) := by
  apply isLimitOfReflects F
  

Proof state:
case t
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
⊢ IsLimit (F.mapCone (vPullbackCone D i j))

Next tactic:
apply (isLimitMapConePullbackConeEquiv _ _).symm _
/-- If `F` preserves the gluing, and reflects the pullback of `U i ⟶ glued` and `U j ⟶ glued`,
then `F` reflects the fact that `V_pullback_cone` is a pullback. -/
def vPullbackConeIsLimitOfMap (i j : D.J) [ReflectsLimit (cospan (D.ι i) (D.ι j)) F]
    (hc : IsLimit ((D.mapGlueData F).vPullbackCone i j)) : IsLimit (D.vPullbackCone i j) := by
  apply isLimitOfReflects F
  apply (isLimitMapConePullbackConeEquiv _ _).symm _
  

Proof state:
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
⊢ IsLimit
    (PullbackCone.mk (F.map (f D i j)) (F.map (t D i j ≫ f D j i))
      (_ : F.map (f D i j) ≫ F.map (ι D i) = F.map (t D i j ≫ f D j i) ≫ F.map (ι D j)))

Next tactic:
let e :
    cospan (F.map (D.ι i)) (F.map (D.ι j)) ≅
      cospan ((D.mapGlueData F).ι i) ((D.mapGlueData F).ι j)
/-- If `F` preserves the gluing, and reflects the pullback of `U i ⟶ glued` and `U j ⟶ glued`,
then `F` reflects the fact that `V_pullback_cone` is a pullback. -/
def vPullbackConeIsLimitOfMap (i j : D.J) [ReflectsLimit (cospan (D.ι i) (D.ι j)) F]
    (hc : IsLimit ((D.mapGlueData F).vPullbackCone i j)) : IsLimit (D.vPullbackCone i j) := by
  apply isLimitOfReflects F
  apply (isLimitMapConePullbackConeEquiv _ _).symm _
  let e :
    cospan (F.map (D.ι i)) (F.map (D.ι j)) ≅
      cospan ((D.mapGlueData F).ι i) ((D.mapGlueData F).ι j)
  

Proof state:
case e
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
⊢ cospan (F.map (ι D i)) (F.map (ι D j)) ≅ cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
e : cospan (F.map (ι D i)) (F.map (ι D j)) ≅ cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j) := ?e
⊢ IsLimit
    (PullbackCone.mk (F.map (f D i j)) (F.map (t D i j ≫ f D j i))
      (_ : F.map (f D i j) ≫ F.map (ι D i) = F.map (t D i j ≫ f D j i) ≫ F.map (ι D j)))

Next tactic:
exact
    NatIso.ofComponents
      (fun x => by
        cases x
        exacts [D.gluedIso F, Iso.refl _])
      (by rintro (_ | _) (_ | _) (_ | _ | _) <;> simp)
/-- If `F` preserves the gluing, and reflects the pullback of `U i ⟶ glued` and `U j ⟶ glued`,
then `F` reflects the fact that `V_pullback_cone` is a pullback. -/
def vPullbackConeIsLimitOfMap (i j : D.J) [ReflectsLimit (cospan (D.ι i) (D.ι j)) F]
    (hc : IsLimit ((D.mapGlueData F).vPullbackCone i j)) : IsLimit (D.vPullbackCone i j) := by
  apply isLimitOfReflects F
  apply (isLimitMapConePullbackConeEquiv _ _).symm _
  let e :
    cospan (F.map (D.ι i)) (F.map (D.ι j)) ≅
      cospan ((D.mapGlueData F).ι i) ((D.mapGlueData F).ι j)
  exact
    NatIso.ofComponents
      (fun x => by
        

Proof state:
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
x : WalkingCospan
⊢ (cospan (F.map (ι D i)) (F.map (ι D j))).obj x ≅ (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).obj x

Next tactic:
cases x
/-- If `F` preserves the gluing, and reflects the pullback of `U i ⟶ glued` and `U j ⟶ glued`,
then `F` reflects the fact that `V_pullback_cone` is a pullback. -/
def vPullbackConeIsLimitOfMap (i j : D.J) [ReflectsLimit (cospan (D.ι i) (D.ι j)) F]
    (hc : IsLimit ((D.mapGlueData F).vPullbackCone i j)) : IsLimit (D.vPullbackCone i j) := by
  apply isLimitOfReflects F
  apply (isLimitMapConePullbackConeEquiv _ _).symm _
  let e :
    cospan (F.map (D.ι i)) (F.map (D.ι j)) ≅
      cospan ((D.mapGlueData F).ι i) ((D.mapGlueData F).ι j)
  exact
    NatIso.ofComponents
      (fun x => by
        cases x
        

Proof state:
case none
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
⊢ (cospan (F.map (ι D i)) (F.map (ι D j))).obj none ≅ (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).obj none
case some
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
val✝ : WalkingPair
⊢ (cospan (F.map (ι D i)) (F.map (ι D j))).obj (some val✝) ≅
    (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).obj (some val✝)

Next tactic:
exacts [D.gluedIso F, Iso.refl _]
/-- If `F` preserves the gluing, and reflects the pullback of `U i ⟶ glued` and `U j ⟶ glued`,
then `F` reflects the fact that `V_pullback_cone` is a pullback. -/
def vPullbackConeIsLimitOfMap (i j : D.J) [ReflectsLimit (cospan (D.ι i) (D.ι j)) F]
    (hc : IsLimit ((D.mapGlueData F).vPullbackCone i j)) : IsLimit (D.vPullbackCone i j) := by
  apply isLimitOfReflects F
  apply (isLimitMapConePullbackConeEquiv _ _).symm _
  let e :
    cospan (F.map (D.ι i)) (F.map (D.ι j)) ≅
      cospan ((D.mapGlueData F).ι i) ((D.mapGlueData F).ι j)
  exact
    NatIso.ofComponents
      (fun x => by
        cases x
        exacts [D.gluedIso F, Iso.refl _])
      (by 

Proof state:
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
⊢ ∀ {X Y : WalkingCospan} (f : X ⟶ Y),
    (cospan (F.map (ι D i)) (F.map (ι D j))).map f ≫
        ((fun x =>
              Option.casesOn (motive := fun t =>
                x = t →
                  ((cospan (F.map (ι D i)) (F.map (ι D j))).obj x ≅
                    (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).obj x))
                x (fun h => (_ : none = x) ▸ gluedIso D F)
                (fun val h => (_ : some val = x) ▸ Iso.refl ((cospan (F.map (ι D i)) (F.map (ι D j))).obj (some val)))
                (_ : x = x))
            Y).hom =
      ((fun x =>
              Option.casesOn (motive := fun t =>
                x = t →
                  ((cospan (F.map (ι D i)) (F.map (ι D j))).obj x ≅
                    (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).obj x))
                x (fun h => (_ : none = x) ▸ gluedIso D F)
                (fun val h => (_ : some val = x) ▸ Iso.refl ((cospan (F.map (ι D i)) (F.map (ι D j))).obj (some val)))
                (_ : x = x))
            X).hom ≫
        (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).map f

Next tactic:
rintro (_ | _) (_ | _) (_ | _ | _)
/-- If `F` preserves the gluing, and reflects the pullback of `U i ⟶ glued` and `U j ⟶ glued`,
then `F` reflects the fact that `V_pullback_cone` is a pullback. -/
def vPullbackConeIsLimitOfMap (i j : D.J) [ReflectsLimit (cospan (D.ι i) (D.ι j)) F]
    (hc : IsLimit ((D.mapGlueData F).vPullbackCone i j)) : IsLimit (D.vPullbackCone i j) := by
  apply isLimitOfReflects F
  apply (isLimitMapConePullbackConeEquiv _ _).symm _
  let e :
    cospan (F.map (D.ι i)) (F.map (D.ι j)) ≅
      cospan ((D.mapGlueData F).ι i) ((D.mapGlueData F).ι j)
  exact
    NatIso.ofComponents
      (fun x => by
        cases x
        exacts [D.gluedIso F, Iso.refl _])
      (by rintro (_ | _) (_ | _) (_ | _ | _) <;> 

Proof state:
case none.none.id
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
⊢ (cospan (F.map (ι D i)) (F.map (ι D j))).map (WidePullbackShape.Hom.id none) ≫
      ((fun x =>
            Option.casesOn (motive := fun t =>
              x = t →
                ((cospan (F.map (ι D i)) (F.map (ι D j))).obj x ≅
                  (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).obj x))
              x (fun h => (_ : none = x) ▸ gluedIso D F)
              (fun val h => (_ : some val = x) ▸ Iso.refl ((cospan (F.map (ι D i)) (F.map (ι D j))).obj (some val)))
              (_ : x = x))
          none).hom =
    ((fun x =>
            Option.casesOn (motive := fun t =>
              x = t →
                ((cospan (F.map (ι D i)) (F.map (ι D j))).obj x ≅
                  (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).obj x))
              x (fun h => (_ : none = x) ▸ gluedIso D F)
              (fun val h => (_ : some val = x) ▸ Iso.refl ((cospan (F.map (ι D i)) (F.map (ι D j))).obj (some val)))
              (_ : x = x))
          none).hom ≫
      (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).map (WidePullbackShape.Hom.id none)

Next tactic:
simp