File: Mathlib/Data/Real/Hyperreal.lean

full_name: Hyperreal
code: /-- Hyperreal numbers on the ultrafilter extending the cofinite filter -/
def Hyperreal : Type 
goal: Type

full_name: Hyperreal._aux_Mathlib_Data_Real_Hyperreal___unexpand_Hyperreal_1
code: @[inherit_doc] notation "ℝ*" => Hyperreal
goal: Lean.PrettyPrinter.Unexpander

full_name: Hyperreal.«_aux_Mathlib_Data_Real_Hyperreal___macroRules_Hyperreal_termℝ*_1»
code: @[inherit_doc] notation "ℝ*" => Hyperreal
goal: Lean.Macro

full_name: Hyperreal.instLinearOrderedField
code: noncomputable instance : LinearOrderedField ℝ* 
goal: LinearOrderedField ℝ*

full_name: Hyperreal.ofReal
code: /-- Natural embedding `ℝ → ℝ*`. -/
@[coe] def ofReal : ℝ → ℝ* 
goal: ℝ → ℝ*

full_name: Hyperreal.instCoeTCReal
code: noncomputable instance : CoeTC ℝ ℝ* 
goal: CoeTC ℝ ℝ*

full_name: Hyperreal.coe_eq_coe
code: @[simp, norm_cast]
theorem coe_eq_coe {x y : ℝ} : (x : ℝ*) = y ↔ x = y 
goal: ↑x = ↑y ↔ x = y

full_name: Hyperreal.coe_ne_coe
code: theorem coe_ne_coe {x y : ℝ} : (x : ℝ*) ≠ y ↔ x ≠ y 
goal: ↑x ≠ ↑y ↔ x ≠ y

full_name: Hyperreal.coe_eq_zero
code: @[simp, norm_cast]
theorem coe_eq_zero {x : ℝ} : (x : ℝ*) = 0 ↔ x = 0 
goal: ↑x = 0 ↔ x = 0

full_name: Hyperreal.coe_eq_one
code: @[simp, norm_cast]
theorem coe_eq_one {x : ℝ} : (x : ℝ*) = 1 ↔ x = 1 
goal: ↑x = 1 ↔ x = 1

full_name: Hyperreal.coe_ne_zero
code: @[norm_cast]
theorem coe_ne_zero {x : ℝ} : (x : ℝ*) ≠ 0 ↔ x ≠ 0 
goal: ↑x ≠ 0 ↔ x ≠ 0

full_name: Hyperreal.coe_ne_one
code: @[norm_cast]
theorem coe_ne_one {x : ℝ} : (x : ℝ*) ≠ 1 ↔ x ≠ 1 
goal: ↑x ≠ 1 ↔ x ≠ 1

full_name: Hyperreal.coe_one
code: @[simp, norm_cast]
theorem coe_one : ↑(1 : ℝ) = (1 : ℝ*) 
goal: ↑1 = 1

full_name: Hyperreal.coe_zero
code: @[simp, norm_cast]
theorem coe_zero : ↑(0 : ℝ) = (0 : ℝ*) 
goal: ↑0 = 0

full_name: Hyperreal.coe_inv
code: @[simp, norm_cast]
theorem coe_inv (x : ℝ) : ↑x⁻¹ = (x⁻¹ : ℝ*) 
goal: ↑x⁻¹ = (↑x)⁻¹

full_name: Hyperreal.coe_neg
code: @[simp, norm_cast]
theorem coe_neg (x : ℝ) : ↑(-x) = (-x : ℝ*) 
goal: ↑(-x) = -↑x

full_name: Hyperreal.coe_add
code: @[simp, norm_cast]
theorem coe_add (x y : ℝ) : ↑(x + y) = (x + y : ℝ*) 
goal: ↑(x + y) = ↑x + ↑y

full_name: Hyperreal.coe_ofNat
code: @[simp, norm_cast]
theorem coe_ofNat (n : ℕ) [n.AtLeastTwo] :
    ((no_index (OfNat.ofNat n : ℝ)) : ℝ*) = OfNat.ofNat n 
goal: ↑(OfNat.ofNat n) = OfNat.ofNat n

full_name: Hyperreal.coe_mul
code: @[simp, norm_cast]
theorem coe_mul (x y : ℝ) : ↑(x * y) = (x * y : ℝ*) 
goal: ↑(x * y) = ↑x * ↑y

full_name: Hyperreal.coe_div
code: @[simp, norm_cast]
theorem coe_div (x y : ℝ) : ↑(x / y) = (x / y : ℝ*) 
goal: ↑(x / y) = ↑x / ↑y

full_name: Hyperreal.coe_sub
code: @[simp, norm_cast]
theorem coe_sub (x y : ℝ) : ↑(x - y) = (x - y : ℝ*) 
goal: ↑(x - y) = ↑x - ↑y

full_name: Hyperreal.coe_le_coe
code: @[simp, norm_cast]
theorem coe_le_coe {x y : ℝ} : (x : ℝ*) ≤ y ↔ x ≤ y 
goal: ↑x ≤ ↑y ↔ x ≤ y

full_name: Hyperreal.coe_lt_coe
code: @[simp, norm_cast]
theorem coe_lt_coe {x y : ℝ} : (x : ℝ*) < y ↔ x < y 
goal: ↑x < ↑y ↔ x < y

full_name: Hyperreal.coe_nonneg
code: @[simp, norm_cast]
theorem coe_nonneg {x : ℝ} : 0 ≤ (x : ℝ*) ↔ 0 ≤ x 
goal: 0 ≤ ↑x ↔ 0 ≤ x

full_name: Hyperreal.coe_pos
code: @[simp, norm_cast]
theorem coe_pos {x : ℝ} : 0 < (x : ℝ*) ↔ 0 < x 
goal: 0 < ↑x ↔ 0 < x

