ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- PhragmenLindelof.eq_zero_on_right_half_plane_of_superexponential_decay
theorem eq_zero_on_right_half_plane_of_superexponential_decay (hd : DiffContOnCl ℂ f {z | 0 < z.re})
    (hexp : ∃ c < (2 : ℝ), ∃ B,
      f =O[cobounded ℂ ⊓ 𝓟 {z | 0 < z.re}] fun z => expR (B * abs z ^ c))
    (hre : SuperpolynomialDecay atTop expR fun x => ‖f x‖) (him : ∃ C, ∀ x : ℝ, ‖f (x * I)‖ ≤ C) :
    EqOn f 0 {z : ℂ | 0 ≤ z.re} 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℂ E] {f : ℂ → E} (hd : DiffContOnCl ℂ f {z | 0 < z.re}) (hexp : ∃ c < 2, ∃ B, f =O[Bornology.cobounded ℂ ⊓ 𝓟 {z | 0 < z.re}] fun z => expR (B * Complex.abs z ^ c)) (hre : Asymptotics.SuperpolynomialDecay Filter.atTop expR fun x => ‖f ↑x‖) (him : ∃ C, ∀ (x : ℝ), ‖f (↑x * Complex.I)‖ ≤ C)
Goal: Set.EqOn f 0 {z | 0 ≤ z.re}
-- PhragmenLindelof.eqOn_right_half_plane_of_superexponential_decay
theorem eqOn_right_half_plane_of_superexponential_decay {g : ℂ → E}
    (hfd : DiffContOnCl ℂ f {z | 0 < z.re}) (hgd : DiffContOnCl ℂ g {z | 0 < z.re})
    (hfexp : ∃ c < (2 : ℝ), ∃ B,
      f =O[cobounded ℂ ⊓ 𝓟 {z | 0 < z.re}] fun z => expR (B * abs z ^ c))
    (hgexp : ∃ c < (2 : ℝ), ∃ B,
      g =O[cobounded ℂ ⊓ 𝓟 {z | 0 < z.re}] fun z => expR (B * abs z ^ c))
    (hre : SuperpolynomialDecay atTop expR fun x => ‖f x - g x‖)
    (hfim : ∃ C, ∀ x : ℝ, ‖f (x * I)‖ ≤ C) (hgim : ∃ C, ∀ x : ℝ, ‖g (x * I)‖ ≤ C) :
    EqOn f g {z : ℂ | 0 ≤ z.re} 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℂ E] {f g : ℂ → E} (hfd : DiffContOnCl ℂ f {z | 0 < z.re}) (hgd : DiffContOnCl ℂ g {z | 0 < z.re}) (hfexp : ∃ c < 2, ∃ B, f =O[Bornology.cobounded ℂ ⊓ 𝓟 {z | 0 < z.re}] fun z => expR (B * Complex.abs z ^ c)) (hgexp : ∃ c < 2, ∃ B, g =O[Bornology.cobounded ℂ ⊓ 𝓟 {z | 0 < z.re}] fun z => expR (B * Complex.abs z ^ c)) (hre : Asymptotics.SuperpolynomialDecay Filter.atTop expR fun x => ‖f ↑x - g ↑x‖) (hfim : ∃ C, ∀ (x : ℝ), ‖f (↑x * Complex.I)‖ ≤ C) (hgim : ∃ C, ∀ (x : ℝ), ‖g (↑x * Complex.I)‖ ≤ C)
Goal: Set.EqOn f g {z | 0 ≤ z.re}
-- Ordinal.CNFRec_zero
@[simp]
theorem CNFRec_zero {C : Ordinal → Sort*} (b : Ordinal) (H0 : C 0)
    (H : ∀ o, o ≠ 0 → C (o % b ^ log b o) → C o) : @CNFRec b C H0 H 0 = H0 
Arguments: {C : Ordinal.{u_2} → Sort u_1} (b : Ordinal.{u_2}) (H0 : C 0) (H : (o : Ordinal.{u_2}) → o ≠ 0 → C (o % b ^ Ordinal.log b o) → C o)
Goal: b.CNFRec H0 H 0 = H0
-- Ordinal.CNFRec_pos
theorem CNFRec_pos (b : Ordinal) {o : Ordinal} {C : Ordinal → Sort*} (ho : o ≠ 0) (H0 : C 0)
    (H : ∀ o, o ≠ 0 → C (o % b ^ log b o) → C o) :
    @CNFRec b C H0 H o = H o ho (@CNFRec b C H0 H _) 
