l3lab/ntp-mathlib huggingface dataset:
/-- (Impl) A preliminary definition to avoid timeouts. -/
@[simps]
def conesEquivInverseObj (B : C) {J : Type w} (F : Discrete J ⥤ Over B) (c : Cone F) :
    Cone (widePullbackDiagramOfDiagramOver B F) where
  pt := c.pt.left
  π :=
    { app := fun X => Option.casesOn X c.pt.hom fun j : J => (c.π.app ⟨j⟩).left
      -- `tidy` can do this using `case_bash`, but let's try to be a good `-T50000` citizen:
      naturality := fun X Y f => by
        dsimp; 

Proof state:
J✝ : Type w
C : Type u
inst✝ : Category.{v, u} C
X✝ B : C
J : Type w
F : Discrete J ⥤ Over B
c : Cone F
X Y : WidePullbackShape J
f : X ⟶ Y
⊢ 𝟙 c.pt.left ≫ Option.rec c.pt.hom (fun val => (c.π.app { as := val }).left) Y =
    Option.rec c.pt.hom (fun val => (c.π.app { as := val }).left) X ≫
      WidePullbackShape.Hom.rec (motive := fun a a_1 t =>
        X = a →
          Y = a_1 →
            HEq f t →
              (Option.rec B (fun val => (F.obj { as := val }).left) X ⟶
                Option.rec B (fun val => (F.obj { as := val }).left) Y))
        (fun X_1 h =>
          Eq.rec (motive := fun x x_1 =>
            Y = x →
              HEq f (𝟙 x) →
                (Option.rec B (fun val => (F.obj { as := val }).left) X ⟶
                  Option.rec B (fun val => (F.obj { as := val }).left) Y))
            (fun h =>
              Eq.rec (motive := fun x x_1 =>
                (f : X ⟶ x) →
                  HEq f (𝟙 X) →
                    (Option.rec B (fun val => (F.obj { as := val }).left) X ⟶
                      Option.rec B (fun val => (F.obj { as := val }).left) x))
                (fun f h => 𝟙 (Option.rec B (fun val => (F.obj { as := val }).left) X)) (_ : X = Y) f)
            h)
        (fun j h =>
          Eq.rec (motive := fun x x_1 =>
            (f : x ⟶ Y) →
              Y = none →
                HEq f (WidePullbackShape.Hom.term j) →
                  (Option.rec B (fun val => (F.obj { as := val }).left) x ⟶
                    Option.rec B (fun val => (F.obj { as := val }).left) Y))
            (fun f h =>
              Eq.rec (motive := fun x x_1 =>
                (f : some j ⟶ x) →
                  HEq f (WidePullbackShape.Hom.term j) →
                    ((F.obj { as := j }).left ⟶ Option.rec B (fun val => (F.obj { as := val }).left) x))
                (fun f h => (F.obj { as := j }).hom) (_ : none = Y) f)
            (_ : some j = X) f)
        f (_ : X = X) (_ : Y = Y) (_ : HEq f f)

Next tactic:
cases X
/-- (Impl) A preliminary definition to avoid timeouts. -/
@[simps]
def conesEquivInverseObj (B : C) {J : Type w} (F : Discrete J ⥤ Over B) (c : Cone F) :
    Cone (widePullbackDiagramOfDiagramOver B F) where
  pt := c.pt.left
  π :=
    { app := fun X => Option.casesOn X c.pt.hom fun j : J => (c.π.app ⟨j⟩).left
      -- `tidy` can do this using `case_bash`, but let's try to be a good `-T50000` citizen:
      naturality := fun X Y f => by
        dsimp; cases X <;> 

Proof state:
case none
J✝ : Type w
C : Type u
inst✝ : Category.{v, u} C
X B : C
J : Type w
F : Discrete J ⥤ Over B
c : Cone F
Y : WidePullbackShape J
f : none ⟶ Y
⊢ 𝟙 c.pt.left ≫ Option.rec c.pt.hom (fun val => (c.π.app { as := val }).left) Y =
    Option.rec c.pt.hom (fun val => (c.π.app { as := val }).left) none ≫
      WidePullbackShape.Hom.rec (motive := fun a a_1 t =>
        none = a →
          Y = a_1 →
            HEq f t →
              (Option.rec B (fun val => (F.obj { as := val }).left) none ⟶
                Option.rec B (fun val => (F.obj { as := val }).left) Y))
        (fun X h =>
          Eq.rec (motive := fun x x_1 =>
            Y = x →
              HEq f (𝟙 x) →
                (Option.rec B (fun val => (F.obj { as := val }).left) none ⟶
                  Option.rec B (fun val => (F.obj { as := val }).left) Y))
            (fun h =>
              Eq.rec (motive := fun x x_1 =>
                (f : none ⟶ x) →
                  HEq f (𝟙 none) →
                    (Option.rec B (fun val => (F.obj { as := val }).left) none ⟶
                      Option.rec B (fun val => (F.obj { as := val }).left) x))
                (fun f h => 𝟙 (Option.rec B (fun val => (F.obj { as := val }).left) none)) (_ : none = Y) f)
            h)
        (fun j h =>
          Eq.rec (motive := fun x x_1 =>
            (f : x ⟶ Y) →
              Y = none →
                HEq f (WidePullbackShape.Hom.term j) →
                  (Option.rec B (fun val => (F.obj { as := val }).left) x ⟶
                    Option.rec B (fun val => (F.obj { as := val }).left) Y))
            (fun f h =>
              Eq.rec (motive := fun x x_1 =>
                (f : some j ⟶ x) →
                  HEq f (WidePullbackShape.Hom.term j) →
                    ((F.obj { as := j }).left ⟶ Option.rec B (fun val => (F.obj { as := val }).left) x))
                (fun f h => (F.obj { as := j }).hom) (_ : none = Y) f)
            (_ : some j = none) f)
        f (_ : none = none) (_ : Y = Y) (_ : HEq f f)

Next tactic:
cases Y
/-- (Impl) A preliminary definition to avoid timeouts. -/
@[simps]
def conesEquivInverseObj (B : C) {J : Type w} (F : Discrete J ⥤ Over B) (c : Cone F) :
    Cone (widePullbackDiagramOfDiagramOver B F) where
  pt := c.pt.left
  π :=
    { app := fun X => Option.casesOn X c.pt.hom fun j : J => (c.π.app ⟨j⟩).left
      -- `tidy` can do this using `case_bash`, but let's try to be a good `-T50000` citizen:
      naturality := fun X Y f => by
        dsimp; cases X <;> 

Proof state:
case some
J✝ : Type w
C : Type u
inst✝ : Category.{v, u} C
X B : C
J : Type w
F : Discrete J ⥤ Over B
c : Cone F
Y : WidePullbackShape J
val✝ : J
f : some val✝ ⟶ Y
⊢ 𝟙 c.pt.left ≫ Option.rec c.pt.hom (fun val => (c.π.app { as := val }).left) Y =
    Option.rec c.pt.hom (fun val => (c.π.app { as := val }).left) (some val✝) ≫
      WidePullbackShape.Hom.rec (motive := fun a a_1 t =>
        some val✝ = a →
          Y = a_1 →
            HEq f t →
              (Option.rec B (fun val => (F.obj { as := val }).left) (some val✝) ⟶
                Option.rec B (fun val => (F.obj { as := val }).left) Y))
        (fun X h =>
          Eq.rec (motive := fun x x_1 =>
            Y = x →
              HEq f (𝟙 x) →
                (Option.rec B (fun val => (F.obj { as := val }).left) (some val✝) ⟶
                  Option.rec B (fun val => (F.obj { as := val }).left) Y))
            (fun h =>
              Eq.rec (motive := fun x x_1 =>
                (f : some val✝ ⟶ x) →
                  HEq f (𝟙 (some val✝)) →
                    (Option.rec B (fun val => (F.obj { as := val }).left) (some val✝) ⟶
                      Option.rec B (fun val => (F.obj { as := val }).left) x))
                (fun f h => 𝟙 (Option.rec B (fun val => (F.obj { as := val }).left) (some val✝))) (_ : some val✝ = Y) f)
            h)
        (fun j h =>
          Eq.rec (motive := fun x x_1 =>
            (f : x ⟶ Y) →
              Y = none →
                HEq f (WidePullbackShape.Hom.term j) →
                  (Option.rec B (fun val => (F.obj { as := val }).left) x ⟶
                    Option.rec B (fun val => (F.obj { as := val }).left) Y))
            (fun f h =>
              Eq.rec (motive := fun x x_1 =>
                (f : some j ⟶ x) →
                  HEq f (WidePullbackShape.Hom.term j) →
                    ((F.obj { as := j }).left ⟶ Option.rec B (fun val => (F.obj { as := val }).left) x))
                (fun f h => (F.obj { as := j }).hom) (_ : none = Y) f)
            (_ : some j = some val✝) f)
        f (_ : some val✝ = some val✝) (_ : Y = Y) (_ : HEq f f)

Next tactic:
cases Y
/-- (Impl) A preliminary definition to avoid timeouts. -/
@[simps]
def conesEquivInverseObj (B : C) {J : Type w} (F : Discrete J ⥤ Over B) (c : Cone F) :
    Cone (widePullbackDiagramOfDiagramOver B F) where
  pt := c.pt.left
  π :=
    { app := fun X => Option.casesOn X c.pt.hom fun j : J => (c.π.app ⟨j⟩).left
      -- `tidy` can do this using `case_bash`, but let's try to be a good `-T50000` citizen:
      naturality := fun X Y f => by
        dsimp; cases X <;> cases Y <;> 

Proof state:
case none.none
J✝ : Type w
C : Type u
inst✝ : Category.{v, u} C
X B : C
J : Type w
F : Discrete J ⥤ Over B
c : Cone F
f : none ⟶ none
⊢ 𝟙 c.pt.left ≫ Option.rec c.pt.hom (fun val => (c.π.app { as := val }).left) none =
    Option.rec c.pt.hom (fun val => (c.π.app { as := val }).left) none ≫
      WidePullbackShape.Hom.rec (motive := fun a a_1 t =>
        none = a →
          none = a_1 →
            HEq f t →
              (Option.rec B (fun val => (F.obj { as := val }).left) none ⟶
                Option.rec B (fun val => (F.obj { as := val }).left) none))
        (fun X h =>
          Eq.rec (motive := fun x x_1 =>
            none = x →
              HEq f (𝟙 x) →
                (Option.rec B (fun val => (F.obj { as := val }).left) none ⟶
                  Option.rec B (fun val => (F.obj { as := val }).left) none))
            (fun h =>
              Eq.rec (motive := fun x x_1 =>
                (f : none ⟶ x) →
                  HEq f (𝟙 none) →
                    (Option.rec B (fun val => (F.obj { as := val }).left) none ⟶
                      Option.rec B (fun val => (F.obj { as := val }).left) x))
                (fun f h => 𝟙 (Option.rec B (fun val => (F.obj { as := val }).left) none)) (_ : none = none) f)
            h)
        (fun j h =>
          Eq.rec (motive := fun x x_1 =>
            (f : x ⟶ none) →
              none = none →
                HEq f (WidePullbackShape.Hom.term j) →
                  (Option.rec B (fun val => (F.obj { as := val }).left) x ⟶
                    Option.rec B (fun val => (F.obj { as := val }).left) none))
            (fun f h =>
              Eq.rec (motive := fun x x_1 =>
                (f : some j ⟶ x) →
                  HEq f (WidePullbackShape.Hom.term j) →
                    ((F.obj { as := j }).left ⟶ Option.rec B (fun val => (F.obj { as := val }).left) x))
                (fun f h => (F.obj { as := j }).hom) (_ : none = none) f)
            (_ : some j = none) f)
        f (_ : none = none) (_ : none = none) (_ : HEq f f)

Next tactic:
cases f
/-- (Impl) A preliminary definition to avoid timeouts. -/
@[simps]
def conesEquivInverseObj (B : C) {J : Type w} (F : Discrete J ⥤ Over B) (c : Cone F) :
    Cone (widePullbackDiagramOfDiagramOver B F) where
  pt := c.pt.left
  π :=
    { app := fun X => Option.casesOn X c.pt.hom fun j : J => (c.π.app ⟨j⟩).left
      -- `tidy` can do this using `case_bash`, but let's try to be a good `-T50000` citizen:
      naturality := fun X Y f => by
        dsimp; cases X <;> cases Y <;> 

Proof state:
case none.some
J✝ : Type w
C : Type u
inst✝ : Category.{v, u} C
X B : C
J : Type w
F : Discrete J ⥤ Over B
c : Cone F
val✝ : J
f : none ⟶ some val✝
⊢ 𝟙 c.pt.left ≫ Option.rec c.pt.hom (fun val => (c.π.app { as := val }).left) (some val✝) =
    Option.rec c.pt.hom (fun val => (c.π.app { as := val }).left) none ≫
      WidePullbackShape.Hom.rec (motive := fun a a_1 t =>
        none = a →
          some val✝ = a_1 →
            HEq f t →
              (Option.rec B (fun val => (F.obj { as := val }).left) none ⟶
                Option.rec B (fun val => (F.obj { as := val }).left) (some val✝)))
        (fun X h =>
          Eq.rec (motive := fun x x_1 =>
            some val✝ = x →
              HEq f (𝟙 x) →
                (Option.rec B (fun val => (F.obj { as := val }).left) none ⟶
                  Option.rec B (fun val => (F.obj { as := val }).left) (some val✝)))
            (fun h =>
              Eq.rec (motive := fun x x_1 =>
                (f : none ⟶ x) →
                  HEq f (𝟙 none) →
                    (Option.rec B (fun val => (F.obj { as := val }).left) none ⟶
                      Option.rec B (fun val => (F.obj { as := val }).left) x))
                (fun f h => 𝟙 (Option.rec B (fun val => (F.obj { as := val }).left) none)) (_ : none = some val✝) f)
            h)
        (fun j h =>
          Eq.rec (motive := fun x x_1 =>
            (f : x ⟶ some val✝) →
              some val✝ = none →
                HEq f (WidePullbackShape.Hom.term j) →
                  (Option.rec B (fun val => (F.obj { as := val }).left) x ⟶
                    Option.rec B (fun val => (F.obj { as := val }).left) (some val✝)))
            (fun f h =>
              Eq.rec (motive := fun x x_1 =>
                (f : some j ⟶ x) →
                  HEq f (WidePullbackShape.Hom.term j) →
                    ((F.obj { as := j }).left ⟶ Option.rec B (fun val => (F.obj { as := val }).left) x))
                (fun f h => (F.obj { as := j }).hom) (_ : none = some val✝) f)
            (_ : some j = none) f)
        f (_ : none = none) (_ : some val✝ = some val✝) (_ : HEq f f)

Next tactic:
cases f
/-- (Impl) A preliminary definition to avoid timeouts. -/
@[simps]
def conesEquivInverseObj (B : C) {J : Type w} (F : Discrete J ⥤ Over B) (c : Cone F) :
    Cone (widePullbackDiagramOfDiagramOver B F) where
  pt := c.pt.left
  π :=
    { app := fun X => Option.casesOn X c.pt.hom fun j : J => (c.π.app ⟨j⟩).left
      -- `tidy` can do this using `case_bash`, but let's try to be a good `-T50000` citizen:
      naturality := fun X Y f => by
        dsimp; cases X <;> cases Y <;> 

Proof state:
case some.none
J✝ : Type w
C : Type u
inst✝ : Category.{v, u} C
X B : C
J : Type w
F : Discrete J ⥤ Over B
c : Cone F
val✝ : J
f : some val✝ ⟶ none
⊢ 𝟙 c.pt.left ≫ Option.rec c.pt.hom (fun val => (c.π.app { as := val }).left) none =
    Option.rec c.pt.hom (fun val => (c.π.app { as := val }).left) (some val✝) ≫
      WidePullbackShape.Hom.rec (motive := fun a a_1 t =>
        some val✝ = a →
          none = a_1 →
            HEq f t →
              (Option.rec B (fun val => (F.obj { as := val }).left) (some val✝) ⟶
                Option.rec B (fun val => (F.obj { as := val }).left) none))
        (fun X h =>
          Eq.rec (motive := fun x x_1 =>
            none = x →
              HEq f (𝟙 x) →
                (Option.rec B (fun val => (F.obj { as := val }).left) (some val✝) ⟶
                  Option.rec B (fun val => (F.obj { as := val }).left) none))
            (fun h =>
              Eq.rec (motive := fun x x_1 =>
                (f : some val✝ ⟶ x) →
                  HEq f (𝟙 (some val✝)) →
                    (Option.rec B (fun val => (F.obj { as := val }).left) (some val✝) ⟶
                      Option.rec B (fun val => (F.obj { as := val }).left) x))
                (fun f h => 𝟙 (Option.rec B (fun val => (F.obj { as := val }).left) (some val✝))) (_ : some val✝ = none)
                f)
            h)
        (fun j h =>
          Eq.rec (motive := fun x x_1 =>
            (f : x ⟶ none) →
              none = none →
                HEq f (WidePullbackShape.Hom.term j) →
                  (Option.rec B (fun val => (F.obj { as := val }).left) x ⟶
                    Option.rec B (fun val => (F.obj { as := val }).left) none))
            (fun f h =>
              Eq.rec (motive := fun x x_1 =>
                (f : some j ⟶ x) →
                  HEq f (WidePullbackShape.Hom.term j) →
                    ((F.obj { as := j }).left ⟶ Option.rec B (fun val => (F.obj { as := val }).left) x))
                (fun f h => (F.obj { as := j }).hom) (_ : none = none) f)
            (_ : some j = some val✝) f)
        f (_ : some val✝ = some val✝) (_ : none = none) (_ : HEq f f)

Next tactic:
cases f
/-- (Impl) A preliminary definition to avoid timeouts. -/
@[simps]
def conesEquivInverseObj (B : C) {J : Type w} (F : Discrete J ⥤ Over B) (c : Cone F) :
    Cone (widePullbackDiagramOfDiagramOver B F) where
  pt := c.pt.left
  π :=
    { app := fun X => Option.casesOn X c.pt.hom fun j : J => (c.π.app ⟨j⟩).left
      -- `tidy` can do this using `case_bash`, but let's try to be a good `-T50000` citizen:
      naturality := fun X Y f => by
        dsimp; cases X <;> cases Y <;> 

Proof state:
case some.some
J✝ : Type w
C : Type u
inst✝ : Category.{v, u} C
X B : C
J : Type w
F : Discrete J ⥤ Over B
c : Cone F
val✝¹ val✝ : J
f : some val✝¹ ⟶ some val✝
⊢ 𝟙 c.pt.left ≫ Option.rec c.pt.hom (fun val => (c.π.app { as := val }).left) (some val✝) =
    Option.rec c.pt.hom (fun val => (c.π.app { as := val }).left) (some val✝¹) ≫
      WidePullbackShape.Hom.rec (motive := fun a a_1 t =>
        some val✝¹ = a →
          some val✝ = a_1 →
            HEq f t →
              (Option.rec B (fun val => (F.obj { as := val }).left) (some val✝¹) ⟶
                Option.rec B (fun val => (F.obj { as := val }).left) (some val✝)))
        (fun X h =>
          Eq.rec (motive := fun x x_1 =>
            some val✝ = x →
              HEq f (𝟙 x) →
                (Option.rec B (fun val => (F.obj { as := val }).left) (some val✝¹) ⟶
                  Option.rec B (fun val => (F.obj { as := val }).left) (some val✝)))
            (fun h =>
              Eq.rec (motive := fun x x_1 =>
                (f : some val✝¹ ⟶ x) →
                  HEq f (𝟙 (some val✝¹)) →
                    (Option.rec B (fun val => (F.obj { as := val }).left) (some val✝¹) ⟶
                      Option.rec B (fun val => (F.obj { as := val }).left) x))
                (fun f h => 𝟙 (Option.rec B (fun val => (F.obj { as := val }).left) (some val✝¹)))
                (_ : some val✝¹ = some val✝) f)
            h)
        (fun j h =>
          Eq.rec (motive := fun x x_1 =>
            (f : x ⟶ some val✝) →
              some val✝ = none →
                HEq f (WidePullbackShape.Hom.term j) →
                  (Option.rec B (fun val => (F.obj { as := val }).left) x ⟶
                    Option.rec B (fun val => (F.obj { as := val }).left) (some val✝)))
            (fun f h =>
              Eq.rec (motive := fun x x_1 =>
                (f : some j ⟶ x) →
                  HEq f (WidePullbackShape.Hom.term j) →
                    ((F.obj { as := j }).left ⟶ Option.rec B (fun val => (F.obj { as := val }).left) x))
                (fun f h => (F.obj { as := j }).hom) (_ : none = some val✝) f)
            (_ : some j = some val✝¹) f)
        f (_ : some val✝¹ = some val✝¹) (_ : some val✝ = some val✝) (_ : HEq f f)

Next tactic:
cases f
/-- (Impl) A preliminary definition to avoid timeouts. -/
@[simps]
def conesEquivInverseObj (B : C) {J : Type w} (F : Discrete J ⥤ Over B) (c : Cone F) :
    Cone (widePullbackDiagramOfDiagramOver B F) where
  pt := c.pt.left
  π :=
    { app := fun X => Option.casesOn X c.pt.hom fun j : J => (c.π.app ⟨j⟩).left
      -- `tidy` can do this using `case_bash`, but let's try to be a good `-T50000` citizen:
      naturality := fun X Y f => by
        dsimp; cases X <;> cases Y <;> cases f
        · 

Proof state:
case none.none.id
J✝ : Type w
C : Type u
inst✝ : Category.{v, u} C
X B : C
J : Type w
F : Discrete J ⥤ Over B
c : Cone F
⊢ 𝟙 c.pt.left ≫ Option.rec c.pt.hom (fun val => (c.π.app { as := val }).left) none =
    Option.rec c.pt.hom (fun val => (c.π.app { as := val }).left) none ≫
      WidePullbackShape.Hom.rec (motive := fun a a_1 t =>
        none = a →
          none = a_1 →
            HEq (WidePullbackShape.Hom.id none) t →
              (Option.rec B (fun val => (F.obj { as := val }).left) none ⟶
                Option.rec B (fun val => (F.obj { as := val }).left) none))
        (fun X h =>
          Eq.rec (motive := fun x x_1 =>
            none = x →
              HEq (WidePullbackShape.Hom.id none) (𝟙 x) →
                (Option.rec B (fun val => (F.obj { as := val }).left) none ⟶
                  Option.rec B (fun val => (F.obj { as := val }).left) none))
            (fun h =>
              Eq.rec (motive := fun x x_1 =>
                (f : none ⟶ x) →
                  HEq f (𝟙 none) →
                    (Option.rec B (fun val => (F.obj { as := val }).left) none ⟶
                      Option.rec B (fun val => (F.obj { as := val }).left) x))
                (fun f h => 𝟙 (Option.rec B (fun val => (F.obj { as := val }).left) none)) (_ : none = none)
                (WidePullbackShape.Hom.id none))
            h)
        (fun j h =>
          Eq.rec (motive := fun x x_1 =>
            (f : x ⟶ none) →
              none = none →
                HEq f (WidePullbackShape.Hom.term j) →
                  (Option.rec B (fun val => (F.obj { as := val }).left) x ⟶
                    Option.rec B (fun val => (F.obj { as := val }).left) none))
            (fun f h =>
              Eq.rec (motive := fun x x_1 =>
                (f : some j ⟶ x) →
                  HEq f (WidePullbackShape.Hom.term j) →
                    ((F.obj { as := j }).left ⟶ Option.rec B (fun val => (F.obj { as := val }).left) x))
                (fun f h => (F.obj { as := j }).hom) (_ : none = none) f)
            (_ : some j = none) (WidePullbackShape.Hom.id none))
        (WidePullbackShape.Hom.id none) (_ : none = none) (_ : none = none)
        (_ : HEq (WidePullbackShape.Hom.id none) (WidePullbackShape.Hom.id none))

Next tactic:
rw [Category.id_comp, Category.comp_id]
/-- (Impl) A preliminary definition to avoid timeouts. -/
@[simps]
def conesEquivInverseObj (B : C) {J : Type w} (F : Discrete J ⥤ Over B) (c : Cone F) :
    Cone (widePullbackDiagramOfDiagramOver B F) where
  pt := c.pt.left
  π :=
    { app := fun X => Option.casesOn X c.pt.hom fun j : J => (c.π.app ⟨j⟩).left
      -- `tidy` can do this using `case_bash`, but let's try to be a good `-T50000` citizen:
      naturality := fun X Y f => by
        dsimp; cases X <;> cases Y <;> cases f
        · rw [Category.id_comp, Category.comp_id]
        · 

Proof state:
case some.none.term
J✝ : Type w
C : Type u
inst✝ : Category.{v, u} C
X B : C
J : Type w
F : Discrete J ⥤ Over B
c : Cone F
val✝ : J
⊢ 𝟙 c.pt.left ≫ Option.rec c.pt.hom (fun val => (c.π.app { as := val }).left) none =
    Option.rec c.pt.hom (fun val => (c.π.app { as := val }).left) (some val✝) ≫
      WidePullbackShape.Hom.rec (motive := fun a a_1 t =>
        some val✝ = a →
          none = a_1 →
            HEq (WidePullbackShape.Hom.term val✝) t →
              (Option.rec B (fun val => (F.obj { as := val }).left) (some val✝) ⟶
                Option.rec B (fun val => (F.obj { as := val }).left) none))
        (fun X h =>
          Eq.rec (motive := fun x x_1 =>
            none = x →
              HEq (WidePullbackShape.Hom.term val✝) (𝟙 x) →
                (Option.rec B (fun val => (F.obj { as := val }).left) (some val✝) ⟶
                  Option.rec B (fun val => (F.obj { as := val }).left) none))
            (fun h =>
              Eq.rec (motive := fun x x_1 =>
                (f : some val✝ ⟶ x) →
                  HEq f (𝟙 (some val✝)) →
                    (Option.rec B (fun val => (F.obj { as := val }).left) (some val✝) ⟶
                      Option.rec B (fun val => (F.obj { as := val }).left) x))
                (fun f h => 𝟙 (Option.rec B (fun val => (F.obj { as := val }).left) (some val✝))) (_ : some val✝ = none)
                (WidePullbackShape.Hom.term val✝))
            h)
        (fun j h =>
          Eq.rec (motive := fun x x_1 =>
            (f : x ⟶ none) →
              none = none →
                HEq f (WidePullbackShape.Hom.term j) →
                  (Option.rec B (fun val => (F.obj { as := val }).left) x ⟶
                    Option.rec B (fun val => (F.obj { as := val }).left) none))
            (fun f h =>
              Eq.rec (motive := fun x x_1 =>
                (f : some j ⟶ x) →
                  HEq f (WidePullbackShape.Hom.term j) →
                    ((F.obj { as := j }).left ⟶ Option.rec B (fun val => (F.obj { as := val }).left) x))
                (fun f h => (F.obj { as := j }).hom) (_ : none = none) f)
            (_ : some j = some val✝) (WidePullbackShape.Hom.term val✝))
        (WidePullbackShape.Hom.term val✝) (_ : some val✝ = some val✝) (_ : none = none)
        (_ : HEq (WidePullbackShape.Hom.term val✝) (WidePullbackShape.Hom.term val✝))

Next tactic:
rw [Over.w, Category.id_comp]