ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Ordinal.log_opow
theorem log_opow {b : Ordinal} (hb : 1 < b) (x : Ordinal) : log b (b ^ x) = x 
Arguments: {b : Ordinal.{u_1}} (hb : 1 < b) (x : Ordinal.{u_1})
Goal: Ordinal.log b (b ^ x) = x
-- Ordinal.div_opow_log_pos
theorem div_opow_log_pos (b : Ordinal) {o : Ordinal} (ho : o ≠ 0) : 0 < o / (b ^ log b o) 
Arguments: (b : Ordinal.{u_1}) {o : Ordinal.{u_1}} (ho : o ≠ 0)
Goal: 0 < o / b ^ Ordinal.log b o
-- Ordinal.div_opow_log_lt
theorem div_opow_log_lt {b : Ordinal} (o : Ordinal) (hb : 1 < b) : o / (b ^ log b o) < b 
Arguments: {b : Ordinal.{u_1}} (o : Ordinal.{u_1}) (hb : 1 < b)
Goal: o / b ^ Ordinal.log b o < b
-- Ordinal.add_log_le_log_mul
theorem add_log_le_log_mul {x y : Ordinal} (b : Ordinal) (hx : x ≠ 0) (hy : y ≠ 0) :
    log b x + log b y ≤ log b (x * y) 
Arguments: {x y : Ordinal.{u_1}} (b : Ordinal.{u_1}) (hx : x ≠ 0) (hy : y ≠ 0)
Goal: Ordinal.log b x + Ordinal.log b y ≤ Ordinal.log b (x * y)
-- Ordinal.natCast_opow
@[simp, norm_cast]
theorem natCast_opow (m : ℕ) : ∀ n : ℕ, ↑(m ^ n : ℕ) = (m : Ordinal) ^ (n : Ordinal)
  
