File: Mathlib/Data/Real/EReal.lean

full_name: EReal
code: /-- ereal : The type `[-∞, ∞]` -/
def EReal 
goal: Type

full_name: instZeroLEOneClassEReal
code: instance : ZeroLEOneClass EReal 
goal: ZeroLEOneClass EReal

full_name: instSupSetEReal
code: instance : SupSet EReal 
goal: SupSet EReal

full_name: instInfSetEReal
code: instance : InfSet EReal 
goal: InfSet EReal

full_name: instCompleteLinearOrderEReal
code: instance : CompleteLinearOrder EReal 
goal: CompleteLinearOrder EReal

full_name: instLinearOrderedAddCommMonoidEReal
code: instance : LinearOrderedAddCommMonoid EReal 
goal: LinearOrderedAddCommMonoid EReal

full_name: instAddCommMonoidWithOneEReal
code: instance : AddCommMonoidWithOne EReal 
goal: AddCommMonoidWithOne EReal

full_name: instDenselyOrderedEReal
code: instance : DenselyOrdered EReal 
goal: DenselyOrdered EReal

full_name: Real.toEReal
code: /-- The canonical inclusion from reals to ereals. Registered as a coercion. -/
@[coe] def Real.toEReal : ℝ → EReal 
goal: ℝ → EReal

full_name: EReal.decidableLT
code: instance decidableLT : DecidableRel ((· < ·) : EReal → EReal → Prop) 
goal: DecidableRel fun x x_1 => x < x_1

full_name: EReal.instTop
code: instance : Top EReal 
goal: Top EReal

full_name: EReal.instCoeReal
code: instance : Coe ℝ EReal 
goal: Coe ℝ EReal

full_name: EReal.coe_strictMono
code: theorem coe_strictMono : StrictMono Real.toEReal 
goal: StrictMono Real.toEReal

full_name: EReal.coe_injective
code: theorem coe_injective : Injective Real.toEReal 
goal: Function.Injective Real.toEReal

full_name: EReal.coe_le_coe_iff
code: @[simp, norm_cast]
protected theorem coe_le_coe_iff {x y : ℝ} : (x : EReal) ≤ (y : EReal) ↔ x ≤ y 
goal: ↑x ≤ ↑y ↔ x ≤ y

full_name: EReal.coe_lt_coe_iff
code: @[simp, norm_cast]
protected theorem coe_lt_coe_iff {x y : ℝ} : (x : EReal) < (y : EReal) ↔ x < y 
goal: ↑x < ↑y ↔ x < y

full_name: EReal.coe_eq_coe_iff
code: @[simp, norm_cast]
protected theorem coe_eq_coe_iff {x y : ℝ} : (x : EReal) = (y : EReal) ↔ x = y 
goal: ↑x = ↑y ↔ x = y

full_name: EReal.coe_ne_coe_iff
code: protected theorem coe_ne_coe_iff {x y : ℝ} : (x : EReal) ≠ (y : EReal) ↔ x ≠ y 
goal: ↑x ≠ ↑y ↔ x ≠ y

full_name: ENNReal.toEReal
code: /-- The canonical map from nonnegative extended reals to extended reals -/
@[coe] def _root_.ENNReal.toEReal : ℝ≥0∞ → EReal
  
goal: ℝ≥0∞ → EReal

full_name: EReal.hasCoeENNReal
code: instance hasCoeENNReal : Coe ℝ≥0∞ EReal 
goal: Coe ℝ≥0∞ EReal

full_name: EReal.instInhabited
code: instance : Inhabited EReal 
goal: Inhabited EReal

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

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

full_name: EReal.rec
code: /-- A recursor for `EReal` in terms of the coercion.

When working in term mode, note that pattern matching can be used directly. -/
@[elab_as_elim, induction_eliminator, cases_eliminator]
protected def rec {C : EReal → Sort*} (h_bot : C ⊥) (h_real : ∀ a : ℝ, C a) (h_top : C ⊤) :
    ∀ a : EReal, C a
  
goal: C a

full_name: EReal.mul
code: /-- The multiplication on `EReal`. Our definition satisfies `0 * x = x * 0 = 0` for any `x`, and
picks the only sensible value elsewhere. -/
protected def mul : EReal → EReal → EReal
  
goal: EReal → EReal → EReal

full_name: EReal.instMul
code: instance : Mul EReal 
goal: Mul EReal

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

full_name: EReal.induction₂
code: /-- Induct on two `EReal`s by performing case splits on the sign of one whenever the other is
infinite. -/
@[elab_as_elim]
theorem induction₂ {P : EReal → EReal → Prop} (top_top : P ⊤ ⊤) (top_pos : ∀ x : ℝ, 0 < x → P ⊤ x)
    (top_zero : P ⊤ 0) (top_neg : ∀ x : ℝ, x < 0 → P ⊤ x) (top_bot : P ⊤ ⊥)
    (pos_top : ∀ x : ℝ, 0 < x → P x ⊤) (pos_bot : ∀ x : ℝ, 0 < x → P x ⊥) (zero_top : P 0 ⊤)
    (coe_coe : ∀ x y : ℝ, P x y) (zero_bot : P 0 ⊥) (neg_top : ∀ x : ℝ, x < 0 → P x ⊤)
    (neg_bot : ∀ x : ℝ, x < 0 → P x ⊥) (bot_top : P ⊥ ⊤) (bot_pos : ∀ x : ℝ, 0 < x → P ⊥ x)
    (bot_zero : P ⊥ 0) (bot_neg : ∀ x : ℝ, x < 0 → P ⊥ x) (bot_bot : P ⊥ ⊥) : ∀ x y, P x y
  
goal: P x y

full_name: EReal.induction₂_symm
code: /-- Induct on two `EReal`s by performing case splits on the sign of one whenever the other is
infinite. This version eliminates some cases by assuming that the relation is symmetric. -/
@[elab_as_elim]
theorem induction₂_symm {P : EReal → EReal → Prop} (symm : ∀ {x y}, P x y → P y x)
    (top_top : P ⊤ ⊤) (top_pos : ∀ x : ℝ, 0 < x → P ⊤ x) (top_zero : P ⊤ 0)
    (top_neg : ∀ x : ℝ, x < 0 → P ⊤ x) (top_bot : P ⊤ ⊥) (pos_bot : ∀ x : ℝ, 0 < x → P x ⊥)
    (coe_coe : ∀ x y : ℝ, P x y) (zero_bot : P 0 ⊥) (neg_bot : ∀ x : ℝ, x < 0 → P x ⊥)
    (bot_bot : P ⊥ ⊥) : ∀ x y, P x y 
goal: P x y

full_name: EReal.mul_comm
code: protected theorem mul_comm (x y : EReal) : x * y = y * x 
goal: x * y = y * x

full_name: EReal.one_mul
code: protected theorem one_mul : ∀ x : EReal, 1 * x = x
  
goal: 1 * x = x

full_name: EReal.zero_mul
code: protected theorem zero_mul : ∀ x : EReal, 0 * x = 0
  
goal: 0 * x = 0

full_name: EReal.instMulZeroOneClass
code: instance : MulZeroOneClass EReal 
goal: MulZeroOneClass EReal

full_name: EReal.canLift
code: instance canLift : CanLift EReal ℝ (↑) fun r => r ≠ ⊤ ∧ r ≠ ⊥ 
goal: CanLift EReal ℝ Real.toEReal fun r => r ≠ ⊤ ∧ r ≠ ⊥

full_name: EReal.toReal
code: /-- The map from extended reals to reals sending infinities to zero. -/
def toReal : EReal → ℝ
  
goal: EReal → ℝ

full_name: EReal.toReal_top
code: @[simp]
theorem toReal_top : toReal ⊤ = 0 
goal: ⊤.toReal = 0

full_name: EReal.toReal_bot
code: @[simp]
theorem toReal_bot : toReal ⊥ = 0 
goal: ⊥.toReal = 0

full_name: EReal.toReal_zero
code: @[simp]
theorem toReal_zero : toReal 0 = 0 
goal: EReal.toReal 0 = 0

full_name: EReal.toReal_one
code: @[simp]
theorem toReal_one : toReal 1 = 1 
goal: EReal.toReal 1 = 1

full_name: EReal.toReal_coe
code: @[simp]
theorem toReal_coe (x : ℝ) : toReal (x : EReal) = x 
goal: (↑x).toReal = x

full_name: EReal.bot_lt_coe
code: @[simp]
theorem bot_lt_coe (x : ℝ) : (⊥ : EReal) < x 
goal: ⊥ < ↑x

full_name: EReal.coe_ne_bot
code: @[simp]
theorem coe_ne_bot (x : ℝ) : (x : EReal) ≠ ⊥ 
goal: ↑x ≠ ⊥

