File: Mathlib/Data/Real/Archimedean.lean

full_name: Real.instArchimedean
code: instance instArchimedean : Archimedean ℝ 
goal: Archimedean ℝ

full_name: Real.instFloorRing
code: noncomputable instance : FloorRing ℝ 
goal: FloorRing ℝ

full_name: Real.isCauSeq_iff_lift
code: theorem isCauSeq_iff_lift {f : ℕ → ℚ} : IsCauSeq abs f ↔ IsCauSeq abs fun i => (f i : ℝ) 
goal: IsCauSeq abs f ↔ IsCauSeq abs fun i => ↑(f i)

full_name: Real.of_near
code: theorem of_near (f : ℕ → ℚ) (x : ℝ) (h : ∀ ε > 0, ∃ i, ∀ j ≥ i, |(f j : ℝ) - x| < ε) :
    ∃ h', Real.mk ⟨f, h'⟩ = x 
goal: ∃ (h' : IsCauSeq abs f), Real.mk ⟨f, h'⟩ = x

full_name: Real.exists_floor
code: theorem exists_floor (x : ℝ) : ∃ ub : ℤ, (ub : ℝ) ≤ x ∧ ∀ z : ℤ, (z : ℝ) ≤ x → z ≤ ub 
goal: ∃ ub, ↑ub ≤ x ∧ ∀ (z : ℤ), ↑z ≤ x → z ≤ ub

full_name: Real.exists_isLUB
code: theorem exists_isLUB {S : Set ℝ} (hne : S.Nonempty) (hbdd : BddAbove S) : ∃ x, IsLUB S x 
goal: ∃ x, IsLUB S x

full_name: Real.exists_isGLB
code: /-- A nonempty, bounded below set of real numbers has a greatest lower bound. -/
theorem exists_isGLB {S : Set ℝ} (hne : S.Nonempty) (hbdd : BddBelow S) : ∃ x, IsGLB S x 
goal: ∃ x, IsGLB S x

full_name: Real.instSupSet
code: noncomputable instance : SupSet ℝ 
goal: SupSet ℝ

full_name: Real.sSup_def
code: theorem sSup_def (S : Set ℝ) :
    sSup S = if h : S.Nonempty ∧ BddAbove S then Classical.choose (exists_isLUB h.1 h.2) else 0 
goal: sSup S = if h : S.Nonempty ∧ BddAbove S then Classical.choose ⋯ else 0

full_name: Real.isLUB_sSup
code: protected theorem isLUB_sSup (S : Set ℝ) (h₁ : S.Nonempty) (h₂ : BddAbove S) :
    IsLUB S (sSup S) 
goal: IsLUB S (sSup S)

full_name: Real.instInfSet
code: noncomputable instance : InfSet ℝ 
goal: InfSet ℝ

full_name: Real.sInf_def
code: theorem sInf_def (S : Set ℝ) : sInf S = -sSup (-S) 
goal: sInf S = -sSup (-S)

full_name: Real.is_glb_sInf
code: protected theorem is_glb_sInf (S : Set ℝ) (h₁ : S.Nonempty) (h₂ : BddBelow S) :
    IsGLB S (sInf S) 
goal: IsGLB S (sInf S)

full_name: Real.instConditionallyCompleteLinearOrder
code: noncomputable instance : ConditionallyCompleteLinearOrder ℝ 
goal: ConditionallyCompleteLinearOrder ℝ

full_name: Real.lt_sInf_add_pos
code: theorem lt_sInf_add_pos {s : Set ℝ} (h : s.Nonempty) {ε : ℝ} (hε : 0 < ε) :
    ∃ a ∈ s, a < sInf s + ε 
goal: ∃ a ∈ s, a < sInf s + ε

full_name: Real.add_neg_lt_sSup
code: theorem add_neg_lt_sSup {s : Set ℝ} (h : s.Nonempty) {ε : ℝ} (hε : ε < 0) :
    ∃ a ∈ s, sSup s + ε < a 
goal: ∃ a ∈ s, sSup s + ε < a

full_name: Real.sInf_le_iff
code: theorem sInf_le_iff {s : Set ℝ} (h : BddBelow s) (h' : s.Nonempty) {a : ℝ} :
    sInf s ≤ a ↔ ∀ ε, 0 < ε → ∃ x ∈ s, x < a + ε 
goal: sInf s ≤ a ↔ ∀ (ε : ℝ), 0 < ε → ∃ x ∈ s, x < a + ε

full_name: Real.le_sSup_iff
code: theorem le_sSup_iff {s : Set ℝ} (h : BddAbove s) (h' : s.Nonempty) {a : ℝ} :
    a ≤ sSup s ↔ ∀ ε, ε < 0 → ∃ x ∈ s, a + ε < x 
goal: a ≤ sSup s ↔ ∀ ε < 0, ∃ x ∈ s, a + ε < x

full_name: Real.sSup_empty
code: @[simp]
theorem sSup_empty : sSup (∅ : Set ℝ) = 0 
goal: sSup ∅ = 0

full_name: Real.iSup_of_isEmpty
code: @[simp] lemma iSup_of_isEmpty {α : Sort*} [IsEmpty α] (f : α → ℝ) : ⨆ i, f i = 0 
goal: ⨆ i, f i = 0

full_name: Real.ciSup_const_zero
code: @[simp]
theorem ciSup_const_zero {α : Sort*} : ⨆ _ : α, (0 : ℝ) = 0 
goal: ⨆ x, 0 = 0

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

full_name: Real.iSup_of_not_bddAbove
code: theorem iSup_of_not_bddAbove {α : Sort*} {f : α → ℝ} (hf : ¬BddAbove (Set.range f)) :
    ⨆ i, f i = 0 
goal: ⨆ i, f i = 0

full_name: Real.sSup_univ
code: theorem sSup_univ : sSup (@Set.univ ℝ) = 0 
goal: sSup Set.univ = 0

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

full_name: Real.iInf_of_isEmpty
code: @[simp] nonrec lemma iInf_of_isEmpty {α : Sort*} [IsEmpty α] (f : α → ℝ) : ⨅ i, f i = 0 
goal: ⨅ i, f i = 0

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

full_name: Real.sInf_of_not_bddBelow
code: theorem sInf_of_not_bddBelow {s : Set ℝ} (hs : ¬BddBelow s) : sInf s = 0 
goal: sInf s = 0

full_name: Real.iInf_of_not_bddBelow
code: theorem iInf_of_not_bddBelow {α : Sort*} {f : α → ℝ} (hf : ¬BddBelow (Set.range f)) :
    ⨅ i, f i = 0 
goal: ⨅ i, f i = 0

full_name: Real.sSup_nonneg
code: /--
As `0` is the default value for `Real.sSup` of the empty set or sets which are not bounded above, it
suffices to show that `S` is bounded below by `0` to show that `0 ≤ sSup S`.
-/
theorem sSup_nonneg (S : Set ℝ) (hS : ∀ x ∈ S, (0 : ℝ) ≤ x) : 0 ≤ sSup S 
goal: 0 ≤ sSup S

full_name: Real.iSup_nonneg
code: /--
As `0` is the default value for `Real.sSup` of the empty set or sets which are not bounded above, it
suffices to show that `f i` is nonnegative to show that `0 ≤ ⨆ i, f i`.
-/
protected theorem iSup_nonneg {ι : Sort*} {f : ι → ℝ} (hf : ∀ i, 0 ≤ f i) : 0 ≤ ⨆ i, f i 
goal: 0 ≤ ⨆ i, f i

full_name: Real.sSup_le
code: /--
As `0` is the default value for `Real.sSup` of the empty set or sets which are not bounded above, it
suffices to show that all elements of `S` are bounded by a nonnegative number to show that `sSup S`
is bounded by this number.
-/
protected theorem sSup_le {S : Set ℝ} {a : ℝ} (hS : ∀ x ∈ S, x ≤ a) (ha : 0 ≤ a) : sSup S ≤ a 
goal: sSup S ≤ a

full_name: Real.iSup_le
code: protected theorem iSup_le {ι : Sort*} {f : ι → ℝ} {a : ℝ} (hS : ∀ i, f i ≤ a) (ha : 0 ≤ a) :
    ⨆ i, f i ≤ a 
goal: ⨆ i, f i ≤ a

full_name: Real.sSup_nonpos
code: /-- As `0` is the default value for `Real.sSup` of the empty set, it suffices to show that `S` is
bounded above by `0` to show that `sSup S ≤ 0`.
-/
theorem sSup_nonpos (S : Set ℝ) (hS : ∀ x ∈ S, x ≤ (0 : ℝ)) : sSup S ≤ 0 
goal: sSup S ≤ 0

full_name: Real.sInf_nonneg
code: /-- As `0` is the default value for `Real.sInf` of the empty set, it suffices to show that `S` is
bounded below by `0` to show that `0 ≤ sInf S`.
-/
theorem sInf_nonneg (S : Set ℝ) (hS : ∀ x ∈ S, (0 : ℝ) ≤ x) : 0 ≤ sInf S 
goal: 0 ≤ sInf S

full_name: Real.iInf_nonneg
code: /-- As `0` is the default value for `Real.sInf` of the empty set, it suffices to show that `f i` is
bounded below by `0` to show that `0 ≤ iInf f`.
-/
theorem iInf_nonneg {ι} {f : ι → ℝ} (hf : ∀ i, 0 ≤ f i) : 0 ≤ iInf f 
goal: 0 ≤ iInf f

full_name: Real.sInf_nonpos
code: /--
As `0` is the default value for `Real.sInf` of the empty set or sets which are not bounded below, it
suffices to show that `S` is bounded above by `0` to show that `sInf S ≤ 0`.
-/
theorem sInf_nonpos (S : Set ℝ) (hS : ∀ x ∈ S, x ≤ (0 : ℝ)) : sInf S ≤ 0 
goal: sInf S ≤ 0

full_name: Real.sInf_le_sSup
code: theorem sInf_le_sSup (s : Set ℝ) (h₁ : BddBelow s) (h₂ : BddAbove s) : sInf s ≤ sSup s 
goal: sInf s ≤ sSup s

full_name: Real.cauSeq_converges
code: theorem cauSeq_converges (f : CauSeq ℝ abs) : ∃ x, f ≈ const abs x 
goal: ∃ x, f ≈ CauSeq.const abs x

full_name: Real.instIsCompleteAbs
code: instance : CauSeq.IsComplete ℝ abs 
goal: CauSeq.IsComplete ℝ abs

full_name: Real.iInf_Ioi_eq_iInf_rat_gt
code: theorem iInf_Ioi_eq_iInf_rat_gt {f : ℝ → ℝ} (x : ℝ) (hf : BddBelow (f '' Ioi x))
    (hf_mono : Monotone f) : ⨅ r : Ioi x, f r = ⨅ q : { q' : ℚ // x < q' }, f q 
goal: ⨅ r, f ↑r = ⨅ q, f ↑↑q

full_name: Real.not_bddAbove_coe
code: theorem not_bddAbove_coe : ¬ (BddAbove <| range (fun (x : ℚ) ↦ (x : ℝ))) 
goal: ¬BddAbove (Set.range fun x => ↑x)

full_name: Real.not_bddBelow_coe
code: theorem not_bddBelow_coe : ¬ (BddBelow <| range (fun (x : ℚ) ↦ (x : ℝ))) 
goal: ¬BddBelow (Set.range fun x => ↑x)

full_name: Real.iUnion_Iic_rat
code: theorem iUnion_Iic_rat : ⋃ r : ℚ, Iic (r : ℝ) = univ 
goal: ⋃ r, Set.Iic ↑r = Set.univ

full_name: Real.iInter_Iic_rat
code: theorem iInter_Iic_rat : ⋂ r : ℚ, Iic (r : ℝ) = ∅ 
goal: ⋂ r, Set.Iic ↑r = ∅