ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- SetTheory.PGame.birthday_add
@[simp]
theorem birthday_add : ∀ x y : PGame.{u}, (x + y).birthday = x.birthday ♯ y.birthday
  
Arguments: (x y : SetTheory.PGame)
Goal: (x + y).birthday = x.birthday.nadd y.birthday
-- SetTheory.PGame.birthday_add_zero
theorem birthday_add_zero : (a + 0).birthday = a.birthday 
Arguments: (a : SetTheory.PGame)
Goal: (a + 0).birthday = a.birthday
-- SetTheory.PGame.birthday_zero_add
theorem birthday_zero_add : (0 + a).birthday = a.birthday 
Arguments: (a : SetTheory.PGame)
Goal: (0 + a).birthday = a.birthday
-- SetTheory.PGame.birthday_add_one
theorem birthday_add_one : (a + 1).birthday = Order.succ a.birthday 
Arguments: (a : SetTheory.PGame)
Goal: (a + 1).birthday = Order.succ a.birthday
-- SetTheory.PGame.birthday_one_add
theorem birthday_one_add : (1 + a).birthday = Order.succ a.birthday 
Arguments: (a : SetTheory.PGame)
Goal: (1 + a).birthday = Order.succ a.birthday
-- SetTheory.PGame.birthday_natCast
@[simp]
theorem birthday_natCast : ∀ n : ℕ, birthday n = n
  
Arguments: (n : ℕ)
Goal: (↑n).birthday = ↑n
-- SetTheory.PGame.birthday_add_nat
theorem birthday_add_nat (n : ℕ) : (a + n).birthday = a.birthday + n 
Arguments: (a : SetTheory.PGame) (n : ℕ)
Goal: (a + ↑n).birthday = a.birthday + ↑n
-- SetTheory.PGame.birthday_nat_add
theorem birthday_nat_add (n : ℕ) : (↑n + a).birthday = a.birthday + n 
Arguments: (a : SetTheory.PGame) (n : ℕ)
Goal: (↑n + a).birthday = a.birthday + ↑n
-- SetTheory.PGame.nim_def
theorem nim_def (o : Ordinal) :
    have : IsWellOrder (Quotient.out o).α (· < ·) := inferInstance
    nim o =
      PGame.mk o.out.α o.out.α (fun o₂ => nim (Ordinal.typein (· < ·) o₂)) fun o₂ =>
        nim (Ordinal.typein (· < ·) o₂) 
Arguments: (o : Ordinal.{u_1})
Goal: let_fun this := ⋯;
SetTheory.PGame.nim o =
  SetTheory.PGame.mk (Quotient.out o).α (Quotient.out o).α
    (fun o₂ => SetTheory.PGame.nim (Ordinal.typein (fun x x_1 => x < x_1) o₂)) fun o₂ =>
    SetTheory.PGame.nim (Ordinal.typein (fun x x_1 => x < x_1) o₂)
-- SetTheory.PGame.leftMoves_nim
theorem leftMoves_nim (o : Ordinal) : (nim o).LeftMoves = o.out.α 
Arguments: (o : Ordinal.{u_1})
Goal: (SetTheory.PGame.nim o).LeftMoves = (Quotient.out o).α
-- SetTheory.PGame.rightMoves_nim
theorem rightMoves_nim (o : Ordinal) : (nim o).RightMoves = o.out.α 
Arguments: (o : Ordinal.{u_1})
Goal: (SetTheory.PGame.nim o).RightMoves = (Quotient.out o).α
-- SetTheory.PGame.moveLeft_nim_hEq
theorem moveLeft_nim_hEq (o : Ordinal) :
    have : IsWellOrder (Quotient.out o).α (· < ·) := inferInstance
    HEq (nim o).moveLeft fun i : o.out.α => nim (typein (· < ·) i) 
Arguments: (o : Ordinal.{u_1})
Goal: let_fun this := ⋯;
HEq (SetTheory.PGame.nim o).moveLeft fun i => SetTheory.PGame.nim (Ordinal.typein (fun x x_1 => x < x_1) i)
-- SetTheory.PGame.moveRight_nim_hEq
theorem moveRight_nim_hEq (o : Ordinal) :
    have : IsWellOrder (Quotient.out o).α (· < ·) := inferInstance
    HEq (nim o).moveRight fun i : o.out.α => nim (typein (· < ·) i) 
Arguments: (o : Ordinal.{u_1})
Goal: let_fun this := ⋯;
HEq (SetTheory.PGame.nim o).moveRight fun i => SetTheory.PGame.nim (Ordinal.typein (fun x x_1 => x < x_1) i)
-- SetTheory.PGame.toLeftMovesNim_symm_lt
@[simp]
theorem toLeftMovesNim_symm_lt {o : Ordinal} (i : (nim o).LeftMoves) :
    ↑(toLeftMovesNim.symm i) < o 
