ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- List.Nat.length_antidiagonal
@[simp]
theorem length_antidiagonal (n : ℕ) : (antidiagonal n).length = n + 1 
Arguments: (n : ℕ)
Goal: (List.Nat.antidiagonal n).length = n + 1
-- List.Nat.antidiagonal_zero
@[simp]
theorem antidiagonal_zero : antidiagonal 0 = [(0, 0)] 
Goal: List.Nat.antidiagonal 0 = [(0, 0)]
-- List.Nat.nodup_antidiagonal
theorem nodup_antidiagonal (n : ℕ) : Nodup (antidiagonal n) 
Arguments: (n : ℕ)
Goal: (List.Nat.antidiagonal n).Nodup
-- List.Nat.antidiagonal_succ
@[simp]
theorem antidiagonal_succ {n : ℕ} :
    antidiagonal (n + 1) = (0, n + 1) :: (antidiagonal n).map (Prod.map Nat.succ id) 
Arguments: {n : ℕ}
Goal: List.Nat.antidiagonal (n + 1) = (0, n + 1) :: List.map (Prod.map Nat.succ id) (List.Nat.antidiagonal n)
-- List.Nat.antidiagonal_succ'
theorem antidiagonal_succ' {n : ℕ} :
    antidiagonal (n + 1) = (antidiagonal n).map (Prod.map id Nat.succ) ++ [(n + 1, 0)] 
Arguments: {n : ℕ}
Goal: List.Nat.antidiagonal (n + 1) = List.map (Prod.map id Nat.succ) (List.Nat.antidiagonal n) ++ [(n + 1, 0)]
-- List.Nat.antidiagonal_succ_succ'
theorem antidiagonal_succ_succ' {n : ℕ} :
    antidiagonal (n + 2) =
      (0, n + 2) :: (antidiagonal n).map (Prod.map Nat.succ Nat.succ) ++ [(n + 2, 0)] 
Arguments: {n : ℕ}
Goal: List.Nat.antidiagonal (n + 2) =
  (0, n + 2) :: List.map (Prod.map Nat.succ Nat.succ) (List.Nat.antidiagonal n) ++ [(n + 2, 0)]
-- List.Nat.map_swap_antidiagonal
theorem map_swap_antidiagonal {n : ℕ} :
    (antidiagonal n).map Prod.swap = (antidiagonal n).reverse 
Arguments: {n : ℕ}
Goal: List.map Prod.swap (List.Nat.antidiagonal n) = (List.Nat.antidiagonal n).reverse
-- List.getElem?_enumFrom
@[simp]
theorem getElem?_enumFrom :
    ∀ n (l : List α) m, (enumFrom n l)[m]? = l[m]?.map fun a => (n + m, a)
  
Arguments: {α : Type u_1} (n : ℕ) (l : List α) (m : ℕ)
Goal: (List.enumFrom n l)[m]? = Option.map (fun a => (n + m, a)) l[m]?
-- List.get?_enumFrom
theorem get?_enumFrom (n) (l : List α) (m) :
    get? (enumFrom n l) m = (get? l m).map fun a => (n + m, a) 
Arguments: {α : Type u_1} (n : ℕ) (l : List α) (m : ℕ)
Goal: (List.enumFrom n l).get? m = Option.map (fun a => (n + m, a)) (l.get? m)
-- List.getElem?_enum
@[simp]
theorem getElem?_enum (l : List α) (n : Nat) : (enum l)[n]? = l[n]?.map fun a => (n, a) 
Arguments: {α : Type u_1} (l : List α) (n : ℕ)
Goal: l.enum[n]? = Option.map (fun a => (n, a)) l[n]?
-- List.get?_enum
theorem get?_enum (l : List α) (n) : get? (enum l) n = (get? l n).map fun a => (n, a) 
Arguments: {α : Type u_1} (l : List α) (n : ℕ)
Goal: l.enum.get? n = Option.map (fun a => (n, a)) (l.get? n)
-- List.enumFrom_map_snd
@[simp]
theorem enumFrom_map_snd : ∀ (n) (l : List α), map Prod.snd (enumFrom n l) = l
  
