File: Mathlib/Data/NNReal/Basic.lean

full_name: NNReal
code: /-- Nonnegative real numbers. -/
def NNReal 
goal: Type

full_name: NNReal._aux_Mathlib_Data_NNReal_Basic___unexpand_NNReal_1
code: scoped notation "ℝ≥0" => NNReal
goal: Lean.PrettyPrinter.Unexpander

full_name: NNReal.«_aux_Mathlib_Data_NNReal_Basic___macroRules_NNReal_termℝ≥0_1»
code: scoped notation "ℝ≥0" => NNReal
goal: Lean.Macro

full_name: NNReal.instFloorSemiring
code: noncomputable instance : FloorSemiring ℝ≥0 
goal: FloorSemiring ℝ≥0

full_name: NNReal.instDenselyOrdered
code: instance instDenselyOrdered : DenselyOrdered ℝ≥0 
goal: DenselyOrdered ℝ≥0

full_name: NNReal.instOrderBot
code: instance : OrderBot ℝ≥0 
goal: OrderBot ℝ≥0

full_name: NNReal.instArchimedean
code: instance : Archimedean ℝ≥0 
goal: Archimedean ℝ≥0

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

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

full_name: NNReal.instCanonicallyLinearOrderedSemifield
code: noncomputable instance : CanonicallyLinearOrderedSemifield ℝ≥0 
goal: CanonicallyLinearOrderedSemifield ℝ≥0

full_name: NNReal.toReal
code: /-- Coercion `ℝ≥0 → ℝ`. -/
@[coe] def toReal : ℝ≥0 → ℝ 
goal: ℝ≥0 → ℝ

full_name: NNReal.instCoeReal
code: instance : Coe ℝ≥0 ℝ 
goal: Coe ℝ≥0 ℝ

full_name: NNReal.val_eq_coe
code: @[simp]
theorem val_eq_coe (n : ℝ≥0) : n.val = n 
goal: ↑n = ↑n

full_name: NNReal.canLift
code: instance canLift : CanLift ℝ ℝ≥0 toReal fun r => 0 ≤ r 
goal: CanLift ℝ ℝ≥0 NNReal.toReal fun r => 0 ≤ r

full_name: NNReal.eq
code: @[ext] protected theorem eq {n m : ℝ≥0} : (n : ℝ) = (m : ℝ) → n = m 
goal: ↑n = ↑m → n = m

full_name: NNReal.eq_iff
code: protected theorem eq_iff {n m : ℝ≥0} : n = m ↔ (n : ℝ) = (m : ℝ) 
goal: n = m ↔ ↑n = ↑m

full_name: NNReal.ne_iff
code: theorem ne_iff {x y : ℝ≥0} : (x : ℝ) ≠ (y : ℝ) ↔ x ≠ y 
goal: ↑x ≠ ↑y ↔ x ≠ y

full_name: NNReal.forall
code: protected theorem «forall» {p : ℝ≥0 → Prop} :
    (∀ x : ℝ≥0, p x) ↔ ∀ (x : ℝ) (hx : 0 ≤ x), p ⟨x, hx⟩ 
goal: (∀ (x : ℝ≥0), p x) ↔ ∀ (x : ℝ) (hx : 0 ≤ x), p ⟨x, hx⟩

full_name: NNReal.exists
code: protected theorem «exists» {p : ℝ≥0 → Prop} :
    (∃ x : ℝ≥0, p x) ↔ ∃ (x : ℝ) (hx : 0 ≤ x), p ⟨x, hx⟩ 
goal: (∃ x, p x) ↔ ∃ x, ∃ (hx : 0 ≤ x), p ⟨x, hx⟩

full_name: Real.toNNReal
code: /-- Reinterpret a real number `r` as a non-negative real number. Returns `0` if `r < 0`. -/
noncomputable def _root_.Real.toNNReal (r : ℝ) : ℝ≥0 
goal: ℝ≥0

full_name: Real.coe_toNNReal
code: theorem _root_.Real.coe_toNNReal (r : ℝ) (hr : 0 ≤ r) : (Real.toNNReal r : ℝ) = r 
goal: ↑r.toNNReal = r

full_name: Real.toNNReal_of_nonneg
code: theorem _root_.Real.toNNReal_of_nonneg {r : ℝ} (hr : 0 ≤ r) : r.toNNReal = ⟨r, hr⟩ 
goal: r.toNNReal = ⟨r, hr⟩

full_name: Real.le_coe_toNNReal
code: theorem _root_.Real.le_coe_toNNReal (r : ℝ) : r ≤ Real.toNNReal r 
goal: r ≤ ↑r.toNNReal

full_name: NNReal.coe_nonneg
code: theorem coe_nonneg (r : ℝ≥0) : (0 : ℝ) ≤ r 
goal: 0 ≤ ↑r

full_name: NNReal.coe_mk
code: @[simp, norm_cast] theorem coe_mk (a : ℝ) (ha) : toReal ⟨a, ha⟩ = a 
goal: ↑⟨a, ha⟩ = a

full_name: NNReal.coe_injective
code: protected theorem coe_injective : Injective ((↑) : ℝ≥0 → ℝ) 
goal: Function.Injective NNReal.toReal

full_name: NNReal.coe_inj
code: @[simp, norm_cast] lemma coe_inj {r₁ r₂ : ℝ≥0} : (r₁ : ℝ) = r₂ ↔ r₁ = r₂ 
goal: ↑r₁ = ↑r₂ ↔ r₁ = r₂

full_name: NNReal.coe_zero
code: @[simp, norm_cast] lemma coe_zero : ((0 : ℝ≥0) : ℝ) = 0 
goal: ↑0 = 0

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

full_name: NNReal.coe_add
code: @[simp, norm_cast]
protected theorem coe_add (r₁ r₂ : ℝ≥0) : ((r₁ + r₂ : ℝ≥0) : ℝ) = r₁ + r₂ 
goal: ↑(r₁ + r₂) = ↑r₁ + ↑r₂

full_name: NNReal.coe_mul
code: @[simp, norm_cast]
protected theorem coe_mul (r₁ r₂ : ℝ≥0) : ((r₁ * r₂ : ℝ≥0) : ℝ) = r₁ * r₂ 
goal: ↑(r₁ * r₂) = ↑r₁ * ↑r₂

full_name: NNReal.coe_inv
code: @[simp, norm_cast]
protected theorem coe_inv (r : ℝ≥0) : ((r⁻¹ : ℝ≥0) : ℝ) = (r : ℝ)⁻¹ 
goal: ↑r⁻¹ = (↑r)⁻¹

full_name: NNReal.coe_div
code: @[simp, norm_cast]
protected theorem coe_div (r₁ r₂ : ℝ≥0) : ((r₁ / r₂ : ℝ≥0) : ℝ) = (r₁ : ℝ) / r₂ 
goal: ↑(r₁ / r₂) = ↑r₁ / ↑r₂

full_name: NNReal.coe_two
code: protected theorem coe_two : ((2 : ℝ≥0) : ℝ) = 2 
goal: ↑2 = 2