Arguments: (b : Ordinal.{u_2}) {o : Ordinal.{u_2}} {C : Ordinal.{u_2} → Sort u_1} (ho : o ≠ 0) (H0 : C 0) (H : (o : Ordinal.{u_2}) → o ≠ 0 → C (o % b ^ Ordinal.log b o) → C o)
Goal: b.CNFRec H0 H o = H o ho (b.CNFRec H0 H (o % b ^ Ordinal.log b o))
-- Ordinal.CNF_zero
@[simp]
theorem CNF_zero (b : Ordinal) : CNF b 0 = [] 
Arguments: (b : Ordinal.{u_1})
Goal: Ordinal.CNF b 0 = []
-- Ordinal.CNF_ne_zero
theorem CNF_ne_zero {b o : Ordinal} (ho : o ≠ 0) :
    CNF b o = (log b o, o / b ^ log b o)::CNF b (o % b ^ log b o) 
Arguments: {b o : Ordinal.{u_1}} (ho : o ≠ 0)
Goal: Ordinal.CNF b o = (Ordinal.log b o, o / b ^ Ordinal.log b o) :: Ordinal.CNF b (o % b ^ Ordinal.log b o)
-- Ordinal.zero_CNF
theorem zero_CNF {o : Ordinal} (ho : o ≠ 0) : CNF 0 o = [⟨0, o⟩] 
Arguments: {o : Ordinal.{u_1}} (ho : o ≠ 0)
Goal: Ordinal.CNF 0 o = [(0, o)]
-- Ordinal.one_CNF
theorem one_CNF {o : Ordinal} (ho : o ≠ 0) : CNF 1 o = [⟨0, o⟩] 
Arguments: {o : Ordinal.{u_1}} (ho : o ≠ 0)
Goal: Ordinal.CNF 1 o = [(0, o)]
-- Ordinal.CNF_of_le_one
theorem CNF_of_le_one {b o : Ordinal} (hb : b ≤ 1) (ho : o ≠ 0) : CNF b o = [⟨0, o⟩] 
Arguments: {b o : Ordinal.{u_1}} (hb : b ≤ 1) (ho : o ≠ 0)
Goal: Ordinal.CNF b o = [(0, o)]
-- Ordinal.CNF_of_lt
theorem CNF_of_lt {b o : Ordinal} (ho : o ≠ 0) (hb : o < b) : CNF b o = [⟨0, o⟩] 
Arguments: {b o : Ordinal.{u_1}} (ho : o ≠ 0) (hb : o < b)
Goal: Ordinal.CNF b o = [(0, o)]
-- Ordinal.CNF_foldr
theorem CNF_foldr (b o : Ordinal) : (CNF b o).foldr (fun p r ↦ b ^ p.1 * p.2 + r) 0 = o 
Arguments: (b o : Ordinal.{u_1})
Goal: List.foldr (fun p r => b ^ p.1 * p.2 + r) 0 (Ordinal.CNF b o) = o
-- Ordinal.CNF_fst_le_log
theorem CNF_fst_le_log {b o : Ordinal.{u}} {x : Ordinal × Ordinal} :
    x ∈ CNF b o → x.1 ≤ log b o 
Arguments: {b o : Ordinal.{u}} {x : Ordinal.{u} × Ordinal.{u}}
Goal: x ∈ Ordinal.CNF b o → x.1 ≤ Ordinal.log b o
-- Ordinal.CNF_fst_le
theorem CNF_fst_le {b o : Ordinal.{u}} {x : Ordinal × Ordinal} (h : x ∈ CNF b o) : x.1 ≤ o 
Arguments: {b o : Ordinal.{u}} {x : Ordinal.{u} × Ordinal.{u}} (h : x ∈ Ordinal.CNF b o)
Goal: x.1 ≤ o
-- Ordinal.CNF_lt_snd
theorem CNF_lt_snd {b o : Ordinal.{u}} {x : Ordinal × Ordinal} : x ∈ CNF b o → 0 < x.2 
Arguments: {b o : Ordinal.{u}} {x : Ordinal.{u} × Ordinal.{u}}
Goal: x ∈ Ordinal.CNF b o → 0 < x.2
-- Ordinal.CNF_snd_lt
theorem CNF_snd_lt {b o : Ordinal.{u}} (hb : 1 < b) {x : Ordinal × Ordinal} :
    x ∈ CNF b o → x.2 < b 
Arguments: {b o : Ordinal.{u}} (hb : 1 < b) {x : Ordinal.{u} × Ordinal.{u}}
Goal: x ∈ Ordinal.CNF b o → x.2 < b
-- Ordinal.CNF_sorted
theorem CNF_sorted (b o : Ordinal) : ((CNF b o).map Prod.fst).Sorted (· > ·) 
Arguments: (b o : Ordinal.{u_1})
Goal: List.Sorted (fun x x_1 => x > x_1) (List.map Prod.fst (Ordinal.CNF b o))
-- Ordinal.toPGame_def
@[nolint unusedHavesSuffices]
theorem toPGame_def (o : Ordinal) :
    have : IsWellOrder o.out.α (· < ·) := isWellOrder_out_lt o
    o.toPGame = ⟨o.out.α, PEmpty, fun x => (typein (· < ·) x).toPGame, PEmpty.elim⟩ 
Arguments: (o : Ordinal.{u_1})
Goal: let_fun this := ⋯;
o.toPGame =
  SetTheory.PGame.mk (Quotient.out o).α PEmpty.{u_1 + 1} (fun x => (Ordinal.typein (fun x x_1 => x < x_1) x).toPGame)
    PEmpty.elim
-- Ordinal.toPGame_leftMoves
@[simp, nolint unusedHavesSuffices]
theorem toPGame_leftMoves (o : Ordinal) : o.toPGame.LeftMoves = o.out.α 
Arguments: (o : Ordinal.{u_1})
Goal: o.toPGame.LeftMoves = (Quotient.out o).α
-- Ordinal.toPGame_rightMoves
@[simp, nolint unusedHavesSuffices]
theorem toPGame_rightMoves (o : Ordinal) : o.toPGame.RightMoves = PEmpty 
Arguments: (o : Ordinal.{u_1})
Goal: o.toPGame.RightMoves = PEmpty.{u_1 + 1}
-- Ordinal.toLeftMovesToPGame_symm_lt
@[simp]
theorem toLeftMovesToPGame_symm_lt {o : Ordinal} (i : o.toPGame.LeftMoves) :
    ↑(toLeftMovesToPGame.symm i) < o 
Arguments: {o : Ordinal.{u_1}} (i : o.toPGame.LeftMoves)
Goal: ↑(Ordinal.toLeftMovesToPGame.symm i) < o
-- Ordinal.toPGame_moveLeft_hEq
@[nolint unusedHavesSuffices]
theorem toPGame_moveLeft_hEq {o : Ordinal} :
    have : IsWellOrder o.out.α (· < ·) := isWellOrder_out_lt o
    HEq o.toPGame.moveLeft fun x : o.out.α => (typein (· < ·) x).toPGame 
Arguments: {o : Ordinal.{u_1}}
Goal: let_fun this := ⋯;
HEq o.toPGame.moveLeft fun x => (Ordinal.typein (fun x x_1 => x < x_1) x).toPGame
-- Ordinal.toPGame_moveLeft'
@[simp]
theorem toPGame_moveLeft' {o : Ordinal} (i) :
    o.toPGame.moveLeft i = (toLeftMovesToPGame.symm i).val.toPGame 
Arguments: {o : Ordinal.{u_1}} (i : o.toPGame.LeftMoves)
Goal: o.toPGame.moveLeft i = (↑(Ordinal.toLeftMovesToPGame.symm i)).toPGame
-- Ordinal.toPGame_moveLeft
theorem toPGame_moveLeft {o : Ordinal} (i) :
    o.toPGame.moveLeft (toLeftMovesToPGame i) = i.val.toPGame 
Arguments: {o : Ordinal.{u_1}} (i : ↑(Set.Iio o))
Goal: o.toPGame.moveLeft (Ordinal.toLeftMovesToPGame i) = (↑i).toPGame
-- Ordinal.one_toPGame_leftMoves_default_eq
@[simp]
theorem one_toPGame_leftMoves_default_eq :
    (default : (toPGame 1).LeftMoves) = @toLeftMovesToPGame 1 ⟨0, Set.mem_Iio.mpr zero_lt_one⟩ 
Goal: default = Ordinal.toLeftMovesToPGame ⟨0, ⋯⟩
-- Ordinal.to_leftMoves_one_toPGame_symm
@[simp]
theorem to_leftMoves_one_toPGame_symm (i) :
    (@toLeftMovesToPGame 1).symm i = ⟨0, Set.mem_Iio.mpr zero_lt_one⟩ 
