l3lab/ntp-mathlib huggingface dataset:
theorem t_id (i : 𝒰.J) : t 𝒰 f g i i = 𝟙 _ := by
  apply pullback.hom_ext <;> 

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

Next tactic:
rw [Category.id_comp]
theorem t_id (i : 𝒰.J) : t 𝒰 f g i i = 𝟙 _ := by
  apply pullback.hom_ext <;> 

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

Next tactic:
rw [Category.id_comp]
theorem t_id (i : 𝒰.J) : t 𝒰 f g i i = 𝟙 _ := by
  apply pullback.hom_ext <;> rw [Category.id_comp]
  

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

Next tactic:
apply pullback.hom_ext
theorem t_id (i : 𝒰.J) : t 𝒰 f g i i = 𝟙 _ := by
  apply pullback.hom_ext <;> rw [Category.id_comp]
  apply pullback.hom_ext
  · 

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

Next tactic:
rw [← cancel_mono (𝒰.map i)]
theorem t_id (i : 𝒰.J) : t 𝒰 f g i i = 𝟙 _ := by
  apply pullback.hom_ext <;> rw [Category.id_comp]
  apply pullback.hom_ext
  · rw [← cancel_mono (𝒰.map i)]; 

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

Next tactic:
simp only [pullback.condition, Category.assoc, t_fst_fst]
theorem t_id (i : 𝒰.J) : t 𝒰 f g i i = 𝟙 _ := by
  apply pullback.hom_ext <;> rw [Category.id_comp]
  apply pullback.hom_ext
  · rw [← cancel_mono (𝒰.map i)]; simp only [pullback.condition, Category.assoc, t_fst_fst]
  · 

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

Next tactic:
simp only [Category.assoc, t_fst_snd]
theorem t_id (i : 𝒰.J) : t 𝒰 f g i i = 𝟙 _ := by
  apply pullback.hom_ext <;> rw [Category.id_comp]
  apply pullback.hom_ext
  · rw [← cancel_mono (𝒰.map i)]; simp only [pullback.condition, Category.assoc, t_fst_fst]
  · simp only [Category.assoc, t_fst_snd]
  · 

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

Next tactic:
rw [← cancel_mono (𝒰.map i)]
theorem t_id (i : 𝒰.J) : t 𝒰 f g i i = 𝟙 _ := by
  apply pullback.hom_ext <;> rw [Category.id_comp]
  apply pullback.hom_ext
  · rw [← cancel_mono (𝒰.map i)]; simp only [pullback.condition, Category.assoc, t_fst_fst]
  · simp only [Category.assoc, t_fst_snd]
  · rw [← cancel_mono (𝒰.map i)]; 

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

Next tactic:
simp only [pullback.condition, t_snd, Category.assoc]
/-- The map `((Xᵢ ×[Z] Y) ×[X] Xⱼ) ×[Xᵢ ×[Z] Y] ((Xᵢ ×[Z] Y) ×[X] Xₖ)` ⟶
  `((Xⱼ ×[Z] Y) ×[X] Xₖ) ×[Xⱼ ×[Z] Y] ((Xⱼ ×[Z] Y) ×[X] Xᵢ)` needed for gluing   -/
def t' (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) := 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 k : 𝒰.J
⊢ pullback (fV 𝒰 f g i j) (fV 𝒰 f g i k) ⟶ pullback (fV 𝒰 f g j k) (fV 𝒰 f g j i)

Next tactic:
refine' (pullbackRightPullbackFstIso _ _ _).hom ≫ _
/-- The map `((Xᵢ ×[Z] Y) ×[X] Xⱼ) ×[Xᵢ ×[Z] Y] ((Xᵢ ×[Z] Y) ×[X] Xₖ)` ⟶
  `((Xⱼ ×[Z] Y) ×[X] Xₖ) ×[Xⱼ ×[Z] Y] ((Xⱼ ×[Z] Y) ×[X] Xᵢ)` needed for gluing   -/
def t' (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) := by
  refine' (pullbackRightPullbackFstIso _ _ _).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 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)

Next tactic:
refine' _ ≫ (pullbackSymmetry _ _).hom
/-- The map `((Xᵢ ×[Z] Y) ×[X] Xⱼ) ×[Xᵢ ×[Z] Y] ((Xᵢ ×[Z] Y) ×[X] Xₖ)` ⟶
  `((Xⱼ ×[Z] Y) ×[X] Xₖ) ×[Xⱼ ×[Z] Y] ((Xⱼ ×[Z] Y) ×[X] Xᵢ)` needed for gluing   -/
def t' (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) := by
  refine' (pullbackRightPullbackFstIso _ _ _).hom ≫ _
  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 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)

Next tactic:
refine' _ ≫ (pullbackRightPullbackFstIso _ _ _).inv
/-- The map `((Xᵢ ×[Z] Y) ×[X] Xⱼ) ×[Xᵢ ×[Z] Y] ((Xᵢ ×[Z] Y) ×[X] Xₖ)` ⟶
  `((Xⱼ ×[Z] Y) ×[X] Xₖ) ×[Xⱼ ×[Z] Y] ((Xⱼ ×[Z] Y) ×[X] Xᵢ)` needed for gluing   -/
def t' (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) := by
  refine' (pullbackRightPullbackFstIso _ _ _).hom ≫ _
  refine' _ ≫ (pullbackSymmetry _ _).hom
  refine' _ ≫ (pullbackRightPullbackFstIso _ _ _).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 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)

Next tactic:
refine' pullback.map _ _ _ _ (t 𝒰 f g i j) (𝟙 _) (𝟙 _) _ _
/-- The map `((Xᵢ ×[Z] Y) ×[X] Xⱼ) ×[Xᵢ ×[Z] Y] ((Xᵢ ×[Z] Y) ×[X] Xₖ)` ⟶
  `((Xⱼ ×[Z] Y) ×[X] Xₖ) ×[Xⱼ ×[Z] Y] ((Xⱼ ×[Z] Y) ×[X] Xᵢ)` needed for gluing   -/
def t' (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) := by
  refine' (pullbackRightPullbackFstIso _ _ _).hom ≫ _
  refine' _ ≫ (pullbackSymmetry _ _).hom
  refine' _ ≫ (pullbackRightPullbackFstIso _ _ _).inv
  refine' pullback.map _ _ _ _ (t 𝒰 f g i j) (𝟙 _) (𝟙 _) _ _
  · 

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 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

Next tactic:
simp only [← pullback.condition, Category.comp_id, t_fst_fst_assoc]
/-- The map `((Xᵢ ×[Z] Y) ×[X] Xⱼ) ×[Xᵢ ×[Z] Y] ((Xᵢ ×[Z] Y) ×[X] Xₖ)` ⟶
  `((Xⱼ ×[Z] Y) ×[X] Xₖ) ×[Xⱼ ×[Z] Y] ((Xⱼ ×[Z] Y) ×[X] Xᵢ)` needed for gluing   -/
def t' (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) := by
  refine' (pullbackRightPullbackFstIso _ _ _).hom ≫ _
  refine' _ ≫ (pullbackSymmetry _ _).hom
  refine' _ ≫ (pullbackRightPullbackFstIso _ _ _).inv
  refine' pullback.map _ _ _ _ (t 𝒰 f g i j) (𝟙 _) (𝟙 _) _ _
  · simp only [← pullback.condition, Category.comp_id, t_fst_fst_assoc]
  · 

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 k : 𝒰.J
⊢ OpenCover.map 𝒰 k ≫ 𝟙 X = 𝟙 (OpenCover.obj 𝒰 k) ≫ OpenCover.map 𝒰 k

Next tactic:
simp only [Category.comp_id, Category.id_comp]
@[simp, reassoc]
theorem t'_fst_fst_fst (i j k : 𝒰.J) :
    t' 𝒰 f g i j k ≫ pullback.fst ≫ pullback.fst ≫ 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 k : 𝒰.J
⊢ t' 𝒰 f g i j k ≫ pullback.fst ≫ pullback.fst ≫ pullback.fst = pullback.fst ≫ pullback.snd

Next tactic:
delta t'
@[simp, reassoc]
theorem t'_fst_fst_fst (i j k : 𝒰.J) :
    t' 𝒰 f g i j k ≫ pullback.fst ≫ pullback.fst ≫ pullback.fst = pullback.fst ≫ pullback.snd := by
  delta t'
  

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 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

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

Next tactic:
delta t'
@[simp, reassoc]
theorem t'_fst_fst_snd (i j k : 𝒰.J) :
    t' 𝒰 f g i j k ≫ pullback.fst ≫ pullback.fst ≫ pullback.snd =
      pullback.fst ≫ pullback.fst ≫ pullback.snd := by
  delta t'
  

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 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

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

Next tactic:
delta t'
@[simp, reassoc]
theorem t'_fst_snd (i j k : 𝒰.J) :
    t' 𝒰 f g i j k ≫ pullback.fst ≫ pullback.snd = pullback.snd ≫ pullback.snd := by
  delta t'
  

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 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