full_name: NNReal.coe_sub
code: @[simp, norm_cast]
protected theorem coe_sub {r₁ r₂ : ℝ≥0} (h : r₂ ≤ r₁) : ((r₁ - r₂ : ℝ≥0) : ℝ) = ↑r₁ - ↑r₂ 
goal: ↑(r₁ - r₂) = ↑r₁ - ↑r₂

full_name: NNReal.coe_eq_zero
code: @[simp, norm_cast] lemma coe_eq_zero : (r : ℝ) = 0 ↔ r = 0 
goal: ↑r = 0 ↔ r = 0

full_name: NNReal.coe_eq_one
code: @[simp, norm_cast] lemma coe_eq_one : (r : ℝ) = 1 ↔ r = 1 
goal: ↑r = 1 ↔ r = 1

full_name: NNReal.coe_ne_zero
code: @[norm_cast] lemma coe_ne_zero : (r : ℝ) ≠ 0 ↔ r ≠ 0 
goal: ↑r ≠ 0 ↔ r ≠ 0

full_name: NNReal.coe_ne_one
code: @[norm_cast] lemma coe_ne_one : (r : ℝ) ≠ 1 ↔ r ≠ 1 
goal: ↑r ≠ 1 ↔ r ≠ 1

full_name: NNReal.toRealHom
code: /-- Coercion `ℝ≥0 → ℝ` as a `RingHom`.

