File: Mathlib/Algebra/Order/Archimedean.lean

full_name: Archimedean.arch
code: /-- An ordered additive commutative monoid is called `Archimedean` if for any two elements `x`, `y`
such that `0 < y`, there exists a natural number `n` such that `x ≤ n • y`. -/
class Archimedean (α) [OrderedAddCommMonoid α] : Prop where
  /-- For any two elements `x`, `y` such that `0 < y`, there exists a natural number `n`
  such that `x ≤ n • y`. -/
  arch : ∀ (x : α) {y : α}, 0 < y → ∃ n : ℕ, x ≤ n • y
goal: 0 < y → ∃ n, x ≤ n • y

full_name: Archimedean
code: /-- An ordered additive commutative monoid is called `Archimedean` if for any two elements `x`, `y`
such that `0 < y`, there exists a natural number `n` such that `x ≤ n • y`. -/
class Archimedean (α) [OrderedAddCommMonoid α] : Prop where
  /-- For any two elements `x`, `y` such that `0 < y`, there exists a natural number `n`
  such that `x ≤ n • y`. -/
  arch : ∀ (x : α) {y : α}, 0 < y → ∃ n : ℕ, x ≤ n • y
goal: Prop

full_name: OrderDual.archimedean
code: instance OrderDual.archimedean [OrderedAddCommGroup α] [Archimedean α] : Archimedean αᵒᵈ 
goal: Archimedean αᵒᵈ

full_name: exists_lt_nsmul
code: theorem exists_lt_nsmul [OrderedAddCommMonoid M] [Archimedean M]
    [CovariantClass M M (· + ·) (· < ·)] {a : M} (ha : 0 < a) (b : M) :
    ∃ n : ℕ, b < n • a 
goal: ∃ n, b < n • a

full_name: existsUnique_zsmul_near_of_pos
code: /-- An archimedean decidable linearly ordered `AddCommGroup` has a version of the floor: for
`a > 0`, any `g` in the group lies between some two consecutive multiples of `a`. -/
theorem existsUnique_zsmul_near_of_pos {a : α} (ha : 0 < a) (g : α) :
    ∃! k : ℤ, k • a ≤ g ∧ g < (k + 1) • a 
goal: ∃! k, k • a ≤ g ∧ g < (k + 1) • a

full_name: existsUnique_zsmul_near_of_pos'
code: theorem existsUnique_zsmul_near_of_pos' {a : α} (ha : 0 < a) (g : α) :
    ∃! k : ℤ, 0 ≤ g - k • a ∧ g - k • a < a 
goal: ∃! k, 0 ≤ g - k • a ∧ g - k • a < a

full_name: existsUnique_sub_zsmul_mem_Ico
code: theorem existsUnique_sub_zsmul_mem_Ico {a : α} (ha : 0 < a) (b c : α) :
    ∃! m : ℤ, b - m • a ∈ Set.Ico c (c + a) 
goal: ∃! m, b - m • a ∈ Set.Ico c (c + a)

full_name: existsUnique_add_zsmul_mem_Ico
code: theorem existsUnique_add_zsmul_mem_Ico {a : α} (ha : 0 < a) (b c : α) :
    ∃! m : ℤ, b + m • a ∈ Set.Ico c (c + a) 
goal: ∃! m, b + m • a ∈ Set.Ico c (c + a)

full_name: existsUnique_add_zsmul_mem_Ioc
code: theorem existsUnique_add_zsmul_mem_Ioc {a : α} (ha : 0 < a) (b c : α) :
    ∃! m : ℤ, b + m • a ∈ Set.Ioc c (c + a) 
goal: ∃! m, b + m • a ∈ Set.Ioc c (c + a)

full_name: existsUnique_sub_zsmul_mem_Ioc
code: theorem existsUnique_sub_zsmul_mem_Ioc {a : α} (ha : 0 < a) (b c : α) :
    ∃! m : ℤ, b - m • a ∈ Set.Ioc c (c + a) 
goal: ∃! m, b - m • a ∈ Set.Ioc c (c + a)

full_name: exists_nat_ge
code: theorem exists_nat_ge [OrderedSemiring α] [Archimedean α] (x : α) : ∃ n : ℕ, x ≤ n 
goal: ∃ n, x ≤ ↑n

full_name: instIsDirectedLeOfArchimedean
code: instance (priority := 100) [OrderedSemiring α] [Archimedean α] : IsDirected α (· ≤ ·) 
goal: IsDirected α fun x x_1 => x ≤ x_1

full_name: exists_nat_gt
code: lemma exists_nat_gt (x : α) : ∃ n : ℕ, x < n 
goal: ∃ n, x < ↑n

