ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- SetTheory.PGame.lt_def
theorem lt_def {x y : PGame} (ox : x.Numeric) (oy : y.Numeric) :
    x < y ↔
      (∃ i, (∀ i', x.moveLeft i' < y.moveLeft i) ∧ ∀ j, x < (y.moveLeft i).moveRight j) ∨
        ∃ j, (∀ i, (x.moveRight j).moveLeft i < y) ∧ ∀ j', x.moveRight j < y.moveRight j' 
Arguments: {x y : SetTheory.PGame} (ox : x.Numeric) (oy : y.Numeric)
Goal: x < y ↔
  (∃ i,
      (∀ (i' : x.LeftMoves), x.moveLeft i' < y.moveLeft i) ∧
        ∀ (j : (y.moveLeft i).RightMoves), x < (y.moveLeft i).moveRight j) ∨
    ∃ j,
      (∀ (i : (x.moveRight j).LeftMoves), (x.moveRight j).moveLeft i < y) ∧
        ∀ (j' : y.RightMoves), x.moveRight j < y.moveRight j'
-- SetTheory.PGame.not_fuzzy
theorem not_fuzzy {x y : PGame} (ox : Numeric x) (oy : Numeric y) : ¬Fuzzy x y 
Arguments: {x y : SetTheory.PGame} (ox : x.Numeric) (oy : y.Numeric)
Goal: ¬x ‖ y
-- SetTheory.PGame.lt_or_equiv_or_gt
theorem lt_or_equiv_or_gt {x y : PGame} (ox : Numeric x) (oy : Numeric y) :
    x < y ∨ (x ≈ y) ∨ y < x 
Arguments: {x y : SetTheory.PGame} (ox : x.Numeric) (oy : y.Numeric)
Goal: x < y ∨ x ≈ y ∨ y < x
-- SetTheory.PGame.numeric_of_isEmpty
theorem numeric_of_isEmpty (x : PGame) [IsEmpty x.LeftMoves] [IsEmpty x.RightMoves] : Numeric x 
Arguments: (x : SetTheory.PGame) [IsEmpty x.LeftMoves] [IsEmpty x.RightMoves]
Goal: x.Numeric
-- SetTheory.PGame.numeric_of_isEmpty_leftMoves
theorem numeric_of_isEmpty_leftMoves (x : PGame) [IsEmpty x.LeftMoves] :
    (∀ j, Numeric (x.moveRight j)) → Numeric x 
Arguments: (x : SetTheory.PGame) [IsEmpty x.LeftMoves]
Goal: (∀ (j : x.RightMoves), (x.moveRight j).Numeric) → x.Numeric
-- SetTheory.PGame.numeric_of_isEmpty_rightMoves
theorem numeric_of_isEmpty_rightMoves (x : PGame) [IsEmpty x.RightMoves]
    (H : ∀ i, Numeric (x.moveLeft i)) : Numeric x 
Arguments: (x : SetTheory.PGame) [IsEmpty x.RightMoves] (H : ∀ (i : x.LeftMoves), (x.moveLeft i).Numeric)
Goal: x.Numeric
-- SetTheory.PGame.numeric_zero
theorem numeric_zero : Numeric 0 
Goal: SetTheory.PGame.Numeric 0
-- SetTheory.PGame.numeric_one
theorem numeric_one : Numeric 1 
Goal: SetTheory.PGame.Numeric 1
-- SetTheory.PGame.Numeric.neg
theorem Numeric.neg : ∀ {x : PGame} (_ : Numeric x), Numeric (-x)
  
Arguments: {x : SetTheory.PGame}
Goal: x.Numeric → (-x).Numeric
-- SetTheory.PGame.insertLeft_numeric
theorem insertLeft_numeric {x x' : PGame} (x_num : x.Numeric) (x'_num : x'.Numeric)
    (h : x' ≤ x) : (insertLeft x x').Numeric 
Arguments: {x x' : SetTheory.PGame} (x_num : x.Numeric) (x'_num : x'.Numeric) (h : x' ≤ x)
Goal: (x.insertLeft x').Numeric
-- SetTheory.PGame.insertRight_numeric
theorem insertRight_numeric {x x' : PGame} (x_num : x.Numeric) (x'_num : x'.Numeric)
    (h : x ≤ x') : (insertRight x x').Numeric 
Arguments: {x x' : SetTheory.PGame} (x_num : x.Numeric) (x'_num : x'.Numeric) (h : x ≤ x')
Goal: (x.insertRight x').Numeric
-- SetTheory.PGame.Numeric.moveLeft_lt
theorem moveLeft_lt {x : PGame} (o : Numeric x) (i) : x.moveLeft i < x 
Arguments: {x : SetTheory.PGame} (o : x.Numeric) (i : x.LeftMoves)
Goal: x.moveLeft i < x
-- SetTheory.PGame.Numeric.moveLeft_le
theorem moveLeft_le {x : PGame} (o : Numeric x) (i) : x.moveLeft i ≤ x 
Arguments: {x : SetTheory.PGame} (o : x.Numeric) (i : x.LeftMoves)
Goal: x.moveLeft i ≤ x
-- SetTheory.PGame.Numeric.lt_moveRight
theorem lt_moveRight {x : PGame} (o : Numeric x) (j) : x < x.moveRight j 
Arguments: {x : SetTheory.PGame} (o : x.Numeric) (j : x.RightMoves)
Goal: x < x.moveRight j
-- SetTheory.PGame.Numeric.le_moveRight
theorem le_moveRight {x : PGame} (o : Numeric x) (j) : x ≤ x.moveRight j 
Arguments: {x : SetTheory.PGame} (o : x.Numeric) (j : x.RightMoves)
Goal: x ≤ x.moveRight j
-- SetTheory.PGame.Numeric.add
theorem add : ∀ {x y : PGame} (_ : Numeric x) (_ : Numeric y), Numeric (x + y)
  
Arguments: {x y : SetTheory.PGame}
Goal: x.Numeric → y.Numeric → (x + y).Numeric
-- SetTheory.PGame.Numeric.sub
theorem sub {x y : PGame} (ox : Numeric x) (oy : Numeric y) : Numeric (x - y) 
Arguments: {x y : SetTheory.PGame} (ox : x.Numeric) (oy : y.Numeric)
Goal: (x - y).Numeric
-- SetTheory.PGame.numeric_nat
theorem numeric_nat : ∀ n : ℕ, Numeric n
  
Arguments: (n : ℕ)
Goal: (↑n).Numeric
-- SetTheory.PGame.numeric_toPGame
theorem numeric_toPGame (o : Ordinal) : o.toPGame.Numeric 
Arguments: (o : Ordinal.{u_1})
Goal: o.toPGame.Numeric
-- Surreal.mk_eq_mk
lemma mk_eq_mk {x y : PGame.{u}} {hx hy} : mk x hx = mk y hy ↔ x ≈ y 
Arguments: {x y : SetTheory.PGame} {hx : x.Numeric} {hy : y.Numeric}
Goal: Surreal.mk x hx = Surreal.mk y hy ↔ x ≈ y
-- Surreal.mk_eq_zero
lemma mk_eq_zero {x : PGame.{u}} {hx} : mk x hx = 0 ↔ x ≈ 0 
Arguments: {x : SetTheory.PGame} {hx : x.Numeric}
Goal: Surreal.mk x hx = 0 ↔ x ≈ 0
-- Surreal.mk_le_mk
@[simp]
lemma mk_le_mk {x y : PGame.{u}} {hx hy} : mk x hx ≤ mk y hy ↔ x ≤ y 
Arguments: {x y : SetTheory.PGame} {hx : x.Numeric} {hy : y.Numeric}
Goal: Surreal.mk x hx ≤ Surreal.mk y hy ↔ x ≤ y
-- Surreal.zero_le_mk
lemma zero_le_mk {x : PGame.{u}} {hx} : 0 ≤ mk x hx ↔ 0 ≤ x 
Arguments: {x : SetTheory.PGame} {hx : x.Numeric}
Goal: 0 ≤ Surreal.mk x hx ↔ 0 ≤ x
-- Surreal.mk_lt_mk
lemma mk_lt_mk {x y : PGame.{u}} {hx hy} : mk x hx < mk y hy ↔ x < y 
Arguments: {x y : SetTheory.PGame} {hx : x.Numeric} {hy : y.Numeric}
Goal: Surreal.mk x hx < Surreal.mk y hy ↔ x < y
-- Surreal.zero_lt_mk
lemma zero_lt_mk {x : PGame.{u}} {hx} : 0 < mk x hx ↔ 0 < x 
Arguments: {x : SetTheory.PGame} {hx : x.Numeric}
Goal: 0 < Surreal.mk x hx ↔ 0 < x
-- Surreal.mk_moveLeft_lt_mk
theorem mk_moveLeft_lt_mk {x : PGame} (o : Numeric x) (i) :
    Surreal.mk (x.moveLeft i) (Numeric.moveLeft o i) < Surreal.mk x o 
Arguments: {x : SetTheory.PGame} (o : x.Numeric) (i : x.LeftMoves)
Goal: Surreal.mk (x.moveLeft i) ⋯ < Surreal.mk x o
-- Surreal.mk_lt_mk_moveRight
theorem mk_lt_mk_moveRight {x : PGame} (o : Numeric x) (j) :
    Surreal.mk x o < Surreal.mk (x.moveRight j) (Numeric.moveRight o j) 
Arguments: {x : SetTheory.PGame} (o : x.Numeric) (j : x.RightMoves)
Goal: Surreal.mk x o < Surreal.mk (x.moveRight j) ⋯
-- Surreal.mk_add
lemma mk_add {x y : PGame} (hx : x.Numeric) (hy : y.Numeric) :
    Surreal.mk (x + y) (hx.add hy) = Surreal.mk x hx + Surreal.mk y hy 
Arguments: {x y : SetTheory.PGame} (hx : x.Numeric) (hy : y.Numeric)
Goal: Surreal.mk (x + y) ⋯ = Surreal.mk x hx + Surreal.mk y hy
-- Surreal.mk_sub
lemma mk_sub {x y : PGame} (hx : x.Numeric) (hy : y.Numeric) :
    Surreal.mk (x - y) (hx.sub hy) = Surreal.mk x hx - Surreal.mk y hy 
Arguments: {x y : SetTheory.PGame} (hx : x.Numeric) (hy : y.Numeric)
Goal: Surreal.mk (x - y) ⋯ = Surreal.mk x hx - Surreal.mk y hy
-- Surreal.zero_def
lemma zero_def : 0 = mk 0 numeric_zero 
Goal: 0 = Surreal.mk 0 SetTheory.PGame.numeric_zero
-- Surreal.zero_toGame
theorem zero_toGame : toGame 0 = 0 
Goal: Surreal.toGame 0 = 0
-- Surreal.one_toGame
@[simp]
theorem one_toGame : toGame 1 = 1 
Goal: Surreal.toGame 1 = 1
-- Surreal.nat_toGame
@[simp]
theorem nat_toGame : ∀ n : ℕ, toGame n = n 
Arguments: (n : ℕ)
Goal: Surreal.toGame ↑n = ↑n
-- Surreal.bddAbove_range_of_small
lemma bddAbove_range_of_small {ι : Type*} [Small.{u} ι] (f : ι → Surreal.{u}) :
    BddAbove (Set.range f) 
Arguments: {ι : Type u_1} [Small.{u, u_1} ι] (f : ι → Surreal)
Goal: BddAbove (Set.range f)
-- Surreal.bddAbove_of_small
lemma bddAbove_of_small (s : Set Surreal.{u}) [Small.{u} s] : BddAbove s 
Arguments: (s : Set Surreal) [Small.{u, u + 1} ↑s]
Goal: BddAbove s
-- Surreal.bddBelow_range_of_small
lemma bddBelow_range_of_small {ι : Type*} [Small.{u} ι] (f : ι → Surreal.{u}) :
    BddBelow (Set.range f) 
Arguments: {ι : Type u_1} [Small.{u, u_1} ι] (f : ι → Surreal)
Goal: BddBelow (Set.range f)
-- Surreal.bddBelow_of_small
lemma bddBelow_of_small (s : Set Surreal.{u}) [Small.{u} s] : BddBelow s 
Arguments: (s : Set Surreal) [Small.{u, u + 1} ↑s]
Goal: BddBelow s
-- Quiver.RootedConnected.nonempty_path
class RootedConnected {V : Type u} [Quiver V] (r : V) : Prop where
  nonempty_path : ∀ b : V, Nonempty (Path r b)
Arguments: {V : Type u} [Quiver V] {r : V} [self : Quiver.RootedConnected r] (b : V)
Goal: Nonempty (Quiver.Path r b)
-- Quiver.shortest_path_spec
theorem shortest_path_spec {a : V} (p : Path r a) : (shortestPath r a).length ≤ p.length 
Arguments: {V : Type u} [Quiver V] (r : V) [Quiver.RootedConnected r] {a : V} (p : Quiver.Path r a)
Goal: (Quiver.shortestPath r a).length ≤ p.length
-- Quiver.Push.of_obj
@[simp]
theorem of_obj : (of σ).obj = σ 
Arguments: {V : Type u_1} [Quiver V] {W : Type u_2} (σ : V → W)
Goal: (Quiver.Push.of σ).obj = σ
-- Quiver.Push.lift_obj
theorem lift_obj : (lift σ φ τ h).obj = τ 
Arguments: {V : Type u_1} [Quiver V] {W : Type u_2} (σ : V → W) {W' : Type u_3} [Quiver W'] (φ : V ⥤q W') (τ : W → W') (h : ∀ (x : V), φ.obj x = τ (σ x))
Goal: (Quiver.Push.lift σ φ τ h).obj = τ
-- Quiver.Push.lift_comp
theorem lift_comp : (of σ ⋙q lift σ φ τ h) = φ 
Arguments: {V : Type u_1} [Quiver V] {W : Type u_2} (σ : V → W) {W' : Type u_3} [Quiver W'] (φ : V ⥤q W') (τ : W → W') (h : ∀ (x : V), φ.obj x = τ (σ x))
Goal: Quiver.Push.of σ ⋙q Quiver.Push.lift σ φ τ h = φ
-- Quiver.Push.lift_unique
theorem lift_unique (Φ : Push σ ⥤q W') (Φ₀ : Φ.obj = τ) (Φcomp : (of σ ⋙q Φ) = φ) :
    Φ = lift σ φ τ h 
Arguments: {V : Type u_1} [Quiver V] {W : Type u_2} (σ : V → W) {W' : Type u_3} [Quiver W'] (φ : V ⥤q W') (τ : W → W') (h : ∀ (x : V), φ.obj x = τ (σ x)) (Φ : Quiver.Push σ ⥤q W') (Φ₀ : Φ.obj = τ) (Φcomp : Quiver.Push.of σ ⋙q Φ = φ)
Goal: Φ = Quiver.Push.lift σ φ τ h
-- Quiver.SingleObj.ext
lemma ext {x y : SingleObj α} : x = y 
Arguments: {α : Type u_1} {x y : Quiver.SingleObj α}
Goal: x = y
-- Quiver.SingleObj.toHom_symm_apply
@[simps!]
def toHom : α ≃ (star α ⟶ star α) 
Arguments: {α : Type u_1} (a : α)
Goal: Quiver.SingleObj.toHom.symm a = a
-- Quiver.SingleObj.toHom_apply
@[simps!]
def toHom : α ≃ (star α ⟶ star α) 
Arguments: {α : Type u_1} (a : α)
Goal: Quiver.SingleObj.toHom a = a
-- Quiver.SingleObj.toPrefunctor_apply_obj
@[simps]
def toPrefunctor : (α → β) ≃ SingleObj α ⥤q SingleObj β 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (a : Quiver.SingleObj α)
Goal: (Quiver.SingleObj.toPrefunctor f).obj a = id a
-- Quiver.SingleObj.toPrefunctor_symm_apply
@[simps]
def toPrefunctor : (α → β) ≃ SingleObj α ⥤q SingleObj β 
Arguments: {α : Type u_1} {β : Type u_2} (f : Quiver.SingleObj α ⥤q Quiver.SingleObj β) (a : α)
Goal: Quiver.SingleObj.toPrefunctor.symm f a = f.map (Quiver.SingleObj.toHom a)
-- Quiver.SingleObj.toPrefunctor_apply_map
@[simps]
def toPrefunctor : (α → β) ≃ SingleObj α ⥤q SingleObj β 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β)
Goal: ∀ {X Y : Quiver.SingleObj α} (a : α), (Quiver.SingleObj.toPrefunctor f).map a = f a
-- Quiver.SingleObj.toPrefunctor_id
theorem toPrefunctor_id : toPrefunctor id = 𝟭q (SingleObj α) 
Arguments: {α : Type u_1}
Goal: Quiver.SingleObj.toPrefunctor id = 𝟭q (Quiver.SingleObj α)
-- Quiver.SingleObj.toPrefunctor_symm_id
@[simp]
theorem toPrefunctor_symm_id : toPrefunctor.symm (𝟭q (SingleObj α)) = id 
Arguments: {α : Type u_1}
Goal: Quiver.SingleObj.toPrefunctor.symm (𝟭q (Quiver.SingleObj α)) = id
-- Quiver.SingleObj.toPrefunctor_comp
theorem toPrefunctor_comp (f : α → β) (g : β → γ) :
    toPrefunctor (g ∘ f) = toPrefunctor f ⋙q toPrefunctor g 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β) (g : β → γ)
Goal: Quiver.SingleObj.toPrefunctor (g ∘ f) = Quiver.SingleObj.toPrefunctor f ⋙q Quiver.SingleObj.toPrefunctor g
-- Quiver.SingleObj.toPrefunctor_symm_comp
@[simp]
theorem toPrefunctor_symm_comp (f : SingleObj α ⥤q SingleObj β) (g : SingleObj β ⥤q SingleObj γ) :
    toPrefunctor.symm (f ⋙q g) = toPrefunctor.symm g ∘ toPrefunctor.symm f 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : Quiver.SingleObj α ⥤q Quiver.SingleObj β) (g : Quiver.SingleObj β ⥤q Quiver.SingleObj γ)
Goal: Quiver.SingleObj.toPrefunctor.symm (f ⋙q g) =
  Quiver.SingleObj.toPrefunctor.symm g ∘ Quiver.SingleObj.toPrefunctor.symm f
-- Quiver.SingleObj.listToPath_pathToList
theorem listToPath_pathToList {x : SingleObj α} (p : Path (star α) x) :
    listToPath (pathToList p) = p.cast rfl ext 
Arguments: {α : Type u_1} {x : Quiver.SingleObj α} (p : Quiver.Path (Quiver.SingleObj.star α) x)
Goal: Quiver.SingleObj.listToPath (Quiver.SingleObj.pathToList p) = Quiver.Path.cast ⋯ ⋯ p
-- Quiver.SingleObj.pathToList_listToPath
theorem pathToList_listToPath (l : List α) : pathToList (listToPath l) = l 
Arguments: {α : Type u_1} (l : List α)
Goal: Quiver.SingleObj.pathToList (Quiver.SingleObj.listToPath l) = l
-- Quiver.SingleObj.pathEquivList_nil
@[simp]
theorem pathEquivList_nil : pathEquivList Path.nil = ([] : List α) 
Arguments: {α : Type u_1}
Goal: Quiver.SingleObj.pathEquivList Quiver.Path.nil = []
-- Quiver.SingleObj.pathEquivList_cons
@[simp]
theorem pathEquivList_cons (p : Path (star α) (star α)) (a : star α ⟶ star α) :
    pathEquivList (Path.cons p a) = a :: pathToList p 
Arguments: {α : Type u_1} (p : Quiver.Path (Quiver.SingleObj.star α) (Quiver.SingleObj.star α)) (a : Quiver.SingleObj.star α ⟶ Quiver.SingleObj.star α)
Goal: Quiver.SingleObj.pathEquivList (p.cons a) = a :: Quiver.SingleObj.pathToList p
-- Quiver.SingleObj.pathEquivList_symm_nil
@[simp]
theorem pathEquivList_symm_nil : pathEquivList.symm ([] : List α) = Path.nil 
Arguments: {α : Type u_1}
Goal: Quiver.SingleObj.pathEquivList.symm [] = Quiver.Path.nil
-- Quiver.SingleObj.pathEquivList_symm_cons
@[simp]
theorem pathEquivList_symm_cons (l : List α) (a : α) :
    pathEquivList.symm (a :: l) = Path.cons (pathEquivList.symm l) a 
Arguments: {α : Type u_1} (l : List α) (a : α)
Goal: Quiver.SingleObj.pathEquivList.symm (a :: l) = (Quiver.SingleObj.pathEquivList.symm l).cons a
-- Ultrafilter.eventually_add
@[to_additive]
theorem Ultrafilter.eventually_mul {M} [Mul M] (U V : Ultrafilter M) (p : M → Prop) :
    (∀ᶠ m in ↑(U * V), p m) ↔ ∀ᶠ m in U, ∀ᶠ m' in V, p (m * m') 
Arguments: {M : Type u_1} [Add M] (U V : Ultrafilter M) (p : M → Prop)
Goal: (∀ᶠ (m : M) in ↑(U + V), p m) ↔ ∀ᶠ (m : M) in ↑U, ∀ᶠ (m' : M) in ↑V, p (m + m')
-- Ultrafilter.eventually_mul
@[to_additive]
theorem Ultrafilter.eventually_mul {M} [Mul M] (U V : Ultrafilter M) (p : M → Prop) :
    (∀ᶠ m in ↑(U * V), p m) ↔ ∀ᶠ m in U, ∀ᶠ m' in V, p (m * m') 
Arguments: {M : Type u_1} [Mul M] (U V : Ultrafilter M) (p : M → Prop)
Goal: (∀ᶠ (m : M) in ↑(U * V), p m) ↔ ∀ᶠ (m : M) in ↑U, ∀ᶠ (m' : M) in ↑V, p (m * m')
-- Ultrafilter.continuous_add_left
@[to_additive]
theorem Ultrafilter.continuous_mul_left {M} [Semigroup M] (V : Ultrafilter M) :
    Continuous (· * V) 
Arguments: {M : Type u_1} [AddSemigroup M] (V : Ultrafilter M)
Goal: Continuous fun x => x + V
-- Ultrafilter.continuous_mul_left
@[to_additive]
theorem Ultrafilter.continuous_mul_left {M} [Semigroup M] (V : Ultrafilter M) :
    Continuous (· * V) 
Arguments: {M : Type u_1} [Semigroup M] (V : Ultrafilter M)
Goal: Continuous fun x => x * V
-- Hindman.FP.mul
@[to_additive
      "If `m` and `m'` are finite sums in `M`, then so is `m + m'`, provided that `m'`
      is obtained from a subsequence of `M` starting sufficiently late."]
theorem FP.mul {M} [Semigroup M] {a : Stream' M} {m : M} (hm : m ∈ FP a) :
    ∃ n, ∀ m' ∈ FP (a.drop n), m * m' ∈ FP a 
Arguments: {M : Type u_1} [Semigroup M] {a : Stream' M} {m : M} (hm : m ∈ Hindman.FP a)
Goal: ∃ n, ∀ m' ∈ Hindman.FP (Stream'.drop n a), m * m' ∈ Hindman.FP a
-- Hindman.FS.add
@[to_additive
      "If `m` and `m'` are finite sums in `M`, then so is `m + m'`, provided that `m'`
      is obtained from a subsequence of `M` starting sufficiently late."]
theorem FP.mul {M} [Semigroup M] {a : Stream' M} {m : M} (hm : m ∈ FP a) :
    ∃ n, ∀ m' ∈ FP (a.drop n), m * m' ∈ FP a 
Arguments: {M : Type u_1} [AddSemigroup M] {a : Stream' M} {m : M} (hm : m ∈ Hindman.FS a)
Goal: ∃ n, ∀ m' ∈ Hindman.FS (Stream'.drop n a), m + m' ∈ Hindman.FS a
-- Hindman.exists_idempotent_ultrafilter_le_FS
@[to_additive exists_idempotent_ultrafilter_le_FS]
theorem exists_idempotent_ultrafilter_le_FP {M} [Semigroup M] (a : Stream' M) :
    ∃ U : Ultrafilter M, U * U = U ∧ ∀ᶠ m in U, m ∈ FP a 
Arguments: {M : Type u_1} [AddSemigroup M] (a : Stream' M)
Goal: ∃ U, U + U = U ∧ ∀ᶠ (m : M) in ↑U, m ∈ Hindman.FS a
-- Hindman.exists_idempotent_ultrafilter_le_FP
@[to_additive exists_idempotent_ultrafilter_le_FS]
theorem exists_idempotent_ultrafilter_le_FP {M} [Semigroup M] (a : Stream' M) :
    ∃ U : Ultrafilter M, U * U = U ∧ ∀ᶠ m in U, m ∈ FP a 
Arguments: {M : Type u_1} [Semigroup M] (a : Stream' M)
Goal: ∃ U, U * U = U ∧ ∀ᶠ (m : M) in ↑U, m ∈ Hindman.FP a
-- Hindman.exists_FP_of_large
@[to_additive exists_FS_of_large]
theorem exists_FP_of_large {M} [Semigroup M] (U : Ultrafilter M) (U_idem : U * U = U) (s₀ : Set M)
    (sU : s₀ ∈ U) : ∃ a, FP a ⊆ s₀ 
Arguments: {M : Type u_1} [Semigroup M] (U : Ultrafilter M) (U_idem : U * U = U) (s₀ : Set M) (sU : s₀ ∈ U)
Goal: ∃ a, Hindman.FP a ⊆ s₀
-- Hindman.exists_FS_of_large
@[to_additive exists_FS_of_large]
theorem exists_FP_of_large {M} [Semigroup M] (U : Ultrafilter M) (U_idem : U * U = U) (s₀ : Set M)
    (sU : s₀ ∈ U) : ∃ a, FP a ⊆ s₀ 
Arguments: {M : Type u_1} [AddSemigroup M] (U : Ultrafilter M) (U_idem : U + U = U) (s₀ : Set M) (sU : s₀ ∈ U)
Goal: ∃ a, Hindman.FS a ⊆ s₀
-- Hindman.FS_partition_regular
@[to_additive FS_partition_regular
      "The strong form of **Hindman's theorem**: in any finite cover of
      an FS-set, one the parts contains an FS-set."]
theorem FP_partition_regular {M} [Semigroup M] (a : Stream' M) (s : Set (Set M)) (sfin : s.Finite)
    (scov : FP a ⊆ ⋃₀ s) : ∃ c ∈ s, ∃ b : Stream' M, FP b ⊆ c 
Arguments: {M : Type u_1} [AddSemigroup M] (a : Stream' M) (s : Set (Set M)) (sfin : s.Finite) (scov : Hindman.FS a ⊆ ⋃₀ s)
Goal: ∃ c ∈ s, ∃ b, Hindman.FS b ⊆ c
-- Hindman.FP_partition_regular
@[to_additive FS_partition_regular
      "The strong form of **Hindman's theorem**: in any finite cover of
      an FS-set, one the parts contains an FS-set."]
theorem FP_partition_regular {M} [Semigroup M] (a : Stream' M) (s : Set (Set M)) (sfin : s.Finite)
    (scov : FP a ⊆ ⋃₀ s) : ∃ c ∈ s, ∃ b : Stream' M, FP b ⊆ c 
Arguments: {M : Type u_1} [Semigroup M] (a : Stream' M) (s : Set (Set M)) (sfin : s.Finite) (scov : Hindman.FP a ⊆ ⋃₀ s)
Goal: ∃ c ∈ s, ∃ b, Hindman.FP b ⊆ c
-- Hindman.exists_FS_of_finite_cover
@[to_additive exists_FS_of_finite_cover
      "The weak form of **Hindman's theorem**: in any finite cover
      of a nonempty additive semigroup, one of the parts contains an FS-set."]
theorem exists_FP_of_finite_cover {M} [Semigroup M] [Nonempty M] (s : Set (Set M)) (sfin : s.Finite)
    (scov : ⊤ ⊆ ⋃₀ s) : ∃ c ∈ s, ∃ a : Stream' M, FP a ⊆ c 
Arguments: {M : Type u_1} [AddSemigroup M] [Nonempty M] (s : Set (Set M)) (sfin : s.Finite) (scov : ⊤ ⊆ ⋃₀ s)
Goal: ∃ c ∈ s, ∃ a, Hindman.FS a ⊆ c
-- Hindman.exists_FP_of_finite_cover
@[to_additive exists_FS_of_finite_cover
      "The weak form of **Hindman's theorem**: in any finite cover
      of a nonempty additive semigroup, one of the parts contains an FS-set."]
theorem exists_FP_of_finite_cover {M} [Semigroup M] [Nonempty M] (s : Set (Set M)) (sfin : s.Finite)
    (scov : ⊤ ⊆ ⋃₀ s) : ∃ c ∈ s, ∃ a : Stream' M, FP a ⊆ c 
Arguments: {M : Type u_1} [Semigroup M] [Nonempty M] (s : Set (Set M)) (sfin : s.Finite) (scov : ⊤ ⊆ ⋃₀ s)
Goal: ∃ c ∈ s, ∃ a, Hindman.FP a ⊆ c
-- Hindman.FP_drop_subset_FP
@[to_additive FS_iter_tail_sub_FS]
theorem FP_drop_subset_FP {M} [Semigroup M] (a : Stream' M) (n : ℕ) : FP (a.drop n) ⊆ FP a 
Arguments: {M : Type u_1} [Semigroup M] (a : Stream' M) (n : ℕ)
Goal: Hindman.FP (Stream'.drop n a) ⊆ Hindman.FP a
-- Hindman.FS_iter_tail_sub_FS
@[to_additive FS_iter_tail_sub_FS]
theorem FP_drop_subset_FP {M} [Semigroup M] (a : Stream' M) (n : ℕ) : FP (a.drop n) ⊆ FP a 
Arguments: {M : Type u_1} [AddSemigroup M] (a : Stream' M) (n : ℕ)
Goal: Hindman.FS (Stream'.drop n a) ⊆ Hindman.FS a
-- Hindman.FP.singleton
@[to_additive]
theorem FP.singleton {M} [Semigroup M] (a : Stream' M) (i : ℕ) : a.get i ∈ FP a 
Arguments: {M : Type u_1} [Semigroup M] (a : Stream' M) (i : ℕ)
Goal: a.get i ∈ Hindman.FP a
-- Hindman.FS.singleton
@[to_additive]
theorem FP.singleton {M} [Semigroup M] (a : Stream' M) (i : ℕ) : a.get i ∈ FP a 
Arguments: {M : Type u_1} [AddSemigroup M] (a : Stream' M) (i : ℕ)
Goal: a.get i ∈ Hindman.FS a
-- Hindman.FP.mul_two
@[to_additive]
theorem FP.mul_two {M} [Semigroup M] (a : Stream' M) (i j : ℕ) (ij : i < j) :
    a.get i * a.get j ∈ FP a 
Arguments: {M : Type u_1} [Semigroup M] (a : Stream' M) (i j : ℕ) (ij : i < j)
Goal: a.get i * a.get j ∈ Hindman.FP a
-- Hindman.FS.add_two
@[to_additive]
theorem FP.mul_two {M} [Semigroup M] (a : Stream' M) (i j : ℕ) (ij : i < j) :
    a.get i * a.get j ∈ FP a 
Arguments: {M : Type u_1} [AddSemigroup M] (a : Stream' M) (i j : ℕ) (ij : i < j)
Goal: a.get i + a.get j ∈ Hindman.FS a
-- Hindman.FP.finset_prod
@[to_additive]
theorem FP.finset_prod {M} [CommMonoid M] (a : Stream' M) (s : Finset ℕ) (hs : s.Nonempty) :
    (s.prod fun i => a.get i) ∈ FP a 
Arguments: {M : Type u_1} [CommMonoid M] (a : Stream' M) (s : Finset ℕ) (hs : s.Nonempty)
Goal: ∏ i ∈ s, a.get i ∈ Hindman.FP a
-- Hindman.FS.finset_sum
@[to_additive]
theorem FP.finset_prod {M} [CommMonoid M] (a : Stream' M) (s : Finset ℕ) (hs : s.Nonempty) :
    (s.prod fun i => a.get i) ∈ FP a 
Arguments: {M : Type u_1} [AddCommMonoid M] (a : Stream' M) (s : Finset ℕ) (hs : s.Nonempty)
Goal: ∑ i ∈ s, a.get i ∈ Hindman.FS a
-- Ordinal.nfpFamily_eq_sup
theorem nfpFamily_eq_sup (f : ι → Ordinal.{max u v} → Ordinal.{max u v}) (a : Ordinal.{max u v}) :
    nfpFamily.{u, v} f a = sup.{u, v} (List.foldr f a) 
Arguments: {ι : Type u} (f : ι → Ordinal.{max u v} → Ordinal.{max u v}) (a : Ordinal.{max u v})
Goal: Ordinal.nfpFamily f a = Ordinal.sup (List.foldr f a)
-- Ordinal.foldr_le_nfpFamily
theorem foldr_le_nfpFamily (f : ι → Ordinal → Ordinal)
    (a l) : List.foldr f a l ≤ nfpFamily.{u, v} f a 
Arguments: {ι : Type u} (f : ι → Ordinal.{max u v} → Ordinal.{max u v}) (a : Ordinal.{max u v}) (l : List ι)
Goal: List.foldr f a l ≤ Ordinal.nfpFamily f a
-- Ordinal.le_nfpFamily
theorem le_nfpFamily (f : ι → Ordinal → Ordinal) (a) : a ≤ nfpFamily f a 
Arguments: {ι : Type u} (f : ι → Ordinal.{max u u_1} → Ordinal.{max u u_1}) (a : Ordinal.{max u u_1})
Goal: a ≤ Ordinal.nfpFamily f a
-- Ordinal.lt_nfpFamily
theorem lt_nfpFamily {a b} : a < nfpFamily.{u, v} f b ↔ ∃ l, a < List.foldr f b l 
Arguments: {ι : Type u} {f : ι → Ordinal.{max u v} → Ordinal.{max u v}} {a : Ordinal.{max v u}} {b : Ordinal.{max u v}}
Goal: a < Ordinal.nfpFamily f b ↔ ∃ l, a < List.foldr f b l
-- Ordinal.nfpFamily_le_iff
theorem nfpFamily_le_iff {a b} : nfpFamily.{u, v} f a ≤ b ↔ ∀ l, List.foldr f a l ≤ b 
Arguments: {ι : Type u} {f : ι → Ordinal.{max u v} → Ordinal.{max u v}} {a : Ordinal.{max u v}} {b : Ordinal.{max v u}}
Goal: Ordinal.nfpFamily f a ≤ b ↔ ∀ (l : List ι), List.foldr f a l ≤ b
-- Ordinal.nfpFamily_le
theorem nfpFamily_le {a b} : (∀ l, List.foldr f a l ≤ b) → nfpFamily.{u, v} f a ≤ b 
Arguments: {ι : Type u} {f : ι → Ordinal.{max u v} → Ordinal.{max u v}} {a b : Ordinal.{max u v}}
Goal: (∀ (l : List ι), List.foldr f a l ≤ b) → Ordinal.nfpFamily f a ≤ b
-- Ordinal.nfpFamily_monotone
theorem nfpFamily_monotone (hf : ∀ i, Monotone (f i)) : Monotone (nfpFamily.{u, v} f) 
Arguments: {ι : Type u} {f : ι → Ordinal.{max u v} → Ordinal.{max u v}} (hf : ∀ (i : ι), Monotone (f i))
Goal: Monotone (Ordinal.nfpFamily f)
-- Ordinal.apply_lt_nfpFamily
theorem apply_lt_nfpFamily (H : ∀ i, IsNormal (f i)) {a b} (hb : b < nfpFamily.{u, v} f a) (i) :
    f i b < nfpFamily.{u, v} f a 
Arguments: {ι : Type u} {f : ι → Ordinal.{max u v} → Ordinal.{max u v}} (H : ∀ (i : ι), Ordinal.IsNormal (f i)) {a : Ordinal.{max u v}} {b : Ordinal.{max v u}} (hb : b < Ordinal.nfpFamily f a) (i : ι)
Goal: f i b < Ordinal.nfpFamily f a
-- Ordinal.apply_lt_nfpFamily_iff
theorem apply_lt_nfpFamily_iff [Nonempty ι] (H : ∀ i, IsNormal (f i)) {a b} :
    (∀ i, f i b < nfpFamily.{u, v} f a) ↔ b < nfpFamily.{u, v} f a 
Arguments: {ι : Type u} {f : ι → Ordinal.{max u v} → Ordinal.{max u v}} [Nonempty ι] (H : ∀ (i : ι), Ordinal.IsNormal (f i)) {a b : Ordinal.{max u v}}
Goal: (∀ (i : ι), f i b < Ordinal.nfpFamily f a) ↔ b < Ordinal.nfpFamily f a