Porting note (#11215): TODO: what if we define `Coe ℝ≥0 ℝ` using this function? -/
def toRealHom : ℝ≥0 →+* ℝ 
goal: ℝ≥0 →+* ℝ

full_name: NNReal.coe_toRealHom
code: @[simp] theorem coe_toRealHom : ⇑toRealHom = toReal 
goal: ⇑NNReal.toRealHom = NNReal.toReal

full_name: NNReal.instMulActionOfReal
code: /-- A `MulAction` over `ℝ` restricts to a `MulAction` over `ℝ≥0`. -/
instance {M : Type*} [MulAction ℝ M] : MulAction ℝ≥0 M 
goal: MulAction ℝ≥0 M

full_name: NNReal.smul_def
code: theorem smul_def {M : Type*} [MulAction ℝ M] (c : ℝ≥0) (x : M) : c • x = (c : ℝ) • x 
goal: c • x = ↑c • x

full_name: NNReal.instIsScalarTowerOfReal
code: instance {M N : Type*} [MulAction ℝ M] [MulAction ℝ N] [SMul M N] [IsScalarTower ℝ M N] :
    IsScalarTower ℝ≥0 M N 
goal: IsScalarTower ℝ≥0 M N

full_name: NNReal.smulCommClass_left
code: instance smulCommClass_left {M N : Type*} [MulAction ℝ N] [SMul M N] [SMulCommClass ℝ M N] :
    SMulCommClass ℝ≥0 M N 
goal: SMulCommClass ℝ≥0 M N

full_name: NNReal.smulCommClass_right
code: instance smulCommClass_right {M N : Type*} [MulAction ℝ N] [SMul M N] [SMulCommClass M ℝ N] :
    SMulCommClass M ℝ≥0 N 
goal: SMulCommClass M ℝ≥0 N

full_name: NNReal.instDistribMulActionOfReal
code: /-- A `DistribMulAction` over `ℝ` restricts to a `DistribMulAction` over `ℝ≥0`. -/
instance {M : Type*} [AddMonoid M] [DistribMulAction ℝ M] : DistribMulAction ℝ≥0 M 
goal: DistribMulAction ℝ≥0 M

full_name: NNReal.instModuleOfReal
code: /-- A `Module` over `ℝ` restricts to a `Module` over `ℝ≥0`. -/
instance {M : Type*} [AddCommMonoid M] [Module ℝ M] : Module ℝ≥0 M 
goal: Module ℝ≥0 M

full_name: NNReal.instAlgebraOfReal
code: /-- An `Algebra` over `ℝ` restricts to an `Algebra` over `ℝ≥0`. -/
instance {A : Type*} [Semiring A] [Algebra ℝ A] : Algebra ℝ≥0 A 
goal: Algebra ℝ≥0 A

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

full_name: NNReal.coe_pow
code: @[simp, norm_cast]
theorem coe_pow (r : ℝ≥0) (n : ℕ) : ((r ^ n : ℝ≥0) : ℝ) = (r : ℝ) ^ n 
goal: ↑(r ^ n) = ↑r ^ n

full_name: NNReal.coe_zpow
code: @[simp, norm_cast]
theorem coe_zpow (r : ℝ≥0) (n : ℤ) : ((r ^ n : ℝ≥0) : ℝ) = (r : ℝ) ^ n 
goal: ↑(r ^ n) = ↑r ^ n

full_name: NNReal.coe_list_sum
code: @[norm_cast]
theorem coe_list_sum (l : List ℝ≥0) : ((l.sum : ℝ≥0) : ℝ) = (l.map (↑)).sum 
goal: ↑l.sum = (List.map NNReal.toReal l).sum

full_name: NNReal.coe_list_prod
code: @[norm_cast]
theorem coe_list_prod (l : List ℝ≥0) : ((l.prod : ℝ≥0) : ℝ) = (l.map (↑)).prod 
goal: ↑l.prod = (List.map NNReal.toReal l).prod

full_name: NNReal.coe_multiset_sum
code: @[norm_cast]
theorem coe_multiset_sum (s : Multiset ℝ≥0) : ((s.sum : ℝ≥0) : ℝ) = (s.map (↑)).sum 
goal: ↑s.sum = (Multiset.map NNReal.toReal s).sum

full_name: NNReal.coe_multiset_prod
code: @[norm_cast]
theorem coe_multiset_prod (s : Multiset ℝ≥0) : ((s.prod : ℝ≥0) : ℝ) = (s.map (↑)).prod 
goal: ↑s.prod = (Multiset.map NNReal.toReal s).prod

full_name: NNReal.coe_sum
code: @[norm_cast]
theorem coe_sum {α} {s : Finset α} {f : α → ℝ≥0} : ↑(∑ a ∈ s, f a) = ∑ a ∈ s, (f a : ℝ) 
goal: ↑(∑ a ∈ s, f a) = ∑ a ∈ s, ↑(f a)

full_name: Real.toNNReal_sum_of_nonneg
code: theorem _root_.Real.toNNReal_sum_of_nonneg {α} {s : Finset α} {f : α → ℝ}
    (hf : ∀ a, a ∈ s → 0 ≤ f a) :
    Real.toNNReal (∑ a ∈ s, f a) = ∑ a ∈ s, Real.toNNReal (f a) 
goal: (∑ a ∈ s, f a).toNNReal = ∑ a ∈ s, (f a).toNNReal

full_name: NNReal.coe_prod
code: @[norm_cast]
theorem coe_prod {α} {s : Finset α} {f : α → ℝ≥0} : ↑(∏ a ∈ s, f a) = ∏ a ∈ s, (f a : ℝ) 
goal: ↑(∏ a ∈ s, f a) = ∏ a ∈ s, ↑(f a)

full_name: Real.toNNReal_prod_of_nonneg
code: theorem _root_.Real.toNNReal_prod_of_nonneg {α} {s : Finset α} {f : α → ℝ}
    (hf : ∀ a, a ∈ s → 0 ≤ f a) :
    Real.toNNReal (∏ a ∈ s, f a) = ∏ a ∈ s, Real.toNNReal (f a) 
goal: (∏ a ∈ s, f a).toNNReal = ∏ a ∈ s, (f a).toNNReal

full_name: NNReal.coe_nsmul
code: theorem coe_nsmul (r : ℝ≥0) (n : ℕ) : ↑(n • r) = n • (r : ℝ) 
goal: ↑(n • r) = n • ↑r

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

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

full_name: NNReal.coe_ofScientific
code: @[simp, norm_cast]
protected theorem coe_ofScientific (m : ℕ) (s : Bool) (e : ℕ) :
    ↑(OfScientific.ofScientific m s e : ℝ≥0) = (OfScientific.ofScientific m s e : ℝ) 
goal: ↑(OfScientific.ofScientific m s e) = OfScientific.ofScientific m s e

full_name: NNReal.algebraMap_eq_coe
code: @[simp, norm_cast]
lemma algebraMap_eq_coe : (algebraMap ℝ≥0 ℝ : ℝ≥0 → ℝ) = (↑) 
goal: ⇑(algebraMap ℝ≥0 ℝ) = NNReal.toReal

full_name: NNReal.coe_le_coe
code: @[simp, norm_cast] lemma coe_le_coe : (r₁ : ℝ) ≤ r₂ ↔ r₁ ≤ r₂ 
goal: ↑r₁ ≤ ↑r₂ ↔ r₁ ≤ r₂

full_name: NNReal.coe_lt_coe
code: @[simp, norm_cast] lemma coe_lt_coe : (r₁ : ℝ) < r₂ ↔ r₁ < r₂ 
goal: ↑r₁ < ↑r₂ ↔ r₁ < r₂

full_name: NNReal.coe_pos
code: @[simp, norm_cast] lemma coe_pos : (0 : ℝ) < r ↔ 0 < r 
goal: 0 < ↑r ↔ 0 < r

full_name: NNReal.one_le_coe
code: @[simp, norm_cast] lemma one_le_coe : 1 ≤ (r : ℝ) ↔ 1 ≤ r 
goal: 1 ≤ ↑r ↔ 1 ≤ r

full_name: NNReal.one_lt_coe
code: @[simp, norm_cast] lemma one_lt_coe : 1 < (r : ℝ) ↔ 1 < r 
goal: 1 < ↑r ↔ 1 < r

full_name: NNReal.coe_le_one
code: @[simp, norm_cast] lemma coe_le_one : (r : ℝ) ≤ 1 ↔ r ≤ 1 
goal: ↑r ≤ 1 ↔ r ≤ 1

full_name: NNReal.coe_lt_one
code: @[simp, norm_cast] lemma coe_lt_one : (r : ℝ) < 1 ↔ r < 1 
goal: ↑r < 1 ↔ r < 1

full_name: NNReal.coe_mono
code: @[mono] lemma coe_mono : Monotone ((↑) : ℝ≥0 → ℝ) 
goal: Monotone NNReal.toReal

full_name: Real.toNNReal_mono
code: protected theorem _root_.Real.toNNReal_mono : Monotone Real.toNNReal 
goal: Monotone Real.toNNReal

full_name: Real.toNNReal_coe
code: @[simp]
theorem _root_.Real.toNNReal_coe {r : ℝ≥0} : Real.toNNReal r = r 
goal: (↑r).toNNReal = r

full_name: NNReal.mk_natCast
code: @[simp]
theorem mk_natCast (n : ℕ) : @Eq ℝ≥0 (⟨(n : ℝ), n.cast_nonneg⟩ : ℝ≥0) n 
goal: ⟨↑n, ⋯⟩ = ↑n

full_name: NNReal.toNNReal_coe_nat
code: @[simp]
theorem toNNReal_coe_nat (n : ℕ) : Real.toNNReal n = n 
goal: (↑n).toNNReal = ↑n

full_name: Real.toNNReal_ofNat
code: @[simp]
theorem _root_.Real.toNNReal_ofNat (n : ℕ) [n.AtLeastTwo] :
    Real.toNNReal (no_index (OfNat.ofNat n)) = OfNat.ofNat n 
goal: (OfNat.ofNat n).toNNReal = OfNat.ofNat n

full_name: NNReal.gi
code: /-- `Real.toNNReal` and `NNReal.toReal : ℝ≥0 → ℝ` form a Galois insertion. -/
noncomputable def gi : GaloisInsertion Real.toNNReal (↑) 
goal: GaloisInsertion Real.toNNReal NNReal.toReal

full_name: NNReal.instPosSMulStrictMono
code: instance instPosSMulStrictMono {α} [Preorder α] [MulAction ℝ α] [PosSMulStrictMono ℝ α] :
    PosSMulStrictMono ℝ≥0 α 
goal: PosSMulStrictMono ℝ≥0 α

full_name: NNReal.instSMulPosStrictMono
code: instance instSMulPosStrictMono {α} [Zero α] [Preorder α] [MulAction ℝ α] [SMulPosStrictMono ℝ α] :
    SMulPosStrictMono ℝ≥0 α 
goal: SMulPosStrictMono ℝ≥0 α

full_name: NNReal.orderIsoIccZeroCoe
code: /-- If `a` is a nonnegative real number, then the closed interval `[0, a]` in `ℝ` is order
isomorphic to the interval `Set.Iic a`. -/
-- Porting note (#11215): TODO: restore once `simps` supports `ℝ≥0` @[simps!? apply_coe_coe]
def orderIsoIccZeroCoe (a : ℝ≥0) : Set.Icc (0 : ℝ) a ≃o Set.Iic a 
goal: ↑(Set.Icc 0 ↑a) ≃o ↑(Set.Iic a)

full_name: NNReal.orderIsoIccZeroCoe_apply_coe_coe
code: @[simp]
theorem orderIsoIccZeroCoe_apply_coe_coe (a : ℝ≥0) (b : Set.Icc (0 : ℝ) a) :
    (orderIsoIccZeroCoe a b : ℝ) = b 
goal: ↑↑(a.orderIsoIccZeroCoe b) = ↑b

full_name: NNReal.orderIsoIccZeroCoe_symm_apply_coe
code: @[simp]
theorem orderIsoIccZeroCoe_symm_apply_coe (a : ℝ≥0) (b : Set.Iic a) :
    ((orderIsoIccZeroCoe a).symm b : ℝ) = b 
goal: ↑(a.orderIsoIccZeroCoe.symm b) = ↑↑b

full_name: NNReal.coe_image
code: theorem coe_image {s : Set ℝ≥0} :
    (↑) '' s = { x : ℝ | ∃ h : 0 ≤ x, @Membership.mem ℝ≥0 _ _ ⟨x, h⟩ s } 
goal: NNReal.toReal '' s = {x | ∃ (h : 0 ≤ x), ⟨x, h⟩ ∈ s}

full_name: NNReal.bddAbove_coe
code: theorem bddAbove_coe {s : Set ℝ≥0} : BddAbove (((↑) : ℝ≥0 → ℝ) '' s) ↔ BddAbove s 
goal: BddAbove (NNReal.toReal '' s) ↔ BddAbove s

full_name: NNReal.bddBelow_coe
code: theorem bddBelow_coe (s : Set ℝ≥0) : BddBelow (((↑) : ℝ≥0 → ℝ) '' s) 
goal: BddBelow (NNReal.toReal '' s)

full_name: NNReal.instConditionallyCompleteLinearOrderBot
code: noncomputable instance : ConditionallyCompleteLinearOrderBot ℝ≥0 
goal: ConditionallyCompleteLinearOrderBot ℝ≥0

full_name: NNReal.coe_sSup
code: @[norm_cast]
theorem coe_sSup (s : Set ℝ≥0) : (↑(sSup s) : ℝ) = sSup (((↑) : ℝ≥0 → ℝ) '' s) 
goal: ↑(sSup s) = sSup (NNReal.toReal '' s)

full_name: NNReal.coe_iSup
code: @[simp, norm_cast] -- Porting note: add `simp`
theorem coe_iSup {ι : Sort*} (s : ι → ℝ≥0) : (↑(⨆ i, s i) : ℝ) = ⨆ i, ↑(s i) 
goal: ↑(⨆ i, s i) = ⨆ i, ↑(s i)

full_name: NNReal.coe_sInf
code: @[norm_cast]
theorem coe_sInf (s : Set ℝ≥0) : (↑(sInf s) : ℝ) = sInf (((↑) : ℝ≥0 → ℝ) '' s) 
goal: ↑(sInf s) = sInf (NNReal.toReal '' s)

full_name: NNReal.sInf_empty
code: @[simp]
theorem sInf_empty : sInf (∅ : Set ℝ≥0) = 0 
goal: sInf ∅ = 0

full_name: NNReal.coe_iInf
code: @[norm_cast]
theorem coe_iInf {ι : Sort*} (s : ι → ℝ≥0) : (↑(⨅ i, s i) : ℝ) = ⨅ i, ↑(s i) 
goal: ↑(⨅ i, s i) = ⨅ i, ↑(s i)

full_name: NNReal.le_iInf_add_iInf
code: theorem le_iInf_add_iInf {ι ι' : Sort*} [Nonempty ι] [Nonempty ι'] {f : ι → ℝ≥0} {g : ι' → ℝ≥0}
    {a : ℝ≥0} (h : ∀ i j, a ≤ f i + g j) : a ≤ (⨅ i, f i) + ⨅ j, g j 
goal: a ≤ (⨅ i, f i) + ⨅ j, g j

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

full_name: NNReal.contravariant_add
code: instance contravariant_add : ContravariantClass ℝ≥0 ℝ≥0 (· + ·) (· < ·) 
goal: ContravariantClass ℝ≥0 ℝ≥0 (fun x x_1 => x + x_1) fun x x_1 => x < x_1

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

full_name: NNReal.le_of_forall_pos_le_add
code: nonrec theorem le_of_forall_pos_le_add {a b : ℝ≥0} (h : ∀ ε, 0 < ε → a ≤ b + ε) : a ≤ b 
goal: a ≤ b

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

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

full_name: NNReal.mul_sup
code: theorem mul_sup (a b c : ℝ≥0) : a * (b ⊔ c) = a * b ⊔ a * c 
goal: a * (b ⊔ c) = a * b ⊔ a * c

full_name: NNReal.sup_mul
code: theorem sup_mul (a b c : ℝ≥0) : (a ⊔ b) * c = a * c ⊔ b * c 
goal: (a ⊔ b) * c = a * c ⊔ b * c

full_name: NNReal.mul_finset_sup
code: theorem mul_finset_sup {α} (r : ℝ≥0) (s : Finset α) (f : α → ℝ≥0) :
    r * s.sup f = s.sup fun a => r * f a 
goal: r * s.sup f = s.sup fun a => r * f a

full_name: NNReal.finset_sup_mul
code: theorem finset_sup_mul {α} (s : Finset α) (f : α → ℝ≥0) (r : ℝ≥0) :
    s.sup f * r = s.sup fun a => f a * r 
goal: s.sup f * r = s.sup fun a => f a * r

full_name: NNReal.finset_sup_div
code: theorem finset_sup_div {α} {f : α → ℝ≥0} {s : Finset α} (r : ℝ≥0) :
    s.sup f / r = s.sup fun a => f a / r 
goal: s.sup f / r = s.sup fun a => f a / r

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

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

full_name: NNReal.zero_le_coe
code: @[simp]
theorem zero_le_coe {q : ℝ≥0} : 0 ≤ (q : ℝ) 
goal: 0 ≤ ↑q

full_name: NNReal.instOrderedSMul
code: instance instOrderedSMul {M : Type*} [OrderedAddCommMonoid M] [Module ℝ M] [OrderedSMul ℝ M] :
    OrderedSMul ℝ≥0 M 
goal: OrderedSMul ℝ≥0 M

full_name: Real.coe_toNNReal'
code: @[simp]
theorem coe_toNNReal' (r : ℝ) : (Real.toNNReal r : ℝ) = max r 0 
goal: ↑r.toNNReal = max r 0

full_name: Real.toNNReal_zero
code: @[simp]
theorem toNNReal_zero : Real.toNNReal 0 = 0 
goal: Real.toNNReal 0 = 0

full_name: Real.toNNReal_one
code: @[simp]
theorem toNNReal_one : Real.toNNReal 1 = 1 
goal: Real.toNNReal 1 = 1

full_name: Real.toNNReal_pos
code: @[simp]
theorem toNNReal_pos {r : ℝ} : 0 < Real.toNNReal r ↔ 0 < r 
goal: 0 < r.toNNReal ↔ 0 < r

full_name: Real.toNNReal_eq_zero
code: @[simp]
theorem toNNReal_eq_zero {r : ℝ} : Real.toNNReal r = 0 ↔ r ≤ 0 
goal: r.toNNReal = 0 ↔ r ≤ 0

full_name: Real.toNNReal_of_nonpos
code: theorem toNNReal_of_nonpos {r : ℝ} : r ≤ 0 → Real.toNNReal r = 0 
goal: r ≤ 0 → r.toNNReal = 0

full_name: Real.toNNReal_eq_iff_eq_coe
code: lemma toNNReal_eq_iff_eq_coe {r : ℝ} {p : ℝ≥0} (hp : p ≠ 0) : r.toNNReal = p ↔ r = p 
goal: r.toNNReal = p ↔ r = ↑p

full_name: Real.toNNReal_eq_one
code: @[simp]
lemma toNNReal_eq_one {r : ℝ} : r.toNNReal = 1 ↔ r = 1 
goal: r.toNNReal = 1 ↔ r = 1

full_name: Real.toNNReal_eq_natCast
code: @[simp]
lemma toNNReal_eq_natCast {r : ℝ} {n : ℕ} (hn : n ≠ 0) : r.toNNReal = n ↔ r = n 
goal: r.toNNReal = ↑n ↔ r = ↑n

full_name: Real.toNNReal_eq_ofNat
code: @[simp]
lemma toNNReal_eq_ofNat {r : ℝ} {n : ℕ} [n.AtLeastTwo] :
    r.toNNReal = no_index (OfNat.ofNat n) ↔ r = OfNat.ofNat n 
goal: r.toNNReal = OfNat.ofNat n ↔ r = OfNat.ofNat n

full_name: Real.toNNReal_le_toNNReal_iff
code: @[simp]
theorem toNNReal_le_toNNReal_iff {r p : ℝ} (hp : 0 ≤ p) :
    toNNReal r ≤ toNNReal p ↔ r ≤ p 
goal: r.toNNReal ≤ p.toNNReal ↔ r ≤ p

full_name: Real.toNNReal_le_one
code: @[simp]
lemma toNNReal_le_one {r : ℝ} : r.toNNReal ≤ 1 ↔ r ≤ 1 
goal: r.toNNReal ≤ 1 ↔ r ≤ 1

full_name: Real.one_lt_toNNReal
code: @[simp]
lemma one_lt_toNNReal {r : ℝ} : 1 < r.toNNReal ↔ 1 < r 
goal: 1 < r.toNNReal ↔ 1 < r

full_name: Real.toNNReal_le_natCast
code: @[simp]
lemma toNNReal_le_natCast {r : ℝ} {n : ℕ} : r.toNNReal ≤ n ↔ r ≤ n 
goal: r.toNNReal ≤ ↑n ↔ r ≤ ↑n

full_name: Real.natCast_lt_toNNReal
code: @[simp]
lemma natCast_lt_toNNReal {r : ℝ} {n : ℕ} : n < r.toNNReal ↔ n < r 
goal: ↑n < r.toNNReal ↔ ↑n < r

full_name: Real.toNNReal_le_ofNat
code: @[simp]
lemma toNNReal_le_ofNat {r : ℝ} {n : ℕ} [n.AtLeastTwo] :
    r.toNNReal ≤ no_index (OfNat.ofNat n) ↔ r ≤ n 
goal: r.toNNReal ≤ OfNat.ofNat n ↔ r ≤ ↑n

full_name: Real.ofNat_lt_toNNReal
code: @[simp]
lemma ofNat_lt_toNNReal {r : ℝ} {n : ℕ} [n.AtLeastTwo] :
    no_index (OfNat.ofNat n) < r.toNNReal ↔ n < r 
goal: OfNat.ofNat n < r.toNNReal ↔ ↑n < r

full_name: Real.toNNReal_eq_toNNReal_iff
code: @[simp]
theorem toNNReal_eq_toNNReal_iff {r p : ℝ} (hr : 0 ≤ r) (hp : 0 ≤ p) :
    toNNReal r = toNNReal p ↔ r = p 
goal: r.toNNReal = p.toNNReal ↔ r = p

full_name: Real.toNNReal_lt_toNNReal_iff'
code: @[simp]
theorem toNNReal_lt_toNNReal_iff' {r p : ℝ} : Real.toNNReal r < Real.toNNReal p ↔ r < p ∧ 0 < p 
goal: r.toNNReal < p.toNNReal ↔ r < p ∧ 0 < p

full_name: Real.toNNReal_lt_toNNReal_iff
code: theorem toNNReal_lt_toNNReal_iff {r p : ℝ} (h : 0 < p) :
    Real.toNNReal r < Real.toNNReal p ↔ r < p 
goal: r.toNNReal < p.toNNReal ↔ r < p

full_name: Real.lt_of_toNNReal_lt
code: theorem lt_of_toNNReal_lt {r p : ℝ} (h : r.toNNReal < p.toNNReal) : r < p 
goal: r < p

full_name: Real.toNNReal_lt_toNNReal_iff_of_nonneg
code: theorem toNNReal_lt_toNNReal_iff_of_nonneg {r p : ℝ} (hr : 0 ≤ r) :
    Real.toNNReal r < Real.toNNReal p ↔ r < p 
goal: r.toNNReal < p.toNNReal ↔ r < p

full_name: Real.toNNReal_le_toNNReal_iff'
code: lemma toNNReal_le_toNNReal_iff' {r p : ℝ} : r.toNNReal ≤ p.toNNReal ↔ r ≤ p ∨ r ≤ 0 
goal: r.toNNReal ≤ p.toNNReal ↔ r ≤ p ∨ r ≤ 0

full_name: Real.toNNReal_le_toNNReal_iff_of_pos
code: lemma toNNReal_le_toNNReal_iff_of_pos {r p : ℝ} (hr : 0 < r) : r.toNNReal ≤ p.toNNReal ↔ r ≤ p 
goal: r.toNNReal ≤ p.toNNReal ↔ r ≤ p

full_name: Real.one_le_toNNReal
code: @[simp]
lemma one_le_toNNReal {r : ℝ} : 1 ≤ r.toNNReal ↔ 1 ≤ r 
goal: 1 ≤ r.toNNReal ↔ 1 ≤ r

full_name: Real.toNNReal_lt_one
code: @[simp]
lemma toNNReal_lt_one {r : ℝ} : r.toNNReal < 1 ↔ r < 1 
goal: r.toNNReal < 1 ↔ r < 1

full_name: Real.natCastle_toNNReal'
code: @[simp]
lemma natCastle_toNNReal' {n : ℕ} {r : ℝ} : ↑n ≤ r.toNNReal ↔ n ≤ r ∨ n = 0 
goal: ↑n ≤ r.toNNReal ↔ ↑n ≤ r ∨ n = 0

full_name: Real.toNNReal_lt_natCast'
code: @[simp]
lemma toNNReal_lt_natCast' {n : ℕ} {r : ℝ} : r.toNNReal < n ↔ r < n ∧ n ≠ 0 
goal: r.toNNReal < ↑n ↔ r < ↑n ∧ n ≠ 0

full_name: Real.natCast_le_toNNReal
code: lemma natCast_le_toNNReal {n : ℕ} {r : ℝ} (hn : n ≠ 0) : ↑n ≤ r.toNNReal ↔ n ≤ r 
goal: ↑n ≤ r.toNNReal ↔ ↑n ≤ r

full_name: Real.toNNReal_lt_natCast
code: lemma toNNReal_lt_natCast {r : ℝ} {n : ℕ} (hn : n ≠ 0) : r.toNNReal < n ↔ r < n 
goal: r.toNNReal < ↑n ↔ r < ↑n

full_name: Real.toNNReal_lt_ofNat
code: @[simp]
lemma toNNReal_lt_ofNat {r : ℝ} {n : ℕ} [n.AtLeastTwo] :
    r.toNNReal < no_index (OfNat.ofNat n) ↔ r < OfNat.ofNat n 
goal: r.toNNReal < OfNat.ofNat n ↔ r < OfNat.ofNat n

full_name: Real.ofNat_le_toNNReal
code: @[simp]
lemma ofNat_le_toNNReal {n : ℕ} {r : ℝ} [n.AtLeastTwo] :
    no_index (OfNat.ofNat n) ≤ r.toNNReal ↔ OfNat.ofNat n ≤ r 
goal: OfNat.ofNat n ≤ r.toNNReal ↔ OfNat.ofNat n ≤ r

full_name: Real.toNNReal_add
code: @[simp]
theorem toNNReal_add {r p : ℝ} (hr : 0 ≤ r) (hp : 0 ≤ p) :
    Real.toNNReal (r + p) = Real.toNNReal r + Real.toNNReal p 
goal: (r + p).toNNReal = r.toNNReal + p.toNNReal

full_name: Real.toNNReal_add_toNNReal
code: theorem toNNReal_add_toNNReal {r p : ℝ} (hr : 0 ≤ r) (hp : 0 ≤ p) :
    Real.toNNReal r + Real.toNNReal p = Real.toNNReal (r + p) 
goal: r.toNNReal + p.toNNReal = (r + p).toNNReal

full_name: Real.toNNReal_le_toNNReal
code: theorem toNNReal_le_toNNReal {r p : ℝ} (h : r ≤ p) : Real.toNNReal r ≤ Real.toNNReal p 
goal: r.toNNReal ≤ p.toNNReal

full_name: Real.toNNReal_add_le
code: theorem toNNReal_add_le {r p : ℝ} : Real.toNNReal (r + p) ≤ Real.toNNReal r + Real.toNNReal p 
goal: (r + p).toNNReal ≤ r.toNNReal + p.toNNReal

full_name: Real.toNNReal_le_iff_le_coe
code: theorem toNNReal_le_iff_le_coe {r : ℝ} {p : ℝ≥0} : toNNReal r ≤ p ↔ r ≤ ↑p 
goal: r.toNNReal ≤ p ↔ r ≤ ↑p

full_name: Real.le_toNNReal_iff_coe_le
code: theorem le_toNNReal_iff_coe_le {r : ℝ≥0} {p : ℝ} (hp : 0 ≤ p) : r ≤ Real.toNNReal p ↔ ↑r ≤ p 
goal: r ≤ p.toNNReal ↔ ↑r ≤ p

full_name: Real.le_toNNReal_iff_coe_le'
code: theorem le_toNNReal_iff_coe_le' {r : ℝ≥0} {p : ℝ} (hr : 0 < r) : r ≤ Real.toNNReal p ↔ ↑r ≤ p 
goal: r ≤ p.toNNReal ↔ ↑r ≤ p

full_name: Real.toNNReal_lt_iff_lt_coe
code: theorem toNNReal_lt_iff_lt_coe {r : ℝ} {p : ℝ≥0} (ha : 0 ≤ r) : Real.toNNReal r < p ↔ r < ↑p 
goal: r.toNNReal < p ↔ r < ↑p

full_name: Real.lt_toNNReal_iff_coe_lt
code: theorem lt_toNNReal_iff_coe_lt {r : ℝ≥0} {p : ℝ} : r < Real.toNNReal p ↔ ↑r < p 
goal: r < p.toNNReal ↔ ↑r < p

full_name: Real.toNNReal_pow
code: theorem toNNReal_pow {x : ℝ} (hx : 0 ≤ x) (n : ℕ) : (x ^ n).toNNReal = x.toNNReal ^ n 
goal: (x ^ n).toNNReal = x.toNNReal ^ n

full_name: Real.toNNReal_mul
code: theorem toNNReal_mul {p q : ℝ} (hp : 0 ≤ p) :
    Real.toNNReal (p * q) = Real.toNNReal p * Real.toNNReal q 
goal: (p * q).toNNReal = p.toNNReal * q.toNNReal

full_name: NNReal.mul_eq_mul_left
code: theorem mul_eq_mul_left {a b c : ℝ≥0} (h : a ≠ 0) : a * b = a * c ↔ b = c 
goal: a * b = a * c ↔ b = c

full_name: NNReal.pow_antitone_exp
code: theorem pow_antitone_exp {a : ℝ≥0} (m n : ℕ) (mn : m ≤ n) (a1 : a ≤ 1) : a ^ n ≤ a ^ m 
goal: a ^ n ≤ a ^ m

full_name: NNReal.exists_pow_lt_of_lt_one
code: nonrec theorem exists_pow_lt_of_lt_one {a b : ℝ≥0} (ha : 0 < a) (hb : b < 1) :
    ∃ n : ℕ, b ^ n < a 
goal: ∃ n, b ^ n < a

full_name: NNReal.exists_mem_Ico_zpow
code: nonrec theorem exists_mem_Ico_zpow {x : ℝ≥0} {y : ℝ≥0} (hx : x ≠ 0) (hy : 1 < y) :
    ∃ n : ℤ, x ∈ Set.Ico (y ^ n) (y ^ (n + 1)) 
goal: ∃ n, x ∈ Set.Ico (y ^ n) (y ^ (n + 1))

full_name: NNReal.exists_mem_Ioc_zpow
code: nonrec theorem exists_mem_Ioc_zpow {x : ℝ≥0} {y : ℝ≥0} (hx : x ≠ 0) (hy : 1 < y) :
    ∃ n : ℤ, x ∈ Set.Ioc (y ^ n) (y ^ (n + 1)) 
goal: ∃ n, x ∈ Set.Ioc (y ^ n) (y ^ (n + 1))

full_name: NNReal.sub_def
code: theorem sub_def {r p : ℝ≥0} : r - p = Real.toNNReal (r - p) 
goal: r - p = (↑r - ↑p).toNNReal

full_name: NNReal.coe_sub_def
code: theorem coe_sub_def {r p : ℝ≥0} : ↑(r - p) = max (r - p : ℝ) 0 
goal: ↑(r - p) = max (↑r - ↑p) 0

full_name: NNReal.sub_div
code: theorem sub_div (a b c : ℝ≥0) : (a - b) / c = a / c - b / c 
goal: (a - b) / c = a / c - b / c

full_name: NNReal.inv_le
code: @[simp]
theorem inv_le {r p : ℝ≥0} (h : r ≠ 0) : r⁻¹ ≤ p ↔ 1 ≤ r * p 
goal: r⁻¹ ≤ p ↔ 1 ≤ r * p

full_name: NNReal.inv_le_of_le_mul
code: theorem inv_le_of_le_mul {r p : ℝ≥0} (h : 1 ≤ r * p) : r⁻¹ ≤ p 
goal: r⁻¹ ≤ p

full_name: NNReal.le_inv_iff_mul_le
code: @[simp]
theorem le_inv_iff_mul_le {r p : ℝ≥0} (h : p ≠ 0) : r ≤ p⁻¹ ↔ r * p ≤ 1 
goal: r ≤ p⁻¹ ↔ r * p ≤ 1

full_name: NNReal.lt_inv_iff_mul_lt
code: @[simp]
theorem lt_inv_iff_mul_lt {r p : ℝ≥0} (h : p ≠ 0) : r < p⁻¹ ↔ r * p < 1 
goal: r < p⁻¹ ↔ r * p < 1

full_name: NNReal.mul_le_iff_le_inv
code: theorem mul_le_iff_le_inv {a b r : ℝ≥0} (hr : r ≠ 0) : r * a ≤ b ↔ a ≤ r⁻¹ * b 
goal: r * a ≤ b ↔ a ≤ r⁻¹ * b

full_name: NNReal.le_div_iff_mul_le
code: theorem le_div_iff_mul_le {a b r : ℝ≥0} (hr : r ≠ 0) : a ≤ b / r ↔ a * r ≤ b 
goal: a ≤ b / r ↔ a * r ≤ b

full_name: NNReal.div_le_iff
code: theorem div_le_iff {a b r : ℝ≥0} (hr : r ≠ 0) : a / r ≤ b ↔ a ≤ b * r 
goal: a / r ≤ b ↔ a ≤ b * r

full_name: NNReal.div_le_iff'
code: nonrec theorem div_le_iff' {a b r : ℝ≥0} (hr : r ≠ 0) : a / r ≤ b ↔ a ≤ r * b 
goal: a / r ≤ b ↔ a ≤ r * b

full_name: NNReal.div_le_of_le_mul
code: theorem div_le_of_le_mul {a b c : ℝ≥0} (h : a ≤ b * c) : a / c ≤ b 
goal: a / c ≤ b

full_name: NNReal.div_le_of_le_mul'
code: theorem div_le_of_le_mul' {a b c : ℝ≥0} (h : a ≤ b * c) : a / b ≤ c 
goal: a / b ≤ c

full_name: NNReal.le_div_iff
code: nonrec theorem le_div_iff {a b r : ℝ≥0} (hr : r ≠ 0) : a ≤ b / r ↔ a * r ≤ b 
goal: a ≤ b / r ↔ a * r ≤ b

full_name: NNReal.le_div_iff'
code: nonrec theorem le_div_iff' {a b r : ℝ≥0} (hr : r ≠ 0) : a ≤ b / r ↔ r * a ≤ b 
goal: a ≤ b / r ↔ r * a ≤ b

full_name: NNReal.div_lt_iff
code: theorem div_lt_iff {a b r : ℝ≥0} (hr : r ≠ 0) : a / r < b ↔ a < b * r 
goal: a / r < b ↔ a < b * r

full_name: NNReal.div_lt_iff'
code: theorem div_lt_iff' {a b r : ℝ≥0} (hr : r ≠ 0) : a / r < b ↔ a < r * b 
goal: a / r < b ↔ a < r * b

full_name: NNReal.lt_div_iff
code: theorem lt_div_iff {a b r : ℝ≥0} (hr : r ≠ 0) : a < b / r ↔ a * r < b 
goal: a < b / r ↔ a * r < b

full_name: NNReal.lt_div_iff'
code: theorem lt_div_iff' {a b r : ℝ≥0} (hr : r ≠ 0) : a < b / r ↔ r * a < b 
goal: a < b / r ↔ r * a < b

full_name: NNReal.mul_lt_of_lt_div
code: theorem mul_lt_of_lt_div {a b r : ℝ≥0} (h : a < b / r) : a * r < b 
goal: a * r < b

full_name: NNReal.div_le_div_left_of_le
code: theorem div_le_div_left_of_le {a b c : ℝ≥0} (c0 : c ≠ 0) (cb : c ≤ b) :
    a / b ≤ a / c 
goal: a / b ≤ a / c

full_name: NNReal.div_le_div_left
code: nonrec theorem div_le_div_left {a b c : ℝ≥0} (a0 : 0 < a) (b0 : 0 < b) (c0 : 0 < c) :
    a / b ≤ a / c ↔ c ≤ b 
goal: a / b ≤ a / c ↔ c ≤ b

full_name: NNReal.le_of_forall_lt_one_mul_le
code: theorem le_of_forall_lt_one_mul_le {x y : ℝ≥0} (h : ∀ a < 1, a * x ≤ y) : x ≤ y 
goal: x ≤ y

full_name: NNReal.half_le_self
code: nonrec theorem half_le_self (a : ℝ≥0) : a / 2 ≤ a 
goal: a / 2 ≤ a

full_name: NNReal.half_lt_self
code: nonrec theorem half_lt_self {a : ℝ≥0} (h : a ≠ 0) : a / 2 < a 
goal: a / 2 < a

full_name: NNReal.div_lt_one_of_lt
code: theorem div_lt_one_of_lt {a b : ℝ≥0} (h : a < b) : a / b < 1 
goal: a / b < 1

full_name: Real.toNNReal_inv
code: theorem _root_.Real.toNNReal_inv {x : ℝ} : Real.toNNReal x⁻¹ = (Real.toNNReal x)⁻¹ 
goal: x⁻¹.toNNReal = x.toNNReal⁻¹

full_name: Real.toNNReal_div
code: theorem _root_.Real.toNNReal_div {x y : ℝ} (hx : 0 ≤ x) :
    Real.toNNReal (x / y) = Real.toNNReal x / Real.toNNReal y 
goal: (x / y).toNNReal = x.toNNReal / y.toNNReal

full_name: Real.toNNReal_div'
code: theorem _root_.Real.toNNReal_div' {x y : ℝ} (hy : 0 ≤ y) :
    Real.toNNReal (x / y) = Real.toNNReal x / Real.toNNReal y 
goal: (x / y).toNNReal = x.toNNReal / y.toNNReal

full_name: NNReal.inv_lt_one_iff
code: theorem inv_lt_one_iff {x : ℝ≥0} (hx : x ≠ 0) : x⁻¹ < 1 ↔ 1 < x 
goal: x⁻¹ < 1 ↔ 1 < x

full_name: NNReal.zpow_pos
code: theorem zpow_pos {x : ℝ≥0} (hx : x ≠ 0) (n : ℤ) : 0 < x ^ n 
goal: 0 < x ^ n

full_name: NNReal.inv_lt_inv
code: theorem inv_lt_inv {x y : ℝ≥0} (hx : x ≠ 0) (h : x < y) : y⁻¹ < x⁻¹ 
goal: y⁻¹ < x⁻¹

full_name: NNReal.abs_eq
code: @[simp]
theorem abs_eq (x : ℝ≥0) : |(x : ℝ)| = x 
goal: |↑x| = ↑x

full_name: NNReal.le_toNNReal_of_coe_le
code: theorem le_toNNReal_of_coe_le {x : ℝ≥0} {y : ℝ} (h : ↑x ≤ y) : x ≤ y.toNNReal 
goal: x ≤ y.toNNReal

full_name: NNReal.sSup_of_not_bddAbove
code: nonrec theorem sSup_of_not_bddAbove {s : Set ℝ≥0} (hs : ¬BddAbove s) : SupSet.sSup s = 0 
goal: sSup s = 0

full_name: NNReal.iSup_of_not_bddAbove
code: theorem iSup_of_not_bddAbove (hf : ¬BddAbove (range f)) : ⨆ i, f i = 0 
goal: ⨆ i, f i = 0

full_name: NNReal.iSup_empty
code: theorem iSup_empty [IsEmpty ι] (f : ι → ℝ≥0) : ⨆ i, f i = 0 
goal: ⨆ i, f i = 0

full_name: NNReal.iInf_empty
code: theorem iInf_empty [IsEmpty ι] (f : ι → ℝ≥0) : ⨅ i, f i = 0 
goal: ⨅ i, f i = 0

full_name: NNReal.iInf_const_zero
code: @[simp]
theorem iInf_const_zero {α : Sort*} : ⨅ _ : α, (0 : ℝ≥0) = 0 
goal: ⨅ x, 0 = 0

full_name: NNReal.iInf_mul
code: theorem iInf_mul (f : ι → ℝ≥0) (a : ℝ≥0) : iInf f * a = ⨅ i, f i * a 
goal: iInf f * a = ⨅ i, f i * a

full_name: NNReal.mul_iInf
code: theorem mul_iInf (f : ι → ℝ≥0) (a : ℝ≥0) : a * iInf f = ⨅ i, a * f i 
goal: a * iInf f = ⨅ i, a * f i

full_name: NNReal.mul_iSup
code: theorem mul_iSup (f : ι → ℝ≥0) (a : ℝ≥0) : (a * ⨆ i, f i) = ⨆ i, a * f i 
goal: a * ⨆ i, f i = ⨆ i, a * f i

full_name: NNReal.iSup_mul
code: theorem iSup_mul (f : ι → ℝ≥0) (a : ℝ≥0) : (⨆ i, f i) * a = ⨆ i, f i * a 
goal: (⨆ i, f i) * a = ⨆ i, f i * a

full_name: NNReal.iSup_div
code: theorem iSup_div (f : ι → ℝ≥0) (a : ℝ≥0) : (⨆ i, f i) / a = ⨆ i, f i / a 
goal: (⨆ i, f i) / a = ⨆ i, f i / a

full_name: NNReal.mul_iSup_le
code: theorem mul_iSup_le {a : ℝ≥0} {g : ℝ≥0} {h : ι → ℝ≥0} (H : ∀ j, g * h j ≤ a) : g * iSup h ≤ a 
goal: g * iSup h ≤ a

full_name: NNReal.iSup_mul_le
code: theorem iSup_mul_le {a : ℝ≥0} {g : ι → ℝ≥0} {h : ℝ≥0} (H : ∀ i, g i * h ≤ a) : iSup g * h ≤ a 
goal: iSup g * h ≤ a

full_name: NNReal.iSup_mul_iSup_le
code: theorem iSup_mul_iSup_le {a : ℝ≥0} {g h : ι → ℝ≥0} (H : ∀ i j, g i * h j ≤ a) :
    iSup g * iSup h ≤ a 
goal: iSup g * iSup h ≤ a

full_name: NNReal.le_mul_iInf
code: theorem le_mul_iInf {a : ℝ≥0} {g : ℝ≥0} {h : ι → ℝ≥0} (H : ∀ j, a ≤ g * h j) : a ≤ g * iInf h 
goal: a ≤ g * iInf h

full_name: NNReal.le_iInf_mul
code: theorem le_iInf_mul {a : ℝ≥0} {g : ι → ℝ≥0} {h : ℝ≥0} (H : ∀ i, a ≤ g i * h) : a ≤ iInf g * h 
goal: a ≤ iInf g * h

full_name: NNReal.le_iInf_mul_iInf
code: theorem le_iInf_mul_iInf {a : ℝ≥0} {g h : ι → ℝ≥0} (H : ∀ i j, a ≤ g i * h j) :
    a ≤ iInf g * iInf h 
goal: a ≤ iInf g * iInf h

full_name: Set.OrdConnected.preimage_coe_nnreal_real
code: theorem preimage_coe_nnreal_real (h : s.OrdConnected) : ((↑) ⁻¹' s : Set ℝ≥0).OrdConnected 
goal: (NNReal.toReal ⁻¹' s).OrdConnected

full_name: Set.OrdConnected.image_coe_nnreal_real
code: theorem image_coe_nnreal_real (h : t.OrdConnected) : ((↑) '' t : Set ℝ).OrdConnected 
goal: (NNReal.toReal '' t).OrdConnected

full_name: Set.OrdConnected.image_real_toNNReal
code: theorem image_real_toNNReal (h : s.OrdConnected) : (Real.toNNReal '' s).OrdConnected 
goal: (Real.toNNReal '' s).OrdConnected

full_name: Set.OrdConnected.preimage_real_toNNReal
code: theorem preimage_real_toNNReal (h : t.OrdConnected) : (Real.toNNReal ⁻¹' t).OrdConnected 
goal: (Real.toNNReal ⁻¹' t).OrdConnected

full_name: Real.nnabs
code: /-- The absolute value on `ℝ` as a map to `ℝ≥0`. -/
-- Porting note (kmill): `pp_nodot` has no affect here
-- unless RFC lean4#1910 leads to dot notation for CoeFun
@[pp_nodot]
def nnabs : ℝ →*₀ ℝ≥0 
goal: ℝ →*₀ ℝ≥0

full_name: Real.coe_nnabs
code: @[norm_cast, simp]
theorem coe_nnabs (x : ℝ) : (nnabs x : ℝ) = |x| 
goal: ↑(Real.nnabs x) = |x|

full_name: Real.nnabs_of_nonneg
code: @[simp]
theorem nnabs_of_nonneg {x : ℝ} (h : 0 ≤ x) : nnabs x = toNNReal x 
goal: Real.nnabs x = x.toNNReal

full_name: Real.nnabs_coe
code: theorem nnabs_coe (x : ℝ≥0) : nnabs x = x 
goal: Real.nnabs ↑x = x

full_name: Real.coe_toNNReal_le
code: theorem coe_toNNReal_le (x : ℝ) : (toNNReal x : ℝ) ≤ |x| 
goal: ↑x.toNNReal ≤ |x|

full_name: Real.toNNReal_abs
code: @[simp] lemma toNNReal_abs (x : ℝ) : |x|.toNNReal = nnabs x 
goal: |x|.toNNReal = Real.nnabs x

full_name: Real.cast_natAbs_eq_nnabs_cast
code: theorem cast_natAbs_eq_nnabs_cast (n : ℤ) : (n.natAbs : ℝ≥0) = nnabs n 
goal: ↑n.natAbs = Real.nnabs ↑n

full_name: NNReal.exists_lt_of_strictMono
code: /-- If `Γ₀ˣ` is nontrivial and `f : Γ₀ →*₀ ℝ≥0` is strictly monotone, then for any positive
  `r : ℝ≥0`, there exists `d : Γ₀ˣ` with `f d < r`. -/
theorem NNReal.exists_lt_of_strictMono [h : Nontrivial Γ₀ˣ] {f : Γ₀ →*₀ ℝ≥0} (hf : StrictMono f)
    {r : ℝ≥0} (hr : 0 < r) : ∃ d : Γ₀ˣ, f d < r 
goal: ∃ d, f ↑d < r

full_name: Real.exists_lt_of_strictMono
code: /-- If `Γ₀ˣ` is nontrivial and `f : Γ₀ →*₀ ℝ≥0` is strictly monotone, then for any positive
  real `r`, there exists `d : Γ₀ˣ` with `f d < r`. -/
theorem Real.exists_lt_of_strictMono [h : Nontrivial Γ₀ˣ] {f : Γ₀ →*₀ ℝ≥0} (hf : StrictMono f)
    {r : ℝ} (hr : 0 < r) : ∃ d : Γ₀ˣ, (f d : ℝ) < r 
goal: ∃ d, ↑(f ↑d) < r

full_name: Mathlib.Meta.Positivity.evalNNRealtoReal
code: /-- Extension for the `positivity` tactic: cast from `ℝ≥0` to `ℝ`. -/
@[positivity NNReal.toReal _]
def evalNNRealtoReal : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt