File: Mathlib/AlgebraicGeometry/Pullbacks.lean

full_name: AlgebraicGeometry.Scheme.Pullback.v
code: /-- The intersection of `Uᵢ ×[Z] Y` and `Uⱼ ×[Z] Y` is given by (Uᵢ ×[Z] Y) ×[X] Uⱼ -/
def v (i j : 𝒰.J) : Scheme 
goal: AlgebraicGeometry.Scheme

full_name: AlgebraicGeometry.Scheme.Pullback.t
code: /-- 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 
goal: AlgebraicGeometry.Scheme.Pullback.v 𝒰 f g i j ⟶ AlgebraicGeometry.Scheme.Pullback.v 𝒰 f g j i

full_name: AlgebraicGeometry.Scheme.Pullback.t_fst_fst
code: @[simp, reassoc]
theorem t_fst_fst (i j : 𝒰.J) : t 𝒰 f g i j ≫ pullback.fst _ _ ≫ pullback.fst _ _ =
    pullback.snd _ _ 
goal: AlgebraicGeometry.Scheme.Pullback.t 𝒰 f g i j ≫
    CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pullback.fst (𝒰.map j ≫ f) g ≫ 𝒰.map j) (𝒰.map i) ≫
      CategoryTheory.Limits.pullback.fst (𝒰.map j ≫ f) g =
  CategoryTheory.Limits.pullback.snd (CategoryTheory.Limits.pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j)

full_name: AlgebraicGeometry.Scheme.Pullback.t_fst_snd
code: @[simp, reassoc]
theorem t_fst_snd (i j : 𝒰.J) :
    t 𝒰 f g i j ≫ pullback.fst _ _ ≫ pullback.snd _ _ = pullback.fst _ _ ≫ pullback.snd _ _ 
goal: AlgebraicGeometry.Scheme.Pullback.t 𝒰 f g i j ≫
    CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pullback.fst (𝒰.map j ≫ f) g ≫ 𝒰.map j) (𝒰.map i) ≫
      CategoryTheory.Limits.pullback.snd (𝒰.map j ≫ f) g =
  CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j) ≫
    CategoryTheory.Limits.pullback.snd (𝒰.map i ≫ f) g

full_name: AlgebraicGeometry.Scheme.Pullback.t_snd
code: @[simp, reassoc]
theorem t_snd (i j : 𝒰.J) : t 𝒰 f g i j ≫ pullback.snd _ _ =
    pullback.fst _ _ ≫ pullback.fst _ _ 
goal: AlgebraicGeometry.Scheme.Pullback.t 𝒰 f g i j ≫
    CategoryTheory.Limits.pullback.snd (CategoryTheory.Limits.pullback.fst (𝒰.map j ≫ f) g ≫ 𝒰.map j) (𝒰.map i) =
  CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j) ≫
    CategoryTheory.Limits.pullback.fst (𝒰.map i ≫ f) g

full_name: AlgebraicGeometry.Scheme.Pullback.t_id
code: theorem t_id (i : 𝒰.J) : t 𝒰 f g i i = 𝟙 _ 
goal: AlgebraicGeometry.Scheme.Pullback.t 𝒰 f g i i = 𝟙 (AlgebraicGeometry.Scheme.Pullback.v 𝒰 f g i i)

full_name: AlgebraicGeometry.Scheme.Pullback.fV
code: /-- The inclusion map of `V i j = (Uᵢ ×[Z] Y) ×[X] Uⱼ ⟶ Uᵢ ×[Z] Y`-/
abbrev fV (i j : 𝒰.J) : v 𝒰 f g i j ⟶ pullback (𝒰.map i ≫ f) g 
goal: AlgebraicGeometry.Scheme.Pullback.v 𝒰 f g i j ⟶ CategoryTheory.Limits.pullback (𝒰.map i ≫ f) g

full_name: AlgebraicGeometry.Scheme.Pullback.t'
code: /-- 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) 
goal: CategoryTheory.Limits.pullback (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i j)
    (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i k) ⟶
  CategoryTheory.Limits.pullback (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g j k)
    (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g j i)

full_name: AlgebraicGeometry.Scheme.Pullback.t'_fst_fst_fst
code: @[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 _ _ 
goal: AlgebraicGeometry.Scheme.Pullback.t' 𝒰 f g i j k ≫
    CategoryTheory.Limits.pullback.fst (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g j k)
        (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g j i) ≫
      CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pullback.fst (𝒰.map j ≫ f) g ≫ 𝒰.map j) (𝒰.map k) ≫
        CategoryTheory.Limits.pullback.fst (𝒰.map j ≫ f) g =
  CategoryTheory.Limits.pullback.fst (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i j)
      (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i k) ≫
    CategoryTheory.Limits.pullback.snd (CategoryTheory.Limits.pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j)

full_name: AlgebraicGeometry.Scheme.Pullback.t'_fst_fst_snd
code: @[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 _ _ 
goal: AlgebraicGeometry.Scheme.Pullback.t' 𝒰 f g i j k ≫
    CategoryTheory.Limits.pullback.fst (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g j k)
        (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g j i) ≫
      CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pullback.fst (𝒰.map j ≫ f) g ≫ 𝒰.map j) (𝒰.map k) ≫
        CategoryTheory.Limits.pullback.snd (𝒰.map j ≫ f) g =
  CategoryTheory.Limits.pullback.fst (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i j)
      (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i k) ≫
    CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j) ≫
      CategoryTheory.Limits.pullback.snd (𝒰.map i ≫ f) g

full_name: AlgebraicGeometry.Scheme.Pullback.t'_fst_snd
code: @[simp, reassoc]
theorem t'_fst_snd (i j k : 𝒰.J) :
    t' 𝒰 f g i j k ≫ pullback.fst _ _ ≫ pullback.snd _ _ =
      pullback.snd _ _ ≫ pullback.snd _ _ 
goal: AlgebraicGeometry.Scheme.Pullback.t' 𝒰 f g i j k ≫
    CategoryTheory.Limits.pullback.fst (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g j k)
        (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g j i) ≫
      CategoryTheory.Limits.pullback.snd (CategoryTheory.Limits.pullback.fst (𝒰.map j ≫ f) g ≫ 𝒰.map j) (𝒰.map k) =
  CategoryTheory.Limits.pullback.snd (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i j)
      (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i k) ≫
    CategoryTheory.Limits.pullback.snd (CategoryTheory.Limits.pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map k)

full_name: AlgebraicGeometry.Scheme.Pullback.t'_snd_fst_fst
code: @[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 _ _ 
goal: AlgebraicGeometry.Scheme.Pullback.t' 𝒰 f g i j k ≫
    CategoryTheory.Limits.pullback.snd (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g j k)
        (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g j i) ≫
      CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pullback.fst (𝒰.map j ≫ f) g ≫ 𝒰.map j) (𝒰.map i) ≫
        CategoryTheory.Limits.pullback.fst (𝒰.map j ≫ f) g =
  CategoryTheory.Limits.pullback.fst (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i j)
      (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i k) ≫
    CategoryTheory.Limits.pullback.snd (CategoryTheory.Limits.pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j)

full_name: AlgebraicGeometry.Scheme.Pullback.t'_snd_fst_snd
code: @[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 _ _ 
goal: AlgebraicGeometry.Scheme.Pullback.t' 𝒰 f g i j k ≫
    CategoryTheory.Limits.pullback.snd (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g j k)
        (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g j i) ≫
      CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pullback.fst (𝒰.map j ≫ f) g ≫ 𝒰.map j) (𝒰.map i) ≫
        CategoryTheory.Limits.pullback.snd (𝒰.map j ≫ f) g =
  CategoryTheory.Limits.pullback.fst (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i j)
      (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i k) ≫
    CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j) ≫
      CategoryTheory.Limits.pullback.snd (𝒰.map i ≫ f) g

full_name: AlgebraicGeometry.Scheme.Pullback.t'_snd_snd
code: @[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 _ _ 
goal: AlgebraicGeometry.Scheme.Pullback.t' 𝒰 f g i j k ≫
    CategoryTheory.Limits.pullback.snd (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g j k)
        (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g j i) ≫
      CategoryTheory.Limits.pullback.snd (CategoryTheory.Limits.pullback.fst (𝒰.map j ≫ f) g ≫ 𝒰.map j) (𝒰.map i) =
  CategoryTheory.Limits.pullback.fst (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i j)
      (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i k) ≫
    CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j) ≫
      CategoryTheory.Limits.pullback.fst (𝒰.map i ≫ f) g

full_name: AlgebraicGeometry.Scheme.Pullback.cocycle_fst_fst_fst
code: 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 _ _ 
goal: AlgebraicGeometry.Scheme.Pullback.t' 𝒰 f g i j k ≫
    AlgebraicGeometry.Scheme.Pullback.t' 𝒰 f g j k i ≫
      AlgebraicGeometry.Scheme.Pullback.t' 𝒰 f g k i j ≫
        CategoryTheory.Limits.pullback.fst (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i j)
            (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i k) ≫
          CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j) ≫
            CategoryTheory.Limits.pullback.fst (𝒰.map i ≫ f) g =
  CategoryTheory.Limits.pullback.fst (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i j)
      (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i k) ≫
    CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j) ≫
      CategoryTheory.Limits.pullback.fst (𝒰.map i ≫ f) g

full_name: AlgebraicGeometry.Scheme.Pullback.cocycle_fst_fst_snd
code: 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 _ _ 
goal: AlgebraicGeometry.Scheme.Pullback.t' 𝒰 f g i j k ≫
    AlgebraicGeometry.Scheme.Pullback.t' 𝒰 f g j k i ≫
      AlgebraicGeometry.Scheme.Pullback.t' 𝒰 f g k i j ≫
        CategoryTheory.Limits.pullback.fst (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i j)
            (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i k) ≫
          CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j) ≫
            CategoryTheory.Limits.pullback.snd (𝒰.map i ≫ f) g =
  CategoryTheory.Limits.pullback.fst (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i j)
      (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i k) ≫
    CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j) ≫
      CategoryTheory.Limits.pullback.snd (𝒰.map i ≫ f) g

full_name: AlgebraicGeometry.Scheme.Pullback.cocycle_fst_snd
code: 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 _ _ 
goal: AlgebraicGeometry.Scheme.Pullback.t' 𝒰 f g i j k ≫
    AlgebraicGeometry.Scheme.Pullback.t' 𝒰 f g j k i ≫
      AlgebraicGeometry.Scheme.Pullback.t' 𝒰 f g k i j ≫
        CategoryTheory.Limits.pullback.fst (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i j)
            (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i k) ≫
          CategoryTheory.Limits.pullback.snd (CategoryTheory.Limits.pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j) =
  CategoryTheory.Limits.pullback.fst (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i j)
      (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i k) ≫
    CategoryTheory.Limits.pullback.snd (CategoryTheory.Limits.pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j)

full_name: AlgebraicGeometry.Scheme.Pullback.cocycle_snd_fst_fst
code: 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 _ _ 
goal: AlgebraicGeometry.Scheme.Pullback.t' 𝒰 f g i j k ≫
    AlgebraicGeometry.Scheme.Pullback.t' 𝒰 f g j k i ≫
      AlgebraicGeometry.Scheme.Pullback.t' 𝒰 f g k i j ≫
        CategoryTheory.Limits.pullback.snd (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i j)
            (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i k) ≫
          CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map k) ≫
            CategoryTheory.Limits.pullback.fst (𝒰.map i ≫ f) g =
  CategoryTheory.Limits.pullback.snd (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i j)
      (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i k) ≫
    CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map k) ≫
      CategoryTheory.Limits.pullback.fst (𝒰.map i ≫ f) g

full_name: AlgebraicGeometry.Scheme.Pullback.cocycle_snd_fst_snd
code: 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 _ _ 
goal: AlgebraicGeometry.Scheme.Pullback.t' 𝒰 f g i j k ≫
    AlgebraicGeometry.Scheme.Pullback.t' 𝒰 f g j k i ≫
      AlgebraicGeometry.Scheme.Pullback.t' 𝒰 f g k i j ≫
        CategoryTheory.Limits.pullback.snd (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i j)
            (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i k) ≫
          CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map k) ≫
            CategoryTheory.Limits.pullback.snd (𝒰.map i ≫ f) g =
  CategoryTheory.Limits.pullback.snd (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i j)
      (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i k) ≫
    CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map k) ≫
      CategoryTheory.Limits.pullback.snd (𝒰.map i ≫ f) g

full_name: AlgebraicGeometry.Scheme.Pullback.cocycle_snd_snd
code: 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 _ _ 
goal: AlgebraicGeometry.Scheme.Pullback.t' 𝒰 f g i j k ≫
    AlgebraicGeometry.Scheme.Pullback.t' 𝒰 f g j k i ≫
      AlgebraicGeometry.Scheme.Pullback.t' 𝒰 f g k i j ≫
        CategoryTheory.Limits.pullback.snd (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i j)
            (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i k) ≫
          CategoryTheory.Limits.pullback.snd (CategoryTheory.Limits.pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map k) =
  CategoryTheory.Limits.pullback.snd (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i j)
      (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i k) ≫
    CategoryTheory.Limits.pullback.snd (CategoryTheory.Limits.pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map k)

full_name: AlgebraicGeometry.Scheme.Pullback.cocycle
code: theorem cocycle (i j k : 𝒰.J) : t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j = 𝟙 _ 
goal: AlgebraicGeometry.Scheme.Pullback.t' 𝒰 f g i j k ≫
    AlgebraicGeometry.Scheme.Pullback.t' 𝒰 f g j k i ≫ AlgebraicGeometry.Scheme.Pullback.t' 𝒰 f g k i j =
  𝟙
    (CategoryTheory.Limits.pullback (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i j)
      (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i k))