Arguments: (i : (Ordinal.toPGame 1).LeftMoves)
Goal: Ordinal.toLeftMovesToPGame.symm i = ⟨0, ⋯⟩
-- Ordinal.one_toPGame_moveLeft
theorem one_toPGame_moveLeft (x) : (toPGame 1).moveLeft x = toPGame 0 
Arguments: (x : (Ordinal.toPGame 1).LeftMoves)
Goal: (Ordinal.toPGame 1).moveLeft x = Ordinal.toPGame 0
-- Ordinal.toPGame_lf
theorem toPGame_lf {a b : Ordinal} (h : a < b) : a.toPGame ⧏ b.toPGame 
Arguments: {a b : Ordinal.{u_1}} (h : a < b)
Goal: a.toPGame ⧏ b.toPGame
-- Ordinal.toPGame_le
theorem toPGame_le {a b : Ordinal} (h : a ≤ b) : a.toPGame ≤ b.toPGame 
Arguments: {a b : Ordinal.{u_1}} (h : a ≤ b)
Goal: a.toPGame ≤ b.toPGame
-- Ordinal.toPGame_lt
theorem toPGame_lt {a b : Ordinal} (h : a < b) : a.toPGame < b.toPGame 
Arguments: {a b : Ordinal.{u_1}} (h : a < b)
Goal: a.toPGame < b.toPGame
-- Ordinal.toPGame_nonneg
theorem toPGame_nonneg (a : Ordinal) : 0 ≤ a.toPGame 
Arguments: (a : Ordinal.{u_1})
Goal: 0 ≤ a.toPGame
-- Ordinal.toPGame_lf_iff
@[simp]
theorem toPGame_lf_iff {a b : Ordinal} : a.toPGame ⧏ b.toPGame ↔ a < b 
Arguments: {a b : Ordinal.{u_1}}
Goal: a.toPGame ⧏ b.toPGame ↔ a < b
-- Ordinal.toPGame_le_iff
@[simp]
theorem toPGame_le_iff {a b : Ordinal} : a.toPGame ≤ b.toPGame ↔ a ≤ b 
Arguments: {a b : Ordinal.{u_1}}
Goal: a.toPGame ≤ b.toPGame ↔ a ≤ b
-- Ordinal.toPGame_lt_iff
@[simp]
theorem toPGame_lt_iff {a b : Ordinal} : a.toPGame < b.toPGame ↔ a < b 
Arguments: {a b : Ordinal.{u_1}}
Goal: a.toPGame < b.toPGame ↔ a < b
-- Ordinal.toPGame_equiv_iff
@[simp]
theorem toPGame_equiv_iff {a b : Ordinal} : (a.toPGame ≈ b.toPGame) ↔ a = b 
Arguments: {a b : Ordinal.{u_1}}
Goal: a.toPGame ≈ b.toPGame ↔ a = b
-- Ordinal.toPGame_injective
theorem toPGame_injective : Function.Injective Ordinal.toPGame 
Goal: Function.Injective Ordinal.toPGame
-- Ordinal.toPGame_eq_iff
@[simp]
theorem toPGame_eq_iff {a b : Ordinal} : a.toPGame = b.toPGame ↔ a = b 
Arguments: {a b : Ordinal.{u_1}}
Goal: a.toPGame = b.toPGame ↔ a = b
-- Ordinal.toPGameEmbedding_apply
@[simps]
noncomputable def toPGameEmbedding : Ordinal.{u} ↪o PGame.{u} 
Goal: ∀ (a : Ordinal.{u}), Ordinal.toPGameEmbedding a = a.toPGame
-- Ordinal.toPGame_add
theorem toPGame_add : ∀ a b : Ordinal.{u}, a.toPGame + b.toPGame ≈ (a ♯ b).toPGame
  