full_name: Hyperreal.coe_abs
code: @[simp, norm_cast]
theorem coe_abs (x : ℝ) : ((|x| : ℝ) : ℝ*) = |↑x| 
goal: ↑|x| = |↑x|

full_name: Hyperreal.coe_max
code: @[simp, norm_cast]
theorem coe_max (x y : ℝ) : ((max x y : ℝ) : ℝ*) = max ↑x ↑y 
goal: ↑(max x y) = max ↑x ↑y

full_name: Hyperreal.coe_min
code: @[simp, norm_cast]
theorem coe_min (x y : ℝ) : ((min x y : ℝ) : ℝ*) = min ↑x ↑y 
goal: ↑(min x y) = min ↑x ↑y

full_name: Hyperreal.ofSeq
code: /-- Construct a hyperreal number from a sequence of real numbers. -/
def ofSeq (f : ℕ → ℝ) : ℝ* 
goal: ℝ*

full_name: Hyperreal.ofSeq_surjective
code: theorem ofSeq_surjective : Function.Surjective ofSeq 
goal: Function.Surjective Hyperreal.ofSeq

full_name: Hyperreal.ofSeq_lt_ofSeq
code: theorem ofSeq_lt_ofSeq {f g : ℕ → ℝ} : ofSeq f < ofSeq g ↔ ∀ᶠ n in hyperfilter ℕ, f n < g n 
goal: Hyperreal.ofSeq f < Hyperreal.ofSeq g ↔ ∀ᶠ (n : ℕ) in ↑(Filter.hyperfilter ℕ), f n < g n

full_name: Hyperreal.epsilon
code: /-- A sample infinitesimal hyperreal-/
noncomputable def epsilon : ℝ* 
goal: ℝ*

full_name: Hyperreal.omega
code: /-- A sample infinite hyperreal-/
noncomputable def omega : ℝ* 
goal: ℝ*

full_name: Hyperreal._aux_Mathlib_Data_Real_Hyperreal___macroRules_Hyperreal_termε_1
code: @[inherit_doc] scoped notation "ε" => Hyperreal.epsilon
goal: Lean.Macro

full_name: Hyperreal._aux_Mathlib_Data_Real_Hyperreal___unexpand_Hyperreal_epsilon_1
code: @[inherit_doc] scoped notation "ε" => Hyperreal.epsilon
goal: Lean.PrettyPrinter.Unexpander

full_name: Hyperreal._aux_Mathlib_Data_Real_Hyperreal___macroRules_Hyperreal_termω_1
code: @[inherit_doc] scoped notation "ω" => Hyperreal.omega
goal: Lean.Macro

full_name: Hyperreal._aux_Mathlib_Data_Real_Hyperreal___unexpand_Hyperreal_omega_1
code: @[inherit_doc] scoped notation "ω" => Hyperreal.omega
goal: Lean.PrettyPrinter.Unexpander

full_name: Hyperreal.inv_omega
code: @[simp]
theorem inv_omega : ω⁻¹ = ε 
goal: Hyperreal.omega⁻¹ = Hyperreal.epsilon

full_name: Hyperreal.inv_epsilon
code: @[simp]
theorem inv_epsilon : ε⁻¹ = ω 
goal: Hyperreal.epsilon⁻¹ = Hyperreal.omega

full_name: Hyperreal.omega_pos
code: theorem omega_pos : 0 < ω 
goal: 0 < Hyperreal.omega

full_name: Hyperreal.epsilon_pos
code: theorem epsilon_pos : 0 < ε 
goal: 0 < Hyperreal.epsilon

full_name: Hyperreal.epsilon_ne_zero
code: theorem epsilon_ne_zero : ε ≠ 0 
goal: Hyperreal.epsilon ≠ 0

full_name: Hyperreal.omega_ne_zero
code: theorem omega_ne_zero : ω ≠ 0 
goal: Hyperreal.omega ≠ 0

full_name: Hyperreal.epsilon_mul_omega
code: theorem epsilon_mul_omega : ε * ω = 1 
goal: Hyperreal.epsilon * Hyperreal.omega = 1

full_name: Hyperreal.lt_of_tendsto_zero_of_pos
code: theorem lt_of_tendsto_zero_of_pos {f : ℕ → ℝ} (hf : Tendsto f atTop (𝓝 0)) :
    ∀ {r : ℝ}, 0 < r → ofSeq f < (r : ℝ*) 
goal: 0 < r → Hyperreal.ofSeq f < ↑r

full_name: Hyperreal.neg_lt_of_tendsto_zero_of_pos
code: theorem neg_lt_of_tendsto_zero_of_pos {f : ℕ → ℝ} (hf : Tendsto f atTop (𝓝 0)) :
    ∀ {r : ℝ}, 0 < r → (-r : ℝ*) < ofSeq f 
goal: 0 < r → -↑r < Hyperreal.ofSeq f

full_name: Hyperreal.gt_of_tendsto_zero_of_neg
code: theorem gt_of_tendsto_zero_of_neg {f : ℕ → ℝ} (hf : Tendsto f atTop (𝓝 0)) :
    ∀ {r : ℝ}, r < 0 → (r : ℝ*) < ofSeq f 
goal: r < 0 → ↑r < Hyperreal.ofSeq f

full_name: Hyperreal.epsilon_lt_pos
code: theorem epsilon_lt_pos (x : ℝ) : 0 < x → ε < x 
goal: 0 < x → Hyperreal.epsilon < ↑x

full_name: Hyperreal.IsSt
code: /-- Standard part predicate -/
def IsSt (x : ℝ*) (r : ℝ) 
goal: Prop

full_name: Hyperreal.st
code: /-- Standard part function: like a "round" to ℝ instead of ℤ -/
noncomputable def st : ℝ* → ℝ 
goal: ℝ* → ℝ

full_name: Hyperreal.Infinitesimal
code: /-- A hyperreal number is infinitesimal if its standard part is 0 -/
def Infinitesimal (x : ℝ*) 
goal: Prop