Next tactic:
simp only [Category.comp_id, Category.assoc, pullbackSymmetry_hom_comp_fst_assoc,
    pullbackRightPullbackFstIso_inv_snd_snd, pullback.lift_snd,
    pullbackRightPullbackFstIso_hom_snd]
@[simp, reassoc]
theorem t'_snd_fst_fst (i j k : 𝒰.J) :
    t' 𝒰 f g i j k ≫ pullback.snd ≫ pullback.fst ≫ 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 k : 𝒰.J
⊢ t' 𝒰 f g i j k ≫ pullback.snd ≫ pullback.fst ≫ pullback.fst = pullback.fst ≫ pullback.snd

Next tactic:
delta t'
@[simp, reassoc]
theorem t'_snd_fst_fst (i j k : 𝒰.J) :
    t' 𝒰 f g i j k ≫ pullback.snd ≫ pullback.fst ≫ pullback.fst = pullback.fst ≫ pullback.snd := by
  delta t'
  

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 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

Next tactic:
simp only [Category.assoc, pullbackSymmetry_hom_comp_snd_assoc,
    pullbackRightPullbackFstIso_inv_fst_assoc, pullback.lift_fst_assoc, t_fst_fst,
    pullbackRightPullbackFstIso_hom_fst_assoc]
@[simp, reassoc]
theorem t'_snd_fst_snd (i j k : 𝒰.J) :
    t' 𝒰 f g i j k ≫ pullback.snd ≫ pullback.fst ≫ pullback.snd =
      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 k : 𝒰.J
⊢ t' 𝒰 f g i j k ≫ pullback.snd ≫ pullback.fst ≫ pullback.snd = pullback.fst ≫ pullback.fst ≫ pullback.snd

Next tactic:
delta t'
@[simp, reassoc]
theorem t'_snd_fst_snd (i j k : 𝒰.J) :
    t' 𝒰 f g i j k ≫ pullback.snd ≫ pullback.fst ≫ pullback.snd =
      pullback.fst ≫ pullback.fst ≫ pullback.snd := by
  delta t'
  

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 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

Next tactic:
simp only [Category.assoc, pullbackSymmetry_hom_comp_snd_assoc,
    pullbackRightPullbackFstIso_inv_fst_assoc, pullback.lift_fst_assoc, t_fst_snd,
    pullbackRightPullbackFstIso_hom_fst_assoc]
@[simp, reassoc]
theorem t'_snd_snd (i j k : 𝒰.J) :
    t' 𝒰 f g i j k ≫ pullback.snd ≫ pullback.snd = pullback.fst ≫ 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 k : 𝒰.J
⊢ t' 𝒰 f g i j k ≫ pullback.snd ≫ pullback.snd = pullback.fst ≫ pullback.fst ≫ pullback.fst

Next tactic:
delta t'
@[simp, reassoc]
theorem t'_snd_snd (i j k : 𝒰.J) :
    t' 𝒰 f g i j k ≫ pullback.snd ≫ pullback.snd = pullback.fst ≫ pullback.fst ≫ pullback.fst := by
  delta t'
  

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 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

Next tactic:
simp only [Category.assoc, pullbackSymmetry_hom_comp_snd_assoc,
    pullbackRightPullbackFstIso_inv_fst_assoc, pullback.lift_fst_assoc, t_snd,
    pullbackRightPullbackFstIso_hom_fst_assoc]
theorem cocycle_fst_fst_fst (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 :=
  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 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

Next tactic:
simp only [t'_fst_fst_fst, t'_fst_snd, t'_snd_snd]
theorem cocycle_fst_fst_snd (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 :=
  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 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

Next tactic:
simp only [t'_fst_fst_snd]
theorem cocycle_fst_snd (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 :=
  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 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

Next tactic:
simp only [t'_fst_snd, t'_snd_snd, t'_fst_fst_fst]
theorem cocycle_snd_fst_fst (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 := 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 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

Next tactic:
rw [← cancel_mono (𝒰.map i)]
theorem cocycle_snd_fst_fst (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 := by
  rw [← cancel_mono (𝒰.map i)]
  

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 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

Next tactic:
simp only [pullback.condition_assoc, t'_snd_fst_fst, t'_fst_snd, t'_snd_snd]
theorem cocycle_snd_fst_snd (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 :=
  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 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

Next tactic:
simp only [pullback.condition_assoc, t'_snd_fst_snd]
theorem cocycle_snd_snd (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 :=
  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 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

Next tactic:
simp only [t'_snd_snd, t'_fst_fst_fst, t'_fst_snd]
theorem cocycle (i j k : 𝒰.J) : t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j = 𝟙 _ := 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 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))

Next tactic:
apply pullback.hom_ext