[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j : 𝒰.J
⊢ v 𝒰 f g i j ⟶ v 𝒰 f g j i
[PROOFSTEP]
haveI : HasPullback (pullback.snd ≫ 𝒰.map i ≫ f) g := hasPullback_assoc_symm (𝒰.map j) (𝒰.map i) (𝒰.map i ≫ f) g
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j : 𝒰.J
this : HasPullback (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) g
⊢ v 𝒰 f g i j ⟶ v 𝒰 f g j i
[PROOFSTEP]
haveI : HasPullback (pullback.snd ≫ 𝒰.map j ≫ f) g := hasPullback_assoc_symm (𝒰.map i) (𝒰.map j) (𝒰.map j ≫ f) g
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j : 𝒰.J
this✝ : HasPullback (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) g
this : HasPullback (pullback.snd ≫ OpenCover.map 𝒰 j ≫ f) g
⊢ v 𝒰 f g i j ⟶ v 𝒰 f g j i
[PROOFSTEP]
refine' (pullbackSymmetry _ _).hom ≫ _
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j : 𝒰.J
this✝ : HasPullback (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) g
this : HasPullback (pullback.snd ≫ OpenCover.map 𝒰 j ≫ f) g
⊢ pullback (OpenCover.map 𝒰 j) (pullback.fst ≫ OpenCover.map 𝒰 i) ⟶ v 𝒰 f g j i
[PROOFSTEP]
refine' (pullbackAssoc _ _ _ _).inv ≫ _
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j : 𝒰.J
this✝ : HasPullback (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) g
this : HasPullback (pullback.snd ≫ OpenCover.map 𝒰 j ≫ f) g
⊢ pullback (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) g ⟶ v 𝒰 f g j i
[PROOFSTEP]
change pullback _ _ ⟶ pullback _ _
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j : 𝒰.J
this✝ : HasPullback (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) g
this : HasPullback (pullback.snd ≫ OpenCover.map 𝒰 j ≫ f) g
⊢ pullback (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) g ⟶ pullback (pullback.fst ≫ OpenCover.map 𝒰 j) (OpenCover.map 𝒰 i)
[PROOFSTEP]
refine' _ ≫ (pullbackSymmetry _ _).hom
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j : 𝒰.J
this✝ : HasPullback (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) g
this : HasPullback (pullback.snd ≫ OpenCover.map 𝒰 j ≫ f) g
⊢ pullback (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) g ⟶ pullback (OpenCover.map 𝒰 i) (pullback.fst ≫ OpenCover.map 𝒰 j)
[PROOFSTEP]
refine' _ ≫ (pullbackAssoc _ _ _ _).hom
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j : 𝒰.J
this✝ : HasPullback (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) g
this : HasPullback (pullback.snd ≫ OpenCover.map 𝒰 j ≫ f) g
⊢ pullback (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) g ⟶ pullback (pullback.snd ≫ OpenCover.map 𝒰 j ≫ f) g
[PROOFSTEP]
refine' pullback.map _ _ _ _ (pullbackSymmetry _ _).hom (𝟙 _) (𝟙 _) _ _
[GOAL]
case refine'_1
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j : 𝒰.J
this✝ : HasPullback (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) g
this : HasPullback (pullback.snd ≫ OpenCover.map 𝒰 j ≫ f) g
⊢ (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) ≫ 𝟙 Z =
    (pullbackSymmetry (OpenCover.map 𝒰 j) (OpenCover.map 𝒰 i)).hom ≫ pullback.snd ≫ OpenCover.map 𝒰 j ≫ f
case refine'_2
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j : 𝒰.J
this✝ : HasPullback (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) g
this : HasPullback (pullback.snd ≫ OpenCover.map 𝒰 j ≫ f) g
⊢ g ≫ 𝟙 Z = 𝟙 Y ≫ g
[PROOFSTEP]
rw [pullbackSymmetry_hom_comp_snd_assoc, pullback.condition_assoc, Category.comp_id]
[GOAL]
case refine'_2
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j : 𝒰.J
this✝ : HasPullback (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) g
this : HasPullback (pullback.snd ≫ OpenCover.map 𝒰 j ≫ f) g
⊢ g ≫ 𝟙 Z = 𝟙 Y ≫ g
[PROOFSTEP]
rw [Category.comp_id, Category.id_comp]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j : 𝒰.J
⊢ t 𝒰 f g i j ≫ pullback.fst ≫ pullback.fst = pullback.snd
[PROOFSTEP]
delta t
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j : 𝒰.J
⊢ ((pullbackSymmetry (pullback.fst ≫ OpenCover.map 𝒰 i) (OpenCover.map 𝒰 j)).hom ≫
        (pullbackAssoc (OpenCover.map 𝒰 j) (OpenCover.map 𝒰 i) (OpenCover.map 𝒰 i ≫ f) g).inv ≫
          let_fun this :=
            (pullback.map (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) g (pullback.snd ≫ OpenCover.map 𝒰 j ≫ f) g
                  (pullbackSymmetry (OpenCover.map 𝒰 j) (OpenCover.map 𝒰 i)).hom (𝟙 Y) (𝟙 Z)
                  (_ :
                    (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) ≫ 𝟙 Z =
                      (pullbackSymmetry (OpenCover.map 𝒰 j) (OpenCover.map 𝒰 i)).hom ≫
                        pullback.snd ≫ OpenCover.map 𝒰 j ≫ f)
                  (_ : g ≫ 𝟙 Z = 𝟙 Y ≫ g) ≫
                (pullbackAssoc (OpenCover.map 𝒰 i) (OpenCover.map 𝒰 j) (OpenCover.map 𝒰 j ≫ f) g).hom) ≫
              (pullbackSymmetry (OpenCover.map 𝒰 i) (pullback.fst ≫ OpenCover.map 𝒰 j)).hom;
          this) ≫
      pullback.fst ≫ pullback.fst =
    pullback.snd
[PROOFSTEP]
haveI : HasPullback (pullback.snd ≫ 𝒰.map i ≫ f) g := hasPullback_assoc_symm (𝒰.map j) (𝒰.map i) (𝒰.map i ≫ f) g
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j : 𝒰.J
this : HasPullback (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) g
⊢ ((pullbackSymmetry (pullback.fst ≫ OpenCover.map 𝒰 i) (OpenCover.map 𝒰 j)).hom ≫
        (pullbackAssoc (OpenCover.map 𝒰 j) (OpenCover.map 𝒰 i) (OpenCover.map 𝒰 i ≫ f) g).inv ≫
          let_fun this :=
            (pullback.map (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) g (pullback.snd ≫ OpenCover.map 𝒰 j ≫ f) g
                  (pullbackSymmetry (OpenCover.map 𝒰 j) (OpenCover.map 𝒰 i)).hom (𝟙 Y) (𝟙 Z)
                  (_ :
                    (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) ≫ 𝟙 Z =
                      (pullbackSymmetry (OpenCover.map 𝒰 j) (OpenCover.map 𝒰 i)).hom ≫
                        pullback.snd ≫ OpenCover.map 𝒰 j ≫ f)
                  (_ : g ≫ 𝟙 Z = 𝟙 Y ≫ g) ≫
                (pullbackAssoc (OpenCover.map 𝒰 i) (OpenCover.map 𝒰 j) (OpenCover.map 𝒰 j ≫ f) g).hom) ≫
              (pullbackSymmetry (OpenCover.map 𝒰 i) (pullback.fst ≫ OpenCover.map 𝒰 j)).hom;
          this) ≫
      pullback.fst ≫ pullback.fst =
    pullback.snd
[PROOFSTEP]
haveI : HasPullback (pullback.snd ≫ 𝒰.map j ≫ f) g := hasPullback_assoc_symm (𝒰.map i) (𝒰.map j) (𝒰.map j ≫ f) g
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j : 𝒰.J
this✝ : HasPullback (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) g
this : HasPullback (pullback.snd ≫ OpenCover.map 𝒰 j ≫ f) g
⊢ ((pullbackSymmetry (pullback.fst ≫ OpenCover.map 𝒰 i) (OpenCover.map 𝒰 j)).hom ≫
        (pullbackAssoc (OpenCover.map 𝒰 j) (OpenCover.map 𝒰 i) (OpenCover.map 𝒰 i ≫ f) g).inv ≫
          let_fun this :=
            (pullback.map (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) g (pullback.snd ≫ OpenCover.map 𝒰 j ≫ f) g
                  (pullbackSymmetry (OpenCover.map 𝒰 j) (OpenCover.map 𝒰 i)).hom (𝟙 Y) (𝟙 Z)
                  (_ :
                    (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) ≫ 𝟙 Z =
                      (pullbackSymmetry (OpenCover.map 𝒰 j) (OpenCover.map 𝒰 i)).hom ≫
                        pullback.snd ≫ OpenCover.map 𝒰 j ≫ f)
                  (_ : g ≫ 𝟙 Z = 𝟙 Y ≫ g) ≫
                (pullbackAssoc (OpenCover.map 𝒰 i) (OpenCover.map 𝒰 j) (OpenCover.map 𝒰 j ≫ f) g).hom) ≫
              (pullbackSymmetry (OpenCover.map 𝒰 i) (pullback.fst ≫ OpenCover.map 𝒰 j)).hom;
          this) ≫
      pullback.fst ≫ pullback.fst =
    pullback.snd
[PROOFSTEP]
simp only [Category.assoc, id.def, pullbackSymmetry_hom_comp_fst_assoc, pullbackAssoc_hom_snd_fst,
  pullback.lift_fst_assoc, pullbackSymmetry_hom_comp_snd, pullbackAssoc_inv_fst_fst, pullbackSymmetry_hom_comp_fst]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j : 𝒰.J
⊢ t 𝒰 f g i j ≫ pullback.fst ≫ pullback.snd = pullback.fst ≫ pullback.snd
[PROOFSTEP]
delta t
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j : 𝒰.J
⊢ ((pullbackSymmetry (pullback.fst ≫ OpenCover.map 𝒰 i) (OpenCover.map 𝒰 j)).hom ≫
        (pullbackAssoc (OpenCover.map 𝒰 j) (OpenCover.map 𝒰 i) (OpenCover.map 𝒰 i ≫ f) g).inv ≫
          let_fun this :=
            (pullback.map (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) g (pullback.snd ≫ OpenCover.map 𝒰 j ≫ f) g
                  (pullbackSymmetry (OpenCover.map 𝒰 j) (OpenCover.map 𝒰 i)).hom (𝟙 Y) (𝟙 Z)
                  (_ :
                    (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) ≫ 𝟙 Z =
                      (pullbackSymmetry (OpenCover.map 𝒰 j) (OpenCover.map 𝒰 i)).hom ≫
                        pullback.snd ≫ OpenCover.map 𝒰 j ≫ f)
                  (_ : g ≫ 𝟙 Z = 𝟙 Y ≫ g) ≫
                (pullbackAssoc (OpenCover.map 𝒰 i) (OpenCover.map 𝒰 j) (OpenCover.map 𝒰 j ≫ f) g).hom) ≫
              (pullbackSymmetry (OpenCover.map 𝒰 i) (pullback.fst ≫ OpenCover.map 𝒰 j)).hom;
          this) ≫
      pullback.fst ≫ pullback.snd =
    pullback.fst ≫ pullback.snd
[PROOFSTEP]
haveI : HasPullback (pullback.snd ≫ 𝒰.map i ≫ f) g := hasPullback_assoc_symm (𝒰.map j) (𝒰.map i) (𝒰.map i ≫ f) g
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j : 𝒰.J
this : HasPullback (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) g
⊢ ((pullbackSymmetry (pullback.fst ≫ OpenCover.map 𝒰 i) (OpenCover.map 𝒰 j)).hom ≫
        (pullbackAssoc (OpenCover.map 𝒰 j) (OpenCover.map 𝒰 i) (OpenCover.map 𝒰 i ≫ f) g).inv ≫
          let_fun this :=
            (pullback.map (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) g (pullback.snd ≫ OpenCover.map 𝒰 j ≫ f) g
                  (pullbackSymmetry (OpenCover.map 𝒰 j) (OpenCover.map 𝒰 i)).hom (𝟙 Y) (𝟙 Z)
                  (_ :
                    (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) ≫ 𝟙 Z =
                      (pullbackSymmetry (OpenCover.map 𝒰 j) (OpenCover.map 𝒰 i)).hom ≫
                        pullback.snd ≫ OpenCover.map 𝒰 j ≫ f)
                  (_ : g ≫ 𝟙 Z = 𝟙 Y ≫ g) ≫
                (pullbackAssoc (OpenCover.map 𝒰 i) (OpenCover.map 𝒰 j) (OpenCover.map 𝒰 j ≫ f) g).hom) ≫
              (pullbackSymmetry (OpenCover.map 𝒰 i) (pullback.fst ≫ OpenCover.map 𝒰 j)).hom;
          this) ≫
      pullback.fst ≫ pullback.snd =
    pullback.fst ≫ pullback.snd
[PROOFSTEP]
haveI : HasPullback (pullback.snd ≫ 𝒰.map j ≫ f) g := hasPullback_assoc_symm (𝒰.map i) (𝒰.map j) (𝒰.map j ≫ f) g
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j : 𝒰.J
this✝ : HasPullback (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) g
this : HasPullback (pullback.snd ≫ OpenCover.map 𝒰 j ≫ f) g
⊢ ((pullbackSymmetry (pullback.fst ≫ OpenCover.map 𝒰 i) (OpenCover.map 𝒰 j)).hom ≫
        (pullbackAssoc (OpenCover.map 𝒰 j) (OpenCover.map 𝒰 i) (OpenCover.map 𝒰 i ≫ f) g).inv ≫
          let_fun this :=
            (pullback.map (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) g (pullback.snd ≫ OpenCover.map 𝒰 j ≫ f) g
                  (pullbackSymmetry (OpenCover.map 𝒰 j) (OpenCover.map 𝒰 i)).hom (𝟙 Y) (𝟙 Z)
                  (_ :
                    (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) ≫ 𝟙 Z =
                      (pullbackSymmetry (OpenCover.map 𝒰 j) (OpenCover.map 𝒰 i)).hom ≫
                        pullback.snd ≫ OpenCover.map 𝒰 j ≫ f)
                  (_ : g ≫ 𝟙 Z = 𝟙 Y ≫ g) ≫
                (pullbackAssoc (OpenCover.map 𝒰 i) (OpenCover.map 𝒰 j) (OpenCover.map 𝒰 j ≫ f) g).hom) ≫
              (pullbackSymmetry (OpenCover.map 𝒰 i) (pullback.fst ≫ OpenCover.map 𝒰 j)).hom;
          this) ≫
      pullback.fst ≫ pullback.snd =
    pullback.fst ≫ pullback.snd
[PROOFSTEP]
simp only [pullbackSymmetry_hom_comp_snd_assoc, Category.comp_id, Category.assoc, id.def,
  pullbackSymmetry_hom_comp_fst_assoc, pullbackAssoc_hom_snd_snd, pullback.lift_snd, pullbackAssoc_inv_snd]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j : 𝒰.J
⊢ t 𝒰 f g i j ≫ pullback.snd = pullback.fst ≫ pullback.fst
[PROOFSTEP]
delta t
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j : 𝒰.J
⊢ ((pullbackSymmetry (pullback.fst ≫ OpenCover.map 𝒰 i) (OpenCover.map 𝒰 j)).hom ≫
        (pullbackAssoc (OpenCover.map 𝒰 j) (OpenCover.map 𝒰 i) (OpenCover.map 𝒰 i ≫ f) g).inv ≫
          let_fun this :=
            (pullback.map (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) g (pullback.snd ≫ OpenCover.map 𝒰 j ≫ f) g
                  (pullbackSymmetry (OpenCover.map 𝒰 j) (OpenCover.map 𝒰 i)).hom (𝟙 Y) (𝟙 Z)
                  (_ :
                    (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) ≫ 𝟙 Z =
                      (pullbackSymmetry (OpenCover.map 𝒰 j) (OpenCover.map 𝒰 i)).hom ≫
                        pullback.snd ≫ OpenCover.map 𝒰 j ≫ f)
                  (_ : g ≫ 𝟙 Z = 𝟙 Y ≫ g) ≫
                (pullbackAssoc (OpenCover.map 𝒰 i) (OpenCover.map 𝒰 j) (OpenCover.map 𝒰 j ≫ f) g).hom) ≫
              (pullbackSymmetry (OpenCover.map 𝒰 i) (pullback.fst ≫ OpenCover.map 𝒰 j)).hom;
          this) ≫
      pullback.snd =
    pullback.fst ≫ pullback.fst
[PROOFSTEP]
haveI : HasPullback (pullback.snd ≫ 𝒰.map i ≫ f) g := hasPullback_assoc_symm (𝒰.map j) (𝒰.map i) (𝒰.map i ≫ f) g
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j : 𝒰.J
this : HasPullback (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) g
⊢ ((pullbackSymmetry (pullback.fst ≫ OpenCover.map 𝒰 i) (OpenCover.map 𝒰 j)).hom ≫
        (pullbackAssoc (OpenCover.map 𝒰 j) (OpenCover.map 𝒰 i) (OpenCover.map 𝒰 i ≫ f) g).inv ≫
          let_fun this :=
            (pullback.map (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) g (pullback.snd ≫ OpenCover.map 𝒰 j ≫ f) g
                  (pullbackSymmetry (OpenCover.map 𝒰 j) (OpenCover.map 𝒰 i)).hom (𝟙 Y) (𝟙 Z)
                  (_ :
                    (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) ≫ 𝟙 Z =
                      (pullbackSymmetry (OpenCover.map 𝒰 j) (OpenCover.map 𝒰 i)).hom ≫
                        pullback.snd ≫ OpenCover.map 𝒰 j ≫ f)
                  (_ : g ≫ 𝟙 Z = 𝟙 Y ≫ g) ≫
                (pullbackAssoc (OpenCover.map 𝒰 i) (OpenCover.map 𝒰 j) (OpenCover.map 𝒰 j ≫ f) g).hom) ≫
              (pullbackSymmetry (OpenCover.map 𝒰 i) (pullback.fst ≫ OpenCover.map 𝒰 j)).hom;
          this) ≫
      pullback.snd =
    pullback.fst ≫ pullback.fst
[PROOFSTEP]
haveI : HasPullback (pullback.snd ≫ 𝒰.map j ≫ f) g := hasPullback_assoc_symm (𝒰.map i) (𝒰.map j) (𝒰.map j ≫ f) g
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j : 𝒰.J
this✝ : HasPullback (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) g
this : HasPullback (pullback.snd ≫ OpenCover.map 𝒰 j ≫ f) g
⊢ ((pullbackSymmetry (pullback.fst ≫ OpenCover.map 𝒰 i) (OpenCover.map 𝒰 j)).hom ≫
        (pullbackAssoc (OpenCover.map 𝒰 j) (OpenCover.map 𝒰 i) (OpenCover.map 𝒰 i ≫ f) g).inv ≫
          let_fun this :=
            (pullback.map (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) g (pullback.snd ≫ OpenCover.map 𝒰 j ≫ f) g
                  (pullbackSymmetry (OpenCover.map 𝒰 j) (OpenCover.map 𝒰 i)).hom (𝟙 Y) (𝟙 Z)
                  (_ :
                    (pullback.snd ≫ OpenCover.map 𝒰 i ≫ f) ≫ 𝟙 Z =
                      (pullbackSymmetry (OpenCover.map 𝒰 j) (OpenCover.map 𝒰 i)).hom ≫
                        pullback.snd ≫ OpenCover.map 𝒰 j ≫ f)
                  (_ : g ≫ 𝟙 Z = 𝟙 Y ≫ g) ≫
                (pullbackAssoc (OpenCover.map 𝒰 i) (OpenCover.map 𝒰 j) (OpenCover.map 𝒰 j ≫ f) g).hom) ≫
              (pullbackSymmetry (OpenCover.map 𝒰 i) (pullback.fst ≫ OpenCover.map 𝒰 j)).hom;
          this) ≫
      pullback.snd =
    pullback.fst ≫ pullback.fst
[PROOFSTEP]
simp only [pullbackSymmetry_hom_comp_snd_assoc, Category.assoc, id.def, pullbackSymmetry_hom_comp_snd,
  pullbackAssoc_hom_fst, pullback.lift_fst_assoc, pullbackSymmetry_hom_comp_fst, pullbackAssoc_inv_fst_snd]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i : 𝒰.J
⊢ t 𝒰 f g i i = 𝟙 (v 𝒰 f g i i)
[PROOFSTEP]
apply pullback.hom_ext
[GOAL]
case h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i : 𝒰.J
⊢ t 𝒰 f g i i ≫ pullback.fst = 𝟙 (v 𝒰 f g i i) ≫ pullback.fst
[PROOFSTEP]
rw [Category.id_comp]
[GOAL]
case h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i : 𝒰.J
⊢ t 𝒰 f g i i ≫ pullback.snd = 𝟙 (v 𝒰 f g i i) ≫ pullback.snd
[PROOFSTEP]
rw [Category.id_comp]
[GOAL]
case h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i : 𝒰.J
⊢ t 𝒰 f g i i ≫ pullback.fst = pullback.fst
case h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i : 𝒰.J
⊢ t 𝒰 f g i i ≫ pullback.snd = pullback.snd
[PROOFSTEP]
apply pullback.hom_ext
[GOAL]
case h₀.h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i : 𝒰.J
⊢ (t 𝒰 f g i i ≫ pullback.fst) ≫ pullback.fst = pullback.fst ≫ pullback.fst
[PROOFSTEP]
rw [← cancel_mono (𝒰.map i)]
[GOAL]
case h₀.h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i : 𝒰.J
⊢ ((t 𝒰 f g i i ≫ pullback.fst) ≫ pullback.fst) ≫ OpenCover.map 𝒰 i = (pullback.fst ≫ pullback.fst) ≫ OpenCover.map 𝒰 i
[PROOFSTEP]
simp only [pullback.condition, Category.assoc, t_fst_fst]
[GOAL]
case h₀.h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i : 𝒰.J
⊢ (t 𝒰 f g i i ≫ pullback.fst) ≫ pullback.snd = pullback.fst ≫ pullback.snd
[PROOFSTEP]
simp only [Category.assoc, t_fst_snd]
[GOAL]
case h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i : 𝒰.J
⊢ t 𝒰 f g i i ≫ pullback.snd = pullback.snd
[PROOFSTEP]
rw [← cancel_mono (𝒰.map i)]
[GOAL]
case h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i : 𝒰.J
⊢ (t 𝒰 f g i i ≫ pullback.snd) ≫ OpenCover.map 𝒰 i = pullback.snd ≫ OpenCover.map 𝒰 i
[PROOFSTEP]
simp only [pullback.condition, t_snd, Category.assoc]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ pullback (fV 𝒰 f g i j) (fV 𝒰 f g i k) ⟶ pullback (fV 𝒰 f g j k) (fV 𝒰 f g j i)
[PROOFSTEP]
refine' (pullbackRightPullbackFstIso _ _ _).hom ≫ _
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ pullback (fV 𝒰 f g i j ≫ pullback.fst ≫ OpenCover.map 𝒰 i) (OpenCover.map 𝒰 k) ⟶
    pullback (fV 𝒰 f g j k) (fV 𝒰 f g j i)
[PROOFSTEP]
refine' _ ≫ (pullbackSymmetry _ _).hom
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ pullback (fV 𝒰 f g i j ≫ pullback.fst ≫ OpenCover.map 𝒰 i) (OpenCover.map 𝒰 k) ⟶
    pullback (fV 𝒰 f g j i) (fV 𝒰 f g j k)
[PROOFSTEP]
refine' _ ≫ (pullbackRightPullbackFstIso _ _ _).inv
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ pullback (fV 𝒰 f g i j ≫ pullback.fst ≫ OpenCover.map 𝒰 i) (OpenCover.map 𝒰 k) ⟶
    pullback (fV 𝒰 f g j i ≫ pullback.fst ≫ OpenCover.map 𝒰 j) (OpenCover.map 𝒰 k)
[PROOFSTEP]
refine' pullback.map _ _ _ _ (t 𝒰 f g i j) (𝟙 _) (𝟙 _) _ _
[GOAL]
case refine'_1
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ (fV 𝒰 f g i j ≫ pullback.fst ≫ OpenCover.map 𝒰 i) ≫ 𝟙 X =
    t 𝒰 f g i j ≫ fV 𝒰 f g j i ≫ pullback.fst ≫ OpenCover.map 𝒰 j
[PROOFSTEP]
simp only [← pullback.condition, Category.comp_id, t_fst_fst_assoc]
[GOAL]
case refine'_2
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ OpenCover.map 𝒰 k ≫ 𝟙 X = 𝟙 (OpenCover.obj 𝒰 k) ≫ OpenCover.map 𝒰 k
[PROOFSTEP]
simp only [Category.comp_id, Category.id_comp]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ t' 𝒰 f g i j k ≫ pullback.fst ≫ pullback.fst ≫ pullback.fst = pullback.fst ≫ pullback.snd
[PROOFSTEP]
delta t'
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ ((pullbackRightPullbackFstIso (pullback.fst ≫ OpenCover.map 𝒰 i) (OpenCover.map 𝒰 k) (fV 𝒰 f g i j)).hom ≫
        (pullback.map (fV 𝒰 f g i j ≫ pullback.fst ≫ OpenCover.map 𝒰 i) (OpenCover.map 𝒰 k)
              (fV 𝒰 f g j i ≫ pullback.fst ≫ OpenCover.map 𝒰 j) (OpenCover.map 𝒰 k) (t 𝒰 f g i j)
              (𝟙 (OpenCover.obj 𝒰 k)) (𝟙 X)
              (_ :
                (fV 𝒰 f g i j ≫ pullback.fst ≫ OpenCover.map 𝒰 i) ≫ 𝟙 X =
                  t 𝒰 f g i j ≫ pullback.fst ≫ pullback.fst ≫ OpenCover.map 𝒰 j)
              (_ : OpenCover.map 𝒰 k ≫ 𝟙 X = 𝟙 (OpenCover.obj 𝒰 k) ≫ OpenCover.map 𝒰 k) ≫
            (pullbackRightPullbackFstIso (pullback.fst ≫ OpenCover.map 𝒰 j) (OpenCover.map 𝒰 k) (fV 𝒰 f g j i)).inv) ≫
          (pullbackSymmetry (fV 𝒰 f g j i) (fV 𝒰 f g j k)).hom) ≫
      pullback.fst ≫ pullback.fst ≫ pullback.fst =
    pullback.fst ≫ pullback.snd
[PROOFSTEP]
simp only [Category.assoc, pullbackSymmetry_hom_comp_fst_assoc, pullbackRightPullbackFstIso_inv_snd_fst_assoc,
  pullback.lift_fst_assoc, t_fst_fst, pullbackRightPullbackFstIso_hom_fst_assoc]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ t' 𝒰 f g i j k ≫ pullback.fst ≫ pullback.fst ≫ pullback.snd = pullback.fst ≫ pullback.fst ≫ pullback.snd
[PROOFSTEP]
delta t'
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ ((pullbackRightPullbackFstIso (pullback.fst ≫ OpenCover.map 𝒰 i) (OpenCover.map 𝒰 k) (fV 𝒰 f g i j)).hom ≫
        (pullback.map (fV 𝒰 f g i j ≫ pullback.fst ≫ OpenCover.map 𝒰 i) (OpenCover.map 𝒰 k)
              (fV 𝒰 f g j i ≫ pullback.fst ≫ OpenCover.map 𝒰 j) (OpenCover.map 𝒰 k) (t 𝒰 f g i j)
              (𝟙 (OpenCover.obj 𝒰 k)) (𝟙 X)
              (_ :
                (fV 𝒰 f g i j ≫ pullback.fst ≫ OpenCover.map 𝒰 i) ≫ 𝟙 X =
                  t 𝒰 f g i j ≫ pullback.fst ≫ pullback.fst ≫ OpenCover.map 𝒰 j)
              (_ : OpenCover.map 𝒰 k ≫ 𝟙 X = 𝟙 (OpenCover.obj 𝒰 k) ≫ OpenCover.map 𝒰 k) ≫
            (pullbackRightPullbackFstIso (pullback.fst ≫ OpenCover.map 𝒰 j) (OpenCover.map 𝒰 k) (fV 𝒰 f g j i)).inv) ≫
          (pullbackSymmetry (fV 𝒰 f g j i) (fV 𝒰 f g j k)).hom) ≫
      pullback.fst ≫ pullback.fst ≫ pullback.snd =
    pullback.fst ≫ pullback.fst ≫ pullback.snd
[PROOFSTEP]
simp only [Category.assoc, pullbackSymmetry_hom_comp_fst_assoc, pullbackRightPullbackFstIso_inv_snd_fst_assoc,
  pullback.lift_fst_assoc, t_fst_snd, pullbackRightPullbackFstIso_hom_fst_assoc]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ t' 𝒰 f g i j k ≫ pullback.fst ≫ pullback.snd = pullback.snd ≫ pullback.snd
[PROOFSTEP]
delta t'
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ ((pullbackRightPullbackFstIso (pullback.fst ≫ OpenCover.map 𝒰 i) (OpenCover.map 𝒰 k) (fV 𝒰 f g i j)).hom ≫
        (pullback.map (fV 𝒰 f g i j ≫ pullback.fst ≫ OpenCover.map 𝒰 i) (OpenCover.map 𝒰 k)
              (fV 𝒰 f g j i ≫ pullback.fst ≫ OpenCover.map 𝒰 j) (OpenCover.map 𝒰 k) (t 𝒰 f g i j)
              (𝟙 (OpenCover.obj 𝒰 k)) (𝟙 X)
              (_ :
                (fV 𝒰 f g i j ≫ pullback.fst ≫ OpenCover.map 𝒰 i) ≫ 𝟙 X =
                  t 𝒰 f g i j ≫ pullback.fst ≫ pullback.fst ≫ OpenCover.map 𝒰 j)
              (_ : OpenCover.map 𝒰 k ≫ 𝟙 X = 𝟙 (OpenCover.obj 𝒰 k) ≫ OpenCover.map 𝒰 k) ≫
            (pullbackRightPullbackFstIso (pullback.fst ≫ OpenCover.map 𝒰 j) (OpenCover.map 𝒰 k) (fV 𝒰 f g j i)).inv) ≫
          (pullbackSymmetry (fV 𝒰 f g j i) (fV 𝒰 f g j k)).hom) ≫
      pullback.fst ≫ pullback.snd =
    pullback.snd ≫ pullback.snd
[PROOFSTEP]
simp only [Category.comp_id, Category.assoc, pullbackSymmetry_hom_comp_fst_assoc,
  pullbackRightPullbackFstIso_inv_snd_snd, pullback.lift_snd, pullbackRightPullbackFstIso_hom_snd]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ t' 𝒰 f g i j k ≫ pullback.snd ≫ pullback.fst ≫ pullback.fst = pullback.fst ≫ pullback.snd
[PROOFSTEP]
delta t'
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ ((pullbackRightPullbackFstIso (pullback.fst ≫ OpenCover.map 𝒰 i) (OpenCover.map 𝒰 k) (fV 𝒰 f g i j)).hom ≫
        (pullback.map (fV 𝒰 f g i j ≫ pullback.fst ≫ OpenCover.map 𝒰 i) (OpenCover.map 𝒰 k)
              (fV 𝒰 f g j i ≫ pullback.fst ≫ OpenCover.map 𝒰 j) (OpenCover.map 𝒰 k) (t 𝒰 f g i j)
              (𝟙 (OpenCover.obj 𝒰 k)) (𝟙 X)
              (_ :
                (fV 𝒰 f g i j ≫ pullback.fst ≫ OpenCover.map 𝒰 i) ≫ 𝟙 X =
                  t 𝒰 f g i j ≫ pullback.fst ≫ pullback.fst ≫ OpenCover.map 𝒰 j)
              (_ : OpenCover.map 𝒰 k ≫ 𝟙 X = 𝟙 (OpenCover.obj 𝒰 k) ≫ OpenCover.map 𝒰 k) ≫
            (pullbackRightPullbackFstIso (pullback.fst ≫ OpenCover.map 𝒰 j) (OpenCover.map 𝒰 k) (fV 𝒰 f g j i)).inv) ≫
          (pullbackSymmetry (fV 𝒰 f g j i) (fV 𝒰 f g j k)).hom) ≫
      pullback.snd ≫ pullback.fst ≫ pullback.fst =
    pullback.fst ≫ pullback.snd
[PROOFSTEP]
simp only [Category.assoc, pullbackSymmetry_hom_comp_snd_assoc, pullbackRightPullbackFstIso_inv_fst_assoc,
  pullback.lift_fst_assoc, t_fst_fst, pullbackRightPullbackFstIso_hom_fst_assoc]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ t' 𝒰 f g i j k ≫ pullback.snd ≫ pullback.fst ≫ pullback.snd = pullback.fst ≫ pullback.fst ≫ pullback.snd
[PROOFSTEP]
delta t'
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ ((pullbackRightPullbackFstIso (pullback.fst ≫ OpenCover.map 𝒰 i) (OpenCover.map 𝒰 k) (fV 𝒰 f g i j)).hom ≫
        (pullback.map (fV 𝒰 f g i j ≫ pullback.fst ≫ OpenCover.map 𝒰 i) (OpenCover.map 𝒰 k)
              (fV 𝒰 f g j i ≫ pullback.fst ≫ OpenCover.map 𝒰 j) (OpenCover.map 𝒰 k) (t 𝒰 f g i j)
              (𝟙 (OpenCover.obj 𝒰 k)) (𝟙 X)
              (_ :
                (fV 𝒰 f g i j ≫ pullback.fst ≫ OpenCover.map 𝒰 i) ≫ 𝟙 X =
                  t 𝒰 f g i j ≫ pullback.fst ≫ pullback.fst ≫ OpenCover.map 𝒰 j)
              (_ : OpenCover.map 𝒰 k ≫ 𝟙 X = 𝟙 (OpenCover.obj 𝒰 k) ≫ OpenCover.map 𝒰 k) ≫
            (pullbackRightPullbackFstIso (pullback.fst ≫ OpenCover.map 𝒰 j) (OpenCover.map 𝒰 k) (fV 𝒰 f g j i)).inv) ≫
          (pullbackSymmetry (fV 𝒰 f g j i) (fV 𝒰 f g j k)).hom) ≫
      pullback.snd ≫ pullback.fst ≫ pullback.snd =
    pullback.fst ≫ pullback.fst ≫ pullback.snd
[PROOFSTEP]
simp only [Category.assoc, pullbackSymmetry_hom_comp_snd_assoc, pullbackRightPullbackFstIso_inv_fst_assoc,
  pullback.lift_fst_assoc, t_fst_snd, pullbackRightPullbackFstIso_hom_fst_assoc]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ t' 𝒰 f g i j k ≫ pullback.snd ≫ pullback.snd = pullback.fst ≫ pullback.fst ≫ pullback.fst
[PROOFSTEP]
delta t'
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ ((pullbackRightPullbackFstIso (pullback.fst ≫ OpenCover.map 𝒰 i) (OpenCover.map 𝒰 k) (fV 𝒰 f g i j)).hom ≫
        (pullback.map (fV 𝒰 f g i j ≫ pullback.fst ≫ OpenCover.map 𝒰 i) (OpenCover.map 𝒰 k)
              (fV 𝒰 f g j i ≫ pullback.fst ≫ OpenCover.map 𝒰 j) (OpenCover.map 𝒰 k) (t 𝒰 f g i j)
              (𝟙 (OpenCover.obj 𝒰 k)) (𝟙 X)
              (_ :
                (fV 𝒰 f g i j ≫ pullback.fst ≫ OpenCover.map 𝒰 i) ≫ 𝟙 X =
                  t 𝒰 f g i j ≫ pullback.fst ≫ pullback.fst ≫ OpenCover.map 𝒰 j)
              (_ : OpenCover.map 𝒰 k ≫ 𝟙 X = 𝟙 (OpenCover.obj 𝒰 k) ≫ OpenCover.map 𝒰 k) ≫
            (pullbackRightPullbackFstIso (pullback.fst ≫ OpenCover.map 𝒰 j) (OpenCover.map 𝒰 k) (fV 𝒰 f g j i)).inv) ≫
          (pullbackSymmetry (fV 𝒰 f g j i) (fV 𝒰 f g j k)).hom) ≫
      pullback.snd ≫ pullback.snd =
    pullback.fst ≫ pullback.fst ≫ pullback.fst
[PROOFSTEP]
simp only [Category.assoc, pullbackSymmetry_hom_comp_snd_assoc, pullbackRightPullbackFstIso_inv_fst_assoc,
  pullback.lift_fst_assoc, t_snd, pullbackRightPullbackFstIso_hom_fst_assoc]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j ≫ pullback.fst ≫ pullback.fst ≫ pullback.fst =
    pullback.fst ≫ pullback.fst ≫ pullback.fst
[PROOFSTEP]
simp only [t'_fst_fst_fst, t'_fst_snd, t'_snd_snd]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j ≫ pullback.fst ≫ pullback.fst ≫ pullback.snd =
    pullback.fst ≫ pullback.fst ≫ pullback.snd
[PROOFSTEP]
simp only [t'_fst_fst_snd]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j ≫ pullback.fst ≫ pullback.snd = pullback.fst ≫ pullback.snd
[PROOFSTEP]
simp only [t'_fst_snd, t'_snd_snd, t'_fst_fst_fst]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j ≫ pullback.snd ≫ pullback.fst ≫ pullback.fst =
    pullback.snd ≫ pullback.fst ≫ pullback.fst
[PROOFSTEP]
rw [← cancel_mono (𝒰.map i)]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ (t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j ≫ pullback.snd ≫ pullback.fst ≫ pullback.fst) ≫ OpenCover.map 𝒰 i =
    (pullback.snd ≫ pullback.fst ≫ pullback.fst) ≫ OpenCover.map 𝒰 i
[PROOFSTEP]
simp only [pullback.condition_assoc, t'_snd_fst_fst, t'_fst_snd, t'_snd_snd]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j ≫ pullback.snd ≫ pullback.fst ≫ pullback.snd =
    pullback.snd ≫ pullback.fst ≫ pullback.snd
[PROOFSTEP]
simp only [pullback.condition_assoc, t'_snd_fst_snd]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j ≫ pullback.snd ≫ pullback.snd = pullback.snd ≫ pullback.snd
[PROOFSTEP]
simp only [t'_snd_snd, t'_fst_fst_fst, t'_fst_snd]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j = 𝟙 (pullback (fV 𝒰 f g i j) (fV 𝒰 f g i k))
[PROOFSTEP]
apply pullback.hom_ext
[GOAL]
case h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ (t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j) ≫ pullback.fst =
    𝟙 (pullback (fV 𝒰 f g i j) (fV 𝒰 f g i k)) ≫ pullback.fst
[PROOFSTEP]
rw [Category.id_comp]
[GOAL]
case h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ (t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j) ≫ pullback.snd =
    𝟙 (pullback (fV 𝒰 f g i j) (fV 𝒰 f g i k)) ≫ pullback.snd
[PROOFSTEP]
rw [Category.id_comp]
[GOAL]
case h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ (t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j) ≫ pullback.fst = pullback.fst
[PROOFSTEP]
apply pullback.hom_ext
[GOAL]
case h₀.h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ ((t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j) ≫ pullback.fst) ≫ pullback.fst = pullback.fst ≫ pullback.fst
[PROOFSTEP]
apply pullback.hom_ext
[GOAL]
case h₀.h₀.h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ (((t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j) ≫ pullback.fst) ≫ pullback.fst) ≫ pullback.fst =
    (pullback.fst ≫ pullback.fst) ≫ pullback.fst
[PROOFSTEP]
simp_rw [Category.assoc]
[GOAL]
case h₀.h₀.h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j ≫ pullback.fst ≫ pullback.fst ≫ pullback.fst =
    pullback.fst ≫ pullback.fst ≫ pullback.fst
[PROOFSTEP]
exact cocycle_fst_fst_fst 𝒰 f g i j k
[GOAL]
case h₀.h₀.h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ (((t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j) ≫ pullback.fst) ≫ pullback.fst) ≫ pullback.snd =
    (pullback.fst ≫ pullback.fst) ≫ pullback.snd
[PROOFSTEP]
simp_rw [Category.assoc]
[GOAL]
case h₀.h₀.h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j ≫ pullback.fst ≫ pullback.fst ≫ pullback.snd =
    pullback.fst ≫ pullback.fst ≫ pullback.snd
[PROOFSTEP]
exact cocycle_fst_fst_snd 𝒰 f g i j k
[GOAL]
case h₀.h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ ((t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j) ≫ pullback.fst) ≫ pullback.snd = pullback.fst ≫ pullback.snd
[PROOFSTEP]
simp_rw [Category.assoc]
[GOAL]
case h₀.h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j ≫ pullback.fst ≫ pullback.snd = pullback.fst ≫ pullback.snd
[PROOFSTEP]
exact cocycle_fst_snd 𝒰 f g i j k
[GOAL]
case h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ (t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j) ≫ pullback.snd = pullback.snd
[PROOFSTEP]
apply pullback.hom_ext
[GOAL]
case h₁.h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ ((t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j) ≫ pullback.snd) ≫ pullback.fst = pullback.snd ≫ pullback.fst
[PROOFSTEP]
apply pullback.hom_ext
[GOAL]
case h₁.h₀.h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ (((t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j) ≫ pullback.snd) ≫ pullback.fst) ≫ pullback.fst =
    (pullback.snd ≫ pullback.fst) ≫ pullback.fst
[PROOFSTEP]
simp_rw [Category.assoc]
[GOAL]
case h₁.h₀.h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j ≫ pullback.snd ≫ pullback.fst ≫ pullback.fst =
    pullback.snd ≫ pullback.fst ≫ pullback.fst
[PROOFSTEP]
exact cocycle_snd_fst_fst 𝒰 f g i j k
[GOAL]
case h₁.h₀.h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ (((t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j) ≫ pullback.snd) ≫ pullback.fst) ≫ pullback.snd =
    (pullback.snd ≫ pullback.fst) ≫ pullback.snd
[PROOFSTEP]
simp_rw [Category.assoc]
[GOAL]
case h₁.h₀.h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j ≫ pullback.snd ≫ pullback.fst ≫ pullback.snd =
    pullback.snd ≫ pullback.fst ≫ pullback.snd
[PROOFSTEP]
exact cocycle_snd_fst_snd 𝒰 f g i j k
[GOAL]
case h₁.h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ ((t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j) ≫ pullback.snd) ≫ pullback.snd = pullback.snd ≫ pullback.snd
[PROOFSTEP]
simp_rw [Category.assoc]
[GOAL]
case h₁.h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j ≫ pullback.snd ≫ pullback.snd = pullback.snd ≫ pullback.snd
[PROOFSTEP]
exact cocycle_snd_snd 𝒰 f g i j k
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ (fun i j k => t' 𝒰 f g i j k) i j k ≫ pullback.snd = pullback.fst ≫ (fun i j => t 𝒰 f g i j) i j
[PROOFSTEP]
apply pullback.hom_ext
[GOAL]
case h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ ((fun i j k => t' 𝒰 f g i j k) i j k ≫ pullback.snd) ≫ pullback.fst =
    (pullback.fst ≫ (fun i j => t 𝒰 f g i j) i j) ≫ pullback.fst
case h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ ((fun i j k => t' 𝒰 f g i j k) i j k ≫ pullback.snd) ≫ pullback.snd =
    (pullback.fst ≫ (fun i j => t 𝒰 f g i j) i j) ≫ pullback.snd
[PROOFSTEP]
apply pullback.hom_ext
[GOAL]
case h₀.h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ (((fun i j k => t' 𝒰 f g i j k) i j k ≫ pullback.snd) ≫ pullback.fst) ≫ pullback.fst =
    ((pullback.fst ≫ (fun i j => t 𝒰 f g i j) i j) ≫ pullback.fst) ≫ pullback.fst
case h₀.h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ (((fun i j k => t' 𝒰 f g i j k) i j k ≫ pullback.snd) ≫ pullback.fst) ≫ pullback.snd =
    ((pullback.fst ≫ (fun i j => t 𝒰 f g i j) i j) ≫ pullback.fst) ≫ pullback.snd
case h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ ((fun i j k => t' 𝒰 f g i j k) i j k ≫ pullback.snd) ≫ pullback.snd =
    (pullback.fst ≫ (fun i j => t 𝒰 f g i j) i j) ≫ pullback.snd
[PROOFSTEP]
all_goals simp only [t'_snd_fst_fst, t'_snd_fst_snd, t'_snd_snd, t_fst_fst, t_fst_snd, t_snd, Category.assoc]
[GOAL]
case h₀.h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ (((fun i j k => t' 𝒰 f g i j k) i j k ≫ pullback.snd) ≫ pullback.fst) ≫ pullback.fst =
    ((pullback.fst ≫ (fun i j => t 𝒰 f g i j) i j) ≫ pullback.fst) ≫ pullback.fst
[PROOFSTEP]
simp only [t'_snd_fst_fst, t'_snd_fst_snd, t'_snd_snd, t_fst_fst, t_fst_snd, t_snd, Category.assoc]
[GOAL]
case h₀.h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ (((fun i j k => t' 𝒰 f g i j k) i j k ≫ pullback.snd) ≫ pullback.fst) ≫ pullback.snd =
    ((pullback.fst ≫ (fun i j => t 𝒰 f g i j) i j) ≫ pullback.fst) ≫ pullback.snd
[PROOFSTEP]
simp only [t'_snd_fst_fst, t'_snd_fst_snd, t'_snd_snd, t_fst_fst, t_fst_snd, t_snd, Category.assoc]
[GOAL]
case h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j k : 𝒰.J
⊢ ((fun i j k => t' 𝒰 f g i j k) i j k ≫ pullback.snd) ≫ pullback.snd =
    (pullback.fst ≫ (fun i j => t 𝒰 f g i j) i j) ≫ pullback.snd
[PROOFSTEP]
simp only [t'_snd_fst_fst, t'_snd_fst_snd, t'_snd_snd, t_fst_fst, t_fst_snd, t_snd, Category.assoc]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
⊢ GlueData.glued (gluing 𝒰 f g) ⟶ X
[PROOFSTEP]
fapply Multicoequalizer.desc
[GOAL]
case k
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
⊢ (b : (GlueData.diagram (gluing 𝒰 f g).toGlueData).R) →
    MultispanIndex.right (GlueData.diagram (gluing 𝒰 f g).toGlueData) b ⟶ X
case h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
⊢ ∀ (a : (GlueData.diagram (gluing 𝒰 f g).toGlueData).L),
    MultispanIndex.fst (GlueData.diagram (gluing 𝒰 f g).toGlueData) a ≫
        ?k (MultispanIndex.fstFrom (GlueData.diagram (gluing 𝒰 f g).toGlueData) a) =
      MultispanIndex.snd (GlueData.diagram (gluing 𝒰 f g).toGlueData) a ≫
        ?k (MultispanIndex.sndFrom (GlueData.diagram (gluing 𝒰 f g).toGlueData) a)
[PROOFSTEP]
exact fun i => pullback.fst ≫ 𝒰.map i
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
⊢ ∀ (a : (GlueData.diagram (gluing 𝒰 f g).toGlueData).L),
    MultispanIndex.fst (GlueData.diagram (gluing 𝒰 f g).toGlueData) a ≫
        pullback.fst ≫ OpenCover.map 𝒰 (MultispanIndex.fstFrom (GlueData.diagram (gluing 𝒰 f g).toGlueData) a) =
      MultispanIndex.snd (GlueData.diagram (gluing 𝒰 f g).toGlueData) a ≫
        pullback.fst ≫ OpenCover.map 𝒰 (MultispanIndex.sndFrom (GlueData.diagram (gluing 𝒰 f g).toGlueData) a)
[PROOFSTEP]
rintro ⟨i, j⟩
[GOAL]
case h.mk
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j : (gluing 𝒰 f g).toGlueData.J
⊢ MultispanIndex.fst (GlueData.diagram (gluing 𝒰 f g).toGlueData) (i, j) ≫
      pullback.fst ≫ OpenCover.map 𝒰 (MultispanIndex.fstFrom (GlueData.diagram (gluing 𝒰 f g).toGlueData) (i, j)) =
    MultispanIndex.snd (GlueData.diagram (gluing 𝒰 f g).toGlueData) (i, j) ≫
      pullback.fst ≫ OpenCover.map 𝒰 (MultispanIndex.sndFrom (GlueData.diagram (gluing 𝒰 f g).toGlueData) (i, j))
[PROOFSTEP]
change pullback.fst ≫ _ ≫ 𝒰.map i = (_ ≫ _) ≫ _ ≫ 𝒰.map j
[GOAL]
case h.mk
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j : (gluing 𝒰 f g).toGlueData.J
⊢ pullback.fst ≫ pullback.fst ≫ OpenCover.map 𝒰 i =
    (GlueData.t (gluing 𝒰 f g).toGlueData i j ≫ GlueData.f (gluing 𝒰 f g).toGlueData j i) ≫
      pullback.fst ≫ OpenCover.map 𝒰 j
[PROOFSTEP]
erw [pullback.condition]
[GOAL]
case h.mk
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j : (gluing 𝒰 f g).toGlueData.J
⊢ pullback.snd ≫ OpenCover.map 𝒰 j =
    (GlueData.t (gluing 𝒰 f g).toGlueData i j ≫ GlueData.f (gluing 𝒰 f g).toGlueData j i) ≫
      pullback.fst ≫ OpenCover.map 𝒰 j
[PROOFSTEP]
rw [← Category.assoc]
[GOAL]
case h.mk
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j : (gluing 𝒰 f g).toGlueData.J
⊢ pullback.snd ≫ OpenCover.map 𝒰 j =
    ((GlueData.t (gluing 𝒰 f g).toGlueData i j ≫ GlueData.f (gluing 𝒰 f g).toGlueData j i) ≫ pullback.fst) ≫
      OpenCover.map 𝒰 j
[PROOFSTEP]
congr 1
[GOAL]
case h.mk.e_a
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j : (gluing 𝒰 f g).toGlueData.J
⊢ pullback.snd = (GlueData.t (gluing 𝒰 f g).toGlueData i j ≫ GlueData.f (gluing 𝒰 f g).toGlueData j i) ≫ pullback.fst
[PROOFSTEP]
rw [Category.assoc]
[GOAL]
case h.mk.e_a
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j : (gluing 𝒰 f g).toGlueData.J
⊢ pullback.snd = GlueData.t (gluing 𝒰 f g).toGlueData i j ≫ GlueData.f (gluing 𝒰 f g).toGlueData j i ≫ pullback.fst
[PROOFSTEP]
exact (t_fst_fst _ _ _ _ _).symm
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
⊢ GlueData.glued (gluing 𝒰 f g) ⟶ Y
[PROOFSTEP]
fapply Multicoequalizer.desc
[GOAL]
case k
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
⊢ (b : (GlueData.diagram (gluing 𝒰 f g).toGlueData).R) →
    MultispanIndex.right (GlueData.diagram (gluing 𝒰 f g).toGlueData) b ⟶ Y
case h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
⊢ ∀ (a : (GlueData.diagram (gluing 𝒰 f g).toGlueData).L),
    MultispanIndex.fst (GlueData.diagram (gluing 𝒰 f g).toGlueData) a ≫
        ?k (MultispanIndex.fstFrom (GlueData.diagram (gluing 𝒰 f g).toGlueData) a) =
      MultispanIndex.snd (GlueData.diagram (gluing 𝒰 f g).toGlueData) a ≫
        ?k (MultispanIndex.sndFrom (GlueData.diagram (gluing 𝒰 f g).toGlueData) a)
[PROOFSTEP]
exact fun i => pullback.snd
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
⊢ ∀ (a : (GlueData.diagram (gluing 𝒰 f g).toGlueData).L),
    MultispanIndex.fst (GlueData.diagram (gluing 𝒰 f g).toGlueData) a ≫ pullback.snd =
      MultispanIndex.snd (GlueData.diagram (gluing 𝒰 f g).toGlueData) a ≫ pullback.snd
[PROOFSTEP]
rintro ⟨i, j⟩
[GOAL]
case h.mk
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j : (gluing 𝒰 f g).toGlueData.J
⊢ MultispanIndex.fst (GlueData.diagram (gluing 𝒰 f g).toGlueData) (i, j) ≫ pullback.snd =
    MultispanIndex.snd (GlueData.diagram (gluing 𝒰 f g).toGlueData) (i, j) ≫ pullback.snd
[PROOFSTEP]
change pullback.fst ≫ _ = (_ ≫ _) ≫ _
[GOAL]
case h.mk
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j : (gluing 𝒰 f g).toGlueData.J
⊢ pullback.fst ≫ pullback.snd =
    (GlueData.t (gluing 𝒰 f g).toGlueData i j ≫ GlueData.f (gluing 𝒰 f g).toGlueData j i) ≫ pullback.snd
[PROOFSTEP]
rw [Category.assoc]
[GOAL]
case h.mk
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i j : (gluing 𝒰 f g).toGlueData.J
⊢ pullback.fst ≫ pullback.snd =
    GlueData.t (gluing 𝒰 f g).toGlueData i j ≫ GlueData.f (gluing 𝒰 f g).toGlueData j i ≫ pullback.snd
[PROOFSTEP]
exact (t_fst_snd _ _ _ _ _).symm
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
⊢ p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g
[PROOFSTEP]
apply Multicoequalizer.hom_ext
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
⊢ ∀ (b : (GlueData.diagram (gluing 𝒰 f g).toGlueData).R),
    Multicoequalizer.π (GlueData.diagram (gluing 𝒰 f g).toGlueData) b ≫ p1 𝒰 f g ≫ f =
      Multicoequalizer.π (GlueData.diagram (gluing 𝒰 f g).toGlueData) b ≫ p2 𝒰 f g ≫ g
[PROOFSTEP]
intro i
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i : (GlueData.diagram (gluing 𝒰 f g).toGlueData).R
⊢ Multicoequalizer.π (GlueData.diagram (gluing 𝒰 f g).toGlueData) i ≫ p1 𝒰 f g ≫ f =
    Multicoequalizer.π (GlueData.diagram (gluing 𝒰 f g).toGlueData) i ≫ p2 𝒰 f g ≫ g
[PROOFSTEP]
erw [Multicoequalizer.π_desc_assoc, Multicoequalizer.π_desc_assoc]
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
i : (GlueData.diagram (gluing 𝒰 f g).toGlueData).R
⊢ (pullback.fst ≫ OpenCover.map 𝒰 i) ≫ f = pullback.snd ≫ g
[PROOFSTEP]
rw [Category.assoc, pullback.condition]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i j : 𝒰.J
⊢ pullback (OpenCover.map (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) i)
      (OpenCover.map (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) j) ⟶
    GlueData.V (gluing 𝒰 f g).toGlueData (i, j)
[PROOFSTEP]
change pullback pullback.fst pullback.fst ⟶ pullback _ _
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i j : 𝒰.J
⊢ pullback pullback.fst pullback.fst ⟶ pullback (pullback.fst ≫ OpenCover.map 𝒰 i) (OpenCover.map 𝒰 j)
[PROOFSTEP]
refine' (pullbackRightPullbackFstIso _ _ _).hom ≫ _
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i j : 𝒰.J
⊢ pullback (pullback.fst ≫ PullbackCone.fst s) (OpenCover.map 𝒰 j) ⟶
    pullback (pullback.fst ≫ OpenCover.map 𝒰 i) (OpenCover.map 𝒰 j)
[PROOFSTEP]
refine' pullback.map _ _ _ _ _ (𝟙 _) (𝟙 _) _ _
[GOAL]
case refine'_1
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i j : 𝒰.J
⊢ pullback (PullbackCone.fst s) (OpenCover.map 𝒰 i) ⟶ pullback (OpenCover.map 𝒰 i ≫ f) g
[PROOFSTEP]
exact (pullbackSymmetry _ _).hom ≫ pullback.map _ _ _ _ (𝟙 _) s.snd f (Category.id_comp _).symm s.condition
[GOAL]
case refine'_2
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i j : 𝒰.J
⊢ (pullback.fst ≫ PullbackCone.fst s) ≫ 𝟙 X =
    ((pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 i)).hom ≫
        pullback.map (OpenCover.map 𝒰 i) (PullbackCone.fst s) (OpenCover.map 𝒰 i ≫ f) g (𝟙 (OpenCover.obj 𝒰 i))
          (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 i ≫ f = 𝟙 (OpenCover.obj 𝒰 i) ≫ OpenCover.map 𝒰 i ≫ f)
          (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g)) ≫
      pullback.fst ≫ OpenCover.map 𝒰 i
[PROOFSTEP]
simpa using pullback.condition
[GOAL]
case refine'_3
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i j : 𝒰.J
⊢ OpenCover.map 𝒰 j ≫ 𝟙 X = 𝟙 (OpenCover.obj 𝒰 j) ≫ OpenCover.map 𝒰 j
[PROOFSTEP]
simp only [Category.comp_id, Category.id_comp]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i j : 𝒰.J
⊢ gluedLiftPullbackMap 𝒰 f g s i j ≫ pullback.fst =
    pullback.fst ≫
      (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 i)).hom ≫
        pullback.map (OpenCover.map 𝒰 i) (PullbackCone.fst s) (OpenCover.map 𝒰 i ≫ f) g (𝟙 (OpenCover.obj 𝒰 i))
          (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 i ≫ f = 𝟙 (OpenCover.obj 𝒰 i) ≫ OpenCover.map 𝒰 i ≫ f)
          (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g)
[PROOFSTEP]
delta gluedLiftPullbackMap
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i j : 𝒰.J
⊢ (let_fun this :=
        (pullbackRightPullbackFstIso (PullbackCone.fst s) (OpenCover.map 𝒰 j) pullback.fst).hom ≫
          pullback.map (pullback.fst ≫ PullbackCone.fst s) (OpenCover.map 𝒰 j) (pullback.fst ≫ OpenCover.map 𝒰 i)
            (OpenCover.map 𝒰 j)
            ((pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 i)).hom ≫
              pullback.map (OpenCover.map 𝒰 i) (PullbackCone.fst s) (OpenCover.map 𝒰 i ≫ f) g (𝟙 (OpenCover.obj 𝒰 i))
                (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 i ≫ f = 𝟙 (OpenCover.obj 𝒰 i) ≫ OpenCover.map 𝒰 i ≫ f)
                (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g))
            (𝟙 (OpenCover.obj 𝒰 j)) (𝟙 X)
            (_ :
              (pullback.fst ≫ PullbackCone.fst s) ≫ 𝟙 X =
                ((pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 i)).hom ≫
                    pullback.map (OpenCover.map 𝒰 i) (PullbackCone.fst s) (OpenCover.map 𝒰 i ≫ f) g
                      (𝟙 (OpenCover.obj 𝒰 i)) (PullbackCone.snd s) f
                      (_ : OpenCover.map 𝒰 i ≫ f = 𝟙 (OpenCover.obj 𝒰 i) ≫ OpenCover.map 𝒰 i ≫ f)
                      (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g)) ≫
                  pullback.fst ≫ OpenCover.map 𝒰 i)
            (_ : OpenCover.map 𝒰 j ≫ 𝟙 X = 𝟙 (OpenCover.obj 𝒰 j) ≫ OpenCover.map 𝒰 j);
      this) ≫
      pullback.fst =
    pullback.fst ≫
      (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 i)).hom ≫
        pullback.map (OpenCover.map 𝒰 i) (PullbackCone.fst s) (OpenCover.map 𝒰 i ≫ f) g (𝟙 (OpenCover.obj 𝒰 i))
          (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 i ≫ f = 𝟙 (OpenCover.obj 𝒰 i) ≫ OpenCover.map 𝒰 i ≫ f)
          (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g)
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i j : 𝒰.J
⊢ gluedLiftPullbackMap 𝒰 f g s i j ≫ pullback.snd = pullback.snd ≫ pullback.snd
[PROOFSTEP]
delta gluedLiftPullbackMap
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i j : 𝒰.J
⊢ (let_fun this :=
        (pullbackRightPullbackFstIso (PullbackCone.fst s) (OpenCover.map 𝒰 j) pullback.fst).hom ≫
          pullback.map (pullback.fst ≫ PullbackCone.fst s) (OpenCover.map 𝒰 j) (pullback.fst ≫ OpenCover.map 𝒰 i)
            (OpenCover.map 𝒰 j)
            ((pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 i)).hom ≫
              pullback.map (OpenCover.map 𝒰 i) (PullbackCone.fst s) (OpenCover.map 𝒰 i ≫ f) g (𝟙 (OpenCover.obj 𝒰 i))
                (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 i ≫ f = 𝟙 (OpenCover.obj 𝒰 i) ≫ OpenCover.map 𝒰 i ≫ f)
                (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g))
            (𝟙 (OpenCover.obj 𝒰 j)) (𝟙 X)
            (_ :
              (pullback.fst ≫ PullbackCone.fst s) ≫ 𝟙 X =
                ((pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 i)).hom ≫
                    pullback.map (OpenCover.map 𝒰 i) (PullbackCone.fst s) (OpenCover.map 𝒰 i ≫ f) g
                      (𝟙 (OpenCover.obj 𝒰 i)) (PullbackCone.snd s) f
                      (_ : OpenCover.map 𝒰 i ≫ f = 𝟙 (OpenCover.obj 𝒰 i) ≫ OpenCover.map 𝒰 i ≫ f)
                      (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g)) ≫
                  pullback.fst ≫ OpenCover.map 𝒰 i)
            (_ : OpenCover.map 𝒰 j ≫ 𝟙 X = 𝟙 (OpenCover.obj 𝒰 j) ≫ OpenCover.map 𝒰 j);
      this) ≫
      pullback.snd =
    pullback.snd ≫ pullback.snd
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
⊢ s.pt ⟶ GlueData.glued (gluing 𝒰 f g)
[PROOFSTEP]
fapply (𝒰.pullbackCover s.fst).glueMorphisms
[GOAL]
case f
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
⊢ (x : (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)).J) →
    OpenCover.obj (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) x ⟶ GlueData.glued (gluing 𝒰 f g)
[PROOFSTEP]
exact fun i =>
  (pullbackSymmetry _ _).hom ≫
    pullback.map _ _ _ _ (𝟙 _) s.snd f (Category.id_comp _).symm s.condition ≫ (gluing 𝒰 f g).ι i
[GOAL]
case hf
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
⊢ ∀ (x y : (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)).J),
    pullback.fst ≫
        (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 x)).hom ≫
          pullback.map (OpenCover.map 𝒰 x) (PullbackCone.fst s) (OpenCover.map 𝒰 x ≫ f) g (𝟙 (OpenCover.obj 𝒰 x))
              (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 x ≫ f = 𝟙 (OpenCover.obj 𝒰 x) ≫ OpenCover.map 𝒰 x ≫ f)
              (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g) ≫
            GlueData.ι (gluing 𝒰 f g) x =
      pullback.snd ≫
        (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 y)).hom ≫
          pullback.map (OpenCover.map 𝒰 y) (PullbackCone.fst s) (OpenCover.map 𝒰 y ≫ f) g (𝟙 (OpenCover.obj 𝒰 y))
              (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 y ≫ f = 𝟙 (OpenCover.obj 𝒰 y) ≫ OpenCover.map 𝒰 y ≫ f)
              (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g) ≫
            GlueData.ι (gluing 𝒰 f g) y
[PROOFSTEP]
intro i j
[GOAL]
case hf
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i j : (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)).J
⊢ pullback.fst ≫
      (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 i)).hom ≫
        pullback.map (OpenCover.map 𝒰 i) (PullbackCone.fst s) (OpenCover.map 𝒰 i ≫ f) g (𝟙 (OpenCover.obj 𝒰 i))
            (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 i ≫ f = 𝟙 (OpenCover.obj 𝒰 i) ≫ OpenCover.map 𝒰 i ≫ f)
            (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g) ≫
          GlueData.ι (gluing 𝒰 f g) i =
    pullback.snd ≫
      (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 j)).hom ≫
        pullback.map (OpenCover.map 𝒰 j) (PullbackCone.fst s) (OpenCover.map 𝒰 j ≫ f) g (𝟙 (OpenCover.obj 𝒰 j))
            (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 j ≫ f = 𝟙 (OpenCover.obj 𝒰 j) ≫ OpenCover.map 𝒰 j ≫ f)
            (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g) ≫
          GlueData.ι (gluing 𝒰 f g) j
[PROOFSTEP]
rw [← gluedLiftPullbackMap_fst_assoc]
[GOAL]
case hf
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i j : (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)).J
⊢ gluedLiftPullbackMap 𝒰 f g s i j ≫ pullback.fst ≫ GlueData.ι (gluing 𝒰 f g) i =
    pullback.snd ≫
      (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 j)).hom ≫
        pullback.map (OpenCover.map 𝒰 j) (PullbackCone.fst s) (OpenCover.map 𝒰 j ≫ f) g (𝟙 (OpenCover.obj 𝒰 j))
            (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 j ≫ f = 𝟙 (OpenCover.obj 𝒰 j) ≫ OpenCover.map 𝒰 j ≫ f)
            (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g) ≫
          GlueData.ι (gluing 𝒰 f g) j
[PROOFSTEP]
have : _ = pullback.fst ≫ _ := (gluing 𝒰 f g).glue_condition i j
[GOAL]
case hf
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i j : (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)).J
this :
  GlueData.t (gluing 𝒰 f g).toGlueData i j ≫ GlueData.f (gluing 𝒰 f g).toGlueData j i ≫ GlueData.ι (gluing 𝒰 f g) j =
    pullback.fst ≫ GlueData.ι (gluing 𝒰 f g) i
⊢ gluedLiftPullbackMap 𝒰 f g s i j ≫ pullback.fst ≫ GlueData.ι (gluing 𝒰 f g) i =
    pullback.snd ≫
      (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 j)).hom ≫
        pullback.map (OpenCover.map 𝒰 j) (PullbackCone.fst s) (OpenCover.map 𝒰 j ≫ f) g (𝟙 (OpenCover.obj 𝒰 j))
            (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 j ≫ f = 𝟙 (OpenCover.obj 𝒰 j) ≫ OpenCover.map 𝒰 j ≫ f)
            (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g) ≫
          GlueData.ι (gluing 𝒰 f g) j
[PROOFSTEP]
rw [← this, gluing_t, gluing_f]
[GOAL]
case hf
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i j : (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)).J
this :
  GlueData.t (gluing 𝒰 f g).toGlueData i j ≫ GlueData.f (gluing 𝒰 f g).toGlueData j i ≫ GlueData.ι (gluing 𝒰 f g) j =
    pullback.fst ≫ GlueData.ι (gluing 𝒰 f g) i
⊢ gluedLiftPullbackMap 𝒰 f g s i j ≫ t 𝒰 f g i j ≫ pullback.fst ≫ GlueData.ι (gluing 𝒰 f g) j =
    pullback.snd ≫
      (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 j)).hom ≫
        pullback.map (OpenCover.map 𝒰 j) (PullbackCone.fst s) (OpenCover.map 𝒰 j ≫ f) g (𝟙 (OpenCover.obj 𝒰 j))
            (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 j ≫ f = 𝟙 (OpenCover.obj 𝒰 j) ≫ OpenCover.map 𝒰 j ≫ f)
            (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g) ≫
          GlueData.ι (gluing 𝒰 f g) j
[PROOFSTEP]
simp_rw [← Category.assoc]
[GOAL]
case hf
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i j : (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)).J
this :
  GlueData.t (gluing 𝒰 f g).toGlueData i j ≫ GlueData.f (gluing 𝒰 f g).toGlueData j i ≫ GlueData.ι (gluing 𝒰 f g) j =
    pullback.fst ≫ GlueData.ι (gluing 𝒰 f g) i
⊢ ((gluedLiftPullbackMap 𝒰 f g s i j ≫ t 𝒰 f g i j) ≫ pullback.fst) ≫ GlueData.ι (gluing 𝒰 f g) j =
    ((pullback.snd ≫ (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 j)).hom) ≫
        pullback.map (OpenCover.map 𝒰 j) (PullbackCone.fst s) (OpenCover.map 𝒰 j ≫ f) g (𝟙 (OpenCover.obj 𝒰 j))
          (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 j ≫ f = 𝟙 (OpenCover.obj 𝒰 j) ≫ OpenCover.map 𝒰 j ≫ f)
          (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g)) ≫
      GlueData.ι (gluing 𝒰 f g) j
[PROOFSTEP]
congr 1
[GOAL]
case hf.e_a
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i j : (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)).J
this :
  GlueData.t (gluing 𝒰 f g).toGlueData i j ≫ GlueData.f (gluing 𝒰 f g).toGlueData j i ≫ GlueData.ι (gluing 𝒰 f g) j =
    pullback.fst ≫ GlueData.ι (gluing 𝒰 f g) i
⊢ (gluedLiftPullbackMap 𝒰 f g s i j ≫ t 𝒰 f g i j) ≫ pullback.fst =
    (pullback.snd ≫ (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 j)).hom) ≫
      pullback.map (OpenCover.map 𝒰 j) (PullbackCone.fst s) (OpenCover.map 𝒰 j ≫ f) g (𝟙 (OpenCover.obj 𝒰 j))
        (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 j ≫ f = 𝟙 (OpenCover.obj 𝒰 j) ≫ OpenCover.map 𝒰 j ≫ f)
        (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g)
[PROOFSTEP]
apply pullback.hom_ext
[GOAL]
case hf.e_a.h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i j : (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)).J
this :
  GlueData.t (gluing 𝒰 f g).toGlueData i j ≫ GlueData.f (gluing 𝒰 f g).toGlueData j i ≫ GlueData.ι (gluing 𝒰 f g) j =
    pullback.fst ≫ GlueData.ι (gluing 𝒰 f g) i
⊢ ((gluedLiftPullbackMap 𝒰 f g s i j ≫ t 𝒰 f g i j) ≫ pullback.fst) ≫ pullback.fst =
    ((pullback.snd ≫ (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 j)).hom) ≫
        pullback.map (OpenCover.map 𝒰 j) (PullbackCone.fst s) (OpenCover.map 𝒰 j ≫ f) g (𝟙 (OpenCover.obj 𝒰 j))
          (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 j ≫ f = 𝟙 (OpenCover.obj 𝒰 j) ≫ OpenCover.map 𝒰 j ≫ f)
          (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g)) ≫
      pullback.fst
[PROOFSTEP]
simp_rw [Category.assoc]
[GOAL]
case hf.e_a.h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i j : (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)).J
this :
  GlueData.t (gluing 𝒰 f g).toGlueData i j ≫ GlueData.f (gluing 𝒰 f g).toGlueData j i ≫ GlueData.ι (gluing 𝒰 f g) j =
    pullback.fst ≫ GlueData.ι (gluing 𝒰 f g) i
⊢ ((gluedLiftPullbackMap 𝒰 f g s i j ≫ t 𝒰 f g i j) ≫ pullback.fst) ≫ pullback.snd =
    ((pullback.snd ≫ (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 j)).hom) ≫
        pullback.map (OpenCover.map 𝒰 j) (PullbackCone.fst s) (OpenCover.map 𝒰 j ≫ f) g (𝟙 (OpenCover.obj 𝒰 j))
          (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 j ≫ f = 𝟙 (OpenCover.obj 𝒰 j) ≫ OpenCover.map 𝒰 j ≫ f)
          (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g)) ≫
      pullback.snd
[PROOFSTEP]
simp_rw [Category.assoc]
[GOAL]
case hf.e_a.h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i j : (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)).J
this :
  GlueData.t (gluing 𝒰 f g).toGlueData i j ≫ GlueData.f (gluing 𝒰 f g).toGlueData j i ≫ GlueData.ι (gluing 𝒰 f g) j =
    pullback.fst ≫ GlueData.ι (gluing 𝒰 f g) i
⊢ gluedLiftPullbackMap 𝒰 f g s i j ≫ t 𝒰 f g i j ≫ pullback.fst ≫ pullback.fst =
    pullback.snd ≫
      (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 j)).hom ≫
        pullback.map (OpenCover.map 𝒰 j) (PullbackCone.fst s) (OpenCover.map 𝒰 j ≫ f) g (𝟙 (OpenCover.obj 𝒰 j))
            (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 j ≫ f = 𝟙 (OpenCover.obj 𝒰 j) ≫ OpenCover.map 𝒰 j ≫ f)
            (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g) ≫
          pullback.fst
[PROOFSTEP]
rw [t_fst_fst, gluedLiftPullbackMap_snd]
[GOAL]
case hf.e_a.h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i j : (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)).J
this :
  GlueData.t (gluing 𝒰 f g).toGlueData i j ≫ GlueData.f (gluing 𝒰 f g).toGlueData j i ≫ GlueData.ι (gluing 𝒰 f g) j =
    pullback.fst ≫ GlueData.ι (gluing 𝒰 f g) i
⊢ pullback.snd ≫ pullback.snd =
    pullback.snd ≫
      (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 j)).hom ≫
        pullback.map (OpenCover.map 𝒰 j) (PullbackCone.fst s) (OpenCover.map 𝒰 j ≫ f) g (𝟙 (OpenCover.obj 𝒰 j))
            (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 j ≫ f = 𝟙 (OpenCover.obj 𝒰 j) ≫ OpenCover.map 𝒰 j ≫ f)
            (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g) ≫
          pullback.fst