Arguments: (a b : Ordinal.{u})
Goal: a.toPGame + b.toPGame ≈ (a ♯ b).toPGame
-- Ordinal.toPGame_add_mk'
@[simp]
theorem toPGame_add_mk' (a b : Ordinal) : (⟦a.toPGame⟧ + ⟦b.toPGame⟧ : Game) = ⟦(a ♯ b).toPGame⟧ 
Arguments: (a b : Ordinal.{u_1})
Goal: ⟦a.toPGame⟧ + ⟦b.toPGame⟧ = ⟦(a ♯ b).toPGame⟧
-- SetTheory.PGame.powHalf_zero
@[simp]
theorem powHalf_zero : powHalf 0 = 1 
Goal: SetTheory.PGame.powHalf 0 = 1
-- SetTheory.PGame.powHalf_leftMoves
theorem powHalf_leftMoves (n) : (powHalf n).LeftMoves = PUnit 
Arguments: (n : ℕ)
Goal: (SetTheory.PGame.powHalf n).LeftMoves = PUnit.{u_1 + 1}
-- SetTheory.PGame.powHalf_zero_rightMoves
theorem powHalf_zero_rightMoves : (powHalf 0).RightMoves = PEmpty 
Goal: (SetTheory.PGame.powHalf 0).RightMoves = PEmpty.{u_1 + 1}
-- SetTheory.PGame.powHalf_succ_rightMoves
theorem powHalf_succ_rightMoves (n) : (powHalf (n + 1)).RightMoves = PUnit 
Arguments: (n : ℕ)
Goal: (SetTheory.PGame.powHalf (n + 1)).RightMoves = PUnit.{u_1 + 1}
-- SetTheory.PGame.powHalf_moveLeft
@[simp]
theorem powHalf_moveLeft (n i) : (powHalf n).moveLeft i = 0 
Arguments: (n : ℕ) (i : (SetTheory.PGame.powHalf n).LeftMoves)
Goal: (SetTheory.PGame.powHalf n).moveLeft i = 0
-- SetTheory.PGame.powHalf_succ_moveRight
@[simp]
theorem powHalf_succ_moveRight (n i) : (powHalf (n + 1)).moveRight i = powHalf n 
Arguments: (n : ℕ) (i : (SetTheory.PGame.powHalf (n + 1)).RightMoves)
Goal: (SetTheory.PGame.powHalf (n + 1)).moveRight i = SetTheory.PGame.powHalf n
-- SetTheory.PGame.birthday_half
@[simp]
theorem birthday_half : birthday (powHalf 1) = 2 
Goal: (SetTheory.PGame.powHalf 1).birthday = 2
-- SetTheory.PGame.numeric_powHalf
theorem numeric_powHalf (n) : (powHalf n).Numeric 
Arguments: (n : ℕ)
Goal: (SetTheory.PGame.powHalf n).Numeric
-- SetTheory.PGame.powHalf_succ_lt_powHalf
theorem powHalf_succ_lt_powHalf (n : ℕ) : powHalf (n + 1) < powHalf n 
Arguments: (n : ℕ)
Goal: SetTheory.PGame.powHalf (n + 1) < SetTheory.PGame.powHalf n
-- SetTheory.PGame.powHalf_succ_le_powHalf
theorem powHalf_succ_le_powHalf (n : ℕ) : powHalf (n + 1) ≤ powHalf n 
Arguments: (n : ℕ)
Goal: SetTheory.PGame.powHalf (n + 1) ≤ SetTheory.PGame.powHalf n
-- SetTheory.PGame.powHalf_le_one
theorem powHalf_le_one (n : ℕ) : powHalf n ≤ 1 
Arguments: (n : ℕ)
Goal: SetTheory.PGame.powHalf n ≤ 1
-- SetTheory.PGame.powHalf_succ_lt_one
theorem powHalf_succ_lt_one (n : ℕ) : powHalf (n + 1) < 1 
Arguments: (n : ℕ)
Goal: SetTheory.PGame.powHalf (n + 1) < 1
-- SetTheory.PGame.powHalf_pos
theorem powHalf_pos (n : ℕ) : 0 < powHalf n 
Arguments: (n : ℕ)
Goal: 0 < SetTheory.PGame.powHalf n
-- SetTheory.PGame.zero_le_powHalf
theorem zero_le_powHalf (n : ℕ) : 0 ≤ powHalf n 
Arguments: (n : ℕ)
Goal: 0 ≤ SetTheory.PGame.powHalf n
-- SetTheory.PGame.add_powHalf_succ_self_eq_powHalf
theorem add_powHalf_succ_self_eq_powHalf (n) : powHalf (n + 1) + powHalf (n + 1) ≈ powHalf n 
Arguments: (n : ℕ)
Goal: SetTheory.PGame.powHalf (n + 1) + SetTheory.PGame.powHalf (n + 1) ≈ SetTheory.PGame.powHalf n
-- SetTheory.PGame.half_add_half_equiv_one
theorem half_add_half_equiv_one : powHalf 1 + powHalf 1 ≈ 1 
Goal: SetTheory.PGame.powHalf 1 + SetTheory.PGame.powHalf 1 ≈ 1
-- Surreal.powHalf_zero
@[simp]
theorem powHalf_zero : powHalf 0 = 1 
Goal: Surreal.powHalf 0 = 1
-- Surreal.double_powHalf_succ_eq_powHalf
@[simp]
theorem double_powHalf_succ_eq_powHalf (n : ℕ) : 2 * powHalf (n + 1) = powHalf n 
Arguments: (n : ℕ)
Goal: 2 * Surreal.powHalf (n + 1) = Surreal.powHalf n
-- Surreal.nsmul_pow_two_powHalf
@[simp]
theorem nsmul_pow_two_powHalf (n : ℕ) : 2 ^ n * powHalf n = 1 
Arguments: (n : ℕ)
Goal: 2 ^ n * Surreal.powHalf n = 1
-- Surreal.nsmul_pow_two_powHalf'
@[simp]
theorem nsmul_pow_two_powHalf' (n k : ℕ) : 2 ^ n * powHalf (n + k) = powHalf k 
Arguments: (n k : ℕ)
Goal: 2 ^ n * Surreal.powHalf (n + k) = Surreal.powHalf k
-- Surreal.zsmul_pow_two_powHalf
theorem zsmul_pow_two_powHalf (m : ℤ) (n k : ℕ) :
    (m * 2 ^ n) * powHalf (n + k) = m * powHalf k 
Arguments: (m : ℤ) (n k : ℕ)
Goal: ↑m * 2 ^ n * Surreal.powHalf (n + k) = ↑m * Surreal.powHalf k
-- Surreal.dyadic_aux
theorem dyadic_aux {m₁ m₂ : ℤ} {y₁ y₂ : ℕ} (h₂ : m₁ * 2 ^ y₁ = m₂ * 2 ^ y₂) :
    m₁ * powHalf y₂ = m₂ * powHalf y₁ 
Arguments: {m₁ m₂ : ℤ} {y₁ y₂ : ℕ} (h₂ : m₁ * 2 ^ y₁ = m₂ * 2 ^ y₂)
Goal: ↑m₁ * Surreal.powHalf y₂ = ↑m₂ * Surreal.powHalf y₁
-- Surreal.dyadicMap_apply
@[simp]
theorem dyadicMap_apply (m : ℤ) (p : Submonoid.powers (2 : ℤ)) :
    dyadicMap (IsLocalization.mk' (Localization (Submonoid.powers 2)) m p) =
      m * powHalf (Submonoid.log p) 
Arguments: (m : ℤ) (p : ↥(Submonoid.powers 2))
Goal: Surreal.dyadicMap (IsLocalization.mk' (Localization (Submonoid.powers 2)) m p) = ↑m * Surreal.powHalf (Submonoid.log p)
-- Surreal.dyadicMap_apply_pow
theorem dyadicMap_apply_pow (m : ℤ) (n : ℕ) :
    dyadicMap (IsLocalization.mk' (Localization (Submonoid.powers 2)) m (Submonoid.pow 2 n)) =
      m • powHalf n 
Arguments: (m : ℤ) (n : ℕ)
Goal: Surreal.dyadicMap (IsLocalization.mk' (Localization (Submonoid.powers 2)) m (Submonoid.pow 2 n)) = m • Surreal.powHalf n
-- Surreal.dyadicMap_apply_pow'
@[simp]
theorem dyadicMap_apply_pow' (m : ℤ) (n : ℕ) :
    m * Surreal.powHalf (Submonoid.log (Submonoid.pow (2 : ℤ) n)) = m * powHalf n 
Arguments: (m : ℤ) (n : ℕ)
Goal: ↑m * Surreal.powHalf (Submonoid.log (Submonoid.pow 2 n)) = ↑m * Surreal.powHalf n
-- Cardinal.not_injective_limitation_set
theorem not_injective_limitation_set : ¬ InjOn g (Iio (ord <| succ #α)) 
Arguments: {α : Type u} (g : Ordinal.{u} → α)
Goal: ¬Set.InjOn g (Set.Iio (SuccOrder.succ (Cardinal.mk α)).ord)
-- OrdinalApprox.lfpApprox_monotone
theorem lfpApprox_monotone : Monotone (lfpApprox f x) 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α) (x : α)
Goal: Monotone (OrdinalApprox.lfpApprox f x)
-- OrdinalApprox.le_lfpApprox
theorem le_lfpApprox {a : Ordinal} : x ≤ lfpApprox f x a 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α) (x : α) {a : Ordinal.{u}}
Goal: x ≤ OrdinalApprox.lfpApprox f x a
-- OrdinalApprox.lfpApprox_add_one
theorem lfpApprox_add_one (h : x ≤ f x) (a : Ordinal) :
    lfpApprox f x (a+1) = f (lfpApprox f x a) 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α) (x : α) (h : x ≤ f x) (a : Ordinal.{u})
Goal: OrdinalApprox.lfpApprox f x (a + 1) = f (OrdinalApprox.lfpApprox f x a)
-- OrdinalApprox.lfpApprox_eq_of_mem_fixedPoints
theorem lfpApprox_eq_of_mem_fixedPoints {a b : Ordinal} (h_init : x ≤ f x) (h_ab : a ≤ b)
    (h : lfpApprox f x a ∈ fixedPoints f) : lfpApprox f x b = lfpApprox f x a 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α) (x : α) {a b : Ordinal.{u}} (h_init : x ≤ f x) (h_ab : a ≤ b) (h : OrdinalApprox.lfpApprox f x a ∈ Function.fixedPoints ⇑f)
Goal: OrdinalApprox.lfpApprox f x b = OrdinalApprox.lfpApprox f x a
-- OrdinalApprox.exists_lfpApprox_eq_lfpApprox
theorem exists_lfpApprox_eq_lfpApprox : ∃ a < ord <| succ #α, ∃ b < ord <| succ #α,
    a ≠ b ∧ lfpApprox f x a = lfpApprox f x b 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α) (x : α)
Goal: ∃ a < (Order.succ (Cardinal.mk α)).ord,
  ∃ b < (Order.succ (Cardinal.mk α)).ord, a ≠ b ∧ OrdinalApprox.lfpApprox f x a = OrdinalApprox.lfpApprox f x b
-- OrdinalApprox.lfpApprox_mem_fixedPoints_of_eq
lemma lfpApprox_mem_fixedPoints_of_eq {a b c : Ordinal}
    (h_init : x ≤ f x) (h_ab : a < b) (h_ac : a ≤ c) (h_fab : lfpApprox f x a = lfpApprox f x b) :
    lfpApprox f x c ∈ fixedPoints f 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α) (x : α) {a b c : Ordinal.{u}} (h_init : x ≤ f x) (h_ab : a < b) (h_ac : a ≤ c) (h_fab : OrdinalApprox.lfpApprox f x a = OrdinalApprox.lfpApprox f x b)