full_name: Hyperreal.InfinitePos
code: /-- A hyperreal number is positive infinite if it is larger than all real numbers -/
def InfinitePos (x : ℝ*) 
goal: Prop

full_name: Hyperreal.InfiniteNeg
code: /-- A hyperreal number is negative infinite if it is smaller than all real numbers -/
def InfiniteNeg (x : ℝ*) 
goal: Prop

full_name: Hyperreal.Infinite
code: /-- A hyperreal number is infinite if it is infinite positive or infinite negative -/
def Infinite (x : ℝ*) 
goal: Prop

full_name: Hyperreal.isSt_ofSeq_iff_tendsto
code: theorem isSt_ofSeq_iff_tendsto {f : ℕ → ℝ} {r : ℝ} :
    IsSt (ofSeq f) r ↔ Tendsto f (hyperfilter ℕ) (𝓝 r) 
goal: (Hyperreal.ofSeq f).IsSt r ↔ Filter.Tendsto f (↑(Filter.hyperfilter ℕ)) (𝓝 r)

full_name: Hyperreal.isSt_iff_tendsto
code: theorem isSt_iff_tendsto {x : ℝ*} {r : ℝ} : IsSt x r ↔ x.Tendsto (𝓝 r) 
goal: x.IsSt r ↔ Filter.Germ.Tendsto x (𝓝 r)

full_name: Hyperreal.isSt_of_tendsto
code: theorem isSt_of_tendsto {f : ℕ → ℝ} {r : ℝ} (hf : Tendsto f atTop (𝓝 r)) : IsSt (ofSeq f) r 
goal: (Hyperreal.ofSeq f).IsSt r

full_name: Hyperreal.IsSt.lt
code: protected theorem IsSt.lt {x y : ℝ*} {r s : ℝ} (hxr : IsSt x r) (hys : IsSt y s) (hrs : r < s) :
    x < y 
goal: x < y

full_name: Hyperreal.IsSt.unique
code: theorem IsSt.unique {x : ℝ*} {r s : ℝ} (hr : IsSt x r) (hs : IsSt x s) : r = s 
goal: r = s

full_name: Hyperreal.IsSt.st_eq
code: theorem IsSt.st_eq {x : ℝ*} {r : ℝ} (hxr : IsSt x r) : st x = r 
goal: x.st = r

full_name: Hyperreal.IsSt.not_infinite
code: theorem IsSt.not_infinite {x : ℝ*} {r : ℝ} (h : IsSt x r) : ¬Infinite x 
goal: ¬x.Infinite

full_name: Hyperreal.not_infinite_of_exists_st
code: theorem not_infinite_of_exists_st {x : ℝ*} : (∃ r : ℝ, IsSt x r) → ¬Infinite x 
goal: (∃ r, x.IsSt r) → ¬x.Infinite

full_name: Hyperreal.Infinite.st_eq
code: theorem Infinite.st_eq {x : ℝ*} (hi : Infinite x) : st x = 0 
goal: x.st = 0

full_name: Hyperreal.isSt_sSup
code: theorem isSt_sSup {x : ℝ*} (hni : ¬Infinite x) : IsSt x (sSup { y : ℝ | (y : ℝ*) < x }) 
goal: x.IsSt (sSup {y | ↑y < x})

full_name: Hyperreal.exists_st_of_not_infinite
code: theorem exists_st_of_not_infinite {x : ℝ*} (hni : ¬Infinite x) : ∃ r : ℝ, IsSt x r 
goal: ∃ r, x.IsSt r

full_name: Hyperreal.st_eq_sSup
code: theorem st_eq_sSup {x : ℝ*} : st x = sSup { y : ℝ | (y : ℝ*) < x } 
goal: x.st = sSup {y | ↑y < x}

full_name: Hyperreal.exists_st_iff_not_infinite
code: theorem exists_st_iff_not_infinite {x : ℝ*} : (∃ r : ℝ, IsSt x r) ↔ ¬Infinite x 
goal: (∃ r, x.IsSt r) ↔ ¬x.Infinite

full_name: Hyperreal.infinite_iff_not_exists_st
code: theorem infinite_iff_not_exists_st {x : ℝ*} : Infinite x ↔ ¬∃ r : ℝ, IsSt x r 
goal: x.Infinite ↔ ¬∃ r, x.IsSt r

full_name: Hyperreal.IsSt.isSt_st
code: theorem IsSt.isSt_st {x : ℝ*} {r : ℝ} (hxr : IsSt x r) : IsSt x (st x) 
goal: x.IsSt x.st

full_name: Hyperreal.isSt_st_of_exists_st
code: theorem isSt_st_of_exists_st {x : ℝ*} (hx : ∃ r : ℝ, IsSt x r) : IsSt x (st x) 
goal: x.IsSt x.st

full_name: Hyperreal.isSt_st'
code: theorem isSt_st' {x : ℝ*} (hx : ¬Infinite x) : IsSt x (st x) 
goal: x.IsSt x.st

full_name: Hyperreal.isSt_st
code: theorem isSt_st {x : ℝ*} (hx : st x ≠ 0) : IsSt x (st x) 
goal: x.IsSt x.st

full_name: Hyperreal.isSt_refl_real
code: theorem isSt_refl_real (r : ℝ) : IsSt r r 
goal: (↑r).IsSt r

full_name: Hyperreal.st_id_real
code: theorem st_id_real (r : ℝ) : st r = r 
goal: (↑r).st = r

full_name: Hyperreal.eq_of_isSt_real
code: theorem eq_of_isSt_real {r s : ℝ} : IsSt r s → r = s 
goal: (↑r).IsSt s → r = s

full_name: Hyperreal.isSt_real_iff_eq
code: theorem isSt_real_iff_eq {r s : ℝ} : IsSt r s ↔ r = s 
goal: (↑r).IsSt s ↔ r = s

full_name: Hyperreal.isSt_symm_real
code: theorem isSt_symm_real {r s : ℝ} : IsSt r s ↔ IsSt s r 
goal: (↑r).IsSt s ↔ (↑s).IsSt r

full_name: Hyperreal.isSt_trans_real
code: theorem isSt_trans_real {r s t : ℝ} : IsSt r s → IsSt s t → IsSt r t 
goal: (↑r).IsSt s → (↑s).IsSt t → (↑r).IsSt t

full_name: Hyperreal.isSt_inj_real
code: theorem isSt_inj_real {r₁ r₂ s : ℝ} (h1 : IsSt r₁ s) (h2 : IsSt r₂ s) : r₁ = r₂ 
goal: r₁ = r₂

full_name: Hyperreal.isSt_iff_abs_sub_lt_delta
code: theorem isSt_iff_abs_sub_lt_delta {x : ℝ*} {r : ℝ} : IsSt x r ↔ ∀ δ : ℝ, 0 < δ → |x - ↑r| < δ 
goal: x.IsSt r ↔ ∀ (δ : ℝ), 0 < δ → |x - ↑r| < ↑δ

full_name: Hyperreal.IsSt.map
code: theorem IsSt.map {x : ℝ*} {r : ℝ} (hxr : IsSt x r) {f : ℝ → ℝ} (hf : ContinuousAt f r) :
    IsSt (x.map f) (f r) 
goal: Hyperreal.IsSt (Filter.Germ.map f x) (f r)

full_name: Hyperreal.IsSt.map₂
code: theorem IsSt.map₂ {x y : ℝ*} {r s : ℝ} (hxr : IsSt x r) (hys : IsSt y s) {f : ℝ → ℝ → ℝ}
    (hf : ContinuousAt (Function.uncurry f) (r, s)) : IsSt (x.map₂ f y) (f r s) 
goal: Hyperreal.IsSt (Filter.Germ.map₂ f x y) (f r s)

full_name: Hyperreal.IsSt.add
code: theorem IsSt.add {x y : ℝ*} {r s : ℝ} (hxr : IsSt x r) (hys : IsSt y s) :
    IsSt (x + y) (r + s) 
goal: (x + y).IsSt (r + s)

full_name: Hyperreal.IsSt.neg
code: theorem IsSt.neg {x : ℝ*} {r : ℝ} (hxr : IsSt x r) : IsSt (-x) (-r) 
goal: (-x).IsSt (-r)

full_name: Hyperreal.IsSt.sub
code: theorem IsSt.sub {x y : ℝ*} {r s : ℝ} (hxr : IsSt x r) (hys : IsSt y s) : IsSt (x - y) (r - s) 
goal: (x - y).IsSt (r - s)

full_name: Hyperreal.IsSt.le
code: theorem IsSt.le {x y : ℝ*} {r s : ℝ} (hrx : IsSt x r) (hsy : IsSt y s) (hxy : x ≤ y) : r ≤ s 
goal: r ≤ s

full_name: Hyperreal.st_le_of_le
code: theorem st_le_of_le {x y : ℝ*} (hix : ¬Infinite x) (hiy : ¬Infinite y) : x ≤ y → st x ≤ st y 
goal: x ≤ y → x.st ≤ y.st

full_name: Hyperreal.lt_of_st_lt
code: theorem lt_of_st_lt {x y : ℝ*} (hix : ¬Infinite x) (hiy : ¬Infinite y) : st x < st y → x < y 
goal: x.st < y.st → x < y

full_name: Hyperreal.infinitePos_def
code: theorem infinitePos_def {x : ℝ*} : InfinitePos x ↔ ∀ r : ℝ, ↑r < x 
goal: x.InfinitePos ↔ ∀ (r : ℝ), ↑r < x

full_name: Hyperreal.infiniteNeg_def
code: theorem infiniteNeg_def {x : ℝ*} : InfiniteNeg x ↔ ∀ r : ℝ, x < r 
goal: x.InfiniteNeg ↔ ∀ (r : ℝ), x < ↑r

full_name: Hyperreal.InfinitePos.pos
code: theorem InfinitePos.pos {x : ℝ*} (hip : InfinitePos x) : 0 < x 
goal: 0 < x

full_name: Hyperreal.InfiniteNeg.lt_zero
code: theorem InfiniteNeg.lt_zero {x : ℝ*} : InfiniteNeg x → x < 0 
goal: x.InfiniteNeg → x < 0

full_name: Hyperreal.Infinite.ne_zero
code: theorem Infinite.ne_zero {x : ℝ*} (hI : Infinite x) : x ≠ 0 
goal: x ≠ 0

full_name: Hyperreal.not_infinite_zero
code: theorem not_infinite_zero : ¬Infinite 0 
goal: ¬Hyperreal.Infinite 0

full_name: Hyperreal.InfiniteNeg.not_infinitePos
code: theorem InfiniteNeg.not_infinitePos {x : ℝ*} : InfiniteNeg x → ¬InfinitePos x 
goal: x.InfiniteNeg → ¬x.InfinitePos

full_name: Hyperreal.InfinitePos.not_infiniteNeg
code: theorem InfinitePos.not_infiniteNeg {x : ℝ*} (hp : InfinitePos x) : ¬InfiniteNeg x 
goal: ¬x.InfiniteNeg

full_name: Hyperreal.InfinitePos.neg
code: theorem InfinitePos.neg {x : ℝ*} : InfinitePos x → InfiniteNeg (-x) 
goal: x.InfinitePos → (-x).InfiniteNeg

full_name: Hyperreal.InfiniteNeg.neg
code: theorem InfiniteNeg.neg {x : ℝ*} : InfiniteNeg x → InfinitePos (-x) 
goal: x.InfiniteNeg → (-x).InfinitePos

full_name: Hyperreal.infiniteNeg_neg
code: @[simp] theorem infiniteNeg_neg {x : ℝ*} : InfiniteNeg (-x) ↔ InfinitePos x 
goal: (-x).InfiniteNeg ↔ x.InfinitePos