[PROOFSTEP]
congr 1
[GOAL]
case hf.e_a.h₀.e_a
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i j : (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)).J
this :
  GlueData.t (gluing 𝒰 f g).toGlueData i j ≫ GlueData.f (gluing 𝒰 f g).toGlueData j i ≫ GlueData.ι (gluing 𝒰 f g) j =
    pullback.fst ≫ GlueData.ι (gluing 𝒰 f g) i
⊢ pullback.snd =
    (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 j)).hom ≫
      pullback.map (OpenCover.map 𝒰 j) (PullbackCone.fst s) (OpenCover.map 𝒰 j ≫ f) g (𝟙 (OpenCover.obj 𝒰 j))
          (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 j ≫ f = 𝟙 (OpenCover.obj 𝒰 j) ≫ OpenCover.map 𝒰 j ≫ f)
          (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g) ≫
        pullback.fst
[PROOFSTEP]
rw [← Iso.inv_comp_eq, pullbackSymmetry_inv_comp_snd]
[GOAL]
case hf.e_a.h₀.e_a
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i j : (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)).J
this :
  GlueData.t (gluing 𝒰 f g).toGlueData i j ≫ GlueData.f (gluing 𝒰 f g).toGlueData j i ≫ GlueData.ι (gluing 𝒰 f g) j =
    pullback.fst ≫ GlueData.ι (gluing 𝒰 f g) i