Arguments: {o : Ordinal.{u_1}} (i : (SetTheory.PGame.nim o).LeftMoves)
Goal: ↑(SetTheory.PGame.toLeftMovesNim.symm i) < o
-- SetTheory.PGame.toRightMovesNim_symm_lt
@[simp]
theorem toRightMovesNim_symm_lt {o : Ordinal} (i : (nim o).RightMoves) :
    ↑(toRightMovesNim.symm i) < o 
Arguments: {o : Ordinal.{u_1}} (i : (SetTheory.PGame.nim o).RightMoves)
Goal: ↑(SetTheory.PGame.toRightMovesNim.symm i) < o
-- SetTheory.PGame.moveLeft_nim'
@[simp]
theorem moveLeft_nim' {o : Ordinal.{u}} (i) :
    (nim o).moveLeft i = nim (toLeftMovesNim.symm i).val 
Arguments: {o : Ordinal.{u}} (i : (SetTheory.PGame.nim o).LeftMoves)
Goal: (SetTheory.PGame.nim o).moveLeft i = SetTheory.PGame.nim ↑(SetTheory.PGame.toLeftMovesNim.symm i)
-- SetTheory.PGame.moveLeft_nim
theorem moveLeft_nim {o : Ordinal} (i) : (nim o).moveLeft (toLeftMovesNim i) = nim i 
Arguments: {o : Ordinal.{u_1}} (i : ↑(Set.Iio o))
Goal: (SetTheory.PGame.nim o).moveLeft (SetTheory.PGame.toLeftMovesNim i) = SetTheory.PGame.nim ↑i
-- SetTheory.PGame.moveRight_nim'
@[simp]
theorem moveRight_nim' {o : Ordinal} (i) : (nim o).moveRight i = nim (toRightMovesNim.symm i).val 
Arguments: {o : Ordinal.{u_1}} (i : (SetTheory.PGame.nim o).RightMoves)
Goal: (SetTheory.PGame.nim o).moveRight i = SetTheory.PGame.nim ↑(SetTheory.PGame.toRightMovesNim.symm i)
-- SetTheory.PGame.moveRight_nim
theorem moveRight_nim {o : Ordinal} (i) : (nim o).moveRight (toRightMovesNim i) = nim i 
Arguments: {o : Ordinal.{u_1}} (i : ↑(Set.Iio o))
Goal: (SetTheory.PGame.nim o).moveRight (SetTheory.PGame.toRightMovesNim i) = SetTheory.PGame.nim ↑i
-- SetTheory.PGame.nim_zero_equiv
theorem nim_zero_equiv : nim 0 ≈ 0 
Goal: SetTheory.PGame.nim 0 ≈ 0
-- SetTheory.PGame.default_nim_one_leftMoves_eq
@[simp]
theorem default_nim_one_leftMoves_eq :
    (default : (nim 1).LeftMoves) = @toLeftMovesNim 1 ⟨0, Set.mem_Iio.mpr zero_lt_one⟩ 
Goal: default = SetTheory.PGame.toLeftMovesNim ⟨0, ⋯⟩
-- SetTheory.PGame.default_nim_one_rightMoves_eq
@[simp]
theorem default_nim_one_rightMoves_eq :
    (default : (nim 1).RightMoves) = @toRightMovesNim 1 ⟨0, Set.mem_Iio.mpr zero_lt_one⟩ 
Goal: default = SetTheory.PGame.toRightMovesNim ⟨0, ⋯⟩
-- SetTheory.PGame.toLeftMovesNim_one_symm
@[simp]
theorem toLeftMovesNim_one_symm (i) :
    (@toLeftMovesNim 1).symm i = ⟨0, Set.mem_Iio.mpr zero_lt_one⟩ 
Arguments: (i : (SetTheory.PGame.nim 1).LeftMoves)
Goal: SetTheory.PGame.toLeftMovesNim.symm i = ⟨0, ⋯⟩
-- SetTheory.PGame.toRightMovesNim_one_symm
@[simp]
theorem toRightMovesNim_one_symm (i) :
    (@toRightMovesNim 1).symm i = ⟨0, Set.mem_Iio.mpr zero_lt_one⟩ 