full_name: add_one_pow_unbounded_of_pos
code: theorem add_one_pow_unbounded_of_pos (x : α) (hy : 0 < y) : ∃ n : ℕ, x < (y + 1) ^ n 
goal: ∃ n, x < (y + 1) ^ n

full_name: pow_unbounded_of_one_lt
code: lemma pow_unbounded_of_one_lt [ExistsAddOfLE α] (x : α) (hy1 : 1 < y) : ∃ n : ℕ, x < y ^ n 
goal: ∃ n, x < y ^ n

full_name: exists_int_gt
code: theorem exists_int_gt (x : α) : ∃ n : ℤ, x < n 
goal: ∃ n, x < ↑n

full_name: exists_int_lt
code: theorem exists_int_lt (x : α) : ∃ n : ℤ, (n : α) < x 
goal: ∃ n, ↑n < x

full_name: exists_floor
code: theorem exists_floor (x : α) : ∃ fl : ℤ, ∀ z : ℤ, z ≤ fl ↔ (z : α) ≤ x 
goal: ∃ fl, ∀ (z : ℤ), z ≤ fl ↔ ↑z ≤ x

full_name: exists_nat_pow_near
code: /-- Every x greater than or equal to 1 is between two successive
natural-number powers of every y greater than one. -/
theorem exists_nat_pow_near (hx : 1 ≤ x) (hy : 1 < y) : ∃ n : ℕ, y ^ n ≤ x ∧ x < y ^ (n + 1) 
goal: ∃ n, y ^ n ≤ x ∧ x < y ^ (n + 1)

full_name: exists_mem_Ico_zpow
code: /-- Every positive `x` is between two successive integer powers of
another `y` greater than one. This is the same as `exists_mem_Ioc_zpow`,
but with ≤ and < the other way around. -/
theorem exists_mem_Ico_zpow (hx : 0 < x) (hy : 1 < y) : ∃ n : ℤ, x ∈ Ico (y ^ n) (y ^ (n + 1)) 
goal: ∃ n, x ∈ Set.Ico (y ^ n) (y ^ (n + 1))

full_name: exists_mem_Ioc_zpow
code: /-- Every positive `x` is between two successive integer powers of
another `y` greater than one. This is the same as `exists_mem_Ico_zpow`,
but with ≤ and < the other way around. -/
theorem exists_mem_Ioc_zpow (hx : 0 < x) (hy : 1 < y) : ∃ n : ℤ, x ∈ Ioc (y ^ n) (y ^ (n + 1)) 
goal: ∃ n, x ∈ Set.Ioc (y ^ n) (y ^ (n + 1))

full_name: exists_pow_lt_of_lt_one
code: /-- For any `y < 1` and any positive `x`, there exists `n : ℕ` with `y ^ n < x`. -/
theorem exists_pow_lt_of_lt_one (hx : 0 < x) (hy : y < 1) : ∃ n : ℕ, y ^ n < x 
goal: ∃ n, y ^ n < x

full_name: exists_nat_pow_near_of_lt_one
code: /-- Given `x` and `y` between `0` and `1`, `x` is between two successive powers of `y`.
This is the same as `exists_nat_pow_near`, but for elements between `0` and `1` -/
theorem exists_nat_pow_near_of_lt_one (xpos : 0 < x) (hx : x ≤ 1) (ypos : 0 < y) (hy : y < 1) :
    ∃ n : ℕ, y ^ (n + 1) < x ∧ x ≤ y ^ n 
goal: ∃ n, y ^ (n + 1) < x ∧ x ≤ y ^ n

full_name: exists_nat_one_div_lt
code: lemma exists_nat_one_div_lt (hε : 0 < ε) : ∃ n : ℕ, 1 / (n + 1 : α) < ε 
goal: ∃ n, 1 / (↑n + 1) < ε

full_name: exists_rat_gt
code: theorem exists_rat_gt (x : α) : ∃ q : ℚ, x < q 
goal: ∃ q, x < ↑q

full_name: exists_rat_lt
code: theorem exists_rat_lt (x : α) : ∃ q : ℚ, (q : α) < x 
goal: ∃ q, ↑q < x

full_name: exists_rat_btwn
code: theorem exists_rat_btwn {x y : α} (h : x < y) : ∃ q : ℚ, x < q ∧ (q : α) < y 
goal: ∃ q, x < ↑q ∧ ↑q < y

full_name: le_of_forall_rat_lt_imp_le
code: theorem le_of_forall_rat_lt_imp_le (h : ∀ q : ℚ, (q : α) < x → (q : α) ≤ y) : x ≤ y 
goal: x ≤ y

