Theorem: CategoryTheory.biconeMk_map
File: Mathlib/CategoryTheory/Limits/Bicones.lean

Proof steps:
state_before: J : Type v₁
inst✝¹ : SmallCategory J
C : Type u₁
inst✝ : Category.{v₁, u₁} C
F : J ⥤ C
c₁ c₂ : Cone F
X✝ Y✝ : Bicone J
f : X✝ ⟶ Y✝
⊢ (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✝
state_after: case left_id
J : Type v₁
inst✝¹ : SmallCategory J
C : Type u₁
inst✝ : Category.{v₁, u₁} C
F : J ⥤ C
c₁ c₂ : Cone F
⊢ (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) Bicone.left

case right_id
J : Type v₁
inst✝¹ : SmallCategory J
C : Type u₁
inst✝ : Category.{v₁, u₁} C
F : J ⥤ C
c₁ c₂ : Cone F
⊢ (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) Bicone.right

case left
J : Type v₁
inst✝¹ : SmallCategory J
C : Type u₁
inst✝ : Category.{v₁, u₁} C
F : J ⥤ C
c₁ c₂ : Cone F
j✝ : 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) (Bicone.diagram j✝)

case right
J : Type v₁
inst✝¹ : SmallCategory J
C : Type u₁
inst✝ : Category.{v₁, u₁} C
F : J ⥤ C
c₁ c₂ : Cone F
j✝ : 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) (Bicone.diagram j✝)

case 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✝
⊢ (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) (Bicone.diagram k✝)
tactic: rcases f with (_|_|_|_|f)
state_before: J : Type v₁
inst✝¹ : SmallCategory J
C : Type u₁
inst✝ : Category.{v₁, u₁} C
F : J ⥤ C
c₁ c₂ : Cone F
X : Bicone 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)) ⋯ f)
                  ⋯ 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)) ⋯ f)
                  ⋯ 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) ⋯ f)
                  ⋯ 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) ⋯ f)
                  ⋯ 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) ⋯ f)
                  ⋯ f)
              ⋯ ⋯ ⋯ }.map
      (𝟙 X) =
    𝟙
      ({ 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)) ⋯ f)
                    ⋯ 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)) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ f)
                ⋯ ⋯ ⋯ }.obj
        X)
state_after: no goals
tactic: cases X <;> simp
state_before: J : Type v₁
inst✝¹ : SmallCategory J
C : Type u₁
inst✝ : Category.{v₁, u₁} C
F : J ⥤ C
c₁ c₂ : Cone F
X✝ Y✝ Z✝ : Bicone J
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ { 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)) ⋯ f)
                  ⋯ 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)) ⋯ f)
                  ⋯ 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) ⋯ f)
                  ⋯ 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) ⋯ f)
                  ⋯ 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) ⋯ f)
                  ⋯ f)
              ⋯ ⋯ ⋯ }.map
      (f ≫ g) =
    { 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)) ⋯ f)
                    ⋯ 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)) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ f)
                ⋯ ⋯ ⋯ }.map
        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)) ⋯ f)
                    ⋯ 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)) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ f)
                ⋯ ⋯ ⋯ }.map
        g
state_after: case left_id
J : Type v₁
inst✝¹ : SmallCategory J
C : Type u₁
inst✝ : Category.{v₁, u₁} C
F : J ⥤ C
c₁ c₂ : Cone F
Z✝ : Bicone J
g : Bicone.left ⟶ Z✝
⊢ { 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)) ⋯ f)
                  ⋯ 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)) ⋯ f)
                  ⋯ 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) ⋯ f)
                  ⋯ 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) ⋯ f)
                  ⋯ 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) ⋯ f)
                  ⋯ f)
              ⋯ ⋯ ⋯ }.map
      (BiconeHom.left_id ≫ g) =
    { 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)) ⋯ f)
                    ⋯ 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)) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ f)
                ⋯ ⋯ ⋯ }.map
        BiconeHom.left_id ≫
      { 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)) ⋯ f)
                    ⋯ 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)) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ f)
                ⋯ ⋯ ⋯ }.map
        g