⊢ pullback.fst =
    pullback.map (OpenCover.map 𝒰 j) (PullbackCone.fst s) (OpenCover.map 𝒰 j ≫ f) g (𝟙 (OpenCover.obj 𝒰 j))
        (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 j ≫ f = 𝟙 (OpenCover.obj 𝒰 j) ≫ OpenCover.map 𝒰 j ≫ f)
        (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g) ≫
      pullback.fst
[PROOFSTEP]
erw [pullback.lift_fst]
[GOAL]
case hf.e_a.h₀.e_a
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i j : (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)).J
this :
  GlueData.t (gluing 𝒰 f g).toGlueData i j ≫ GlueData.f (gluing 𝒰 f g).toGlueData j i ≫ GlueData.ι (gluing 𝒰 f g) j =
    pullback.fst ≫ GlueData.ι (gluing 𝒰 f g) i
⊢ pullback.fst = pullback.fst ≫ 𝟙 (OpenCover.obj 𝒰 j)
[PROOFSTEP]
rw [Category.comp_id]
[GOAL]
case hf.e_a.h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i j : (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)).J
this :
  GlueData.t (gluing 𝒰 f g).toGlueData i j ≫ GlueData.f (gluing 𝒰 f g).toGlueData j i ≫ GlueData.ι (gluing 𝒰 f g) j =
    pullback.fst ≫ GlueData.ι (gluing 𝒰 f g) i
⊢ gluedLiftPullbackMap 𝒰 f g s i j ≫ t 𝒰 f g i j ≫ pullback.fst ≫ pullback.snd =
    pullback.snd ≫
      (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 j)).hom ≫
        pullback.map (OpenCover.map 𝒰 j) (PullbackCone.fst s) (OpenCover.map 𝒰 j ≫ f) g (𝟙 (OpenCover.obj 𝒰 j))
            (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 j ≫ f = 𝟙 (OpenCover.obj 𝒰 j) ≫ OpenCover.map 𝒰 j ≫ f)
            (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g) ≫
          pullback.snd
[PROOFSTEP]
rw [t_fst_snd, gluedLiftPullbackMap_fst_assoc]
[GOAL]
case hf.e_a.h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i j : (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)).J
this :
  GlueData.t (gluing 𝒰 f g).toGlueData i j ≫ GlueData.f (gluing 𝒰 f g).toGlueData j i ≫ GlueData.ι (gluing 𝒰 f g) j =
    pullback.fst ≫ GlueData.ι (gluing 𝒰 f g) i
⊢ pullback.fst ≫
      (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 i)).hom ≫
        pullback.map (OpenCover.map 𝒰 i) (PullbackCone.fst s) (OpenCover.map 𝒰 i ≫ f) g (𝟙 (OpenCover.obj 𝒰 i))
            (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 i ≫ f = 𝟙 (OpenCover.obj 𝒰 i) ≫ OpenCover.map 𝒰 i ≫ f)
            (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g) ≫
          pullback.snd =
    pullback.snd ≫
      (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 j)).hom ≫
        pullback.map (OpenCover.map 𝒰 j) (PullbackCone.fst s) (OpenCover.map 𝒰 j ≫ f) g (𝟙 (OpenCover.obj 𝒰 j))
            (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 j ≫ f = 𝟙 (OpenCover.obj 𝒰 j) ≫ OpenCover.map 𝒰 j ≫ f)
            (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g) ≫
          pullback.snd