full_name: AlgebraicGeometry.Scheme.Pullback.gluing_U
code: /-- Given `Uᵢ ×[Z] Y`, this is the glued fibered product `X ×[Z] Y`. -/
@[simps U V f t t', simps (config := .lemmasOnly) J]
def gluing : Scheme.GlueData.{u} 
goal: (AlgebraicGeometry.Scheme.Pullback.gluing 𝒰 f g).U i = CategoryTheory.Limits.pullback (𝒰.map i ≫ f) g

full_name: AlgebraicGeometry.Scheme.Pullback.gluing_V
code: /-- Given `Uᵢ ×[Z] Y`, this is the glued fibered product `X ×[Z] Y`. -/
@[simps U V f t t', simps (config := .lemmasOnly) J]
def gluing : Scheme.GlueData.{u} 
goal: ∀ (x : 𝒰.J × 𝒰.J),
  (AlgebraicGeometry.Scheme.Pullback.gluing 𝒰 f g).V x =
    match x with
    | (i, j) => AlgebraicGeometry.Scheme.Pullback.v 𝒰 f g i j

full_name: AlgebraicGeometry.Scheme.Pullback.gluing_J
code: /-- Given `Uᵢ ×[Z] Y`, this is the glued fibered product `X ×[Z] Y`. -/
@[simps U V f t t', simps (config := .lemmasOnly) J]
def gluing : Scheme.GlueData.{u} 
goal: (AlgebraicGeometry.Scheme.Pullback.gluing 𝒰 f g).J = 𝒰.J

full_name: AlgebraicGeometry.Scheme.Pullback.gluing_t
code: /-- Given `Uᵢ ×[Z] Y`, this is the glued fibered product `X ×[Z] Y`. -/
@[simps U V f t t', simps (config := .lemmasOnly) J]
def gluing : Scheme.GlueData.{u} 
goal: (AlgebraicGeometry.Scheme.Pullback.gluing 𝒰 f g).t i j = AlgebraicGeometry.Scheme.Pullback.t 𝒰 f g i j

full_name: AlgebraicGeometry.Scheme.Pullback.gluing
code: /-- Given `Uᵢ ×[Z] Y`, this is the glued fibered product `X ×[Z] Y`. -/
@[simps U V f t t', simps (config := .lemmasOnly) J]
def gluing : Scheme.GlueData.{u} 
goal: AlgebraicGeometry.Scheme.GlueData

full_name: AlgebraicGeometry.Scheme.Pullback.gluing_f
code: /-- Given `Uᵢ ×[Z] Y`, this is the glued fibered product `X ×[Z] Y`. -/
@[simps U V f t t', simps (config := .lemmasOnly) J]
def gluing : Scheme.GlueData.{u} 
goal: (AlgebraicGeometry.Scheme.Pullback.gluing 𝒰 f g).f i j =
  CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j)

full_name: AlgebraicGeometry.Scheme.Pullback.gluing_t'
code: /-- Given `Uᵢ ×[Z] Y`, this is the glued fibered product `X ×[Z] Y`. -/
@[simps U V f t t', simps (config := .lemmasOnly) J]
def gluing : Scheme.GlueData.{u} 
goal: (AlgebraicGeometry.Scheme.Pullback.gluing 𝒰 f g).t' i j k = AlgebraicGeometry.Scheme.Pullback.t' 𝒰 f g i j k

full_name: AlgebraicGeometry.Scheme.Pullback.gluing_ι
code: @[simp]
lemma gluing_ι (j : 𝒰.J) :
    (gluing 𝒰 f g).ι j = Multicoequalizer.π (gluing 𝒰 f g).diagram j 
goal: (AlgebraicGeometry.Scheme.Pullback.gluing 𝒰 f g).ι j =
  CategoryTheory.Limits.Multicoequalizer.π (AlgebraicGeometry.Scheme.Pullback.gluing 𝒰 f g).diagram j

full_name: AlgebraicGeometry.Scheme.Pullback.p1
code: /-- The first projection from the glued scheme into `X`. -/
def p1 : (gluing 𝒰 f g).glued ⟶ X 
goal: (AlgebraicGeometry.Scheme.Pullback.gluing 𝒰 f g).glued ⟶ X

full_name: AlgebraicGeometry.Scheme.Pullback.p2
code: /-- The second projection from the glued scheme into `Y`. -/
def p2 : (gluing 𝒰 f g).glued ⟶ Y 
goal: (AlgebraicGeometry.Scheme.Pullback.gluing 𝒰 f g).glued ⟶ Y

full_name: AlgebraicGeometry.Scheme.Pullback.p_comm
code: theorem p_comm : p1 𝒰 f g ≫ f = p2 𝒰 f g ≫ g 
goal: AlgebraicGeometry.Scheme.Pullback.p1 𝒰 f g ≫ f = AlgebraicGeometry.Scheme.Pullback.p2 𝒰 f g ≫ g

full_name: AlgebraicGeometry.Scheme.Pullback.gluedLiftPullbackMap
code: /-- (Implementation)
The canonical map `(s.X ×[X] Uᵢ) ×[s.X] (s.X ×[X] Uⱼ) ⟶ (Uᵢ ×[Z] Y) ×[X] Uⱼ`

This is used in `gluedLift`. -/
def gluedLiftPullbackMap (i j : 𝒰.J) :
    pullback ((𝒰.pullbackCover s.fst).map i) ((𝒰.pullbackCover s.fst).map j) ⟶
      (gluing 𝒰 f g).V ⟨i, j⟩ 
goal: CategoryTheory.Limits.pullback ((𝒰.pullbackCover s.fst).map i) ((𝒰.pullbackCover s.fst).map j) ⟶
  (AlgebraicGeometry.Scheme.Pullback.gluing 𝒰 f g).V (i, j)

full_name: AlgebraicGeometry.Scheme.Pullback.gluedLiftPullbackMap_fst
code: @[reassoc]
theorem gluedLiftPullbackMap_fst (i j : 𝒰.J) :
    gluedLiftPullbackMap 𝒰 f g s i j ≫ pullback.fst _ _ =
      pullback.fst _ _ ≫
        (pullbackSymmetry _ _).hom ≫
          pullback.map _ _ _ _ (𝟙 _) s.snd f (Category.id_comp _).symm s.condition 
goal: AlgebraicGeometry.Scheme.Pullback.gluedLiftPullbackMap 𝒰 f g s i j ≫
    CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j) =
  CategoryTheory.Limits.pullback.fst ((𝒰.pullbackCover s.fst).map i) ((𝒰.pullbackCover s.fst).map j) ≫
    (CategoryTheory.Limits.pullbackSymmetry s.fst (𝒰.map i)).hom ≫
      CategoryTheory.Limits.pullback.map (𝒰.map i) s.fst (𝒰.map i ≫ f) g (𝟙 (𝒰.obj i)) s.snd f ⋯ ⋯

full_name: AlgebraicGeometry.Scheme.Pullback.gluedLiftPullbackMap_snd
code: @[reassoc]
theorem gluedLiftPullbackMap_snd (i j : 𝒰.J) :
    gluedLiftPullbackMap 𝒰 f g s i j ≫ pullback.snd _ _ = pullback.snd _ _ ≫ pullback.snd _ _ 
goal: AlgebraicGeometry.Scheme.Pullback.gluedLiftPullbackMap 𝒰 f g s i j ≫
    CategoryTheory.Limits.pullback.snd (CategoryTheory.Limits.pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j) =
  CategoryTheory.Limits.pullback.snd ((𝒰.pullbackCover s.fst).map i) ((𝒰.pullbackCover s.fst).map j) ≫
    CategoryTheory.Limits.pullback.snd s.fst (𝒰.map j)

full_name: AlgebraicGeometry.Scheme.Pullback.gluedLift
code: /-- The lifted map `s.X ⟶ (gluing 𝒰 f g).glued` in order to show that `(gluing 𝒰 f g).glued` is
indeed the pullback.

Given a pullback cone `s`, we have the maps `s.fst ⁻¹' Uᵢ ⟶ Uᵢ` and
`s.fst ⁻¹' Uᵢ ⟶ s.X ⟶ Y` that we may lift to a map `s.fst ⁻¹' Uᵢ ⟶ Uᵢ ×[Z] Y`.

to glue these into a map `s.X ⟶ Uᵢ ×[Z] Y`, we need to show that the maps agree on
`(s.fst ⁻¹' Uᵢ) ×[s.X] (s.fst ⁻¹' Uⱼ) ⟶ Uᵢ ×[Z] Y`. This is achieved by showing that both of these
maps factors through `gluedLiftPullbackMap`.
-/
def gluedLift : s.pt ⟶ (gluing 𝒰 f g).glued 
goal: s.pt ⟶ (AlgebraicGeometry.Scheme.Pullback.gluing 𝒰 f g).glued

full_name: AlgebraicGeometry.Scheme.Pullback.gluedLift_p1
code: theorem gluedLift_p1 : gluedLift 𝒰 f g s ≫ p1 𝒰 f g = s.fst 
goal: AlgebraicGeometry.Scheme.Pullback.gluedLift 𝒰 f g s ≫ AlgebraicGeometry.Scheme.Pullback.p1 𝒰 f g = s.fst

full_name: AlgebraicGeometry.Scheme.Pullback.gluedLift_p2
code: theorem gluedLift_p2 : gluedLift 𝒰 f g s ≫ p2 𝒰 f g = s.snd 
goal: AlgebraicGeometry.Scheme.Pullback.gluedLift 𝒰 f g s ≫ AlgebraicGeometry.Scheme.Pullback.p2 𝒰 f g = s.snd

full_name: AlgebraicGeometry.Scheme.Pullback.pullbackFstιToV
code: /-- (Implementation)
The canonical map `(W ×[X] Uᵢ) ×[W] (Uⱼ ×[Z] Y) ⟶ (Uⱼ ×[Z] Y) ×[X] Uᵢ = V j i` where `W` is
the glued fibred product.

This is used in `lift_comp_ι`. -/
def pullbackFstιToV (i j : 𝒰.J) :
    pullback (pullback.fst (p1 𝒰 f g) (𝒰.map i)) ((gluing 𝒰 f g).ι j) ⟶
      v 𝒰 f g j i 
goal: CategoryTheory.Limits.pullback
    (CategoryTheory.Limits.pullback.fst (AlgebraicGeometry.Scheme.Pullback.p1 𝒰 f g) (𝒰.map i))
    ((AlgebraicGeometry.Scheme.Pullback.gluing 𝒰 f g).ι j) ⟶
  AlgebraicGeometry.Scheme.Pullback.v 𝒰 f g j i

full_name: AlgebraicGeometry.Scheme.Pullback.pullbackFstιToV_fst
code: @[simp, reassoc]
theorem pullbackFstιToV_fst (i j : 𝒰.J) :
    pullbackFstιToV 𝒰 f g i j ≫ pullback.fst _ _ = pullback.snd _ _ 
goal: AlgebraicGeometry.Scheme.Pullback.pullbackFstιToV 𝒰 f g i j ≫
    CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pullback.fst (𝒰.map j ≫ f) g ≫ 𝒰.map j) (𝒰.map i) =
  CategoryTheory.Limits.pullback.snd
    (CategoryTheory.Limits.pullback.fst (AlgebraicGeometry.Scheme.Pullback.p1 𝒰 f g) (𝒰.map i))
    ((AlgebraicGeometry.Scheme.Pullback.gluing 𝒰 f g).ι j)

full_name: AlgebraicGeometry.Scheme.Pullback.pullbackFstιToV_snd
code: @[simp, reassoc]
theorem pullbackFstιToV_snd (i j : 𝒰.J) :
    pullbackFstιToV 𝒰 f g i j ≫ pullback.snd _ _ = pullback.fst _ _ ≫ pullback.snd _ _ 
goal: AlgebraicGeometry.Scheme.Pullback.pullbackFstιToV 𝒰 f g i j ≫
    CategoryTheory.Limits.pullback.snd (CategoryTheory.Limits.pullback.fst (𝒰.map j ≫ f) g ≫ 𝒰.map j) (𝒰.map i) =
  CategoryTheory.Limits.pullback.fst
      (CategoryTheory.Limits.pullback.fst (AlgebraicGeometry.Scheme.Pullback.p1 𝒰 f g) (𝒰.map i))
      ((AlgebraicGeometry.Scheme.Pullback.gluing 𝒰 f g).ι j) ≫
    CategoryTheory.Limits.pullback.snd (AlgebraicGeometry.Scheme.Pullback.p1 𝒰 f g) (𝒰.map i)

full_name: AlgebraicGeometry.Scheme.Pullback.lift_comp_ι
code: /-- We show that the map `W ×[X] Uᵢ ⟶ Uᵢ ×[Z] Y ⟶ W` is the first projection, where the
first map is given by the lift of `W ×[X] Uᵢ ⟶ Uᵢ` and `W ×[X] Uᵢ ⟶ W ⟶ Y`.

It suffices to show that the two map agrees when restricted onto `Uⱼ ×[Z] Y`. In this case,
both maps factor through `V j i` via `pullback_fst_ι_to_V` -/
theorem lift_comp_ι (i : 𝒰.J) :
    pullback.lift (pullback.snd _ _) (pullback.fst _ _ ≫ p2 𝒰 f g)
          (by rw [← pullback.condition_assoc, Category.assoc, p_comm]) ≫
        (gluing 𝒰 f g).ι i =
      (pullback.fst _ _ : pullback (p1 𝒰 f g) (𝒰.map i) ⟶ _) 
goal: CategoryTheory.Limits.pullback.lift
      (CategoryTheory.Limits.pullback.snd (AlgebraicGeometry.Scheme.Pullback.p1 𝒰 f g) (𝒰.map i))
      (CategoryTheory.Limits.pullback.fst (AlgebraicGeometry.Scheme.Pullback.p1 𝒰 f g) (𝒰.map i) ≫
        AlgebraicGeometry.Scheme.Pullback.p2 𝒰 f g)
      ⋯ ≫
    (AlgebraicGeometry.Scheme.Pullback.gluing 𝒰 f g).ι i =
  CategoryTheory.Limits.pullback.fst (AlgebraicGeometry.Scheme.Pullback.p1 𝒰 f g) (𝒰.map i)

full_name: AlgebraicGeometry.Scheme.Pullback.pullbackP1Iso
code: /-- The canonical isomorphism between `W ×[X] Uᵢ` and `Uᵢ ×[X] Y`. That is, the preimage of `Uᵢ` in
`W` along `p1` is indeed `Uᵢ ×[X] Y`. -/
def pullbackP1Iso (i : 𝒰.J) : pullback (p1 𝒰 f g) (𝒰.map i) ≅ pullback (𝒰.map i ≫ f) g 
goal: CategoryTheory.Limits.pullback (AlgebraicGeometry.Scheme.Pullback.p1 𝒰 f g) (𝒰.map i) ≅
  CategoryTheory.Limits.pullback (𝒰.map i ≫ f) g

full_name: AlgebraicGeometry.Scheme.Pullback.pullbackP1Iso_hom_fst
code: @[simp, reassoc]
theorem pullbackP1Iso_hom_fst (i : 𝒰.J) :
    (pullbackP1Iso 𝒰 f g i).hom ≫ pullback.fst _ _ = pullback.snd _ _ 
goal: (AlgebraicGeometry.Scheme.Pullback.pullbackP1Iso 𝒰 f g i).hom ≫ CategoryTheory.Limits.pullback.fst (𝒰.map i ≫ f) g =
  CategoryTheory.Limits.pullback.snd (AlgebraicGeometry.Scheme.Pullback.p1 𝒰 f g) (𝒰.map i)

full_name: AlgebraicGeometry.Scheme.Pullback.pullbackP1Iso_hom_snd
code: @[simp, reassoc]
theorem pullbackP1Iso_hom_snd (i : 𝒰.J) :
    (pullbackP1Iso 𝒰 f g i).hom ≫ pullback.snd _ _ = pullback.fst _ _ ≫ p2 𝒰 f g 
goal: (AlgebraicGeometry.Scheme.Pullback.pullbackP1Iso 𝒰 f g i).hom ≫ CategoryTheory.Limits.pullback.snd (𝒰.map i ≫ f) g =
  CategoryTheory.Limits.pullback.fst (AlgebraicGeometry.Scheme.Pullback.p1 𝒰 f g) (𝒰.map i) ≫
    AlgebraicGeometry.Scheme.Pullback.p2 𝒰 f g

full_name: AlgebraicGeometry.Scheme.Pullback.pullbackP1Iso_inv_fst
code: @[simp, reassoc]
theorem pullbackP1Iso_inv_fst (i : 𝒰.J) :
    (pullbackP1Iso 𝒰 f g i).inv ≫ pullback.fst _ _ = (gluing 𝒰 f g).ι i 
goal: (AlgebraicGeometry.Scheme.Pullback.pullbackP1Iso 𝒰 f g i).inv ≫
    CategoryTheory.Limits.pullback.fst (AlgebraicGeometry.Scheme.Pullback.p1 𝒰 f g) (𝒰.map i) =
  (AlgebraicGeometry.Scheme.Pullback.gluing 𝒰 f g).ι i

full_name: AlgebraicGeometry.Scheme.Pullback.pullbackP1Iso_inv_snd
code: @[simp, reassoc]
theorem pullbackP1Iso_inv_snd (i : 𝒰.J) :
    (pullbackP1Iso 𝒰 f g i).inv ≫ pullback.snd _ _ = pullback.fst _ _ 
goal: (AlgebraicGeometry.Scheme.Pullback.pullbackP1Iso 𝒰 f g i).inv ≫
    CategoryTheory.Limits.pullback.snd (AlgebraicGeometry.Scheme.Pullback.p1 𝒰 f g) (𝒰.map i) =
  CategoryTheory.Limits.pullback.fst (𝒰.map i ≫ f) g

full_name: AlgebraicGeometry.Scheme.Pullback.pullbackP1Iso_hom_ι
code: @[simp, reassoc]
theorem pullbackP1Iso_hom_ι (i : 𝒰.J) :
    (pullbackP1Iso 𝒰 f g i).hom ≫ Multicoequalizer.π (gluing 𝒰 f g).diagram i =
    pullback.fst _ _ 
goal: (AlgebraicGeometry.Scheme.Pullback.pullbackP1Iso 𝒰 f g i).hom ≫
    CategoryTheory.Limits.Multicoequalizer.π (AlgebraicGeometry.Scheme.Pullback.gluing 𝒰 f g).diagram i =
  CategoryTheory.Limits.pullback.fst (AlgebraicGeometry.Scheme.Pullback.p1 𝒰 f g) (𝒰.map i)

full_name: AlgebraicGeometry.Scheme.Pullback.gluedIsLimit
code: /-- The glued scheme (`(gluing 𝒰 f g).glued`) is indeed the pullback of `f` and `g`. -/
def gluedIsLimit : IsLimit (PullbackCone.mk _ _ (p_comm 𝒰 f g)) 
goal: CategoryTheory.Limits.IsLimit
  (CategoryTheory.Limits.PullbackCone.mk (AlgebraicGeometry.Scheme.Pullback.p1 𝒰 f g)
    (AlgebraicGeometry.Scheme.Pullback.p2 𝒰 f g) ⋯)

full_name: AlgebraicGeometry.Scheme.Pullback.hasPullback_of_cover
code: theorem hasPullback_of_cover : HasPullback f g 
goal: CategoryTheory.Limits.HasPullback f g

full_name: AlgebraicGeometry.Scheme.Pullback.affine_hasPullback
code: instance affine_hasPullback {A B C : CommRingCat}
    (f : Spec A ⟶ Spec C)
    (g : Spec B ⟶ Spec C) : HasPullback f g 
goal: CategoryTheory.Limits.HasPullback f g

full_name: AlgebraicGeometry.Scheme.Pullback.affine_affine_hasPullback
code: theorem affine_affine_hasPullback {B C : CommRingCat} {X : Scheme}
    (f : X ⟶ Spec C) (g : Spec B ⟶ Spec C) :
    HasPullback f g 
goal: CategoryTheory.Limits.HasPullback f g

full_name: AlgebraicGeometry.Scheme.Pullback.base_affine_hasPullback
code: instance base_affine_hasPullback {C : CommRingCat} {X Y : Scheme} (f : X ⟶ Spec C)
    (g : Y ⟶ Spec C) : HasPullback f g 
goal: CategoryTheory.Limits.HasPullback f g

full_name: AlgebraicGeometry.Scheme.Pullback.left_affine_comp_pullback_hasPullback
code: instance left_affine_comp_pullback_hasPullback {X Y Z : Scheme} (f : X ⟶ Z) (g : Y ⟶ Z)
    (i : Z.affineCover.J) : HasPullback ((Z.affineCover.pullbackCover f).map i ≫ f) g 
goal: CategoryTheory.Limits.HasPullback ((Z.affineCover.pullbackCover f).map i ≫ f) g

full_name: AlgebraicGeometry.Scheme.Pullback.instHasPullback
code: instance {X Y Z : Scheme} (f : X ⟶ Z) (g : Y ⟶ Z) : HasPullback f g 
goal: CategoryTheory.Limits.HasPullback f g

full_name: AlgebraicGeometry.Scheme.Pullback.instHasPullbacks
code: instance : HasPullbacks Scheme 
goal: CategoryTheory.Limits.HasPullbacks AlgebraicGeometry.Scheme

full_name: AlgebraicGeometry.Scheme.Pullback.isAffine_of_isAffine_isAffine_isAffine
code: instance isAffine_of_isAffine_isAffine_isAffine {X Y Z : Scheme}
    (f : X ⟶ Z) (g : Y ⟶ Z) [IsAffine X] [IsAffine Y] [IsAffine Z] :
    IsAffine (pullback f g) 
goal: AlgebraicGeometry.IsAffine (CategoryTheory.Limits.pullback f g)

full_name: AlgebraicGeometry.Scheme.Pullback.openCoverOfLeft_J
code: /-- Given an open cover `{ Xᵢ }` of `X`, then `X ×[Z] Y` is covered by `Xᵢ ×[Z] Y`. -/
@[simps! J obj map]
def openCoverOfLeft (𝒰 : OpenCover X) (f : X ⟶ Z) (g : Y ⟶ Z) : OpenCover (pullback f g) 
goal: (AlgebraicGeometry.Scheme.Pullback.openCoverOfLeft 𝒰 f g).J = 𝒰.J

full_name: AlgebraicGeometry.Scheme.Pullback.openCoverOfLeft_obj
code: /-- Given an open cover `{ Xᵢ }` of `X`, then `X ×[Z] Y` is covered by `Xᵢ ×[Z] Y`. -/
@[simps! J obj map]
def openCoverOfLeft (𝒰 : OpenCover X) (f : X ⟶ Z) (g : Y ⟶ Z) : OpenCover (pullback f g) 
goal: (AlgebraicGeometry.Scheme.Pullback.openCoverOfLeft 𝒰 f g).obj i = CategoryTheory.Limits.pullback (𝒰.map i ≫ f) g

full_name: AlgebraicGeometry.Scheme.Pullback.openCoverOfLeft_map
code: /-- Given an open cover `{ Xᵢ }` of `X`, then `X ×[Z] Y` is covered by `Xᵢ ×[Z] Y`. -/
@[simps! J obj map]
def openCoverOfLeft (𝒰 : OpenCover X) (f : X ⟶ Z) (g : Y ⟶ Z) : OpenCover (pullback f g) 
goal: (AlgebraicGeometry.Scheme.Pullback.openCoverOfLeft 𝒰 f g).map i =
  CategoryTheory.Limits.pullback.map (𝒰.map i ≫ f) g f g (𝒰.map i) (𝟙 Y) (𝟙 Z) ⋯ ⋯

full_name: AlgebraicGeometry.Scheme.Pullback.openCoverOfLeft
code: /-- Given an open cover `{ Xᵢ }` of `X`, then `X ×[Z] Y` is covered by `Xᵢ ×[Z] Y`. -/
@[simps! J obj map]
def openCoverOfLeft (𝒰 : OpenCover X) (f : X ⟶ Z) (g : Y ⟶ Z) : OpenCover (pullback f g) 
goal: (CategoryTheory.Limits.pullback f g).OpenCover

full_name: AlgebraicGeometry.Scheme.Pullback.openCoverOfRight
code: /-- Given an open cover `{ Yᵢ }` of `Y`, then `X ×[Z] Y` is covered by `X ×[Z] Yᵢ`. -/
@[simps! J obj map]
def openCoverOfRight (𝒰 : OpenCover Y) (f : X ⟶ Z) (g : Y ⟶ Z) : OpenCover (pullback f g) 
goal: (CategoryTheory.Limits.pullback f g).OpenCover

full_name: AlgebraicGeometry.Scheme.Pullback.openCoverOfRight_map
code: /-- Given an open cover `{ Yᵢ }` of `Y`, then `X ×[Z] Y` is covered by `X ×[Z] Yᵢ`. -/
@[simps! J obj map]
def openCoverOfRight (𝒰 : OpenCover Y) (f : X ⟶ Z) (g : Y ⟶ Z) : OpenCover (pullback f g) 
goal: (AlgebraicGeometry.Scheme.Pullback.openCoverOfRight 𝒰 f g).map i =
  CategoryTheory.Limits.pullback.map f (𝒰.map i ≫ g) f g (𝟙 X) (𝒰.map i) (𝟙 Z) ⋯ ⋯

full_name: AlgebraicGeometry.Scheme.Pullback.openCoverOfRight_obj
code: /-- Given an open cover `{ Yᵢ }` of `Y`, then `X ×[Z] Y` is covered by `X ×[Z] Yᵢ`. -/
@[simps! J obj map]
def openCoverOfRight (𝒰 : OpenCover Y) (f : X ⟶ Z) (g : Y ⟶ Z) : OpenCover (pullback f g) 
goal: (AlgebraicGeometry.Scheme.Pullback.openCoverOfRight 𝒰 f g).obj i = CategoryTheory.Limits.pullback f (𝒰.map i ≫ g)

full_name: AlgebraicGeometry.Scheme.Pullback.openCoverOfRight_J
code: /-- Given an open cover `{ Yᵢ }` of `Y`, then `X ×[Z] Y` is covered by `X ×[Z] Yᵢ`. -/
@[simps! J obj map]
def openCoverOfRight (𝒰 : OpenCover Y) (f : X ⟶ Z) (g : Y ⟶ Z) : OpenCover (pullback f g) 
goal: (AlgebraicGeometry.Scheme.Pullback.openCoverOfRight 𝒰 f g).J = 𝒰.J

full_name: AlgebraicGeometry.Scheme.Pullback.openCoverOfLeftRight_obj
code: /-- Given an open cover `{ Xᵢ }` of `X` and an open cover `{ Yⱼ }` of `Y`, then
`X ×[Z] Y` is covered by `Xᵢ ×[Z] Yⱼ`. -/
@[simps! J obj map]
def openCoverOfLeftRight (𝒰X : X.OpenCover) (𝒰Y : Y.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z) :
    (pullback f g).OpenCover 
goal: (AlgebraicGeometry.Scheme.Pullback.openCoverOfLeftRight 𝒰X 𝒰Y f g).obj ij =
  CategoryTheory.Limits.pullback (𝒰X.map ij.1 ≫ f) (𝒰Y.map ij.2 ≫ g)

full_name: AlgebraicGeometry.Scheme.Pullback.openCoverOfLeftRight
code: /-- Given an open cover `{ Xᵢ }` of `X` and an open cover `{ Yⱼ }` of `Y`, then
`X ×[Z] Y` is covered by `Xᵢ ×[Z] Yⱼ`. -/
@[simps! J obj map]
def openCoverOfLeftRight (𝒰X : X.OpenCover) (𝒰Y : Y.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z) :
    (pullback f g).OpenCover 
goal: (CategoryTheory.Limits.pullback f g).OpenCover

full_name: AlgebraicGeometry.Scheme.Pullback.openCoverOfLeftRight_J
code: /-- Given an open cover `{ Xᵢ }` of `X` and an open cover `{ Yⱼ }` of `Y`, then
`X ×[Z] Y` is covered by `Xᵢ ×[Z] Yⱼ`. -/
@[simps! J obj map]
def openCoverOfLeftRight (𝒰X : X.OpenCover) (𝒰Y : Y.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z) :
    (pullback f g).OpenCover 
goal: (AlgebraicGeometry.Scheme.Pullback.openCoverOfLeftRight 𝒰X 𝒰Y f g).J = (𝒰X.J × 𝒰Y.J)

full_name: AlgebraicGeometry.Scheme.Pullback.openCoverOfLeftRight_map
code: /-- Given an open cover `{ Xᵢ }` of `X` and an open cover `{ Yⱼ }` of `Y`, then
`X ×[Z] Y` is covered by `Xᵢ ×[Z] Yⱼ`. -/
@[simps! J obj map]
def openCoverOfLeftRight (𝒰X : X.OpenCover) (𝒰Y : Y.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z) :
    (pullback f g).OpenCover 
goal: (AlgebraicGeometry.Scheme.Pullback.openCoverOfLeftRight 𝒰X 𝒰Y f g).map ij =
  CategoryTheory.Limits.pullback.map (𝒰X.map ij.1 ≫ f) (𝒰Y.map ij.2 ≫ g) f g (𝒰X.map ij.1) (𝒰Y.map ij.2) (𝟙 Z) ⋯ ⋯

full_name: AlgebraicGeometry.Scheme.Pullback.openCoverOfBase'_map
code: /-- (Implementation). Use `openCoverOfBase` instead. -/
@[simps! map]
def openCoverOfBase' (𝒰 : OpenCover Z) (f : X ⟶ Z) (g : Y ⟶ Z) : OpenCover (pullback f g) 
goal: (AlgebraicGeometry.Scheme.Pullback.openCoverOfBase' 𝒰 f g).map x =
  (CategoryTheory.Limits.pullbackSymmetry (CategoryTheory.Limits.pullback.snd f (𝒰.map x.fst))
        (CategoryTheory.Limits.pullback.snd g (𝒰.map x.fst))).hom ≫
    (CategoryTheory.Limits.limit.isoLimitCone
          {
            cone :=
              CategoryTheory.Limits.PullbackCone.mk
                (CategoryTheory.Limits.pullback.snd (CategoryTheory.Limits.pullback.snd g (𝒰.map x.fst))
                  (CategoryTheory.Limits.pullback.snd f (𝒰.map x.fst)))
                (CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pullback.snd g (𝒰.map x.fst))
                    (CategoryTheory.Limits.pullback.snd f (𝒰.map x.fst)) ≫
                  CategoryTheory.Limits.pullback.fst g (𝒰.map x.fst))
                ⋯,
            isLimit :=
              CategoryTheory.Limits.bigSquareIsPullback
                (CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pullback.snd g (𝒰.map x.fst))
                  (CategoryTheory.Limits.pullback.snd f (𝒰.map x.fst)))
                (CategoryTheory.Limits.pullback.fst g (𝒰.map x.fst))
                (CategoryTheory.Limits.pullback.snd f (𝒰.map x.fst)) (𝒰.map x.fst)
                (CategoryTheory.Limits.pullback.snd (CategoryTheory.Limits.pullback.snd g (𝒰.map x.fst))
                  (CategoryTheory.Limits.pullback.snd f (𝒰.map x.fst)))
                (CategoryTheory.Limits.pullback.snd g (𝒰.map x.fst)) g ⋯ ⋯
                (CategoryTheory.Limits.PullbackCone.isLimitOfFlip
                  (CategoryTheory.Limits.pullbackIsPullback g (𝒰.map x.fst)))
                (CategoryTheory.Limits.PullbackCone.isLimitOfFlip
                  (CategoryTheory.Limits.pullbackIsPullback (CategoryTheory.Limits.pullback.snd g (𝒰.map x.fst))
                    (CategoryTheory.Limits.pullback.snd f (𝒰.map x.fst)))) }).inv ≫
      CategoryTheory.Limits.pullback.map (CategoryTheory.Limits.pullback.snd f (𝒰.map x.fst) ≫ 𝒰.map x.fst) g
          (CategoryTheory.Limits.pullback.fst f (𝒰.map x.fst) ≫ f) g
          (𝟙 (CategoryTheory.Limits.pullback f (𝒰.map x.fst))) (𝟙 Y) (𝟙 Z) ⋯ ⋯ ≫
        CategoryTheory.Limits.pullback.map (CategoryTheory.Limits.pullback.fst f (𝒰.map x.fst) ≫ f) g f g
          (CategoryTheory.Limits.pullback.fst f (𝒰.map x.fst)) (𝟙 Y) (𝟙 Z) ⋯ ⋯

full_name: AlgebraicGeometry.Scheme.Pullback.openCoverOfBase'
code: /-- (Implementation). Use `openCoverOfBase` instead. -/
@[simps! map]
def openCoverOfBase' (𝒰 : OpenCover Z) (f : X ⟶ Z) (g : Y ⟶ Z) : OpenCover (pullback f g) 
goal: (CategoryTheory.Limits.pullback f g).OpenCover

full_name: AlgebraicGeometry.Scheme.Pullback.openCoverOfBase_obj
code: /-- Given an open cover `{ Zᵢ }` of `Z`, then `X ×[Z] Y` is covered by `Xᵢ ×[Zᵢ] Yᵢ`, where
  `Xᵢ = X ×[Z] Zᵢ` and `Yᵢ = Y ×[Z] Zᵢ` is the preimage of `Zᵢ` in `X` and `Y`. -/
@[simps! J obj map]
def openCoverOfBase (𝒰 : OpenCover Z) (f : X ⟶ Z) (g : Y ⟶ Z) : OpenCover (pullback f g) 
goal: (AlgebraicGeometry.Scheme.Pullback.openCoverOfBase 𝒰 f g).obj i =
  CategoryTheory.Limits.pullback (CategoryTheory.Limits.pullback.snd f (𝒰.map i))
    (CategoryTheory.Limits.pullback.snd g (𝒰.map i))

full_name: AlgebraicGeometry.Scheme.Pullback.openCoverOfBase_J
code: /-- Given an open cover `{ Zᵢ }` of `Z`, then `X ×[Z] Y` is covered by `Xᵢ ×[Zᵢ] Yᵢ`, where
  `Xᵢ = X ×[Z] Zᵢ` and `Yᵢ = Y ×[Z] Zᵢ` is the preimage of `Zᵢ` in `X` and `Y`. -/
@[simps! J obj map]
def openCoverOfBase (𝒰 : OpenCover Z) (f : X ⟶ Z) (g : Y ⟶ Z) : OpenCover (pullback f g) 
goal: (AlgebraicGeometry.Scheme.Pullback.openCoverOfBase 𝒰 f g).J = 𝒰.J

full_name: AlgebraicGeometry.Scheme.Pullback.openCoverOfBase
code: /-- Given an open cover `{ Zᵢ }` of `Z`, then `X ×[Z] Y` is covered by `Xᵢ ×[Zᵢ] Yᵢ`, where
  `Xᵢ = X ×[Z] Zᵢ` and `Yᵢ = Y ×[Z] Zᵢ` is the preimage of `Zᵢ` in `X` and `Y`. -/
@[simps! J obj map]
def openCoverOfBase (𝒰 : OpenCover Z) (f : X ⟶ Z) (g : Y ⟶ Z) : OpenCover (pullback f g) 
goal: (CategoryTheory.Limits.pullback f g).OpenCover

full_name: AlgebraicGeometry.Scheme.Pullback.openCoverOfBase_map
code: /-- Given an open cover `{ Zᵢ }` of `Z`, then `X ×[Z] Y` is covered by `Xᵢ ×[Zᵢ] Yᵢ`, where
  `Xᵢ = X ×[Z] Zᵢ` and `Yᵢ = Y ×[Z] Zᵢ` is the preimage of `Zᵢ` in `X` and `Y`. -/
@[simps! J obj map]
def openCoverOfBase (𝒰 : OpenCover Z) (f : X ⟶ Z) (g : Y ⟶ Z) : OpenCover (pullback f g) 
goal: (AlgebraicGeometry.Scheme.Pullback.openCoverOfBase 𝒰 f g).map i =
  CategoryTheory.Limits.pullback.map (CategoryTheory.Limits.pullback.snd f (𝒰.map i))
    (CategoryTheory.Limits.pullback.snd g (𝒰.map i)) f g (CategoryTheory.Limits.pullback.fst f (𝒰.map i))
    (CategoryTheory.Limits.pullback.fst g (𝒰.map i)) (𝒰.map i) ⋯ ⋯

full_name: AlgebraicGeometry.Scheme.pullback_map_isOpenImmersion
code: instance Scheme.pullback_map_isOpenImmersion {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')
    [IsOpenImmersion i₁] [IsOpenImmersion i₂] [Mono i₃] :
    IsOpenImmersion (pullback.map f g f' g' i₁ i₂ i₃ e₁ e₂) 
goal: AlgebraicGeometry.IsOpenImmersion (CategoryTheory.Limits.pullback.map f g f' g' i₁ i₂ i₃ e₁ e₂)

full_name: AlgebraicGeometry.pullbackSpecIso
code: /-- The isomorphism between the fiber product of two schemes `Spec S` and `Spec T`
over a scheme `Spec R` and the `Spec` of the tensor product `S ⊗[R] T`.-/
noncomputable
def pullbackSpecIso :
    pullback (Spec.map (CommRingCat.ofHom (algebraMap R S)))
      (Spec.map (CommRingCat.ofHom (algebraMap R T))) ≅ Spec (.of <| S ⊗[R] T) 
goal: CategoryTheory.Limits.pullback (AlgebraicGeometry.Spec.map (CommRingCat.ofHom (algebraMap R S)))
    (AlgebraicGeometry.Spec.map (CommRingCat.ofHom (algebraMap R T))) ≅
  AlgebraicGeometry.Spec (CommRingCat.of (TensorProduct R S T))

full_name: AlgebraicGeometry.pullbackSpecIso_inv_fst
code: /--
The composition of the inverse of the isomorphism `pullbackSepcIso R S T` (from the pullback of
`Spec S ⟶ Spec R` and `Spec T ⟶ Spec R` to `Spec (S ⊗[R] T)`) with the first projection is
the morphism `Spec (S ⊗[R] T) ⟶ Spec S` obtained by applying `Spec.map` to the ring morphism
`s ↦ s ⊗ₜ[R] 1`.
-/
@[reassoc (attr := simp)]
lemma pullbackSpecIso_inv_fst :
    (pullbackSpecIso R S T).inv ≫ pullback.fst _ _ = Spec.map (ofHom includeLeftRingHom) 
goal: (AlgebraicGeometry.pullbackSpecIso R S T).inv ≫
    CategoryTheory.Limits.pullback.fst (AlgebraicGeometry.Spec.map (CommRingCat.ofHom (algebraMap R S)))
      (AlgebraicGeometry.Spec.map (CommRingCat.ofHom (algebraMap R T))) =
  AlgebraicGeometry.Spec.map (CommRingCat.ofHom Algebra.TensorProduct.includeLeftRingHom)

full_name: AlgebraicGeometry.pullbackSpecIso_inv_snd
code: /--
The composition of the inverse of the isomorphism `pullbackSepcIso R S T` (from the pullback of
`Spec S ⟶ Spec R` and `Spec T ⟶ Spec R` to `Spec (S ⊗[R] T)`) with the second projection is
the morphism `Spec (S ⊗[R] T) ⟶ Spec T` obtained by applying `Spec.map` to the ring morphism
`t ↦ 1 ⊗ₜ[R] t`.
-/
@[reassoc (attr := simp)]
lemma pullbackSpecIso_inv_snd :
    (pullbackSpecIso R S T).inv ≫ pullback.snd _ _ = Spec.map (ofHom (toRingHom includeRight)) 
goal: (AlgebraicGeometry.pullbackSpecIso R S T).inv ≫
    CategoryTheory.Limits.pullback.snd (AlgebraicGeometry.Spec.map (CommRingCat.ofHom (algebraMap R S)))
      (AlgebraicGeometry.Spec.map (CommRingCat.ofHom (algebraMap R T))) =
  AlgebraicGeometry.Spec.map (CommRingCat.ofHom ↑Algebra.TensorProduct.includeRight)

full_name: AlgebraicGeometry.pullbackSpecIso_hom_fst
code: /--
The composition of the isomorphism `pullbackSepcIso R S T` (from the pullback of
`Spec S ⟶ Spec R` and `Spec T ⟶ Spec R` to `Spec (S ⊗[R] T)`) with the morphism
`Spec (S ⊗[R] T) ⟶ Spec S` obtained by applying `Spec.map` to the ring morphism `s ↦ s ⊗ₜ[R] 1`
is the first projection.
-/
@[reassoc (attr := simp)]
lemma pullbackSpecIso_hom_fst :
    (pullbackSpecIso R S T).hom ≫ Spec.map (ofHom includeLeftRingHom) = pullback.fst _ _ 
goal: (AlgebraicGeometry.pullbackSpecIso R S T).hom ≫
    AlgebraicGeometry.Spec.map (CommRingCat.ofHom Algebra.TensorProduct.includeLeftRingHom) =
  CategoryTheory.Limits.pullback.fst (AlgebraicGeometry.Spec.map (CommRingCat.ofHom (algebraMap R S)))
    (AlgebraicGeometry.Spec.map (CommRingCat.ofHom (algebraMap R T)))

full_name: AlgebraicGeometry.pullbackSpecIso_hom_snd
code: /--
The composition of the isomorphism `pullbackSepcIso R S T` (from the pullback of
`Spec S ⟶ Spec R` and `Spec T ⟶ Spec R` to `Spec (S ⊗[R] T)`) with the morphism
`Spec (S ⊗[R] T) ⟶ Spec T` obtained by applying `Spec.map` to the ring morphism `t ↦ 1 ⊗ₜ[R] t`
is the second projection.
-/
@[reassoc (attr := simp)]
lemma pullbackSpecIso_hom_snd :
    (pullbackSpecIso R S T).hom ≫ Spec.map (ofHom (toRingHom includeRight)) = pullback.snd _ _ 
goal: (AlgebraicGeometry.pullbackSpecIso R S T).hom ≫
    AlgebraicGeometry.Spec.map (CommRingCat.ofHom ↑Algebra.TensorProduct.includeRight) =
  CategoryTheory.Limits.pullback.snd (AlgebraicGeometry.Spec.map (CommRingCat.ofHom (algebraMap R S)))
    (AlgebraicGeometry.Spec.map (CommRingCat.ofHom (algebraMap R T)))