File: Mathlib/Data/ENNReal/Basic.lean

full_name: ENNReal
code: /-- The extended nonnegative real numbers. This is usually denoted [0, ∞],
  and is relevant as the codomain of a measure. -/
def ENNReal 
goal: Type

full_name: ENNReal._aux_Mathlib_Data_ENNReal_Basic___unexpand_ENNReal_1
code: @[inherit_doc]
scoped[ENNReal] notation "ℝ≥0∞" => ENNReal
goal: Lean.PrettyPrinter.Unexpander

full_name: ENNReal.«_aux_Mathlib_Data_ENNReal_Basic___macroRules_ENNReal_termℝ≥0∞_1»
code: @[inherit_doc]
scoped[ENNReal] notation "ℝ≥0∞" => ENNReal
goal: Lean.Macro

full_name: ENNReal.«_aux_Mathlib_Data_ENNReal_Basic___macroRules_ENNReal_term∞_1»
code: /-- Notation for infinity as an `ENNReal` number. -/
scoped[ENNReal] notation "∞" => (⊤ : ENNReal)
goal: Lean.Macro

full_name: ENNReal.instOrderBot
code: instance : OrderBot ℝ≥0∞ 
goal: OrderBot ℝ≥0∞

full_name: ENNReal.instBoundedOrder
code: instance : BoundedOrder ℝ≥0∞ 
goal: BoundedOrder ℝ≥0∞

full_name: ENNReal.instCharZero
code: instance : CharZero ℝ≥0∞ 
goal: CharZero ℝ≥0∞

full_name: ENNReal.instCanonicallyOrderedCommSemiring
code: noncomputable instance : CanonicallyOrderedCommSemiring ℝ≥0∞ 
goal: CanonicallyOrderedCommSemiring ℝ≥0∞

full_name: ENNReal.instCompleteLinearOrder
code: noncomputable instance : CompleteLinearOrder ℝ≥0∞ 
goal: CompleteLinearOrder ℝ≥0∞

full_name: ENNReal.instDenselyOrdered
code: instance : DenselyOrdered ℝ≥0∞ 
goal: DenselyOrdered ℝ≥0∞

full_name: ENNReal.instCanonicallyLinearOrderedAddCommMonoid
code: noncomputable instance : CanonicallyLinearOrderedAddCommMonoid ℝ≥0∞ 
goal: CanonicallyLinearOrderedAddCommMonoid ℝ≥0∞

full_name: ENNReal.instSub
code: noncomputable instance instSub : Sub ℝ≥0∞ 
goal: Sub ℝ≥0∞

full_name: ENNReal.instOrderedSub
code: noncomputable instance : OrderedSub ℝ≥0∞ 
goal: OrderedSub ℝ≥0∞

full_name: ENNReal.instLinearOrderedAddCommMonoidWithTop
code: noncomputable instance : LinearOrderedAddCommMonoidWithTop ℝ≥0∞ 
goal: LinearOrderedAddCommMonoidWithTop ℝ≥0∞

full_name: ENNReal.instInv
code: noncomputable instance : Inv ℝ≥0∞ 
goal: Inv ℝ≥0∞

full_name: ENNReal.instDivInvMonoid
code: noncomputable instance : DivInvMonoid ℝ≥0∞ 
goal: DivInvMonoid ℝ≥0∞