[PROOFSTEP]
erw [pullback.lift_snd, pullback.lift_snd]
[GOAL]
case hf.e_a.h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i j : (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)).J
this :
  GlueData.t (gluing 𝒰 f g).toGlueData i j ≫ GlueData.f (gluing 𝒰 f g).toGlueData j i ≫ GlueData.ι (gluing 𝒰 f g) j =
    pullback.fst ≫ GlueData.ι (gluing 𝒰 f g) i
⊢ pullback.fst ≫ (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 i)).hom ≫ pullback.snd ≫ PullbackCone.snd s =
    pullback.snd ≫ (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 j)).hom ≫ pullback.snd ≫ PullbackCone.snd s
[PROOFSTEP]
rw [pullbackSymmetry_hom_comp_snd_assoc, pullbackSymmetry_hom_comp_snd_assoc]
[GOAL]
case hf.e_a.h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i j : (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)).J
this :
  GlueData.t (gluing 𝒰 f g).toGlueData i j ≫ GlueData.f (gluing 𝒰 f g).toGlueData j i ≫ GlueData.ι (gluing 𝒰 f g) j =
    pullback.fst ≫ GlueData.ι (gluing 𝒰 f g) i
⊢ pullback.fst ≫ pullback.fst ≫ PullbackCone.snd s = pullback.snd ≫ pullback.fst ≫ PullbackCone.snd s
[PROOFSTEP]
exact pullback.condition_assoc _
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
⊢ gluedLift 𝒰 f g s ≫ p1 𝒰 f g = PullbackCone.fst s
[PROOFSTEP]
rw [← cancel_epi (𝒰.pullbackCover s.fst).fromGlued]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
⊢ OpenCover.fromGlued (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) ≫ gluedLift 𝒰 f g s ≫ p1 𝒰 f g =
    OpenCover.fromGlued (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) ≫ PullbackCone.fst s
[PROOFSTEP]
apply Multicoequalizer.hom_ext
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
⊢ ∀ (b : (GlueData.diagram (OpenCover.gluedCover (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s))).toGlueData).R),
    Multicoequalizer.π
          (GlueData.diagram (OpenCover.gluedCover (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s))).toGlueData) b ≫
        OpenCover.fromGlued (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) ≫ gluedLift 𝒰 f g s ≫ p1 𝒰 f g =
      Multicoequalizer.π
          (GlueData.diagram (OpenCover.gluedCover (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s))).toGlueData) b ≫
        OpenCover.fromGlued (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) ≫ PullbackCone.fst s
[PROOFSTEP]
intro b
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
b : (GlueData.diagram (OpenCover.gluedCover (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s))).toGlueData).R
⊢ Multicoequalizer.π
        (GlueData.diagram (OpenCover.gluedCover (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s))).toGlueData) b ≫
      OpenCover.fromGlued (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) ≫ gluedLift 𝒰 f g s ≫ p1 𝒰 f g =
    Multicoequalizer.π
        (GlueData.diagram (OpenCover.gluedCover (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s))).toGlueData) b ≫
      OpenCover.fromGlued (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) ≫ PullbackCone.fst s
[PROOFSTEP]
erw [Multicoequalizer.π_desc_assoc, Multicoequalizer.π_desc_assoc]
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
b : (GlueData.diagram (OpenCover.gluedCover (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s))).toGlueData).R
⊢ OpenCover.map (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) b ≫ gluedLift 𝒰 f g s ≫ p1 𝒰 f g =
    OpenCover.map (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) b ≫ PullbackCone.fst s
[PROOFSTEP]
delta gluedLift
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
b : (GlueData.diagram (OpenCover.gluedCover (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s))).toGlueData).R
⊢ OpenCover.map (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) b ≫
      OpenCover.glueMorphisms (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s))
          (fun i =>
            (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 i)).hom ≫
              pullback.map (OpenCover.map 𝒰 i) (PullbackCone.fst s) (OpenCover.map 𝒰 i ≫ f) g (𝟙 (OpenCover.obj 𝒰 i))
                  (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 i ≫ f = 𝟙 (OpenCover.obj 𝒰 i) ≫ OpenCover.map 𝒰 i ≫ f)
                  (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g) ≫
                GlueData.ι (gluing 𝒰 f g) i)
          (_ :
            ∀ (i j : (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)).J),
              pullback.fst ≫
                  (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 i)).hom ≫
                    pullback.map (OpenCover.map 𝒰 i) (PullbackCone.fst s) (OpenCover.map 𝒰 i ≫ f) g
                        (𝟙 (OpenCover.obj 𝒰 i)) (PullbackCone.snd s) f
                        (_ : OpenCover.map 𝒰 i ≫ f = 𝟙 (OpenCover.obj 𝒰 i) ≫ OpenCover.map 𝒰 i ≫ f)
                        (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g) ≫
                      GlueData.ι (gluing 𝒰 f g) i =
                pullback.snd ≫
                  (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 j)).hom ≫
                    pullback.map (OpenCover.map 𝒰 j) (PullbackCone.fst s) (OpenCover.map 𝒰 j ≫ f) g
                        (𝟙 (OpenCover.obj 𝒰 j)) (PullbackCone.snd s) f
                        (_ : OpenCover.map 𝒰 j ≫ f = 𝟙 (OpenCover.obj 𝒰 j) ≫ OpenCover.map 𝒰 j ≫ f)
                        (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g) ≫
                      GlueData.ι (gluing 𝒰 f g) j) ≫
        p1 𝒰 f g =
    OpenCover.map (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) b ≫ PullbackCone.fst s
[PROOFSTEP]
simp_rw [← Category.assoc]
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
b : (GlueData.diagram (OpenCover.gluedCover (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s))).toGlueData).R
⊢ (OpenCover.map (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) b ≫
        OpenCover.glueMorphisms (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s))
          (fun i =>
            ((pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 i)).hom ≫
                pullback.map (OpenCover.map 𝒰 i) (PullbackCone.fst s) (OpenCover.map 𝒰 i ≫ f) g (𝟙 (OpenCover.obj 𝒰 i))
                  (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 i ≫ f = 𝟙 (OpenCover.obj 𝒰 i) ≫ OpenCover.map 𝒰 i ≫ f)
                  (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g)) ≫
              GlueData.ι (gluing 𝒰 f g) i)
          (_ :
            ∀ (x y : (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)).J),
              pullback.fst ≫
                  (fun i =>
                      ((pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 i)).hom ≫
                          pullback.map (OpenCover.map 𝒰 i) (PullbackCone.fst s) (OpenCover.map 𝒰 i ≫ f) g
                            (𝟙 (OpenCover.obj 𝒰 i)) (PullbackCone.snd s) f
                            (_ : OpenCover.map 𝒰 i ≫ f = 𝟙 (OpenCover.obj 𝒰 i) ≫ OpenCover.map 𝒰 i ≫ f)
                            (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g)) ≫
                        GlueData.ι (gluing 𝒰 f g) i)
                    x =
                pullback.snd ≫
                  (fun i =>
                      ((pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 i)).hom ≫
                          pullback.map (OpenCover.map 𝒰 i) (PullbackCone.fst s) (OpenCover.map 𝒰 i ≫ f) g
                            (𝟙 (OpenCover.obj 𝒰 i)) (PullbackCone.snd s) f
                            (_ : OpenCover.map 𝒰 i ≫ f = 𝟙 (OpenCover.obj 𝒰 i) ≫ OpenCover.map 𝒰 i ≫ f)
                            (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g)) ≫
                        GlueData.ι (gluing 𝒰 f g) i)
                    y)) ≫
      p1 𝒰 f g =
    OpenCover.map (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) b ≫ PullbackCone.fst s
[PROOFSTEP]
rw [(𝒰.pullbackCover s.fst).ι_glueMorphisms]
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
b : (GlueData.diagram (OpenCover.gluedCover (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s))).toGlueData).R
⊢ (((pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 b)).hom ≫
          pullback.map (OpenCover.map 𝒰 b) (PullbackCone.fst s) (OpenCover.map 𝒰 b ≫ f) g (𝟙 (OpenCover.obj 𝒰 b))
            (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 b ≫ f = 𝟙 (OpenCover.obj 𝒰 b) ≫ OpenCover.map 𝒰 b ≫ f)
            (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g)) ≫
        GlueData.ι (gluing 𝒰 f g) b) ≫
      p1 𝒰 f g =
    OpenCover.map (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) b ≫ PullbackCone.fst s
[PROOFSTEP]
simp_rw [Category.assoc]
  -- Porting note : `Category.comp_id` is no longer necessary, don't know where `𝟙 _` has gone
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
b : (GlueData.diagram (OpenCover.gluedCover (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s))).toGlueData).R
⊢ (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 b)).hom ≫
      pullback.map (OpenCover.map 𝒰 b) (PullbackCone.fst s) (OpenCover.map 𝒰 b ≫ f) g (𝟙 (OpenCover.obj 𝒰 b))
          (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 b ≫ f = 𝟙 (OpenCover.obj 𝒰 b) ≫ OpenCover.map 𝒰 b ≫ f)
          (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g) ≫
        GlueData.ι (gluing 𝒰 f g) b ≫ p1 𝒰 f g =
    OpenCover.map (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) b ≫ PullbackCone.fst s
[PROOFSTEP]
erw [Multicoequalizer.π_desc, pullback.lift_fst_assoc, pullback.condition]
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
b : (GlueData.diagram (OpenCover.gluedCover (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s))).toGlueData).R
⊢ (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 b)).hom ≫ pullback.snd ≫ PullbackCone.fst s =
    OpenCover.map (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) b ≫ PullbackCone.fst s
[PROOFSTEP]
rw [pullbackSymmetry_hom_comp_snd_assoc]
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
b : (GlueData.diagram (OpenCover.gluedCover (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s))).toGlueData).R
⊢ pullback.fst ≫ PullbackCone.fst s =
    OpenCover.map (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) b ≫ PullbackCone.fst s
[PROOFSTEP]
rfl
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
⊢ gluedLift 𝒰 f g s ≫ p2 𝒰 f g = PullbackCone.snd s
[PROOFSTEP]
rw [← cancel_epi (𝒰.pullbackCover s.fst).fromGlued]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
⊢ OpenCover.fromGlued (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) ≫ gluedLift 𝒰 f g s ≫ p2 𝒰 f g =
    OpenCover.fromGlued (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) ≫ PullbackCone.snd s
[PROOFSTEP]
apply Multicoequalizer.hom_ext
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
⊢ ∀ (b : (GlueData.diagram (OpenCover.gluedCover (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s))).toGlueData).R),
    Multicoequalizer.π
          (GlueData.diagram (OpenCover.gluedCover (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s))).toGlueData) b ≫
        OpenCover.fromGlued (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) ≫ gluedLift 𝒰 f g s ≫ p2 𝒰 f g =
      Multicoequalizer.π
          (GlueData.diagram (OpenCover.gluedCover (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s))).toGlueData) b ≫
        OpenCover.fromGlued (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) ≫ PullbackCone.snd s
[PROOFSTEP]
intro b
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
b : (GlueData.diagram (OpenCover.gluedCover (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s))).toGlueData).R
⊢ Multicoequalizer.π
        (GlueData.diagram (OpenCover.gluedCover (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s))).toGlueData) b ≫
      OpenCover.fromGlued (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) ≫ gluedLift 𝒰 f g s ≫ p2 𝒰 f g =
    Multicoequalizer.π
        (GlueData.diagram (OpenCover.gluedCover (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s))).toGlueData) b ≫
      OpenCover.fromGlued (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) ≫ PullbackCone.snd s
[PROOFSTEP]
erw [Multicoequalizer.π_desc_assoc, Multicoequalizer.π_desc_assoc]
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
b : (GlueData.diagram (OpenCover.gluedCover (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s))).toGlueData).R
⊢ OpenCover.map (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) b ≫ gluedLift 𝒰 f g s ≫ p2 𝒰 f g =
    OpenCover.map (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) b ≫ PullbackCone.snd s
[PROOFSTEP]
delta gluedLift
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
b : (GlueData.diagram (OpenCover.gluedCover (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s))).toGlueData).R
⊢ OpenCover.map (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) b ≫
      OpenCover.glueMorphisms (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s))
          (fun i =>
            (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 i)).hom ≫
              pullback.map (OpenCover.map 𝒰 i) (PullbackCone.fst s) (OpenCover.map 𝒰 i ≫ f) g (𝟙 (OpenCover.obj 𝒰 i))
                  (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 i ≫ f = 𝟙 (OpenCover.obj 𝒰 i) ≫ OpenCover.map 𝒰 i ≫ f)
                  (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g) ≫
                GlueData.ι (gluing 𝒰 f g) i)
          (_ :
            ∀ (i j : (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)).J),
              pullback.fst ≫
                  (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 i)).hom ≫
                    pullback.map (OpenCover.map 𝒰 i) (PullbackCone.fst s) (OpenCover.map 𝒰 i ≫ f) g
                        (𝟙 (OpenCover.obj 𝒰 i)) (PullbackCone.snd s) f
                        (_ : OpenCover.map 𝒰 i ≫ f = 𝟙 (OpenCover.obj 𝒰 i) ≫ OpenCover.map 𝒰 i ≫ f)
                        (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g) ≫
                      GlueData.ι (gluing 𝒰 f g) i =
                pullback.snd ≫
                  (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 j)).hom ≫
                    pullback.map (OpenCover.map 𝒰 j) (PullbackCone.fst s) (OpenCover.map 𝒰 j ≫ f) g
                        (𝟙 (OpenCover.obj 𝒰 j)) (PullbackCone.snd s) f
                        (_ : OpenCover.map 𝒰 j ≫ f = 𝟙 (OpenCover.obj 𝒰 j) ≫ OpenCover.map 𝒰 j ≫ f)
                        (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g) ≫
                      GlueData.ι (gluing 𝒰 f g) j) ≫
        p2 𝒰 f g =
    OpenCover.map (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) b ≫ PullbackCone.snd s
[PROOFSTEP]
simp_rw [← Category.assoc]
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
b : (GlueData.diagram (OpenCover.gluedCover (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s))).toGlueData).R
⊢ (OpenCover.map (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) b ≫
        OpenCover.glueMorphisms (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s))
          (fun i =>
            ((pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 i)).hom ≫
                pullback.map (OpenCover.map 𝒰 i) (PullbackCone.fst s) (OpenCover.map 𝒰 i ≫ f) g (𝟙 (OpenCover.obj 𝒰 i))
                  (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 i ≫ f = 𝟙 (OpenCover.obj 𝒰 i) ≫ OpenCover.map 𝒰 i ≫ f)
                  (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g)) ≫
              GlueData.ι (gluing 𝒰 f g) i)
          (_ :
            ∀ (x y : (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)).J),
              pullback.fst ≫
                  (fun i =>
                      ((pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 i)).hom ≫
                          pullback.map (OpenCover.map 𝒰 i) (PullbackCone.fst s) (OpenCover.map 𝒰 i ≫ f) g
                            (𝟙 (OpenCover.obj 𝒰 i)) (PullbackCone.snd s) f
                            (_ : OpenCover.map 𝒰 i ≫ f = 𝟙 (OpenCover.obj 𝒰 i) ≫ OpenCover.map 𝒰 i ≫ f)
                            (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g)) ≫
                        GlueData.ι (gluing 𝒰 f g) i)
                    x =
                pullback.snd ≫
                  (fun i =>
                      ((pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 i)).hom ≫
                          pullback.map (OpenCover.map 𝒰 i) (PullbackCone.fst s) (OpenCover.map 𝒰 i ≫ f) g
                            (𝟙 (OpenCover.obj 𝒰 i)) (PullbackCone.snd s) f
                            (_ : OpenCover.map 𝒰 i ≫ f = 𝟙 (OpenCover.obj 𝒰 i) ≫ OpenCover.map 𝒰 i ≫ f)
                            (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g)) ≫
                        GlueData.ι (gluing 𝒰 f g) i)
                    y)) ≫
      p2 𝒰 f g =
    OpenCover.map (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) b ≫ PullbackCone.snd s
[PROOFSTEP]
rw [(𝒰.pullbackCover s.fst).ι_glueMorphisms]
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
b : (GlueData.diagram (OpenCover.gluedCover (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s))).toGlueData).R
⊢ (((pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 b)).hom ≫
          pullback.map (OpenCover.map 𝒰 b) (PullbackCone.fst s) (OpenCover.map 𝒰 b ≫ f) g (𝟙 (OpenCover.obj 𝒰 b))
            (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 b ≫ f = 𝟙 (OpenCover.obj 𝒰 b) ≫ OpenCover.map 𝒰 b ≫ f)
            (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g)) ≫
        GlueData.ι (gluing 𝒰 f g) b) ≫
      p2 𝒰 f g =
    OpenCover.map (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) b ≫ PullbackCone.snd s
[PROOFSTEP]
simp_rw [Category.assoc]
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
b : (GlueData.diagram (OpenCover.gluedCover (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s))).toGlueData).R
⊢ (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 b)).hom ≫
      pullback.map (OpenCover.map 𝒰 b) (PullbackCone.fst s) (OpenCover.map 𝒰 b ≫ f) g (𝟙 (OpenCover.obj 𝒰 b))
          (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 b ≫ f = 𝟙 (OpenCover.obj 𝒰 b) ≫ OpenCover.map 𝒰 b ≫ f)
          (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g) ≫
        GlueData.ι (gluing 𝒰 f g) b ≫ p2 𝒰 f g =
    OpenCover.map (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) b ≫ PullbackCone.snd s
[PROOFSTEP]
erw [Multicoequalizer.π_desc, pullback.lift_snd]
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
b : (GlueData.diagram (OpenCover.gluedCover (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s))).toGlueData).R
⊢ (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 b)).hom ≫ pullback.snd ≫ PullbackCone.snd s =
    OpenCover.map (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) b ≫ PullbackCone.snd s
[PROOFSTEP]
rw [pullbackSymmetry_hom_comp_snd_assoc]
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
b : (GlueData.diagram (OpenCover.gluedCover (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s))).toGlueData).R
⊢ pullback.fst ≫ PullbackCone.snd s =
    OpenCover.map (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) b ≫ PullbackCone.snd s
[PROOFSTEP]
rfl
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i j : 𝒰.J
⊢ pullbackFstιToV 𝒰 f g i j ≫ pullback.fst = pullback.snd
[PROOFSTEP]
delta pullbackFstιToV
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i j : 𝒰.J
⊢ ((pullbackSymmetry pullback.fst (GlueData.ι (gluing 𝒰 f g) j) ≪≫
            pullbackRightPullbackFstIso (p1 𝒰 f g) (OpenCover.map 𝒰 i) (GlueData.ι (gluing 𝒰 f g) j)).hom ≫
        (pullback.congrHom
            (_ :
              Multicoequalizer.π (GlueData.diagram (gluing 𝒰 f g).toGlueData) j ≫
                  Multicoequalizer.desc (GlueData.diagram (gluing 𝒰 f g).toGlueData) X
                    (fun i => pullback.fst ≫ OpenCover.map 𝒰 i)
                    (_ :
                      ∀ (a : (GlueData.diagram (gluing 𝒰 f g).toGlueData).L),
                        MultispanIndex.fst (GlueData.diagram (gluing 𝒰 f g).toGlueData) a ≫
                            pullback.fst ≫
                              OpenCover.map 𝒰 (MultispanIndex.fstFrom (GlueData.diagram (gluing 𝒰 f g).toGlueData) a) =
                          MultispanIndex.snd (GlueData.diagram (gluing 𝒰 f g).toGlueData) a ≫
                            pullback.fst ≫
                              OpenCover.map 𝒰 (MultispanIndex.sndFrom (GlueData.diagram (gluing 𝒰 f g).toGlueData) a)) =
                pullback.fst ≫ OpenCover.map 𝒰 j)
            (_ : OpenCover.map 𝒰 i = OpenCover.map 𝒰 i)).hom) ≫
      pullback.fst =
    pullback.snd
[PROOFSTEP]
simp only [Iso.trans_hom, pullback.congrHom_hom, Category.assoc, pullback.lift_fst, Category.comp_id]
  -- Porting note : `pullbackRightPullbackFstIso_hom_fst` is not used in `simp` even though
    -- instructed, forcing `pullbackSymmetry_hom_comp_fst` to be manually `rw`ed as well.
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i j : 𝒰.J
⊢ (pullbackSymmetry pullback.fst (GlueData.ι (gluing 𝒰 f g) j)).hom ≫
      (pullbackRightPullbackFstIso (p1 𝒰 f g) (OpenCover.map 𝒰 i) (GlueData.ι (gluing 𝒰 f g) j)).hom ≫ pullback.fst =
    pullback.snd
[PROOFSTEP]
erw [pullbackRightPullbackFstIso_hom_fst]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i j : 𝒰.J
⊢ (pullbackSymmetry pullback.fst (GlueData.ι (gluing 𝒰 f g) j)).hom ≫ pullback.fst = pullback.snd
[PROOFSTEP]
rw [pullbackSymmetry_hom_comp_fst]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i j : 𝒰.J
⊢ pullbackFstιToV 𝒰 f g i j ≫ pullback.snd = pullback.fst ≫ pullback.snd
[PROOFSTEP]
delta pullbackFstιToV
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i j : 𝒰.J
⊢ ((pullbackSymmetry pullback.fst (GlueData.ι (gluing 𝒰 f g) j) ≪≫
            pullbackRightPullbackFstIso (p1 𝒰 f g) (OpenCover.map 𝒰 i) (GlueData.ι (gluing 𝒰 f g) j)).hom ≫
        (pullback.congrHom
            (_ :
              Multicoequalizer.π (GlueData.diagram (gluing 𝒰 f g).toGlueData) j ≫
                  Multicoequalizer.desc (GlueData.diagram (gluing 𝒰 f g).toGlueData) X
                    (fun i => pullback.fst ≫ OpenCover.map 𝒰 i)
                    (_ :
                      ∀ (a : (GlueData.diagram (gluing 𝒰 f g).toGlueData).L),
                        MultispanIndex.fst (GlueData.diagram (gluing 𝒰 f g).toGlueData) a ≫
                            pullback.fst ≫
                              OpenCover.map 𝒰 (MultispanIndex.fstFrom (GlueData.diagram (gluing 𝒰 f g).toGlueData) a) =
                          MultispanIndex.snd (GlueData.diagram (gluing 𝒰 f g).toGlueData) a ≫
                            pullback.fst ≫
                              OpenCover.map 𝒰 (MultispanIndex.sndFrom (GlueData.diagram (gluing 𝒰 f g).toGlueData) a)) =
                pullback.fst ≫ OpenCover.map 𝒰 j)
            (_ : OpenCover.map 𝒰 i = OpenCover.map 𝒰 i)).hom) ≫
      pullback.snd =
    pullback.fst ≫ pullback.snd
[PROOFSTEP]
simp only [Iso.trans_hom, pullback.congrHom_hom, Category.assoc, pullback.lift_snd, Category.comp_id]
  -- Porting note : `pullbackRightPullbackFstIso_hom_snd` is not used in `simp` even though
    -- instructed, forcing `pullbackSymmetry_hom_comp_snd_assoc` to be manually `rw`ed as well.
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i j : 𝒰.J
⊢ (pullbackSymmetry pullback.fst (GlueData.ι (gluing 𝒰 f g) j)).hom ≫
      (pullbackRightPullbackFstIso (p1 𝒰 f g) (OpenCover.map 𝒰 i) (GlueData.ι (gluing 𝒰 f g) j)).hom ≫ pullback.snd =
    pullback.fst ≫ pullback.snd
[PROOFSTEP]
erw [pullbackRightPullbackFstIso_hom_snd]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i j : 𝒰.J
⊢ (pullbackSymmetry pullback.fst (GlueData.ι (gluing 𝒰 f g) j)).hom ≫ pullback.snd ≫ pullback.snd =
    pullback.fst ≫ pullback.snd
[PROOFSTEP]
rw [pullbackSymmetry_hom_comp_snd_assoc]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
⊢ pullback.snd ≫ OpenCover.map 𝒰 i ≫ f = (pullback.fst ≫ p2 𝒰 f g) ≫ g
[PROOFSTEP]
rw [← pullback.condition_assoc, Category.assoc, p_comm]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
⊢ pullback.lift pullback.snd (pullback.fst ≫ p2 𝒰 f g)
        (_ : pullback.snd ≫ OpenCover.map 𝒰 i ≫ f = (pullback.fst ≫ p2 𝒰 f g) ≫ g) ≫
      GlueData.ι (gluing 𝒰 f g) i =
    pullback.fst
[PROOFSTEP]
apply ((gluing 𝒰 f g).openCover.pullbackCover pullback.fst).hom_ext
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
⊢ ∀ (x : (OpenCover.pullbackCover (GlueData.openCover (gluing 𝒰 f g)) pullback.fst).J),
    OpenCover.map (OpenCover.pullbackCover (GlueData.openCover (gluing 𝒰 f g)) pullback.fst) x ≫
        pullback.lift pullback.snd (pullback.fst ≫ p2 𝒰 f g)
            (_ : pullback.snd ≫ OpenCover.map 𝒰 i ≫ f = (pullback.fst ≫ p2 𝒰 f g) ≫ g) ≫
          GlueData.ι (gluing 𝒰 f g) i =
      OpenCover.map (OpenCover.pullbackCover (GlueData.openCover (gluing 𝒰 f g)) pullback.fst) x ≫ pullback.fst
[PROOFSTEP]
intro j
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
j : (OpenCover.pullbackCover (GlueData.openCover (gluing 𝒰 f g)) pullback.fst).J
⊢ OpenCover.map (OpenCover.pullbackCover (GlueData.openCover (gluing 𝒰 f g)) pullback.fst) j ≫
      pullback.lift pullback.snd (pullback.fst ≫ p2 𝒰 f g)
          (_ : pullback.snd ≫ OpenCover.map 𝒰 i ≫ f = (pullback.fst ≫ p2 𝒰 f g) ≫ g) ≫
        GlueData.ι (gluing 𝒰 f g) i =
    OpenCover.map (OpenCover.pullbackCover (GlueData.openCover (gluing 𝒰 f g)) pullback.fst) j ≫ pullback.fst