Arguments: (i : (SetTheory.PGame.nim 1).RightMoves)
Goal: SetTheory.PGame.toRightMovesNim.symm i = ⟨0, ⋯⟩
-- SetTheory.PGame.nim_one_moveLeft
theorem nim_one_moveLeft (x) : (nim 1).moveLeft x = nim 0 
Arguments: (x : (SetTheory.PGame.nim 1).LeftMoves)
Goal: (SetTheory.PGame.nim 1).moveLeft x = SetTheory.PGame.nim 0
-- SetTheory.PGame.nim_one_moveRight
theorem nim_one_moveRight (x) : (nim 1).moveRight x = nim 0 
Arguments: (x : (SetTheory.PGame.nim 1).RightMoves)
Goal: (SetTheory.PGame.nim 1).moveRight x = SetTheory.PGame.nim 0
-- SetTheory.PGame.nim_one_equiv
theorem nim_one_equiv : nim 1 ≈ star 
Goal: SetTheory.PGame.nim 1 ≈ SetTheory.PGame.star
-- SetTheory.PGame.nim_birthday
@[simp]
theorem nim_birthday (o : Ordinal) : (nim o).birthday = o 
Arguments: (o : Ordinal.{u_1})
Goal: (SetTheory.PGame.nim o).birthday = o
-- SetTheory.PGame.neg_nim
@[simp]
theorem neg_nim (o : Ordinal) : -nim o = nim o 
Arguments: (o : Ordinal.{u_1})
Goal: -SetTheory.PGame.nim o = SetTheory.PGame.nim o
-- SetTheory.PGame.nim_fuzzy_zero_of_ne_zero
theorem nim_fuzzy_zero_of_ne_zero {o : Ordinal} (ho : o ≠ 0) : nim o ‖ 0 
Arguments: {o : Ordinal.{u_1}} (ho : o ≠ 0)
Goal: (SetTheory.PGame.nim o).Fuzzy 0
-- SetTheory.PGame.nim_add_equiv_zero_iff
@[simp]
theorem nim_add_equiv_zero_iff (o₁ o₂ : Ordinal) : (nim o₁ + nim o₂ ≈ 0) ↔ o₁ = o₂ 
Arguments: (o₁ o₂ : Ordinal.{u_1})
Goal: SetTheory.PGame.nim o₁ + SetTheory.PGame.nim o₂ ≈ 0 ↔ o₁ = o₂
-- SetTheory.PGame.nim_add_fuzzy_zero_iff
@[simp]
theorem nim_add_fuzzy_zero_iff {o₁ o₂ : Ordinal} : nim o₁ + nim o₂ ‖ 0 ↔ o₁ ≠ o₂ 
Arguments: {o₁ o₂ : Ordinal.{u_1}}
Goal: (SetTheory.PGame.nim o₁ + SetTheory.PGame.nim o₂).Fuzzy 0 ↔ o₁ ≠ o₂
-- SetTheory.PGame.nim_equiv_iff_eq
@[simp]
theorem nim_equiv_iff_eq {o₁ o₂ : Ordinal} : (nim o₁ ≈ nim o₂) ↔ o₁ = o₂ 
Arguments: {o₁ o₂ : Ordinal.{u_1}}
Goal: SetTheory.PGame.nim o₁ ≈ SetTheory.PGame.nim o₂ ↔ o₁ = o₂
-- SetTheory.PGame.grundyValue_eq_mex_left
theorem grundyValue_eq_mex_left (G : PGame) :
    grundyValue G = Ordinal.mex.{u, u} fun i => grundyValue (G.moveLeft i) 
Arguments: (G : SetTheory.PGame)
Goal: G.grundyValue = Ordinal.mex fun i => (G.moveLeft i).grundyValue
-- SetTheory.PGame.equiv_nim_grundyValue
theorem equiv_nim_grundyValue : ∀ (G : PGame.{u}) [G.Impartial], G ≈ nim (grundyValue G)
  
Arguments: (G : SetTheory.PGame) [G.Impartial]
Goal: G ≈ SetTheory.PGame.nim G.grundyValue
-- SetTheory.PGame.grundyValue_eq_iff_equiv_nim
theorem grundyValue_eq_iff_equiv_nim {G : PGame} [G.Impartial] {o : Ordinal} :
    grundyValue G = o ↔ (G ≈ nim o) 
Arguments: {G : SetTheory.PGame} [G.Impartial] {o : Ordinal.{u_1}}
Goal: G.grundyValue = o ↔ G ≈ SetTheory.PGame.nim o
-- SetTheory.PGame.nim_grundyValue
@[simp]
theorem nim_grundyValue (o : Ordinal.{u}) : grundyValue (nim o) = o 
Arguments: (o : Ordinal.{u})
Goal: (SetTheory.PGame.nim o).grundyValue = o
-- SetTheory.PGame.grundyValue_eq_iff_equiv
theorem grundyValue_eq_iff_equiv (G H : PGame) [G.Impartial] [H.Impartial] :
    grundyValue G = grundyValue H ↔ (G ≈ H) 
Arguments: (G H : SetTheory.PGame) [G.Impartial] [H.Impartial]
Goal: G.grundyValue = H.grundyValue ↔ G ≈ H
-- SetTheory.PGame.grundyValue_zero
@[simp]
theorem grundyValue_zero : grundyValue 0 = 0 
Goal: SetTheory.PGame.grundyValue 0 = 0
-- SetTheory.PGame.grundyValue_iff_equiv_zero
theorem grundyValue_iff_equiv_zero (G : PGame) [G.Impartial] : grundyValue G = 0 ↔ (G ≈ 0) 
Arguments: (G : SetTheory.PGame) [G.Impartial]
Goal: G.grundyValue = 0 ↔ G ≈ 0
-- SetTheory.PGame.grundyValue_star
@[simp]
theorem grundyValue_star : grundyValue star = 1 
Goal: SetTheory.PGame.star.grundyValue = 1
-- SetTheory.PGame.grundyValue_neg
@[simp]
theorem grundyValue_neg (G : PGame) [G.Impartial] : grundyValue (-G) = grundyValue G 
Arguments: (G : SetTheory.PGame) [G.Impartial]
Goal: (-G).grundyValue = G.grundyValue
-- SetTheory.PGame.grundyValue_eq_mex_right
theorem grundyValue_eq_mex_right :
    ∀ (G : PGame) [G.Impartial],
      grundyValue G = Ordinal.mex.{u, u} fun i => grundyValue (G.moveRight i)
   
Arguments: (G : SetTheory.PGame) [G.Impartial]
Goal: G.grundyValue = Ordinal.mex fun i => (G.moveRight i).grundyValue
-- SetTheory.PGame.grundyValue_nim_add_nim
@[simp]
theorem grundyValue_nim_add_nim (n m : ℕ) :
    grundyValue (nim.{u} n + nim.{u} m) = n ^^^ m 
Arguments: (n m : ℕ)
Goal: (SetTheory.PGame.nim ↑n + SetTheory.PGame.nim ↑m).grundyValue = ↑(n ^^^ m)
-- SetTheory.PGame.nim_add_nim_equiv
theorem nim_add_nim_equiv {n m : ℕ} : nim n + nim m ≈ nim (n ^^^ m) 
Arguments: {n m : ℕ}
Goal: SetTheory.PGame.nim ↑n + SetTheory.PGame.nim ↑m ≈ SetTheory.PGame.nim ↑(n ^^^ m)
-- SetTheory.PGame.grundyValue_add
theorem grundyValue_add (G H : PGame) [G.Impartial] [H.Impartial] {n m : ℕ} (hG : grundyValue G = n)
    (hH : grundyValue H = m) : grundyValue (G + H) = n ^^^ m 
Arguments: (G H : SetTheory.PGame) [G.Impartial] [H.Impartial] {n m : ℕ} (hG : G.grundyValue = ↑n) (hH : H.grundyValue = ↑m)
Goal: (G + H).grundyValue = ↑(n ^^^ m)
-- Prefunctor.mk_obj
lemma mk_obj {V W : Type*} [Quiver V] [Quiver W] {obj : V → W} {map} {X : V} :
    (Prefunctor.mk obj map).obj X = obj X 
Arguments: {V : Type u_1} {W : Type u_2} [Quiver V] [Quiver W] {obj : V → W} {map : {X Y : V} → (X ⟶ Y) → (obj X ⟶ obj Y)} {X : V}
Goal: { obj := obj, map := map }.obj X = obj X
-- Prefunctor.mk_map
lemma mk_map {V W : Type*} [Quiver V] [Quiver W] {obj : V → W} {map} {X Y : V} {f : X ⟶ Y} :
    (Prefunctor.mk obj map).map f = map f 
Arguments: {V : Type u_1} {W : Type u_2} [Quiver V] [Quiver W] {obj : V → W} {map : {X Y : V} → (X ⟶ Y) → (obj X ⟶ obj Y)} {X Y : V} {f : X ⟶ Y}
Goal: { obj := obj, map := map }.map f = map f
-- Prefunctor.ext
@[ext]
theorem ext {V : Type u} [Quiver.{v₁} V] {W : Type u₂} [Quiver.{v₂} W] {F G : Prefunctor V W}
    (h_obj : ∀ X, F.obj X = G.obj X)
    (h_map : ∀ (X Y : V) (f : X ⟶ Y),
      F.map f = Eq.recOn (h_obj Y).symm (Eq.recOn (h_obj X).symm (G.map f))) : F = G 
Arguments: {V : Type u} [Quiver V] {W : Type u₂} [Quiver W] {F G : V ⥤q W} (h_obj : ∀ (X : V), F.obj X = G.obj X) (h_map : ∀ (X Y : V) (f : X ⟶ Y), F.map f = Eq.recOn ⋯ (Eq.recOn ⋯ (G.map f)))
Goal: F = G
-- Prefunctor.id_obj
@[simps]
def id (V : Type*) [Quiver V] : Prefunctor V V 
Arguments: (V : Type u_1) [Quiver V] (X : V)
Goal: (𝟭q V).obj X = X
-- Prefunctor.id_map
@[simps]
def id (V : Type*) [Quiver V] : Prefunctor V V 
Arguments: (V : Type u_1) [Quiver V]
Goal: ∀ {X Y : V} (f : X ⟶ Y), (𝟭q V).map f = f
-- Prefunctor.comp_map
@[simps]
def comp {U : Type*} [Quiver U] {V : Type*} [Quiver V] {W : Type*} [Quiver W]
    (F : Prefunctor U V) (G : Prefunctor V W) : Prefunctor U W 
Arguments: {U : Type u_1} [Quiver U] {V : Type u_2} [Quiver V] {W : Type u_3} [Quiver W] (F : U ⥤q V) (G : V ⥤q W)
Goal: ∀ {X Y : U} (f : X ⟶ Y), (F ⋙q G).map f = G.map (F.map f)
-- Prefunctor.comp_obj
@[simps]
def comp {U : Type*} [Quiver U] {V : Type*} [Quiver V] {W : Type*} [Quiver W]
    (F : Prefunctor U V) (G : Prefunctor V W) : Prefunctor U W 
Arguments: {U : Type u_1} [Quiver U] {V : Type u_2} [Quiver V] {W : Type u_3} [Quiver W] (F : U ⥤q V) (G : V ⥤q W) (X : U)
Goal: (F ⋙q G).obj X = G.obj (F.obj X)
-- Prefunctor.comp_id
@[simp]
theorem comp_id {U V : Type*} [Quiver U] [Quiver V] (F : Prefunctor U V) :
    F.comp (id _) = F 
Arguments: {U : Type u_1} {V : Type u_2} [Quiver U] [Quiver V] (F : U ⥤q V)
Goal: F ⋙q 𝟭q V = F
-- Prefunctor.id_comp
@[simp]
theorem id_comp {U V : Type*} [Quiver U] [Quiver V] (F : Prefunctor U V) :
    (id _).comp F = F 
Arguments: {U : Type u_1} {V : Type u_2} [Quiver U] [Quiver V] (F : U ⥤q V)
Goal: 𝟭q U ⋙q F = F
-- Prefunctor.comp_assoc
@[simp]
theorem comp_assoc {U V W Z : Type*} [Quiver U] [Quiver V] [Quiver W] [Quiver Z]
    (F : Prefunctor U V) (G : Prefunctor V W) (H : Prefunctor W Z) :
    (F.comp G).comp H = F.comp (G.comp H) 
Arguments: {U : Type u_1} {V : Type u_2} {W : Type u_3} {Z : Type u_4} [Quiver U] [Quiver V] [Quiver W] [Quiver Z] (F : U ⥤q V) (G : V ⥤q W) (H : W ⥤q Z)
Goal: F ⋙q G ⋙q H = F ⋙q (G ⋙q H)
-- Prefunctor.congr_map
theorem congr_map {U V : Type*} [Quiver U] [Quiver V] (F : U ⥤q V) {X Y : U} {f g : X ⟶ Y}
    (h : f = g) : F.map f = F.map g 
Arguments: {U : Type u_1} {V : Type u_2} [Quiver U] [Quiver V] (F : U ⥤q V) {X Y : U} {f g : X ⟶ Y} (h : f = g)
Goal: F.map f = F.map g
-- Quiver.empty_arrow
@[simp]
theorem empty_arrow {V : Type u} (a b : Empty V) : (a ⟶ b) = PEmpty 
Arguments: {V : Type u} (a b : Quiver.Empty V)
Goal: (a ⟶ b) = PEmpty.{u}
-- Ordinal.opow_def
theorem opow_def (a b : Ordinal) :
    a ^ b = if a = 0 then 1 - b else limitRecOn b 1 (fun _ IH => IH * a) fun b _ => bsup.{u, u} b 
Arguments: (a b : Ordinal.{u})
Goal: a ^ b = if a = 0 then 1 - b else b.limitRecOn 1 (fun x IH => IH * a) fun b x => b.bsup
-- Ordinal.zero_opow'
theorem zero_opow' (a : Ordinal) : 0 ^ a = 1 - a 
Arguments: (a : Ordinal.{u_1})
Goal: 0 ^ a = 1 - a
-- Ordinal.zero_opow
@[simp]
theorem zero_opow {a : Ordinal} (a0 : a ≠ 0) : (0 : Ordinal) ^ a = 0 
Arguments: {a : Ordinal.{u_1}} (a0 : a ≠ 0)
Goal: 0 ^ a = 0
-- Ordinal.opow_zero
@[simp]
theorem opow_zero (a : Ordinal) : a ^ (0 : Ordinal) = 1 
Arguments: (a : Ordinal.{u_1})
Goal: a ^ 0 = 1
-- Ordinal.opow_succ
@[simp]
theorem opow_succ (a b : Ordinal) : a ^ succ b = a ^ b * a 
Arguments: (a b : Ordinal.{u_1})
Goal: a ^ Order.succ b = a ^ b * a
-- Ordinal.opow_limit
theorem opow_limit {a b : Ordinal} (a0 : a ≠ 0) (h : IsLimit b) :
    a ^ b = bsup.{u, u} b fun c _ => a ^ c 
Arguments: {a b : Ordinal.{u}} (a0 : a ≠ 0) (h : b.IsLimit)
Goal: a ^ b = b.bsup fun c x => a ^ c
-- Ordinal.opow_le_of_limit
theorem opow_le_of_limit {a b c : Ordinal} (a0 : a ≠ 0) (h : IsLimit b) :
    a ^ b ≤ c ↔ ∀ b' < b, a ^ b' ≤ c 