full_name: ENNReal.covariantClass_mul_le
code: instance covariantClass_mul_le : CovariantClass ℝ≥0∞ ℝ≥0∞ (· * ·) (· ≤ ·) 
goal: CovariantClass ℝ≥0∞ ℝ≥0∞ (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1

full_name: ENNReal.covariantClass_add_le
code: instance covariantClass_add_le : CovariantClass ℝ≥0∞ ℝ≥0∞ (· + ·) (· ≤ ·) 
goal: CovariantClass ℝ≥0∞ ℝ≥0∞ (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1

full_name: ENNReal.instLinearOrderedCommMonoidWithZero
code: noncomputable instance : LinearOrderedCommMonoidWithZero ℝ≥0∞ 
goal: LinearOrderedCommMonoidWithZero ℝ≥0∞

full_name: ENNReal.instUniqueAddUnits
code: noncomputable instance : Unique (AddUnits ℝ≥0∞) 
goal: Unique (AddUnits ℝ≥0∞)

full_name: ENNReal.instInhabited
code: instance : Inhabited ℝ≥0∞ 
goal: Inhabited ℝ≥0∞

full_name: ENNReal.ofNNReal
code: /-- Coercion from `ℝ≥0` to `ℝ≥0∞`. -/
@[coe, match_pattern] def ofNNReal : ℝ≥0 → ℝ≥0∞ 
goal: ℝ≥0 → ℝ≥0∞

full_name: ENNReal.instCoeNNReal
code: instance : Coe ℝ≥0 ℝ≥0∞ 
goal: Coe ℝ≥0 ℝ≥0∞

full_name: ENNReal.recTopCoe
code: /-- A version of `WithTop.recTopCoe` that uses `ENNReal.ofNNReal`. -/
@[elab_as_elim, induction_eliminator, cases_eliminator]
def recTopCoe {C : ℝ≥0∞ → Sort*} (top : C ∞) (coe : ∀ x : ℝ≥0, C x) (x : ℝ≥0∞) : C x 
goal: C x

full_name: ENNReal.canLift
code: instance canLift : CanLift ℝ≥0∞ ℝ≥0 ofNNReal (· ≠ ∞) 
goal: CanLift ℝ≥0∞ ℝ≥0 ENNReal.ofNNReal fun x => x ≠ ⊤

full_name: ENNReal.none_eq_top
code: @[simp] theorem none_eq_top : (none : ℝ≥0∞) = ∞ 
goal: none = ⊤

full_name: ENNReal.some_eq_coe
code: @[simp] theorem some_eq_coe (a : ℝ≥0) : (Option.some a : ℝ≥0∞) = (↑a : ℝ≥0∞) 
goal: some a = ↑a

full_name: ENNReal.some_eq_coe'
code: @[simp] theorem some_eq_coe' (a : ℝ≥0) : (WithTop.some a : ℝ≥0∞) = (↑a : ℝ≥0∞) 
goal: ↑a = ↑a

full_name: ENNReal.coe_injective
code: lemma coe_injective : Injective ((↑) : ℝ≥0 → ℝ≥0∞) 
goal: Function.Injective ENNReal.ofNNReal

full_name: ENNReal.coe_inj
code: @[simp, norm_cast] lemma coe_inj : (p : ℝ≥0∞) = q ↔ p = q 
goal: ↑p = ↑q ↔ p = q

full_name: ENNReal.coe_ne_coe
code: lemma coe_ne_coe : (p : ℝ≥0∞) ≠ q ↔ p ≠ q 
goal: ↑p ≠ ↑q ↔ p ≠ q

full_name: ENNReal.range_coe'
code: theorem range_coe' : range ofNNReal = Iio ∞ 
goal: Set.range ENNReal.ofNNReal = Set.Iio ⊤

full_name: ENNReal.range_coe
code: theorem range_coe : range ofNNReal = {∞}ᶜ 
goal: Set.range ENNReal.ofNNReal = {⊤}ᶜ

full_name: ENNReal.toNNReal
code: /-- `toNNReal x` returns `x` if it is real, otherwise 0. -/
protected def toNNReal : ℝ≥0∞ → ℝ≥0 
goal: ℝ≥0∞ → ℝ≥0

full_name: ENNReal.toReal
code: /-- `toReal x` returns `x` if it is real, `0` otherwise. -/
protected def toReal (a : ℝ≥0∞) : Real 
goal: ℝ

full_name: ENNReal.ofReal
code: /-- `ofReal x` returns `x` if it is nonnegative, `0` otherwise. -/
protected noncomputable def ofReal (r : Real) : ℝ≥0∞ 
goal: ℝ≥0∞

full_name: ENNReal.toNNReal_coe
code: @[simp, norm_cast]
theorem toNNReal_coe : (r : ℝ≥0∞).toNNReal = r 
goal: (↑r).toNNReal = r

full_name: ENNReal.coe_toNNReal
code: @[simp]
theorem coe_toNNReal : ∀ {a : ℝ≥0∞}, a ≠ ∞ → ↑a.toNNReal = a
  
goal: a ≠ ⊤ → ↑a.toNNReal = a

full_name: ENNReal.ofReal_toReal
code: @[simp]
theorem ofReal_toReal {a : ℝ≥0∞} (h : a ≠ ∞) : ENNReal.ofReal a.toReal = a 
goal: ENNReal.ofReal a.toReal = a

full_name: ENNReal.toReal_ofReal
code: @[simp]
theorem toReal_ofReal {r : ℝ} (h : 0 ≤ r) : (ENNReal.ofReal r).toReal = r 
goal: (ENNReal.ofReal r).toReal = r

full_name: ENNReal.toReal_ofReal'
code: theorem toReal_ofReal' {r : ℝ} : (ENNReal.ofReal r).toReal = max r 0 
goal: (ENNReal.ofReal r).toReal = max r 0

full_name: ENNReal.coe_toNNReal_le_self
code: theorem coe_toNNReal_le_self : ∀ {a : ℝ≥0∞}, ↑a.toNNReal ≤ a
  
goal: ↑a.toNNReal ≤ a

full_name: ENNReal.coe_nnreal_eq
code: theorem coe_nnreal_eq (r : ℝ≥0) : (r : ℝ≥0∞) = ENNReal.ofReal r 
goal: ↑r = ENNReal.ofReal ↑r

full_name: ENNReal.ofReal_eq_coe_nnreal
code: theorem ofReal_eq_coe_nnreal {x : ℝ} (h : 0 ≤ x) :
    ENNReal.ofReal x = ofNNReal ⟨x, h⟩ 
goal: ENNReal.ofReal x = ↑⟨x, h⟩

full_name: ENNReal.ofReal_coe_nnreal
code: @[simp] theorem ofReal_coe_nnreal : ENNReal.ofReal p = p 
goal: ENNReal.ofReal ↑p = ↑p

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

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

full_name: ENNReal.toReal_nonneg
code: @[simp] theorem toReal_nonneg {a : ℝ≥0∞} : 0 ≤ a.toReal 
goal: 0 ≤ a.toReal

full_name: ENNReal.top_toNNReal
code: @[simp] theorem top_toNNReal : ∞.toNNReal = 0 
goal: ⊤.toNNReal = 0

full_name: ENNReal.top_toReal
code: @[simp] theorem top_toReal : ∞.toReal = 0 
goal: ⊤.toReal = 0

full_name: ENNReal.one_toReal
code: @[simp] theorem one_toReal : (1 : ℝ≥0∞).toReal = 1 
goal: ENNReal.toReal 1 = 1

full_name: ENNReal.one_toNNReal
code: @[simp] theorem one_toNNReal : (1 : ℝ≥0∞).toNNReal = 1 
goal: ENNReal.toNNReal 1 = 1

full_name: ENNReal.coe_toReal
code: @[simp] theorem coe_toReal (r : ℝ≥0) : (r : ℝ≥0∞).toReal = r 
goal: (↑r).toReal = ↑r

full_name: ENNReal.zero_toNNReal
code: @[simp] theorem zero_toNNReal : (0 : ℝ≥0∞).toNNReal = 0 
goal: ENNReal.toNNReal 0 = 0

full_name: ENNReal.zero_toReal
code: @[simp] theorem zero_toReal : (0 : ℝ≥0∞).toReal = 0 
goal: ENNReal.toReal 0 = 0

full_name: ENNReal.ofReal_zero
code: @[simp] theorem ofReal_zero : ENNReal.ofReal (0 : ℝ) = 0 
goal: ENNReal.ofReal 0 = 0

full_name: ENNReal.ofReal_one
code: @[simp] theorem ofReal_one : ENNReal.ofReal (1 : ℝ) = (1 : ℝ≥0∞) 
goal: ENNReal.ofReal 1 = 1

full_name: ENNReal.ofReal_toReal_le
code: theorem ofReal_toReal_le {a : ℝ≥0∞} : ENNReal.ofReal a.toReal ≤ a 
goal: ENNReal.ofReal a.toReal ≤ a

full_name: ENNReal.forall_ennreal
code: theorem forall_ennreal {p : ℝ≥0∞ → Prop} : (∀ a, p a) ↔ (∀ r : ℝ≥0, p r) ∧ p ∞ 
goal: (∀ (a : ℝ≥0∞), p a) ↔ (∀ (r : ℝ≥0), p ↑r) ∧ p ⊤

full_name: ENNReal.forall_ne_top
code: theorem forall_ne_top {p : ℝ≥0∞ → Prop} : (∀ a, a ≠ ∞ → p a) ↔ ∀ r : ℝ≥0, p r 
goal: (∀ (a : ℝ≥0∞), a ≠ ⊤ → p a) ↔ ∀ (r : ℝ≥0), p ↑r

full_name: ENNReal.exists_ne_top
code: theorem exists_ne_top {p : ℝ≥0∞ → Prop} : (∃ a ≠ ∞, p a) ↔ ∃ r : ℝ≥0, p r 
goal: (∃ a, a ≠ ⊤ ∧ p a) ↔ ∃ r, p ↑r

full_name: ENNReal.toNNReal_eq_zero_iff
code: theorem toNNReal_eq_zero_iff (x : ℝ≥0∞) : x.toNNReal = 0 ↔ x = 0 ∨ x = ∞ 
goal: x.toNNReal = 0 ↔ x = 0 ∨ x = ⊤

full_name: ENNReal.toReal_eq_zero_iff
code: theorem toReal_eq_zero_iff (x : ℝ≥0∞) : x.toReal = 0 ↔ x = 0 ∨ x = ∞ 
goal: x.toReal = 0 ↔ x = 0 ∨ x = ⊤

full_name: ENNReal.toNNReal_ne_zero
code: theorem toNNReal_ne_zero : a.toNNReal ≠ 0 ↔ a ≠ 0 ∧ a ≠ ∞ 
goal: a.toNNReal ≠ 0 ↔ a ≠ 0 ∧ a ≠ ⊤

full_name: ENNReal.toReal_ne_zero
code: theorem toReal_ne_zero : a.toReal ≠ 0 ↔ a ≠ 0 ∧ a ≠ ∞ 
goal: a.toReal ≠ 0 ↔ a ≠ 0 ∧ a ≠ ⊤

full_name: ENNReal.toNNReal_eq_one_iff
code: theorem toNNReal_eq_one_iff (x : ℝ≥0∞) : x.toNNReal = 1 ↔ x = 1 
goal: x.toNNReal = 1 ↔ x = 1

full_name: ENNReal.toReal_eq_one_iff
code: theorem toReal_eq_one_iff (x : ℝ≥0∞) : x.toReal = 1 ↔ x = 1 
goal: x.toReal = 1 ↔ x = 1

full_name: ENNReal.toNNReal_ne_one
code: theorem toNNReal_ne_one : a.toNNReal ≠ 1 ↔ a ≠ 1 
goal: a.toNNReal ≠ 1 ↔ a ≠ 1

full_name: ENNReal.toReal_ne_one
code: theorem toReal_ne_one : a.toReal ≠ 1 ↔ a ≠ 1 
goal: a.toReal ≠ 1 ↔ a ≠ 1

full_name: ENNReal.coe_ne_top
code: @[simp] theorem coe_ne_top : (r : ℝ≥0∞) ≠ ∞ 
goal: ↑r ≠ ⊤

full_name: ENNReal.top_ne_coe
code: @[simp] theorem top_ne_coe : ∞ ≠ (r : ℝ≥0∞) 
goal: ⊤ ≠ ↑r

full_name: ENNReal.coe_lt_top
code: @[simp] theorem coe_lt_top : (r : ℝ≥0∞) < ∞ 
goal: ↑r < ⊤

full_name: ENNReal.ofReal_ne_top
code: @[simp] theorem ofReal_ne_top {r : ℝ} : ENNReal.ofReal r ≠ ∞ 
goal: ENNReal.ofReal r ≠ ⊤

full_name: ENNReal.ofReal_lt_top
code: @[simp] theorem ofReal_lt_top {r : ℝ} : ENNReal.ofReal r < ∞ 
goal: ENNReal.ofReal r < ⊤

full_name: ENNReal.top_ne_ofReal
code: @[simp] theorem top_ne_ofReal {r : ℝ} : ∞ ≠ ENNReal.ofReal r 
goal: ⊤ ≠ ENNReal.ofReal r

full_name: ENNReal.ofReal_toReal_eq_iff
code: @[simp]
theorem ofReal_toReal_eq_iff : ENNReal.ofReal a.toReal = a ↔ a ≠ ⊤ 
goal: ENNReal.ofReal a.toReal = a ↔ a ≠ ⊤

full_name: ENNReal.toReal_ofReal_eq_iff
code: @[simp]
theorem toReal_ofReal_eq_iff {a : ℝ} : (ENNReal.ofReal a).toReal = a ↔ 0 ≤ a 
goal: (ENNReal.ofReal a).toReal = a ↔ 0 ≤ a

full_name: ENNReal.zero_ne_top
code: @[simp] theorem zero_ne_top : 0 ≠ ∞ 
goal: 0 ≠ ⊤

full_name: ENNReal.top_ne_zero
code: @[simp] theorem top_ne_zero : ∞ ≠ 0 
goal: ⊤ ≠ 0

full_name: ENNReal.one_ne_top
code: @[simp] theorem one_ne_top : 1 ≠ ∞ 
goal: 1 ≠ ⊤

full_name: ENNReal.top_ne_one
code: @[simp] theorem top_ne_one : ∞ ≠ 1 
goal: ⊤ ≠ 1

full_name: ENNReal.zero_lt_top
code: @[simp] theorem zero_lt_top : 0 < ∞ 
goal: 0 < ⊤

full_name: ENNReal.coe_le_coe
code: @[simp, norm_cast] theorem coe_le_coe : (↑r : ℝ≥0∞) ≤ ↑q ↔ r ≤ q 
goal: ↑r ≤ ↑q ↔ r ≤ q

full_name: ENNReal.coe_lt_coe
code: @[simp, norm_cast] theorem coe_lt_coe : (↑r : ℝ≥0∞) < ↑q ↔ r < q 
goal: ↑r < ↑q ↔ r < q

full_name: ENNReal.coe_mono
code: theorem coe_mono : Monotone ofNNReal 
goal: Monotone ENNReal.ofNNReal

full_name: ENNReal.coe_strictMono
code: theorem coe_strictMono : StrictMono ofNNReal 
goal: StrictMono ENNReal.ofNNReal

full_name: ENNReal.coe_eq_zero
code: @[simp, norm_cast] theorem coe_eq_zero : (↑r : ℝ≥0∞) = 0 ↔ r = 0 
goal: ↑r = 0 ↔ r = 0

full_name: ENNReal.zero_eq_coe
code: @[simp, norm_cast] theorem zero_eq_coe : 0 = (↑r : ℝ≥0∞) ↔ 0 = r 
goal: 0 = ↑r ↔ 0 = r

full_name: ENNReal.coe_eq_one
code: @[simp, norm_cast] theorem coe_eq_one : (↑r : ℝ≥0∞) = 1 ↔ r = 1 
goal: ↑r = 1 ↔ r = 1

full_name: ENNReal.one_eq_coe
code: @[simp, norm_cast] theorem one_eq_coe : 1 = (↑r : ℝ≥0∞) ↔ 1 = r 
goal: 1 = ↑r ↔ 1 = r

full_name: ENNReal.coe_pos
code: @[simp, norm_cast] theorem coe_pos : 0 < (r : ℝ≥0∞) ↔ 0 < r 
goal: 0 < ↑r ↔ 0 < r

full_name: ENNReal.coe_ne_zero
code: theorem coe_ne_zero : (r : ℝ≥0∞) ≠ 0 ↔ r ≠ 0 
goal: ↑r ≠ 0 ↔ r ≠ 0

full_name: ENNReal.coe_ne_one
code: lemma coe_ne_one : (r : ℝ≥0∞) ≠ 1 ↔ r ≠ 1 
goal: ↑r ≠ 1 ↔ r ≠ 1

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

full_name: ENNReal.coe_mul
code: @[simp, norm_cast] lemma coe_mul (x y : ℝ≥0) : (↑(x * y) : ℝ≥0∞) = x * y 
goal: ↑(x * y) = ↑x * ↑y

full_name: ENNReal.coe_nsmul
code: @[norm_cast] lemma coe_nsmul (n : ℕ) (x : ℝ≥0) : (↑(n • x) : ℝ≥0∞) = n • x 
goal: ↑(n • x) = n • ↑x

full_name: ENNReal.coe_pow
code: @[simp, norm_cast] lemma coe_pow (x : ℝ≥0) (n : ℕ) : (↑(x ^ n) : ℝ≥0∞) = x ^ n 
goal: ↑(x ^ n) = ↑x ^ n

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

full_name: ENNReal.coe_two
code: theorem coe_two : ((2 : ℝ≥0) : ℝ≥0∞) = 2 
goal: ↑2 = 2

full_name: ENNReal.toNNReal_eq_toNNReal_iff
code: theorem toNNReal_eq_toNNReal_iff (x y : ℝ≥0∞) :
    x.toNNReal = y.toNNReal ↔ x = y ∨ x = 0 ∧ y = ⊤ ∨ x = ⊤ ∧ y = 0 
goal: x.toNNReal = y.toNNReal ↔ x = y ∨ x = 0 ∧ y = ⊤ ∨ x = ⊤ ∧ y = 0

full_name: ENNReal.toReal_eq_toReal_iff
code: theorem toReal_eq_toReal_iff (x y : ℝ≥0∞) :
    x.toReal = y.toReal ↔ x = y ∨ x = 0 ∧ y = ⊤ ∨ x = ⊤ ∧ y = 0 
goal: x.toReal = y.toReal ↔ x = y ∨ x = 0 ∧ y = ⊤ ∨ x = ⊤ ∧ y = 0

full_name: ENNReal.toNNReal_eq_toNNReal_iff'
code: theorem toNNReal_eq_toNNReal_iff' {x y : ℝ≥0∞} (hx : x ≠ ⊤) (hy : y ≠ ⊤) :
    x.toNNReal = y.toNNReal ↔ x = y 
goal: x.toNNReal = y.toNNReal ↔ x = y

full_name: ENNReal.toReal_eq_toReal_iff'
code: theorem toReal_eq_toReal_iff' {x y : ℝ≥0∞} (hx : x ≠ ⊤) (hy : y ≠ ⊤) :
    x.toReal = y.toReal ↔ x = y 
goal: x.toReal = y.toReal ↔ x = y

full_name: ENNReal.one_lt_two
code: theorem one_lt_two : (1 : ℝ≥0∞) < 2 
goal: 1 < 2

full_name: ENNReal.two_ne_top
code: @[simp] theorem two_ne_top : (2 : ℝ≥0∞) ≠ ∞ 
goal: 2 ≠ ⊤

full_name: ENNReal.two_lt_top
code: @[simp] theorem two_lt_top : (2 : ℝ≥0∞) < ∞ 
goal: 2 < ⊤

full_name: fact_one_le_one_ennreal
code: /-- `(1 : ℝ≥0∞) ≤ 1`, recorded as a `Fact` for use with `Lp` spaces. -/
instance _root_.fact_one_le_one_ennreal : Fact ((1 : ℝ≥0∞) ≤ 1) 
goal: Fact (1 ≤ 1)

full_name: fact_one_le_two_ennreal
code: /-- `(1 : ℝ≥0∞) ≤ 2`, recorded as a `Fact` for use with `Lp` spaces. -/
instance _root_.fact_one_le_two_ennreal : Fact ((1 : ℝ≥0∞) ≤ 2) 
goal: Fact (1 ≤ 2)

full_name: fact_one_le_top_ennreal
code: /-- `(1 : ℝ≥0∞) ≤ ∞`, recorded as a `Fact` for use with `Lp` spaces. -/
instance _root_.fact_one_le_top_ennreal : Fact ((1 : ℝ≥0∞) ≤ ∞) 
goal: Fact (1 ≤ ⊤)

full_name: ENNReal.neTopEquivNNReal
code: /-- The set of numbers in `ℝ≥0∞` that are not equal to `∞` is equivalent to `ℝ≥0`. -/
def neTopEquivNNReal : { a | a ≠ ∞ } ≃ ℝ≥0 
goal: ↑{a | a ≠ ⊤} ≃ ℝ≥0

full_name: ENNReal.cinfi_ne_top
code: theorem cinfi_ne_top [InfSet α] (f : ℝ≥0∞ → α) : ⨅ x : { x // x ≠ ∞ }, f x = ⨅ x : ℝ≥0, f x 
goal: ⨅ x, f ↑x = ⨅ x, f ↑x

full_name: ENNReal.iInf_ne_top
code: theorem iInf_ne_top [CompleteLattice α] (f : ℝ≥0∞ → α) :
    ⨅ (x) (_ : x ≠ ∞), f x = ⨅ x : ℝ≥0, f x 
goal: ⨅ x, ⨅ (_ : x ≠ ⊤), f x = ⨅ x, f ↑x

full_name: ENNReal.csupr_ne_top
code: theorem csupr_ne_top [SupSet α] (f : ℝ≥0∞ → α) : ⨆ x : { x // x ≠ ∞ }, f x = ⨆ x : ℝ≥0, f x 
goal: ⨆ x, f ↑x = ⨆ x, f ↑x

full_name: ENNReal.iSup_ne_top
code: theorem iSup_ne_top [CompleteLattice α] (f : ℝ≥0∞ → α) :
    ⨆ (x) (_ : x ≠ ∞), f x = ⨆ x : ℝ≥0, f x 
goal: ⨆ x, ⨆ (_ : x ≠ ⊤), f x = ⨆ x, f ↑x

full_name: ENNReal.iInf_ennreal
code: theorem iInf_ennreal {α : Type*} [CompleteLattice α] {f : ℝ≥0∞ → α} :
    ⨅ n, f n = (⨅ n : ℝ≥0, f n) ⊓ f ∞ 
goal: ⨅ n, f n = (⨅ n, f ↑n) ⊓ f ⊤

full_name: ENNReal.iSup_ennreal
code: theorem iSup_ennreal {α : Type*} [CompleteLattice α] {f : ℝ≥0∞ → α} :
    ⨆ n, f n = (⨆ n : ℝ≥0, f n) ⊔ f ∞ 
goal: ⨆ n, f n = (⨆ n, f ↑n) ⊔ f ⊤

full_name: ENNReal.ofNNRealHom
code: /-- Coercion `ℝ≥0 → ℝ≥0∞` as a `RingHom`. -/
def ofNNRealHom : ℝ≥0 →+* ℝ≥0∞ 
goal: ℝ≥0 →+* ℝ≥0∞

full_name: ENNReal.coe_ofNNRealHom
code: @[simp] theorem coe_ofNNRealHom : ⇑ofNNRealHom = some 
goal: ⇑ENNReal.ofNNRealHom = some

full_name: ENNReal.coe_indicator
code: @[simp, norm_cast]
theorem coe_indicator {α} (s : Set α) (f : α → ℝ≥0) (a : α) :
    ((s.indicator f a : ℝ≥0) : ℝ≥0∞) = s.indicator (fun x => ↑(f x)) a 
goal: ↑(s.indicator f a) = s.indicator (fun x => ↑(f x)) a

full_name: ENNReal.bot_eq_zero
code: theorem bot_eq_zero : (⊥ : ℝ≥0∞) = 0 
goal: ⊥ = 0

full_name: ENNReal.not_top_le_coe
code: theorem not_top_le_coe : ¬∞ ≤ ↑r 
goal: ¬⊤ ≤ ↑r

full_name: ENNReal.one_le_coe_iff
code: @[simp, norm_cast]
theorem one_le_coe_iff : (1 : ℝ≥0∞) ≤ ↑r ↔ 1 ≤ r 
goal: 1 ≤ ↑r ↔ 1 ≤ r

full_name: ENNReal.coe_le_one_iff
code: @[simp, norm_cast]
theorem coe_le_one_iff : ↑r ≤ (1 : ℝ≥0∞) ↔ r ≤ 1 
goal: ↑r ≤ 1 ↔ r ≤ 1

full_name: ENNReal.coe_lt_one_iff
code: @[simp, norm_cast]
theorem coe_lt_one_iff : (↑p : ℝ≥0∞) < 1 ↔ p < 1 
goal: ↑p < 1 ↔ p < 1

full_name: ENNReal.one_lt_coe_iff
code: @[simp, norm_cast]
theorem one_lt_coe_iff : 1 < (↑p : ℝ≥0∞) ↔ 1 < p 
goal: 1 < ↑p ↔ 1 < p

full_name: ENNReal.coe_natCast
code: @[simp, norm_cast]
theorem coe_natCast (n : ℕ) : ((n : ℝ≥0) : ℝ≥0∞) = n 
goal: ↑↑n = ↑n

full_name: ENNReal.ofReal_natCast
code: @[simp, norm_cast] lemma ofReal_natCast (n : ℕ) : ENNReal.ofReal n = n 
goal: ENNReal.ofReal ↑n = ↑n

full_name: ENNReal.ofReal_ofNat
code: @[simp] theorem ofReal_ofNat (n : ℕ) [n.AtLeastTwo] :
    ENNReal.ofReal (no_index (OfNat.ofNat n)) = OfNat.ofNat n 
goal: ENNReal.ofReal (OfNat.ofNat n) = OfNat.ofNat n

full_name: ENNReal.natCast_ne_top
code: @[simp] theorem natCast_ne_top (n : ℕ) : (n : ℝ≥0∞) ≠ ∞ 
goal: ↑n ≠ ⊤

full_name: ENNReal.top_ne_natCast
code: @[simp] theorem top_ne_natCast (n : ℕ) : ∞ ≠ n 
goal: ⊤ ≠ ↑n

full_name: ENNReal.one_lt_top
code: @[simp] theorem one_lt_top : 1 < ∞ 
goal: 1 < ⊤

full_name: ENNReal.toNNReal_nat
code: @[simp, norm_cast]
theorem toNNReal_nat (n : ℕ) : (n : ℝ≥0∞).toNNReal = n 
goal: (↑n).toNNReal = ↑n

full_name: ENNReal.toReal_nat
code: @[simp, norm_cast]
theorem toReal_nat (n : ℕ) : (n : ℝ≥0∞).toReal = n 
goal: (↑n).toReal = ↑n

full_name: ENNReal.toReal_ofNat
code: @[simp] theorem toReal_ofNat (n : ℕ) [n.AtLeastTwo] :
    ENNReal.toReal (no_index (OfNat.ofNat n)) = OfNat.ofNat n 
goal: (OfNat.ofNat n).toReal = OfNat.ofNat n

full_name: ENNReal.le_coe_iff
code: theorem le_coe_iff : a ≤ ↑r ↔ ∃ p : ℝ≥0, a = p ∧ p ≤ r 
goal: a ≤ ↑r ↔ ∃ p, a = ↑p ∧ p ≤ r

full_name: ENNReal.coe_le_iff
code: theorem coe_le_iff : ↑r ≤ a ↔ ∀ p : ℝ≥0, a = p → r ≤ p 
goal: ↑r ≤ a ↔ ∀ (p : ℝ≥0), a = ↑p → r ≤ p

full_name: ENNReal.lt_iff_exists_coe
code: theorem lt_iff_exists_coe : a < b ↔ ∃ p : ℝ≥0, a = p ∧ ↑p < b 
goal: a < b ↔ ∃ p, a = ↑p ∧ ↑p < b

full_name: ENNReal.toReal_le_coe_of_le_coe
code: theorem toReal_le_coe_of_le_coe {a : ℝ≥0∞} {b : ℝ≥0} (h : a ≤ b) : a.toReal ≤ b 
goal: a.toReal ≤ ↑b

full_name: ENNReal.coe_finset_sup
code: @[simp, norm_cast]
theorem coe_finset_sup {s : Finset α} {f : α → ℝ≥0} : ↑(s.sup f) = s.sup fun x => (f x : ℝ≥0∞) 
goal: ↑(s.sup f) = s.sup fun x => ↑(f x)

full_name: ENNReal.max_eq_zero_iff
code: @[simp] theorem max_eq_zero_iff : max a b = 0 ↔ a = 0 ∧ b = 0 
goal: max a b = 0 ↔ a = 0 ∧ b = 0

full_name: ENNReal.max_zero_left
code: theorem max_zero_left : max 0 a = a 
goal: max 0 a = a

full_name: ENNReal.max_zero_right
code: theorem max_zero_right : max a 0 = a 
goal: max a 0 = a

full_name: ENNReal.sup_eq_max
code: @[simp] theorem sup_eq_max : a ⊔ b = max a b 
goal: a ⊔ b = max a b

full_name: ENNReal.lt_iff_exists_rat_btwn
code: theorem lt_iff_exists_rat_btwn :
    a < b ↔ ∃ q : ℚ, 0 ≤ q ∧ a < Real.toNNReal q ∧ (Real.toNNReal q : ℝ≥0∞) < b 
goal: a < b ↔ ∃ q, 0 ≤ q ∧ a < ↑(↑q).toNNReal ∧ ↑(↑q).toNNReal < b

full_name: ENNReal.lt_iff_exists_real_btwn
code: theorem lt_iff_exists_real_btwn :
    a < b ↔ ∃ r : ℝ, 0 ≤ r ∧ a < ENNReal.ofReal r ∧ (ENNReal.ofReal r : ℝ≥0∞) < b 
goal: a < b ↔ ∃ r, 0 ≤ r ∧ a < ENNReal.ofReal r ∧ ENNReal.ofReal r < b

full_name: ENNReal.lt_iff_exists_nnreal_btwn
code: theorem lt_iff_exists_nnreal_btwn : a < b ↔ ∃ r : ℝ≥0, a < r ∧ (r : ℝ≥0∞) < b 
goal: a < b ↔ ∃ r, a < ↑r ∧ ↑r < b

full_name: ENNReal.lt_iff_exists_add_pos_lt
code: theorem lt_iff_exists_add_pos_lt : a < b ↔ ∃ r : ℝ≥0, 0 < r ∧ a + r < b 
goal: a < b ↔ ∃ r, 0 < r ∧ a + ↑r < b

full_name: ENNReal.le_of_forall_pos_le_add
code: theorem le_of_forall_pos_le_add (h : ∀ ε : ℝ≥0, 0 < ε → b < ∞ → a ≤ b + ε) : a ≤ b 
goal: a ≤ b

full_name: ENNReal.natCast_lt_coe
code: theorem natCast_lt_coe {n : ℕ} : n < (r : ℝ≥0∞) ↔ n < r 
goal: ↑n < ↑r ↔ ↑n < r

full_name: ENNReal.coe_lt_natCast
code: theorem coe_lt_natCast {n : ℕ} : (r : ℝ≥0∞) < n ↔ r < n 
goal: ↑r < ↑n ↔ r < ↑n

full_name: ENNReal.exists_nat_gt
code: protected theorem exists_nat_gt {r : ℝ≥0∞} (h : r ≠ ∞) : ∃ n : ℕ, r < n 
goal: ∃ n, r < ↑n

full_name: ENNReal.iUnion_Iio_coe_nat
code: @[simp]
theorem iUnion_Iio_coe_nat : ⋃ n : ℕ, Iio (n : ℝ≥0∞) = {∞}ᶜ 
goal: ⋃ n, Set.Iio ↑n = {⊤}ᶜ

full_name: ENNReal.iUnion_Iic_coe_nat
code: @[simp]
theorem iUnion_Iic_coe_nat : ⋃ n : ℕ, Iic (n : ℝ≥0∞) = {∞}ᶜ 
goal: ⋃ n, Set.Iic ↑n = {⊤}ᶜ

full_name: ENNReal.iUnion_Ioc_coe_nat
code: @[simp]
theorem iUnion_Ioc_coe_nat : ⋃ n : ℕ, Ioc a n = Ioi a \ {∞} 
goal: ⋃ n, Set.Ioc a ↑n = Set.Ioi a \ {⊤}

full_name: ENNReal.iUnion_Ioo_coe_nat
code: @[simp]
theorem iUnion_Ioo_coe_nat : ⋃ n : ℕ, Ioo a n = Ioi a \ {∞} 
goal: ⋃ n, Set.Ioo a ↑n = Set.Ioi a \ {⊤}

full_name: ENNReal.iUnion_Icc_coe_nat
code: @[simp]
theorem iUnion_Icc_coe_nat : ⋃ n : ℕ, Icc a n = Ici a \ {∞} 
goal: ⋃ n, Set.Icc a ↑n = Set.Ici a \ {⊤}

full_name: ENNReal.iUnion_Ico_coe_nat
code: @[simp]
theorem iUnion_Ico_coe_nat : ⋃ n : ℕ, Ico a n = Ici a \ {∞} 
goal: ⋃ n, Set.Ico a ↑n = Set.Ici a \ {⊤}

full_name: ENNReal.iInter_Ici_coe_nat
code: @[simp]
theorem iInter_Ici_coe_nat : ⋂ n : ℕ, Ici (n : ℝ≥0∞) = {∞} 
goal: ⋂ n, Set.Ici ↑n = {⊤}

full_name: ENNReal.iInter_Ioi_coe_nat
code: @[simp]
theorem iInter_Ioi_coe_nat : ⋂ n : ℕ, Ioi (n : ℝ≥0∞) = {∞} 
goal: ⋂ n, Set.Ioi ↑n = {⊤}

full_name: ENNReal.coe_min
code: @[simp, norm_cast]
theorem coe_min (r p : ℝ≥0) : ((min r p : ℝ≥0) : ℝ≥0∞) = min (r : ℝ≥0∞) p 
goal: ↑(min r p) = min ↑r ↑p

full_name: ENNReal.coe_max
code: @[simp, norm_cast]
theorem coe_max (r p : ℝ≥0) : ((max r p : ℝ≥0) : ℝ≥0∞) = max (r : ℝ≥0∞) p 
goal: ↑(max r p) = max ↑r ↑p

full_name: ENNReal.le_of_top_imp_top_of_toNNReal_le
code: theorem le_of_top_imp_top_of_toNNReal_le {a b : ℝ≥0∞} (h : a = ⊤ → b = ⊤)
    (h_nnreal : a ≠ ⊤ → b ≠ ⊤ → a.toNNReal ≤ b.toNNReal) : a ≤ b 
goal: a ≤ b

full_name: ENNReal.abs_toReal
code: @[simp]
theorem abs_toReal {x : ℝ≥0∞} : |x.toReal| = x.toReal 
goal: |x.toReal| = x.toReal

full_name: ENNReal.coe_sSup
code: theorem coe_sSup {s : Set ℝ≥0} : BddAbove s → (↑(sSup s) : ℝ≥0∞) = ⨆ a ∈ s, ↑a 
goal: BddAbove s → ↑(sSup s) = ⨆ a ∈ s, ↑a

full_name: ENNReal.coe_sInf
code: theorem coe_sInf {s : Set ℝ≥0} (hs : s.Nonempty) : (↑(sInf s) : ℝ≥0∞) = ⨅ a ∈ s, ↑a 
goal: ↑(sInf s) = ⨅ a ∈ s, ↑a

full_name: ENNReal.coe_iSup
code: theorem coe_iSup {ι : Sort*} {f : ι → ℝ≥0} (hf : BddAbove (range f)) :
    (↑(iSup f) : ℝ≥0∞) = ⨆ a, ↑(f a) 
goal: ↑(iSup f) = ⨆ a, ↑(f a)

full_name: ENNReal.coe_iInf
code: @[norm_cast]
theorem coe_iInf {ι : Sort*} [Nonempty ι] (f : ι → ℝ≥0) : (↑(iInf f) : ℝ≥0∞) = ⨅ a, ↑(f a) 
goal: ↑(iInf f) = ⨅ a, ↑(f a)

full_name: ENNReal.coe_mem_upperBounds
code: theorem coe_mem_upperBounds {s : Set ℝ≥0} :
    ↑r ∈ upperBounds (ofNNReal '' s) ↔ r ∈ upperBounds s 
goal: ↑r ∈ upperBounds (ENNReal.ofNNReal '' s) ↔ r ∈ upperBounds s

full_name: ENNReal.iSup_coe_eq_top
code: lemma iSup_coe_eq_top : ⨆ i, (f i : ℝ≥0∞) = ⊤ ↔ ¬ BddAbove (range f) 
goal: ⨆ i, ↑(f i) = ⊤ ↔ ¬BddAbove (Set.range f)

full_name: ENNReal.iSup_coe_lt_top
code: lemma iSup_coe_lt_top : ⨆ i, (f i : ℝ≥0∞) < ⊤ ↔ BddAbove (range f) 
goal: ⨆ i, ↑(f i) < ⊤ ↔ BddAbove (Set.range f)

full_name: ENNReal.iInf_coe_eq_top
code: lemma iInf_coe_eq_top : ⨅ i, (f i : ℝ≥0∞) = ⊤ ↔ IsEmpty ι 
goal: ⨅ i, ↑(f i) = ⊤ ↔ IsEmpty ι

full_name: ENNReal.iInf_coe_lt_top
code: lemma iInf_coe_lt_top : ⨅ i, (f i : ℝ≥0∞) < ⊤ ↔ Nonempty ι 
goal: ⨅ i, ↑(f i) < ⊤ ↔ Nonempty ι

full_name: Set.OrdConnected.preimage_coe_nnreal_ennreal
code: theorem preimage_coe_nnreal_ennreal (h : u.OrdConnected) : ((↑) ⁻¹' u : Set ℝ≥0).OrdConnected 
goal: (ENNReal.ofNNReal ⁻¹' u).OrdConnected

full_name: Set.OrdConnected.image_coe_nnreal_ennreal
code: theorem image_coe_nnreal_ennreal (h : t.OrdConnected) : ((↑) '' t : Set ℝ≥0∞).OrdConnected 
goal: (ENNReal.ofNNReal '' t).OrdConnected

full_name: Set.OrdConnected.preimage_ennreal_ofReal
code: theorem preimage_ennreal_ofReal (h : u.OrdConnected) : (ENNReal.ofReal ⁻¹' u).OrdConnected 
goal: (ENNReal.ofReal ⁻¹' u).OrdConnected

full_name: Set.OrdConnected.image_ennreal_ofReal
code: theorem image_ennreal_ofReal (h : s.OrdConnected) : (ENNReal.ofReal '' s).OrdConnected 
goal: (ENNReal.ofReal '' s).OrdConnected

full_name: Mathlib.Meta.Positivity.evalENNRealtoReal
code: /-- Extension for the `positivity` tactic: `ENNReal.toReal`. -/
@[positivity ENNReal.toReal _]
def evalENNRealtoReal : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt

full_name: Mathlib.Meta.Positivity.evalENNRealOfNNReal
code: /-- Extension for the `positivity` tactic: `ENNReal.ofNNReal`. -/
@[positivity ENNReal.ofNNReal _]
def evalENNRealOfNNReal : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt