l3lab/ntp-mathlib huggingface dataset:
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 => ?_
    change ((_ ≫ _) ≫ _ ≫ _) ≫ _ = _
    

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
⊢ ((invApp hf (op x).unop ≫
          g.c.app (op ((IsOpenMap.functor (_ : IsOpenMap ⇑f.base)).obj (op x).unop)) ≫
            Y.presheaf.map
              (eqToHom
                (_ :
                  (Opens.map g.base).op.obj (op ((IsOpenMap.functor (_ : IsOpenMap ⇑f.base)).obj (op x).unop)) =
                    (IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj
                      ((Opens.map pullback.fst).op.obj (op x))))) ≫
        (PullbackCone.snd s).c.app
            ((IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj
              ((Opens.map (PullbackCone.fst (pullbackConeOfLeft f g)).base).op.obj (op x))) ≫
          s.pt.presheaf.map
            (eqToHom
              (_ :
                (Opens.map (PullbackCone.snd s).base).op.obj
                    ((IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj
                      ((Opens.map (PullbackCone.fst (pullbackConeOfLeft f g)).base).op.obj (op x))) =
                  (Opens.map
                          (pullback.lift (PullbackCone.fst s).base (PullbackCone.snd s).base
                            (_ : (PullbackCone.fst s ≫ f).base = (PullbackCone.snd s ≫ g).base))).op.obj
                    ((Opens.map (PullbackCone.fst (pullbackConeOfLeft f g)).base).op.obj (op x))))) ≫
      (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:
simp_rw [Category.assoc]
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 => ?_
    change ((_ ≫ _) ≫ _ ≫ _) ≫ _ = _
    simp_rw [Category.assoc]
    

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
⊢ invApp hf (op x).unop ≫
      g.c.app (op ((IsOpenMap.functor (_ : IsOpenMap ⇑f.base)).obj (op x).unop)) ≫
        Y.presheaf.map
            (eqToHom
              (_ :
                (Opens.map g.base).op.obj (op ((IsOpenMap.functor (_ : IsOpenMap ⇑f.base)).obj (op x).unop)) =
                  (IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj ((Opens.map pullback.fst).op.obj (op x)))) ≫
          (PullbackCone.snd s).c.app
              ((IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj
                ((Opens.map (PullbackCone.fst (pullbackConeOfLeft f g)).base).op.obj (op x))) ≫
            s.pt.presheaf.map
                (eqToHom
                  (_ :
                    (Opens.map (PullbackCone.snd s).base).op.obj
                        ((IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj
                          ((Opens.map (PullbackCone.fst (pullbackConeOfLeft f g)).base).op.obj (op x))) =
                      (Opens.map
                              (pullback.lift (PullbackCone.fst s).base (PullbackCone.snd s).base
                                (_ : (PullbackCone.fst s ≫ f).base = (PullbackCone.snd s ≫ g).base))).op.obj
                        ((Opens.map (PullbackCone.fst (pullbackConeOfLeft f g)).base).op.obj (op x)))) ≫
              (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:
erw [← s.pt.presheaf.map_comp]
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 => ?_
    change ((_ ≫ _) ≫ _ ≫ _) ≫ _ = _
    simp_rw [Category.assoc]
    erw [← s.pt.presheaf.map_comp]
    

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
⊢ invApp hf (op x).unop ≫
      g.c.app (op ((IsOpenMap.functor (_ : IsOpenMap ⇑f.base)).obj (op x).unop)) ≫
        Y.presheaf.map
            (eqToHom
              (_ :
                (Opens.map g.base).op.obj (op ((IsOpenMap.functor (_ : IsOpenMap ⇑f.base)).obj (op x).unop)) =
                  (IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj ((Opens.map pullback.fst).op.obj (op x)))) ≫
          (PullbackCone.snd s).c.app
              ((IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj
                ((Opens.map (PullbackCone.fst (pullbackConeOfLeft f g)).base).op.obj (op x))) ≫
            s.pt.presheaf.map
              (eqToHom
                  (_ :
                    (Opens.map (PullbackCone.snd s).base).op.obj
                        ((IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj
                          ((Opens.map (PullbackCone.fst (pullbackConeOfLeft f g)).base).op.obj (op x))) =
                      (Opens.map
                              (pullback.lift (PullbackCone.fst s).base (PullbackCone.snd s).base
                                (_ : (PullbackCone.fst s ≫ f).base = (PullbackCone.snd s ≫ g).base))).op.obj
                        ((Opens.map (PullbackCone.fst (pullbackConeOfLeft f g)).base).op.obj (op x))) ≫
                (eqToHom
                      (_ :
                        (Opens.map (pullbackConeOfLeftLift f g s ≫ PullbackCone.fst (pullbackConeOfLeft f g)).base).op =
                          (Opens.map (PullbackCone.fst s).base).op)).app
                  (op x)) =
    (PullbackCone.fst s).c.app (op x)

Next tactic:
erw [s.snd.c.naturality_assoc]
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 => ?_
    change ((_ ≫ _) ≫ _ ≫ _) ≫ _ = _
    simp_rw [Category.assoc]
    erw [← s.pt.presheaf.map_comp]
    erw [s.snd.c.naturality_assoc]
    

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
⊢ invApp hf (op x).unop ≫
      g.c.app (op ((IsOpenMap.functor (_ : IsOpenMap ⇑f.base)).obj (op x).unop)) ≫
        (PullbackCone.snd s).c.app
            ((Opens.map g.base).op.obj (op ((IsOpenMap.functor (_ : IsOpenMap ⇑f.base)).obj (op x).unop))) ≫
          ((PullbackCone.snd s).base _* s.pt.presheaf).map
              (eqToHom
                (_ :
                  (Opens.map g.base).op.obj (op ((IsOpenMap.functor (_ : IsOpenMap ⇑f.base)).obj (op x).unop)) =
                    (IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj
                      ((Opens.map pullback.fst).op.obj (op x)))) ≫
            s.pt.presheaf.map
              (eqToHom
                  (_ :
                    (Opens.map (PullbackCone.snd s).base).op.obj
                        ((IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj
                          ((Opens.map (PullbackCone.fst (pullbackConeOfLeft f g)).base).op.obj (op x))) =
                      (Opens.map
                              (pullback.lift (PullbackCone.fst s).base (PullbackCone.snd s).base
                                (_ : (PullbackCone.fst s ≫ f).base = (PullbackCone.snd s ≫ g).base))).op.obj
                        ((Opens.map (PullbackCone.fst (pullbackConeOfLeft f g)).base).op.obj (op x))) ≫
                (eqToHom
                      (_ :
                        (Opens.map (pullbackConeOfLeftLift f g s ≫ PullbackCone.fst (pullbackConeOfLeft f g)).base).op =
                          (Opens.map (PullbackCone.fst s).base).op)).app
                  (op x)) =
    (PullbackCone.fst s).c.app (op x)

Next tactic:
have := congr_app s.condition (op (hf.openFunctor.obj 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 => ?_
    change ((_ ≫ _) ≫ _ ≫ _) ≫ _ = _
    simp_rw [Category.assoc]
    erw [← s.pt.presheaf.map_comp]
    erw [s.snd.c.naturality_assoc]
    have := congr_app s.condition (op (hf.openFunctor.obj 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
this :
  (PullbackCone.fst s ≫ f).c.app (op ((openFunctor hf).obj x)) =
    (PullbackCone.snd s ≫ g).c.app (op ((openFunctor hf).obj x)) ≫
      s.pt.presheaf.map
        (eqToHom
          (_ :
            (Opens.map (PullbackCone.snd s ≫ g).base).op.obj (op ((openFunctor hf).obj x)) =
              (Opens.map (PullbackCone.fst s ≫ f).base).op.obj (op ((openFunctor hf).obj x))))
⊢ invApp hf (op x).unop ≫
      g.c.app (op ((IsOpenMap.functor (_ : IsOpenMap ⇑f.base)).obj (op x).unop)) ≫
        (PullbackCone.snd s).c.app
            ((Opens.map g.base).op.obj (op ((IsOpenMap.functor (_ : IsOpenMap ⇑f.base)).obj (op x).unop))) ≫
          ((PullbackCone.snd s).base _* s.pt.presheaf).map
              (eqToHom
                (_ :
                  (Opens.map g.base).op.obj (op ((IsOpenMap.functor (_ : IsOpenMap ⇑f.base)).obj (op x).unop)) =
                    (IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj
                      ((Opens.map pullback.fst).op.obj (op x)))) ≫
            s.pt.presheaf.map
              (eqToHom
                  (_ :
                    (Opens.map (PullbackCone.snd s).base).op.obj
                        ((IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj
                          ((Opens.map (PullbackCone.fst (pullbackConeOfLeft f g)).base).op.obj (op x))) =
                      (Opens.map
                              (pullback.lift (PullbackCone.fst s).base (PullbackCone.snd s).base
                                (_ : (PullbackCone.fst s ≫ f).base = (PullbackCone.snd s ≫ g).base))).op.obj
                        ((Opens.map (PullbackCone.fst (pullbackConeOfLeft f g)).base).op.obj (op x))) ≫
                (eqToHom
                      (_ :
                        (Opens.map (pullbackConeOfLeftLift f g s ≫ PullbackCone.fst (pullbackConeOfLeft f g)).base).op =
                          (Opens.map (PullbackCone.fst s).base).op)).app
                  (op x)) =
    (PullbackCone.fst s).c.app (op x)

Next tactic:
dsimp only [comp_c_app, unop_op] at this
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 => ?_
    change ((_ ≫ _) ≫ _ ≫ _) ≫ _ = _
    simp_rw [Category.assoc]
    erw [← s.pt.presheaf.map_comp]
    erw [s.snd.c.naturality_assoc]
    have := congr_app s.condition (op (hf.openFunctor.obj x))
    dsimp only [comp_c_app, unop_op] at this
    

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
this :
  f.c.app (op ((openFunctor hf).obj x)) ≫
      (PullbackCone.fst s).c.app (op ((Opens.map f.base).obj ((openFunctor hf).obj x))) =
    (g.c.app (op ((openFunctor hf).obj x)) ≫
        (PullbackCone.snd s).c.app (op ((Opens.map g.base).obj ((openFunctor hf).obj x)))) ≫
      s.pt.presheaf.map
        (eqToHom
          (_ :
            (Opens.map (PullbackCone.snd s ≫ g).base).op.obj (op ((openFunctor hf).obj x)) =
              (Opens.map (PullbackCone.fst s ≫ f).base).op.obj (op ((openFunctor hf).obj x))))
⊢ invApp hf (op x).unop ≫
      g.c.app (op ((IsOpenMap.functor (_ : IsOpenMap ⇑f.base)).obj (op x).unop)) ≫
        (PullbackCone.snd s).c.app
            ((Opens.map g.base).op.obj (op ((IsOpenMap.functor (_ : IsOpenMap ⇑f.base)).obj (op x).unop))) ≫
          ((PullbackCone.snd s).base _* s.pt.presheaf).map
              (eqToHom
                (_ :
                  (Opens.map g.base).op.obj (op ((IsOpenMap.functor (_ : IsOpenMap ⇑f.base)).obj (op x).unop)) =
                    (IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj
                      ((Opens.map pullback.fst).op.obj (op x)))) ≫
            s.pt.presheaf.map
              (eqToHom
                  (_ :
                    (Opens.map (PullbackCone.snd s).base).op.obj
                        ((IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj
                          ((Opens.map (PullbackCone.fst (pullbackConeOfLeft f g)).base).op.obj (op x))) =
                      (Opens.map
                              (pullback.lift (PullbackCone.fst s).base (PullbackCone.snd s).base
                                (_ : (PullbackCone.fst s ≫ f).base = (PullbackCone.snd s ≫ g).base))).op.obj
                        ((Opens.map (PullbackCone.fst (pullbackConeOfLeft f g)).base).op.obj (op x))) ≫
                (eqToHom
                      (_ :
                        (Opens.map (pullbackConeOfLeftLift f g s ≫ PullbackCone.fst (pullbackConeOfLeft f g)).base).op =
                          (Opens.map (PullbackCone.fst s).base).op)).app
                  (op x)) =
    (PullbackCone.fst s).c.app (op x)

Next tactic:
rw [← IsIso.comp_inv_eq] at this
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 => ?_
    change ((_ ≫ _) ≫ _ ≫ _) ≫ _ = _
    simp_rw [Category.assoc]
    erw [← s.pt.presheaf.map_comp]
    erw [s.snd.c.naturality_assoc]
    have := congr_app s.condition (op (hf.openFunctor.obj x))
    dsimp only [comp_c_app, unop_op] at this
    rw [← IsIso.comp_inv_eq] at this
    

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
this :
  (f.c.app (op ((openFunctor hf).obj x)) ≫
        (PullbackCone.fst s).c.app (op ((Opens.map f.base).obj ((openFunctor hf).obj x)))) ≫
      inv
        (s.pt.presheaf.map
          (eqToHom
            (_ :
              (Opens.map (PullbackCone.snd s ≫ g).base).op.obj (op ((openFunctor hf).obj x)) =
                (Opens.map (PullbackCone.fst s ≫ f).base).op.obj (op ((openFunctor hf).obj x))))) =
    g.c.app (op ((openFunctor hf).obj x)) ≫
      (PullbackCone.snd s).c.app (op ((Opens.map g.base).obj ((openFunctor hf).obj x)))
⊢ invApp hf (op x).unop ≫
      g.c.app (op ((IsOpenMap.functor (_ : IsOpenMap ⇑f.base)).obj (op x).unop)) ≫
        (PullbackCone.snd s).c.app
            ((Opens.map g.base).op.obj (op ((IsOpenMap.functor (_ : IsOpenMap ⇑f.base)).obj (op x).unop))) ≫
          ((PullbackCone.snd s).base _* s.pt.presheaf).map
              (eqToHom
                (_ :
                  (Opens.map g.base).op.obj (op ((IsOpenMap.functor (_ : IsOpenMap ⇑f.base)).obj (op x).unop)) =
                    (IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj
                      ((Opens.map pullback.fst).op.obj (op x)))) ≫
            s.pt.presheaf.map
              (eqToHom
                  (_ :
                    (Opens.map (PullbackCone.snd s).base).op.obj
                        ((IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj
                          ((Opens.map (PullbackCone.fst (pullbackConeOfLeft f g)).base).op.obj (op x))) =
                      (Opens.map
                              (pullback.lift (PullbackCone.fst s).base (PullbackCone.snd s).base
                                (_ : (PullbackCone.fst s ≫ f).base = (PullbackCone.snd s ≫ g).base))).op.obj
                        ((Opens.map (PullbackCone.fst (pullbackConeOfLeft f g)).base).op.obj (op x))) ≫
                (eqToHom
                      (_ :
                        (Opens.map (pullbackConeOfLeftLift f g s ≫ PullbackCone.fst (pullbackConeOfLeft f g)).base).op =
                          (Opens.map (PullbackCone.fst s).base).op)).app
                  (op x)) =
    (PullbackCone.fst s).c.app (op x)

Next tactic:
replace this := reassoc_of% this
theorem pullbackConeOfLeftLift_snd :
    pullbackConeOfLeftLift f g s ≫ (pullbackConeOfLeft f g).snd = s.snd := 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.snd (pullbackConeOfLeft f g) = PullbackCone.snd s

Next tactic:
refine PresheafedSpace.Hom.ext _ _ ?_ <| NatTrans.ext _ _ <| funext fun x => ?_
theorem pullbackConeOfLeftLift_snd :
    pullbackConeOfLeftLift f g s ≫ (pullbackConeOfLeft f g).snd = s.snd := 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.snd (pullbackConeOfLeft f g)).base = (PullbackCone.snd s).base

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

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.snd =
    (PullbackCone.snd s).base

Next tactic:
simp
theorem pullbackConeOfLeftLift_snd :
    pullbackConeOfLeftLift f g s ≫ (pullbackConeOfLeft f g).snd = s.snd := by
  -- Porting note : `ext` did not pick up `NatTrans.ext`
  refine PresheafedSpace.Hom.ext _ _ ?_ <| NatTrans.ext _ _ <| funext fun x => ?_
  · change pullback.lift _ _ _ ≫ pullback.snd = _
    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 ↑↑Y)ᵒᵖ
⊢ ((pullbackConeOfLeftLift f g s ≫ PullbackCone.snd (pullbackConeOfLeft f g)).c ≫
          whiskerRight
            (eqToHom
              (_ :
                (Opens.map (pullbackConeOfLeftLift f g s ≫ PullbackCone.snd (pullbackConeOfLeft f g)).base).op =
                  (Opens.map (PullbackCone.snd s).base).op))
            s.pt.presheaf).app
      x =
    (PullbackCone.snd s).c.app x

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

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 ↑↑Y)ᵒᵖ
⊢ ((PullbackCone.snd (pullbackConeOfLeft f g)).c.app x ≫
        (PullbackCone.snd s).c.app
            ((IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj
              ((Opens.map (PullbackCone.snd (pullbackConeOfLeft f g)).base).op.obj x)) ≫
          s.pt.presheaf.map
            (eqToHom
              (_ :
                (Opens.map (PullbackCone.snd s).base).op.obj
                    ((IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj
                      ((Opens.map (PullbackCone.snd (pullbackConeOfLeft f g)).base).op.obj x)) =
                  (Opens.map
                          (pullback.lift (PullbackCone.fst s).base (PullbackCone.snd s).base
                            (_ : (PullbackCone.fst s ≫ f).base = (PullbackCone.snd s ≫ g).base))).op.obj
                    ((Opens.map (PullbackCone.snd (pullbackConeOfLeft f g)).base).op.obj x)))) ≫
      (whiskerRight
            (eqToHom
              (_ :
                (Opens.map (pullbackConeOfLeftLift f g s ≫ PullbackCone.snd (pullbackConeOfLeft f g)).base).op =
                  (Opens.map (PullbackCone.snd s).base).op))
            s.pt.presheaf).app
        x =
    (PullbackCone.snd s).c.app x

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

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 ↑↑Y)ᵒᵖ
⊢ (PullbackCone.snd (pullbackConeOfLeft f g)).c.app x ≫
      (PullbackCone.snd s).c.app
          ((IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj
            ((Opens.map (PullbackCone.snd (pullbackConeOfLeft f g)).base).op.obj x)) ≫
        s.pt.presheaf.map
            (eqToHom
              (_ :
                (Opens.map (PullbackCone.snd s).base).op.obj
                    ((IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj
                      ((Opens.map (PullbackCone.snd (pullbackConeOfLeft f g)).base).op.obj x)) =
                  (Opens.map
                          (pullback.lift (PullbackCone.fst s).base (PullbackCone.snd s).base
                            (_ : (PullbackCone.fst s ≫ f).base = (PullbackCone.snd s ≫ g).base))).op.obj
                    ((Opens.map (PullbackCone.snd (pullbackConeOfLeft f g)).base).op.obj x))) ≫
          (whiskerRight
                (eqToHom
                  (_ :
                    (Opens.map (pullbackConeOfLeftLift f g s ≫ PullbackCone.snd (pullbackConeOfLeft f g)).base).op =
                      (Opens.map (PullbackCone.snd s).base).op))
                s.pt.presheaf).app
            x =
    (PullbackCone.snd s).c.app x

Next tactic:
erw [s.snd.c.naturality_assoc]