case right_id
J : Type v₁
inst✝¹ : SmallCategory J
C : Type u₁
inst✝ : Category.{v₁, u₁} C
F : J ⥤ C
c₁ c₂ : Cone F
Z✝ : Bicone J
g : Bicone.right ⟶ Z✝
⊢ { 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)) ⋯ f)
                  ⋯ 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)) ⋯ f)
                  ⋯ 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) ⋯ f)
                  ⋯ 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) ⋯ f)
                  ⋯ 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) ⋯ f)
                  ⋯ f)
              ⋯ ⋯ ⋯ }.map
      (BiconeHom.right_id ≫ g) =
    { 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)) ⋯ f)
                    ⋯ 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)) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ f)
                ⋯ ⋯ ⋯ }.map
        BiconeHom.right_id ≫
      { 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)) ⋯ f)
                    ⋯ 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)) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ f)
                ⋯ ⋯ ⋯ }.map
        g

case left
J : Type v₁
inst✝¹ : SmallCategory J
C : Type u₁
inst✝ : Category.{v₁, u₁} C
F : J ⥤ C
c₁ c₂ : Cone F
Z✝ : Bicone J
j✝ : J
g : Bicone.diagram j✝ ⟶ Z✝
⊢ { 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)) ⋯ f)
                  ⋯ 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)) ⋯ f)
                  ⋯ 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) ⋯ f)
                  ⋯ 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) ⋯ f)
                  ⋯ 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) ⋯ f)
                  ⋯ f)
              ⋯ ⋯ ⋯ }.map
      (BiconeHom.left j✝ ≫ g) =
    { 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)) ⋯ f)
                    ⋯ 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)) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ 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) ⋯ 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)) ⋯ f)
                    ⋯ 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)) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ f)
                ⋯ ⋯ ⋯ }.map
        g

case right
J : Type v₁
inst✝¹ : SmallCategory J
C : Type u₁
inst✝ : Category.{v₁, u₁} C
F : J ⥤ C
c₁ c₂ : Cone F
Z✝ : Bicone J
j✝ : J
g : Bicone.diagram j✝ ⟶ Z✝
⊢ { 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)) ⋯ f)
                  ⋯ 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)) ⋯ f)
                  ⋯ 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) ⋯ f)
                  ⋯ 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) ⋯ f)
                  ⋯ 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) ⋯ f)
                  ⋯ f)
              ⋯ ⋯ ⋯ }.map
      (BiconeHom.right j✝ ≫ g) =
    { 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)) ⋯ f)
                    ⋯ 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)) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ f)
                ⋯ ⋯ ⋯ }.map
        (BiconeHom.right 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)) ⋯ f)
                    ⋯ 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)) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ f)
                ⋯ ⋯ ⋯ }.map
        g

case diagram
J : Type v₁
inst✝¹ : SmallCategory J
C : Type u₁
inst✝ : Category.{v₁, u₁} C
F : J ⥤ C
c₁ c₂ : Cone F
Z✝ : Bicone J
j✝ k✝ : J
f✝ : j✝ ⟶ k✝
g : Bicone.diagram k✝ ⟶ Z✝
⊢ { 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)) ⋯ f)
                  ⋯ 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)) ⋯ f)
                  ⋯ 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) ⋯ f)
                  ⋯ 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) ⋯ f)
                  ⋯ 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) ⋯ f)
                  ⋯ f)
              ⋯ ⋯ ⋯ }.map
      (BiconeHom.diagram f✝ ≫ g) =
    { 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)) ⋯ f)
                    ⋯ 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)) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ f)
                ⋯ ⋯ ⋯ }.map
        (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)) ⋯ f)
                    ⋯ 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)) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ 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) ⋯ f)
                    ⋯ f)
                ⋯ ⋯ ⋯ }.map
        g
tactic: rcases f with (_|_|_|_|_)