full_name: EReal.bot_ne_coe
code: @[simp]
theorem bot_ne_coe (x : ℝ) : (⊥ : EReal) ≠ x 
goal: ⊥ ≠ ↑x

full_name: EReal.coe_lt_top
code: @[simp]
theorem coe_lt_top (x : ℝ) : (x : EReal) < ⊤ 
goal: ↑x < ⊤

full_name: EReal.coe_ne_top
code: @[simp]
theorem coe_ne_top (x : ℝ) : (x : EReal) ≠ ⊤ 
goal: ↑x ≠ ⊤

full_name: EReal.top_ne_coe
code: @[simp]
theorem top_ne_coe (x : ℝ) : (⊤ : EReal) ≠ x 
goal: ⊤ ≠ ↑x

full_name: EReal.bot_lt_zero
code: @[simp]
theorem bot_lt_zero : (⊥ : EReal) < 0 
goal: ⊥ < 0

full_name: EReal.bot_ne_zero
code: @[simp]
theorem bot_ne_zero : (⊥ : EReal) ≠ 0 
goal: ⊥ ≠ 0

full_name: EReal.zero_ne_bot
code: @[simp]
theorem zero_ne_bot : (0 : EReal) ≠ ⊥ 
goal: 0 ≠ ⊥

full_name: EReal.zero_lt_top
code: @[simp]
theorem zero_lt_top : (0 : EReal) < ⊤ 
goal: 0 < ⊤

full_name: EReal.zero_ne_top
code: @[simp]
theorem zero_ne_top : (0 : EReal) ≠ ⊤ 
goal: 0 ≠ ⊤

full_name: EReal.top_ne_zero
code: @[simp]
theorem top_ne_zero : (⊤ : EReal) ≠ 0 
goal: ⊤ ≠ 0

full_name: EReal.range_coe
code: theorem range_coe : range Real.toEReal = {⊥, ⊤}ᶜ 
goal: Set.range Real.toEReal = {⊥, ⊤}ᶜ

full_name: EReal.range_coe_eq_Ioo
code: theorem range_coe_eq_Ioo : range Real.toEReal = Ioo ⊥ ⊤ 
goal: Set.range Real.toEReal = Set.Ioo ⊥ ⊤

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

full_name: EReal.coe_nsmul
code: @[norm_cast]
theorem coe_nsmul (n : ℕ) (x : ℝ) : (↑(n • x) : EReal) = n • (x : EReal) 
goal: ↑(n • x) = n • ↑x

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

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

full_name: EReal.coe_ne_zero
code: theorem coe_ne_zero {x : ℝ} : (x : EReal) ≠ 0 ↔ x ≠ 0 
goal: ↑x ≠ 0 ↔ x ≠ 0

full_name: EReal.coe_ne_one
code: theorem coe_ne_one {x : ℝ} : (x : EReal) ≠ 1 ↔ x ≠ 1 
goal: ↑x ≠ 1 ↔ x ≠ 1

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

full_name: EReal.coe_nonpos
code: @[simp, norm_cast]
protected theorem coe_nonpos {x : ℝ} : (x : EReal) ≤ 0 ↔ x ≤ 0 
goal: ↑x ≤ 0 ↔ x ≤ 0

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

full_name: EReal.coe_neg'
code: @[simp, norm_cast]
protected theorem coe_neg' {x : ℝ} : (x : EReal) < 0 ↔ x < 0 
goal: ↑x < 0 ↔ x < 0

full_name: EReal.toReal_le_toReal
code: theorem toReal_le_toReal {x y : EReal} (h : x ≤ y) (hx : x ≠ ⊥) (hy : y ≠ ⊤) :
    x.toReal ≤ y.toReal 
goal: x.toReal ≤ y.toReal