Arguments: (m n : ℕ)
Goal: ↑(m ^ n) = ↑m ^ ↑n
-- Ordinal.sup_opow_nat
theorem sup_opow_nat {o : Ordinal} (ho : 0 < o) : (sup fun n : ℕ => o ^ (n : Ordinal)) = o ^ ω 
Arguments: {o : Ordinal.{u_1}} (ho : 0 < o)
Goal: (Ordinal.sup fun n => o ^ ↑n) = o ^ ω
-- Quiver.Path.nil_ne_cons
lemma nil_ne_cons (p : Path a b) (e : b ⟶ a) : Path.nil ≠ p.cons e 
Arguments: {V : Type u} [Quiver V] {a b : V} (p : Quiver.Path a b) (e : b ⟶ a)
Goal: Quiver.Path.nil ≠ p.cons e
-- Quiver.Path.cons_ne_nil
lemma cons_ne_nil (p : Path a b) (e : b ⟶ a) : p.cons e ≠ Path.nil 
Arguments: {V : Type u} [Quiver V] {a b : V} (p : Quiver.Path a b) (e : b ⟶ a)
Goal: p.cons e ≠ Quiver.Path.nil
-- Quiver.Path.obj_eq_of_cons_eq_cons
lemma obj_eq_of_cons_eq_cons {p : Path a b} {p' : Path a c}
    {e : b ⟶ d} {e' : c ⟶ d} (h : p.cons e = p'.cons e') : b = c 
Arguments: {V : Type u} [Quiver V] {a b c d : V} {p : Quiver.Path a b} {p' : Quiver.Path a c} {e : b ⟶ d} {e' : c ⟶ d} (h : p.cons e = p'.cons e')
Goal: b = c
-- Quiver.Path.heq_of_cons_eq_cons
lemma heq_of_cons_eq_cons {p : Path a b} {p' : Path a c}
    {e : b ⟶ d} {e' : c ⟶ d} (h : p.cons e = p'.cons e') : HEq p p' 
Arguments: {V : Type u} [Quiver V] {a b c d : V} {p : Quiver.Path a b} {p' : Quiver.Path a c} {e : b ⟶ d} {e' : c ⟶ d} (h : p.cons e = p'.cons e')
Goal: HEq p p'
-- Quiver.Path.hom_heq_of_cons_eq_cons
lemma hom_heq_of_cons_eq_cons {p : Path a b} {p' : Path a c}
    {e : b ⟶ d} {e' : c ⟶ d} (h : p.cons e = p'.cons e') : HEq e e' 
Arguments: {V : Type u} [Quiver V] {a b c d : V} {p : Quiver.Path a b} {p' : Quiver.Path a c} {e : b ⟶ d} {e' : c ⟶ d} (h : p.cons e = p'.cons e')
Goal: HEq e e'
-- Quiver.Path.length_nil
@[simp]
theorem length_nil {a : V} : (nil : Path a a).length = 0 
Arguments: {V : Type u} [Quiver V] {a : V}
Goal: Quiver.Path.nil.length = 0
-- Quiver.Path.length_cons
@[simp]
theorem length_cons (a b c : V) (p : Path a b) (e : b ⟶ c) : (p.cons e).length = p.length + 1 
Arguments: {V : Type u} [Quiver V] (a b c : V) (p : Quiver.Path a b) (e : b ⟶ c)
Goal: (p.cons e).length = p.length + 1
-- Quiver.Path.eq_of_length_zero
theorem eq_of_length_zero (p : Path a b) (hzero : p.length = 0) : a = b 
Arguments: {V : Type u} [Quiver V] {a b : V} (p : Quiver.Path a b) (hzero : p.length = 0)
Goal: a = b
-- Quiver.Path.comp_cons
@[simp]
theorem comp_cons {a b c d : V} (p : Path a b) (q : Path b c) (e : c ⟶ d) :
    p.comp (q.cons e) = (p.comp q).cons e 
Arguments: {V : Type u} [Quiver V] {a b c d : V} (p : Quiver.Path a b) (q : Quiver.Path b c) (e : c ⟶ d)
Goal: p.comp (q.cons e) = (p.comp q).cons e
-- Quiver.Path.comp_nil
@[simp]
theorem comp_nil {a b : V} (p : Path a b) : p.comp Path.nil = p 
Arguments: {V : Type u} [Quiver V] {a b : V} (p : Quiver.Path a b)
Goal: p.comp Quiver.Path.nil = p
-- Quiver.Path.nil_comp
@[simp]
theorem nil_comp {a : V} : ∀ {b} (p : Path a b), Path.nil.comp p = p
  
Arguments: {V : Type u} [Quiver V] {a b : V} (p : Quiver.Path a b)
Goal: Quiver.Path.nil.comp p = p
-- Quiver.Path.comp_assoc
@[simp]
theorem comp_assoc {a b c : V} :
    ∀ {d} (p : Path a b) (q : Path b c) (r : Path c d), (p.comp q).comp r = p.comp (q.comp r)
  
Arguments: {V : Type u} [Quiver V] {a b c d : V} (p : Quiver.Path a b) (q : Quiver.Path b c) (r : Quiver.Path c d)
Goal: (p.comp q).comp r = p.comp (q.comp r)
-- Quiver.Path.length_comp
@[simp]
theorem length_comp (p : Path a b) : ∀ {c} (q : Path b c), (p.comp q).length = p.length + q.length
  
Arguments: {V : Type u} [Quiver V] {a b : V} (p : Quiver.Path a b) {c : V} (q : Quiver.Path b c)
Goal: (p.comp q).length = p.length + q.length
-- Quiver.Path.comp_inj
theorem comp_inj {p₁ p₂ : Path a b} {q₁ q₂ : Path b c} (hq : q₁.length = q₂.length) :
    p₁.comp q₁ = p₂.comp q₂ ↔ p₁ = p₂ ∧ q₁ = q₂ 
Arguments: {V : Type u} [Quiver V] {a b c : V} {p₁ p₂ : Quiver.Path a b} {q₁ q₂ : Quiver.Path b c} (hq : q₁.length = q₂.length)
Goal: p₁.comp q₁ = p₂.comp q₂ ↔ p₁ = p₂ ∧ q₁ = q₂
-- Quiver.Path.comp_inj'
theorem comp_inj' {p₁ p₂ : Path a b} {q₁ q₂ : Path b c} (h : p₁.length = p₂.length) :
    p₁.comp q₁ = p₂.comp q₂ ↔ p₁ = p₂ ∧ q₁ = q₂ 
Arguments: {V : Type u} [Quiver V] {a b c : V} {p₁ p₂ : Quiver.Path a b} {q₁ q₂ : Quiver.Path b c} (h : p₁.length = p₂.length)
Goal: p₁.comp q₁ = p₂.comp q₂ ↔ p₁ = p₂ ∧ q₁ = q₂
-- Quiver.Path.comp_injective_left
theorem comp_injective_left (q : Path b c) : Injective fun p : Path a b => p.comp q 
Arguments: {V : Type u} [Quiver V] {a b c : V} (q : Quiver.Path b c)
Goal: Function.Injective fun p => p.comp q
-- Quiver.Path.comp_injective_right
theorem comp_injective_right (p : Path a b) : Injective (p.comp : Path b c → Path a c) 
Arguments: {V : Type u} [Quiver V] {a b c : V} (p : Quiver.Path a b)
Goal: Function.Injective p.comp
-- Quiver.Path.comp_inj_left
@[simp]
theorem comp_inj_left {p₁ p₂ : Path a b} {q : Path b c} : p₁.comp q = p₂.comp q ↔ p₁ = p₂ 
Arguments: {V : Type u} [Quiver V] {a b c : V} {p₁ p₂ : Quiver.Path a b} {q : Quiver.Path b c}
Goal: p₁.comp q = p₂.comp q ↔ p₁ = p₂
-- Quiver.Path.comp_inj_right
@[simp]
theorem comp_inj_right {p : Path a b} {q₁ q₂ : Path b c} : p.comp q₁ = p.comp q₂ ↔ q₁ = q₂ 
Arguments: {V : Type u} [Quiver V] {a b c : V} {p : Quiver.Path a b} {q₁ q₂ : Quiver.Path b c}
Goal: p.comp q₁ = p.comp q₂ ↔ q₁ = q₂
-- Quiver.Path.toList_comp
@[simp]
theorem toList_comp (p : Path a b) : ∀ {c} (q : Path b c), (p.comp q).toList = q.toList ++ p.toList
  
Arguments: {V : Type u} [Quiver V] {a b : V} (p : Quiver.Path a b) {c : V} (q : Quiver.Path b c)
Goal: (p.comp q).toList = q.toList ++ p.toList
-- Quiver.Path.toList_chain_nonempty
theorem toList_chain_nonempty :
    ∀ {b} (p : Path a b), p.toList.Chain (fun x y => Nonempty (y ⟶ x)) b
  
Arguments: {V : Type u} [Quiver V] {a b : V} (p : Quiver.Path a b)
Goal: List.Chain (fun x y => Nonempty (y ⟶ x)) b p.toList
-- Quiver.Path.toList_injective
theorem toList_injective (a : V) : ∀ b, Injective (toList : Path a b → List V)
  
Arguments: {V : Type u} [Quiver V] [∀ (a b : V), Subsingleton (a ⟶ b)] (a b : V)
Goal: Function.Injective Quiver.Path.toList
-- Quiver.Path.toList_inj
@[simp]
theorem toList_inj {p q : Path a b} : p.toList = q.toList ↔ p = q 
Arguments: {V : Type u} [Quiver V] {a b : V} [∀ (a b : V), Subsingleton (a ⟶ b)] {p q : Quiver.Path a b}
Goal: p.toList = q.toList ↔ p = q
-- Prefunctor.mapPath_nil
@[simp]
theorem mapPath_nil (a : V) : F.mapPath (Path.nil : Path a a) = Path.nil 
Arguments: {V : Type u₁} [Quiver V] {W : Type u₂} [Quiver W] (F : V ⥤q W) (a : V)
Goal: F.mapPath Quiver.Path.nil = Quiver.Path.nil
-- Prefunctor.mapPath_cons
@[simp]
theorem mapPath_cons {a b c : V} (p : Path a b) (e : b ⟶ c) :
    F.mapPath (Path.cons p e) = Path.cons (F.mapPath p) (F.map e) 
Arguments: {V : Type u₁} [Quiver V] {W : Type u₂} [Quiver W] (F : V ⥤q W) {a b c : V} (p : Quiver.Path a b) (e : b ⟶ c)
Goal: F.mapPath (p.cons e) = (F.mapPath p).cons (F.map e)
-- Prefunctor.mapPath_comp
@[simp]
theorem mapPath_comp {a b : V} (p : Path a b) :
    ∀ {c : V} (q : Path b c), F.mapPath (p.comp q) = (F.mapPath p).comp (F.mapPath q)
  
Arguments: {V : Type u₁} [Quiver V] {W : Type u₂} [Quiver W] (F : V ⥤q W) {a b : V} (p : Quiver.Path a b) {c : V} (q : Quiver.Path b c)
Goal: F.mapPath (p.comp q) = (F.mapPath p).comp (F.mapPath q)
-- Prefunctor.mapPath_toPath
@[simp]
theorem mapPath_toPath {a b : V} (f : a ⟶ b) : F.mapPath f.toPath = (F.map f).toPath 
Arguments: {V : Type u₁} [Quiver V] {W : Type u₂} [Quiver W] (F : V ⥤q W) {a b : V} (f : a ⟶ b)
Goal: F.mapPath f.toPath = (F.map f).toPath
-- CategoryTheory.Arrow.cechNerve_obj
@[simps]
def cechNerve : SimplicialObject C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow C) [∀ (n : ℕ), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom] (n : SimplexCategoryᵒᵖ)
Goal: f.cechNerve.obj n = CategoryTheory.Limits.widePullback f.right (fun x => f.left) fun x => f.hom
-- CategoryTheory.Arrow.cechNerve_map
@[simps]
def cechNerve : SimplicialObject C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow C) [∀ (n : ℕ), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom]
Goal: ∀ {X Y : SimplexCategoryᵒᵖ} (g : X ⟶ Y),
  f.cechNerve.map g =
    CategoryTheory.Limits.WidePullback.lift (CategoryTheory.Limits.WidePullback.base fun x => f.hom)
      (fun i => CategoryTheory.Limits.WidePullback.π (fun x => f.hom) ((SimplexCategory.Hom.toOrderHom g.unop) i)) ⋯
-- CategoryTheory.Arrow.mapCechNerve_app
@[simps]
def mapCechNerve {f g : Arrow C}
    [∀ n : ℕ, HasWidePullback f.right (fun _ : Fin (n + 1) => f.left) fun _ => f.hom]
    [∀ n : ℕ, HasWidePullback g.right (fun _ : Fin (n + 1) => g.left) fun _ => g.hom] (F : f ⟶ g) :
    f.cechNerve ⟶ g.cechNerve 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {f g : CategoryTheory.Arrow C} [∀ (n : ℕ), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom] [∀ (n : ℕ), CategoryTheory.Limits.HasWidePullback g.right (fun x => g.left) fun x => g.hom] (F : f ⟶ g) (n : SimplexCategoryᵒᵖ)
Goal: (CategoryTheory.Arrow.mapCechNerve F).app n =
  CategoryTheory.Limits.WidePullback.lift ((CategoryTheory.Limits.WidePullback.base fun x => f.hom) ≫ F.right)
    (fun i => CategoryTheory.Limits.WidePullback.π (fun x => f.hom) i ≫ F.left) ⋯
-- CategoryTheory.Arrow.augmentedCechNerve_right
@[simps]
def augmentedCechNerve : SimplicialObject.Augmented C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow C) [∀ (n : ℕ), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom]
Goal: f.augmentedCechNerve.right = f.right
-- CategoryTheory.Arrow.augmentedCechNerve_left
@[simps]
def augmentedCechNerve : SimplicialObject.Augmented C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow C) [∀ (n : ℕ), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom]
Goal: f.augmentedCechNerve.left = f.cechNerve
-- CategoryTheory.Arrow.augmentedCechNerve_hom_app
@[simps]
def augmentedCechNerve : SimplicialObject.Augmented C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow C) [∀ (n : ℕ), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom] (i : SimplexCategoryᵒᵖ)
Goal: f.augmentedCechNerve.hom.app i = CategoryTheory.Limits.WidePullback.base fun x => f.hom
-- CategoryTheory.Arrow.mapAugmentedCechNerve_left
@[simps]
def mapAugmentedCechNerve {f g : Arrow C}
    [∀ n : ℕ, HasWidePullback f.right (fun _ : Fin (n + 1) => f.left) fun _ => f.hom]
    [∀ n : ℕ, HasWidePullback g.right (fun _ : Fin (n + 1) => g.left) fun _ => g.hom] (F : f ⟶ g) :
    f.augmentedCechNerve ⟶ g.augmentedCechNerve 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {f g : CategoryTheory.Arrow C} [∀ (n : ℕ), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom] [∀ (n : ℕ), CategoryTheory.Limits.HasWidePullback g.right (fun x => g.left) fun x => g.hom] (F : f ⟶ g)
Goal: (CategoryTheory.Arrow.mapAugmentedCechNerve F).left = CategoryTheory.Arrow.mapCechNerve F
-- CategoryTheory.Arrow.mapAugmentedCechNerve_right
@[simps]
def mapAugmentedCechNerve {f g : Arrow C}
    [∀ n : ℕ, HasWidePullback f.right (fun _ : Fin (n + 1) => f.left) fun _ => f.hom]
    [∀ n : ℕ, HasWidePullback g.right (fun _ : Fin (n + 1) => g.left) fun _ => g.hom] (F : f ⟶ g) :
    f.augmentedCechNerve ⟶ g.augmentedCechNerve 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {f g : CategoryTheory.Arrow C} [∀ (n : ℕ), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom] [∀ (n : ℕ), CategoryTheory.Limits.HasWidePullback g.right (fun x => g.left) fun x => g.hom] (F : f ⟶ g)
Goal: (CategoryTheory.Arrow.mapAugmentedCechNerve F).right = F.right
-- CategoryTheory.SimplicialObject.cechNerve_obj
@[simps]
def cechNerve : Arrow C ⥤ SimplicialObject C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [∀ (n : ℕ) (f : CategoryTheory.Arrow C), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom] (f : CategoryTheory.Arrow C)
Goal: CategoryTheory.SimplicialObject.cechNerve.obj f = f.cechNerve
-- CategoryTheory.SimplicialObject.cechNerve_map
@[simps]
def cechNerve : Arrow C ⥤ SimplicialObject C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [∀ (n : ℕ) (f : CategoryTheory.Arrow C), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom]
Goal: ∀ {X Y : CategoryTheory.Arrow C} (F : X ⟶ Y),
  CategoryTheory.SimplicialObject.cechNerve.map F = CategoryTheory.Arrow.mapCechNerve F
-- CategoryTheory.SimplicialObject.augmentedCechNerve_obj_right
@[simps!]
def augmentedCechNerve : Arrow C ⥤ SimplicialObject.Augmented C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [∀ (n : ℕ) (f : CategoryTheory.Arrow C), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom] (f : CategoryTheory.Arrow C)
Goal: (CategoryTheory.SimplicialObject.augmentedCechNerve.obj f).right = f.right
-- CategoryTheory.SimplicialObject.augmentedCechNerve_obj_left_map
@[simps!]
def augmentedCechNerve : Arrow C ⥤ SimplicialObject.Augmented C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [∀ (n : ℕ) (f : CategoryTheory.Arrow C), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom] (f : CategoryTheory.Arrow C)
Goal: ∀ {X Y : SimplexCategoryᵒᵖ} (g : X ⟶ Y),
  (CategoryTheory.SimplicialObject.augmentedCechNerve.obj f).left.map g =
    CategoryTheory.Limits.WidePullback.lift (CategoryTheory.Limits.WidePullback.base fun x => f.hom)
      (fun i => CategoryTheory.Limits.WidePullback.π (fun x => f.hom) ((SimplexCategory.Hom.toOrderHom g.unop) i)) ⋯
-- CategoryTheory.SimplicialObject.augmentedCechNerve_map_left_app
@[simps!]
def augmentedCechNerve : Arrow C ⥤ SimplicialObject.Augmented C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [∀ (n : ℕ) (f : CategoryTheory.Arrow C), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom]
Goal: ∀ {X Y : CategoryTheory.Arrow C} (F : X ⟶ Y) (n : SimplexCategoryᵒᵖ),
  (CategoryTheory.SimplicialObject.augmentedCechNerve.map F).left.app n =
    CategoryTheory.Limits.WidePullback.lift ((CategoryTheory.Limits.WidePullback.base fun x => X.hom) ≫ F.right)
      (fun i => CategoryTheory.Limits.WidePullback.π (fun x => X.hom) i ≫ F.left) ⋯
-- CategoryTheory.SimplicialObject.augmentedCechNerve_map_right
@[simps!]
def augmentedCechNerve : Arrow C ⥤ SimplicialObject.Augmented C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [∀ (n : ℕ) (f : CategoryTheory.Arrow C), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom]
Goal: ∀ {X Y : CategoryTheory.Arrow C} (F : X ⟶ Y), (CategoryTheory.SimplicialObject.augmentedCechNerve.map F).right = F.right
-- CategoryTheory.SimplicialObject.augmentedCechNerve_obj_left_obj
@[simps!]
def augmentedCechNerve : Arrow C ⥤ SimplicialObject.Augmented C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [∀ (n : ℕ) (f : CategoryTheory.Arrow C), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom] (f : CategoryTheory.Arrow C) (n : SimplexCategoryᵒᵖ)
Goal: (CategoryTheory.SimplicialObject.augmentedCechNerve.obj f).left.obj n =
  CategoryTheory.Limits.widePullback f.right (fun x => f.left) fun x => f.hom
-- CategoryTheory.SimplicialObject.augmentedCechNerve_obj_hom_app
@[simps!]
def augmentedCechNerve : Arrow C ⥤ SimplicialObject.Augmented C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [∀ (n : ℕ) (f : CategoryTheory.Arrow C), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom] (f : CategoryTheory.Arrow C) (i : SimplexCategoryᵒᵖ)
Goal: (CategoryTheory.SimplicialObject.augmentedCechNerve.obj f).hom.app i =
  CategoryTheory.Limits.WidePullback.base fun x => f.hom
-- CategoryTheory.SimplicialObject.equivalenceRightToLeft_left
@[simps]
def equivalenceRightToLeft (X : SimplicialObject.Augmented C) (F : Arrow C)
    (G : X ⟶ F.augmentedCechNerve) : Augmented.toArrow.obj X ⟶ F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [∀ (n : ℕ) (f : CategoryTheory.Arrow C), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom] (X : CategoryTheory.SimplicialObject.Augmented C) (F : CategoryTheory.Arrow C) (G : X ⟶ F.augmentedCechNerve)
Goal: (CategoryTheory.SimplicialObject.equivalenceRightToLeft X F G).left =
  G.left.app (Opposite.op (SimplexCategory.mk 0)) ≫ CategoryTheory.Limits.WidePullback.π (fun x => F.hom) 0
-- CategoryTheory.SimplicialObject.equivalenceRightToLeft_right
@[simps]
def equivalenceRightToLeft (X : SimplicialObject.Augmented C) (F : Arrow C)
    (G : X ⟶ F.augmentedCechNerve) : Augmented.toArrow.obj X ⟶ F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [∀ (n : ℕ) (f : CategoryTheory.Arrow C), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom] (X : CategoryTheory.SimplicialObject.Augmented C) (F : CategoryTheory.Arrow C) (G : X ⟶ F.augmentedCechNerve)
Goal: (CategoryTheory.SimplicialObject.equivalenceRightToLeft X F G).right = G.right
-- CategoryTheory.SimplicialObject.equivalenceLeftToRight_left_app
@[simps]
def equivalenceLeftToRight (X : SimplicialObject.Augmented C) (F : Arrow C)
    (G : Augmented.toArrow.obj X ⟶ F) : X ⟶ F.augmentedCechNerve 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [∀ (n : ℕ) (f : CategoryTheory.Arrow C), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom] (X : CategoryTheory.SimplicialObject.Augmented C) (F : CategoryTheory.Arrow C) (G : CategoryTheory.SimplicialObject.Augmented.toArrow.obj X ⟶ F) (x : SimplexCategoryᵒᵖ)
Goal: (CategoryTheory.SimplicialObject.equivalenceLeftToRight X F G).left.app x =
  CategoryTheory.Limits.WidePullback.lift (X.hom.app x ≫ G.right)
    (fun i => X.left.map ((SimplexCategory.mk 0).const (Opposite.unop x) i).op ≫ G.left) ⋯
-- CategoryTheory.SimplicialObject.equivalenceLeftToRight_right
@[simps]
def equivalenceLeftToRight (X : SimplicialObject.Augmented C) (F : Arrow C)
    (G : Augmented.toArrow.obj X ⟶ F) : X ⟶ F.augmentedCechNerve 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [∀ (n : ℕ) (f : CategoryTheory.Arrow C), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom] (X : CategoryTheory.SimplicialObject.Augmented C) (F : CategoryTheory.Arrow C) (G : CategoryTheory.SimplicialObject.Augmented.toArrow.obj X ⟶ F)
Goal: (CategoryTheory.SimplicialObject.equivalenceLeftToRight X F G).right = G.right
-- CategoryTheory.SimplicialObject.cechNerveEquiv_symm_apply
@[simps]
def cechNerveEquiv (X : SimplicialObject.Augmented C) (F : Arrow C) :
    (Augmented.toArrow.obj X ⟶ F) ≃ (X ⟶ F.augmentedCechNerve) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [∀ (n : ℕ) (f : CategoryTheory.Arrow C), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom] (X : CategoryTheory.SimplicialObject.Augmented C) (F : CategoryTheory.Arrow C) (G : X ⟶ F.augmentedCechNerve)
Goal: (CategoryTheory.SimplicialObject.cechNerveEquiv X F).symm G =
  CategoryTheory.SimplicialObject.equivalenceRightToLeft X F G
-- CategoryTheory.SimplicialObject.cechNerveEquiv_apply
@[simps]
def cechNerveEquiv (X : SimplicialObject.Augmented C) (F : Arrow C) :
    (Augmented.toArrow.obj X ⟶ F) ≃ (X ⟶ F.augmentedCechNerve) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [∀ (n : ℕ) (f : CategoryTheory.Arrow C), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom] (X : CategoryTheory.SimplicialObject.Augmented C) (F : CategoryTheory.Arrow C) (G : CategoryTheory.SimplicialObject.Augmented.toArrow.obj X ⟶ F)
Goal: (CategoryTheory.SimplicialObject.cechNerveEquiv X F) G = CategoryTheory.SimplicialObject.equivalenceLeftToRight X F G
-- CategoryTheory.Arrow.cechConerve_obj
@[simps]
def cechConerve : CosimplicialObject C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow C) [∀ (n : ℕ), CategoryTheory.Limits.HasWidePushout f.left (fun x => f.right) fun x => f.hom] (n : SimplexCategory)
Goal: f.cechConerve.obj n = CategoryTheory.Limits.widePushout f.left (fun x => f.right) fun x => f.hom
-- CategoryTheory.Arrow.cechConerve_map
@[simps]
def cechConerve : CosimplicialObject C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow C) [∀ (n : ℕ), CategoryTheory.Limits.HasWidePushout f.left (fun x => f.right) fun x => f.hom] {x y : SimplexCategory} (g : x ⟶ y)
Goal: f.cechConerve.map g =
  CategoryTheory.Limits.WidePushout.desc (CategoryTheory.Limits.WidePushout.head fun x => f.hom)
    (fun i => CategoryTheory.Limits.WidePushout.ι (fun x => f.hom) ((SimplexCategory.Hom.toOrderHom g) i)) ⋯
