File: Mathlib/NumberTheory/Liouville/LiouvilleWith.lean

full_name: LiouvilleWith
code: /-- We say that a real number `x` is a Liouville number with exponent `p : ℝ` if there exists a real
number `C` such that for infinitely many denominators `n` there exists a numerator `m` such that
`x ≠ m / n` and `|x - m / n| < C / n ^ p`.

A number is a Liouville number in the sense of `Liouville` if it is `LiouvilleWith` any real
exponent. -/
def LiouvilleWith (p x : ℝ) : Prop 
goal: Prop

full_name: liouvilleWith_one
code: /-- For `p = 1` (hence, for any `p ≤ 1`), the condition `LiouvilleWith p x` is trivial. -/
theorem liouvilleWith_one (x : ℝ) : LiouvilleWith 1 x 
goal: LiouvilleWith 1 x

full_name: LiouvilleWith.exists_pos
code: /-- The constant `C` provided by the definition of `LiouvilleWith` can be made positive.
We also add `1 ≤ n` to the list of assumptions about the denominator. While it is equivalent to
the original statement, the case `n = 0` breaks many arguments. -/
theorem exists_pos (h : LiouvilleWith p x) :
    ∃ (C : ℝ) (_h₀ : 0 < C),
      ∃ᶠ n : ℕ in atTop, 1 ≤ n ∧ ∃ m : ℤ, x ≠ m / n ∧ |x - m / n| < C / n ^ p 
goal: ∃ C, ∃ (_ : 0 < C), ∃ᶠ (n : ℕ) in Filter.atTop, 1 ≤ n ∧ ∃ m, x ≠ ↑m / ↑n ∧ |x - ↑m / ↑n| < C / ↑n ^ p

full_name: LiouvilleWith.mono
code: /-- If a number is Liouville with exponent `p`, then it is Liouville with any smaller exponent. -/
theorem mono (h : LiouvilleWith p x) (hle : q ≤ p) : LiouvilleWith q x 
goal: LiouvilleWith q x

full_name: LiouvilleWith.frequently_lt_rpow_neg
code: /-- If `x` satisfies Liouville condition with exponent `p` and `q < p`, then `x`
satisfies Liouville condition with exponent `q` and constant `1`. -/
theorem frequently_lt_rpow_neg (h : LiouvilleWith p x) (hlt : q < p) :
    ∃ᶠ n : ℕ in atTop, ∃ m : ℤ, x ≠ m / n ∧ |x - m / n| < n ^ (-q) 
goal: ∃ᶠ (n : ℕ) in Filter.atTop, ∃ m, x ≠ ↑m / ↑n ∧ |x - ↑m / ↑n| < ↑n ^ (-q)

full_name: LiouvilleWith.mul_rat
code: /-- The product of a Liouville number and a nonzero rational number is again a Liouville number.  -/
theorem mul_rat (h : LiouvilleWith p x) (hr : r ≠ 0) : LiouvilleWith p (x * r) 
goal: LiouvilleWith p (x * ↑r)

full_name: LiouvilleWith.mul_rat_iff
code: /-- The product `x * r`, `r : ℚ`, `r ≠ 0`, is a Liouville number with exponent `p` if and only if
`x` satisfies the same condition. -/
theorem mul_rat_iff (hr : r ≠ 0) : LiouvilleWith p (x * r) ↔ LiouvilleWith p x 
goal: LiouvilleWith p (x * ↑r) ↔ LiouvilleWith p x

full_name: LiouvilleWith.rat_mul_iff
code: /-- The product `r * x`, `r : ℚ`, `r ≠ 0`, is a Liouville number with exponent `p` if and only if
`x` satisfies the same condition. -/
theorem rat_mul_iff (hr : r ≠ 0) : LiouvilleWith p (r * x) ↔ LiouvilleWith p x 
goal: LiouvilleWith p (↑r * x) ↔ LiouvilleWith p x

full_name: LiouvilleWith.rat_mul
code: theorem rat_mul (h : LiouvilleWith p x) (hr : r ≠ 0) : LiouvilleWith p (r * x) 
goal: LiouvilleWith p (↑r * x)

full_name: LiouvilleWith.mul_int_iff
code: theorem mul_int_iff (hm : m ≠ 0) : LiouvilleWith p (x * m) ↔ LiouvilleWith p x 
goal: LiouvilleWith p (x * ↑m) ↔ LiouvilleWith p x

full_name: LiouvilleWith.mul_int
code: theorem mul_int (h : LiouvilleWith p x) (hm : m ≠ 0) : LiouvilleWith p (x * m) 
goal: LiouvilleWith p (x * ↑m)

