l3lab/ntp-mathlib huggingface dataset:
/-- The canonical transition map `(Uᵢ ×[Z] Y) ×[X] Uⱼ ⟶ (Uⱼ ×[Z] Y) ×[X] Uᵢ` given by the fact
that pullbacks are associative and symmetric. -/
def t (i j : 𝒰.J) : v 𝒰 f g i j ⟶ v 𝒰 f g j i := by
  haveI : HasPullback (pullback.snd ≫ 𝒰.map i ≫ f) g :=
    hasPullback_assoc_symm (𝒰.map j) (𝒰.map i) (𝒰.map i ≫ f) g
  haveI : HasPullback (pullback.snd ≫ 𝒰.map j ≫ f) g :=
    hasPullback_assoc_symm (𝒰.map i) (𝒰.map j) (𝒰.map j ≫ f) g
  refine' (pullbackSymmetry _ _).hom ≫ _
  

Proof state:
C : Type u
inst✝¹ : Category.{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

Next tactic:
refine' (pullbackAssoc _ _ _ _).inv ≫ _
/-- The canonical transition map `(Uᵢ ×[Z] Y) ×[X] Uⱼ ⟶ (Uⱼ ×[Z] Y) ×[X] Uᵢ` given by the fact
that pullbacks are associative and symmetric. -/
def t (i j : 𝒰.J) : v 𝒰 f g i j ⟶ v 𝒰 f g j i := by
  haveI : HasPullback (pullback.snd ≫ 𝒰.map i ≫ f) g :=
    hasPullback_assoc_symm (𝒰.map j) (𝒰.map i) (𝒰.map i ≫ f) g
  haveI : HasPullback (pullback.snd ≫ 𝒰.map j ≫ f) g :=
    hasPullback_assoc_symm (𝒰.map i) (𝒰.map j) (𝒰.map j ≫ f) g
  refine' (pullbackSymmetry _ _).hom ≫ _
  refine' (pullbackAssoc _ _ _ _).inv ≫ _
  

Proof state:
C : Type u
inst✝¹ : Category.{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

Next tactic:
change pullback _ _ ⟶ pullback _ _
/-- The canonical transition map `(Uᵢ ×[Z] Y) ×[X] Uⱼ ⟶ (Uⱼ ×[Z] Y) ×[X] Uᵢ` given by the fact
that pullbacks are associative and symmetric. -/
def t (i j : 𝒰.J) : v 𝒰 f g i j ⟶ v 𝒰 f g j i := by
  haveI : HasPullback (pullback.snd ≫ 𝒰.map i ≫ f) g :=
    hasPullback_assoc_symm (𝒰.map j) (𝒰.map i) (𝒰.map i ≫ f) g
  haveI : HasPullback (pullback.snd ≫ 𝒰.map j ≫ f) g :=
    hasPullback_assoc_symm (𝒰.map i) (𝒰.map j) (𝒰.map j ≫ f) g
  refine' (pullbackSymmetry _ _).hom ≫ _
  refine' (pullbackAssoc _ _ _ _).inv ≫ _
  change pullback _ _ ⟶ pullback _ _
  

Proof state:
C : Type u
inst✝¹ : Category.{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)

Next tactic:
refine' _ ≫ (pullbackSymmetry _ _).hom
/-- The canonical transition map `(Uᵢ ×[Z] Y) ×[X] Uⱼ ⟶ (Uⱼ ×[Z] Y) ×[X] Uᵢ` given by the fact
that pullbacks are associative and symmetric. -/
def t (i j : 𝒰.J) : v 𝒰 f g i j ⟶ v 𝒰 f g j i := by
  haveI : HasPullback (pullback.snd ≫ 𝒰.map i ≫ f) g :=
    hasPullback_assoc_symm (𝒰.map j) (𝒰.map i) (𝒰.map i ≫ f) g
  haveI : HasPullback (pullback.snd ≫ 𝒰.map j ≫ f) g :=
    hasPullback_assoc_symm (𝒰.map i) (𝒰.map j) (𝒰.map j ≫ f) g
  refine' (pullbackSymmetry _ _).hom ≫ _
  refine' (pullbackAssoc _ _ _ _).inv ≫ _
  change pullback _ _ ⟶ pullback _ _
  refine' _ ≫ (pullbackSymmetry _ _).hom
  

Proof state:
C : Type u
inst✝¹ : Category.{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)

Next tactic:
refine' _ ≫ (pullbackAssoc _ _ _ _).hom
/-- The canonical transition map `(Uᵢ ×[Z] Y) ×[X] Uⱼ ⟶ (Uⱼ ×[Z] Y) ×[X] Uᵢ` given by the fact
that pullbacks are associative and symmetric. -/
def t (i j : 𝒰.J) : v 𝒰 f g i j ⟶ v 𝒰 f g j i := by
  haveI : HasPullback (pullback.snd ≫ 𝒰.map i ≫ f) g :=
    hasPullback_assoc_symm (𝒰.map j) (𝒰.map i) (𝒰.map i ≫ f) g
  haveI : HasPullback (pullback.snd ≫ 𝒰.map j ≫ f) g :=
    hasPullback_assoc_symm (𝒰.map i) (𝒰.map j) (𝒰.map j ≫ f) g
  refine' (pullbackSymmetry _ _).hom ≫ _
  refine' (pullbackAssoc _ _ _ _).inv ≫ _
  change pullback _ _ ⟶ pullback _ _
  refine' _ ≫ (pullbackSymmetry _ _).hom
  refine' _ ≫ (pullbackAssoc _ _ _ _).hom
  

Proof state:
C : Type u
inst✝¹ : Category.{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

Next tactic:
refine' pullback.map _ _ _ _ (pullbackSymmetry _ _).hom (𝟙 _) (𝟙 _) _ _
/-- The canonical transition map `(Uᵢ ×[Z] Y) ×[X] Uⱼ ⟶ (Uⱼ ×[Z] Y) ×[X] Uᵢ` given by the fact
that pullbacks are associative and symmetric. -/
def t (i j : 𝒰.J) : v 𝒰 f g i j ⟶ v 𝒰 f g j i := by
  haveI : HasPullback (pullback.snd ≫ 𝒰.map i ≫ f) g :=
    hasPullback_assoc_symm (𝒰.map j) (𝒰.map i) (𝒰.map i ≫ f) g
  haveI : HasPullback (pullback.snd ≫ 𝒰.map j ≫ f) g :=
    hasPullback_assoc_symm (𝒰.map i) (𝒰.map j) (𝒰.map j ≫ f) g
  refine' (pullbackSymmetry _ _).hom ≫ _
  refine' (pullbackAssoc _ _ _ _).inv ≫ _
  change pullback _ _ ⟶ pullback _ _
  refine' _ ≫ (pullbackSymmetry _ _).hom
  refine' _ ≫ (pullbackAssoc _ _ _ _).hom
  refine' pullback.map _ _ _ _ (pullbackSymmetry _ _).hom (𝟙 _) (𝟙 _) _ _
  

Proof state:
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

Next tactic:
rw [pullbackSymmetry_hom_comp_snd_assoc, pullback.condition_assoc, Category.comp_id]
/-- The canonical transition map `(Uᵢ ×[Z] Y) ×[X] Uⱼ ⟶ (Uⱼ ×[Z] Y) ×[X] Uᵢ` given by the fact
that pullbacks are associative and symmetric. -/
def t (i j : 𝒰.J) : v 𝒰 f g i j ⟶ v 𝒰 f g j i := by
  haveI : HasPullback (pullback.snd ≫ 𝒰.map i ≫ f) g :=
    hasPullback_assoc_symm (𝒰.map j) (𝒰.map i) (𝒰.map i ≫ f) g
  haveI : HasPullback (pullback.snd ≫ 𝒰.map j ≫ f) g :=
    hasPullback_assoc_symm (𝒰.map i) (𝒰.map j) (𝒰.map j ≫ f) g
  refine' (pullbackSymmetry _ _).hom ≫ _
  refine' (pullbackAssoc _ _ _ _).inv ≫ _
  change pullback _ _ ⟶ pullback _ _
  refine' _ ≫ (pullbackSymmetry _ _).hom
  refine' _ ≫ (pullbackAssoc _ _ _ _).hom
  refine' pullback.map _ _ _ _ (pullbackSymmetry _ _).hom (𝟙 _) (𝟙 _) _ _
  rw [pullbackSymmetry_hom_comp_snd_assoc, pullback.condition_assoc, Category.comp_id]
  

Proof state:
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

Next tactic:
rw [Category.comp_id, Category.id_comp]
@[simp, reassoc]
theorem t_fst_fst (i j : 𝒰.J) : t 𝒰 f g i j ≫ pullback.fst ≫ pullback.fst = pullback.snd := by
  

Proof state:
C : Type u
inst✝¹ : Category.{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

Next tactic:
delta t
@[simp, reassoc]
theorem t_fst_fst (i j : 𝒰.J) : t 𝒰 f g i j ≫ pullback.fst ≫ pullback.fst = pullback.snd := by
  delta t
  -- Porting note : copied from previous definition, otherwise `simp` wouldn't work
  

Proof state:
C : Type u
inst✝¹ : Category.{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

Next tactic:
haveI : HasPullback (pullback.snd ≫ 𝒰.map i ≫ f) g :=
    hasPullback_assoc_symm (𝒰.map j) (𝒰.map i) (𝒰.map i ≫ f) g
@[simp, reassoc]
theorem t_fst_fst (i j : 𝒰.J) : t 𝒰 f g i j ≫ pullback.fst ≫ pullback.fst = pullback.snd := by
  delta t
  -- Porting note : copied from previous definition, otherwise `simp` wouldn't work
  haveI : HasPullback (pullback.snd ≫ 𝒰.map i ≫ f) g :=
    hasPullback_assoc_symm (𝒰.map j) (𝒰.map i) (𝒰.map i ≫ f) g
  

Proof state:
C : Type u
inst✝¹ : Category.{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

Next tactic:
haveI : HasPullback (pullback.snd ≫ 𝒰.map j ≫ f) g :=
    hasPullback_assoc_symm (𝒰.map i) (𝒰.map j) (𝒰.map j ≫ f) g
@[simp, reassoc]
theorem t_fst_fst (i j : 𝒰.J) : t 𝒰 f g i j ≫ pullback.fst ≫ pullback.fst = pullback.snd := by
  delta t
  -- Porting note : copied from previous definition, otherwise `simp` wouldn't work
  haveI : HasPullback (pullback.snd ≫ 𝒰.map i ≫ f) g :=
    hasPullback_assoc_symm (𝒰.map j) (𝒰.map i) (𝒰.map i ≫ f) g
  haveI : HasPullback (pullback.snd ≫ 𝒰.map j ≫ f) g :=
    hasPullback_assoc_symm (𝒰.map i) (𝒰.map j) (𝒰.map j ≫ f) g
  

Proof state:
C : Type u
inst✝¹ : Category.{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

Next tactic:
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]
@[simp, reassoc]
theorem t_fst_snd (i j : 𝒰.J) :
    t 𝒰 f g i j ≫ pullback.fst ≫ pullback.snd = pullback.fst ≫ pullback.snd := by
  

Proof state:
C : Type u
inst✝¹ : Category.{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

Next tactic:
delta t
@[simp, reassoc]
theorem t_fst_snd (i j : 𝒰.J) :
    t 𝒰 f g i j ≫ pullback.fst ≫ pullback.snd = pullback.fst ≫ pullback.snd := by
  delta t
  -- Porting note : copied from previous definition, otherwise `simp` wouldn't work
  

Proof state:
C : Type u
inst✝¹ : Category.{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

Next tactic:
haveI : HasPullback (pullback.snd ≫ 𝒰.map i ≫ f) g :=
    hasPullback_assoc_symm (𝒰.map j) (𝒰.map i) (𝒰.map i ≫ f) g
@[simp, reassoc]
theorem t_fst_snd (i j : 𝒰.J) :
    t 𝒰 f g i j ≫ pullback.fst ≫ pullback.snd = pullback.fst ≫ pullback.snd := by
  delta t
  -- Porting note : copied from previous definition, otherwise `simp` wouldn't work
  haveI : HasPullback (pullback.snd ≫ 𝒰.map i ≫ f) g :=
    hasPullback_assoc_symm (𝒰.map j) (𝒰.map i) (𝒰.map i ≫ f) g
  

Proof state:
C : Type u
inst✝¹ : Category.{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

Next tactic:
haveI : HasPullback (pullback.snd ≫ 𝒰.map j ≫ f) g :=
    hasPullback_assoc_symm (𝒰.map i) (𝒰.map j) (𝒰.map j ≫ f) g
@[simp, reassoc]
theorem t_fst_snd (i j : 𝒰.J) :
    t 𝒰 f g i j ≫ pullback.fst ≫ pullback.snd = pullback.fst ≫ pullback.snd := by
  delta t
  -- Porting note : copied from previous definition, otherwise `simp` wouldn't work
  haveI : HasPullback (pullback.snd ≫ 𝒰.map i ≫ f) g :=
    hasPullback_assoc_symm (𝒰.map j) (𝒰.map i) (𝒰.map i ≫ f) g
  haveI : HasPullback (pullback.snd ≫ 𝒰.map j ≫ f) g :=
    hasPullback_assoc_symm (𝒰.map i) (𝒰.map j) (𝒰.map j ≫ f) g
  

Proof state:
C : Type u
inst✝¹ : Category.{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

Next tactic:
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]
@[simp, reassoc]
theorem t_snd (i j : 𝒰.J) : t 𝒰 f g i j ≫ pullback.snd = pullback.fst ≫ pullback.fst := by
  

Proof state:
C : Type u
inst✝¹ : Category.{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

Next tactic:
delta t
@[simp, reassoc]
theorem t_snd (i j : 𝒰.J) : t 𝒰 f g i j ≫ pullback.snd = pullback.fst ≫ pullback.fst := by
  delta t
  -- Porting note : copied from previous definition, otherwise `simp` wouldn't work
  

Proof state:
C : Type u
inst✝¹ : Category.{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

Next tactic:
haveI : HasPullback (pullback.snd ≫ 𝒰.map i ≫ f) g :=
    hasPullback_assoc_symm (𝒰.map j) (𝒰.map i) (𝒰.map i ≫ f) g
@[simp, reassoc]
theorem t_snd (i j : 𝒰.J) : t 𝒰 f g i j ≫ pullback.snd = pullback.fst ≫ pullback.fst := by
  delta t
  -- Porting note : copied from previous definition, otherwise `simp` wouldn't work
  haveI : HasPullback (pullback.snd ≫ 𝒰.map i ≫ f) g :=
    hasPullback_assoc_symm (𝒰.map j) (𝒰.map i) (𝒰.map i ≫ f) g
  

Proof state:
C : Type u
inst✝¹ : Category.{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

Next tactic:
haveI : HasPullback (pullback.snd ≫ 𝒰.map j ≫ f) g :=
    hasPullback_assoc_symm (𝒰.map i) (𝒰.map j) (𝒰.map j ≫ f) g
@[simp, reassoc]
theorem t_snd (i j : 𝒰.J) : t 𝒰 f g i j ≫ pullback.snd = pullback.fst ≫ pullback.fst := by
  delta t
  -- Porting note : copied from previous definition, otherwise `simp` wouldn't work
  haveI : HasPullback (pullback.snd ≫ 𝒰.map i ≫ f) g :=
    hasPullback_assoc_symm (𝒰.map j) (𝒰.map i) (𝒰.map i ≫ f) g
  haveI : HasPullback (pullback.snd ≫ 𝒰.map j ≫ f) g :=
    hasPullback_assoc_symm (𝒰.map i) (𝒰.map j) (𝒰.map j ≫ f) g
  

Proof state:
C : Type u
inst✝¹ : Category.{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

Next tactic:
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]
theorem t_id (i : 𝒰.J) : t 𝒰 f g i i = 𝟙 _ := by
  

Proof state:
C : Type u
inst✝¹ : Category.{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)

Next tactic:
apply pullback.hom_ext