[PROOFSTEP]
dsimp only [OpenCover.pullbackCover]
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
j : (OpenCover.pullbackCover (GlueData.openCover (gluing 𝒰 f g)) pullback.fst).J
⊢ pullback.fst ≫
      pullback.lift pullback.snd (pullback.fst ≫ p2 𝒰 f g)
          (_ : pullback.snd ≫ OpenCover.map 𝒰 i ≫ f = (pullback.fst ≫ p2 𝒰 f g) ≫ g) ≫
        GlueData.ι (gluing 𝒰 f g) i =
    pullback.fst ≫ pullback.fst
[PROOFSTEP]
trans pullbackFstιToV 𝒰 f g i j ≫ fV 𝒰 f g j i ≫ (gluing 𝒰 f g).ι _
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
j : (OpenCover.pullbackCover (GlueData.openCover (gluing 𝒰 f g)) pullback.fst).J
⊢ pullback.fst ≫
      pullback.lift pullback.snd (pullback.fst ≫ p2 𝒰 f g)
          (_ : pullback.snd ≫ OpenCover.map 𝒰 i ≫ f = (pullback.fst ≫ p2 𝒰 f g) ≫ g) ≫
        GlueData.ι (gluing 𝒰 f g) i =
    pullbackFstιToV 𝒰 f g i j ≫ fV 𝒰 f g j i ≫ GlueData.ι (gluing 𝒰 f g) j
[PROOFSTEP]
rw [← show _ = fV 𝒰 f g j i ≫ _ from (gluing 𝒰 f g).glue_condition j i]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
j : (OpenCover.pullbackCover (GlueData.openCover (gluing 𝒰 f g)) pullback.fst).J
⊢ pullback.fst ≫
      pullback.lift pullback.snd (pullback.fst ≫ p2 𝒰 f g)
          (_ : pullback.snd ≫ OpenCover.map 𝒰 i ≫ f = (pullback.fst ≫ p2 𝒰 f g) ≫ g) ≫
        GlueData.ι (gluing 𝒰 f g) i =
    pullbackFstιToV 𝒰 f g i j ≫
      GlueData.t (gluing 𝒰 f g).toGlueData j i ≫ GlueData.f (gluing 𝒰 f g).toGlueData i j ≫ GlueData.ι (gluing 𝒰 f g) i
[PROOFSTEP]
simp_rw [← Category.assoc]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
j : (OpenCover.pullbackCover (GlueData.openCover (gluing 𝒰 f g)) pullback.fst).J
⊢ (pullback.fst ≫
        pullback.lift pullback.snd (pullback.fst ≫ p2 𝒰 f g)
          (_ : pullback.snd ≫ OpenCover.map 𝒰 i ≫ f = (pullback.fst ≫ p2 𝒰 f g) ≫ g)) ≫
      GlueData.ι (gluing 𝒰 f g) i =
    ((pullbackFstιToV 𝒰 f g i j ≫ GlueData.t (gluing 𝒰 f g).toGlueData j i) ≫
        GlueData.f (gluing 𝒰 f g).toGlueData i j) ≫
      GlueData.ι (gluing 𝒰 f g) i
[PROOFSTEP]
congr 1
[GOAL]
case e_a
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
j : (OpenCover.pullbackCover (GlueData.openCover (gluing 𝒰 f g)) pullback.fst).J
⊢ pullback.fst ≫
      pullback.lift pullback.snd (pullback.fst ≫ p2 𝒰 f g)
        (_ : pullback.snd ≫ OpenCover.map 𝒰 i ≫ f = (pullback.fst ≫ p2 𝒰 f g) ≫ g) =
    (pullbackFstιToV 𝒰 f g i j ≫ GlueData.t (gluing 𝒰 f g).toGlueData j i) ≫ GlueData.f (gluing 𝒰 f g).toGlueData i j
[PROOFSTEP]
rw [gluing_f, gluing_t]
[GOAL]
case e_a
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
j : (OpenCover.pullbackCover (GlueData.openCover (gluing 𝒰 f g)) pullback.fst).J
⊢ pullback.fst ≫
      pullback.lift pullback.snd (pullback.fst ≫ p2 𝒰 f g)
        (_ : pullback.snd ≫ OpenCover.map 𝒰 i ≫ f = (pullback.fst ≫ p2 𝒰 f g) ≫ g) =
    (pullbackFstιToV 𝒰 f g i j ≫ t 𝒰 f g j i) ≫ pullback.fst
[PROOFSTEP]
apply pullback.hom_ext
[GOAL]
case e_a.h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
j : (OpenCover.pullbackCover (GlueData.openCover (gluing 𝒰 f g)) pullback.fst).J
⊢ (pullback.fst ≫
        pullback.lift pullback.snd (pullback.fst ≫ p2 𝒰 f g)
          (_ : pullback.snd ≫ OpenCover.map 𝒰 i ≫ f = (pullback.fst ≫ p2 𝒰 f g) ≫ g)) ≫
      pullback.fst =
    ((pullbackFstιToV 𝒰 f g i j ≫ t 𝒰 f g j i) ≫ pullback.fst) ≫ pullback.fst
[PROOFSTEP]
simp_rw [Category.assoc]
  -- Porting note : in the following two bullet points, `rfl` was not necessary
[GOAL]
case e_a.h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
j : (OpenCover.pullbackCover (GlueData.openCover (gluing 𝒰 f g)) pullback.fst).J
⊢ (pullback.fst ≫
        pullback.lift pullback.snd (pullback.fst ≫ p2 𝒰 f g)
          (_ : pullback.snd ≫ OpenCover.map 𝒰 i ≫ f = (pullback.fst ≫ p2 𝒰 f g) ≫ g)) ≫
      pullback.snd =
    ((pullbackFstιToV 𝒰 f g i j ≫ t 𝒰 f g j i) ≫ pullback.fst) ≫ pullback.snd
[PROOFSTEP]
simp_rw [Category.assoc]
  -- Porting note : in the following two bullet points, `rfl` was not necessary
[GOAL]
case e_a.h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
j : (OpenCover.pullbackCover (GlueData.openCover (gluing 𝒰 f g)) pullback.fst).J
⊢ pullback.fst ≫
      pullback.lift pullback.snd (pullback.fst ≫ p2 𝒰 f g)
          (_ : pullback.snd ≫ OpenCover.map 𝒰 i ≫ f = (pullback.fst ≫ p2 𝒰 f g) ≫ g) ≫
        pullback.fst =
    pullbackFstιToV 𝒰 f g i j ≫ t 𝒰 f g j i ≫ pullback.fst ≫ pullback.fst
[PROOFSTEP]
rw [t_fst_fst, pullback.lift_fst, pullbackFstιToV_snd]
[GOAL]
case e_a.h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
j : (OpenCover.pullbackCover (GlueData.openCover (gluing 𝒰 f g)) pullback.fst).J
⊢ pullback.fst ≫ pullback.snd = pullback.fst ≫ pullback.snd
[PROOFSTEP]
rfl
[GOAL]
case e_a.h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
j : (OpenCover.pullbackCover (GlueData.openCover (gluing 𝒰 f g)) pullback.fst).J
⊢ pullback.fst ≫
      pullback.lift pullback.snd (pullback.fst ≫ p2 𝒰 f g)
          (_ : pullback.snd ≫ OpenCover.map 𝒰 i ≫ f = (pullback.fst ≫ p2 𝒰 f g) ≫ g) ≫
        pullback.snd =
    pullbackFstιToV 𝒰 f g i j ≫ t 𝒰 f g j i ≫ pullback.fst ≫ pullback.snd
[PROOFSTEP]
rw [t_fst_snd, pullback.lift_snd, pullbackFstιToV_fst_assoc, pullback.condition_assoc]
[GOAL]
case e_a.h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
j : (OpenCover.pullbackCover (GlueData.openCover (gluing 𝒰 f g)) pullback.fst).J
⊢ pullback.snd ≫ OpenCover.map (GlueData.openCover (gluing 𝒰 f g)) j ≫ p2 𝒰 f g = pullback.snd ≫ pullback.snd
[PROOFSTEP]
erw [Multicoequalizer.π_desc]
[GOAL]
case e_a.h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
j : (OpenCover.pullbackCover (GlueData.openCover (gluing 𝒰 f g)) pullback.fst).J
⊢ pullback.snd ≫ pullback.snd = pullback.snd ≫ pullback.snd
[PROOFSTEP]
rfl
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
j : (OpenCover.pullbackCover (GlueData.openCover (gluing 𝒰 f g)) pullback.fst).J
⊢ pullbackFstιToV 𝒰 f g i j ≫ fV 𝒰 f g j i ≫ GlueData.ι (gluing 𝒰 f g) j = pullback.fst ≫ pullback.fst
[PROOFSTEP]
rw [pullback.condition, ← Category.assoc]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
j : (OpenCover.pullbackCover (GlueData.openCover (gluing 𝒰 f g)) pullback.fst).J
⊢ (pullbackFstιToV 𝒰 f g i j ≫ fV 𝒰 f g j i) ≫ GlueData.ι (gluing 𝒰 f g) j =
    pullback.snd ≫ OpenCover.map (GlueData.openCover (gluing 𝒰 f g)) j
[PROOFSTEP]
congr 1
[GOAL]
case e_a
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
j : (OpenCover.pullbackCover (GlueData.openCover (gluing 𝒰 f g)) pullback.fst).J
⊢ pullbackFstιToV 𝒰 f g i j ≫ fV 𝒰 f g j i = pullback.snd
[PROOFSTEP]
apply pullback.hom_ext
[GOAL]
case e_a.h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
j : (OpenCover.pullbackCover (GlueData.openCover (gluing 𝒰 f g)) pullback.fst).J
⊢ (pullbackFstιToV 𝒰 f g i j ≫ fV 𝒰 f g j i) ≫ pullback.fst = pullback.snd ≫ pullback.fst
[PROOFSTEP]
simp only [pullbackFstιToV_fst]
[GOAL]
case e_a.h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
j : (OpenCover.pullbackCover (GlueData.openCover (gluing 𝒰 f g)) pullback.fst).J
⊢ pullback.snd ≫ pullback.fst = pullback.snd ≫ pullback.fst
[PROOFSTEP]
rfl
[GOAL]
case e_a.h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
j : (OpenCover.pullbackCover (GlueData.openCover (gluing 𝒰 f g)) pullback.fst).J
⊢ (pullbackFstιToV 𝒰 f g i j ≫ fV 𝒰 f g j i) ≫ pullback.snd = pullback.snd ≫ pullback.snd
[PROOFSTEP]
simp only [pullbackFstιToV_fst]
[GOAL]
case e_a.h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
j : (OpenCover.pullbackCover (GlueData.openCover (gluing 𝒰 f g)) pullback.fst).J
⊢ pullback.snd ≫ pullback.snd = pullback.snd ≫ pullback.snd
[PROOFSTEP]
rfl
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
⊢ pullback (p1 𝒰 f g) (OpenCover.map 𝒰 i) ≅ pullback (OpenCover.map 𝒰 i ≫ f) g
[PROOFSTEP]
fconstructor
[GOAL]
case hom
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
⊢ pullback (p1 𝒰 f g) (OpenCover.map 𝒰 i) ⟶ pullback (OpenCover.map 𝒰 i ≫ f) g
case inv
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
⊢ pullback (OpenCover.map 𝒰 i ≫ f) g ⟶ pullback (p1 𝒰 f g) (OpenCover.map 𝒰 i)
case hom_inv_id
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
⊢ autoParam (?hom ≫ ?inv = 𝟙 (pullback (p1 𝒰 f g) (OpenCover.map 𝒰 i))) _auto✝
case inv_hom_id
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
⊢ autoParam (?inv ≫ ?hom = 𝟙 (pullback (OpenCover.map 𝒰 i ≫ f) g)) _auto✝
[PROOFSTEP]
exact pullback.lift pullback.snd (pullback.fst ≫ p2 𝒰 f g) (by rw [← pullback.condition_assoc, Category.assoc, p_comm])
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
⊢ pullback.snd ≫ OpenCover.map 𝒰 i ≫ f = (pullback.fst ≫ p2 𝒰 f g) ≫ g
[PROOFSTEP]
rw [← pullback.condition_assoc, Category.assoc, p_comm]
[GOAL]
case inv
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
⊢ pullback (OpenCover.map 𝒰 i ≫ f) g ⟶ pullback (p1 𝒰 f g) (OpenCover.map 𝒰 i)
case hom_inv_id
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
⊢ autoParam
    (pullback.lift pullback.snd (pullback.fst ≫ p2 𝒰 f g)
          (_ : pullback.snd ≫ OpenCover.map 𝒰 i ≫ f = (pullback.fst ≫ p2 𝒰 f g) ≫ g) ≫
        ?inv =
      𝟙 (pullback (p1 𝒰 f g) (OpenCover.map 𝒰 i)))
    _auto✝
case inv_hom_id
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
⊢ autoParam
    (?inv ≫
        pullback.lift pullback.snd (pullback.fst ≫ p2 𝒰 f g)
          (_ : pullback.snd ≫ OpenCover.map 𝒰 i ≫ f = (pullback.fst ≫ p2 𝒰 f g) ≫ g) =
      𝟙 (pullback (OpenCover.map 𝒰 i ≫ f) g))
    _auto✝
[PROOFSTEP]
refine' pullback.lift ((gluing 𝒰 f g).ι i) pullback.fst (by erw [Multicoequalizer.π_desc])
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
⊢ GlueData.ι (gluing 𝒰 f g) i ≫ p1 𝒰 f g = pullback.fst ≫ OpenCover.map 𝒰 i
[PROOFSTEP]
erw [Multicoequalizer.π_desc]
[GOAL]
case hom_inv_id
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
⊢ autoParam
    (pullback.lift pullback.snd (pullback.fst ≫ p2 𝒰 f g)
          (_ : pullback.snd ≫ OpenCover.map 𝒰 i ≫ f = (pullback.fst ≫ p2 𝒰 f g) ≫ g) ≫
        pullback.lift (GlueData.ι (gluing 𝒰 f g) i) pullback.fst
          (_ : GlueData.ι (gluing 𝒰 f g) i ≫ p1 𝒰 f g = pullback.fst ≫ OpenCover.map 𝒰 i) =
      𝟙 (pullback (p1 𝒰 f g) (OpenCover.map 𝒰 i)))
    _auto✝
[PROOFSTEP]
apply pullback.hom_ext
[GOAL]
case hom_inv_id.h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
⊢ (pullback.lift pullback.snd (pullback.fst ≫ p2 𝒰 f g)
          (_ : pullback.snd ≫ OpenCover.map 𝒰 i ≫ f = (pullback.fst ≫ p2 𝒰 f g) ≫ g) ≫
        pullback.lift (GlueData.ι (gluing 𝒰 f g) i) pullback.fst
          (_ : GlueData.ι (gluing 𝒰 f g) i ≫ p1 𝒰 f g = pullback.fst ≫ OpenCover.map 𝒰 i)) ≫
      pullback.fst =
    𝟙 (pullback (p1 𝒰 f g) (OpenCover.map 𝒰 i)) ≫ pullback.fst
[PROOFSTEP]
simpa using lift_comp_ι 𝒰 f g i
[GOAL]
case hom_inv_id.h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
⊢ (pullback.lift pullback.snd (pullback.fst ≫ p2 𝒰 f g)
          (_ : pullback.snd ≫ OpenCover.map 𝒰 i ≫ f = (pullback.fst ≫ p2 𝒰 f g) ≫ g) ≫
        pullback.lift (GlueData.ι (gluing 𝒰 f g) i) pullback.fst
          (_ : GlueData.ι (gluing 𝒰 f g) i ≫ p1 𝒰 f g = pullback.fst ≫ OpenCover.map 𝒰 i)) ≫
      pullback.snd =
    𝟙 (pullback (p1 𝒰 f g) (OpenCover.map 𝒰 i)) ≫ pullback.snd
[PROOFSTEP]
simp only [Category.assoc, pullback.lift_snd, pullback.lift_fst, Category.id_comp]
[GOAL]
case inv_hom_id
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
⊢ autoParam
    (pullback.lift (GlueData.ι (gluing 𝒰 f g) i) pullback.fst
          (_ : GlueData.ι (gluing 𝒰 f g) i ≫ p1 𝒰 f g = pullback.fst ≫ OpenCover.map 𝒰 i) ≫
        pullback.lift pullback.snd (pullback.fst ≫ p2 𝒰 f g)
          (_ : pullback.snd ≫ OpenCover.map 𝒰 i ≫ f = (pullback.fst ≫ p2 𝒰 f g) ≫ g) =
      𝟙 (pullback (OpenCover.map 𝒰 i ≫ f) g))
    _auto✝
[PROOFSTEP]
apply pullback.hom_ext
[GOAL]
case inv_hom_id.h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
⊢ (pullback.lift (GlueData.ι (gluing 𝒰 f g) i) pullback.fst
          (_ : GlueData.ι (gluing 𝒰 f g) i ≫ p1 𝒰 f g = pullback.fst ≫ OpenCover.map 𝒰 i) ≫
        pullback.lift pullback.snd (pullback.fst ≫ p2 𝒰 f g)
          (_ : pullback.snd ≫ OpenCover.map 𝒰 i ≫ f = (pullback.fst ≫ p2 𝒰 f g) ≫ g)) ≫
      pullback.fst =
    𝟙 (pullback (OpenCover.map 𝒰 i ≫ f) g) ≫ pullback.fst
[PROOFSTEP]
simp only [Category.assoc, pullback.lift_fst, pullback.lift_snd, Category.id_comp]
[GOAL]
case inv_hom_id.h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
⊢ (pullback.lift (GlueData.ι (gluing 𝒰 f g) i) pullback.fst
          (_ : GlueData.ι (gluing 𝒰 f g) i ≫ p1 𝒰 f g = pullback.fst ≫ OpenCover.map 𝒰 i) ≫
        pullback.lift pullback.snd (pullback.fst ≫ p2 𝒰 f g)
          (_ : pullback.snd ≫ OpenCover.map 𝒰 i ≫ f = (pullback.fst ≫ p2 𝒰 f g) ≫ g)) ≫
      pullback.snd =
    𝟙 (pullback (OpenCover.map 𝒰 i ≫ f) g) ≫ pullback.snd
[PROOFSTEP]
simp only [Category.assoc, pullback.lift_snd, pullback.lift_fst_assoc, Category.id_comp]
[GOAL]
case inv_hom_id.h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
⊢ GlueData.ι (gluing 𝒰 f g) i ≫ p2 𝒰 f g = pullback.snd
[PROOFSTEP]
erw [Multicoequalizer.π_desc]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
⊢ (pullbackP1Iso 𝒰 f g i).hom ≫ pullback.fst = pullback.snd
[PROOFSTEP]
delta pullbackP1Iso
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
⊢ (Iso.mk
          (pullback.lift pullback.snd (pullback.fst ≫ p2 𝒰 f g)
            (_ : pullback.snd ≫ OpenCover.map 𝒰 i ≫ f = (pullback.fst ≫ p2 𝒰 f g) ≫ g))
          (pullback.lift (GlueData.ι (gluing 𝒰 f g) i) pullback.fst
            (_ : GlueData.ι (gluing 𝒰 f g) i ≫ p1 𝒰 f g = pullback.fst ≫ OpenCover.map 𝒰 i))).hom ≫
      pullback.fst =
    pullback.snd
[PROOFSTEP]
simp only [pullback.lift_fst]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
⊢ (pullbackP1Iso 𝒰 f g i).hom ≫ pullback.snd = pullback.fst ≫ p2 𝒰 f g
[PROOFSTEP]
delta pullbackP1Iso
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
⊢ (Iso.mk
          (pullback.lift pullback.snd (pullback.fst ≫ p2 𝒰 f g)
            (_ : pullback.snd ≫ OpenCover.map 𝒰 i ≫ f = (pullback.fst ≫ p2 𝒰 f g) ≫ g))
          (pullback.lift (GlueData.ι (gluing 𝒰 f g) i) pullback.fst
            (_ : GlueData.ι (gluing 𝒰 f g) i ≫ p1 𝒰 f g = pullback.fst ≫ OpenCover.map 𝒰 i))).hom ≫
      pullback.snd =
    pullback.fst ≫ p2 𝒰 f g
[PROOFSTEP]
simp only [pullback.lift_snd]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
⊢ (pullbackP1Iso 𝒰 f g i).inv ≫ pullback.fst = GlueData.ι (gluing 𝒰 f g) i
[PROOFSTEP]
delta pullbackP1Iso
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
⊢ (Iso.mk
          (pullback.lift pullback.snd (pullback.fst ≫ p2 𝒰 f g)
            (_ : pullback.snd ≫ OpenCover.map 𝒰 i ≫ f = (pullback.fst ≫ p2 𝒰 f g) ≫ g))
          (pullback.lift (GlueData.ι (gluing 𝒰 f g) i) pullback.fst
            (_ : GlueData.ι (gluing 𝒰 f g) i ≫ p1 𝒰 f g = pullback.fst ≫ OpenCover.map 𝒰 i))).inv ≫
      pullback.fst =
    GlueData.ι (gluing 𝒰 f g) i
[PROOFSTEP]
simp only [pullback.lift_fst]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
⊢ (pullbackP1Iso 𝒰 f g i).inv ≫ pullback.snd = pullback.fst
[PROOFSTEP]
delta pullbackP1Iso
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
⊢ (Iso.mk
          (pullback.lift pullback.snd (pullback.fst ≫ p2 𝒰 f g)
            (_ : pullback.snd ≫ OpenCover.map 𝒰 i ≫ f = (pullback.fst ≫ p2 𝒰 f g) ≫ g))
          (pullback.lift (GlueData.ι (gluing 𝒰 f g) i) pullback.fst
            (_ : GlueData.ι (gluing 𝒰 f g) i ≫ p1 𝒰 f g = pullback.fst ≫ OpenCover.map 𝒰 i))).inv ≫
      pullback.snd =
    pullback.fst
[PROOFSTEP]
simp only [pullback.lift_snd]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
⊢ (pullbackP1Iso 𝒰 f g i).hom ≫ GlueData.ι (gluing 𝒰 f g) i = pullback.fst
[PROOFSTEP]
rw [← pullbackP1Iso_inv_fst, Iso.hom_inv_id_assoc]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
⊢ IsLimit (PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g))
[PROOFSTEP]
apply PullbackCone.isLimitAux'
[GOAL]
case create
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s : PullbackCone f g
⊢ (s : PullbackCone f g) →
    { l //
      l ≫ PullbackCone.fst (PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g)) =
          PullbackCone.fst s ∧
        l ≫ PullbackCone.snd (PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g)) =
            PullbackCone.snd s ∧
          ∀ {m : s.pt ⟶ (PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g)).pt},
            m ≫ PullbackCone.fst (PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g)) =
                PullbackCone.fst s →
              m ≫ PullbackCone.snd (PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g)) =
                  PullbackCone.snd s →
                m = l }
[PROOFSTEP]
intro s
[GOAL]
case create
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s✝ s : PullbackCone f g
⊢ { l //
    l ≫ PullbackCone.fst (PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g)) =
        PullbackCone.fst s ∧
      l ≫ PullbackCone.snd (PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g)) =
          PullbackCone.snd s ∧
        ∀ {m : s.pt ⟶ (PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g)).pt},
          m ≫ PullbackCone.fst (PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g)) =
              PullbackCone.fst s →
            m ≫ PullbackCone.snd (PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g)) =
                PullbackCone.snd s →
              m = l }
[PROOFSTEP]
refine' ⟨gluedLift 𝒰 f g s, gluedLift_p1 𝒰 f g s, gluedLift_p2 𝒰 f g s, _⟩
[GOAL]
case create
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s✝ s : PullbackCone f g
⊢ ∀ {m : s.pt ⟶ (PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g)).pt},
    m ≫ PullbackCone.fst (PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g)) =
        PullbackCone.fst s →
      m ≫ PullbackCone.snd (PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g)) =
          PullbackCone.snd s →
        m = gluedLift 𝒰 f g s
[PROOFSTEP]
intro m h₁ h₂
[GOAL]
case create
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s✝ s : PullbackCone f g
m : s.pt ⟶ (PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g)).pt
h₁ : m ≫ PullbackCone.fst (PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g)) = PullbackCone.fst s
h₂ : m ≫ PullbackCone.snd (PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g)) = PullbackCone.snd s
⊢ m = gluedLift 𝒰 f g s
[PROOFSTEP]
change m ≫ p1 𝒰 f g = _ at h₁ 
[GOAL]
case create
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s✝ s : PullbackCone f g
m : s.pt ⟶ (PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g)).pt
h₂ : m ≫ PullbackCone.snd (PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g)) = PullbackCone.snd s
h₁ : m ≫ p1 𝒰 f g = PullbackCone.fst s
⊢ m = gluedLift 𝒰 f g s
[PROOFSTEP]
change m ≫ p2 𝒰 f g = _ at h₂ 
[GOAL]
case create
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s✝ s : PullbackCone f g
m : s.pt ⟶ (PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g)).pt
h₁ : m ≫ p1 𝒰 f g = PullbackCone.fst s
h₂ : m ≫ p2 𝒰 f g = PullbackCone.snd s
⊢ m = gluedLift 𝒰 f g s
[PROOFSTEP]
apply (𝒰.pullbackCover s.fst).hom_ext
[GOAL]
case create.h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s✝ s : PullbackCone f g
m : s.pt ⟶ (PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g)).pt
h₁ : m ≫ p1 𝒰 f g = PullbackCone.fst s
h₂ : m ≫ p2 𝒰 f g = PullbackCone.snd s
⊢ ∀ (x : (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)).J),
    OpenCover.map (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) x ≫ m =
      OpenCover.map (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) x ≫ gluedLift 𝒰 f g s