Goal: OrdinalApprox.lfpApprox f x c ∈ Function.fixedPoints ⇑f
-- OrdinalApprox.lfpApprox_ord_mem_fixedPoint
theorem lfpApprox_ord_mem_fixedPoint (h_init : x ≤ f x) :
    lfpApprox f x (ord <| succ #α) ∈ fixedPoints f 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α) (x : α) (h_init : x ≤ f x)
Goal: OrdinalApprox.lfpApprox f x (Order.succ (Cardinal.mk α)).ord ∈ Function.fixedPoints ⇑f
-- OrdinalApprox.lfpApprox_le_of_mem_fixedPoints
theorem lfpApprox_le_of_mem_fixedPoints {a : α}
    (h_a : a ∈ fixedPoints f) (h_le_init : x ≤ a) (i : Ordinal) : lfpApprox f x i ≤ a 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α) (x : α) {a : α} (h_a : a ∈ Function.fixedPoints ⇑f) (h_le_init : x ≤ a) (i : Ordinal.{u})
Goal: OrdinalApprox.lfpApprox f x i ≤ a
-- OrdinalApprox.lfpApprox_ord_eq_lfp
theorem lfpApprox_ord_eq_lfp : lfpApprox f ⊥ (ord <| succ #α) = lfp f 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α)
Goal: OrdinalApprox.lfpApprox f ⊥ (Order.succ (Cardinal.mk α)).ord = OrderHom.lfp f
-- OrdinalApprox.lfp_mem_range_lfpApprox
theorem lfp_mem_range_lfpApprox : lfp f ∈ Set.range (lfpApprox f ⊥) 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α)
Goal: OrderHom.lfp f ∈ Set.range (OrdinalApprox.lfpApprox f ⊥)
-- OrdinalApprox.gfpApprox_antitone
theorem gfpApprox_antitone : Antitone (gfpApprox f x) 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α) (x : α)
Goal: Antitone (OrdinalApprox.gfpApprox f x)
-- OrdinalApprox.gfpApprox_le
theorem gfpApprox_le {a : Ordinal} : gfpApprox f x a ≤ x 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α) (x : α) {a : Ordinal.{u}}
Goal: OrdinalApprox.gfpApprox f x a ≤ x
-- OrdinalApprox.gfpApprox_add_one
theorem gfpApprox_add_one (h : f x ≤ x) (a : Ordinal) :
    gfpApprox f x (a+1) = f (gfpApprox f x a) 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α) (x : α) (h : f x ≤ x) (a : Ordinal.{u})
Goal: OrdinalApprox.gfpApprox f x (a + 1) = f (OrdinalApprox.gfpApprox f x a)
-- OrdinalApprox.gfpApprox_eq_of_mem_fixedPoints
theorem gfpApprox_eq_of_mem_fixedPoints {a b : Ordinal} (h_init : f x ≤ x) (h_ab : a ≤ b)
    (h : gfpApprox f x a ∈ fixedPoints f) : gfpApprox f x b = gfpApprox f x a 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α) (x : α) {a b : Ordinal.{u}} (h_init : f x ≤ x) (h_ab : a ≤ b) (h : OrdinalApprox.gfpApprox f x a ∈ Function.fixedPoints ⇑f)
Goal: OrdinalApprox.gfpApprox f x b = OrdinalApprox.gfpApprox f x a
-- OrdinalApprox.exists_gfpApprox_eq_gfpApprox
theorem exists_gfpApprox_eq_gfpApprox : ∃ a < ord <| succ #α, ∃ b < ord <| succ #α,
    a ≠ b ∧ gfpApprox f x a = gfpApprox f x b 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α) (x : α)
Goal: ∃ a < (Order.succ (Cardinal.mk α)).ord,
  ∃ b < (Order.succ (Cardinal.mk α)).ord, a ≠ b ∧ OrdinalApprox.gfpApprox f x a = OrdinalApprox.gfpApprox f x b
-- OrdinalApprox.gfpApprox_ord_mem_fixedPoint
lemma gfpApprox_ord_mem_fixedPoint (h_init : f x ≤ x) :
    gfpApprox f x (ord <| succ #α) ∈ fixedPoints f 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α) (x : α) (h_init : f x ≤ x)
Goal: OrdinalApprox.gfpApprox f x (Order.succ (Cardinal.mk α)).ord ∈ Function.fixedPoints ⇑f
-- OrdinalApprox.le_gfpApprox_of_mem_fixedPoints
lemma le_gfpApprox_of_mem_fixedPoints {a : α}
    (h_a : a ∈ fixedPoints f) (h_le_init : a ≤ x) (i : Ordinal) : a ≤ gfpApprox f x i 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α) (x : α) {a : α} (h_a : a ∈ Function.fixedPoints ⇑f) (h_le_init : a ≤ x) (i : Ordinal.{u})