full_name: LiouvilleWith.int_mul_iff
code: theorem int_mul_iff (hm : m ≠ 0) : LiouvilleWith p (m * x) ↔ LiouvilleWith p x 
goal: LiouvilleWith p (↑m * x) ↔ LiouvilleWith p x

full_name: LiouvilleWith.int_mul
code: theorem int_mul (h : LiouvilleWith p x) (hm : m ≠ 0) : LiouvilleWith p (m * x) 
goal: LiouvilleWith p (↑m * x)

full_name: LiouvilleWith.mul_nat_iff
code: theorem mul_nat_iff (hn : n ≠ 0) : LiouvilleWith p (x * n) ↔ LiouvilleWith p x 
goal: LiouvilleWith p (x * ↑n) ↔ LiouvilleWith p x

full_name: LiouvilleWith.mul_nat
code: theorem mul_nat (h : LiouvilleWith p x) (hn : n ≠ 0) : LiouvilleWith p (x * n) 
goal: LiouvilleWith p (x * ↑n)

full_name: LiouvilleWith.nat_mul_iff
code: theorem nat_mul_iff (hn : n ≠ 0) : LiouvilleWith p (n * x) ↔ LiouvilleWith p x 
goal: LiouvilleWith p (↑n * x) ↔ LiouvilleWith p x

full_name: LiouvilleWith.nat_mul
code: theorem nat_mul (h : LiouvilleWith p x) (hn : n ≠ 0) : LiouvilleWith p (n * x) 
goal: LiouvilleWith p (↑n * x)

full_name: LiouvilleWith.add_rat
code: theorem add_rat (h : LiouvilleWith p x) (r : ℚ) : LiouvilleWith p (x + r) 
goal: LiouvilleWith p (x + ↑r)

full_name: LiouvilleWith.add_rat_iff
code: @[simp]
theorem add_rat_iff : LiouvilleWith p (x + r) ↔ LiouvilleWith p x 
goal: LiouvilleWith p (x + ↑r) ↔ LiouvilleWith p x

full_name: LiouvilleWith.rat_add_iff
code: @[simp]
theorem rat_add_iff : LiouvilleWith p (r + x) ↔ LiouvilleWith p x 
goal: LiouvilleWith p (↑r + x) ↔ LiouvilleWith p x

full_name: LiouvilleWith.rat_add
code: theorem rat_add (h : LiouvilleWith p x) (r : ℚ) : LiouvilleWith p (r + x) 
goal: LiouvilleWith p (↑r + x)

full_name: LiouvilleWith.add_int_iff
code: @[simp]
theorem add_int_iff : LiouvilleWith p (x + m) ↔ LiouvilleWith p x 
goal: LiouvilleWith p (x + ↑m) ↔ LiouvilleWith p x

full_name: LiouvilleWith.int_add_iff
code: @[simp]
theorem int_add_iff : LiouvilleWith p (m + x) ↔ LiouvilleWith p x 
goal: LiouvilleWith p (↑m + x) ↔ LiouvilleWith p x

full_name: LiouvilleWith.add_nat_iff
code: @[simp]
theorem add_nat_iff : LiouvilleWith p (x + n) ↔ LiouvilleWith p x 
goal: LiouvilleWith p (x + ↑n) ↔ LiouvilleWith p x

full_name: LiouvilleWith.nat_add_iff
code: @[simp]
theorem nat_add_iff : LiouvilleWith p (n + x) ↔ LiouvilleWith p x 
goal: LiouvilleWith p (↑n + x) ↔ LiouvilleWith p x

full_name: LiouvilleWith.add_int
code: theorem add_int (h : LiouvilleWith p x) (m : ℤ) : LiouvilleWith p (x + m) 
goal: LiouvilleWith p (x + ↑m)

full_name: LiouvilleWith.int_add
code: theorem int_add (h : LiouvilleWith p x) (m : ℤ) : LiouvilleWith p (m + x) 
goal: LiouvilleWith p (↑m + x)

full_name: LiouvilleWith.add_nat
code: theorem add_nat (h : LiouvilleWith p x) (n : ℕ) : LiouvilleWith p (x + n) 
goal: LiouvilleWith p (x + ↑n)

full_name: LiouvilleWith.nat_add
code: theorem nat_add (h : LiouvilleWith p x) (n : ℕ) : LiouvilleWith p (n + x) 
goal: LiouvilleWith p (↑n + x)

full_name: LiouvilleWith.neg
code: protected theorem neg (h : LiouvilleWith p x) : LiouvilleWith p (-x) 
goal: LiouvilleWith p (-x)

full_name: LiouvilleWith.neg_iff
code: @[simp]
theorem neg_iff : LiouvilleWith p (-x) ↔ LiouvilleWith p x 
goal: LiouvilleWith p (-x) ↔ LiouvilleWith p x

full_name: LiouvilleWith.sub_rat_iff
code: @[simp]
theorem sub_rat_iff : LiouvilleWith p (x - r) ↔ LiouvilleWith p x 
goal: LiouvilleWith p (x - ↑r) ↔ LiouvilleWith p x

full_name: LiouvilleWith.sub_rat
code: theorem sub_rat (h : LiouvilleWith p x) (r : ℚ) : LiouvilleWith p (x - r) 
goal: LiouvilleWith p (x - ↑r)

full_name: LiouvilleWith.sub_int_iff
code: @[simp]
theorem sub_int_iff : LiouvilleWith p (x - m) ↔ LiouvilleWith p x 
goal: LiouvilleWith p (x - ↑m) ↔ LiouvilleWith p x

full_name: LiouvilleWith.sub_int
code: theorem sub_int (h : LiouvilleWith p x) (m : ℤ) : LiouvilleWith p (x - m) 
goal: LiouvilleWith p (x - ↑m)

full_name: LiouvilleWith.sub_nat_iff
code: @[simp]
theorem sub_nat_iff : LiouvilleWith p (x - n) ↔ LiouvilleWith p x 
goal: LiouvilleWith p (x - ↑n) ↔ LiouvilleWith p x

full_name: LiouvilleWith.sub_nat
code: theorem sub_nat (h : LiouvilleWith p x) (n : ℕ) : LiouvilleWith p (x - n) 
goal: LiouvilleWith p (x - ↑n)

full_name: LiouvilleWith.rat_sub_iff
code: @[simp]
theorem rat_sub_iff : LiouvilleWith p (r - x) ↔ LiouvilleWith p x 
goal: LiouvilleWith p (↑r - x) ↔ LiouvilleWith p x

full_name: LiouvilleWith.rat_sub
code: theorem rat_sub (h : LiouvilleWith p x) (r : ℚ) : LiouvilleWith p (r - x) 
goal: LiouvilleWith p (↑r - x)

full_name: LiouvilleWith.int_sub_iff
code: @[simp]
theorem int_sub_iff : LiouvilleWith p (m - x) ↔ LiouvilleWith p x 
goal: LiouvilleWith p (↑m - x) ↔ LiouvilleWith p x

full_name: LiouvilleWith.int_sub
code: theorem int_sub (h : LiouvilleWith p x) (m : ℤ) : LiouvilleWith p (m - x) 
goal: LiouvilleWith p (↑m - x)

full_name: LiouvilleWith.nat_sub_iff
code: @[simp]
theorem nat_sub_iff : LiouvilleWith p (n - x) ↔ LiouvilleWith p x 
goal: LiouvilleWith p (↑n - x) ↔ LiouvilleWith p x

full_name: LiouvilleWith.nat_sub
code: theorem nat_sub (h : LiouvilleWith p x) (n : ℕ) : LiouvilleWith p (n - x) 
goal: LiouvilleWith p (↑n - x)

full_name: LiouvilleWith.ne_cast_int
code: theorem ne_cast_int (h : LiouvilleWith p x) (hp : 1 < p) (m : ℤ) : x ≠ m 
goal: x ≠ ↑m

full_name: LiouvilleWith.irrational
code: /-- A number satisfying the Liouville condition with exponent `p > 1` is an irrational number. -/
protected theorem irrational (h : LiouvilleWith p x) (hp : 1 < p) : Irrational x 
goal: Irrational x

full_name: Liouville.frequently_exists_num
code: /-- If `x` is a Liouville number, then for any `n`, for infinitely many denominators `b` there
exists a numerator `a` such that `x ≠ a / b` and `|x - a / b| < 1 / b ^ n`. -/
theorem frequently_exists_num (hx : Liouville x) (n : ℕ) :
    ∃ᶠ b : ℕ in atTop, ∃ a : ℤ, x ≠ a / b ∧ |x - a / b| < 1 / (b : ℝ) ^ n 
goal: ∃ᶠ (b : ℕ) in Filter.atTop, ∃ a, x ≠ ↑a / ↑b ∧ |x - ↑a / ↑b| < 1 / ↑b ^ n

full_name: Liouville.liouvilleWith
code: /-- A Liouville number is a Liouville number with any real exponent. -/
protected theorem liouvilleWith (hx : Liouville x) (p : ℝ) : LiouvilleWith p x 
goal: LiouvilleWith p x

full_name: forall_liouvilleWith_iff
code: /-- A number satisfies the Liouville condition with any exponent if and only if it is a Liouville
number. -/
theorem forall_liouvilleWith_iff {x : ℝ} : (∀ p, LiouvilleWith p x) ↔ Liouville x 
goal: (∀ (p : ℝ), LiouvilleWith p x) ↔ Liouville x