[PROOFSTEP]
intro i
[GOAL]
case create.h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s✝ s : PullbackCone f g
m : s.pt ⟶ (PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g)).pt
h₁ : m ≫ p1 𝒰 f g = PullbackCone.fst s
h₂ : m ≫ p2 𝒰 f g = PullbackCone.snd s
i : (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)).J
⊢ OpenCover.map (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) i ≫ m =
    OpenCover.map (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)) i ≫ gluedLift 𝒰 f g s
[PROOFSTEP]
rw [OpenCover.pullbackCover_map]
[GOAL]
case create.h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s✝ s : PullbackCone f g
m : s.pt ⟶ (PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g)).pt
h₁ : m ≫ p1 𝒰 f g = PullbackCone.fst s
h₂ : m ≫ p2 𝒰 f g = PullbackCone.snd s
i : (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)).J
⊢ pullback.fst ≫ m = pullback.fst ≫ gluedLift 𝒰 f g s
[PROOFSTEP]
have := pullbackRightPullbackFstIso (p1 𝒰 f g) (𝒰.map i) m ≪≫ pullback.congrHom h₁ rfl
[GOAL]
case create.h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s✝ s : PullbackCone f g
m : s.pt ⟶ (PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g)).pt
h₁ : m ≫ p1 𝒰 f g = PullbackCone.fst s
h₂ : m ≫ p2 𝒰 f g = PullbackCone.snd s
i : (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)).J
this : pullback m pullback.fst ≅ pullback (PullbackCone.fst s) (OpenCover.map 𝒰 i)
⊢ pullback.fst ≫ m = pullback.fst ≫ gluedLift 𝒰 f g s
[PROOFSTEP]
erw [(𝒰.pullbackCover s.fst).ι_glueMorphisms]
[GOAL]
case create.h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s✝ s : PullbackCone f g
m : s.pt ⟶ (PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g)).pt
h₁ : m ≫ p1 𝒰 f g = PullbackCone.fst s
h₂ : m ≫ p2 𝒰 f g = PullbackCone.snd s
i : (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)).J
this : pullback m pullback.fst ≅ pullback (PullbackCone.fst s) (OpenCover.map 𝒰 i)
⊢ pullback.fst ≫ m =
    (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 i)).hom ≫
      pullback.map (OpenCover.map 𝒰 i) (PullbackCone.fst s) (OpenCover.map 𝒰 i ≫ f) g (𝟙 (OpenCover.obj 𝒰 i))
          (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 i ≫ f = 𝟙 (OpenCover.obj 𝒰 i) ≫ OpenCover.map 𝒰 i ≫ f)
          (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g) ≫
        GlueData.ι (gluing 𝒰 f g) i
[PROOFSTEP]
rw [← cancel_epi (pullbackRightPullbackFstIso (p1 𝒰 f g) (𝒰.map i) m ≪≫ pullback.congrHom h₁ rfl).hom, Iso.trans_hom,
  Category.assoc, pullback.congrHom_hom, pullback.lift_fst_assoc, Category.comp_id,
  pullbackRightPullbackFstIso_hom_fst_assoc, pullback.condition]
[GOAL]
case create.h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s✝ s : PullbackCone f g
m : s.pt ⟶ (PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g)).pt
h₁ : m ≫ p1 𝒰 f g = PullbackCone.fst s
h₂ : m ≫ p2 𝒰 f g = PullbackCone.snd s
i : (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)).J
this : pullback m pullback.fst ≅ pullback (PullbackCone.fst s) (OpenCover.map 𝒰 i)
⊢ pullback.snd ≫ pullback.fst =
    ((pullbackRightPullbackFstIso (p1 𝒰 f g) (OpenCover.map 𝒰 i) m).hom ≫
        pullback.map (m ≫ p1 𝒰 f g) (OpenCover.map 𝒰 i) (PullbackCone.fst s) (OpenCover.map 𝒰 i) (𝟙 s.pt)
          (𝟙 (OpenCover.obj 𝒰 i)) (𝟙 X) (_ : (m ≫ p1 𝒰 f g) ≫ 𝟙 X = 𝟙 s.pt ≫ PullbackCone.fst s)
          (_ : OpenCover.map 𝒰 i ≫ 𝟙 X = 𝟙 (OpenCover.obj 𝒰 i) ≫ OpenCover.map 𝒰 i)) ≫
      (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 i)).hom ≫
        pullback.map (OpenCover.map 𝒰 i) (PullbackCone.fst s) (OpenCover.map 𝒰 i ≫ f) g (𝟙 (OpenCover.obj 𝒰 i))
            (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 i ≫ f = 𝟙 (OpenCover.obj 𝒰 i) ≫ OpenCover.map 𝒰 i ≫ f)
            (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g) ≫
          GlueData.ι (gluing 𝒰 f g) i
[PROOFSTEP]
trans pullback.snd ≫ (pullbackP1Iso 𝒰 f g _).hom ≫ (gluing 𝒰 f g).ι _
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s✝ s : PullbackCone f g
m : s.pt ⟶ (PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g)).pt
h₁ : m ≫ p1 𝒰 f g = PullbackCone.fst s
h₂ : m ≫ p2 𝒰 f g = PullbackCone.snd s
i : (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)).J
this : pullback m pullback.fst ≅ pullback (PullbackCone.fst s) (OpenCover.map 𝒰 i)
⊢ pullback.snd ≫ pullback.fst = pullback.snd ≫ (pullbackP1Iso 𝒰 f g i).hom ≫ GlueData.ι (gluing 𝒰 f g) i
[PROOFSTEP]
congr 1
[GOAL]
case e_a
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s✝ s : PullbackCone f g
m : s.pt ⟶ (PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g)).pt
h₁ : m ≫ p1 𝒰 f g = PullbackCone.fst s
h₂ : m ≫ p2 𝒰 f g = PullbackCone.snd s
i : (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)).J
this : pullback m pullback.fst ≅ pullback (PullbackCone.fst s) (OpenCover.map 𝒰 i)
⊢ pullback.fst = (pullbackP1Iso 𝒰 f g i).hom ≫ GlueData.ι (gluing 𝒰 f g) i
[PROOFSTEP]
rw [← pullbackP1Iso_hom_ι]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s✝ s : PullbackCone f g
m : s.pt ⟶ (PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g)).pt
h₁ : m ≫ p1 𝒰 f g = PullbackCone.fst s
h₂ : m ≫ p2 𝒰 f g = PullbackCone.snd s
i : (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)).J
this : pullback m pullback.fst ≅ pullback (PullbackCone.fst s) (OpenCover.map 𝒰 i)
⊢ pullback.snd ≫ (pullbackP1Iso 𝒰 f g i).hom ≫ GlueData.ι (gluing 𝒰 f g) i =
    ((pullbackRightPullbackFstIso (p1 𝒰 f g) (OpenCover.map 𝒰 i) m).hom ≫
        pullback.map (m ≫ p1 𝒰 f g) (OpenCover.map 𝒰 i) (PullbackCone.fst s) (OpenCover.map 𝒰 i) (𝟙 s.pt)
          (𝟙 (OpenCover.obj 𝒰 i)) (𝟙 X) (_ : (m ≫ p1 𝒰 f g) ≫ 𝟙 X = 𝟙 s.pt ≫ PullbackCone.fst s)
          (_ : OpenCover.map 𝒰 i ≫ 𝟙 X = 𝟙 (OpenCover.obj 𝒰 i) ≫ OpenCover.map 𝒰 i)) ≫
      (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 i)).hom ≫
        pullback.map (OpenCover.map 𝒰 i) (PullbackCone.fst s) (OpenCover.map 𝒰 i ≫ f) g (𝟙 (OpenCover.obj 𝒰 i))
            (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 i ≫ f = 𝟙 (OpenCover.obj 𝒰 i) ≫ OpenCover.map 𝒰 i ≫ f)
            (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g) ≫
          GlueData.ι (gluing 𝒰 f g) i
[PROOFSTEP]
simp_rw [← Category.assoc]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s✝ s : PullbackCone f g
m : s.pt ⟶ (PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g)).pt
h₁ : m ≫ p1 𝒰 f g = PullbackCone.fst s
h₂ : m ≫ p2 𝒰 f g = PullbackCone.snd s
i : (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)).J
this : pullback m pullback.fst ≅ pullback (PullbackCone.fst s) (OpenCover.map 𝒰 i)
⊢ (pullback.snd ≫ (pullbackP1Iso 𝒰 f g i).hom) ≫ GlueData.ι (gluing 𝒰 f g) i =
    ((((pullbackRightPullbackFstIso (p1 𝒰 f g) (OpenCover.map 𝒰 i) m).hom ≫
            pullback.map (m ≫ p1 𝒰 f g) (OpenCover.map 𝒰 i) (PullbackCone.fst s) (OpenCover.map 𝒰 i) (𝟙 s.pt)
              (𝟙 (OpenCover.obj 𝒰 i)) (𝟙 X) (_ : (m ≫ p1 𝒰 f g) ≫ 𝟙 X = 𝟙 s.pt ≫ PullbackCone.fst s)
              (_ : OpenCover.map 𝒰 i ≫ 𝟙 X = 𝟙 (OpenCover.obj 𝒰 i) ≫ OpenCover.map 𝒰 i)) ≫
          (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 i)).hom) ≫
        pullback.map (OpenCover.map 𝒰 i) (PullbackCone.fst s) (OpenCover.map 𝒰 i ≫ f) g (𝟙 (OpenCover.obj 𝒰 i))
          (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 i ≫ f = 𝟙 (OpenCover.obj 𝒰 i) ≫ OpenCover.map 𝒰 i ≫ f)
          (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g)) ≫
      GlueData.ι (gluing 𝒰 f g) i
[PROOFSTEP]
congr 1
[GOAL]
case e_a
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s✝ s : PullbackCone f g
m : s.pt ⟶ (PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g)).pt
h₁ : m ≫ p1 𝒰 f g = PullbackCone.fst s
h₂ : m ≫ p2 𝒰 f g = PullbackCone.snd s
i : (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)).J
this : pullback m pullback.fst ≅ pullback (PullbackCone.fst s) (OpenCover.map 𝒰 i)
⊢ pullback.snd ≫ (pullbackP1Iso 𝒰 f g i).hom =
    (((pullbackRightPullbackFstIso (p1 𝒰 f g) (OpenCover.map 𝒰 i) m).hom ≫
          pullback.map (m ≫ p1 𝒰 f g) (OpenCover.map 𝒰 i) (PullbackCone.fst s) (OpenCover.map 𝒰 i) (𝟙 s.pt)
            (𝟙 (OpenCover.obj 𝒰 i)) (𝟙 X) (_ : (m ≫ p1 𝒰 f g) ≫ 𝟙 X = 𝟙 s.pt ≫ PullbackCone.fst s)
            (_ : OpenCover.map 𝒰 i ≫ 𝟙 X = 𝟙 (OpenCover.obj 𝒰 i) ≫ OpenCover.map 𝒰 i)) ≫
        (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 i)).hom) ≫
      pullback.map (OpenCover.map 𝒰 i) (PullbackCone.fst s) (OpenCover.map 𝒰 i ≫ f) g (𝟙 (OpenCover.obj 𝒰 i))
        (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 i ≫ f = 𝟙 (OpenCover.obj 𝒰 i) ≫ OpenCover.map 𝒰 i ≫ f)
        (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g)
[PROOFSTEP]
apply pullback.hom_ext
[GOAL]
case e_a.h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s✝ s : PullbackCone f g
m : s.pt ⟶ (PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g)).pt
h₁ : m ≫ p1 𝒰 f g = PullbackCone.fst s
h₂ : m ≫ p2 𝒰 f g = PullbackCone.snd s
i : (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)).J
this : pullback m pullback.fst ≅ pullback (PullbackCone.fst s) (OpenCover.map 𝒰 i)
⊢ (pullback.snd ≫ (pullbackP1Iso 𝒰 f g i).hom) ≫ pullback.fst =
    ((((pullbackRightPullbackFstIso (p1 𝒰 f g) (OpenCover.map 𝒰 i) m).hom ≫
            pullback.map (m ≫ p1 𝒰 f g) (OpenCover.map 𝒰 i) (PullbackCone.fst s) (OpenCover.map 𝒰 i) (𝟙 s.pt)
              (𝟙 (OpenCover.obj 𝒰 i)) (𝟙 X) (_ : (m ≫ p1 𝒰 f g) ≫ 𝟙 X = 𝟙 s.pt ≫ PullbackCone.fst s)
              (_ : OpenCover.map 𝒰 i ≫ 𝟙 X = 𝟙 (OpenCover.obj 𝒰 i) ≫ OpenCover.map 𝒰 i)) ≫
          (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 i)).hom) ≫
        pullback.map (OpenCover.map 𝒰 i) (PullbackCone.fst s) (OpenCover.map 𝒰 i ≫ f) g (𝟙 (OpenCover.obj 𝒰 i))
          (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 i ≫ f = 𝟙 (OpenCover.obj 𝒰 i) ≫ OpenCover.map 𝒰 i ≫ f)
          (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g)) ≫
      pullback.fst
[PROOFSTEP]
simp only [Category.comp_id, pullbackRightPullbackFstIso_hom_snd, Category.assoc, pullbackP1Iso_hom_fst,
  pullback.lift_snd, pullback.lift_fst, pullbackSymmetry_hom_comp_fst]
[GOAL]
case e_a.h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s✝ s : PullbackCone f g
m : s.pt ⟶ (PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g)).pt
h₁ : m ≫ p1 𝒰 f g = PullbackCone.fst s
h₂ : m ≫ p2 𝒰 f g = PullbackCone.snd s
i : (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)).J
this : pullback m pullback.fst ≅ pullback (PullbackCone.fst s) (OpenCover.map 𝒰 i)
⊢ (pullback.snd ≫ (pullbackP1Iso 𝒰 f g i).hom) ≫ pullback.snd =
    ((((pullbackRightPullbackFstIso (p1 𝒰 f g) (OpenCover.map 𝒰 i) m).hom ≫
            pullback.map (m ≫ p1 𝒰 f g) (OpenCover.map 𝒰 i) (PullbackCone.fst s) (OpenCover.map 𝒰 i) (𝟙 s.pt)
              (𝟙 (OpenCover.obj 𝒰 i)) (𝟙 X) (_ : (m ≫ p1 𝒰 f g) ≫ 𝟙 X = 𝟙 s.pt ≫ PullbackCone.fst s)
              (_ : OpenCover.map 𝒰 i ≫ 𝟙 X = 𝟙 (OpenCover.obj 𝒰 i) ≫ OpenCover.map 𝒰 i)) ≫
          (pullbackSymmetry (PullbackCone.fst s) (OpenCover.map 𝒰 i)).hom) ≫
        pullback.map (OpenCover.map 𝒰 i) (PullbackCone.fst s) (OpenCover.map 𝒰 i ≫ f) g (𝟙 (OpenCover.obj 𝒰 i))
          (PullbackCone.snd s) f (_ : OpenCover.map 𝒰 i ≫ f = 𝟙 (OpenCover.obj 𝒰 i) ≫ OpenCover.map 𝒰 i ≫ f)
          (_ : PullbackCone.fst s ≫ f = PullbackCone.snd s ≫ g)) ≫
      pullback.snd
[PROOFSTEP]
simp only [Category.comp_id, pullbackRightPullbackFstIso_hom_fst_assoc, pullbackP1Iso_hom_snd, Category.assoc,
  pullback.lift_fst_assoc, pullbackSymmetry_hom_comp_snd_assoc, pullback.lift_snd]
[GOAL]
case e_a.h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f) g
s✝ s : PullbackCone f g
m : s.pt ⟶ (PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g)).pt
h₁ : m ≫ p1 𝒰 f g = PullbackCone.fst s
h₂ : m ≫ p2 𝒰 f g = PullbackCone.snd s
i : (OpenCover.pullbackCover 𝒰 (PullbackCone.fst s)).J
this : pullback m pullback.fst ≅ pullback (PullbackCone.fst s) (OpenCover.map 𝒰 i)
⊢ pullback.snd ≫ pullback.fst ≫ p2 𝒰 f g = pullback.fst ≫ PullbackCone.snd s
[PROOFSTEP]
rw [← pullback.condition_assoc, h₂]
[GOAL]
C✝ : Type u
inst✝¹ : Category.{v, u} C✝
X Y Z : Scheme
𝒰 : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f✝) g✝
s : PullbackCone f✝ g✝
A B C : CommRingCat
f : Spec.obj (Opposite.op A) ⟶ Spec.obj (Opposite.op C)
g : Spec.obj (Opposite.op B) ⟶ Spec.obj (Opposite.op C)
⊢ HasPullback f g
[PROOFSTEP]
rw [← Spec.image_preimage f, ← Spec.image_preimage g]
[GOAL]
C✝ : Type u
inst✝¹ : Category.{v, u} C✝
X Y Z : Scheme
𝒰 : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f✝) g✝
s : PullbackCone f✝ g✝
A B C : CommRingCat
f : Spec.obj (Opposite.op A) ⟶ Spec.obj (Opposite.op C)
g : Spec.obj (Opposite.op B) ⟶ Spec.obj (Opposite.op C)
⊢ HasPullback (Spec.map (Spec.preimage f)) (Spec.map (Spec.preimage g))
[PROOFSTEP]
exact ⟨⟨⟨_, isLimitOfHasPullbackOfPreservesLimit Spec (Spec.preimage f) (Spec.preimage g)⟩⟩⟩
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝ : Scheme
𝒰 : OpenCover X✝
f✝ : X✝ ⟶ Z✝
g✝ : Y✝ ⟶ Z✝
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f✝) g✝
s : PullbackCone f✝ g✝
X Y Z : Scheme
f : X ⟶ Z
g : Y ⟶ Z
i : (affineCover Z).J
⊢ HasPullback (OpenCover.map (OpenCover.pullbackCover (affineCover Z) f) i ≫ f) g
[PROOFSTEP]
let Xᵢ := pullback f (Z.affineCover.map i)
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝ : Scheme
𝒰 : OpenCover X✝
f✝ : X✝ ⟶ Z✝
g✝ : Y✝ ⟶ Z✝
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f✝) g✝
s : PullbackCone f✝ g✝
X Y Z : Scheme
f : X ⟶ Z
g : Y ⟶ Z
i : (affineCover Z).J
Xᵢ : Scheme := pullback f (OpenCover.map (affineCover Z) i)
⊢ HasPullback (OpenCover.map (OpenCover.pullbackCover (affineCover Z) f) i ≫ f) g
[PROOFSTEP]
let Yᵢ := pullback g (Z.affineCover.map i)
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝ : Scheme
𝒰 : OpenCover X✝
f✝ : X✝ ⟶ Z✝
g✝ : Y✝ ⟶ Z✝
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f✝) g✝
s : PullbackCone f✝ g✝
X Y Z : Scheme
f : X ⟶ Z
g : Y ⟶ Z
i : (affineCover Z).J
Xᵢ : Scheme := pullback f (OpenCover.map (affineCover Z) i)
Yᵢ : Scheme := pullback g (OpenCover.map (affineCover Z) i)
⊢ HasPullback (OpenCover.map (OpenCover.pullbackCover (affineCover Z) f) i ≫ f) g
[PROOFSTEP]
let W := pullback (pullback.snd : Yᵢ ⟶ _) (pullback.snd : Xᵢ ⟶ _)
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝ : Scheme
𝒰 : OpenCover X✝
f✝ : X✝ ⟶ Z✝
g✝ : Y✝ ⟶ Z✝
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f✝) g✝
s : PullbackCone f✝ g✝
X Y Z : Scheme
f : X ⟶ Z
g : Y ⟶ Z
i : (affineCover Z).J
Xᵢ : Scheme := pullback f (OpenCover.map (affineCover Z) i)
Yᵢ : Scheme := pullback g (OpenCover.map (affineCover Z) i)
W : Scheme := pullback pullback.snd pullback.snd
⊢ HasPullback (OpenCover.map (OpenCover.pullbackCover (affineCover Z) f) i ≫ f) g
[PROOFSTEP]
have :=
  bigSquareIsPullback (pullback.fst : W ⟶ _) (pullback.fst : Yᵢ ⟶ _) (pullback.snd : Xᵢ ⟶ _) (Z.affineCover.map i)
    pullback.snd pullback.snd g pullback.condition.symm pullback.condition.symm
    (PullbackCone.flipIsLimit <| pullbackIsPullback _ _) (PullbackCone.flipIsLimit <| pullbackIsPullback _ _)
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝ : Scheme
𝒰 : OpenCover X✝
f✝ : X✝ ⟶ Z✝
g✝ : Y✝ ⟶ Z✝
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f✝) g✝
s : PullbackCone f✝ g✝
X Y Z : Scheme
f : X ⟶ Z
g : Y ⟶ Z
i : (affineCover Z).J
Xᵢ : Scheme := pullback f (OpenCover.map (affineCover Z) i)
Yᵢ : Scheme := pullback g (OpenCover.map (affineCover Z) i)
W : Scheme := pullback pullback.snd pullback.snd
this :
  IsLimit
    (PullbackCone.mk pullback.snd (pullback.fst ≫ pullback.fst)
      (_ : pullback.snd ≫ pullback.snd ≫ OpenCover.map (affineCover Z) i = (pullback.fst ≫ pullback.fst) ≫ g))
⊢ HasPullback (OpenCover.map (OpenCover.pullbackCover (affineCover Z) f) i ≫ f) g
[PROOFSTEP]
have : HasPullback (pullback.snd ≫ Z.affineCover.map i : Xᵢ ⟶ _) g := ⟨⟨⟨_, this⟩⟩⟩
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝ : Scheme
𝒰 : OpenCover X✝
f✝ : X✝ ⟶ Z✝
g✝ : Y✝ ⟶ Z✝
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f✝) g✝
s : PullbackCone f✝ g✝
X Y Z : Scheme
f : X ⟶ Z
g : Y ⟶ Z
i : (affineCover Z).J
Xᵢ : Scheme := pullback f (OpenCover.map (affineCover Z) i)
Yᵢ : Scheme := pullback g (OpenCover.map (affineCover Z) i)
W : Scheme := pullback pullback.snd pullback.snd
this✝ :
  IsLimit
    (PullbackCone.mk pullback.snd (pullback.fst ≫ pullback.fst)
      (_ : pullback.snd ≫ pullback.snd ≫ OpenCover.map (affineCover Z) i = (pullback.fst ≫ pullback.fst) ≫ g))
this : HasPullback (pullback.snd ≫ OpenCover.map (affineCover Z) i) g
⊢ HasPullback (OpenCover.map (OpenCover.pullbackCover (affineCover Z) f) i ≫ f) g
[PROOFSTEP]
rw [← pullback.condition] at this 
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝ : Scheme
𝒰 : OpenCover X✝
f✝ : X✝ ⟶ Z✝
g✝ : Y✝ ⟶ Z✝
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f✝) g✝
s : PullbackCone f✝ g✝
X Y Z : Scheme
f : X ⟶ Z
g : Y ⟶ Z
i : (affineCover Z).J
Xᵢ : Scheme := pullback f (OpenCover.map (affineCover Z) i)
Yᵢ : Scheme := pullback g (OpenCover.map (affineCover Z) i)
W : Scheme := pullback pullback.snd pullback.snd
this✝ :
  IsLimit
    (PullbackCone.mk pullback.snd (pullback.fst ≫ pullback.fst)
      (_ : pullback.snd ≫ pullback.snd ≫ OpenCover.map (affineCover Z) i = (pullback.fst ≫ pullback.fst) ≫ g))
this : HasPullback (pullback.fst ≫ f) g
⊢ HasPullback (OpenCover.map (OpenCover.pullbackCover (affineCover Z) f) i ≫ f) g
[PROOFSTEP]
exact this
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
⊢ OpenCover (pullback f g)
[PROOFSTEP]
fapply
  ((gluing 𝒰 f g).openCover.pushforwardIso (limit.isoLimitCone ⟨_, gluedIsLimit 𝒰 f g⟩).inv).copy 𝒰.J
    (fun i => pullback (𝒰.map i ≫ f) g)
    (fun i => pullback.map _ _ _ _ (𝒰.map i) (𝟙 _) (𝟙 _) (Category.comp_id _) (by simp)) (Equiv.refl 𝒰.J) fun _ =>
    Iso.refl _
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
i : 𝒰.J
⊢ g ≫ 𝟙 Z = 𝟙 Y ≫ g
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
⊢ ∀ (i : 𝒰.J),
    pullback.map (OpenCover.map 𝒰 i ≫ f) g f g (OpenCover.map 𝒰 i) (𝟙 Y) (𝟙 Z)
        (_ : (OpenCover.map 𝒰 i ≫ f) ≫ 𝟙 Z = OpenCover.map 𝒰 i ≫ f) (_ : g ≫ 𝟙 Z = 𝟙 Y ≫ g) =
      (Iso.refl ((fun i => pullback (OpenCover.map 𝒰 i ≫ f) g) i)).hom ≫
        OpenCover.map
          (OpenCover.pushforwardIso (GlueData.openCover (gluing 𝒰 f g))
            (limit.isoLimitCone
                { cone := PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g),
                  isLimit := gluedIsLimit 𝒰 f g }).inv)
          (↑(Equiv.refl 𝒰.J) i)
[PROOFSTEP]
rintro (i : 𝒰.J)
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
i : 𝒰.J
⊢ pullback.map (OpenCover.map 𝒰 i ≫ f) g f g (OpenCover.map 𝒰 i) (𝟙 Y) (𝟙 Z)
      (_ : (OpenCover.map 𝒰 i ≫ f) ≫ 𝟙 Z = OpenCover.map 𝒰 i ≫ f) (_ : g ≫ 𝟙 Z = 𝟙 Y ≫ g) =
    (Iso.refl ((fun i => pullback (OpenCover.map 𝒰 i ≫ f) g) i)).hom ≫
      OpenCover.map
        (OpenCover.pushforwardIso (GlueData.openCover (gluing 𝒰 f g))
          (limit.isoLimitCone
              { cone := PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g),
                isLimit := gluedIsLimit 𝒰 f g }).inv)
        (↑(Equiv.refl 𝒰.J) i)