full_name: le_of_forall_lt_rat_imp_le
code: theorem le_of_forall_lt_rat_imp_le (h : ∀ q : ℚ, y < q → x ≤ q) : x ≤ y 
goal: x ≤ y

full_name: le_iff_forall_rat_lt_imp_le
code: theorem le_iff_forall_rat_lt_imp_le : x ≤ y ↔ ∀ q : ℚ, (q : α) < x → (q : α) ≤ y 
goal: x ≤ y ↔ ∀ (q : ℚ), ↑q < x → ↑q ≤ y

full_name: le_iff_forall_lt_rat_imp_le
code: theorem le_iff_forall_lt_rat_imp_le : x ≤ y ↔ ∀ q : ℚ, y < q → x ≤ q 
goal: x ≤ y ↔ ∀ (q : ℚ), y < ↑q → x ≤ ↑q

full_name: eq_of_forall_rat_lt_iff_lt
code: theorem eq_of_forall_rat_lt_iff_lt (h : ∀ q : ℚ, (q : α) < x ↔ (q : α) < y) : x = y 
goal: x = y

full_name: eq_of_forall_lt_rat_iff_lt
code: theorem eq_of_forall_lt_rat_iff_lt (h : ∀ q : ℚ, x < q ↔ y < q) : x = y 
goal: x = y

full_name: exists_pos_rat_lt
code: theorem exists_pos_rat_lt {x : α} (x0 : 0 < x) : ∃ q : ℚ, 0 < q ∧ (q : α) < x 
goal: ∃ q, 0 < q ∧ ↑q < x

full_name: exists_rat_near
code: theorem exists_rat_near (x : α) (ε0 : 0 < ε) : ∃ q : ℚ, |x - q| < ε 
goal: ∃ q, |x - ↑q| < ε

full_name: archimedean_iff_nat_lt
code: theorem archimedean_iff_nat_lt : Archimedean α ↔ ∀ x : α, ∃ n : ℕ, x < n 
goal: Archimedean α ↔ ∀ (x : α), ∃ n, x < ↑n

full_name: archimedean_iff_nat_le
code: theorem archimedean_iff_nat_le : Archimedean α ↔ ∀ x : α, ∃ n : ℕ, x ≤ n 
goal: Archimedean α ↔ ∀ (x : α), ∃ n, x ≤ ↑n

full_name: archimedean_iff_int_lt
code: theorem archimedean_iff_int_lt : Archimedean α ↔ ∀ x : α, ∃ n : ℤ, x < n 
goal: Archimedean α ↔ ∀ (x : α), ∃ n, x < ↑n

full_name: archimedean_iff_int_le
code: theorem archimedean_iff_int_le : Archimedean α ↔ ∀ x : α, ∃ n : ℤ, x ≤ n 
goal: Archimedean α ↔ ∀ (x : α), ∃ n, x ≤ ↑n

full_name: archimedean_iff_rat_lt
code: theorem archimedean_iff_rat_lt : Archimedean α ↔ ∀ x : α, ∃ q : ℚ, x < q 
goal: Archimedean α ↔ ∀ (x : α), ∃ q, x < ↑q

full_name: archimedean_iff_rat_le
code: theorem archimedean_iff_rat_le : Archimedean α ↔ ∀ x : α, ∃ q : ℚ, x ≤ q 
goal: Archimedean α ↔ ∀ (x : α), ∃ q, x ≤ ↑q

full_name: instArchimedeanNat
code: instance : Archimedean ℕ 
goal: Archimedean ℕ

full_name: instArchimedeanInt
code: instance : Archimedean ℤ 
goal: Archimedean ℤ

full_name: instArchimedeanRat
code: instance : Archimedean ℚ 
goal: Archimedean ℚ

full_name: Nonneg.archimedean
code: instance Nonneg.archimedean [OrderedAddCommMonoid α] [Archimedean α] :
    Archimedean { x : α // 0 ≤ x } 
goal: Archimedean { x // 0 ≤ x }

full_name: instArchimedeanNNRat
code: instance : Archimedean NNRat 
goal: Archimedean ℚ≥0

full_name: Archimedean.floorRing
code: /-- A linear ordered archimedean ring is a floor ring. This is not an `instance` because in some
cases we have a computable `floor` function. -/
noncomputable def Archimedean.floorRing (α) [LinearOrderedRing α] [Archimedean α] : FloorRing α 
goal: FloorRing α

full_name: FloorRing.archimedean
code: /-- A linear ordered field that is a floor ring is archimedean. -/
instance (priority := 100) FloorRing.archimedean (α) [LinearOrderedField α] [FloorRing α] :
    Archimedean α 
goal: Archimedean α