full_name: EReal.coe_toReal
code: theorem coe_toReal {x : EReal} (hx : x ≠ ⊤) (h'x : x ≠ ⊥) : (x.toReal : EReal) = x 
goal: ↑x.toReal = x

full_name: EReal.le_coe_toReal
code: theorem le_coe_toReal {x : EReal} (h : x ≠ ⊤) : x ≤ x.toReal 
goal: x ≤ ↑x.toReal

full_name: EReal.coe_toReal_le
code: theorem coe_toReal_le {x : EReal} (h : x ≠ ⊥) : ↑x.toReal ≤ x 
goal: ↑x.toReal ≤ x

full_name: EReal.eq_top_iff_forall_lt
code: theorem eq_top_iff_forall_lt (x : EReal) : x = ⊤ ↔ ∀ y : ℝ, (y : EReal) < x 
goal: x = ⊤ ↔ ∀ (y : ℝ), ↑y < x

full_name: EReal.eq_bot_iff_forall_lt
code: theorem eq_bot_iff_forall_lt (x : EReal) : x = ⊥ ↔ ∀ y : ℝ, x < (y : EReal) 
goal: x = ⊥ ↔ ∀ (y : ℝ), x < ↑y

full_name: EReal.exists_between_coe_real
code: lemma exists_between_coe_real {x z : EReal} (h : x < z) : ∃ y : ℝ, x < y ∧ y < z 
goal: ∃ y, x < ↑y ∧ ↑y < z

full_name: EReal.image_coe_Icc
code: @[simp]
lemma image_coe_Icc (x y : ℝ) : Real.toEReal '' Icc x y = Icc ↑x ↑y 
goal: Real.toEReal '' Set.Icc x y = Set.Icc ↑x ↑y

full_name: EReal.image_coe_Ico
code: @[simp]
lemma image_coe_Ico (x y : ℝ) : Real.toEReal '' Ico x y = Ico ↑x ↑y 
goal: Real.toEReal '' Set.Ico x y = Set.Ico ↑x ↑y

full_name: EReal.image_coe_Ici
code: @[simp]
lemma image_coe_Ici (x : ℝ) : Real.toEReal '' Ici x = Ico ↑x ⊤ 
goal: Real.toEReal '' Set.Ici x = Set.Ico ↑x ⊤

full_name: EReal.image_coe_Ioc
code: @[simp]
lemma image_coe_Ioc (x y : ℝ) : Real.toEReal '' Ioc x y = Ioc ↑x ↑y 
goal: Real.toEReal '' Set.Ioc x y = Set.Ioc ↑x ↑y

full_name: EReal.image_coe_Ioo
code: @[simp]
lemma image_coe_Ioo (x y : ℝ) : Real.toEReal '' Ioo x y = Ioo ↑x ↑y 
goal: Real.toEReal '' Set.Ioo x y = Set.Ioo ↑x ↑y

full_name: EReal.image_coe_Ioi
code: @[simp]
lemma image_coe_Ioi (x : ℝ) : Real.toEReal '' Ioi x = Ioo ↑x ⊤ 
goal: Real.toEReal '' Set.Ioi x = Set.Ioo ↑x ⊤

full_name: EReal.image_coe_Iic
code: @[simp]
lemma image_coe_Iic (x : ℝ) : Real.toEReal '' Iic x = Ioc ⊥ ↑x 
goal: Real.toEReal '' Set.Iic x = Set.Ioc ⊥ ↑x

full_name: EReal.image_coe_Iio
code: @[simp]
lemma image_coe_Iio (x : ℝ) : Real.toEReal '' Iio x = Ioo ⊥ ↑x 
goal: Real.toEReal '' Set.Iio x = Set.Ioo ⊥ ↑x

full_name: EReal.preimage_coe_Ici
code: @[simp]
lemma preimage_coe_Ici (x : ℝ) : Real.toEReal ⁻¹' Ici x = Ici x 
goal: Real.toEReal ⁻¹' Set.Ici ↑x = Set.Ici x

full_name: EReal.preimage_coe_Ioi
code: @[simp]
lemma preimage_coe_Ioi (x : ℝ) : Real.toEReal ⁻¹' Ioi x = Ioi x 
goal: Real.toEReal ⁻¹' Set.Ioi ↑x = Set.Ioi x

full_name: EReal.preimage_coe_Ioi_bot
code: @[simp]
lemma preimage_coe_Ioi_bot : Real.toEReal ⁻¹' Ioi ⊥ = univ 
goal: Real.toEReal ⁻¹' Set.Ioi ⊥ = Set.univ

full_name: EReal.preimage_coe_Iic
code: @[simp]
lemma preimage_coe_Iic (y : ℝ) : Real.toEReal ⁻¹' Iic y = Iic y 
goal: Real.toEReal ⁻¹' Set.Iic ↑y = Set.Iic y

full_name: EReal.preimage_coe_Iio
code: @[simp]
lemma preimage_coe_Iio (y : ℝ) : Real.toEReal ⁻¹' Iio y = Iio y 
goal: Real.toEReal ⁻¹' Set.Iio ↑y = Set.Iio y

full_name: EReal.preimage_coe_Iio_top
code: @[simp]
lemma preimage_coe_Iio_top : Real.toEReal ⁻¹' Iio ⊤ = univ 
goal: Real.toEReal ⁻¹' Set.Iio ⊤ = Set.univ

full_name: EReal.preimage_coe_Icc
code: @[simp]
lemma preimage_coe_Icc (x y : ℝ) : Real.toEReal ⁻¹' Icc x y = Icc x y 
goal: Real.toEReal ⁻¹' Set.Icc ↑x ↑y = Set.Icc x y

full_name: EReal.preimage_coe_Ico
code: @[simp]
lemma preimage_coe_Ico (x y : ℝ) : Real.toEReal ⁻¹' Ico x y = Ico x y 
goal: Real.toEReal ⁻¹' Set.Ico ↑x ↑y = Set.Ico x y

full_name: EReal.preimage_coe_Ioc
code: @[simp]
lemma preimage_coe_Ioc (x y : ℝ) : Real.toEReal ⁻¹' Ioc x y = Ioc x y 
goal: Real.toEReal ⁻¹' Set.Ioc ↑x ↑y = Set.Ioc x y

full_name: EReal.preimage_coe_Ioo
code: @[simp]
lemma preimage_coe_Ioo (x y : ℝ) : Real.toEReal ⁻¹' Ioo x y = Ioo x y 
goal: Real.toEReal ⁻¹' Set.Ioo ↑x ↑y = Set.Ioo x y

full_name: EReal.preimage_coe_Ico_top
code: @[simp]
lemma preimage_coe_Ico_top (x : ℝ) : Real.toEReal ⁻¹' Ico x ⊤ = Ici x 
goal: Real.toEReal ⁻¹' Set.Ico ↑x ⊤ = Set.Ici x

full_name: EReal.preimage_coe_Ioo_top
code: @[simp]
lemma preimage_coe_Ioo_top (x : ℝ) : Real.toEReal ⁻¹' Ioo x ⊤ = Ioi x 
goal: Real.toEReal ⁻¹' Set.Ioo ↑x ⊤ = Set.Ioi x

full_name: EReal.preimage_coe_Ioc_bot
code: @[simp]
lemma preimage_coe_Ioc_bot (y : ℝ) : Real.toEReal ⁻¹' Ioc ⊥ y = Iic y 
goal: Real.toEReal ⁻¹' Set.Ioc ⊥ ↑y = Set.Iic y

full_name: EReal.preimage_coe_Ioo_bot
code: @[simp]
lemma preimage_coe_Ioo_bot (y : ℝ) : Real.toEReal ⁻¹' Ioo ⊥ y = Iio y 
goal: Real.toEReal ⁻¹' Set.Ioo ⊥ ↑y = Set.Iio y

full_name: EReal.preimage_coe_Ioo_bot_top
code: @[simp]
lemma preimage_coe_Ioo_bot_top : Real.toEReal ⁻¹' Ioo ⊥ ⊤ = univ 
goal: Real.toEReal ⁻¹' Set.Ioo ⊥ ⊤ = Set.univ

full_name: EReal.toReal_coe_ennreal
code: @[simp]
theorem toReal_coe_ennreal : ∀ {x : ℝ≥0∞}, toReal (x : EReal) = ENNReal.toReal x
  
goal: (↑x).toReal = x.toReal

full_name: EReal.coe_ennreal_ofReal
code: @[simp]
theorem coe_ennreal_ofReal {x : ℝ} : (ENNReal.ofReal x : EReal) = max x 0 
goal: ↑(ENNReal.ofReal x) = ↑(max x 0)

full_name: EReal.coe_nnreal_eq_coe_real
code: theorem coe_nnreal_eq_coe_real (x : ℝ≥0) : ((x : ℝ≥0∞) : EReal) = (x : ℝ) 
goal: ↑↑x = ↑↑x

full_name: EReal.coe_ennreal_zero
code: @[simp, norm_cast]
theorem coe_ennreal_zero : ((0 : ℝ≥0∞) : EReal) = 0 
goal: ↑0 = 0

full_name: EReal.coe_ennreal_one
code: @[simp, norm_cast]
theorem coe_ennreal_one : ((1 : ℝ≥0∞) : EReal) = 1 
goal: ↑1 = 1

full_name: EReal.coe_ennreal_top
code: @[simp, norm_cast]
theorem coe_ennreal_top : ((⊤ : ℝ≥0∞) : EReal) = ⊤ 
goal: ↑⊤ = ⊤

full_name: EReal.coe_ennreal_strictMono
code: theorem coe_ennreal_strictMono : StrictMono ((↑) : ℝ≥0∞ → EReal) 
goal: StrictMono ENNReal.toEReal

full_name: EReal.coe_ennreal_injective
code: theorem coe_ennreal_injective : Injective ((↑) : ℝ≥0∞ → EReal) 
goal: Function.Injective ENNReal.toEReal

full_name: EReal.coe_ennreal_eq_top_iff
code: @[simp]
theorem coe_ennreal_eq_top_iff {x : ℝ≥0∞} : (x : EReal) = ⊤ ↔ x = ⊤ 
goal: ↑x = ⊤ ↔ x = ⊤

full_name: EReal.coe_nnreal_ne_top
code: theorem coe_nnreal_ne_top (x : ℝ≥0) : ((x : ℝ≥0∞) : EReal) ≠ ⊤ 
goal: ↑↑x ≠ ⊤

full_name: EReal.coe_nnreal_lt_top
code: @[simp]
theorem coe_nnreal_lt_top (x : ℝ≥0) : ((x : ℝ≥0∞) : EReal) < ⊤ 
goal: ↑↑x < ⊤

full_name: EReal.coe_ennreal_le_coe_ennreal_iff
code: @[simp, norm_cast]
theorem coe_ennreal_le_coe_ennreal_iff {x y : ℝ≥0∞} : (x : EReal) ≤ (y : EReal) ↔ x ≤ y 
goal: ↑x ≤ ↑y ↔ x ≤ y

full_name: EReal.coe_ennreal_lt_coe_ennreal_iff
code: @[simp, norm_cast]
theorem coe_ennreal_lt_coe_ennreal_iff {x y : ℝ≥0∞} : (x : EReal) < (y : EReal) ↔ x < y 
goal: ↑x < ↑y ↔ x < y

full_name: EReal.coe_ennreal_eq_coe_ennreal_iff
code: @[simp, norm_cast]
theorem coe_ennreal_eq_coe_ennreal_iff {x y : ℝ≥0∞} : (x : EReal) = (y : EReal) ↔ x = y 
goal: ↑x = ↑y ↔ x = y

full_name: EReal.coe_ennreal_ne_coe_ennreal_iff
code: theorem coe_ennreal_ne_coe_ennreal_iff {x y : ℝ≥0∞} : (x : EReal) ≠ (y : EReal) ↔ x ≠ y 
goal: ↑x ≠ ↑y ↔ x ≠ y

full_name: EReal.coe_ennreal_eq_zero
code: @[simp, norm_cast]
theorem coe_ennreal_eq_zero {x : ℝ≥0∞} : (x : EReal) = 0 ↔ x = 0 
goal: ↑x = 0 ↔ x = 0

full_name: EReal.coe_ennreal_eq_one
code: @[simp, norm_cast]
theorem coe_ennreal_eq_one {x : ℝ≥0∞} : (x : EReal) = 1 ↔ x = 1 
goal: ↑x = 1 ↔ x = 1

full_name: EReal.coe_ennreal_ne_zero
code: @[norm_cast]
theorem coe_ennreal_ne_zero {x : ℝ≥0∞} : (x : EReal) ≠ 0 ↔ x ≠ 0 
goal: ↑x ≠ 0 ↔ x ≠ 0

full_name: EReal.coe_ennreal_ne_one
code: @[norm_cast]
theorem coe_ennreal_ne_one {x : ℝ≥0∞} : (x : EReal) ≠ 1 ↔ x ≠ 1 
goal: ↑x ≠ 1 ↔ x ≠ 1

full_name: EReal.coe_ennreal_nonneg
code: theorem coe_ennreal_nonneg (x : ℝ≥0∞) : (0 : EReal) ≤ x 
goal: 0 ≤ ↑x

full_name: EReal.range_coe_ennreal
code: @[simp] theorem range_coe_ennreal : range ((↑) : ℝ≥0∞ → EReal) = Set.Ici 0 
goal: Set.range ENNReal.toEReal = Set.Ici 0

full_name: EReal.instCanLiftENNRealToERealLeOfNat
code: instance : CanLift EReal ℝ≥0∞ (↑) (0 ≤ ·) 
goal: CanLift EReal ℝ≥0∞ ENNReal.toEReal fun x => 0 ≤ x

full_name: EReal.coe_ennreal_pos
code: @[simp, norm_cast]
theorem coe_ennreal_pos {x : ℝ≥0∞} : (0 : EReal) < x ↔ 0 < x 
goal: 0 < ↑x ↔ 0 < x

full_name: EReal.bot_lt_coe_ennreal
code: @[simp]
theorem bot_lt_coe_ennreal (x : ℝ≥0∞) : (⊥ : EReal) < x 
goal: ⊥ < ↑x

full_name: EReal.coe_ennreal_ne_bot
code: @[simp]
theorem coe_ennreal_ne_bot (x : ℝ≥0∞) : (x : EReal) ≠ ⊥ 
goal: ↑x ≠ ⊥

full_name: EReal.coe_ennreal_add
code: @[simp, norm_cast]
theorem coe_ennreal_add (x y : ENNReal) : ((x + y : ℝ≥0∞) : EReal) = x + y 
goal: ↑(x + y) = ↑x + ↑y

full_name: _private.Mathlib.Data.Real.EReal.0.EReal.coe_ennreal_top_mul
code: private theorem coe_ennreal_top_mul (x : ℝ≥0) : ((⊤ * x : ℝ≥0∞) : EReal) = ⊤ * x 
goal: ↑(⊤ * ↑x) = ⊤ * ↑↑x

full_name: EReal.coe_ennreal_mul
code: @[simp, norm_cast]
theorem coe_ennreal_mul : ∀ x y : ℝ≥0∞, ((x * y : ℝ≥0∞) : EReal) = (x : EReal) * y
  
goal: ↑(x * y) = ↑x * ↑y

full_name: EReal.coe_ennreal_nsmul
code: @[norm_cast]
theorem coe_ennreal_nsmul (n : ℕ) (x : ℝ≥0∞) : (↑(n • x) : EReal) = n • (x : EReal) 
goal: ↑(n • x) = n • ↑x

full_name: EReal.coe_coe_eq_natCast
code: theorem coe_coe_eq_natCast (n : ℕ) : (n : ℝ) = (n : EReal) 
goal: ↑↑n = ↑n

full_name: EReal.natCast_ne_bot
code: theorem natCast_ne_bot (n : ℕ) : (n : EReal) ≠ ⊥ 
goal: ↑n ≠ ⊥

full_name: EReal.natCast_ne_top
code: theorem natCast_ne_top (n : ℕ) : (n : EReal) ≠ ⊤ 
goal: ↑n ≠ ⊤

full_name: EReal.natCast_eq_iff
code: @[simp, norm_cast]
theorem natCast_eq_iff {m n : ℕ} : (m : EReal) = (n : EReal) ↔ m = n 
goal: ↑m = ↑n ↔ m = n

full_name: EReal.natCast_ne_iff
code: theorem natCast_ne_iff {m n : ℕ} : (m : EReal) ≠ (n : EReal) ↔ m ≠ n 
goal: ↑m ≠ ↑n ↔ m ≠ n

full_name: EReal.natCast_le_iff
code: @[simp, norm_cast]
theorem natCast_le_iff {m n : ℕ} : (m : EReal) ≤ (n : EReal) ↔ m ≤ n 
goal: ↑m ≤ ↑n ↔ m ≤ n

full_name: EReal.natCast_lt_iff
code: @[simp, norm_cast]
theorem natCast_lt_iff {m n : ℕ} : (m : EReal) < (n : EReal) ↔ m < n 
goal: ↑m < ↑n ↔ m < n

full_name: EReal.natCast_mul
code: @[simp, norm_cast]
theorem natCast_mul (m n : ℕ) :
    (m * n : ℕ) = (m : EReal) * (n : EReal) 
goal: ↑(m * n) = ↑m * ↑n

full_name: EReal.exists_rat_btwn_of_lt
code: theorem exists_rat_btwn_of_lt :
    ∀ {a b : EReal}, a < b → ∃ x : ℚ, a < (x : ℝ) ∧ ((x : ℝ) : EReal) < b
  
goal: a < b → ∃ x, a < ↑↑x ∧ ↑↑x < b

full_name: EReal.lt_iff_exists_rat_btwn
code: theorem lt_iff_exists_rat_btwn {a b : EReal} :
    a < b ↔ ∃ x : ℚ, a < (x : ℝ) ∧ ((x : ℝ) : EReal) < b 
goal: a < b ↔ ∃ x, a < ↑↑x ∧ ↑↑x < b

full_name: EReal.lt_iff_exists_real_btwn
code: theorem lt_iff_exists_real_btwn {a b : EReal} : a < b ↔ ∃ x : ℝ, a < x ∧ (x : EReal) < b 
goal: a < b ↔ ∃ x, a < ↑x ∧ ↑x < b

full_name: EReal.neTopBotEquivReal
code: /-- The set of numbers in `EReal` that are not equal to `±∞` is equivalent to `ℝ`. -/
def neTopBotEquivReal : ({⊥, ⊤}ᶜ : Set EReal) ≃ ℝ 
goal: ↑{⊥, ⊤}ᶜ ≃ ℝ

full_name: EReal.add_bot
code: @[simp]
theorem add_bot (x : EReal) : x + ⊥ = ⊥ 
goal: x + ⊥ = ⊥

full_name: EReal.bot_add
code: @[simp]
theorem bot_add (x : EReal) : ⊥ + x = ⊥ 
goal: ⊥ + x = ⊥

full_name: EReal.add_eq_bot_iff
code: @[simp]
theorem add_eq_bot_iff {x y : EReal} : x + y = ⊥ ↔ x = ⊥ ∨ y = ⊥ 
goal: x + y = ⊥ ↔ x = ⊥ ∨ y = ⊥

full_name: EReal.bot_lt_add_iff
code: @[simp]
theorem bot_lt_add_iff {x y : EReal} : ⊥ < x + y ↔ ⊥ < x ∧ ⊥ < y 
goal: ⊥ < x + y ↔ ⊥ < x ∧ ⊥ < y

full_name: EReal.top_add_top
code: @[simp]
theorem top_add_top : (⊤ : EReal) + ⊤ = ⊤ 
goal: ⊤ + ⊤ = ⊤

full_name: EReal.top_add_coe
code: @[simp]
theorem top_add_coe (x : ℝ) : (⊤ : EReal) + x = ⊤ 
goal: ⊤ + ↑x = ⊤

full_name: EReal.top_add_of_ne_bot
code: /-- For any extended real number `x` which is not `⊥`, the sum of `⊤` and `x` is equal to `⊤`. -/
@[simp]
theorem top_add_of_ne_bot {x : EReal} (h : x ≠ ⊥) : ⊤ + x = ⊤ 
goal: ⊤ + x = ⊤

full_name: EReal.top_add_iff_ne_bot
code: /-- For any extended real number `x`, the sum of `⊤` and `x` is equal to `⊤`
if and only if `x` is not `⊥`. -/
theorem top_add_iff_ne_bot {x : EReal} : ⊤ + x = ⊤ ↔ x ≠ ⊥ 
goal: ⊤ + x = ⊤ ↔ x ≠ ⊥

full_name: EReal.add_top_of_ne_bot
code: /-- For any extended real number `x` which is not `⊥`, the sum of `x` and `⊤` is equal to `⊤`. -/
@[simp]
theorem add_top_of_ne_bot {x : EReal} (h : x ≠ ⊥) : x + ⊤ = ⊤ 
goal: x + ⊤ = ⊤

full_name: EReal.add_top_iff_ne_bot
code: /-- For any extended real number `x`, the sum of `x` and `⊤` is equal to `⊤`
if and only if `x` is not `⊥`. -/
theorem add_top_iff_ne_bot {x : EReal} : x + ⊤ = ⊤ ↔ x ≠ ⊥ 
goal: x + ⊤ = ⊤ ↔ x ≠ ⊥

full_name: EReal.add_pos
code: /-- For any two extended real numbers `a` and `b`, if both `a` and `b` are greater than `0`,
then their sum is also greater than `0`. -/
theorem add_pos {a b : EReal} (ha : 0 < a) (hb : 0 < b) : 0 < a + b 
goal: 0 < a + b

full_name: EReal.coe_add_top
code: @[simp]
theorem coe_add_top (x : ℝ) : (x : EReal) + ⊤ = ⊤ 
goal: ↑x + ⊤ = ⊤

full_name: EReal.toReal_add
code: theorem toReal_add {x y : EReal} (hx : x ≠ ⊤) (h'x : x ≠ ⊥) (hy : y ≠ ⊤) (h'y : y ≠ ⊥) :
    toReal (x + y) = toReal x + toReal y 
goal: (x + y).toReal = x.toReal + y.toReal

full_name: EReal.addLECancellable_coe
code: theorem addLECancellable_coe (x : ℝ) : AddLECancellable (x : EReal)
  
goal: AddLECancellable ↑x

full_name: EReal.add_lt_add_right_coe
code: theorem add_lt_add_right_coe {x y : EReal} (h : x < y) (z : ℝ) : x + z < y + z 
goal: x + ↑z < y + ↑z

full_name: EReal.add_lt_add_left_coe
code: theorem add_lt_add_left_coe {x y : EReal} (h : x < y) (z : ℝ) : (z : EReal) + x < z + y 
goal: ↑z + x < ↑z + y

full_name: EReal.add_lt_add
code: theorem add_lt_add {x y z t : EReal} (h1 : x < y) (h2 : z < t) : x + z < y + t 
goal: x + z < y + t

full_name: EReal.add_lt_add_of_lt_of_le'
code: theorem add_lt_add_of_lt_of_le' {x y z t : EReal} (h : x < y) (h' : z ≤ t) (hbot : t ≠ ⊥)
    (htop : t = ⊤ → z = ⊤ → x = ⊥) : x + z < y + t 
