/-- Given a diagram `F : J ⥤ C` and two `Cone F`s, we can join them into a diagram `Bicone J ⥤ C`.
-/
@[simps]
def biconeMk {C : Type u₁} [Category.{v₁} C] {F : J ⥤ C} (c₁ c₂ : Cone F) : Bicone J ⥤ C
    where
  obj X := Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j
  map f := by
    rcases f with (_|_|_|_|f)
    · exact 𝟙 _
    · exact 𝟙 _
    · exact c₁.π.app _
    · exact c₂.π.app _
    · exact F.map f
  map_id X := by cases X <;> simp
  map_comp f g := by
    rcases f with (_|_|_|_|_)
    · exact (Category.id_comp _).symm
    · exact (Category.id_comp _).symm
    · cases g
      

Proof state:
case left.diagram
J : Type v₁
inst✝¹ : SmallCategory J
C : Type u₁
inst✝ : Category.{v₁, u₁} C
F : J ⥤ C
c₁ c₂ : Cone F
j✝ k✝ : J
f✝ : j✝ ⟶ k✝
⊢ { obj := fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j,
          map := fun {X Y} f =>
            BiconeHom.casesOn (motive := fun a a_1 x =>
              X = a →
                Y = a_1 →
                  HEq f x →
                    ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) X ⟶
                      (fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Y))
              f
              (fun h =>
                Eq.ndrec (motive := fun {X} =>
                  (f : X ⟶ Y) →
                    Y = Bicone.left →
                      HEq f BiconeHom.left_id →
                        ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) X ⟶
                          (fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Y))
                  (fun f h =>
                    Eq.ndrec (motive := fun {Y} =>
                      (f : Bicone.left ⟶ Y) →
                        HEq f BiconeHom.left_id →
                          ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Bicone.left ⟶
                            (fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Y))
                      (fun f h => 𝟙 ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Bicone.left))
                      (_ : Bicone.left = Y) f)
                  (_ : Bicone.left = X) f)
              (fun h =>
                Eq.ndrec (motive := fun {X} =>
                  (f : X ⟶ Y) →
                    Y = Bicone.right →
                      HEq f BiconeHom.right_id →
                        ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) X ⟶
                          (fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Y))
                  (fun f h =>
                    Eq.ndrec (motive := fun {Y} =>
                      (f : Bicone.right ⟶ Y) →
                        HEq f BiconeHom.right_id →
                          ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Bicone.right ⟶
                            (fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Y))
                      (fun f h => 𝟙 ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Bicone.right))
                      (_ : Bicone.right = Y) f)
                  (_ : Bicone.right = X) f)
              (fun j h =>
                Eq.ndrec (motive := fun {X} =>
                  (f : X ⟶ Y) →
                    Y = Bicone.diagram j →
                      HEq f (BiconeHom.left j) →
                        ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) X ⟶
                          (fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Y))
                  (fun f h =>
                    Eq.ndrec (motive := fun {Y} =>
                      (f : Bicone.left ⟶ Y) →
                        HEq f (BiconeHom.left j) →
                          ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Bicone.left ⟶
                            (fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Y))
                      (fun f h => c₁.π.app j) (_ : Bicone.diagram j = Y) f)
                  (_ : Bicone.left = X) f)
              (fun j h =>
                Eq.ndrec (motive := fun {X} =>
                  (f : X ⟶ Y) →
                    Y = Bicone.diagram j →
                      HEq f (BiconeHom.right j) →
                        ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) X ⟶
                          (fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Y))
                  (fun f h =>
                    Eq.ndrec (motive := fun {Y} =>
                      (f : Bicone.right ⟶ Y) →
                        HEq f (BiconeHom.right j) →
                          ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Bicone.right ⟶
                            (fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Y))
                      (fun f h => c₂.π.app j) (_ : Bicone.diagram j = Y) f)
                  (_ : Bicone.right = X) f)
              (fun {j k} f_1 h =>
                Eq.ndrec (motive := fun {X} =>
                  (f : X ⟶ Y) →
                    Y = Bicone.diagram k →
                      HEq f (BiconeHom.diagram f_1) →
                        ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) X ⟶
                          (fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Y))
                  (fun f h =>
                    Eq.ndrec (motive := fun {Y} =>
                      (f : Bicone.diagram j ⟶ Y) →
                        HEq f (BiconeHom.diagram f_1) →
                          ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) (Bicone.diagram j) ⟶
                            (fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Y))
                      (fun f h => F.map f_1) (_ : Bicone.diagram k = Y) f)
                  (_ : Bicone.diagram j = X) f)
              (_ : X = X) (_ : Y = Y) (_ : HEq f f) }.map
      (BiconeHom.left j✝ ≫ BiconeHom.diagram f✝) =
    { obj := fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j,
            map := fun {X Y} f =>
              BiconeHom.casesOn (motive := fun a a_1 x =>
                X = a →
                  Y = a_1 →
                    HEq f x →
                      ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) X ⟶
                        (fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Y))
                f
                (fun h =>
                  Eq.ndrec (motive := fun {X} =>
                    (f : X ⟶ Y) →
                      Y = Bicone.left →
                        HEq f BiconeHom.left_id →
                          ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) X ⟶
                            (fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Y))
                    (fun f h =>
                      Eq.ndrec (motive := fun {Y} =>
                        (f : Bicone.left ⟶ Y) →
                          HEq f BiconeHom.left_id →
                            ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Bicone.left ⟶
                              (fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Y))
                        (fun f h => 𝟙 ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Bicone.left))
                        (_ : Bicone.left = Y) f)
                    (_ : Bicone.left = X) f)
                (fun h =>
                  Eq.ndrec (motive := fun {X} =>
                    (f : X ⟶ Y) →
                      Y = Bicone.right →
                        HEq f BiconeHom.right_id →
                          ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) X ⟶
                            (fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Y))
                    (fun f h =>
                      Eq.ndrec (motive := fun {Y} =>
                        (f : Bicone.right ⟶ Y) →
                          HEq f BiconeHom.right_id →
                            ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Bicone.right ⟶
                              (fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Y))
                        (fun f h => 𝟙 ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Bicone.right))
                        (_ : Bicone.right = Y) f)
                    (_ : Bicone.right = X) f)
                (fun j h =>
                  Eq.ndrec (motive := fun {X} =>
                    (f : X ⟶ Y) →
                      Y = Bicone.diagram j →
                        HEq f (BiconeHom.left j) →
                          ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) X ⟶
                            (fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Y))
                    (fun f h =>
                      Eq.ndrec (motive := fun {Y} =>
                        (f : Bicone.left ⟶ Y) →
                          HEq f (BiconeHom.left j) →
                            ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Bicone.left ⟶
                              (fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Y))
                        (fun f h => c₁.π.app j) (_ : Bicone.diagram j = Y) f)
                    (_ : Bicone.left = X) f)
                (fun j h =>
                  Eq.ndrec (motive := fun {X} =>
                    (f : X ⟶ Y) →
                      Y = Bicone.diagram j →
                        HEq f (BiconeHom.right j) →
                          ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) X ⟶
                            (fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Y))
                    (fun f h =>
                      Eq.ndrec (motive := fun {Y} =>
                        (f : Bicone.right ⟶ Y) →
                          HEq f (BiconeHom.right j) →
                            ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Bicone.right ⟶
                              (fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Y))
                        (fun f h => c₂.π.app j) (_ : Bicone.diagram j = Y) f)
                    (_ : Bicone.right = X) f)
                (fun {j k} f_1 h =>
                  Eq.ndrec (motive := fun {X} =>
                    (f : X ⟶ Y) →
                      Y = Bicone.diagram k →
                        HEq f (BiconeHom.diagram f_1) →
                          ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) X ⟶
                            (fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Y))
                    (fun f h =>
                      Eq.ndrec (motive := fun {Y} =>
                        (f : Bicone.diagram j ⟶ Y) →
                          HEq f (BiconeHom.diagram f_1) →
                            ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) (Bicone.diagram j) ⟶
                              (fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Y))
                        (fun f h => F.map f_1) (_ : Bicone.diagram k = Y) f)
                    (_ : Bicone.diagram j = X) f)
                (_ : X = X) (_ : Y = Y) (_ : HEq f f) }.map
        (BiconeHom.left j✝) ≫
      { obj := fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j,
            map := fun {X Y} f =>
              BiconeHom.casesOn (motive := fun a a_1 x =>
                X = a →
                  Y = a_1 →
                    HEq f x →
                      ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) X ⟶
                        (fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Y))
                f
                (fun h =>
                  Eq.ndrec (motive := fun {X} =>
                    (f : X ⟶ Y) →
                      Y = Bicone.left →
                        HEq f BiconeHom.left_id →
                          ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) X ⟶
                            (fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Y))
                    (fun f h =>
                      Eq.ndrec (motive := fun {Y} =>
                        (f : Bicone.left ⟶ Y) →
                          HEq f BiconeHom.left_id →
                            ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Bicone.left ⟶
                              (fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Y))
                        (fun f h => 𝟙 ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Bicone.left))
                        (_ : Bicone.left = Y) f)
                    (_ : Bicone.left = X) f)
                (fun h =>
                  Eq.ndrec (motive := fun {X} =>
                    (f : X ⟶ Y) →
                      Y = Bicone.right →
                        HEq f BiconeHom.right_id →
                          ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) X ⟶
                            (fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Y))
                    (fun f h =>
                      Eq.ndrec (motive := fun {Y} =>
                        (f : Bicone.right ⟶ Y) →
                          HEq f BiconeHom.right_id →
                            ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Bicone.right ⟶
                              (fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Y))
                        (fun f h => 𝟙 ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Bicone.right))
                        (_ : Bicone.right = Y) f)
                    (_ : Bicone.right = X) f)
                (fun j h =>
                  Eq.ndrec (motive := fun {X} =>
                    (f : X ⟶ Y) →
                      Y = Bicone.diagram j →
                        HEq f (BiconeHom.left j) →
                          ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) X ⟶
                            (fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Y))
                    (fun f h =>
                      Eq.ndrec (motive := fun {Y} =>
                        (f : Bicone.left ⟶ Y) →
                          HEq f (BiconeHom.left j) →
                            ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Bicone.left ⟶
                              (fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Y))
                        (fun f h => c₁.π.app j) (_ : Bicone.diagram j = Y) f)
                    (_ : Bicone.left = X) f)
                (fun j h =>
                  Eq.ndrec (motive := fun {X} =>
                    (f : X ⟶ Y) →
                      Y = Bicone.diagram j →
                        HEq f (BiconeHom.right j) →
                          ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) X ⟶
                            (fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Y))
                    (fun f h =>
                      Eq.ndrec (motive := fun {Y} =>
                        (f : Bicone.right ⟶ Y) →
                          HEq f (BiconeHom.right j) →
                            ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Bicone.right ⟶
                              (fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Y))
                        (fun f h => c₂.π.app j) (_ : Bicone.diagram j = Y) f)
                    (_ : Bicone.right = X) f)
                (fun {j k} f_1 h =>
                  Eq.ndrec (motive := fun {X} =>
                    (f : X ⟶ Y) →
                      Y = Bicone.diagram k →
                        HEq f (BiconeHom.diagram f_1) →
                          ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) X ⟶
                            (fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Y))
                    (fun f h =>
                      Eq.ndrec (motive := fun {Y} =>
                        (f : Bicone.diagram j ⟶ Y) →
                          HEq f (BiconeHom.diagram f_1) →
                            ((fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) (Bicone.diagram j) ⟶
                              (fun X => Bicone.casesOn X c₁.pt c₂.pt fun j => F.obj j) Y))
                        (fun f h => F.map f_1) (_ : Bicone.diagram k = Y) f)
                    (_ : Bicone.diagram j = X) f)
                (_ : X = X) (_ : Y = Y) (_ : HEq f f) }.map
        (BiconeHom.diagram f✝)

Next tactic:
exact (Category.id_comp _).symm.trans (c₁.π.naturality _)