Goal: a ≤ OrdinalApprox.gfpApprox f x i
-- OrdinalApprox.gfpApprox_ord_eq_gfp
theorem gfpApprox_ord_eq_gfp : gfpApprox f ⊤ (ord <| succ #α) = gfp f 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α)
Goal: OrdinalApprox.gfpApprox f ⊤ (Order.succ (Cardinal.mk α)).ord = OrderHom.gfp f
-- OrdinalApprox.gfp_mem_range_gfpApprox
theorem gfp_mem_range_gfpApprox : gfp f ∈ Set.range (gfpApprox f ⊤) 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α)
Goal: OrderHom.gfp f ∈ Set.range (OrdinalApprox.gfpApprox f ⊤)
-- SetTheory.PGame.birthday_def
theorem birthday_def (x : PGame) :
    birthday x =
      max (lsub.{u, u} fun i => birthday (x.moveLeft i))
        (lsub.{u, u} fun i => birthday (x.moveRight i)) 
Arguments: (x : SetTheory.PGame)
Goal: x.birthday = max (Ordinal.lsub fun i => (x.moveLeft i).birthday) (Ordinal.lsub fun i => (x.moveRight i).birthday)
-- SetTheory.PGame.birthday_moveLeft_lt
theorem birthday_moveLeft_lt {x : PGame} (i : x.LeftMoves) :
    (x.moveLeft i).birthday < x.birthday 
Arguments: {x : SetTheory.PGame} (i : x.LeftMoves)
Goal: (x.moveLeft i).birthday < x.birthday
-- SetTheory.PGame.birthday_moveRight_lt
theorem birthday_moveRight_lt {x : PGame} (i : x.RightMoves) :
    (x.moveRight i).birthday < x.birthday 
Arguments: {x : SetTheory.PGame} (i : x.RightMoves)
Goal: (x.moveRight i).birthday < x.birthday
-- SetTheory.PGame.lt_birthday_iff
theorem lt_birthday_iff {x : PGame} {o : Ordinal} :
    o < x.birthday ↔
      (∃ i : x.LeftMoves, o ≤ (x.moveLeft i).birthday) ∨
        ∃ i : x.RightMoves, o ≤ (x.moveRight i).birthday 
Arguments: {x : SetTheory.PGame} {o : Ordinal.{u_1}}
Goal: o < x.birthday ↔ (∃ i, o ≤ (x.moveLeft i).birthday) ∨ ∃ i, o ≤ (x.moveRight i).birthday
-- SetTheory.PGame.Relabelling.birthday_congr
theorem Relabelling.birthday_congr : ∀ {x y : PGame.{u}}, x ≡r y → birthday x = birthday y
  
Arguments: {x y : SetTheory.PGame}
Goal: x.Relabelling y → x.birthday = y.birthday
-- SetTheory.PGame.birthday_eq_zero
@[simp]
theorem birthday_eq_zero {x : PGame} :
    birthday x = 0 ↔ IsEmpty x.LeftMoves ∧ IsEmpty x.RightMoves 
Arguments: {x : SetTheory.PGame}
Goal: x.birthday = 0 ↔ IsEmpty x.LeftMoves ∧ IsEmpty x.RightMoves
-- SetTheory.PGame.birthday_zero
@[simp]
theorem birthday_zero : birthday 0 = 0 
Goal: SetTheory.PGame.birthday 0 = 0
-- SetTheory.PGame.birthday_one
@[simp]
theorem birthday_one : birthday 1 = 1 
Goal: SetTheory.PGame.birthday 1 = 1
-- SetTheory.PGame.birthday_star
@[simp]
theorem birthday_star : birthday star = 1 
Goal: SetTheory.PGame.star.birthday = 1
-- SetTheory.PGame.neg_birthday
@[simp]
theorem neg_birthday : ∀ x : PGame, (-x).birthday = x.birthday
  
Arguments: (x : SetTheory.PGame)
Goal: (-x).birthday = x.birthday
-- SetTheory.PGame.toPGame_birthday
@[simp]
theorem toPGame_birthday (o : Ordinal) : o.toPGame.birthday = o 
Arguments: (o : Ordinal.{u_1})
Goal: o.toPGame.birthday = o
-- SetTheory.PGame.le_birthday
theorem le_birthday : ∀ x : PGame, x ≤ x.birthday.toPGame
  
Arguments: (x : SetTheory.PGame)
Goal: x ≤ x.birthday.toPGame
-- SetTheory.PGame.neg_birthday_le
theorem neg_birthday_le : -x.birthday.toPGame ≤ x 
Arguments: (x : SetTheory.PGame)
Goal: -x.birthday.toPGame ≤ x