l3lab/ntp-mathlib huggingface dataset:
/-- (Implementation.) Any cone over `cospan f g` indeed factors through the constructed cone.
-/
def pullbackConeOfLeftLift : s.pt ⟶ (pullbackConeOfLeft f g).pt where
  base :=
    pullback.lift s.fst.base s.snd.base
      (congr_arg (fun x => PresheafedSpace.Hom.base x) s.condition)
  c :=
    { app := fun U =>
        s.snd.c.app _ ≫
          s.pt.presheaf.map
            (eqToHom
              (by
                dsimp only [Opens.map, IsOpenMap.functor, Functor.op]
                congr 2
                let s' : PullbackCone f.base g.base := PullbackCone.mk s.fst.base s.snd.base
                  -- Porting note : in mathlib3, this is just an underscore
                  (congr_arg Hom.base s.condition)

                have : _ = s.snd.base := limit.lift_π s' WalkingCospan.right
                conv_lhs =>
                  erw [← this]
                  dsimp
                  -- Porting note : need a bit more hand holding here about function composition
                  rw [coe_comp, show ∀ f g, f ∘ g = fun x => f (g x) from fun _ _ => rfl]
                  

Proof state:
C : Type u_1
inst✝ : Category.{?u.125761, u_1} C
X Y Z : PresheafedSpace C
f : X ⟶ Z
hf : IsOpenImmersion f
g : Y ⟶ Z
s : PullbackCone f g
U : (Opens ↑↑(pullbackConeOfLeft f g).pt)ᵒᵖ
s' : PullbackCone f.base g.base :=
  PullbackCone.mk (PullbackCone.fst s).base (PullbackCone.snd s).base
    (_ : (PullbackCone.fst s ≫ f).base = (PullbackCone.snd s ≫ g).base)
this :
  limit.lift (cospan f.base g.base) s' ≫ limit.π (cospan f.base g.base) WalkingCospan.right = (PullbackCone.snd s).base
| (fun x =>
      (limit.π (cospan f.base g.base) WalkingCospan.right)
        ((limit.lift (cospan f.base g.base)
            (PullbackCone.mk (PullbackCone.fst s).base (PullbackCone.snd s).base
              (_ : (PullbackCone.fst s ≫ f).base = (PullbackCone.snd s ≫ g).base)))
          x)) ⁻¹'
    (⇑pullback.snd '' ↑U.unop)

Next tactic:
erw [← Set.preimage_preimage]
/-- (Implementation.) Any cone over `cospan f g` indeed factors through the constructed cone.
-/
def pullbackConeOfLeftLift : s.pt ⟶ (pullbackConeOfLeft f g).pt where
  base :=
    pullback.lift s.fst.base s.snd.base
      (congr_arg (fun x => PresheafedSpace.Hom.base x) s.condition)
  c :=
    { app := fun U =>
        s.snd.c.app _ ≫
          s.pt.presheaf.map
            (eqToHom
              (by
                dsimp only [Opens.map, IsOpenMap.functor, Functor.op]
                congr 2
                let s' : PullbackCone f.base g.base := PullbackCone.mk s.fst.base s.snd.base
                  -- Porting note : in mathlib3, this is just an underscore
                  (congr_arg Hom.base s.condition)

                have : _ = s.snd.base := limit.lift_π s' WalkingCospan.right
                conv_lhs =>
                  erw [← this]
                  dsimp
                  -- Porting note : need a bit more hand holding here about function composition
                  rw [coe_comp, show ∀ f g, f ∘ g = fun x => f (g x) from fun _ _ => rfl]
                  erw [← Set.preimage_preimage]
                

Proof state:
case e_x.e_carrier
C : Type u_1
inst✝ : Category.{?u.125761, u_1} C
X Y Z : PresheafedSpace C
f : X ⟶ Z
hf : IsOpenImmersion f
g : Y ⟶ Z
s : PullbackCone f g
U : (Opens ↑↑(pullbackConeOfLeft f g).pt)ᵒᵖ
s' : PullbackCone f.base g.base :=
  PullbackCone.mk (PullbackCone.fst s).base (PullbackCone.snd s).base
    (_ : (PullbackCone.fst s ≫ f).base = (PullbackCone.snd s ≫ g).base)
this :
  limit.lift (cospan f.base g.base) s' ≫ limit.π (cospan f.base g.base) WalkingCospan.right = (PullbackCone.snd s).base
⊢ (fun x =>
        (limit.lift (cospan f.base g.base)
            (PullbackCone.mk (PullbackCone.fst s).base (PullbackCone.snd s).base
              (_ : (PullbackCone.fst s ≫ f).base = (PullbackCone.snd s ≫ g).base)))
          x) ⁻¹'
      (⇑(limit.π (cospan f.base g.base) WalkingCospan.right) ⁻¹' (⇑pullback.snd '' ↑U.unop)) =
    ⇑(pullback.lift (PullbackCone.fst s).base (PullbackCone.snd s).base
          (_ : (PullbackCone.fst s ≫ f).base = (PullbackCone.snd s ≫ g).base)) ⁻¹'
      ↑U.unop

Next tactic:
erw [Set.preimage_image_eq _
                    (TopCat.snd_openEmbedding_of_left_openEmbedding hf.base_open g.base).inj]
/-- (Implementation.) Any cone over `cospan f g` indeed factors through the constructed cone.
-/
def pullbackConeOfLeftLift : s.pt ⟶ (pullbackConeOfLeft f g).pt where
  base :=
    pullback.lift s.fst.base s.snd.base
      (congr_arg (fun x => PresheafedSpace.Hom.base x) s.condition)
  c :=
    { app := fun U =>
        s.snd.c.app _ ≫
          s.pt.presheaf.map
            (eqToHom
              (by
                dsimp only [Opens.map, IsOpenMap.functor, Functor.op]
                congr 2
                let s' : PullbackCone f.base g.base := PullbackCone.mk s.fst.base s.snd.base
                  -- Porting note : in mathlib3, this is just an underscore
                  (congr_arg Hom.base s.condition)

                have : _ = s.snd.base := limit.lift_π s' WalkingCospan.right
                conv_lhs =>
                  erw [← this]
                  dsimp
                  -- Porting note : need a bit more hand holding here about function composition
                  rw [coe_comp, show ∀ f g, f ∘ g = fun x => f (g x) from fun _ _ => rfl]
                  erw [← Set.preimage_preimage]
                erw [Set.preimage_image_eq _
                    (TopCat.snd_openEmbedding_of_left_openEmbedding hf.base_open g.base).inj]
                

Proof state:
case e_x.e_carrier
C : Type u_1
inst✝ : Category.{?u.125761, u_1} C
X Y Z : PresheafedSpace C
f : X ⟶ Z
hf : IsOpenImmersion f
g : Y ⟶ Z
s : PullbackCone f g
U : (Opens ↑↑(pullbackConeOfLeft f g).pt)ᵒᵖ
s' : PullbackCone f.base g.base :=
  PullbackCone.mk (PullbackCone.fst s).base (PullbackCone.snd s).base
    (_ : (PullbackCone.fst s ≫ f).base = (PullbackCone.snd s ≫ g).base)
this :
  limit.lift (cospan f.base g.base) s' ≫ limit.π (cospan f.base g.base) WalkingCospan.right = (PullbackCone.snd s).base
⊢ (fun x =>
        (limit.lift (cospan f.base g.base)
            (PullbackCone.mk (PullbackCone.fst s).base (PullbackCone.snd s).base
              (_ : (PullbackCone.fst s ≫ f).base = (PullbackCone.snd s ≫ g).base)))
          x) ⁻¹'
      ↑U.unop =
    ⇑(pullback.lift (PullbackCone.fst s).base (PullbackCone.snd s).base
          (_ : (PullbackCone.fst s ≫ f).base = (PullbackCone.snd s ≫ g).base)) ⁻¹'
      ↑U.unop

Next tactic:
rfl
/-- (Implementation.) Any cone over `cospan f g` indeed factors through the constructed cone.
-/
def pullbackConeOfLeftLift : s.pt ⟶ (pullbackConeOfLeft f g).pt where
  base :=
    pullback.lift s.fst.base s.snd.base
      (congr_arg (fun x => PresheafedSpace.Hom.base x) s.condition)
  c :=
    { app := fun U =>
        s.snd.c.app _ ≫
          s.pt.presheaf.map
            (eqToHom
              (by
                dsimp only [Opens.map, IsOpenMap.functor, Functor.op]
                congr 2
                let s' : PullbackCone f.base g.base := PullbackCone.mk s.fst.base s.snd.base
                  -- Porting note : in mathlib3, this is just an underscore
                  (congr_arg Hom.base s.condition)

                have : _ = s.snd.base := limit.lift_π s' WalkingCospan.right
                conv_lhs =>
                  erw [← this]
                  dsimp
                  -- Porting note : need a bit more hand holding here about function composition
                  rw [coe_comp, show ∀ f g, f ∘ g = fun x => f (g x) from fun _ _ => rfl]
                  erw [← Set.preimage_preimage]
                erw [Set.preimage_image_eq _
                    (TopCat.snd_openEmbedding_of_left_openEmbedding hf.base_open g.base).inj]
                rfl))
      naturality := fun U V i => by
        

Proof state:
C : Type u_1
inst✝ : Category.{?u.125761, u_1} C
X Y Z : PresheafedSpace C
f : X ⟶ Z
hf : IsOpenImmersion f
g : Y ⟶ Z
s : PullbackCone f g
U V : (Opens ↑↑(pullbackConeOfLeft f g).pt)ᵒᵖ
i : U ⟶ V
⊢ (pullbackConeOfLeft f g).pt.presheaf.map i ≫
      (fun U =>
          (PullbackCone.snd s).c.app ((IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj U) ≫
            s.pt.presheaf.map
              (eqToHom
                (_ :
                  (Opens.map (PullbackCone.snd s).base).op.obj
                      ((IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj U) =
                    (Opens.map
                            (pullback.lift (PullbackCone.fst s).base (PullbackCone.snd s).base
                              (_ : (PullbackCone.fst s ≫ f).base = (PullbackCone.snd s ≫ g).base))).op.obj
                      U)))
        V =
    (fun U =>
          (PullbackCone.snd s).c.app ((IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj U) ≫
            s.pt.presheaf.map
              (eqToHom
                (_ :
                  (Opens.map (PullbackCone.snd s).base).op.obj
                      ((IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj U) =
                    (Opens.map
                            (pullback.lift (PullbackCone.fst s).base (PullbackCone.snd s).base
                              (_ : (PullbackCone.fst s ≫ f).base = (PullbackCone.snd s ≫ g).base))).op.obj
                      U)))
        U ≫
      (pullback.lift (PullbackCone.fst s).base (PullbackCone.snd s).base
              (_ : (PullbackCone.fst s ≫ f).base = (PullbackCone.snd s ≫ g).base) _*
            s.pt.presheaf).map
        i

Next tactic:
erw [s.snd.c.naturality_assoc]
/-- (Implementation.) Any cone over `cospan f g` indeed factors through the constructed cone.
-/
def pullbackConeOfLeftLift : s.pt ⟶ (pullbackConeOfLeft f g).pt where
  base :=
    pullback.lift s.fst.base s.snd.base
      (congr_arg (fun x => PresheafedSpace.Hom.base x) s.condition)
  c :=
    { app := fun U =>
        s.snd.c.app _ ≫
          s.pt.presheaf.map
            (eqToHom
              (by
                dsimp only [Opens.map, IsOpenMap.functor, Functor.op]
                congr 2
                let s' : PullbackCone f.base g.base := PullbackCone.mk s.fst.base s.snd.base
                  -- Porting note : in mathlib3, this is just an underscore
                  (congr_arg Hom.base s.condition)

                have : _ = s.snd.base := limit.lift_π s' WalkingCospan.right
                conv_lhs =>
                  erw [← this]
                  dsimp
                  -- Porting note : need a bit more hand holding here about function composition
                  rw [coe_comp, show ∀ f g, f ∘ g = fun x => f (g x) from fun _ _ => rfl]
                  erw [← Set.preimage_preimage]
                erw [Set.preimage_image_eq _
                    (TopCat.snd_openEmbedding_of_left_openEmbedding hf.base_open g.base).inj]
                rfl))
      naturality := fun U V i => by
        erw [s.snd.c.naturality_assoc]
        

Proof state:
C : Type u_1
inst✝ : Category.{?u.125761, u_1} C
X Y Z : PresheafedSpace C
f : X ⟶ Z
hf : IsOpenImmersion f
g : Y ⟶ Z
s : PullbackCone f g
U V : (Opens ↑↑(pullbackConeOfLeft f g).pt)ᵒᵖ
i : U ⟶ V
⊢ (PullbackCone.snd s).c.app ((IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj U) ≫
      ((PullbackCone.snd s).base _* s.pt.presheaf).map ((IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.map i) ≫
        s.pt.presheaf.map
          (eqToHom
            (_ :
              (Opens.map (PullbackCone.snd s).base).op.obj
                  ((IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj V) =
                (Opens.map
                        (pullback.lift (PullbackCone.fst s).base (PullbackCone.snd s).base
                          (_ : (PullbackCone.fst s ≫ f).base = (PullbackCone.snd s ≫ g).base))).op.obj
                  V)) =
    (fun U =>
          (PullbackCone.snd s).c.app ((IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj U) ≫
            s.pt.presheaf.map
              (eqToHom
                (_ :
                  (Opens.map (PullbackCone.snd s).base).op.obj
                      ((IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj U) =
                    (Opens.map
                            (pullback.lift (PullbackCone.fst s).base (PullbackCone.snd s).base
                              (_ : (PullbackCone.fst s ≫ f).base = (PullbackCone.snd s ≫ g).base))).op.obj
                      U)))
        U ≫
      (pullback.lift (PullbackCone.fst s).base (PullbackCone.snd s).base
              (_ : (PullbackCone.fst s ≫ f).base = (PullbackCone.snd s ≫ g).base) _*
            s.pt.presheaf).map
        i

Next tactic:
rw [Category.assoc]
/-- (Implementation.) Any cone over `cospan f g` indeed factors through the constructed cone.
-/
def pullbackConeOfLeftLift : s.pt ⟶ (pullbackConeOfLeft f g).pt where
  base :=
    pullback.lift s.fst.base s.snd.base
      (congr_arg (fun x => PresheafedSpace.Hom.base x) s.condition)
  c :=
    { app := fun U =>
        s.snd.c.app _ ≫
          s.pt.presheaf.map
            (eqToHom
              (by
                dsimp only [Opens.map, IsOpenMap.functor, Functor.op]
                congr 2
                let s' : PullbackCone f.base g.base := PullbackCone.mk s.fst.base s.snd.base
                  -- Porting note : in mathlib3, this is just an underscore
                  (congr_arg Hom.base s.condition)

                have : _ = s.snd.base := limit.lift_π s' WalkingCospan.right
                conv_lhs =>
                  erw [← this]
                  dsimp
                  -- Porting note : need a bit more hand holding here about function composition
                  rw [coe_comp, show ∀ f g, f ∘ g = fun x => f (g x) from fun _ _ => rfl]
                  erw [← Set.preimage_preimage]
                erw [Set.preimage_image_eq _
                    (TopCat.snd_openEmbedding_of_left_openEmbedding hf.base_open g.base).inj]
                rfl))
      naturality := fun U V i => by
        erw [s.snd.c.naturality_assoc]
        rw [Category.assoc]
        

Proof state:
C : Type u_1
inst✝ : Category.{?u.125761, u_1} C
X Y Z : PresheafedSpace C
f : X ⟶ Z
hf : IsOpenImmersion f
g : Y ⟶ Z
s : PullbackCone f g
U V : (Opens ↑↑(pullbackConeOfLeft f g).pt)ᵒᵖ
i : U ⟶ V
⊢ (PullbackCone.snd s).c.app ((IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj U) ≫
      ((PullbackCone.snd s).base _* s.pt.presheaf).map ((IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.map i) ≫
        s.pt.presheaf.map
          (eqToHom
            (_ :
              (Opens.map (PullbackCone.snd s).base).op.obj
                  ((IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj V) =
                (Opens.map
                        (pullback.lift (PullbackCone.fst s).base (PullbackCone.snd s).base
                          (_ : (PullbackCone.fst s ≫ f).base = (PullbackCone.snd s ≫ g).base))).op.obj
                  V)) =
    (PullbackCone.snd s).c.app ((IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj U) ≫
      s.pt.presheaf.map
          (eqToHom
            (_ :
              (Opens.map (PullbackCone.snd s).base).op.obj
                  ((IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj U) =
                (Opens.map
                        (pullback.lift (PullbackCone.fst s).base (PullbackCone.snd s).base
                          (_ : (PullbackCone.fst s ≫ f).base = (PullbackCone.snd s ≫ g).base))).op.obj
                  U)) ≫
        (pullback.lift (PullbackCone.fst s).base (PullbackCone.snd s).base
                (_ : (PullbackCone.fst s ≫ f).base = (PullbackCone.snd s ≫ g).base) _*
              s.pt.presheaf).map
          i

Next tactic:
erw [← s.pt.presheaf.map_comp, ← s.pt.presheaf.map_comp]
/-- (Implementation.) Any cone over `cospan f g` indeed factors through the constructed cone.
-/
def pullbackConeOfLeftLift : s.pt ⟶ (pullbackConeOfLeft f g).pt where
  base :=
    pullback.lift s.fst.base s.snd.base
      (congr_arg (fun x => PresheafedSpace.Hom.base x) s.condition)
  c :=
    { app := fun U =>
        s.snd.c.app _ ≫
          s.pt.presheaf.map
            (eqToHom
              (by
                dsimp only [Opens.map, IsOpenMap.functor, Functor.op]
                congr 2
                let s' : PullbackCone f.base g.base := PullbackCone.mk s.fst.base s.snd.base
                  -- Porting note : in mathlib3, this is just an underscore
                  (congr_arg Hom.base s.condition)

                have : _ = s.snd.base := limit.lift_π s' WalkingCospan.right
                conv_lhs =>
                  erw [← this]
                  dsimp
                  -- Porting note : need a bit more hand holding here about function composition
                  rw [coe_comp, show ∀ f g, f ∘ g = fun x => f (g x) from fun _ _ => rfl]
                  erw [← Set.preimage_preimage]
                erw [Set.preimage_image_eq _
                    (TopCat.snd_openEmbedding_of_left_openEmbedding hf.base_open g.base).inj]
                rfl))
      naturality := fun U V i => by
        erw [s.snd.c.naturality_assoc]
        rw [Category.assoc]
        erw [← s.pt.presheaf.map_comp, ← s.pt.presheaf.map_comp]
        

Proof state:
C : Type u_1
inst✝ : Category.{?u.125761, u_1} C
X Y Z : PresheafedSpace C
f : X ⟶ Z
hf : IsOpenImmersion f
g : Y ⟶ Z
s : PullbackCone f g
U V : (Opens ↑↑(pullbackConeOfLeft f g).pt)ᵒᵖ
i : U ⟶ V
⊢ (PullbackCone.snd s).c.app ((IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj U) ≫
      s.pt.presheaf.map
        ((Opens.map (PullbackCone.snd s).base).op.map ((IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.map i) ≫
          eqToHom
            (_ :
              (Opens.map (PullbackCone.snd s).base).op.obj
                  ((IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj V) =
                (Opens.map
                        (pullback.lift (PullbackCone.fst s).base (PullbackCone.snd s).base
                          (_ : (PullbackCone.fst s ≫ f).base = (PullbackCone.snd s ≫ g).base))).op.obj
                  V)) =
    (PullbackCone.snd s).c.app ((IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj U) ≫
      s.pt.presheaf.map
        (eqToHom
            (_ :
              (Opens.map (PullbackCone.snd s).base).op.obj
                  ((IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj U) =
                (Opens.map
                        (pullback.lift (PullbackCone.fst s).base (PullbackCone.snd s).base
                          (_ : (PullbackCone.fst s ≫ f).base = (PullbackCone.snd s ≫ g).base))).op.obj
                  U) ≫
          (Opens.map
                  (pullback.lift (PullbackCone.fst s).base (PullbackCone.snd s).base
                    (_ : (PullbackCone.fst s ≫ f).base = (PullbackCone.snd s ≫ g).base))).op.map
            i)

Next tactic:
congr 1
theorem pullbackConeOfLeftLift_fst :
    pullbackConeOfLeftLift f g s ≫ (pullbackConeOfLeft f g).fst = s.fst := by
  -- Porting note : `ext` did not pick up `NatTrans.ext`
  

Proof state:
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y Z : PresheafedSpace C
f : X ⟶ Z
hf : IsOpenImmersion f
g : Y ⟶ Z
s : PullbackCone f g
⊢ pullbackConeOfLeftLift f g s ≫ PullbackCone.fst (pullbackConeOfLeft f g) = PullbackCone.fst s

Next tactic:
refine PresheafedSpace.Hom.ext _ _ ?_ <| NatTrans.ext _ _ <| funext fun x => ?_
theorem pullbackConeOfLeftLift_fst :
    pullbackConeOfLeftLift f g s ≫ (pullbackConeOfLeft f g).fst = s.fst := by
  -- Porting note : `ext` did not pick up `NatTrans.ext`
  refine PresheafedSpace.Hom.ext _ _ ?_ <| NatTrans.ext _ _ <| funext fun x => ?_
  · 

Proof state:
case refine_1
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y Z : PresheafedSpace C
f : X ⟶ Z
hf : IsOpenImmersion f
g : Y ⟶ Z
s : PullbackCone f g
⊢ (pullbackConeOfLeftLift f g s ≫ PullbackCone.fst (pullbackConeOfLeft f g)).base = (PullbackCone.fst s).base

Next tactic:
change pullback.lift _ _ _ ≫ pullback.fst = _
theorem pullbackConeOfLeftLift_fst :
    pullbackConeOfLeftLift f g s ≫ (pullbackConeOfLeft f g).fst = s.fst := by
  -- Porting note : `ext` did not pick up `NatTrans.ext`
  refine PresheafedSpace.Hom.ext _ _ ?_ <| NatTrans.ext _ _ <| funext fun x => ?_
  · change pullback.lift _ _ _ ≫ pullback.fst = _
    

Proof state:
case refine_1
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y Z : PresheafedSpace C
f : X ⟶ Z
hf : IsOpenImmersion f
g : Y ⟶ Z
s : PullbackCone f g
⊢ pullback.lift (PullbackCone.fst s).base (PullbackCone.snd s).base
        (_ : (PullbackCone.fst s ≫ f).base = (PullbackCone.snd s ≫ g).base) ≫
      pullback.fst =
    (PullbackCone.fst s).base

Next tactic:
simp
theorem pullbackConeOfLeftLift_fst :
    pullbackConeOfLeftLift f g s ≫ (pullbackConeOfLeft f g).fst = s.fst := by
  -- Porting note : `ext` did not pick up `NatTrans.ext`
  refine PresheafedSpace.Hom.ext _ _ ?_ <| NatTrans.ext _ _ <| funext fun x => ?_
  · change pullback.lift _ _ _ ≫ pullback.fst = _
    simp
  · 

Proof state:
case refine_2
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y Z : PresheafedSpace C
f : X ⟶ Z
hf : IsOpenImmersion f
g : Y ⟶ Z
s : PullbackCone f g
x : (Opens ↑↑X)ᵒᵖ
⊢ ((pullbackConeOfLeftLift f g s ≫ PullbackCone.fst (pullbackConeOfLeft f g)).c ≫
          whiskerRight
            (eqToHom
              (_ :
                (Opens.map (pullbackConeOfLeftLift f g s ≫ PullbackCone.fst (pullbackConeOfLeft f g)).base).op =
                  (Opens.map (PullbackCone.fst s).base).op))
            s.pt.presheaf).app
      x =
    (PullbackCone.fst s).c.app x

Next tactic:
induction x using Opposite.rec' with | h x => ?_
theorem pullbackConeOfLeftLift_fst :
    pullbackConeOfLeftLift f g s ≫ (pullbackConeOfLeft f g).fst = s.fst := by
  -- Porting note : `ext` did not pick up `NatTrans.ext`
  refine PresheafedSpace.Hom.ext _ _ ?_ <| NatTrans.ext _ _ <| funext fun x => ?_
  · change pullback.lift _ _ _ ≫ pullback.fst = _
    simp
  · induction x using Opposite.rec' with | h x => ?_
    

Proof state:
case refine_2.h
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y Z : PresheafedSpace C
f : X ⟶ Z
hf : IsOpenImmersion f
g : Y ⟶ Z
s : PullbackCone f g
x : Opens ↑↑X
⊢ ((pullbackConeOfLeftLift f g s ≫ PullbackCone.fst (pullbackConeOfLeft f g)).c ≫
          whiskerRight
            (eqToHom
              (_ :
                (Opens.map (pullbackConeOfLeftLift f g s ≫ PullbackCone.fst (pullbackConeOfLeft f g)).base).op =
                  (Opens.map (PullbackCone.fst s).base).op))
            s.pt.presheaf).app
      (op x) =
    (PullbackCone.fst s).c.app (op x)

Next tactic:
change ((_ ≫ _) ≫ _ ≫ _) ≫ _ = _