Arguments: {a b c : Ordinal.{u_1}} (a0 : a ≠ 0) (h : b.IsLimit)
Goal: a ^ b ≤ c ↔ ∀ b' < b, a ^ b' ≤ c
-- Ordinal.lt_opow_of_limit
theorem lt_opow_of_limit {a b c : Ordinal} (b0 : b ≠ 0) (h : IsLimit c) :
    a < b ^ c ↔ ∃ c' < c, a < b ^ c' 
Arguments: {a b c : Ordinal.{u_1}} (b0 : b ≠ 0) (h : c.IsLimit)
Goal: a < b ^ c ↔ ∃ c' < c, a < b ^ c'
-- Ordinal.opow_one
@[simp]
theorem opow_one (a : Ordinal) : a ^ (1 : Ordinal) = a 
Arguments: (a : Ordinal.{u_1})
Goal: a ^ 1 = a
-- Ordinal.one_opow
@[simp]
theorem one_opow (a : Ordinal) : (1 : Ordinal) ^ a = 1 
Arguments: (a : Ordinal.{u_1})
Goal: 1 ^ a = 1
-- Ordinal.opow_pos
theorem opow_pos {a : Ordinal} (b : Ordinal) (a0 : 0 < a) : 0 < a ^ b 
Arguments: {a : Ordinal.{u_1}} (b : Ordinal.{u_1}) (a0 : 0 < a)
Goal: 0 < a ^ b
-- Ordinal.opow_ne_zero
theorem opow_ne_zero {a : Ordinal} (b : Ordinal) (a0 : a ≠ 0) : a ^ b ≠ 0 
Arguments: {a : Ordinal.{u_1}} (b : Ordinal.{u_1}) (a0 : a ≠ 0)
Goal: a ^ b ≠ 0
-- Ordinal.opow_isNormal
theorem opow_isNormal {a : Ordinal} (h : 1 < a) : IsNormal (a ^ ·) 
Arguments: {a : Ordinal.{u_1}} (h : 1 < a)
Goal: Ordinal.IsNormal fun x => a ^ x
-- Ordinal.opow_lt_opow_iff_right
theorem opow_lt_opow_iff_right {a b c : Ordinal} (a1 : 1 < a) : a ^ b < a ^ c ↔ b < c 
Arguments: {a b c : Ordinal.{u_1}} (a1 : 1 < a)
Goal: a ^ b < a ^ c ↔ b < c
-- Ordinal.opow_le_opow_iff_right
theorem opow_le_opow_iff_right {a b c : Ordinal} (a1 : 1 < a) : a ^ b ≤ a ^ c ↔ b ≤ c 
Arguments: {a b c : Ordinal.{u_1}} (a1 : 1 < a)
Goal: a ^ b ≤ a ^ c ↔ b ≤ c
-- Ordinal.opow_right_inj
theorem opow_right_inj {a b c : Ordinal} (a1 : 1 < a) : a ^ b = a ^ c ↔ b = c 
Arguments: {a b c : Ordinal.{u_1}} (a1 : 1 < a)
Goal: a ^ b = a ^ c ↔ b = c
-- Ordinal.opow_isLimit
theorem opow_isLimit {a b : Ordinal} (a1 : 1 < a) : IsLimit b → IsLimit (a ^ b) 
Arguments: {a b : Ordinal.{u_1}} (a1 : 1 < a)
Goal: b.IsLimit → (a ^ b).IsLimit
-- Ordinal.opow_isLimit_left
theorem opow_isLimit_left {a b : Ordinal} (l : IsLimit a) (hb : b ≠ 0) : IsLimit (a ^ b) 
Arguments: {a b : Ordinal.{u_1}} (l : a.IsLimit) (hb : b ≠ 0)
Goal: (a ^ b).IsLimit
-- Ordinal.opow_le_opow_right
theorem opow_le_opow_right {a b c : Ordinal} (h₁ : 0 < a) (h₂ : b ≤ c) : a ^ b ≤ a ^ c 
Arguments: {a b c : Ordinal.{u_1}} (h₁ : 0 < a) (h₂ : b ≤ c)
Goal: a ^ b ≤ a ^ c
-- Ordinal.opow_le_opow_left
theorem opow_le_opow_left {a b : Ordinal} (c : Ordinal) (ab : a ≤ b) : a ^ c ≤ b ^ c 
Arguments: {a b : Ordinal.{u_1}} (c : Ordinal.{u_1}) (ab : a ≤ b)
Goal: a ^ c ≤ b ^ c
-- Ordinal.left_le_opow
theorem left_le_opow (a : Ordinal) {b : Ordinal} (b1 : 0 < b) : a ≤ a ^ b 
Arguments: (a : Ordinal.{u_1}) {b : Ordinal.{u_1}} (b1 : 0 < b)
Goal: a ≤ a ^ b
-- Ordinal.right_le_opow
theorem right_le_opow {a : Ordinal} (b : Ordinal) (a1 : 1 < a) : b ≤ a ^ b 
Arguments: {a : Ordinal.{u_1}} (b : Ordinal.{u_1}) (a1 : 1 < a)
Goal: b ≤ a ^ b
-- Ordinal.opow_lt_opow_left_of_succ
theorem opow_lt_opow_left_of_succ {a b c : Ordinal} (ab : a < b) : a ^ succ c < b ^ succ c 
Arguments: {a b c : Ordinal.{u_1}} (ab : a < b)
Goal: a ^ Order.succ c < b ^ Order.succ c
-- Ordinal.opow_add
theorem opow_add (a b c : Ordinal) : a ^ (b + c) = a ^ b * a ^ c 
Arguments: (a b c : Ordinal.{u_1})
Goal: a ^ (b + c) = a ^ b * a ^ c
-- Ordinal.opow_one_add
theorem opow_one_add (a b : Ordinal) : a ^ (1 + b) = a * a ^ b 
Arguments: (a b : Ordinal.{u_1})
Goal: a ^ (1 + b) = a * a ^ b
-- Ordinal.opow_dvd_opow
theorem opow_dvd_opow (a : Ordinal) {b c : Ordinal} (h : b ≤ c) : a ^ b ∣ a ^ c 
Arguments: (a : Ordinal.{u_1}) {b c : Ordinal.{u_1}} (h : b ≤ c)
Goal: a ^ b ∣ a ^ c
-- Ordinal.opow_dvd_opow_iff
theorem opow_dvd_opow_iff {a b c : Ordinal} (a1 : 1 < a) : a ^ b ∣ a ^ c ↔ b ≤ c 
Arguments: {a b c : Ordinal.{u_1}} (a1 : 1 < a)
Goal: a ^ b ∣ a ^ c ↔ b ≤ c
-- Ordinal.opow_mul
theorem opow_mul (a b c : Ordinal) : a ^ (b * c) = (a ^ b) ^ c 
Arguments: (a b c : Ordinal.{u_1})
Goal: a ^ (b * c) = (a ^ b) ^ c
-- Ordinal.log_nonempty
theorem log_nonempty {b x : Ordinal} (h : 1 < b) : { o : Ordinal | x < b ^ o }.Nonempty 
Arguments: {b x : Ordinal.{u_1}} (h : 1 < b)
Goal: {o | x < b ^ o}.Nonempty
-- Ordinal.log_def
theorem log_def {b : Ordinal} (h : 1 < b) (x : Ordinal) :
    log b x = pred (sInf { o | x < b ^ o }) 