full_name: Hyperreal.infinitePos_neg
code: @[simp] theorem infinitePos_neg {x : ℝ*} : InfinitePos (-x) ↔ InfiniteNeg x 
goal: (-x).InfinitePos ↔ x.InfiniteNeg

full_name: Hyperreal.infinite_neg
code: @[simp] theorem infinite_neg {x : ℝ*} : Infinite (-x) ↔ Infinite x 
goal: (-x).Infinite ↔ x.Infinite

full_name: Hyperreal.Infinitesimal.not_infinite
code: nonrec theorem Infinitesimal.not_infinite {x : ℝ*} (h : Infinitesimal x) : ¬Infinite x 
goal: ¬x.Infinite

full_name: Hyperreal.Infinite.not_infinitesimal
code: theorem Infinite.not_infinitesimal {x : ℝ*} (h : Infinite x) : ¬Infinitesimal x 
goal: ¬x.Infinitesimal

full_name: Hyperreal.InfinitePos.not_infinitesimal
code: theorem InfinitePos.not_infinitesimal {x : ℝ*} (h : InfinitePos x) : ¬Infinitesimal x 
goal: ¬x.Infinitesimal

full_name: Hyperreal.InfiniteNeg.not_infinitesimal
code: theorem InfiniteNeg.not_infinitesimal {x : ℝ*} (h : InfiniteNeg x) : ¬Infinitesimal x 
goal: ¬x.Infinitesimal

full_name: Hyperreal.infinitePos_iff_infinite_and_pos
code: theorem infinitePos_iff_infinite_and_pos {x : ℝ*} : InfinitePos x ↔ Infinite x ∧ 0 < x 
goal: x.InfinitePos ↔ x.Infinite ∧ 0 < x

full_name: Hyperreal.infiniteNeg_iff_infinite_and_neg
code: theorem infiniteNeg_iff_infinite_and_neg {x : ℝ*} : InfiniteNeg x ↔ Infinite x ∧ x < 0 
goal: x.InfiniteNeg ↔ x.Infinite ∧ x < 0

full_name: Hyperreal.infinitePos_iff_infinite_of_nonneg
code: theorem infinitePos_iff_infinite_of_nonneg {x : ℝ*} (hp : 0 ≤ x) : InfinitePos x ↔ Infinite x 
goal: x.InfinitePos ↔ x.Infinite

full_name: Hyperreal.infinitePos_iff_infinite_of_pos
code: theorem infinitePos_iff_infinite_of_pos {x : ℝ*} (hp : 0 < x) : InfinitePos x ↔ Infinite x 
goal: x.InfinitePos ↔ x.Infinite

full_name: Hyperreal.infiniteNeg_iff_infinite_of_neg
code: theorem infiniteNeg_iff_infinite_of_neg {x : ℝ*} (hn : x < 0) : InfiniteNeg x ↔ Infinite x 
goal: x.InfiniteNeg ↔ x.Infinite

full_name: Hyperreal.infinitePos_abs_iff_infinite_abs
code: theorem infinitePos_abs_iff_infinite_abs {x : ℝ*} : InfinitePos |x| ↔ Infinite |x| 
goal: |x|.InfinitePos ↔ |x|.Infinite

full_name: Hyperreal.infinite_abs_iff
code: @[simp] theorem infinite_abs_iff {x : ℝ*} : Infinite |x| ↔ Infinite x 
goal: |x|.Infinite ↔ x.Infinite

full_name: Hyperreal.infinitePos_abs_iff_infinite
code: @[simp] theorem infinitePos_abs_iff_infinite {x : ℝ*} : InfinitePos |x| ↔ Infinite x 
goal: |x|.InfinitePos ↔ x.Infinite

full_name: Hyperreal.infinite_iff_abs_lt_abs
code: theorem infinite_iff_abs_lt_abs {x : ℝ*} : Infinite x ↔ ∀ r : ℝ, (|r| : ℝ*) < |x| 
goal: x.Infinite ↔ ∀ (r : ℝ), |↑r| < |x|

full_name: Hyperreal.infinitePos_add_not_infiniteNeg
code: theorem infinitePos_add_not_infiniteNeg {x y : ℝ*} :
    InfinitePos x → ¬InfiniteNeg y → InfinitePos (x + y) 
goal: x.InfinitePos → ¬y.InfiniteNeg → (x + y).InfinitePos

full_name: Hyperreal.not_infiniteNeg_add_infinitePos
code: theorem not_infiniteNeg_add_infinitePos {x y : ℝ*} :
    ¬InfiniteNeg x → InfinitePos y → InfinitePos (x + y) 
goal: ¬x.InfiniteNeg → y.InfinitePos → (x + y).InfinitePos

full_name: Hyperreal.infiniteNeg_add_not_infinitePos
code: theorem infiniteNeg_add_not_infinitePos {x y : ℝ*} :
    InfiniteNeg x → ¬InfinitePos y → InfiniteNeg (x + y) 
goal: x.InfiniteNeg → ¬y.InfinitePos → (x + y).InfiniteNeg

full_name: Hyperreal.not_infinitePos_add_infiniteNeg
code: theorem not_infinitePos_add_infiniteNeg {x y : ℝ*} :
    ¬InfinitePos x → InfiniteNeg y → InfiniteNeg (x + y) 
goal: ¬x.InfinitePos → y.InfiniteNeg → (x + y).InfiniteNeg

full_name: Hyperreal.infinitePos_add_infinitePos
code: theorem infinitePos_add_infinitePos {x y : ℝ*} :
    InfinitePos x → InfinitePos y → InfinitePos (x + y) 
goal: x.InfinitePos → y.InfinitePos → (x + y).InfinitePos

full_name: Hyperreal.infiniteNeg_add_infiniteNeg
code: theorem infiniteNeg_add_infiniteNeg {x y : ℝ*} :
    InfiniteNeg x → InfiniteNeg y → InfiniteNeg (x + y) 
