Theorem: CategoryTheory.PreservesFiniteLimitsOfFlat.uniq
File: Mathlib/CategoryTheory/Functor/Flat.lean

tactic: let α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  { app := fun X => eqToHom (by simp [← h₁])
    naturality := fun j₁ j₂ φ => by
      ext
      simp only [Functor.mapCone_pt, Functor.comp_obj, toDiagram_obj,
        Functor.mapCone_π_app, map_mk, mk_right, Functor.comp_map, toDiagram_map, comp_right,
        map_map_right, homMk_right]
      rw [Comma.eqToHom_right, Comma.eqToHom_right] simp }
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
⊢ f₁ = f₂

tactic: let α₂ : toDiagram (F.mapCone c) ⋙ map f₂ ⟶ toDiagram s :=
  { app := fun X => eqToHom (by simp [← h₂])
    naturality := fun _ _ _ => by
      ext
      simp only [Functor.mapCone_pt, Functor.comp_obj, toDiagram_obj, Functor.mapCone_π_app,
        map_mk, mk_right, Functor.comp_map, toDiagram_map, comp_right, map_map_right, homMk_right]
      rw [Comma.eqToHom_right, Comma.eqToHom_right] simp }
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
⊢ f₁ = f₂

tactic: let c₁ : Cone (toDiagram s ⋙ pre s.pt K F) :=
  (Cones.postcompose (whiskerRight α₁ (pre s.pt K F) : _)).obj (toCone F c f₁)
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
α₂ : toDiagram (F.mapCone c) ⋙ map f₂ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
⊢ f₁ = f₂

tactic: let c₂ : Cone (toDiagram s ⋙ pre s.pt K F) :=
  (Cones.postcompose (whiskerRight α₂ (pre s.pt K F) : _)).obj (toCone F c f₂)
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
α₂ : toDiagram (F.mapCone c) ⋙ map f₂ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
c₁ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₁ (pre s.pt K F))).obj (toCone F c f₁)
⊢ f₁ = f₂

tactic: let c₀ := IsCofiltered.cone (biconeMk _ c₁ c₂)
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
α₂ : toDiagram (F.mapCone c) ⋙ map f₂ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
c₁ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₁ (pre s.pt K F))).obj (toCone F c f₁)
c₂ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₂ (pre s.pt K F))).obj (toCone F c f₂)
⊢ f₁ = f₂

tactic: let g₁ : c₀.pt ⟶ c₁.pt := c₀.π.app Bicone.left
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
α₂ : toDiagram (F.mapCone c) ⋙ map f₂ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
c₁ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₁ (pre s.pt K F))).obj (toCone F c f₁)
c₂ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₂ (pre s.pt K F))).obj (toCone F c f₂)
c₀ : Cone (biconeMk J c₁ c₂) := IsCofiltered.cone (biconeMk J c₁ c₂)
⊢ f₁ = f₂

tactic: let g₂ : c₀.pt ⟶ c₂.pt := c₀.π.app Bicone.right
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
α₂ : toDiagram (F.mapCone c) ⋙ map f₂ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
c₁ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₁ (pre s.pt K F))).obj (toCone F c f₁)
c₂ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₂ (pre s.pt K F))).obj (toCone F c f₂)
c₀ : Cone (biconeMk J c₁ c₂) := IsCofiltered.cone (biconeMk J c₁ c₂)
g₁ : c₀.pt ⟶ c₁.pt := c₀.π.app Bicone.left
⊢ f₁ = f₂

tactic: have : ∀ j : J, g₁.right ≫ c.π.app j = g₂.right ≫ c.π.app j := by
  intro j
  injection c₀.π.naturality (BiconeHom.left j) with _ e₁
  injection c₀.π.naturality (BiconeHom.right j) with _ e₂
  have e₃ := e₁.symm.trans e₂
  simp (config := {zeta := false}) at e₃ rw [Comma.eqToHom_right, Comma.eqToHom_right] at e₃ simpa (config := {zeta := false}) using e₃
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
α₂ : toDiagram (F.mapCone c) ⋙ map f₂ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
c₁ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₁ (pre s.pt K F))).obj (toCone F c f₁)
c₂ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₂ (pre s.pt K F))).obj (toCone F c f₂)
c₀ : Cone (biconeMk J c₁ c₂) := IsCofiltered.cone (biconeMk J c₁ c₂)
g₁ : c₀.pt ⟶ c₁.pt := c₀.π.app Bicone.left
g₂ : c₀.pt ⟶ c₂.pt := c₀.π.app Bicone.right
⊢ f₁ = f₂

tactic: have : c.extend g₁.right = c.extend g₂.right := by
  unfold Cone.extend
  congr 1
  ext x
  apply this
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
α₂ : toDiagram (F.mapCone c) ⋙ map f₂ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
c₁ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₁ (pre s.pt K F))).obj (toCone F c f₁)
c₂ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₂ (pre s.pt K F))).obj (toCone F c f₂)
c₀ : Cone (biconeMk J c₁ c₂) := IsCofiltered.cone (biconeMk J c₁ c₂)
g₁ : c₀.pt ⟶ c₁.pt := c₀.π.app Bicone.left
g₂ : c₀.pt ⟶ c₂.pt := c₀.π.app Bicone.right
this : ∀ (j : J), g₁.right ≫ c.π.app j = g₂.right ≫ c.π.app j
⊢ f₁ = f₂

tactic: have : g₁.right = g₂.right
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
α₂ : toDiagram (F.mapCone c) ⋙ map f₂ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
c₁ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₁ (pre s.pt K F))).obj (toCone F c f₁)
c₂ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₂ (pre s.pt K F))).obj (toCone F c f₂)
c₀ : Cone (biconeMk J c₁ c₂) := IsCofiltered.cone (biconeMk J c₁ c₂)
g₁ : c₀.pt ⟶ c₁.pt := c₀.π.app Bicone.left
g₂ : c₀.pt ⟶ c₂.pt := c₀.π.app Bicone.right
this✝ : ∀ (j : J), g₁.right ≫ c.π.app j = g₂.right ≫ c.π.app j
this : Cone.extend c g₁.right = Cone.extend c g₂.right
⊢ f₁ = f₂

tactic: calc
  g₁.right = hc.lift (c.extend g₁.right) := by
    apply hc.uniq (c.extend _)
    intro j ; rfl
  _ = hc.lift (c.extend g₂.right) := by
    congr
  _ = g₂.right := by
    symm
    apply hc.uniq (c.extend _)
    intro _ ; rfl
state_before: case this
C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
α₂ : toDiagram (F.mapCone c) ⋙ map f₂ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
c₁ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₁ (pre s.pt K F))).obj (toCone F c f₁)
c₂ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₂ (pre s.pt K F))).obj (toCone F c f₂)
c₀ : Cone (biconeMk J c₁ c₂) := IsCofiltered.cone (biconeMk J c₁ c₂)
g₁ : c₀.pt ⟶ c₁.pt := c₀.π.app Bicone.left
g₂ : c₀.pt ⟶ c₂.pt := c₀.π.app Bicone.right
this✝ : ∀ (j : J), g₁.right ≫ c.π.app j = g₂.right ≫ c.π.app j
this : Cone.extend c g₁.right = Cone.extend c g₂.right
⊢ g₁.right = g₂.right

C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
α₂ : toDiagram (F.mapCone c) ⋙ map f₂ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
c₁ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₁ (pre s.pt K F))).obj (toCone F c f₁)
c₂ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₂ (pre s.pt K F))).obj (toCone F c f₂)
c₀ : Cone (biconeMk J c₁ c₂) := IsCofiltered.cone (biconeMk J c₁ c₂)
g₁ : c₀.pt ⟶ c₁.pt := c₀.π.app Bicone.left
g₂ : c₀.pt ⟶ c₂.pt := c₀.π.app Bicone.right
this✝¹ : ∀ (j : J), g₁.right ≫ c.π.app j = g₂.right ≫ c.π.app j
this✝ : Cone.extend c g₁.right = Cone.extend c g₂.right
this : g₁.right = g₂.right
⊢ f₁ = f₂

tactic: calc
  f₁ = 𝟙 _ ≫ f₁ := by simp
  _ = c₀.pt.hom ≫ F.map g₁.right := g₁.w
  _ = c₀.pt.hom ≫ F.map g₂.right := by rw [this]
  _ = 𝟙 _ ≫ f₂ := g₂.w.symm
  _ = f₂ := by simp
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
α₂ : toDiagram (F.mapCone c) ⋙ map f₂ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
c₁ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₁ (pre s.pt K F))).obj (toCone F c f₁)
c₂ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₂ (pre s.pt K F))).obj (toCone F c f₂)
c₀ : Cone (biconeMk J c₁ c₂) := IsCofiltered.cone (biconeMk J c₁ c₂)
g₁ : c₀.pt ⟶ c₁.pt := c₀.π.app Bicone.left
g₂ : c₀.pt ⟶ c₂.pt := c₀.π.app Bicone.right
this✝¹ : ∀ (j : J), g₁.right ≫ c.π.app j = g₂.right ≫ c.π.app j
this✝ : Cone.extend c g₁.right = Cone.extend c g₂.right
this : g₁.right = g₂.right
⊢ f₁ = f₂

tactic: simp [← h₁]
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
X : J
⊢ (toDiagram (F.mapCone c) ⋙ map f₁).obj X = (toDiagram s).obj X

tactic: ext
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
j₁ j₂ : J
φ : j₁ ⟶ j₂
⊢ (toDiagram (F.mapCone c) ⋙ map f₁).map φ ≫
      (fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))) j₂ =
    (fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))) j₁ ≫
      (toDiagram s).map φ

tactic: simp only [Functor.mapCone_pt, Functor.comp_obj, toDiagram_obj,
  Functor.mapCone_π_app, map_mk, mk_right, Functor.comp_map, toDiagram_map, comp_right,
  map_map_right, homMk_right]