Arguments: {b : Ordinal.{u_1}} (h : 1 < b) (x : Ordinal.{u_1})
Goal: Ordinal.log b x = (sInf {o | x < b ^ o}).pred
-- Ordinal.log_of_not_one_lt_left
theorem log_of_not_one_lt_left {b : Ordinal} (h : ¬1 < b) (x : Ordinal) : log b x = 0 
Arguments: {b : Ordinal.{u_1}} (h : ¬1 < b) (x : Ordinal.{u_1})
Goal: Ordinal.log b x = 0
-- Ordinal.log_of_left_le_one
theorem log_of_left_le_one {b : Ordinal} (h : b ≤ 1) : ∀ x, log b x = 0 
Arguments: {b : Ordinal.{u_1}} (h : b ≤ 1) (x : Ordinal.{u_1})
Goal: Ordinal.log b x = 0
-- Ordinal.log_zero_left
@[simp]
theorem log_zero_left : ∀ b, log 0 b = 0 
Arguments: (b : Ordinal.{u_1})
Goal: Ordinal.log 0 b = 0
-- Ordinal.log_zero_right
@[simp]
theorem log_zero_right (b : Ordinal) : log b 0 = 0 
Arguments: (b : Ordinal.{u_1})
Goal: Ordinal.log b 0 = 0
-- Ordinal.log_one_left
@[simp]
theorem log_one_left : ∀ b, log 1 b = 0 
Arguments: (b : Ordinal.{u_1})
Goal: Ordinal.log 1 b = 0
-- Ordinal.succ_log_def
theorem succ_log_def {b x : Ordinal} (hb : 1 < b) (hx : x ≠ 0) :
    succ (log b x) = sInf { o : Ordinal | x < b ^ o } 
Arguments: {b x : Ordinal.{u_1}} (hb : 1 < b) (hx : x ≠ 0)
Goal: Order.succ (Ordinal.log b x) = sInf {o | x < b ^ o}
-- Ordinal.lt_opow_succ_log_self
theorem lt_opow_succ_log_self {b : Ordinal} (hb : 1 < b) (x : Ordinal) :
    x < b ^ succ (log b x) 