-- CategoryTheory.Arrow.mapCechConerve_app
@[simps]
def mapCechConerve {f g : Arrow C}
    [∀ n : ℕ, HasWidePushout f.left (fun _ : Fin (n + 1) => f.right) fun _ => f.hom]
    [∀ n : ℕ, HasWidePushout g.left (fun _ : Fin (n + 1) => g.right) fun _ => g.hom] (F : f ⟶ g) :
    f.cechConerve ⟶ g.cechConerve 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {f g : CategoryTheory.Arrow C} [∀ (n : ℕ), CategoryTheory.Limits.HasWidePushout f.left (fun x => f.right) fun x => f.hom] [∀ (n : ℕ), CategoryTheory.Limits.HasWidePushout g.left (fun x => g.right) fun x => g.hom] (F : f ⟶ g) (n : SimplexCategory)
Goal: (CategoryTheory.Arrow.mapCechConerve F).app n =
  CategoryTheory.Limits.WidePushout.desc (F.left ≫ CategoryTheory.Limits.WidePushout.head fun x => g.hom)
    (fun i => F.right ≫ CategoryTheory.Limits.WidePushout.ι (fun x => g.hom) i) ⋯
-- CategoryTheory.Arrow.augmentedCechConerve_right
@[simps]
def augmentedCechConerve : CosimplicialObject.Augmented C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow C) [∀ (n : ℕ), CategoryTheory.Limits.HasWidePushout f.left (fun x => f.right) fun x => f.hom]
Goal: f.augmentedCechConerve.right = f.cechConerve
-- CategoryTheory.Arrow.augmentedCechConerve_left
@[simps]
def augmentedCechConerve : CosimplicialObject.Augmented C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow C) [∀ (n : ℕ), CategoryTheory.Limits.HasWidePushout f.left (fun x => f.right) fun x => f.hom]
Goal: f.augmentedCechConerve.left = f.left
-- CategoryTheory.Arrow.augmentedCechConerve_hom_app
@[simps]
def augmentedCechConerve : CosimplicialObject.Augmented C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow C) [∀ (n : ℕ), CategoryTheory.Limits.HasWidePushout f.left (fun x => f.right) fun x => f.hom] (i : SimplexCategory)
Goal: f.augmentedCechConerve.hom.app i = CategoryTheory.Limits.WidePushout.head fun x => f.hom