state_before: case h
C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
j₁ j₂ : J
φ : j₁ ⟶ j₂
⊢ ((toDiagram (F.mapCone c) ⋙ map f₁).map φ ≫
        (fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X)))
          j₂).right =
    ((fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))) j₁ ≫
        (toDiagram s).map φ).right

tactic: rw [Comma.eqToHom_right, Comma.eqToHom_right]
state_before: case h
C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
j₁ j₂ : J
φ : j₁ ⟶ j₂
⊢ φ ≫ (eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app j₂)) = StructuredArrow.mk (s.π.app j₂))).right =
    (eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app j₁)) = StructuredArrow.mk (s.π.app j₁))).right ≫ φ

tactic: simp
state_before: case h
C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
j₁ j₂ : J
φ : j₁ ⟶ j₂
⊢ φ ≫ eqToHom (_ : (StructuredArrow.mk (f₁ ≫ F.map (c.π.app j₂))).right = (StructuredArrow.mk (s.π.app j₂)).right) =
    eqToHom (_ : (StructuredArrow.mk (f₁ ≫ F.map (c.π.app j₁))).right = (StructuredArrow.mk (s.π.app j₁)).right) ≫ φ

tactic: simp [← h₂]
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
X : J
⊢ (toDiagram (F.mapCone c) ⋙ map f₂).obj X = (toDiagram s).obj X

tactic: ext
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
x✝² x✝¹ : J
x✝ : x✝² ⟶ x✝¹
⊢ (toDiagram (F.mapCone c) ⋙ map f₂).map x✝ ≫
      (fun X => eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))) x✝¹ =
    (fun X => eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))) x✝² ≫
      (toDiagram s).map x✝

tactic: simp only [Functor.mapCone_pt, Functor.comp_obj, toDiagram_obj, Functor.mapCone_π_app,
  map_mk, mk_right, Functor.comp_map, toDiagram_map, comp_right, map_map_right, homMk_right]
state_before: case h
C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
x✝² x✝¹ : J
x✝ : x✝² ⟶ x✝¹
⊢ ((toDiagram (F.mapCone c) ⋙ map f₂).map x✝ ≫
        (fun X => eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X)))
          x✝¹).right =
    ((fun X => eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))) x✝² ≫
        (toDiagram s).map x✝).right

tactic: rw [Comma.eqToHom_right, Comma.eqToHom_right]
state_before: case h
C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
x✝² x✝¹ : J
x✝ : x✝² ⟶ x✝¹
⊢ x✝ ≫ (eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app x✝¹)) = StructuredArrow.mk (s.π.app x✝¹))).right =
    (eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app x✝²)) = StructuredArrow.mk (s.π.app x✝²))).right ≫ x✝

tactic: simp
state_before: case h
C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
x✝² x✝¹ : J
x✝ : x✝² ⟶ x✝¹
⊢ x✝ ≫ eqToHom (_ : (StructuredArrow.mk (f₂ ≫ F.map (c.π.app x✝¹))).right = (StructuredArrow.mk (s.π.app x✝¹)).right) =
    eqToHom (_ : (StructuredArrow.mk (f₂ ≫ F.map (c.π.app x✝²))).right = (StructuredArrow.mk (s.π.app x✝²)).right) ≫ x✝

tactic: intro j
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
α₂ : toDiagram (F.mapCone c) ⋙ map f₂ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
c₁ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₁ (pre s.pt K F))).obj (toCone F c f₁)
c₂ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₂ (pre s.pt K F))).obj (toCone F c f₂)
c₀ : Cone (biconeMk J c₁ c₂) := IsCofiltered.cone (biconeMk J c₁ c₂)
g₁ : c₀.pt ⟶ c₁.pt := c₀.π.app Bicone.left
g₂ : c₀.pt ⟶ c₂.pt := c₀.π.app Bicone.right
⊢ ∀ (j : J), g₁.right ≫ c.π.app j = g₂.right ≫ c.π.app j

tactic: injection c₀.π.naturality (BiconeHom.left j) with _ e₁
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
α₂ : toDiagram (F.mapCone c) ⋙ map f₂ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
c₁ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₁ (pre s.pt K F))).obj (toCone F c f₁)
c₂ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₂ (pre s.pt K F))).obj (toCone F c f₂)
c₀ : Cone (biconeMk J c₁ c₂) := IsCofiltered.cone (biconeMk J c₁ c₂)
g₁ : c₀.pt ⟶ c₁.pt := c₀.π.app Bicone.left
g₂ : c₀.pt ⟶ c₂.pt := c₀.π.app Bicone.right
j : J
⊢ g₁.right ≫ c.π.app j = g₂.right ≫ c.π.app j