Arguments: {b : Ordinal.{u_1}} (hb : 1 < b) (x : Ordinal.{u_1})
Goal: x < b ^ Order.succ (Ordinal.log b x)
-- Ordinal.opow_log_le_self
theorem opow_log_le_self (b : Ordinal) {x : Ordinal} (hx : x ≠ 0) : b ^ log b x ≤ x 
Arguments: (b : Ordinal.{u_1}) {x : Ordinal.{u_1}} (hx : x ≠ 0)
Goal: b ^ Ordinal.log b x ≤ x
-- Ordinal.opow_le_iff_le_log
theorem opow_le_iff_le_log {b x c : Ordinal} (hb : 1 < b) (hx : x ≠ 0) : b ^ c ≤ x ↔ c ≤ log b x 
Arguments: {b x c : Ordinal.{u_1}} (hb : 1 < b) (hx : x ≠ 0)
Goal: b ^ c ≤ x ↔ c ≤ Ordinal.log b x
-- Ordinal.lt_opow_iff_log_lt
theorem lt_opow_iff_log_lt {b x c : Ordinal} (hb : 1 < b) (hx : x ≠ 0) : x < b ^ c ↔ log b x < c 
Arguments: {b x c : Ordinal.{u_1}} (hb : 1 < b) (hx : x ≠ 0)
Goal: x < b ^ c ↔ Ordinal.log b x < c
-- Ordinal.log_pos
theorem log_pos {b o : Ordinal} (hb : 1 < b) (ho : o ≠ 0) (hbo : b ≤ o) : 0 < log b o 
Arguments: {b o : Ordinal.{u_1}} (hb : 1 < b) (ho : o ≠ 0) (hbo : b ≤ o)
Goal: 0 < Ordinal.log b o
-- Ordinal.log_eq_zero
theorem log_eq_zero {b o : Ordinal} (hbo : o < b) : log b o = 0 
Arguments: {b o : Ordinal.{u_1}} (hbo : o < b)
Goal: Ordinal.log b o = 0
-- Ordinal.log_mono_right
@[mono]
theorem log_mono_right (b : Ordinal) {x y : Ordinal} (xy : x ≤ y) : log b x ≤ log b y 
Arguments: (b : Ordinal.{u_1}) {x y : Ordinal.{u_1}} (xy : x ≤ y)
Goal: Ordinal.log b x ≤ Ordinal.log b y
-- Ordinal.log_le_self
theorem log_le_self (b x : Ordinal) : log b x ≤ x 
Arguments: (b x : Ordinal.{u_1})
Goal: Ordinal.log b x ≤ x
-- Ordinal.log_one_right
@[simp]
theorem log_one_right (b : Ordinal) : log b 1 = 0 
Arguments: (b : Ordinal.{u_1})
Goal: Ordinal.log b 1 = 0
-- Ordinal.mod_opow_log_lt_self
theorem mod_opow_log_lt_self (b : Ordinal) {o : Ordinal} (ho : o ≠ 0) : o % (b ^ log b o) < o 
Arguments: (b : Ordinal.{u_1}) {o : Ordinal.{u_1}} (ho : o ≠ 0)
Goal: o % b ^ Ordinal.log b o < o
-- Ordinal.log_mod_opow_log_lt_log_self
theorem log_mod_opow_log_lt_log_self {b o : Ordinal} (hb : 1 < b) (ho : o ≠ 0) (hbo : b ≤ o) :
    log b (o % (b ^ log b o)) < log b o 
Arguments: {b o : Ordinal.{u_1}} (hb : 1 < b) (ho : o ≠ 0) (hbo : b ≤ o)
Goal: Ordinal.log b (o % b ^ Ordinal.log b o) < Ordinal.log b o
-- Ordinal.opow_mul_add_pos
theorem opow_mul_add_pos {b v : Ordinal} (hb : b ≠ 0) (u : Ordinal) (hv : v ≠ 0) (w : Ordinal) :
    0 < b ^ u * v + w 
Arguments: {b v : Ordinal.{u_1}} (hb : b ≠ 0) (u : Ordinal.{u_1}) (hv : v ≠ 0) (w : Ordinal.{u_1})
Goal: 0 < b ^ u * v + w
-- Ordinal.opow_mul_add_lt_opow_mul_succ
theorem opow_mul_add_lt_opow_mul_succ {b u w : Ordinal} (v : Ordinal) (hw : w < b ^ u) :
    b ^ u * v + w < b ^ u * succ v 
Arguments: {b u w : Ordinal.{u_1}} (v : Ordinal.{u_1}) (hw : w < b ^ u)
Goal: b ^ u * v + w < b ^ u * Order.succ v
-- Ordinal.opow_mul_add_lt_opow_succ
theorem opow_mul_add_lt_opow_succ {b u v w : Ordinal} (hvb : v < b) (hw : w < b ^ u) :
    b ^ u * v + w < b ^ succ u 
Arguments: {b u v w : Ordinal.{u_1}} (hvb : v < b) (hw : w < b ^ u)
Goal: b ^ u * v + w < b ^ Order.succ u
-- Ordinal.log_opow_mul_add
theorem log_opow_mul_add {b u v w : Ordinal} (hb : 1 < b) (hv : v ≠ 0) (hvb : v < b)
    (hw : w < b ^ u) : log b (b ^ u * v + w) = u 
Arguments: {b u v w : Ordinal.{u_1}} (hb : 1 < b) (hv : v ≠ 0) (hvb : v < b) (hw : w < b ^ u)
Goal: Ordinal.log b (b ^ u * v + w) = u