[PROOFSTEP]
change pullback.map _ _ _ _ _ _ _ _ _ = 𝟙 _ ≫ (gluing 𝒰 f g).ι i ≫ _
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
i : 𝒰.J
⊢ pullback.map (OpenCover.map 𝒰 i ≫ f) g f g (OpenCover.map 𝒰 i) (𝟙 Y) (𝟙 Z)
      (_ : (OpenCover.map 𝒰 i ≫ f) ≫ 𝟙 Z = OpenCover.map 𝒰 i ≫ f) (_ : g ≫ 𝟙 Z = 𝟙 Y ≫ g) =
    𝟙 (GlueData.U (gluing 𝒰 f g).toGlueData i) ≫
      GlueData.ι (gluing 𝒰 f g) i ≫
        OpenCover.map
          (openCoverOfIsIso
            (limit.isoLimitCone
                { cone := PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g),
                  isLimit := gluedIsLimit 𝒰 f g }).inv)
          (↑((Equiv.punitProd (GlueData.openCover (gluing 𝒰 f g)).J).symm.trans
                  (Equiv.sigmaEquivProd PUnit (GlueData.openCover (gluing 𝒰 f g)).J).symm)
              (↑(Equiv.refl 𝒰.J) i)).fst
[PROOFSTEP]
refine' Eq.trans _ (Category.id_comp _).symm
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
i : 𝒰.J
⊢ pullback.map (OpenCover.map 𝒰 i ≫ f) g f g (OpenCover.map 𝒰 i) (𝟙 Y) (𝟙 Z)
      (_ : (OpenCover.map 𝒰 i ≫ f) ≫ 𝟙 Z = OpenCover.map 𝒰 i ≫ f) (_ : g ≫ 𝟙 Z = 𝟙 Y ≫ g) =
    GlueData.ι (gluing 𝒰 f g) i ≫
      OpenCover.map
        (openCoverOfIsIso
          (limit.isoLimitCone
              { cone := PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g),
                isLimit := gluedIsLimit 𝒰 f g }).inv)
        (↑((Equiv.punitProd (GlueData.openCover (gluing 𝒰 f g)).J).symm.trans
                (Equiv.sigmaEquivProd PUnit (GlueData.openCover (gluing 𝒰 f g)).J).symm)
            (↑(Equiv.refl 𝒰.J) i)).fst
[PROOFSTEP]
apply pullback.hom_ext
[GOAL]
case h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
i : 𝒰.J
⊢ pullback.map (OpenCover.map 𝒰 i ≫ f) g f g (OpenCover.map 𝒰 i) (𝟙 Y) (𝟙 Z)
        (_ : (OpenCover.map 𝒰 i ≫ f) ≫ 𝟙 Z = OpenCover.map 𝒰 i ≫ f) (_ : g ≫ 𝟙 Z = 𝟙 Y ≫ g) ≫
      pullback.fst =
    (GlueData.ι (gluing 𝒰 f g) i ≫
        OpenCover.map
          (openCoverOfIsIso
            (limit.isoLimitCone
                { cone := PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g),
                  isLimit := gluedIsLimit 𝒰 f g }).inv)
          (↑((Equiv.punitProd (GlueData.openCover (gluing 𝒰 f g)).J).symm.trans
                  (Equiv.sigmaEquivProd PUnit (GlueData.openCover (gluing 𝒰 f g)).J).symm)
              (↑(Equiv.refl 𝒰.J) i)).fst) ≫
      pullback.fst
case h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
i : 𝒰.J
⊢ pullback.map (OpenCover.map 𝒰 i ≫ f) g f g (OpenCover.map 𝒰 i) (𝟙 Y) (𝟙 Z)
        (_ : (OpenCover.map 𝒰 i ≫ f) ≫ 𝟙 Z = OpenCover.map 𝒰 i ≫ f) (_ : g ≫ 𝟙 Z = 𝟙 Y ≫ g) ≫
      pullback.snd =
    (GlueData.ι (gluing 𝒰 f g) i ≫
        OpenCover.map
          (openCoverOfIsIso
            (limit.isoLimitCone
                { cone := PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g),
                  isLimit := gluedIsLimit 𝒰 f g }).inv)
          (↑((Equiv.punitProd (GlueData.openCover (gluing 𝒰 f g)).J).symm.trans
                  (Equiv.sigmaEquivProd PUnit (GlueData.openCover (gluing 𝒰 f g)).J).symm)
              (↑(Equiv.refl 𝒰.J) i)).fst) ≫
      pullback.snd
[PROOFSTEP]
all_goals
  dsimp
  simp only [limit.isoLimitCone_inv_π, PullbackCone.mk_π_app_left, Category.comp_id, PullbackCone.mk_π_app_right,
    Category.assoc, pullback.lift_fst, pullback.lift_snd]
  symm
  exact Multicoequalizer.π_desc _ _ _ _ _
[GOAL]
case h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
i : 𝒰.J
⊢ pullback.map (OpenCover.map 𝒰 i ≫ f) g f g (OpenCover.map 𝒰 i) (𝟙 Y) (𝟙 Z)
        (_ : (OpenCover.map 𝒰 i ≫ f) ≫ 𝟙 Z = OpenCover.map 𝒰 i ≫ f) (_ : g ≫ 𝟙 Z = 𝟙 Y ≫ g) ≫
      pullback.fst =
    (GlueData.ι (gluing 𝒰 f g) i ≫
        OpenCover.map
          (openCoverOfIsIso
            (limit.isoLimitCone
                { cone := PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g),
                  isLimit := gluedIsLimit 𝒰 f g }).inv)
          (↑((Equiv.punitProd (GlueData.openCover (gluing 𝒰 f g)).J).symm.trans
                  (Equiv.sigmaEquivProd PUnit (GlueData.openCover (gluing 𝒰 f g)).J).symm)
              (↑(Equiv.refl 𝒰.J) i)).fst) ≫
      pullback.fst
[PROOFSTEP]
dsimp
[GOAL]
case h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
i : 𝒰.J
⊢ pullback.map (OpenCover.map 𝒰 i ≫ f) g f g (OpenCover.map 𝒰 i) (𝟙 Y) (𝟙 Z)
        (_ : (OpenCover.map 𝒰 i ≫ f) ≫ 𝟙 Z = OpenCover.map 𝒰 i ≫ f) (_ : g ≫ 𝟙 Z = 𝟙 Y ≫ g) ≫
      pullback.fst =
    (GlueData.ι (gluing 𝒰 f g) i ≫
        (limit.isoLimitCone
            { cone := PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g),
              isLimit := gluedIsLimit 𝒰 f g }).inv) ≫
      pullback.fst
[PROOFSTEP]
simp only [limit.isoLimitCone_inv_π, PullbackCone.mk_π_app_left, Category.comp_id, PullbackCone.mk_π_app_right,
  Category.assoc, pullback.lift_fst, pullback.lift_snd]
[GOAL]
case h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
i : 𝒰.J
⊢ pullback.fst ≫ OpenCover.map 𝒰 i = GlueData.ι (gluing 𝒰 f g) i ≫ p1 𝒰 f g
[PROOFSTEP]
symm
[GOAL]
case h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
i : 𝒰.J
⊢ GlueData.ι (gluing 𝒰 f g) i ≫ p1 𝒰 f g = pullback.fst ≫ OpenCover.map 𝒰 i
[PROOFSTEP]
exact Multicoequalizer.π_desc _ _ _ _ _
[GOAL]
case h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
i : 𝒰.J
⊢ pullback.map (OpenCover.map 𝒰 i ≫ f) g f g (OpenCover.map 𝒰 i) (𝟙 Y) (𝟙 Z)
        (_ : (OpenCover.map 𝒰 i ≫ f) ≫ 𝟙 Z = OpenCover.map 𝒰 i ≫ f) (_ : g ≫ 𝟙 Z = 𝟙 Y ≫ g) ≫
      pullback.snd =
    (GlueData.ι (gluing 𝒰 f g) i ≫
        OpenCover.map
          (openCoverOfIsIso
            (limit.isoLimitCone
                { cone := PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g),
                  isLimit := gluedIsLimit 𝒰 f g }).inv)
          (↑((Equiv.punitProd (GlueData.openCover (gluing 𝒰 f g)).J).symm.trans
                  (Equiv.sigmaEquivProd PUnit (GlueData.openCover (gluing 𝒰 f g)).J).symm)
              (↑(Equiv.refl 𝒰.J) i)).fst) ≫
      pullback.snd
[PROOFSTEP]
dsimp
[GOAL]
case h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
i : 𝒰.J
⊢ pullback.map (OpenCover.map 𝒰 i ≫ f) g f g (OpenCover.map 𝒰 i) (𝟙 Y) (𝟙 Z)
        (_ : (OpenCover.map 𝒰 i ≫ f) ≫ 𝟙 Z = OpenCover.map 𝒰 i ≫ f) (_ : g ≫ 𝟙 Z = 𝟙 Y ≫ g) ≫
      pullback.snd =
    (GlueData.ι (gluing 𝒰 f g) i ≫
        (limit.isoLimitCone
            { cone := PullbackCone.mk (p1 𝒰 f g) (p2 𝒰 f g) (_ : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g),
              isLimit := gluedIsLimit 𝒰 f g }).inv) ≫
      pullback.snd
[PROOFSTEP]
simp only [limit.isoLimitCone_inv_π, PullbackCone.mk_π_app_left, Category.comp_id, PullbackCone.mk_π_app_right,
  Category.assoc, pullback.lift_fst, pullback.lift_snd]
[GOAL]
case h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
i : 𝒰.J
⊢ pullback.snd = GlueData.ι (gluing 𝒰 f g) i ≫ p2 𝒰 f g
[PROOFSTEP]
symm
[GOAL]
case h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover X
f : X ⟶ Z
g : Y ⟶ Z
i : 𝒰.J
⊢ GlueData.ι (gluing 𝒰 f g) i ≫ p2 𝒰 f g = pullback.snd
[PROOFSTEP]
exact Multicoequalizer.π_desc _ _ _ _ _
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover Y
f : X ⟶ Z
g : Y ⟶ Z
⊢ OpenCover (pullback f g)
[PROOFSTEP]
fapply
  ((openCoverOfLeft 𝒰 g f).pushforwardIso (pullbackSymmetry _ _).hom).copy 𝒰.J (fun i => pullback f (𝒰.map i ≫ g))
    (fun i => pullback.map _ _ _ _ (𝟙 _) (𝒰.map i) (𝟙 _) (by simp) (Category.comp_id _)) (Equiv.refl _) fun i =>
    pullbackSymmetry _ _
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover Y
f : X ⟶ Z
g : Y ⟶ Z
i : 𝒰.J
⊢ f ≫ 𝟙 Z = 𝟙 X ≫ f
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover Y
f : X ⟶ Z
g : Y ⟶ Z
⊢ ∀ (i : 𝒰.J),
    pullback.map f (OpenCover.map 𝒰 i ≫ g) f g (𝟙 X) (OpenCover.map 𝒰 i) (𝟙 Z) (_ : f ≫ 𝟙 Z = 𝟙 X ≫ f)
        (_ : (OpenCover.map 𝒰 i ≫ g) ≫ 𝟙 Z = OpenCover.map 𝒰 i ≫ g) =
      (pullbackSymmetry f (OpenCover.map 𝒰 i ≫ g)).hom ≫
        OpenCover.map (OpenCover.pushforwardIso (openCoverOfLeft 𝒰 g f) (pullbackSymmetry g f).hom)
          (↑(Equiv.refl 𝒰.J) i)
[PROOFSTEP]
intro i
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover Y
f : X ⟶ Z
g : Y ⟶ Z
i : 𝒰.J
⊢ pullback.map f (OpenCover.map 𝒰 i ≫ g) f g (𝟙 X) (OpenCover.map 𝒰 i) (𝟙 Z) (_ : f ≫ 𝟙 Z = 𝟙 X ≫ f)
      (_ : (OpenCover.map 𝒰 i ≫ g) ≫ 𝟙 Z = OpenCover.map 𝒰 i ≫ g) =
    (pullbackSymmetry f (OpenCover.map 𝒰 i ≫ g)).hom ≫
      OpenCover.map (OpenCover.pushforwardIso (openCoverOfLeft 𝒰 g f) (pullbackSymmetry g f).hom) (↑(Equiv.refl 𝒰.J) i)
[PROOFSTEP]
dsimp [OpenCover.bind]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover Y
f : X ⟶ Z
g : Y ⟶ Z
i : 𝒰.J
⊢ pullback.map f (OpenCover.map 𝒰 i ≫ g) f g (𝟙 X) (OpenCover.map 𝒰 i) (𝟙 Z) (_ : f ≫ 𝟙 Z = 𝟙 X ≫ f)
      (_ : (OpenCover.map 𝒰 i ≫ g) ≫ 𝟙 Z = OpenCover.map 𝒰 i ≫ g) =
    (pullbackSymmetry f (OpenCover.map 𝒰 i ≫ g)).hom ≫
      pullback.map (OpenCover.map 𝒰 i ≫ g) f g f (OpenCover.map 𝒰 i) (𝟙 X) (𝟙 Z)
          (_ : (OpenCover.map 𝒰 i ≫ g) ≫ 𝟙 Z = OpenCover.map 𝒰 i ≫ g) (_ : f ≫ 𝟙 Z = 𝟙 X ≫ f) ≫
        (pullbackSymmetry g f).hom
[PROOFSTEP]
apply pullback.hom_ext
[GOAL]
case h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover Y
f : X ⟶ Z
g : Y ⟶ Z
i : 𝒰.J
⊢ pullback.map f (OpenCover.map 𝒰 i ≫ g) f g (𝟙 X) (OpenCover.map 𝒰 i) (𝟙 Z) (_ : f ≫ 𝟙 Z = 𝟙 X ≫ f)
        (_ : (OpenCover.map 𝒰 i ≫ g) ≫ 𝟙 Z = OpenCover.map 𝒰 i ≫ g) ≫
      pullback.fst =
    ((pullbackSymmetry f (OpenCover.map 𝒰 i ≫ g)).hom ≫
        pullback.map (OpenCover.map 𝒰 i ≫ g) f g f (OpenCover.map 𝒰 i) (𝟙 X) (𝟙 Z)
            (_ : (OpenCover.map 𝒰 i ≫ g) ≫ 𝟙 Z = OpenCover.map 𝒰 i ≫ g) (_ : f ≫ 𝟙 Z = 𝟙 X ≫ f) ≫
          (pullbackSymmetry g f).hom) ≫
      pullback.fst
[PROOFSTEP]
simp
[GOAL]
case h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover Y
f : X ⟶ Z
g : Y ⟶ Z
i : 𝒰.J
⊢ pullback.map f (OpenCover.map 𝒰 i ≫ g) f g (𝟙 X) (OpenCover.map 𝒰 i) (𝟙 Z) (_ : f ≫ 𝟙 Z = 𝟙 X ≫ f)
        (_ : (OpenCover.map 𝒰 i ≫ g) ≫ 𝟙 Z = OpenCover.map 𝒰 i ≫ g) ≫
      pullback.snd =
    ((pullbackSymmetry f (OpenCover.map 𝒰 i ≫ g)).hom ≫
        pullback.map (OpenCover.map 𝒰 i ≫ g) f g f (OpenCover.map 𝒰 i) (𝟙 X) (𝟙 Z)
            (_ : (OpenCover.map 𝒰 i ≫ g) ≫ 𝟙 Z = OpenCover.map 𝒰 i ≫ g) (_ : f ≫ 𝟙 Z = 𝟙 X ≫ f) ≫
          (pullbackSymmetry g f).hom) ≫
      pullback.snd
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰X : OpenCover X
𝒰Y : OpenCover Y
f : X ⟶ Z
g : Y ⟶ Z
⊢ OpenCover (pullback f g)
[PROOFSTEP]
fapply
  ((openCoverOfLeft 𝒰X f g).bind fun x => openCoverOfRight 𝒰Y (𝒰X.map x ≫ f) g).copy (𝒰X.J × 𝒰Y.J)
    (fun ij => pullback (𝒰X.map ij.1 ≫ f) (𝒰Y.map ij.2 ≫ g))
    (fun ij => pullback.map _ _ _ _ (𝒰X.map ij.1) (𝒰Y.map ij.2) (𝟙 _) (Category.comp_id _) (Category.comp_id _))
    (Equiv.sigmaEquivProd _ _).symm fun _ => Iso.refl _
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰X : OpenCover X
𝒰Y : OpenCover Y
f : X ⟶ Z
g : Y ⟶ Z
⊢ ∀ (i : 𝒰X.J × 𝒰Y.J),
    pullback.map (OpenCover.map 𝒰X i.fst ≫ f) (OpenCover.map 𝒰Y i.snd ≫ g) f g (OpenCover.map 𝒰X i.fst)
        (OpenCover.map 𝒰Y i.snd) (𝟙 Z) (_ : (OpenCover.map 𝒰X i.fst ≫ f) ≫ 𝟙 Z = OpenCover.map 𝒰X i.fst ≫ f)
        (_ : (OpenCover.map 𝒰Y i.snd ≫ g) ≫ 𝟙 Z = OpenCover.map 𝒰Y i.snd ≫ g) =
      (Iso.refl ((fun ij => pullback (OpenCover.map 𝒰X ij.fst ≫ f) (OpenCover.map 𝒰Y ij.snd ≫ g)) i)).hom ≫
        OpenCover.map (OpenCover.bind (openCoverOfLeft 𝒰X f g) fun x => openCoverOfRight 𝒰Y (OpenCover.map 𝒰X x ≫ f) g)
          (↑(Equiv.sigmaEquivProd 𝒰X.J 𝒰Y.J).symm i)
[PROOFSTEP]
rintro ⟨i, j⟩
[GOAL]
case mk
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰X : OpenCover X
𝒰Y : OpenCover Y
f : X ⟶ Z
g : Y ⟶ Z
i : 𝒰X.J
j : 𝒰Y.J
⊢ pullback.map (OpenCover.map 𝒰X (i, j).fst ≫ f) (OpenCover.map 𝒰Y (i, j).snd ≫ g) f g (OpenCover.map 𝒰X (i, j).fst)
      (OpenCover.map 𝒰Y (i, j).snd) (𝟙 Z)
      (_ : (OpenCover.map 𝒰X (i, j).fst ≫ f) ≫ 𝟙 Z = OpenCover.map 𝒰X (i, j).fst ≫ f)
      (_ : (OpenCover.map 𝒰Y (i, j).snd ≫ g) ≫ 𝟙 Z = OpenCover.map 𝒰Y (i, j).snd ≫ g) =
    (Iso.refl ((fun ij => pullback (OpenCover.map 𝒰X ij.fst ≫ f) (OpenCover.map 𝒰Y ij.snd ≫ g)) (i, j))).hom ≫
      OpenCover.map (OpenCover.bind (openCoverOfLeft 𝒰X f g) fun x => openCoverOfRight 𝒰Y (OpenCover.map 𝒰X x ≫ f) g)
        (↑(Equiv.sigmaEquivProd 𝒰X.J 𝒰Y.J).symm (i, j))
[PROOFSTEP]
apply pullback.hom_ext
[GOAL]
case mk.h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰X : OpenCover X
𝒰Y : OpenCover Y
f : X ⟶ Z
g : Y ⟶ Z
i : 𝒰X.J
j : 𝒰Y.J
⊢ pullback.map (OpenCover.map 𝒰X (i, j).fst ≫ f) (OpenCover.map 𝒰Y (i, j).snd ≫ g) f g (OpenCover.map 𝒰X (i, j).fst)
        (OpenCover.map 𝒰Y (i, j).snd) (𝟙 Z)
        (_ : (OpenCover.map 𝒰X (i, j).fst ≫ f) ≫ 𝟙 Z = OpenCover.map 𝒰X (i, j).fst ≫ f)
        (_ : (OpenCover.map 𝒰Y (i, j).snd ≫ g) ≫ 𝟙 Z = OpenCover.map 𝒰Y (i, j).snd ≫ g) ≫
      pullback.fst =
    ((Iso.refl ((fun ij => pullback (OpenCover.map 𝒰X ij.fst ≫ f) (OpenCover.map 𝒰Y ij.snd ≫ g)) (i, j))).hom ≫
        OpenCover.map (OpenCover.bind (openCoverOfLeft 𝒰X f g) fun x => openCoverOfRight 𝒰Y (OpenCover.map 𝒰X x ≫ f) g)
          (↑(Equiv.sigmaEquivProd 𝒰X.J 𝒰Y.J).symm (i, j))) ≫
      pullback.fst