goal: x + z < y + t

full_name: EReal.add_lt_add_of_lt_of_le
code: /-- See also `EReal.add_lt_add_of_lt_of_le'` for a version with weaker but less convenient
assumptions. -/
theorem add_lt_add_of_lt_of_le {x y z t : EReal} (h : x < y) (h' : z ≤ t) (hz : z ≠ ⊥)
    (ht : t ≠ ⊤) : x + z < y + t 
goal: x + z < y + t

full_name: EReal.add_lt_top
code: theorem add_lt_top {x y : EReal} (hx : x ≠ ⊤) (hy : y ≠ ⊤) : x + y < ⊤ 
goal: x + y < ⊤

full_name: EReal.instLinearOrderedAddCommMonoidWithTopOrderDual
code: /-- We do not have a notion of `LinearOrderedAddCommMonoidWithBot` but we can at least make
the order dual of the extended reals into a `LinearOrderedAddCommMonoidWithTop`. -/
instance : LinearOrderedAddCommMonoidWithTop ERealᵒᵈ 
goal: LinearOrderedAddCommMonoidWithTop ERealᵒᵈ

full_name: EReal.neg
code: /-- negation on `EReal` -/
protected def neg : EReal → EReal
  
goal: EReal → EReal

full_name: EReal.instNeg
code: instance : Neg EReal 
goal: Neg EReal

full_name: EReal.instSubNegZeroMonoid
code: instance : SubNegZeroMonoid EReal 
goal: SubNegZeroMonoid EReal

full_name: EReal.neg_top
code: @[simp]
theorem neg_top : -(⊤ : EReal) = ⊥ 
goal: -⊤ = ⊥

full_name: EReal.neg_bot
code: @[simp]
theorem neg_bot : -(⊥ : EReal) = ⊤ 
goal: -⊥ = ⊤

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

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

full_name: EReal.coe_zsmul
code: @[norm_cast]
theorem coe_zsmul (n : ℤ) (x : ℝ) : (↑(n • x) : EReal) = n • (x : EReal) 
goal: ↑(n • x) = n • ↑x

full_name: EReal.instInvolutiveNeg
code: instance : InvolutiveNeg EReal 
goal: InvolutiveNeg EReal

full_name: EReal.toReal_neg
code: @[simp]
theorem toReal_neg : ∀ {a : EReal}, toReal (-a) = -toReal a
  
goal: (-a).toReal = -a.toReal

full_name: EReal.neg_eq_top_iff
code: @[simp]
theorem neg_eq_top_iff {x : EReal} : -x = ⊤ ↔ x = ⊥ 
goal: -x = ⊤ ↔ x = ⊥

full_name: EReal.neg_eq_bot_iff
code: @[simp]
theorem neg_eq_bot_iff {x : EReal} : -x = ⊥ ↔ x = ⊤ 
goal: -x = ⊥ ↔ x = ⊤

full_name: EReal.neg_eq_zero_iff
code: @[simp]
theorem neg_eq_zero_iff {x : EReal} : -x = 0 ↔ x = 0 
goal: -x = 0 ↔ x = 0

full_name: EReal.neg_strictAnti
code: theorem neg_strictAnti : StrictAnti (- · : EReal → EReal) 
goal: StrictAnti fun x => -x

full_name: EReal.neg_le_neg_iff
code: @[simp] theorem neg_le_neg_iff {a b : EReal} : -a ≤ -b ↔ b ≤ a 
goal: -a ≤ -b ↔ b ≤ a

full_name: EReal.neg_lt_neg_iff
code: @[simp] theorem neg_lt_neg_iff {a b : EReal} : -a < -b ↔ b < a 
goal: -a < -b ↔ b < a

full_name: EReal.neg_le
code: /-- `-a ≤ b ↔ -b ≤ a` on `EReal`. -/
protected theorem neg_le {a b : EReal} : -a ≤ b ↔ -b ≤ a 
goal: -a ≤ b ↔ -b ≤ a

full_name: EReal.neg_le_of_neg_le
code: /-- if `-a ≤ b` then `-b ≤ a` on `EReal`. -/
protected theorem neg_le_of_neg_le {a b : EReal} (h : -a ≤ b) : -b ≤ a 
goal: -b ≤ a

full_name: EReal.le_neg_of_le_neg
code: /-- `a ≤ -b → b ≤ -a` on ereal -/
theorem le_neg_of_le_neg {a b : EReal} (h : a ≤ -b) : b ≤ -a 
goal: b ≤ -a

full_name: EReal.negOrderIso
code: /-- Negation as an order reversing isomorphism on `EReal`. -/
def negOrderIso : EReal ≃o ERealᵒᵈ 
goal: EReal ≃o ERealᵒᵈ

full_name: EReal.neg_lt_iff_neg_lt
code: theorem neg_lt_iff_neg_lt {a b : EReal} : -a < b ↔ -b < a 
goal: -a < b ↔ -b < a

full_name: EReal.neg_lt_of_neg_lt
code: theorem neg_lt_of_neg_lt {a b : EReal} (h : -a < b) : -b < a 
goal: -b < a

full_name: EReal.neg_add
code: lemma neg_add {x y : EReal} (h1 : x ≠ ⊥ ∨ y ≠ ⊤) (h2 : x ≠ ⊤ ∨ y ≠ ⊥) :
    - (x + y) = - x - y 
goal: -(x + y) = -x - y

full_name: EReal.neg_sub
code: lemma neg_sub {x y : EReal} (h1 : x ≠ ⊥ ∨ y ≠ ⊥) (h2 : x ≠ ⊤ ∨ y ≠ ⊤) :
    - (x - y) = - x + y 
goal: -(x - y) = -x + y

full_name: EReal.bot_sub
code: @[simp]
theorem bot_sub (x : EReal) : ⊥ - x = ⊥ 
goal: ⊥ - x = ⊥

full_name: EReal.sub_top
code: @[simp]
theorem sub_top (x : EReal) : x - ⊤ = ⊥ 
goal: x - ⊤ = ⊥

full_name: EReal.top_sub_bot
code: @[simp]
theorem top_sub_bot : (⊤ : EReal) - ⊥ = ⊤ 
goal: ⊤ - ⊥ = ⊤

full_name: EReal.top_sub_coe
code: @[simp]
theorem top_sub_coe (x : ℝ) : (⊤ : EReal) - x = ⊤ 
goal: ⊤ - ↑x = ⊤

full_name: EReal.coe_sub_bot
code: @[simp]
theorem coe_sub_bot (x : ℝ) : (x : EReal) - ⊥ = ⊤ 
goal: ↑x - ⊥ = ⊤

full_name: EReal.sub_le_sub
code: theorem sub_le_sub {x y z t : EReal} (h : x ≤ y) (h' : t ≤ z) : x - z ≤ y - t 
goal: x - z ≤ y - t

full_name: EReal.sub_lt_sub_of_lt_of_le
code: theorem sub_lt_sub_of_lt_of_le {x y z t : EReal} (h : x < y) (h' : z ≤ t) (hz : z ≠ ⊥)
    (ht : t ≠ ⊤) : x - t < y - z 
goal: x - t < y - z

full_name: EReal.coe_real_ereal_eq_coe_toNNReal_sub_coe_toNNReal
code: theorem coe_real_ereal_eq_coe_toNNReal_sub_coe_toNNReal (x : ℝ) :
    (x : EReal) = Real.toNNReal x - Real.toNNReal (-x) 
goal: ↑x = ↑↑x.toNNReal - ↑↑(-x).toNNReal

full_name: EReal.toReal_sub
code: theorem toReal_sub {x y : EReal} (hx : x ≠ ⊤) (h'x : x ≠ ⊥) (hy : y ≠ ⊤) (h'y : y ≠ ⊥) :
    toReal (x - y) = toReal x - toReal y 
goal: (x - y).toReal = x.toReal - y.toReal

full_name: EReal.add_sub_cancel_right
code: lemma add_sub_cancel_right {a : EReal} {b : Real} : a + b - b = a 
goal: a + ↑b - ↑b = a

full_name: EReal.top_mul_top
code: @[simp] lemma top_mul_top : (⊤ : EReal) * ⊤ = ⊤ 
goal: ⊤ * ⊤ = ⊤

full_name: EReal.top_mul_bot
code: @[simp] lemma top_mul_bot : (⊤ : EReal) * ⊥ = ⊥ 
goal: ⊤ * ⊥ = ⊥

full_name: EReal.bot_mul_top
code: @[simp] lemma bot_mul_top : (⊥ : EReal) * ⊤ = ⊥ 
goal: ⊥ * ⊤ = ⊥

full_name: EReal.bot_mul_bot
code: @[simp] lemma bot_mul_bot : (⊥ : EReal) * ⊥ = ⊤ 
goal: ⊥ * ⊥ = ⊤

full_name: EReal.coe_mul_top_of_pos
code: lemma coe_mul_top_of_pos {x : ℝ} (h : 0 < x) : (x : EReal) * ⊤ = ⊤ 
goal: ↑x * ⊤ = ⊤

full_name: EReal.coe_mul_top_of_neg
code: lemma coe_mul_top_of_neg {x : ℝ} (h : x < 0) : (x : EReal) * ⊤ = ⊥ 
goal: ↑x * ⊤ = ⊥

full_name: EReal.top_mul_coe_of_pos
code: lemma top_mul_coe_of_pos {x : ℝ} (h : 0 < x) : (⊤ : EReal) * x = ⊤ 
goal: ⊤ * ↑x = ⊤

full_name: EReal.top_mul_coe_of_neg
code: lemma top_mul_coe_of_neg {x : ℝ} (h : x < 0) : (⊤ : EReal) * x = ⊥ 
goal: ⊤ * ↑x = ⊥

full_name: EReal.mul_top_of_pos
code: lemma mul_top_of_pos : ∀ {x : EReal}, 0 < x → x * ⊤ = ⊤
  
goal: 0 < x → x * ⊤ = ⊤

full_name: EReal.mul_top_of_neg
code: lemma mul_top_of_neg : ∀ {x : EReal}, x < 0 → x * ⊤ = ⊥
  
goal: x < 0 → x * ⊤ = ⊥

full_name: EReal.top_mul_of_pos
code: lemma top_mul_of_pos {x : EReal} (h : 0 < x) : ⊤ * x = ⊤ 
goal: ⊤ * x = ⊤

full_name: EReal.mul_pos
code: /-- The product of two positive extended real numbers is positive. -/
lemma mul_pos {a b : EReal} (ha : 0 < a) (hb : 0 < b) : 0 < a * b 
goal: 0 < a * b

full_name: EReal.top_mul_of_neg
code: lemma top_mul_of_neg {x : EReal} (h : x < 0) : ⊤ * x = ⊥ 
goal: ⊤ * x = ⊥

full_name: EReal.coe_mul_bot_of_pos
code: lemma coe_mul_bot_of_pos {x : ℝ} (h : 0 < x) : (x : EReal) * ⊥ = ⊥ 
goal: ↑x * ⊥ = ⊥

full_name: EReal.coe_mul_bot_of_neg
code: lemma coe_mul_bot_of_neg {x : ℝ} (h : x < 0) : (x : EReal) * ⊥ = ⊤ 
goal: ↑x * ⊥ = ⊤

full_name: EReal.bot_mul_coe_of_pos
code: lemma bot_mul_coe_of_pos {x : ℝ} (h : 0 < x) : (⊥ : EReal) * x = ⊥ 
goal: ⊥ * ↑x = ⊥

full_name: EReal.bot_mul_coe_of_neg
code: lemma bot_mul_coe_of_neg {x : ℝ} (h : x < 0) : (⊥ : EReal) * x = ⊤ 
goal: ⊥ * ↑x = ⊤

full_name: EReal.mul_bot_of_pos
code: lemma mul_bot_of_pos : ∀ {x : EReal}, 0 < x → x * ⊥ = ⊥
  
goal: 0 < x → x * ⊥ = ⊥

full_name: EReal.mul_bot_of_neg
code: lemma mul_bot_of_neg : ∀ {x : EReal}, x < 0 → x * ⊥ = ⊤
  
goal: x < 0 → x * ⊥ = ⊤

full_name: EReal.bot_mul_of_pos
code: lemma bot_mul_of_pos {x : EReal} (h : 0 < x) : ⊥ * x = ⊥ 
goal: ⊥ * x = ⊥

full_name: EReal.bot_mul_of_neg
code: lemma bot_mul_of_neg {x : EReal} (h : x < 0) : ⊥ * x = ⊤ 
goal: ⊥ * x = ⊤

full_name: EReal.toReal_mul
code: lemma toReal_mul {x y : EReal} : toReal (x * y) = toReal x * toReal y 
goal: (x * y).toReal = x.toReal * y.toReal

full_name: EReal.induction₂_neg_left
code: /-- Induct on two ereals by performing case splits on the sign of one whenever the other is
infinite. This version eliminates some cases by assuming that `P x y` implies `P (-x) y` for all
`x`, `y`. -/
@[elab_as_elim]
lemma induction₂_neg_left {P : EReal → EReal → Prop} (neg_left : ∀ {x y}, P x y → P (-x) y)
    (top_top : P ⊤ ⊤) (top_pos : ∀ x : ℝ, 0 < x → P ⊤ x)
    (top_zero : P ⊤ 0) (top_neg : ∀ x : ℝ, x < 0 → P ⊤ x) (top_bot : P ⊤ ⊥)
    (zero_top : P 0 ⊤) (zero_bot : P 0 ⊥)
    (pos_top : ∀ x : ℝ, 0 < x → P x ⊤) (pos_bot : ∀ x : ℝ, 0 < x → P x ⊥)
    (coe_coe : ∀ x y : ℝ, P x y) : ∀ x y, P x y 
goal: P x y

full_name: EReal.induction₂_symm_neg
code: /-- Induct on two ereals by performing case splits on the sign of one whenever the other is
infinite. This version eliminates some cases by assuming that `P` is symmetric and `P x y` implies
`P (-x) y` for all `x`, `y`. -/
@[elab_as_elim]
lemma induction₂_symm_neg {P : EReal → EReal → Prop}
    (symm : ∀ {x y}, P x y → P y x)
    (neg_left : ∀ {x y}, P x y → P (-x) y) (top_top : P ⊤ ⊤)
    (top_pos : ∀ x : ℝ, 0 < x → P ⊤ x) (top_zero : P ⊤ 0) (coe_coe : ∀ x y : ℝ, P x y) :
    ∀ x y, P x y 
goal: P x y

full_name: EReal.neg_mul
code: protected lemma neg_mul (x y : EReal) : -x * y = -(x * y) 
goal: -x * y = -(x * y)

full_name: EReal.instHasDistribNeg
code: instance : HasDistribNeg EReal 
goal: HasDistribNeg EReal

full_name: EReal.right_distrib_of_nonneg
code: lemma right_distrib_of_nonneg {a b c : EReal} (ha : 0 ≤ a) (hb : 0 ≤ b) :
    (a + b) * c = a * c + b * c 
goal: (a + b) * c = a * c + b * c

full_name: EReal.left_distrib_of_nonneg
code: lemma left_distrib_of_nonneg {a b c : EReal} (ha : 0 ≤ a) (hb : 0 ≤ b) :
    c * (a + b) = c * a + c * b 
goal: c * (a + b) = c * a + c * b

full_name: EReal.le_iff_le_forall_real_gt
code: lemma le_iff_le_forall_real_gt (x y : EReal) : (∀ z : ℝ, x < z → y ≤ z) ↔ y ≤ x 
goal: (∀ (z : ℝ), x < ↑z → y ≤ ↑z) ↔ y ≤ x

full_name: EReal.ge_iff_le_forall_real_lt
code: lemma ge_iff_le_forall_real_lt (x y : EReal) : (∀ z : ℝ, z < y → z ≤ x) ↔ y ≤ x 
goal: (∀ (z : ℝ), ↑z < y → ↑z ≤ x) ↔ y ≤ x

full_name: EReal.abs
code: /-- The absolute value from `EReal` to `ℝ≥0∞`, mapping `⊥` and `⊤` to `⊤` and
a real `x` to `|x|`. -/
protected def abs : EReal → ℝ≥0∞
  
goal: EReal → ℝ≥0∞

full_name: EReal.abs_top
code: @[simp] theorem abs_top : (⊤ : EReal).abs = ⊤ 
goal: ⊤.abs = ⊤

full_name: EReal.abs_bot
code: @[simp] theorem abs_bot : (⊥ : EReal).abs = ⊤ 
goal: ⊥.abs = ⊤

full_name: EReal.abs_def
code: theorem abs_def (x : ℝ) : (x : EReal).abs = ENNReal.ofReal |x| 
goal: (↑x).abs = ENNReal.ofReal |x|

full_name: EReal.abs_coe_lt_top
code: theorem abs_coe_lt_top (x : ℝ) : (x : EReal).abs < ⊤ 
goal: (↑x).abs < ⊤

full_name: EReal.abs_eq_zero_iff
code: @[simp]
theorem abs_eq_zero_iff {x : EReal} : x.abs = 0 ↔ x = 0 
goal: x.abs = 0 ↔ x = 0

full_name: EReal.abs_zero
code: @[simp]
theorem abs_zero : (0 : EReal).abs = 0 
goal: EReal.abs 0 = 0

full_name: EReal.coe_abs
code: @[simp]
theorem coe_abs (x : ℝ) : ((x : EReal).abs : EReal) = (|x| : ℝ) 
goal: ↑(↑x).abs = ↑|x|

full_name: EReal.abs_neg
code: @[simp]
protected theorem abs_neg : ∀ x : EReal, (-x).abs = x.abs
  
goal: (-x).abs = x.abs

full_name: EReal.abs_mul
code: @[simp]
theorem abs_mul (x y : EReal) : (x * y).abs = x.abs * y.abs 
goal: (x * y).abs = x.abs * y.abs

full_name: EReal.sign_top
code: theorem sign_top : sign (⊤ : EReal) = 1 
goal: SignType.sign ⊤ = 1

full_name: EReal.sign_bot
code: theorem sign_bot : sign (⊥ : EReal) = -1 
goal: SignType.sign ⊥ = -1

full_name: EReal.sign_coe
code: @[simp]
theorem sign_coe (x : ℝ) : sign (x : EReal) = sign x 
goal: SignType.sign ↑x = SignType.sign x

full_name: EReal.coe_coe_sign
code: @[simp, norm_cast]
theorem coe_coe_sign (x : SignType) : ((x : ℝ) : EReal) = x 
goal: ↑↑x = ↑x

full_name: EReal.sign_neg
code: @[simp] theorem sign_neg : ∀ x : EReal, sign (-x) = -sign x
  
goal: SignType.sign (-x) = -SignType.sign x

full_name: EReal.sign_mul
code: @[simp]
theorem sign_mul (x y : EReal) : sign (x * y) = sign x * sign y 
goal: SignType.sign (x * y) = SignType.sign x * SignType.sign y

full_name: EReal.sign_mul_abs
code: @[simp] protected theorem sign_mul_abs : ∀ x : EReal, (sign x * x.abs : EReal) = x
  
goal: ↑(SignType.sign x) * ↑x.abs = x

full_name: EReal.abs_mul_sign
code: @[simp] protected theorem abs_mul_sign (x : EReal) : (x.abs * sign x : EReal) = x 
goal: ↑x.abs * ↑(SignType.sign x) = x

full_name: EReal.sign_eq_and_abs_eq_iff_eq
code: theorem sign_eq_and_abs_eq_iff_eq {x y : EReal} :
    x.abs = y.abs ∧ sign x = sign y ↔ x = y 
goal: x.abs = y.abs ∧ SignType.sign x = SignType.sign y ↔ x = y

full_name: EReal.le_iff_sign
code: theorem le_iff_sign {x y : EReal} :
    x ≤ y ↔ sign x < sign y ∨
      sign x = SignType.neg ∧ sign y = SignType.neg ∧ y.abs ≤ x.abs ∨
        sign x = SignType.zero ∧ sign y = SignType.zero ∨
          sign x = SignType.pos ∧ sign y = SignType.pos ∧ x.abs ≤ y.abs 
goal: x ≤ y ↔
  SignType.sign x < SignType.sign y ∨
    SignType.sign x = SignType.neg ∧ SignType.sign y = SignType.neg ∧ y.abs ≤ x.abs ∨
      SignType.sign x = SignType.zero ∧ SignType.sign y = SignType.zero ∨
        SignType.sign x = SignType.pos ∧ SignType.sign y = SignType.pos ∧ x.abs ≤ y.abs

full_name: EReal.instCommMonoidWithZero
code: instance : CommMonoidWithZero EReal 
goal: CommMonoidWithZero EReal

full_name: EReal.instPosMulMono
code: instance : PosMulMono EReal 
goal: PosMulMono EReal

full_name: EReal.instMulPosMono
code: instance : MulPosMono EReal 
goal: MulPosMono EReal

full_name: EReal.instPosMulReflectLT
code: instance : PosMulReflectLT EReal 
goal: PosMulReflectLT EReal

full_name: EReal.instMulPosReflectLT
code: instance : MulPosReflectLT EReal 
goal: MulPosReflectLT EReal

full_name: EReal.coe_pow
code: @[simp, norm_cast]
theorem coe_pow (x : ℝ) (n : ℕ) : (↑(x ^ n) : EReal) = (x : EReal) ^ n 
goal: ↑(x ^ n) = ↑x ^ n

full_name: EReal.coe_ennreal_pow
code: @[simp, norm_cast]
theorem coe_ennreal_pow (x : ℝ≥0∞) (n : ℕ) : (↑(x ^ n) : EReal) = (x : EReal) ^ n 
goal: ↑(x ^ n) = ↑x ^ n

full_name: EReal.min_neg_neg
code: lemma min_neg_neg (x y : EReal) : min (-x) (-y) = -max x y 
goal: min (-x) (-y) = -max x y

full_name: EReal.max_neg_neg
code: lemma max_neg_neg (x y : EReal) : max (-x) (-y) = -min x y 
goal: max (-x) (-y) = -min x y

full_name: EReal.inv
code: /-- Multiplicative inverse of an `EReal`. We choose `0⁻¹ = 0` to guarantee several good properties,
for instance `(a * b)⁻¹ = a⁻¹ * b⁻¹`. -/
protected def inv : EReal → EReal
  
goal: EReal → EReal

full_name: EReal.instInv
code: instance : Inv (EReal) 
goal: Inv EReal

full_name: EReal.instDivInvMonoid
code: noncomputable instance : DivInvMonoid EReal 
goal: DivInvMonoid EReal

full_name: EReal.inv_bot
code: @[simp]
lemma inv_bot : (⊥ : EReal)⁻¹ = 0 
goal: ⊥⁻¹ = 0

full_name: EReal.inv_top
code: @[simp]
lemma inv_top : (⊤ : EReal)⁻¹ = 0 
goal: ⊤⁻¹ = 0

full_name: EReal.coe_inv
code: lemma coe_inv (x : ℝ) : (x⁻¹ : ℝ) = (x : EReal)⁻¹ 
goal: ↑x⁻¹ = (↑x)⁻¹

full_name: EReal.inv_zero
code: @[simp]
lemma inv_zero : (0 : EReal)⁻¹ = 0 
goal: 0⁻¹ = 0

full_name: EReal.instDivInvOneMonoid
code: noncomputable instance : DivInvOneMonoid EReal 
goal: DivInvOneMonoid EReal

full_name: EReal.inv_neg
code: lemma inv_neg (a : EReal) : (-a)⁻¹ = -a⁻¹ 
goal: (-a)⁻¹ = -a⁻¹

full_name: EReal.inv_inv
code: lemma inv_inv {a : EReal} (h : a ≠ ⊥) (h' : a ≠ ⊤) : (a⁻¹)⁻¹ = a 
goal: a⁻¹⁻¹ = a

full_name: EReal.mul_inv
code: lemma mul_inv (a b : EReal) : (a * b)⁻¹ = a⁻¹ * b⁻¹ 
goal: (a * b)⁻¹ = a⁻¹ * b⁻¹

full_name: EReal.sign_mul_inv_abs
code: lemma sign_mul_inv_abs (a : EReal) : (sign a) * (a.abs : EReal)⁻¹ = a⁻¹ 
goal: ↑(SignType.sign a) * (↑a.abs)⁻¹ = a⁻¹

full_name: EReal.sign_mul_inv_abs'
code: lemma sign_mul_inv_abs' (a : EReal) : (sign a) * ((a.abs⁻¹ : ℝ≥0∞) : EReal) = a⁻¹ 
goal: ↑(SignType.sign a) * ↑a.abs⁻¹ = a⁻¹

full_name: EReal.inv_nonneg_of_nonneg
code: lemma inv_nonneg_of_nonneg {a : EReal} (h : 0 ≤ a) : 0 ≤ a⁻¹ 
goal: 0 ≤ a⁻¹

full_name: EReal.inv_nonpos_of_nonpos
code: lemma inv_nonpos_of_nonpos {a : EReal} (h : a ≤ 0) : a⁻¹ ≤ 0 
goal: a⁻¹ ≤ 0

full_name: EReal.inv_pos_of_pos_ne_top
code: lemma inv_pos_of_pos_ne_top {a : EReal} (h : 0 < a) (h' : a ≠ ⊤) : 0 < a⁻¹ 
goal: 0 < a⁻¹

full_name: EReal.inv_neg_of_neg_ne_bot
code: lemma inv_neg_of_neg_ne_bot {a : EReal} (h : a < 0) (h' : a ≠ ⊥) : a⁻¹ < 0 
goal: a⁻¹ < 0

full_name: EReal.div_eq_inv_mul
code: lemma div_eq_inv_mul (a b : EReal) : a / b = b⁻¹ * a 
goal: a / b = b⁻¹ * a

full_name: EReal.coe_div
code: lemma coe_div (a b : ℝ) : (a / b : ℝ) = (a : EReal) / (b : EReal) 
goal: ↑(a / b) = ↑a / ↑b

full_name: EReal.natCast_div_le
code: theorem natCast_div_le (m n : ℕ) :
    (m / n : ℕ) ≤ (m : EReal) / (n : EReal) 
goal: ↑(m / n) ≤ ↑m / ↑n

full_name: EReal.div_bot
code: @[simp]
lemma div_bot {a : EReal} : a / ⊥ = 0 
goal: a / ⊥ = 0

full_name: EReal.div_top
code: @[simp]
lemma div_top {a : EReal} : a / ⊤ = 0 
goal: a / ⊤ = 0

full_name: EReal.div_zero
code: @[simp]
lemma div_zero {a : EReal} : a / 0 = 0 
goal: a / 0 = 0

full_name: EReal.zero_div
code: @[simp]
lemma zero_div {a : EReal} : 0 / a = 0 
goal: 0 / a = 0

full_name: EReal.top_div_of_pos_ne_top
code: lemma top_div_of_pos_ne_top {a : EReal} (h : 0 < a) (h' : a ≠ ⊤) : ⊤ / a = ⊤ 
goal: ⊤ / a = ⊤

full_name: EReal.top_div_of_neg_ne_bot
code: lemma top_div_of_neg_ne_bot {a : EReal} (h : a < 0) (h' : a ≠ ⊥) : ⊤ / a = ⊥ 
goal: ⊤ / a = ⊥

full_name: EReal.bot_div_of_pos_ne_top
code: lemma bot_div_of_pos_ne_top {a : EReal} (h : 0 < a) (h' : a ≠ ⊤) : ⊥ / a = ⊥ 
goal: ⊥ / a = ⊥

full_name: EReal.bot_div_of_neg_ne_bot
code: lemma bot_div_of_neg_ne_bot {a : EReal} (h : a < 0) (h' : a ≠ ⊥) : ⊥ / a = ⊤ 
goal: ⊥ / a = ⊤

full_name: EReal.div_self
code: lemma div_self {a : EReal} (h₁ : a ≠ ⊥) (h₂ : a ≠ ⊤) (h₃ : a ≠ 0) : a / a = 1 
goal: a / a = 1

full_name: EReal.mul_div
code: lemma mul_div (a b c : EReal) : a * (b / c) = (a * b) / c 
goal: a * (b / c) = a * b / c

full_name: EReal.mul_div_right
code: lemma mul_div_right (a b c : EReal) : (a / b) * c = (a * c) / b 
goal: a / b * c = a * c / b

full_name: EReal.div_div
code: lemma div_div (a b c : EReal) : a / b / c = a / (b * c) 
goal: a / b / c = a / (b * c)

full_name: EReal.div_mul_cancel
code: lemma div_mul_cancel {a b : EReal} (h₁ : b ≠ ⊥) (h₂ : b ≠ ⊤) (h₃ : b ≠ 0) : (a / b) * b = a 
goal: a / b * b = a

full_name: EReal.mul_div_cancel
code: lemma mul_div_cancel {a b : EReal} (h₁ : b ≠ ⊥) (h₂ : b ≠ ⊤) (h₃ : b ≠ 0) : b * (a / b) = a 
goal: b * (a / b) = a

full_name: EReal.mul_div_mul_cancel
code: lemma mul_div_mul_cancel {a b c : EReal} (h₁ : c ≠ ⊥) (h₂ : c ≠ ⊤) (h₃ : c ≠ 0) :
    (a * c) / (b * c) = a / b 
goal: a * c / (b * c) = a / b

full_name: EReal.div_right_distrib_of_nonneg
code: lemma div_right_distrib_of_nonneg {a b c : EReal} (h : 0 ≤ a) (h' : 0 ≤ b) :
    (a + b) / c = (a / c) + (b / c) 
goal: (a + b) / c = a / c + b / c

full_name: EReal.monotone_div_right_of_nonneg
code: lemma monotone_div_right_of_nonneg {b : EReal} (h : 0 ≤ b) : Monotone fun a ↦ a / b 
goal: Monotone fun a => a / b

full_name: EReal.div_le_div_right_of_nonneg
code: lemma div_le_div_right_of_nonneg {a a' b : EReal} (h : 0 ≤ b) (h' : a ≤ a') :
    a / b ≤ a' / b 
goal: a / b ≤ a' / b

full_name: EReal.strictMono_div_right_of_pos
code: lemma strictMono_div_right_of_pos {b : EReal} (h : 0 < b) (h' : b ≠ ⊤) :
    StrictMono fun a ↦ a / b 
goal: StrictMono fun a => a / b

full_name: EReal.div_lt_div_right_of_pos
code: lemma div_lt_div_right_of_pos {a a' b : EReal} (h₁ : 0 < b) (h₂ : b ≠ ⊤)
    (h₃ : a < a') : a / b < a' / b 
goal: a / b < a' / b

full_name: EReal.antitone_div_right_of_nonpos
code: lemma antitone_div_right_of_nonpos {b : EReal} (h : b ≤ 0) : Antitone fun a ↦ a / b 
goal: Antitone fun a => a / b

full_name: EReal.div_le_div_right_of_nonpos
code: lemma div_le_div_right_of_nonpos {a a' b : EReal} (h : b ≤ 0) (h' : a ≤ a') :
    a' / b ≤ a / b 
goal: a' / b ≤ a / b

full_name: EReal.strictAnti_div_right_of_neg
code: lemma strictAnti_div_right_of_neg {b : EReal} (h : b < 0) (h' : b ≠ ⊥) :
    StrictAnti fun a ↦ a / b 
goal: StrictAnti fun a => a / b

full_name: EReal.div_lt_div_right_of_neg
code: lemma div_lt_div_right_of_neg {a a' b : EReal} (h₁ : b < 0) (h₂ : b ≠ ⊥)
    (h₃ : a < a') : a' / b < a / b 
goal: a' / b < a / b

full_name: EReal.le_div_iff_mul_le
code: lemma le_div_iff_mul_le {a b c : EReal} (h : b > 0) (h' : b ≠ ⊤) :
    a ≤ c / b ↔ a * b ≤ c 
goal: a ≤ c / b ↔ a * b ≤ c

full_name: EReal.div_le_iff_le_mul
code: lemma div_le_iff_le_mul {a b c : EReal} (h : 0 < b) (h' : b ≠ ⊤) :
    a / b ≤ c ↔ a ≤ b * c 
goal: a / b ≤ c ↔ a ≤ b * c

full_name: EReal.div_nonneg
code: lemma div_nonneg {a b : EReal} (h : 0 ≤ a) (h' : 0 ≤ b) : 0 ≤ a / b 
goal: 0 ≤ a / b

full_name: EReal.div_nonpos_of_nonpos_of_nonneg
code: lemma div_nonpos_of_nonpos_of_nonneg {a b : EReal} (h : a ≤ 0) (h' : 0 ≤ b) : a / b ≤ 0 
goal: a / b ≤ 0

full_name: EReal.div_nonpos_of_nonneg_of_nonpos
code: lemma div_nonpos_of_nonneg_of_nonpos {a b : EReal} (h : 0 ≤ a) (h' : b ≤ 0) : a / b ≤ 0 
goal: a / b ≤ 0

full_name: EReal.div_nonneg_of_nonpos_of_nonpos
code: lemma div_nonneg_of_nonpos_of_nonpos {a b : EReal} (h : a ≤ 0) (h' : b ≤ 0) : 0 ≤ a / b 
goal: 0 ≤ a / b