goal: x.InfiniteNeg → y.InfiniteNeg → (x + y).InfiniteNeg

full_name: Hyperreal.infinitePos_add_not_infinite
code: theorem infinitePos_add_not_infinite {x y : ℝ*} :
    InfinitePos x → ¬Infinite y → InfinitePos (x + y) 
goal: x.InfinitePos → ¬y.Infinite → (x + y).InfinitePos

full_name: Hyperreal.infiniteNeg_add_not_infinite
code: theorem infiniteNeg_add_not_infinite {x y : ℝ*} :
    InfiniteNeg x → ¬Infinite y → InfiniteNeg (x + y) 
goal: x.InfiniteNeg → ¬y.Infinite → (x + y).InfiniteNeg

full_name: Hyperreal.infinitePos_of_tendsto_top
code: theorem infinitePos_of_tendsto_top {f : ℕ → ℝ} (hf : Tendsto f atTop atTop) :
    InfinitePos (ofSeq f) 
goal: (Hyperreal.ofSeq f).InfinitePos

full_name: Hyperreal.infiniteNeg_of_tendsto_bot
code: theorem infiniteNeg_of_tendsto_bot {f : ℕ → ℝ} (hf : Tendsto f atTop atBot) :
    InfiniteNeg (ofSeq f) 
goal: (Hyperreal.ofSeq f).InfiniteNeg

full_name: Hyperreal.not_infinite_neg
code: theorem not_infinite_neg {x : ℝ*} : ¬Infinite x → ¬Infinite (-x) 
goal: ¬x.Infinite → ¬(-x).Infinite

full_name: Hyperreal.not_infinite_add
code: theorem not_infinite_add {x y : ℝ*} (hx : ¬Infinite x) (hy : ¬Infinite y) : ¬Infinite (x + y) 
goal: ¬(x + y).Infinite

full_name: Hyperreal.not_infinite_iff_exist_lt_gt
code: theorem not_infinite_iff_exist_lt_gt {x : ℝ*} : ¬Infinite x ↔ ∃ r s : ℝ, (r : ℝ*) < x ∧ x < s 
goal: ¬x.Infinite ↔ ∃ r s, ↑r < x ∧ x < ↑s

full_name: Hyperreal.not_infinite_real
code: theorem not_infinite_real (r : ℝ) : ¬Infinite r 
goal: ¬(↑r).Infinite

full_name: Hyperreal.Infinite.ne_real
code: theorem Infinite.ne_real {x : ℝ*} : Infinite x → ∀ r : ℝ, x ≠ r 
goal: x.Infinite → ∀ (r : ℝ), x ≠ ↑r

full_name: Hyperreal.IsSt.mul
code: theorem IsSt.mul {x y : ℝ*} {r s : ℝ} (hxr : IsSt x r) (hys : IsSt y s) : IsSt (x * y) (r * s) 
goal: (x * y).IsSt (r * s)

full_name: Hyperreal.not_infinite_mul
code: theorem not_infinite_mul {x y : ℝ*} (hx : ¬Infinite x) (hy : ¬Infinite y) : ¬Infinite (x * y) 
goal: ¬(x * y).Infinite

full_name: Hyperreal.st_add
code: theorem st_add {x y : ℝ*} (hx : ¬Infinite x) (hy : ¬Infinite y) : st (x + y) = st x + st y 
goal: (x + y).st = x.st + y.st

full_name: Hyperreal.st_neg
code: theorem st_neg (x : ℝ*) : st (-x) = -st x 
goal: (-x).st = -x.st

full_name: Hyperreal.st_mul
code: theorem st_mul {x y : ℝ*} (hx : ¬Infinite x) (hy : ¬Infinite y) : st (x * y) = st x * st y 
goal: (x * y).st = x.st * y.st

full_name: Hyperreal.infinitesimal_def
code: theorem infinitesimal_def {x : ℝ*} : Infinitesimal x ↔ ∀ r : ℝ, 0 < r → -(r : ℝ*) < x ∧ x < r 
goal: x.Infinitesimal ↔ ∀ (r : ℝ), 0 < r → -↑r < x ∧ x < ↑r

full_name: Hyperreal.lt_of_pos_of_infinitesimal
code: theorem lt_of_pos_of_infinitesimal {x : ℝ*} : Infinitesimal x → ∀ r : ℝ, 0 < r → x < r 
goal: x.Infinitesimal → ∀ (r : ℝ), 0 < r → x < ↑r

full_name: Hyperreal.lt_neg_of_pos_of_infinitesimal
code: theorem lt_neg_of_pos_of_infinitesimal {x : ℝ*} : Infinitesimal x → ∀ r : ℝ, 0 < r → -↑r < x 
goal: x.Infinitesimal → ∀ (r : ℝ), 0 < r → -↑r < x

full_name: Hyperreal.gt_of_neg_of_infinitesimal
code: theorem gt_of_neg_of_infinitesimal {x : ℝ*} (hi : Infinitesimal x) (r : ℝ) (hr : r < 0) : ↑r < x 
goal: ↑r < x

full_name: Hyperreal.abs_lt_real_iff_infinitesimal
code: theorem abs_lt_real_iff_infinitesimal {x : ℝ*} : Infinitesimal x ↔ ∀ r : ℝ, r ≠ 0 → |x| < |↑r| 
goal: x.Infinitesimal ↔ ∀ (r : ℝ), r ≠ 0 → |x| < |↑r|

full_name: Hyperreal.infinitesimal_zero
code: theorem infinitesimal_zero : Infinitesimal 0 
goal: Hyperreal.Infinitesimal 0

full_name: Hyperreal.Infinitesimal.eq_zero
code: theorem Infinitesimal.eq_zero {r : ℝ} : Infinitesimal r → r = 0 
goal: (↑r).Infinitesimal → r = 0

full_name: Hyperreal.infinitesimal_real_iff
code: @[simp] theorem infinitesimal_real_iff {r : ℝ} : Infinitesimal r ↔ r = 0 
goal: (↑r).Infinitesimal ↔ r = 0

full_name: Hyperreal.Infinitesimal.add
code: nonrec theorem Infinitesimal.add {x y : ℝ*} (hx : Infinitesimal x) (hy : Infinitesimal y) :
    Infinitesimal (x + y) 
goal: (x + y).Infinitesimal

full_name: Hyperreal.Infinitesimal.neg
code: nonrec theorem Infinitesimal.neg {x : ℝ*} (hx : Infinitesimal x) : Infinitesimal (-x) 
goal: (-x).Infinitesimal

full_name: Hyperreal.infinitesimal_neg
code: @[simp] theorem infinitesimal_neg {x : ℝ*} : Infinitesimal (-x) ↔ Infinitesimal x 
goal: (-x).Infinitesimal ↔ x.Infinitesimal

full_name: Hyperreal.Infinitesimal.mul
code: nonrec theorem Infinitesimal.mul {x y : ℝ*} (hx : Infinitesimal x) (hy : Infinitesimal y) :
    Infinitesimal (x * y) 
goal: (x * y).Infinitesimal

full_name: Hyperreal.infinitesimal_of_tendsto_zero
code: theorem infinitesimal_of_tendsto_zero {f : ℕ → ℝ} (h : Tendsto f atTop (𝓝 0)) :
    Infinitesimal (ofSeq f) 
goal: (Hyperreal.ofSeq f).Infinitesimal

full_name: Hyperreal.infinitesimal_epsilon
code: theorem infinitesimal_epsilon : Infinitesimal ε 
goal: Hyperreal.epsilon.Infinitesimal

full_name: Hyperreal.not_real_of_infinitesimal_ne_zero
code: theorem not_real_of_infinitesimal_ne_zero (x : ℝ*) : Infinitesimal x → x ≠ 0 → ∀ r : ℝ, x ≠ r 
goal: x.Infinitesimal → x ≠ 0 → ∀ (r : ℝ), x ≠ ↑r

full_name: Hyperreal.IsSt.infinitesimal_sub
code: theorem IsSt.infinitesimal_sub {x : ℝ*} {r : ℝ} (hxr : IsSt x r) : Infinitesimal (x - ↑r) 
goal: (x - ↑r).Infinitesimal

full_name: Hyperreal.infinitesimal_sub_st
code: theorem infinitesimal_sub_st {x : ℝ*} (hx : ¬Infinite x) : Infinitesimal (x - ↑(st x)) 
goal: (x - ↑x.st).Infinitesimal

full_name: Hyperreal.infinitePos_iff_infinitesimal_inv_pos
code: theorem infinitePos_iff_infinitesimal_inv_pos {x : ℝ*} :
    InfinitePos x ↔ Infinitesimal x⁻¹ ∧ 0 < x⁻¹ 
goal: x.InfinitePos ↔ x⁻¹.Infinitesimal ∧ 0 < x⁻¹

full_name: Hyperreal.infiniteNeg_iff_infinitesimal_inv_neg
code: theorem infiniteNeg_iff_infinitesimal_inv_neg {x : ℝ*} :
    InfiniteNeg x ↔ Infinitesimal x⁻¹ ∧ x⁻¹ < 0 
goal: x.InfiniteNeg ↔ x⁻¹.Infinitesimal ∧ x⁻¹ < 0

full_name: Hyperreal.infinitesimal_inv_of_infinite
code: theorem infinitesimal_inv_of_infinite {x : ℝ*} : Infinite x → Infinitesimal x⁻¹ 
goal: x.Infinite → x⁻¹.Infinitesimal

full_name: Hyperreal.infinite_of_infinitesimal_inv
code: theorem infinite_of_infinitesimal_inv {x : ℝ*} (h0 : x ≠ 0) (hi : Infinitesimal x⁻¹) :
    Infinite x 
goal: x.Infinite

full_name: Hyperreal.infinite_iff_infinitesimal_inv
code: theorem infinite_iff_infinitesimal_inv {x : ℝ*} (h0 : x ≠ 0) : Infinite x ↔ Infinitesimal x⁻¹ 
goal: x.Infinite ↔ x⁻¹.Infinitesimal

full_name: Hyperreal.infinitesimal_pos_iff_infinitePos_inv
code: theorem infinitesimal_pos_iff_infinitePos_inv {x : ℝ*} :
    InfinitePos x⁻¹ ↔ Infinitesimal x ∧ 0 < x 
goal: x⁻¹.InfinitePos ↔ x.Infinitesimal ∧ 0 < x

full_name: Hyperreal.infinitesimal_neg_iff_infiniteNeg_inv
code: theorem infinitesimal_neg_iff_infiniteNeg_inv {x : ℝ*} :
    InfiniteNeg x⁻¹ ↔ Infinitesimal x ∧ x < 0 
goal: x⁻¹.InfiniteNeg ↔ x.Infinitesimal ∧ x < 0

full_name: Hyperreal.infinitesimal_iff_infinite_inv
code: theorem infinitesimal_iff_infinite_inv {x : ℝ*} (h : x ≠ 0) : Infinitesimal x ↔ Infinite x⁻¹ 
goal: x.Infinitesimal ↔ x⁻¹.Infinite

full_name: Hyperreal.IsSt.inv
code: theorem IsSt.inv {x : ℝ*} {r : ℝ} (hi : ¬Infinitesimal x) (hr : IsSt x r) : IsSt x⁻¹ r⁻¹ 
goal: x⁻¹.IsSt r⁻¹

full_name: Hyperreal.st_inv
code: theorem st_inv (x : ℝ*) : st x⁻¹ = (st x)⁻¹ 
goal: x⁻¹.st = x.st⁻¹

full_name: Hyperreal.infinitePos_omega
code: theorem infinitePos_omega : InfinitePos ω 
goal: Hyperreal.omega.InfinitePos

full_name: Hyperreal.infinite_omega
code: theorem infinite_omega : Infinite ω 
goal: Hyperreal.omega.Infinite

full_name: Hyperreal.infinitePos_mul_of_infinitePos_not_infinitesimal_pos
code: theorem infinitePos_mul_of_infinitePos_not_infinitesimal_pos {x y : ℝ*} :
    InfinitePos x → ¬Infinitesimal y → 0 < y → InfinitePos (x * y) 
goal: x.InfinitePos → ¬y.Infinitesimal → 0 < y → (x * y).InfinitePos

full_name: Hyperreal.infinitePos_mul_of_not_infinitesimal_pos_infinitePos
code: theorem infinitePos_mul_of_not_infinitesimal_pos_infinitePos {x y : ℝ*} :
    ¬Infinitesimal x → 0 < x → InfinitePos y → InfinitePos (x * y) 
goal: ¬x.Infinitesimal → 0 < x → y.InfinitePos → (x * y).InfinitePos

full_name: Hyperreal.infinitePos_mul_of_infiniteNeg_not_infinitesimal_neg
code: theorem infinitePos_mul_of_infiniteNeg_not_infinitesimal_neg {x y : ℝ*} :
    InfiniteNeg x → ¬Infinitesimal y → y < 0 → InfinitePos (x * y) 
goal: x.InfiniteNeg → ¬y.Infinitesimal → y < 0 → (x * y).InfinitePos

full_name: Hyperreal.infinitePos_mul_of_not_infinitesimal_neg_infiniteNeg
code: theorem infinitePos_mul_of_not_infinitesimal_neg_infiniteNeg {x y : ℝ*} :
    ¬Infinitesimal x → x < 0 → InfiniteNeg y → InfinitePos (x * y) 
goal: ¬x.Infinitesimal → x < 0 → y.InfiniteNeg → (x * y).InfinitePos

full_name: Hyperreal.infiniteNeg_mul_of_infinitePos_not_infinitesimal_neg
code: theorem infiniteNeg_mul_of_infinitePos_not_infinitesimal_neg {x y : ℝ*} :
    InfinitePos x → ¬Infinitesimal y → y < 0 → InfiniteNeg (x * y) 
goal: x.InfinitePos → ¬y.Infinitesimal → y < 0 → (x * y).InfiniteNeg

full_name: Hyperreal.infiniteNeg_mul_of_not_infinitesimal_neg_infinitePos
code: theorem infiniteNeg_mul_of_not_infinitesimal_neg_infinitePos {x y : ℝ*} :
    ¬Infinitesimal x → x < 0 → InfinitePos y → InfiniteNeg (x * y) 
goal: ¬x.Infinitesimal → x < 0 → y.InfinitePos → (x * y).InfiniteNeg

full_name: Hyperreal.infiniteNeg_mul_of_infiniteNeg_not_infinitesimal_pos
code: theorem infiniteNeg_mul_of_infiniteNeg_not_infinitesimal_pos {x y : ℝ*} :
    InfiniteNeg x → ¬Infinitesimal y → 0 < y → InfiniteNeg (x * y) 
goal: x.InfiniteNeg → ¬y.Infinitesimal → 0 < y → (x * y).InfiniteNeg

full_name: Hyperreal.infiniteNeg_mul_of_not_infinitesimal_pos_infiniteNeg
code: theorem infiniteNeg_mul_of_not_infinitesimal_pos_infiniteNeg {x y : ℝ*} :
    ¬Infinitesimal x → 0 < x → InfiniteNeg y → InfiniteNeg (x * y) 
goal: ¬x.Infinitesimal → 0 < x → y.InfiniteNeg → (x * y).InfiniteNeg

full_name: Hyperreal.infinitePos_mul_infinitePos
code: theorem infinitePos_mul_infinitePos {x y : ℝ*} :
    InfinitePos x → InfinitePos y → InfinitePos (x * y) 
goal: x.InfinitePos → y.InfinitePos → (x * y).InfinitePos

full_name: Hyperreal.infiniteNeg_mul_infiniteNeg
code: theorem infiniteNeg_mul_infiniteNeg {x y : ℝ*} :
    InfiniteNeg x → InfiniteNeg y → InfinitePos (x * y) 
goal: x.InfiniteNeg → y.InfiniteNeg → (x * y).InfinitePos

full_name: Hyperreal.infinitePos_mul_infiniteNeg
code: theorem infinitePos_mul_infiniteNeg {x y : ℝ*} :
    InfinitePos x → InfiniteNeg y → InfiniteNeg (x * y) 
goal: x.InfinitePos → y.InfiniteNeg → (x * y).InfiniteNeg

full_name: Hyperreal.infiniteNeg_mul_infinitePos
code: theorem infiniteNeg_mul_infinitePos {x y : ℝ*} :
    InfiniteNeg x → InfinitePos y → InfiniteNeg (x * y) 
goal: x.InfiniteNeg → y.InfinitePos → (x * y).InfiniteNeg

full_name: Hyperreal.infinite_mul_of_infinite_not_infinitesimal
code: theorem infinite_mul_of_infinite_not_infinitesimal {x y : ℝ*} :
    Infinite x → ¬Infinitesimal y → Infinite (x * y) 
goal: x.Infinite → ¬y.Infinitesimal → (x * y).Infinite

full_name: Hyperreal.infinite_mul_of_not_infinitesimal_infinite
code: theorem infinite_mul_of_not_infinitesimal_infinite {x y : ℝ*} :
    ¬Infinitesimal x → Infinite y → Infinite (x * y) 
goal: ¬x.Infinitesimal → y.Infinite → (x * y).Infinite

full_name: Hyperreal.Infinite.mul
code: theorem Infinite.mul {x y : ℝ*} : Infinite x → Infinite y → Infinite (x * y) 
goal: x.Infinite → y.Infinite → (x * y).Infinite