[PROOFSTEP]
simp
[GOAL]
case mk.h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (OpenCover.map 𝒰 i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰X : OpenCover X
𝒰Y : OpenCover Y
f : X ⟶ Z
g : Y ⟶ Z
i : 𝒰X.J
j : 𝒰Y.J
⊢ pullback.map (OpenCover.map 𝒰X (i, j).fst ≫ f) (OpenCover.map 𝒰Y (i, j).snd ≫ g) f g (OpenCover.map 𝒰X (i, j).fst)
        (OpenCover.map 𝒰Y (i, j).snd) (𝟙 Z)
        (_ : (OpenCover.map 𝒰X (i, j).fst ≫ f) ≫ 𝟙 Z = OpenCover.map 𝒰X (i, j).fst ≫ f)
        (_ : (OpenCover.map 𝒰Y (i, j).snd ≫ g) ≫ 𝟙 Z = OpenCover.map 𝒰Y (i, j).snd ≫ g) ≫
      pullback.snd =
    ((Iso.refl ((fun ij => pullback (OpenCover.map 𝒰X ij.fst ≫ f) (OpenCover.map 𝒰Y ij.snd ≫ g)) (i, j))).hom ≫
        OpenCover.map (OpenCover.bind (openCoverOfLeft 𝒰X f g) fun x => openCoverOfRight 𝒰Y (OpenCover.map 𝒰X x ≫ f) g)
          (↑(Equiv.sigmaEquivProd 𝒰X.J 𝒰Y.J).symm (i, j))) ≫
      pullback.snd
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover Z
f : X ⟶ Z
g : Y ⟶ Z
⊢ OpenCover (pullback f g)
[PROOFSTEP]
apply (openCoverOfLeft (𝒰.pullbackCover f) f g).bind
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover Z
f : X ⟶ Z
g : Y ⟶ Z
⊢ (x : (openCoverOfLeft (OpenCover.pullbackCover 𝒰 f) f g).J) →
    OpenCover (OpenCover.obj (openCoverOfLeft (OpenCover.pullbackCover 𝒰 f) f g) x)
[PROOFSTEP]
intro i
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover Z
f : X ⟶ Z
g : Y ⟶ Z
i : (openCoverOfLeft (OpenCover.pullbackCover 𝒰 f) f g).J
⊢ OpenCover (OpenCover.obj (openCoverOfLeft (OpenCover.pullbackCover 𝒰 f) f g) i)
[PROOFSTEP]
let Xᵢ := pullback f (𝒰.map i)
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover Z
f : X ⟶ Z
g : Y ⟶ Z
i : (openCoverOfLeft (OpenCover.pullbackCover 𝒰 f) f g).J
Xᵢ : Scheme := pullback f (OpenCover.map 𝒰 i)
⊢ OpenCover (OpenCover.obj (openCoverOfLeft (OpenCover.pullbackCover 𝒰 f) f g) i)
[PROOFSTEP]
let Yᵢ := pullback g (𝒰.map i)
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover Z
f : X ⟶ Z
g : Y ⟶ Z
i : (openCoverOfLeft (OpenCover.pullbackCover 𝒰 f) f g).J
Xᵢ : Scheme := pullback f (OpenCover.map 𝒰 i)
Yᵢ : Scheme := pullback g (OpenCover.map 𝒰 i)
⊢ OpenCover (OpenCover.obj (openCoverOfLeft (OpenCover.pullbackCover 𝒰 f) f g) i)
[PROOFSTEP]
let W := pullback (pullback.snd : Yᵢ ⟶ _) (pullback.snd : Xᵢ ⟶ _)
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover Z
f : X ⟶ Z
g : Y ⟶ Z
i : (openCoverOfLeft (OpenCover.pullbackCover 𝒰 f) f g).J
Xᵢ : Scheme := pullback f (OpenCover.map 𝒰 i)
Yᵢ : Scheme := pullback g (OpenCover.map 𝒰 i)
W : Scheme := pullback pullback.snd pullback.snd
⊢ OpenCover (OpenCover.obj (openCoverOfLeft (OpenCover.pullbackCover 𝒰 f) f g) i)
[PROOFSTEP]
have :=
  bigSquareIsPullback (pullback.fst : W ⟶ _) (pullback.fst : Yᵢ ⟶ _) (pullback.snd : Xᵢ ⟶ _) (𝒰.map i) pullback.snd
    pullback.snd g pullback.condition.symm pullback.condition.symm (PullbackCone.flipIsLimit <| pullbackIsPullback _ _)
    (PullbackCone.flipIsLimit <| pullbackIsPullback _ _)
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover Z
f : X ⟶ Z
g : Y ⟶ Z
i : (openCoverOfLeft (OpenCover.pullbackCover 𝒰 f) f g).J
Xᵢ : Scheme := pullback f (OpenCover.map 𝒰 i)
Yᵢ : Scheme := pullback g (OpenCover.map 𝒰 i)
W : Scheme := pullback pullback.snd pullback.snd
this :
  IsLimit
    (PullbackCone.mk pullback.snd (pullback.fst ≫ pullback.fst)
      (_ : pullback.snd ≫ pullback.snd ≫ OpenCover.map 𝒰 i = (pullback.fst ≫ pullback.fst) ≫ g))
⊢ OpenCover (OpenCover.obj (openCoverOfLeft (OpenCover.pullbackCover 𝒰 f) f g) i)
[PROOFSTEP]
refine'
  @openCoverOfIsIso (f :=
    (pullbackSymmetry _ _).hom ≫ (limit.isoLimitCone ⟨_, this⟩).inv ≫ pullback.map _ _ _ _ (𝟙 _) (𝟙 _) (𝟙 _) _ _) ?_
[GOAL]
case refine'_1
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover Z
f : X ⟶ Z
g : Y ⟶ Z
i : (openCoverOfLeft (OpenCover.pullbackCover 𝒰 f) f g).J
Xᵢ : Scheme := pullback f (OpenCover.map 𝒰 i)
Yᵢ : Scheme := pullback g (OpenCover.map 𝒰 i)
W : Scheme := pullback pullback.snd pullback.snd
this :
  IsLimit
    (PullbackCone.mk pullback.snd (pullback.fst ≫ pullback.fst)
      (_ : pullback.snd ≫ pullback.snd ≫ OpenCover.map 𝒰 i = (pullback.fst ≫ pullback.fst) ≫ g))
⊢ (pullback.snd ≫ OpenCover.map 𝒰 i) ≫ 𝟙 Z =
    𝟙 (pullback f (OpenCover.map 𝒰 i)) ≫ OpenCover.map (OpenCover.pullbackCover 𝒰 f) i ≫ f
[PROOFSTEP]
simp only [Category.comp_id, Category.id_comp, ← pullback.condition]
  -- Porting note : `simpa` failed, but this is indeed `rfl`
[GOAL]
case refine'_1
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover Z
f : X ⟶ Z
g : Y ⟶ Z
i : (openCoverOfLeft (OpenCover.pullbackCover 𝒰 f) f g).J
Xᵢ : Scheme := pullback f (OpenCover.map 𝒰 i)
Yᵢ : Scheme := pullback g (OpenCover.map 𝒰 i)
W : Scheme := pullback pullback.snd pullback.snd
this :
  IsLimit
    (PullbackCone.mk pullback.snd (pullback.fst ≫ pullback.fst)
      (_ : pullback.snd ≫ pullback.snd ≫ OpenCover.map 𝒰 i = (pullback.fst ≫ pullback.fst) ≫ g))
⊢ pullback.fst ≫ f = OpenCover.map (OpenCover.pullbackCover 𝒰 f) i ≫ f
[PROOFSTEP]
rfl
[GOAL]
case refine'_2
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover Z
f : X ⟶ Z
g : Y ⟶ Z
i : (openCoverOfLeft (OpenCover.pullbackCover 𝒰 f) f g).J
Xᵢ : Scheme := pullback f (OpenCover.map 𝒰 i)
Yᵢ : Scheme := pullback g (OpenCover.map 𝒰 i)
W : Scheme := pullback pullback.snd pullback.snd
this :
  IsLimit
    (PullbackCone.mk pullback.snd (pullback.fst ≫ pullback.fst)
      (_ : pullback.snd ≫ pullback.snd ≫ OpenCover.map 𝒰 i = (pullback.fst ≫ pullback.fst) ≫ g))
⊢ g ≫ 𝟙 Z = 𝟙 Y ≫ g
[PROOFSTEP]
simp only [Category.comp_id, Category.id_comp]
  -- Porting note : this `IsIso` instance was `inferInstance`
[GOAL]
case refine'_3
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover Z
f : X ⟶ Z
g : Y ⟶ Z
i : (openCoverOfLeft (OpenCover.pullbackCover 𝒰 f) f g).J
Xᵢ : Scheme := pullback f (OpenCover.map 𝒰 i)
Yᵢ : Scheme := pullback g (OpenCover.map 𝒰 i)
W : Scheme := pullback pullback.snd pullback.snd
this :
  IsLimit
    (PullbackCone.mk pullback.snd (pullback.fst ≫ pullback.fst)
      (_ : pullback.snd ≫ pullback.snd ≫ OpenCover.map 𝒰 i = (pullback.fst ≫ pullback.fst) ≫ g))
⊢ IsIso
    ((pullbackSymmetry pullback.snd pullback.snd).hom ≫
      (limit.isoLimitCone
            {
              cone :=
                PullbackCone.mk pullback.snd (pullback.fst ≫ pullback.fst)
                  (_ : pullback.snd ≫ pullback.snd ≫ OpenCover.map 𝒰 i = (pullback.fst ≫ pullback.fst) ≫ g),
              isLimit := this }).inv ≫
        pullback.map (pullback.snd ≫ OpenCover.map 𝒰 i) g (OpenCover.map (OpenCover.pullbackCover 𝒰 f) i ≫ f) g
          (𝟙 (pullback f (OpenCover.map 𝒰 i))) (𝟙 Y) (𝟙 Z)
          (_ :
            (pullback.snd ≫ OpenCover.map 𝒰 i) ≫ 𝟙 Z =
              𝟙 (pullback f (OpenCover.map 𝒰 i)) ≫ OpenCover.map (OpenCover.pullbackCover 𝒰 f) i ≫ f)
          (_ : g ≫ 𝟙 Z = 𝟙 Y ≫ g))
[PROOFSTEP]
apply IsIso.comp_isIso
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover Z
f : X ⟶ Z
g : Y ⟶ Z
⊢ OpenCover (pullback f g)
[PROOFSTEP]
apply
  (openCoverOfBase'.{u, u} 𝒰 f g).copy 𝒰.J
    (fun i => pullback (pullback.snd : pullback f (𝒰.map i) ⟶ _) (pullback.snd : pullback g (𝒰.map i) ⟶ _))
    (fun i => pullback.map _ _ _ _ pullback.fst pullback.fst (𝒰.map i) pullback.condition.symm pullback.condition.symm)
    ((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit).symm) fun _ => Iso.refl _
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover Z
f : X ⟶ Z
g : Y ⟶ Z
⊢ ∀ (i : 𝒰.J),
    pullback.map pullback.snd pullback.snd f g pullback.fst pullback.fst (OpenCover.map 𝒰 i)
        (_ : pullback.snd ≫ OpenCover.map 𝒰 i = pullback.fst ≫ f)
        (_ : pullback.snd ≫ OpenCover.map 𝒰 i = pullback.fst ≫ g) =
      (Iso.refl ((fun i => pullback pullback.snd pullback.snd) i)).hom ≫
        OpenCover.map (openCoverOfBase' 𝒰 f g)
          (↑((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit).symm) i)
[PROOFSTEP]
intro i
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover Z
f : X ⟶ Z
g : Y ⟶ Z
i : 𝒰.J
⊢ pullback.map pullback.snd pullback.snd f g pullback.fst pullback.fst (OpenCover.map 𝒰 i)
      (_ : pullback.snd ≫ OpenCover.map 𝒰 i = pullback.fst ≫ f)
      (_ : pullback.snd ≫ OpenCover.map 𝒰 i = pullback.fst ≫ g) =
    (Iso.refl ((fun i => pullback pullback.snd pullback.snd) i)).hom ≫
      OpenCover.map (openCoverOfBase' 𝒰 f g)
        (↑((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit).symm) i)
[PROOFSTEP]
rw [Iso.refl_hom, Category.id_comp, openCoverOfBase'_map]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover Z
f : X ⟶ Z
g : Y ⟶ Z
i : 𝒰.J
⊢ pullback.map pullback.snd pullback.snd f g pullback.fst pullback.fst (OpenCover.map 𝒰 i)
      (_ : pullback.snd ≫ OpenCover.map 𝒰 i = pullback.fst ≫ f)
      (_ : pullback.snd ≫ OpenCover.map 𝒰 i = pullback.fst ≫ g) =
    (pullbackSymmetry pullback.snd pullback.snd).hom ≫
      (limit.isoLimitCone
            {
              cone :=
                PullbackCone.mk pullback.snd (pullback.fst ≫ pullback.fst)
                  (_ :
                    (pullback.snd ≫ pullback.snd) ≫
                        OpenCover.map 𝒰
                          (↑((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit).symm) i).fst =
                      (pullback.fst ≫ pullback.fst) ≫ g),
              isLimit :=
                bigSquareIsPullback pullback.fst pullback.fst pullback.snd
                  (OpenCover.map 𝒰 (↑((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit).symm) i).fst)
                  pullback.snd pullback.snd g (_ : pullback.snd ≫ pullback.snd = pullback.fst ≫ pullback.snd)
                  (_ :
                    pullback.snd ≫
                        OpenCover.map 𝒰
                          (↑((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit).symm) i).fst =
                      pullback.fst ≫ g)
                  (PullbackCone.flipIsLimit
                    (pullbackIsPullback g
                      (OpenCover.map 𝒰
                        (↑((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit).symm) i).fst)))
                  (PullbackCone.flipIsLimit (pullbackIsPullback pullback.snd pullback.snd)) }).inv ≫
        pullback.map
            (pullback.snd ≫
              OpenCover.map 𝒰 (↑((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit).symm) i).fst)
            g (pullback.fst ≫ f) g
            (𝟙
              (pullback f
                (OpenCover.map 𝒰 (↑((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit).symm) i).fst)))
            (𝟙 Y) (𝟙 Z)
            (_ :
              (pullback.snd ≫
                    OpenCover.map 𝒰 (↑((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit).symm) i).fst) ≫
                  𝟙 Z =
                𝟙
                    (pullback f
                      (OpenCover.map 𝒰
                        (↑((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit).symm) i).fst)) ≫
                  pullback.fst ≫ f)
            (_ : g ≫ 𝟙 Z = 𝟙 Y ≫ g) ≫
          pullback.map (pullback.fst ≫ f) g f g pullback.fst (𝟙 Y) (𝟙 Z)
            (_ :
              (OpenCover.map (OpenCover.pullbackCover 𝒰 f)
                      (↑((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit).symm) i).fst ≫
                    f) ≫
                  𝟙 Z =
                OpenCover.map (OpenCover.pullbackCover 𝒰 f)
                    (↑((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit).symm) i).fst ≫
                  f)
            (_ : g ≫ 𝟙 Z = 𝟙 Y ≫ g)
[PROOFSTEP]
apply pullback.hom_ext
[GOAL]
case h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover Z
f : X ⟶ Z
g : Y ⟶ Z
i : 𝒰.J
⊢ pullback.map pullback.snd pullback.snd f g pullback.fst pullback.fst (OpenCover.map 𝒰 i)
        (_ : pullback.snd ≫ OpenCover.map 𝒰 i = pullback.fst ≫ f)
        (_ : pullback.snd ≫ OpenCover.map 𝒰 i = pullback.fst ≫ g) ≫
      pullback.fst =
    ((pullbackSymmetry pullback.snd pullback.snd).hom ≫
        (limit.isoLimitCone
              {
                cone :=
                  PullbackCone.mk pullback.snd (pullback.fst ≫ pullback.fst)
                    (_ :
                      (pullback.snd ≫ pullback.snd) ≫
                          OpenCover.map 𝒰
                            (↑((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit).symm) i).fst =
                        (pullback.fst ≫ pullback.fst) ≫ g),
                isLimit :=
                  bigSquareIsPullback pullback.fst pullback.fst pullback.snd
                    (OpenCover.map 𝒰 (↑((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit).symm) i).fst)
                    pullback.snd pullback.snd g (_ : pullback.snd ≫ pullback.snd = pullback.fst ≫ pullback.snd)
                    (_ :
                      pullback.snd ≫
                          OpenCover.map 𝒰
                            (↑((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit).symm) i).fst =
                        pullback.fst ≫ g)
                    (PullbackCone.flipIsLimit
                      (pullbackIsPullback g
                        (OpenCover.map 𝒰
                          (↑((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit).symm) i).fst)))
                    (PullbackCone.flipIsLimit (pullbackIsPullback pullback.snd pullback.snd)) }).inv ≫
          pullback.map
              (pullback.snd ≫
                OpenCover.map 𝒰 (↑((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit).symm) i).fst)
              g (pullback.fst ≫ f) g
              (𝟙
                (pullback f
                  (OpenCover.map 𝒰 (↑((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit).symm) i).fst)))
              (𝟙 Y) (𝟙 Z)
              (_ :
                (pullback.snd ≫
                      OpenCover.map 𝒰
                        (↑((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit).symm) i).fst) ≫
                    𝟙 Z =
                  𝟙
                      (pullback f
                        (OpenCover.map 𝒰
                          (↑((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit).symm) i).fst)) ≫
                    pullback.fst ≫ f)
              (_ : g ≫ 𝟙 Z = 𝟙 Y ≫ g) ≫
            pullback.map (pullback.fst ≫ f) g f g pullback.fst (𝟙 Y) (𝟙 Z)
              (_ :
                (OpenCover.map (OpenCover.pullbackCover 𝒰 f)
                        (↑((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit).symm) i).fst ≫
                      f) ≫
                    𝟙 Z =
                  OpenCover.map (OpenCover.pullbackCover 𝒰 f)
                      (↑((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit).symm) i).fst ≫
                    f)
              (_ : g ≫ 𝟙 Z = 𝟙 Y ≫ g)) ≫
      pullback.fst
[PROOFSTEP]
dsimp
[GOAL]
case h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover Z
f : X ⟶ Z
g : Y ⟶ Z
i : 𝒰.J
⊢ pullback.map pullback.snd pullback.snd f g pullback.fst pullback.fst (OpenCover.map 𝒰 i)
        (_ : pullback.snd ≫ OpenCover.map 𝒰 i = pullback.fst ≫ f)
        (_ : pullback.snd ≫ OpenCover.map 𝒰 i = pullback.fst ≫ g) ≫
      pullback.snd =
    ((pullbackSymmetry pullback.snd pullback.snd).hom ≫
        (limit.isoLimitCone
              {
                cone :=
                  PullbackCone.mk pullback.snd (pullback.fst ≫ pullback.fst)
                    (_ :
                      (pullback.snd ≫ pullback.snd) ≫
                          OpenCover.map 𝒰
                            (↑((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit).symm) i).fst =
                        (pullback.fst ≫ pullback.fst) ≫ g),
                isLimit :=
                  bigSquareIsPullback pullback.fst pullback.fst pullback.snd
                    (OpenCover.map 𝒰 (↑((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit).symm) i).fst)
                    pullback.snd pullback.snd g (_ : pullback.snd ≫ pullback.snd = pullback.fst ≫ pullback.snd)
                    (_ :
                      pullback.snd ≫
                          OpenCover.map 𝒰
                            (↑((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit).symm) i).fst =
                        pullback.fst ≫ g)
                    (PullbackCone.flipIsLimit
                      (pullbackIsPullback g
                        (OpenCover.map 𝒰
                          (↑((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit).symm) i).fst)))
                    (PullbackCone.flipIsLimit (pullbackIsPullback pullback.snd pullback.snd)) }).inv ≫
          pullback.map
              (pullback.snd ≫
                OpenCover.map 𝒰 (↑((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit).symm) i).fst)
              g (pullback.fst ≫ f) g
              (𝟙
                (pullback f
                  (OpenCover.map 𝒰 (↑((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit).symm) i).fst)))
              (𝟙 Y) (𝟙 Z)
              (_ :
                (pullback.snd ≫
                      OpenCover.map 𝒰
                        (↑((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit).symm) i).fst) ≫
                    𝟙 Z =
                  𝟙
                      (pullback f
                        (OpenCover.map 𝒰
                          (↑((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit).symm) i).fst)) ≫
                    pullback.fst ≫ f)
              (_ : g ≫ 𝟙 Z = 𝟙 Y ≫ g) ≫
            pullback.map (pullback.fst ≫ f) g f g pullback.fst (𝟙 Y) (𝟙 Z)
              (_ :
                (OpenCover.map (OpenCover.pullbackCover 𝒰 f)
                        (↑((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit).symm) i).fst ≫
                      f) ≫
                    𝟙 Z =
                  OpenCover.map (OpenCover.pullbackCover 𝒰 f)
                      (↑((Equiv.prodPUnit 𝒰.J).symm.trans (Equiv.sigmaEquivProd 𝒰.J PUnit).symm) i).fst ≫
                    f)
              (_ : g ≫ 𝟙 Z = 𝟙 Y ≫ g)) ≫
      pullback.snd
[PROOFSTEP]
dsimp
[GOAL]
case h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover Z
f : X ⟶ Z
g : Y ⟶ Z
i : 𝒰.J
⊢ pullback.map pullback.snd pullback.snd f g pullback.fst pullback.fst (OpenCover.map 𝒰 i)
        (_ : pullback.snd ≫ OpenCover.map 𝒰 i = pullback.fst ≫ f)
        (_ : pullback.snd ≫ OpenCover.map 𝒰 i = pullback.fst ≫ g) ≫
      pullback.fst =
    ((pullbackSymmetry pullback.snd pullback.snd).hom ≫
        (limit.isoLimitCone
              {
                cone :=
                  PullbackCone.mk pullback.snd (pullback.fst ≫ pullback.fst)
                    (_ :
                      (pullback.snd ≫ pullback.snd) ≫
                          OpenCover.map 𝒰 (↑(Equiv.sigmaEquivProd 𝒰.J PUnit).symm (i, PUnit.unit)).fst =
                        (pullback.fst ≫ pullback.fst) ≫ g),
                isLimit :=
                  bigSquareIsPullback pullback.fst pullback.fst pullback.snd
                    (OpenCover.map 𝒰 (↑(Equiv.sigmaEquivProd 𝒰.J PUnit).symm (i, PUnit.unit)).fst) pullback.snd
                    pullback.snd g (_ : pullback.snd ≫ pullback.snd = pullback.fst ≫ pullback.snd)
                    (_ :
                      pullback.snd ≫ OpenCover.map 𝒰 (↑(Equiv.sigmaEquivProd 𝒰.J PUnit).symm (i, PUnit.unit)).fst =
                        pullback.fst ≫ g)
                    (PullbackCone.flipIsLimit
                      (pullbackIsPullback g
                        (OpenCover.map 𝒰 (↑(Equiv.sigmaEquivProd 𝒰.J PUnit).symm (i, PUnit.unit)).fst)))
                    (PullbackCone.flipIsLimit (pullbackIsPullback pullback.snd pullback.snd)) }).inv ≫
          pullback.map (pullback.snd ≫ OpenCover.map 𝒰 (↑(Equiv.sigmaEquivProd 𝒰.J PUnit).symm (i, PUnit.unit)).fst) g
              (pullback.fst ≫ f) g
              (𝟙 (pullback f (OpenCover.map 𝒰 (↑(Equiv.sigmaEquivProd 𝒰.J PUnit).symm (i, PUnit.unit)).fst))) (𝟙 Y)
              (𝟙 Z)
              (_ :
                (pullback.snd ≫ OpenCover.map 𝒰 (↑(Equiv.sigmaEquivProd 𝒰.J PUnit).symm (i, PUnit.unit)).fst) ≫ 𝟙 Z =
                  𝟙 (pullback f (OpenCover.map 𝒰 (↑(Equiv.sigmaEquivProd 𝒰.J PUnit).symm (i, PUnit.unit)).fst)) ≫
                    pullback.fst ≫ f)
              (_ : g ≫ 𝟙 Z = 𝟙 Y ≫ g) ≫
            pullback.map (pullback.fst ≫ f) g f g pullback.fst (𝟙 Y) (𝟙 Z)
              (_ :
                (OpenCover.map (OpenCover.pullbackCover 𝒰 f)
                        (↑(Equiv.sigmaEquivProd 𝒰.J PUnit).symm (i, PUnit.unit)).fst ≫
                      f) ≫
                    𝟙 Z =
                  OpenCover.map (OpenCover.pullbackCover 𝒰 f)
                      (↑(Equiv.sigmaEquivProd 𝒰.J PUnit).symm (i, PUnit.unit)).fst ≫
                    f)
              (_ : g ≫ 𝟙 Z = 𝟙 Y ≫ g)) ≫
      pullback.fst
[PROOFSTEP]
simp only [limit.lift_π, PullbackCone.mk_pt, PullbackCone.mk_π_app, Category.assoc, limit.lift_π_assoc, cospan_left,
  Category.comp_id, limit.isoLimitCone_inv_π, limit.isoLimitCone_inv_π_assoc, pullbackSymmetry_hom_comp_fst_assoc,
  pullbackSymmetry_hom_comp_snd_assoc]
[GOAL]
case h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover Z
f : X ⟶ Z
g : Y ⟶ Z
i : 𝒰.J
⊢ pullback.fst ≫ pullback.fst = pullback.fst ≫ pullback.fst
[PROOFSTEP]
rfl
[GOAL]
case h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover Z
f : X ⟶ Z
g : Y ⟶ Z
i : 𝒰.J
⊢ pullback.map pullback.snd pullback.snd f g pullback.fst pullback.fst (OpenCover.map 𝒰 i)
        (_ : pullback.snd ≫ OpenCover.map 𝒰 i = pullback.fst ≫ f)
        (_ : pullback.snd ≫ OpenCover.map 𝒰 i = pullback.fst ≫ g) ≫
      pullback.snd =
    ((pullbackSymmetry pullback.snd pullback.snd).hom ≫
        (limit.isoLimitCone
              {
                cone :=
                  PullbackCone.mk pullback.snd (pullback.fst ≫ pullback.fst)
                    (_ :
                      (pullback.snd ≫ pullback.snd) ≫
                          OpenCover.map 𝒰 (↑(Equiv.sigmaEquivProd 𝒰.J PUnit).symm (i, PUnit.unit)).fst =
                        (pullback.fst ≫ pullback.fst) ≫ g),
                isLimit :=
                  bigSquareIsPullback pullback.fst pullback.fst pullback.snd
                    (OpenCover.map 𝒰 (↑(Equiv.sigmaEquivProd 𝒰.J PUnit).symm (i, PUnit.unit)).fst) pullback.snd
                    pullback.snd g (_ : pullback.snd ≫ pullback.snd = pullback.fst ≫ pullback.snd)
                    (_ :
                      pullback.snd ≫ OpenCover.map 𝒰 (↑(Equiv.sigmaEquivProd 𝒰.J PUnit).symm (i, PUnit.unit)).fst =
                        pullback.fst ≫ g)
                    (PullbackCone.flipIsLimit
                      (pullbackIsPullback g
                        (OpenCover.map 𝒰 (↑(Equiv.sigmaEquivProd 𝒰.J PUnit).symm (i, PUnit.unit)).fst)))
                    (PullbackCone.flipIsLimit (pullbackIsPullback pullback.snd pullback.snd)) }).inv ≫
          pullback.map (pullback.snd ≫ OpenCover.map 𝒰 (↑(Equiv.sigmaEquivProd 𝒰.J PUnit).symm (i, PUnit.unit)).fst) g
              (pullback.fst ≫ f) g
              (𝟙 (pullback f (OpenCover.map 𝒰 (↑(Equiv.sigmaEquivProd 𝒰.J PUnit).symm (i, PUnit.unit)).fst))) (𝟙 Y)
              (𝟙 Z)
              (_ :
                (pullback.snd ≫ OpenCover.map 𝒰 (↑(Equiv.sigmaEquivProd 𝒰.J PUnit).symm (i, PUnit.unit)).fst) ≫ 𝟙 Z =
                  𝟙 (pullback f (OpenCover.map 𝒰 (↑(Equiv.sigmaEquivProd 𝒰.J PUnit).symm (i, PUnit.unit)).fst)) ≫
                    pullback.fst ≫ f)
              (_ : g ≫ 𝟙 Z = 𝟙 Y ≫ g) ≫
            pullback.map (pullback.fst ≫ f) g f g pullback.fst (𝟙 Y) (𝟙 Z)
              (_ :
                (OpenCover.map (OpenCover.pullbackCover 𝒰 f)
                        (↑(Equiv.sigmaEquivProd 𝒰.J PUnit).symm (i, PUnit.unit)).fst ≫
                      f) ≫
                    𝟙 Z =
                  OpenCover.map (OpenCover.pullbackCover 𝒰 f)
                      (↑(Equiv.sigmaEquivProd 𝒰.J PUnit).symm (i, PUnit.unit)).fst ≫
                    f)
              (_ : g ≫ 𝟙 Z = 𝟙 Y ≫ g)) ≫
      pullback.snd
[PROOFSTEP]
simp only [limit.lift_π, PullbackCone.mk_pt, PullbackCone.mk_π_app, Category.assoc, limit.lift_π_assoc, cospan_left,
  Category.comp_id, limit.isoLimitCone_inv_π, limit.isoLimitCone_inv_π_assoc, pullbackSymmetry_hom_comp_fst_assoc,
  pullbackSymmetry_hom_comp_snd_assoc]
[GOAL]
case h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰✝ : OpenCover X
f✝ : X ⟶ Z
g✝ : Y ⟶ Z
inst✝ : ∀ (i : 𝒰✝.J), HasPullback (OpenCover.map 𝒰✝ i ≫ f✝) g✝
s : PullbackCone f✝ g✝
𝒰 : OpenCover Z
f : X ⟶ Z
g : Y ⟶ Z
i : 𝒰.J
⊢ pullback.snd ≫ pullback.fst = pullback.snd ≫ pullback.fst
[PROOFSTEP]
rfl
[GOAL]
X Y S X' Y' S' : Scheme
f : X ⟶ S
g : Y ⟶ S
f' : X' ⟶ S'
g' : Y' ⟶ S'
i₁ : X ⟶ X'
i₂ : Y ⟶ Y'
i₃ : S ⟶ S'
e₁ : f ≫ i₃ = i₁ ≫ f'
e₂ : g ≫ i₃ = i₂ ≫ g'
inst✝² : IsOpenImmersion i₁
inst✝¹ : IsOpenImmersion i₂
inst✝ : Mono i₃
⊢ IsOpenImmersion (pullback.map f g f' g' i₁ i₂ i₃ e₁ e₂)
[PROOFSTEP]
rw [pullback_map_eq_pullbackFstFstIso_inv]
  -- Porting note : was automatic
[GOAL]
X Y S X' Y' S' : Scheme
f : X ⟶ S
g : Y ⟶ S
f' : X' ⟶ S'
g' : Y' ⟶ S'
i₁ : X ⟶ X'
i₂ : Y ⟶ Y'
i₃ : S ⟶ S'
e₁ : f ≫ i₃ = i₁ ≫ f'
e₂ : g ≫ i₃ = i₂ ≫ g'
inst✝² : IsOpenImmersion i₁
inst✝¹ : IsOpenImmersion i₂
inst✝ : Mono i₃
⊢ IsOpenImmersion ((pullbackFstFstIso f g f' g' i₁ i₂ i₃ e₁ e₂).inv ≫ pullback.snd ≫ pullback.fst)
[PROOFSTEP]
exact PresheafedSpace.IsOpenImmersion.comp _ (hg := PresheafedSpace.IsOpenImmersion.comp _ _)