Arguments: {α : Type u_1} (n : ℕ) (l : List α)
Goal: List.map Prod.snd (List.enumFrom n l) = l
-- List.enum_map_snd
@[simp]
theorem enum_map_snd (l : List α) : map Prod.snd (enum l) = l 
Arguments: {α : Type u_1} (l : List α)
Goal: List.map Prod.snd l.enum = l
-- List.getElem_enumFrom
@[simp]
theorem getElem_enumFrom (l : List α) (n) (i : Nat) (h : i < (l.enumFrom n).length) :
    (l.enumFrom n)[i] = (n + i, l[i]'(by simpa [enumFrom_length] using h)) 
Arguments: {α : Type u_1} (l : List α) (n i : ℕ) (h : i < (List.enumFrom n l).length)
Goal: (List.enumFrom n l)[i] = (n + i, l[i])
-- List.get_enumFrom
theorem get_enumFrom (l : List α) (n) (i : Fin (l.enumFrom n).length) :
    (l.enumFrom n).get i = (n + i, l.get (i.cast enumFrom_length)) 
Arguments: {α : Type u_1} (l : List α) (n : ℕ) (i : Fin (List.enumFrom n l).length)
Goal: (List.enumFrom n l).get i = (n + ↑i, l.get (Fin.cast ⋯ i))
-- List.getElem_enum
@[simp]
theorem getElem_enum (l : List α) (i : Nat) (h : i < l.enum.length) :
    l.enum[i] = (i, l[i]'(by simpa [enum_length] using h)) 
Arguments: {α : Type u_1} (l : List α) (i : ℕ) (h : i < l.enum.length)
Goal: l.enum[i] = (i, l[i])
-- List.get_enum
theorem get_enum (l : List α) (i : Fin l.enum.length) :
    l.enum.get i = (i.1, l.get (i.cast enum_length)) 
Arguments: {α : Type u_1} (l : List α) (i : Fin l.enum.length)
Goal: l.enum.get i = (↑i, l.get (Fin.cast ⋯ i))
-- List.mk_add_mem_enumFrom_iff_get?
theorem mk_add_mem_enumFrom_iff_get? {n i : ℕ} {x : α} {l : List α} :
    (n + i, x) ∈ enumFrom n l ↔ l.get? i = x 
Arguments: {α : Type u_1} {n i : ℕ} {x : α} {l : List α}
Goal: (n + i, x) ∈ List.enumFrom n l ↔ l.get? i = some x
-- List.mk_mem_enumFrom_iff_le_and_get?_sub
theorem mk_mem_enumFrom_iff_le_and_get?_sub {n i : ℕ} {x : α} {l : List α} :
    (i, x) ∈ enumFrom n l ↔ n ≤ i ∧ l.get? (i - n) = x 
Arguments: {α : Type u_1} {n i : ℕ} {x : α} {l : List α}
Goal: (i, x) ∈ List.enumFrom n l ↔ n ≤ i ∧ l.get? (i - n) = some x
-- List.mk_mem_enum_iff_get?
theorem mk_mem_enum_iff_get? {i : ℕ} {x : α} {l : List α} : (i, x) ∈ enum l ↔ l.get? i = x 
Arguments: {α : Type u_1} {i : ℕ} {x : α} {l : List α}
Goal: (i, x) ∈ l.enum ↔ l.get? i = some x
-- List.mem_enum_iff_get?
theorem mem_enum_iff_get? {x : ℕ × α} {l : List α} : x ∈ enum l ↔ l.get? x.1 = x.2 
Arguments: {α : Type u_1} {x : ℕ × α} {l : List α}
Goal: x ∈ l.enum ↔ l.get? x.1 = some x.2
-- List.le_fst_of_mem_enumFrom
theorem le_fst_of_mem_enumFrom {x : ℕ × α} {n : ℕ} {l : List α} (h : x ∈ enumFrom n l) :
    n ≤ x.1 
Arguments: {α : Type u_1} {x : ℕ × α} {n : ℕ} {l : List α} (h : x ∈ List.enumFrom n l)
Goal: n ≤ x.1
-- List.fst_lt_add_of_mem_enumFrom
theorem fst_lt_add_of_mem_enumFrom {x : ℕ × α} {n : ℕ} {l : List α} (h : x ∈ enumFrom n l) :
    x.1 < n + length l 
Arguments: {α : Type u_1} {x : ℕ × α} {n : ℕ} {l : List α} (h : x ∈ List.enumFrom n l)
Goal: x.1 < n + l.length
-- List.fst_lt_of_mem_enum
theorem fst_lt_of_mem_enum {x : ℕ × α} {l : List α} (h : x ∈ enum l) : x.1 < length l 
Arguments: {α : Type u_1} {x : ℕ × α} {l : List α} (h : x ∈ l.enum)
Goal: x.1 < l.length
-- List.snd_mem_of_mem_enumFrom
theorem snd_mem_of_mem_enumFrom {x : ℕ × α} {n : ℕ} {l : List α} (h : x ∈ enumFrom n l) : x.2 ∈ l 
Arguments: {α : Type u_1} {x : ℕ × α} {n : ℕ} {l : List α} (h : x ∈ List.enumFrom n l)
Goal: x.2 ∈ l
-- List.snd_mem_of_mem_enum
theorem snd_mem_of_mem_enum {x : ℕ × α} {l : List α} (h : x ∈ enum l) : x.2 ∈ l 
Arguments: {α : Type u_1} {x : ℕ × α} {l : List α} (h : x ∈ l.enum)
Goal: x.2 ∈ l
-- List.mem_enumFrom
theorem mem_enumFrom {x : α} {i j : ℕ} (xs : List α) (h : (i, x) ∈ xs.enumFrom j) :
    j ≤ i ∧ i < j + xs.length ∧ x ∈ xs 
Arguments: {α : Type u_1} {x : α} {i j : ℕ} (xs : List α) (h : (i, x) ∈ List.enumFrom j xs)
Goal: j ≤ i ∧ i < j + xs.length ∧ x ∈ xs
-- List.enumFrom_singleton
@[simp]
theorem enumFrom_singleton (x : α) (n : ℕ) : enumFrom n [x] = [(n, x)] 
Arguments: {α : Type u_1} (x : α) (n : ℕ)
Goal: List.enumFrom n [x] = [(n, x)]
-- List.enum_singleton
@[simp]
theorem enum_singleton (x : α) : enum [x] = [(0, x)] 
Arguments: {α : Type u_1} (x : α)
Goal: [x].enum = [(0, x)]
-- List.enumFrom_append
theorem enumFrom_append (xs ys : List α) (n : ℕ) :
    enumFrom n (xs ++ ys) = enumFrom n xs ++ enumFrom (n + xs.length) ys 
Arguments: {α : Type u_1} (xs ys : List α) (n : ℕ)
Goal: List.enumFrom n (xs ++ ys) = List.enumFrom n xs ++ List.enumFrom (n + xs.length) ys
-- List.enum_append
theorem enum_append (xs ys : List α) : enum (xs ++ ys) = enum xs ++ enumFrom xs.length ys 
Arguments: {α : Type u_1} (xs ys : List α)
Goal: (xs ++ ys).enum = xs.enum ++ List.enumFrom xs.length ys
-- List.map_fst_add_enumFrom_eq_enumFrom
theorem map_fst_add_enumFrom_eq_enumFrom (l : List α) (n k : ℕ) :
    map (Prod.map (· + n) id) (enumFrom k l) = enumFrom (n + k) l 
Arguments: {α : Type u_1} (l : List α) (n k : ℕ)
Goal: List.map (Prod.map (fun x => x + n) id) (List.enumFrom k l) = List.enumFrom (n + k) l
-- List.map_fst_add_enum_eq_enumFrom
theorem map_fst_add_enum_eq_enumFrom (l : List α) (n : ℕ) :
    map (Prod.map (· + n) id) (enum l) = enumFrom n l 
Arguments: {α : Type u_1} (l : List α) (n : ℕ)
Goal: List.map (Prod.map (fun x => x + n) id) l.enum = List.enumFrom n l
-- List.enumFrom_cons'
theorem enumFrom_cons' (n : ℕ) (x : α) (xs : List α) :
    enumFrom n (x :: xs) = (n, x) :: (enumFrom n xs).map (Prod.map Nat.succ id) 
Arguments: {α : Type u_1} (n : ℕ) (x : α) (xs : List α)
Goal: List.enumFrom n (x :: xs) = (n, x) :: List.map (Prod.map Nat.succ id) (List.enumFrom n xs)
-- List.enum_cons'
theorem enum_cons' (x : α) (xs : List α) :
    enum (x :: xs) = (0, x) :: (enum xs).map (Prod.map Nat.succ id) 
Arguments: {α : Type u_1} (x : α) (xs : List α)
Goal: (x :: xs).enum = (0, x) :: List.map (Prod.map Nat.succ id) xs.enum
-- List.enumFrom_map
theorem enumFrom_map (n : ℕ) (l : List α) (f : α → β) :
    enumFrom n (l.map f) = (enumFrom n l).map (Prod.map id f) 
Arguments: {α : Type u_1} {β : Type u_2} (n : ℕ) (l : List α) (f : α → β)
Goal: List.enumFrom n (List.map f l) = List.map (Prod.map id f) (List.enumFrom n l)
-- List.enum_map
theorem enum_map (l : List α) (f : α → β) : (l.map f).enum = l.enum.map (Prod.map id f) 
Arguments: {α : Type u_1} {β : Type u_2} (l : List α) (f : α → β)
Goal: (List.map f l).enum = List.map (Prod.map id f) l.enum
-- List.enumFrom_eq_nil
@[simp]
theorem enumFrom_eq_nil {n : ℕ} {l : List α} : List.enumFrom n l = [] ↔ l = [] 
Arguments: {α : Type u_1} {n : ℕ} {l : List α}
Goal: List.enumFrom n l = [] ↔ l = []
-- List.enum_eq_nil
@[simp]
theorem enum_eq_nil {l : List α} : List.enum l = [] ↔ l = [] 
Arguments: {α : Type u_1} {l : List α}
Goal: l.enum = [] ↔ l = []
-- List.Nodup.getBijectionOfForallMemList_coe
@[simps]
def getBijectionOfForallMemList (l : List α) (nd : l.Nodup) (h : ∀ x : α, x ∈ l) :
    { f : Fin l.length → α // Function.Bijective f } 
Arguments: {α : Type u_1} (l : List α) (nd : l.Nodup) (h : ∀ (x : α), x ∈ l) (i : Fin l.length)
Goal: ↑(List.Nodup.getBijectionOfForallMemList l nd h) i = l.get i
-- List.Nodup.getEquiv_apply_coe
@[simps]
def getEquiv (l : List α) (H : Nodup l) : Fin (length l) ≃ { x // x ∈ l } 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) (H : l.Nodup) (i : Fin l.length)
Goal: ↑((List.Nodup.getEquiv l H) i) = l.get i
-- List.Nodup.getEquiv_symm_apply_val
@[simps]
def getEquiv (l : List α) (H : Nodup l) : Fin (length l) ≃ { x // x ∈ l } 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) (H : l.Nodup) (x : { x // x ∈ l })
Goal: ↑((List.Nodup.getEquiv l H).symm x) = List.indexOf (↑x) l
-- List.Nodup.getEquivOfForallMemList_apply
@[simps]
def getEquivOfForallMemList (l : List α) (nd : l.Nodup) (h : ∀ x : α, x ∈ l) :
    Fin l.length ≃ α 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) (nd : l.Nodup) (h : ∀ (x : α), x ∈ l) (i : Fin l.length)
Goal: (List.Nodup.getEquivOfForallMemList l nd h) i = l.get i
-- List.Nodup.getEquivOfForallMemList_symm_apply_val
@[simps]
def getEquivOfForallMemList (l : List α) (nd : l.Nodup) (h : ∀ x : α, x ∈ l) :
    Fin l.length ≃ α 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) (nd : l.Nodup) (h : ∀ (x : α), x ∈ l) (a : α)
Goal: ↑((List.Nodup.getEquivOfForallMemList l nd h).symm a) = List.indexOf a l
-- List.Sorted.get_mono
theorem get_mono (h : l.Sorted (· ≤ ·)) : Monotone l.get 
Arguments: {α : Type u_1} [Preorder α] {l : List α} (h : List.Sorted (fun x x_1 => x ≤ x_1) l)
Goal: Monotone l.get
-- List.Sorted.get_strictMono
theorem get_strictMono (h : l.Sorted (· < ·)) : StrictMono l.get 
Arguments: {α : Type u_1} [Preorder α] {l : List α} (h : List.Sorted (fun x x_1 => x < x_1) l)
Goal: StrictMono l.get
-- List.Sorted.coe_getIso_apply
@[simp]
theorem coe_getIso_apply : (H.getIso l i : α) = get l i 
Arguments: {α : Type u_1} [Preorder α] {l : List α} [DecidableEq α] (H : List.Sorted (fun x x_1 => x < x_1) l) {i : Fin l.length}
Goal: ↑((List.Sorted.getIso l H) i) = l.get i
-- List.Sorted.coe_getIso_symm_apply
@[simp]
theorem coe_getIso_symm_apply : ((H.getIso l).symm x : ℕ) = indexOf (↑x) l 
Arguments: {α : Type u_1} [Preorder α] {l : List α} [DecidableEq α] (H : List.Sorted (fun x x_1 => x < x_1) l) {x : { x // x ∈ l }}
Goal: ↑((List.Sorted.getIso l H).symm x) = List.indexOf (↑x) l
-- List.sublist_of_orderEmbedding_get?_eq
theorem sublist_of_orderEmbedding_get?_eq {l l' : List α} (f : ℕ ↪o ℕ)
    (hf : ∀ ix : ℕ, l.get? ix = l'.get? (f ix)) : l <+ l' 
Arguments: {α : Type u_1} {l l' : List α} (f : ℕ ↪o ℕ) (hf : ∀ (ix : ℕ), l.get? ix = l'.get? (f ix))
Goal: l.Sublist l'
-- List.sublist_iff_exists_orderEmbedding_get?_eq
theorem sublist_iff_exists_orderEmbedding_get?_eq {l l' : List α} :
    l <+ l' ↔ ∃ f : ℕ ↪o ℕ, ∀ ix : ℕ, l.get? ix = l'.get? (f ix) 
Arguments: {α : Type u_1} {l l' : List α}
Goal: l.Sublist l' ↔ ∃ f, ∀ (ix : ℕ), l.get? ix = l'.get? (f ix)
-- List.sublist_iff_exists_fin_orderEmbedding_get_eq
theorem sublist_iff_exists_fin_orderEmbedding_get_eq {l l' : List α} :
    l <+ l' ↔
      ∃ f : Fin l.length ↪o Fin l'.length,
        ∀ ix : Fin l.length, l.get ix = l'.get (f ix) 
Arguments: {α : Type u_1} {l l' : List α}
Goal: l.Sublist l' ↔ ∃ f, ∀ (ix : Fin l.length), l.get ix = l'.get (f ix)
-- List.duplicate_iff_exists_distinct_get
theorem duplicate_iff_exists_distinct_get {l : List α} {x : α} :
    l.Duplicate x ↔
      ∃ (n m : Fin l.length) (_ : n < m),
        x = l.get n ∧ x = l.get m 
Arguments: {α : Type u_1} {l : List α} {x : α}
Goal: List.Duplicate x l ↔ ∃ n m, ∃ (_ : n < m), x = l.get n ∧ x = l.get m
-- List.duplicate_iff_exists_distinct_nthLe
@[deprecated duplicate_iff_exists_distinct_get (since := "2023-01-19")]
theorem duplicate_iff_exists_distinct_nthLe {l : List α} {x : α} :
    l.Duplicate x ↔
      ∃ (n : ℕ) (hn : n < l.length) (m : ℕ) (hm : m < l.length) (_ : n < m),
        x = l.nthLe n hn ∧ x = l.nthLe m hm 
Arguments: {α : Type u_1} {l : List α} {x : α}
Goal: List.Duplicate x l ↔
  ∃ n, ∃ (hn : n < l.length), ∃ m, ∃ (hm : m < l.length) (_ : n < m), x = l.nthLe n hn ∧ x = l.nthLe m hm
-- AlgebraicGeometry.Scheme.Pullback.t_fst_fst
@[simp, reassoc]
theorem t_fst_fst (i j : 𝒰.J) : t 𝒰 f g i j ≫ pullback.fst _ _ ≫ pullback.fst _ _ =
    pullback.snd _ _ 
Arguments: {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z) [∀ (i : 𝒰.J), CategoryTheory.Limits.HasPullback (𝒰.map i ≫ f) g] (i j : 𝒰.J)
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)
-- AlgebraicGeometry.Scheme.Pullback.t_fst_snd
@[simp, reassoc]
theorem t_fst_snd (i j : 𝒰.J) :
    t 𝒰 f g i j ≫ pullback.fst _ _ ≫ pullback.snd _ _ = pullback.fst _ _ ≫ pullback.snd _ _ 
Arguments: {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z) [∀ (i : 𝒰.J), CategoryTheory.Limits.HasPullback (𝒰.map i ≫ f) g] (i j : 𝒰.J)
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
-- AlgebraicGeometry.Scheme.Pullback.t_snd
@[simp, reassoc]
theorem t_snd (i j : 𝒰.J) : t 𝒰 f g i j ≫ pullback.snd _ _ =
    pullback.fst _ _ ≫ pullback.fst _ _ 
Arguments: {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z) [∀ (i : 𝒰.J), CategoryTheory.Limits.HasPullback (𝒰.map i ≫ f) g] (i j : 𝒰.J)
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
-- AlgebraicGeometry.Scheme.Pullback.t_id
theorem t_id (i : 𝒰.J) : t 𝒰 f g i i = 𝟙 _ 
Arguments: {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z) [∀ (i : 𝒰.J), CategoryTheory.Limits.HasPullback (𝒰.map i ≫ f) g] (i : 𝒰.J)
Goal: AlgebraicGeometry.Scheme.Pullback.t 𝒰 f g i i = 𝟙 (AlgebraicGeometry.Scheme.Pullback.v 𝒰 f g i i)
-- AlgebraicGeometry.Scheme.Pullback.t'_fst_fst_fst
@[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 _ _ 
Arguments: {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z) [∀ (i : 𝒰.J), CategoryTheory.Limits.HasPullback (𝒰.map i ≫ f) g] (i j k : 𝒰.J)
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)
-- AlgebraicGeometry.Scheme.Pullback.t'_fst_fst_snd
@[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 _ _ 
Arguments: {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z) [∀ (i : 𝒰.J), CategoryTheory.Limits.HasPullback (𝒰.map i ≫ f) g] (i j k : 𝒰.J)
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
-- AlgebraicGeometry.Scheme.Pullback.t'_fst_snd
@[simp, reassoc]
theorem t'_fst_snd (i j k : 𝒰.J) :
    t' 𝒰 f g i j k ≫ pullback.fst _ _ ≫ pullback.snd _ _ =
      pullback.snd _ _ ≫ pullback.snd _ _ 
Arguments: {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z) [∀ (i : 𝒰.J), CategoryTheory.Limits.HasPullback (𝒰.map i ≫ f) g] (i j k : 𝒰.J)
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)
-- AlgebraicGeometry.Scheme.Pullback.t'_snd_fst_fst
@[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 _ _ 
Arguments: {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z) [∀ (i : 𝒰.J), CategoryTheory.Limits.HasPullback (𝒰.map i ≫ f) g] (i j k : 𝒰.J)
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)
-- AlgebraicGeometry.Scheme.Pullback.t'_snd_fst_snd
@[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 _ _ 
Arguments: {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z) [∀ (i : 𝒰.J), CategoryTheory.Limits.HasPullback (𝒰.map i ≫ f) g] (i j k : 𝒰.J)
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
-- AlgebraicGeometry.Scheme.Pullback.t'_snd_snd
@[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 _ _ 
Arguments: {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z) [∀ (i : 𝒰.J), CategoryTheory.Limits.HasPullback (𝒰.map i ≫ f) g] (i j k : 𝒰.J)
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
-- AlgebraicGeometry.Scheme.Pullback.cocycle_fst_fst_fst
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 _ _ 
Arguments: {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z) [∀ (i : 𝒰.J), CategoryTheory.Limits.HasPullback (𝒰.map i ≫ f) g] (i j k : 𝒰.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.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