tactic: injection c₀.π.naturality (BiconeHom.right j) with _ e₂
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
α₂ : toDiagram (F.mapCone c) ⋙ map f₂ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
c₁ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₁ (pre s.pt K F))).obj (toCone F c f₁)
c₂ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₂ (pre s.pt K F))).obj (toCone F c f₂)
c₀ : Cone (biconeMk J c₁ c₂) := IsCofiltered.cone (biconeMk J c₁ c₂)
g₁ : c₀.pt ⟶ c₁.pt := c₀.π.app Bicone.left
g₂ : c₀.pt ⟶ c₂.pt := c₀.π.app Bicone.right
j : J
left_eq✝ :
  (((Functor.const (Bicone J)).obj c₀.pt).map (BiconeHom.left j)).left ≫ (c₀.π.app (Bicone.diagram j)).left =
    (c₀.π.app Bicone.left).left ≫ ((biconeMk J c₁ c₂).map (BiconeHom.left j)).left
e₁ :
  (((Functor.const (Bicone J)).obj c₀.pt).map (BiconeHom.left j)).right ≫ (c₀.π.app (Bicone.diagram j)).right =
    (c₀.π.app Bicone.left).right ≫ ((biconeMk J c₁ c₂).map (BiconeHom.left j)).right
⊢ g₁.right ≫ c.π.app j = g₂.right ≫ c.π.app j

tactic: have e₃ := e₁.symm.trans e₂
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
α₂ : toDiagram (F.mapCone c) ⋙ map f₂ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
c₁ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₁ (pre s.pt K F))).obj (toCone F c f₁)
c₂ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₂ (pre s.pt K F))).obj (toCone F c f₂)
c₀ : Cone (biconeMk J c₁ c₂) := IsCofiltered.cone (biconeMk J c₁ c₂)
g₁ : c₀.pt ⟶ c₁.pt := c₀.π.app Bicone.left
g₂ : c₀.pt ⟶ c₂.pt := c₀.π.app Bicone.right
j : J
left_eq✝¹ :
  (((Functor.const (Bicone J)).obj c₀.pt).map (BiconeHom.left j)).left ≫ (c₀.π.app (Bicone.diagram j)).left =
    (c₀.π.app Bicone.left).left ≫ ((biconeMk J c₁ c₂).map (BiconeHom.left j)).left
e₁ :
  (((Functor.const (Bicone J)).obj c₀.pt).map (BiconeHom.left j)).right ≫ (c₀.π.app (Bicone.diagram j)).right =
    (c₀.π.app Bicone.left).right ≫ ((biconeMk J c₁ c₂).map (BiconeHom.left j)).right
left_eq✝ :
  (((Functor.const (Bicone J)).obj c₀.pt).map (BiconeHom.right j)).left ≫ (c₀.π.app (Bicone.diagram j)).left =
    (c₀.π.app Bicone.right).left ≫ ((biconeMk J c₁ c₂).map (BiconeHom.right j)).left
e₂ :
  (((Functor.const (Bicone J)).obj c₀.pt).map (BiconeHom.right j)).right ≫ (c₀.π.app (Bicone.diagram j)).right =
    (c₀.π.app Bicone.right).right ≫ ((biconeMk J c₁ c₂).map (BiconeHom.right j)).right
⊢ g₁.right ≫ c.π.app j = g₂.right ≫ c.π.app j

tactic: simp (config := {zeta := false}) at e₃
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
α₂ : toDiagram (F.mapCone c) ⋙ map f₂ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
c₁ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₁ (pre s.pt K F))).obj (toCone F c f₁)
c₂ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₂ (pre s.pt K F))).obj (toCone F c f₂)
c₀ : Cone (biconeMk J c₁ c₂) := IsCofiltered.cone (biconeMk J c₁ c₂)
g₁ : c₀.pt ⟶ c₁.pt := c₀.π.app Bicone.left
g₂ : c₀.pt ⟶ c₂.pt := c₀.π.app Bicone.right
j : J
left_eq✝¹ :
  (((Functor.const (Bicone J)).obj c₀.pt).map (BiconeHom.left j)).left ≫ (c₀.π.app (Bicone.diagram j)).left =
    (c₀.π.app Bicone.left).left ≫ ((biconeMk J c₁ c₂).map (BiconeHom.left j)).left
e₁ :
  (((Functor.const (Bicone J)).obj c₀.pt).map (BiconeHom.left j)).right ≫ (c₀.π.app (Bicone.diagram j)).right =
    (c₀.π.app Bicone.left).right ≫ ((biconeMk J c₁ c₂).map (BiconeHom.left j)).right
left_eq✝ :
  (((Functor.const (Bicone J)).obj c₀.pt).map (BiconeHom.right j)).left ≫ (c₀.π.app (Bicone.diagram j)).left =
    (c₀.π.app Bicone.right).left ≫ ((biconeMk J c₁ c₂).map (BiconeHom.right j)).left
e₂ :
  (((Functor.const (Bicone J)).obj c₀.pt).map (BiconeHom.right j)).right ≫ (c₀.π.app (Bicone.diagram j)).right =
    (c₀.π.app Bicone.right).right ≫ ((biconeMk J c₁ c₂).map (BiconeHom.right j)).right
e₃ :
  (c₀.π.app Bicone.left).right ≫ ((biconeMk J c₁ c₂).map (BiconeHom.left j)).right =
    (c₀.π.app Bicone.right).right ≫ ((biconeMk J c₁ c₂).map (BiconeHom.right j)).right
⊢ g₁.right ≫ c.π.app j = g₂.right ≫ c.π.app j

tactic: rw [Comma.eqToHom_right, Comma.eqToHom_right] at e₃
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
α₂ : toDiagram (F.mapCone c) ⋙ map f₂ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
c₁ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₁ (pre s.pt K F))).obj (toCone F c f₁)
c₂ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₂ (pre s.pt K F))).obj (toCone F c f₂)
c₀ : Cone (biconeMk J c₁ c₂) := IsCofiltered.cone (biconeMk J c₁ c₂)
g₁ : c₀.pt ⟶ c₁.pt := c₀.π.app Bicone.left
g₂ : c₀.pt ⟶ c₂.pt := c₀.π.app Bicone.right
j : J
left_eq✝¹ :
  (((Functor.const (Bicone J)).obj c₀.pt).map (BiconeHom.left j)).left ≫ (c₀.π.app (Bicone.diagram j)).left =
    (c₀.π.app Bicone.left).left ≫ ((biconeMk J c₁ c₂).map (BiconeHom.left j)).left
e₁ :
  (((Functor.const (Bicone J)).obj c₀.pt).map (BiconeHom.left j)).right ≫ (c₀.π.app (Bicone.diagram j)).right =
    (c₀.π.app Bicone.left).right ≫ ((biconeMk J c₁ c₂).map (BiconeHom.left j)).right
left_eq✝ :
  (((Functor.const (Bicone J)).obj c₀.pt).map (BiconeHom.right j)).left ≫ (c₀.π.app (Bicone.diagram j)).left =
    (c₀.π.app Bicone.right).left ≫ ((biconeMk J c₁ c₂).map (BiconeHom.right j)).left
e₂ :
  (((Functor.const (Bicone J)).obj c₀.pt).map (BiconeHom.right j)).right ≫ (c₀.π.app (Bicone.diagram j)).right =
    (c₀.π.app Bicone.right).right ≫ ((biconeMk J c₁ c₂).map (BiconeHom.right j)).right
e₃ :
  (c₀.π.app Bicone.left).right ≫
      c.π.app j ≫
        (eqToHom
            (_ :
              (pre s.pt K F).obj (StructuredArrow.mk (f₁ ≫ F.map (c.π.app j))) =
                (pre s.pt K F).obj (StructuredArrow.mk (s.π.app j)))).right =
    (c₀.π.app Bicone.right).right ≫
      c.π.app j ≫
        (eqToHom
            (_ :
              (pre s.pt K F).obj (StructuredArrow.mk (f₂ ≫ F.map (c.π.app j))) =
                (pre s.pt K F).obj (StructuredArrow.mk (s.π.app j)))).right
⊢ g₁.right ≫ c.π.app j = g₂.right ≫ c.π.app j

tactic: simpa (config := {zeta := false}) using e₃
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
α₂ : toDiagram (F.mapCone c) ⋙ map f₂ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
c₁ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₁ (pre s.pt K F))).obj (toCone F c f₁)
c₂ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₂ (pre s.pt K F))).obj (toCone F c f₂)
c₀ : Cone (biconeMk J c₁ c₂) := IsCofiltered.cone (biconeMk J c₁ c₂)
g₁ : c₀.pt ⟶ c₁.pt := c₀.π.app Bicone.left
g₂ : c₀.pt ⟶ c₂.pt := c₀.π.app Bicone.right
j : J
left_eq✝¹ :
  (((Functor.const (Bicone J)).obj c₀.pt).map (BiconeHom.left j)).left ≫ (c₀.π.app (Bicone.diagram j)).left =
    (c₀.π.app Bicone.left).left ≫ ((biconeMk J c₁ c₂).map (BiconeHom.left j)).left
e₁ :
  (((Functor.const (Bicone J)).obj c₀.pt).map (BiconeHom.left j)).right ≫ (c₀.π.app (Bicone.diagram j)).right =
    (c₀.π.app Bicone.left).right ≫ ((biconeMk J c₁ c₂).map (BiconeHom.left j)).right
left_eq✝ :
  (((Functor.const (Bicone J)).obj c₀.pt).map (BiconeHom.right j)).left ≫ (c₀.π.app (Bicone.diagram j)).left =
    (c₀.π.app Bicone.right).left ≫ ((biconeMk J c₁ c₂).map (BiconeHom.right j)).left
e₂ :
  (((Functor.const (Bicone J)).obj c₀.pt).map (BiconeHom.right j)).right ≫ (c₀.π.app (Bicone.diagram j)).right =
    (c₀.π.app Bicone.right).right ≫ ((biconeMk J c₁ c₂).map (BiconeHom.right j)).right
e₃ :
  (c₀.π.app Bicone.left).right ≫
      c.π.app j ≫
        eqToHom
          (_ :
            ((pre s.pt K F).obj (StructuredArrow.mk (f₁ ≫ F.map (c.π.app j)))).right =
              ((pre s.pt K F).obj (StructuredArrow.mk (s.π.app j))).right) =
    (c₀.π.app Bicone.right).right ≫
      c.π.app j ≫
        eqToHom
          (_ :
            ((pre s.pt K F).obj (StructuredArrow.mk (f₂ ≫ F.map (c.π.app j)))).right =
              ((pre s.pt K F).obj (StructuredArrow.mk (s.π.app j))).right)
⊢ g₁.right ≫ c.π.app j = g₂.right ≫ c.π.app j

tactic: unfold Cone.extend
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
α₂ : toDiagram (F.mapCone c) ⋙ map f₂ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
c₁ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₁ (pre s.pt K F))).obj (toCone F c f₁)
c₂ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₂ (pre s.pt K F))).obj (toCone F c f₂)
c₀ : Cone (biconeMk J c₁ c₂) := IsCofiltered.cone (biconeMk J c₁ c₂)
g₁ : c₀.pt ⟶ c₁.pt := c₀.π.app Bicone.left
g₂ : c₀.pt ⟶ c₂.pt := c₀.π.app Bicone.right
this : ∀ (j : J), g₁.right ≫ c.π.app j = g₂.right ≫ c.π.app j
⊢ Cone.extend c g₁.right = Cone.extend c g₂.right

tactic: congr 1
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
α₂ : toDiagram (F.mapCone c) ⋙ map f₂ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
c₁ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₁ (pre s.pt K F))).obj (toCone F c f₁)
c₂ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₂ (pre s.pt K F))).obj (toCone F c f₂)
c₀ : Cone (biconeMk J c₁ c₂) := IsCofiltered.cone (biconeMk J c₁ c₂)
g₁ : c₀.pt ⟶ c₁.pt := c₀.π.app Bicone.left
g₂ : c₀.pt ⟶ c₂.pt := c₀.π.app Bicone.right
this : ∀ (j : J), g₁.right ≫ c.π.app j = g₂.right ≫ c.π.app j
⊢ { pt := c₀.pt.right, π := (Cone.extensions c).app c₀.pt.right.op { down := g₁.right } } =
    { pt := c₀.pt.right, π := (Cone.extensions c).app c₀.pt.right.op { down := g₂.right } }

tactic: ext x
state_before: case e_π
C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
α₂ : toDiagram (F.mapCone c) ⋙ map f₂ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
c₁ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₁ (pre s.pt K F))).obj (toCone F c f₁)
c₂ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₂ (pre s.pt K F))).obj (toCone F c f₂)
c₀ : Cone (biconeMk J c₁ c₂) := IsCofiltered.cone (biconeMk J c₁ c₂)
g₁ : c₀.pt ⟶ c₁.pt := c₀.π.app Bicone.left
g₂ : c₀.pt ⟶ c₂.pt := c₀.π.app Bicone.right
this : ∀ (j : J), g₁.right ≫ c.π.app j = g₂.right ≫ c.π.app j
⊢ (Cone.extensions c).app c₀.pt.right.op { down := g₁.right } =
    (Cone.extensions c).app c₀.pt.right.op { down := g₂.right }

tactic: apply this
state_before: case e_π.w.h
C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
α₂ : toDiagram (F.mapCone c) ⋙ map f₂ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
c₁ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₁ (pre s.pt K F))).obj (toCone F c f₁)
c₂ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₂ (pre s.pt K F))).obj (toCone F c f₂)
c₀ : Cone (biconeMk J c₁ c₂) := IsCofiltered.cone (biconeMk J c₁ c₂)
g₁ : c₀.pt ⟶ c₁.pt := c₀.π.app Bicone.left
g₂ : c₀.pt ⟶ c₂.pt := c₀.π.app Bicone.right
this : ∀ (j : J), g₁.right ≫ c.π.app j = g₂.right ≫ c.π.app j
x : J
⊢ ((Cone.extensions c).app c₀.pt.right.op { down := g₁.right }).app x =
    ((Cone.extensions c).app c₀.pt.right.op { down := g₂.right }).app x

tactic: apply hc.uniq (c.extend _)
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
α₂ : toDiagram (F.mapCone c) ⋙ map f₂ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
c₁ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₁ (pre s.pt K F))).obj (toCone F c f₁)
c₂ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₂ (pre s.pt K F))).obj (toCone F c f₂)
c₀ : Cone (biconeMk J c₁ c₂) := IsCofiltered.cone (biconeMk J c₁ c₂)
g₁ : c₀.pt ⟶ c₁.pt := c₀.π.app Bicone.left
g₂ : c₀.pt ⟶ c₂.pt := c₀.π.app Bicone.right
this✝ : ∀ (j : J), g₁.right ≫ c.π.app j = g₂.right ≫ c.π.app j
this : Cone.extend c g₁.right = Cone.extend c g₂.right
⊢ g₁.right = IsLimit.lift hc (Cone.extend c g₁.right)

tactic: intro j
state_before: case x
C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
α₂ : toDiagram (F.mapCone c) ⋙ map f₂ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
c₁ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₁ (pre s.pt K F))).obj (toCone F c f₁)
c₂ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₂ (pre s.pt K F))).obj (toCone F c f₂)
c₀ : Cone (biconeMk J c₁ c₂) := IsCofiltered.cone (biconeMk J c₁ c₂)
g₁ : c₀.pt ⟶ c₁.pt := c₀.π.app Bicone.left
g₂ : c₀.pt ⟶ c₂.pt := c₀.π.app Bicone.right
this✝ : ∀ (j : J), g₁.right ≫ c.π.app j = g₂.right ≫ c.π.app j
this : Cone.extend c g₁.right = Cone.extend c g₂.right
⊢ ∀ (j : J), g₁.right ≫ c.π.app j = (Cone.extend c g₁.right).π.app j

tactic: rfl
state_before: case x
C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
α₂ : toDiagram (F.mapCone c) ⋙ map f₂ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
c₁ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₁ (pre s.pt K F))).obj (toCone F c f₁)
c₂ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₂ (pre s.pt K F))).obj (toCone F c f₂)
c₀ : Cone (biconeMk J c₁ c₂) := IsCofiltered.cone (biconeMk J c₁ c₂)
g₁ : c₀.pt ⟶ c₁.pt := c₀.π.app Bicone.left
g₂ : c₀.pt ⟶ c₂.pt := c₀.π.app Bicone.right
this✝ : ∀ (j : J), g₁.right ≫ c.π.app j = g₂.right ≫ c.π.app j
this : Cone.extend c g₁.right = Cone.extend c g₂.right
j : J
⊢ g₁.right ≫ c.π.app j = (Cone.extend c g₁.right).π.app j

tactic: congr
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
α₂ : toDiagram (F.mapCone c) ⋙ map f₂ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
c₁ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₁ (pre s.pt K F))).obj (toCone F c f₁)
c₂ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₂ (pre s.pt K F))).obj (toCone F c f₂)
c₀ : Cone (biconeMk J c₁ c₂) := IsCofiltered.cone (biconeMk J c₁ c₂)
g₁ : c₀.pt ⟶ c₁.pt := c₀.π.app Bicone.left
g₂ : c₀.pt ⟶ c₂.pt := c₀.π.app Bicone.right
this✝ : ∀ (j : J), g₁.right ≫ c.π.app j = g₂.right ≫ c.π.app j
this : Cone.extend c g₁.right = Cone.extend c g₂.right
⊢ IsLimit.lift hc (Cone.extend c g₁.right) = IsLimit.lift hc (Cone.extend c g₂.right)

tactic: symm
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
α₂ : toDiagram (F.mapCone c) ⋙ map f₂ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
c₁ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₁ (pre s.pt K F))).obj (toCone F c f₁)
c₂ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₂ (pre s.pt K F))).obj (toCone F c f₂)
c₀ : Cone (biconeMk J c₁ c₂) := IsCofiltered.cone (biconeMk J c₁ c₂)
g₁ : c₀.pt ⟶ c₁.pt := c₀.π.app Bicone.left
g₂ : c₀.pt ⟶ c₂.pt := c₀.π.app Bicone.right
this✝ : ∀ (j : J), g₁.right ≫ c.π.app j = g₂.right ≫ c.π.app j
this : Cone.extend c g₁.right = Cone.extend c g₂.right
⊢ IsLimit.lift hc (Cone.extend c g₂.right) = g₂.right

tactic: apply hc.uniq (c.extend _)
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
α₂ : toDiagram (F.mapCone c) ⋙ map f₂ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
c₁ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₁ (pre s.pt K F))).obj (toCone F c f₁)
c₂ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₂ (pre s.pt K F))).obj (toCone F c f₂)
c₀ : Cone (biconeMk J c₁ c₂) := IsCofiltered.cone (biconeMk J c₁ c₂)
g₁ : c₀.pt ⟶ c₁.pt := c₀.π.app Bicone.left
g₂ : c₀.pt ⟶ c₂.pt := c₀.π.app Bicone.right
this✝ : ∀ (j : J), g₁.right ≫ c.π.app j = g₂.right ≫ c.π.app j
this : Cone.extend c g₁.right = Cone.extend c g₂.right
⊢ g₂.right = IsLimit.lift hc (Cone.extend c g₂.right)

tactic: intro _
state_before: case x
C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
α₂ : toDiagram (F.mapCone c) ⋙ map f₂ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
c₁ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₁ (pre s.pt K F))).obj (toCone F c f₁)
c₂ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₂ (pre s.pt K F))).obj (toCone F c f₂)
c₀ : Cone (biconeMk J c₁ c₂) := IsCofiltered.cone (biconeMk J c₁ c₂)
g₁ : c₀.pt ⟶ c₁.pt := c₀.π.app Bicone.left
g₂ : c₀.pt ⟶ c₂.pt := c₀.π.app Bicone.right
this✝ : ∀ (j : J), g₁.right ≫ c.π.app j = g₂.right ≫ c.π.app j
this : Cone.extend c g₁.right = Cone.extend c g₂.right
⊢ ∀ (j : J), g₂.right ≫ c.π.app j = (Cone.extend c g₂.right).π.app j

tactic: rfl
state_before: case x
C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
α₂ : toDiagram (F.mapCone c) ⋙ map f₂ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
c₁ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₁ (pre s.pt K F))).obj (toCone F c f₁)
c₂ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₂ (pre s.pt K F))).obj (toCone F c f₂)
c₀ : Cone (biconeMk J c₁ c₂) := IsCofiltered.cone (biconeMk J c₁ c₂)
g₁ : c₀.pt ⟶ c₁.pt := c₀.π.app Bicone.left
g₂ : c₀.pt ⟶ c₂.pt := c₀.π.app Bicone.right
this✝ : ∀ (j : J), g₁.right ≫ c.π.app j = g₂.right ≫ c.π.app j
this : Cone.extend c g₁.right = Cone.extend c g₂.right
j✝ : J
⊢ g₂.right ≫ c.π.app j✝ = (Cone.extend c g₂.right).π.app j✝

tactic: simp
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
α₂ : toDiagram (F.mapCone c) ⋙ map f₂ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
c₁ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₁ (pre s.pt K F))).obj (toCone F c f₁)
c₂ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₂ (pre s.pt K F))).obj (toCone F c f₂)
c₀ : Cone (biconeMk J c₁ c₂) := IsCofiltered.cone (biconeMk J c₁ c₂)
g₁ : c₀.pt ⟶ c₁.pt := c₀.π.app Bicone.left
g₂ : c₀.pt ⟶ c₂.pt := c₀.π.app Bicone.right
this✝¹ : ∀ (j : J), g₁.right ≫ c.π.app j = g₂.right ≫ c.π.app j
this✝ : Cone.extend c g₁.right = Cone.extend c g₂.right
this : g₁.right = g₂.right
⊢ f₁ = 𝟙 s.pt ≫ f₁

tactic: rw [this]
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
α₂ : toDiagram (F.mapCone c) ⋙ map f₂ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
c₁ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₁ (pre s.pt K F))).obj (toCone F c f₁)
c₂ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₂ (pre s.pt K F))).obj (toCone F c f₂)
c₀ : Cone (biconeMk J c₁ c₂) := IsCofiltered.cone (biconeMk J c₁ c₂)
g₁ : c₀.pt ⟶ c₁.pt := c₀.π.app Bicone.left
g₂ : c₀.pt ⟶ c₂.pt := c₀.π.app Bicone.right
this✝¹ : ∀ (j : J), g₁.right ≫ c.π.app j = g₂.right ≫ c.π.app j
this✝ : Cone.extend c g₁.right = Cone.extend c g₂.right
this : g₁.right = g₂.right
⊢ c₀.pt.hom ≫ F.map g₁.right = c₀.pt.hom ≫ F.map g₂.right

tactic: simp
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K✝ : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c✝ : Cone K✝
hc✝ : IsLimit c✝
s✝ : Cone (K✝ ⋙ F)
K : J ⥤ C
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
f₁ f₂ : s.pt ⟶ F.obj c.pt
h₁ : ∀ (j : J), f₁ ≫ (F.mapCone c).π.app j = s.π.app j
h₂ : ∀ (j : J), f₂ ≫ (F.mapCone c).π.app j = s.π.app j
α₁ : toDiagram (F.mapCone c) ⋙ map f₁ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₁ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
α₂ : toDiagram (F.mapCone c) ⋙ map f₂ ⟶ toDiagram s :=
  NatTrans.mk fun X => eqToHom (_ : StructuredArrow.mk (f₂ ≫ F.map (c.π.app X)) = StructuredArrow.mk (s.π.app X))
c₁ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₁ (pre s.pt K F))).obj (toCone F c f₁)
c₂ : Cone (toDiagram s ⋙ pre s.pt K F) := (Cones.postcompose (whiskerRight α₂ (pre s.pt K F))).obj (toCone F c f₂)
c₀ : Cone (biconeMk J c₁ c₂) := IsCofiltered.cone (biconeMk J c₁ c₂)
g₁ : c₀.pt ⟶ c₁.pt := c₀.π.app Bicone.left
g₂ : c₀.pt ⟶ c₂.pt := c₀.π.app Bicone.right
this✝¹ : ∀ (j : J), g₁.right ≫ c.π.app j = g₂.right ≫ c.π.app j
this✝ : Cone.extend c g₁.right = Cone.extend c g₂.right
this : g₁.right = g₂.right
⊢ 𝟙 s.pt ≫ f₂ = f₂