Theorem: Liouville.irrational
File: Mathlib/NumberTheory/Liouville/Basic.lean

tactic: rintro ⟨⟨a, b, bN0, cop⟩, rfl⟩
state_before: x : ℝ
h : Liouville x
⊢ Irrational x

tactic: rw [Rat.cast_mk', ← div_eq_mul_inv] at h
state_before: case intro.mk'
a : ℤ
b : ℕ
bN0 : b ≠ 0
cop : Nat.coprime (Int.natAbs a) b
h : Liouville ↑(Rat.mk' a b)
⊢ False

tactic: rcases h (b + 1) with ⟨p, q, q1, a0, a1⟩
state_before: case intro.mk'
a : ℤ
b : ℕ
bN0 : b ≠ 0
cop : Nat.coprime (Int.natAbs a) b
h : Liouville (↑a / ↑b)
⊢ False

tactic: have qR0 : (0 : ℝ) < q := Int.cast_pos.mpr (zero_lt_one.trans q1)
state_before: case intro.mk'.intro.intro.intro.intro
a : ℤ
b : ℕ
bN0 : b ≠ 0
cop : Nat.coprime (Int.natAbs a) b
h : Liouville (↑a / ↑b)
p q : ℤ
q1 : 1 < q
a0 : ↑a / ↑b ≠ ↑p / ↑q
a1 : abs (↑a / ↑b - ↑p / ↑q) < 1 / ↑q ^ (b + 1)
⊢ False

tactic: have b0 : (b : ℝ) ≠ 0 := Nat.cast_ne_zero.mpr bN0
state_before: case intro.mk'.intro.intro.intro.intro
a : ℤ
b : ℕ
bN0 : b ≠ 0
cop : Nat.coprime (Int.natAbs a) b
h : Liouville (↑a / ↑b)
p q : ℤ
q1 : 1 < q
a0 : ↑a / ↑b ≠ ↑p / ↑q
a1 : abs (↑a / ↑b - ↑p / ↑q) < 1 / ↑q ^ (b + 1)
qR0 : 0 < ↑q
⊢ False

tactic: have bq0 : (0 : ℝ) < b * q := mul_pos (Nat.cast_pos.mpr bN0.bot_lt) qR0
state_before: case intro.mk'.intro.intro.intro.intro
a : ℤ
b : ℕ
bN0 : b ≠ 0
cop : Nat.coprime (Int.natAbs a) b
h : Liouville (↑a / ↑b)
p q : ℤ
q1 : 1 < q
a0 : ↑a / ↑b ≠ ↑p / ↑q
a1 : abs (↑a / ↑b - ↑p / ↑q) < 1 / ↑q ^ (b + 1)
qR0 : 0 < ↑q
b0 : ↑b ≠ 0
⊢ False

tactic: replace a1 : |a * q - b * p| * q ^ (b + 1) < b * q
state_before: case intro.mk'.intro.intro.intro.intro
a : ℤ
b : ℕ
bN0 : b ≠ 0
cop : Nat.coprime (Int.natAbs a) b
h : Liouville (↑a / ↑b)
p q : ℤ
q1 : 1 < q
a0 : ↑a / ↑b ≠ ↑p / ↑q
a1 : abs (↑a / ↑b - ↑p / ↑q) < 1 / ↑q ^ (b + 1)
qR0 : 0 < ↑q
b0 : ↑b ≠ 0
bq0 : 0 < ↑b * ↑q
⊢ False

tactic: replace a0 : a * q - ↑b * p ≠ 0
state_before: case intro.mk'.intro.intro.intro.intro
a : ℤ
b : ℕ
bN0 : b ≠ 0
cop : Nat.coprime (Int.natAbs a) b
h : Liouville (↑a / ↑b)
p q : ℤ
q1 : 1 < q
a0 : ↑a / ↑b ≠ ↑p / ↑q
qR0 : 0 < ↑q
b0 : ↑b ≠ 0
bq0 : 0 < ↑b * ↑q
a1 : abs (a * q - ↑b * p) * q ^ (b + 1) < ↑b * q
⊢ False

tactic: lift q to ℕ using (zero_lt_one.trans q1).le
state_before: case intro.mk'.intro.intro.intro.intro
a : ℤ
b : ℕ
bN0 : b ≠ 0
cop : Nat.coprime (Int.natAbs a) b
h : Liouville (↑a / ↑b)
p q : ℤ
q1 : 1 < q
qR0 : 0 < ↑q
b0 : ↑b ≠ 0
bq0 : 0 < ↑b * ↑q
a1 : abs (a * q - ↑b * p) * q ^ (b + 1) < ↑b * q
a0 : a * q - ↑b * p ≠ 0
⊢ False

tactic: have ap : 0 < |a * ↑q - ↑b * p| := abs_pos.mpr a0
state_before: case intro.mk'.intro.intro.intro.intro.intro
a : ℤ
b : ℕ
bN0 : b ≠ 0
cop : Nat.coprime (Int.natAbs a) b
h : Liouville (↑a / ↑b)
p : ℤ
b0 : ↑b ≠ 0
q : ℕ
q1 : 1 < ↑q
qR0 : 0 < ↑↑q
bq0 : 0 < ↑b * ↑↑q
a1 : abs (a * ↑q - ↑b * p) * ↑q ^ (b + 1) < ↑b * ↑q
a0 : a * ↑q - ↑b * p ≠ 0
⊢ False

tactic: lift |a * ↑q - ↑b * p| to ℕ using abs_nonneg (a * ↑q - ↑b * p) with e he
state_before: case intro.mk'.intro.intro.intro.intro.intro
a : ℤ
b : ℕ
bN0 : b ≠ 0
cop : Nat.coprime (Int.natAbs a) b
h : Liouville (↑a / ↑b)
p : ℤ
b0 : ↑b ≠ 0
q : ℕ
q1 : 1 < ↑q
qR0 : 0 < ↑↑q
bq0 : 0 < ↑b * ↑↑q
a1 : abs (a * ↑q - ↑b * p) * ↑q ^ (b + 1) < ↑b * ↑q
a0 : a * ↑q - ↑b * p ≠ 0
ap : 0 < abs (a * ↑q - ↑b * p)
⊢ False

tactic: rw [← Int.ofNat_mul, ← Int.coe_nat_pow, ← Int.ofNat_mul, Int.ofNat_lt] at a1
state_before: case intro.mk'.intro.intro.intro.intro.intro.intro
a : ℤ
b : ℕ
bN0 : b ≠ 0
cop : Nat.coprime (Int.natAbs a) b
h : Liouville (↑a / ↑b)
p : ℤ
b0 : ↑b ≠ 0
q : ℕ
q1 : 1 < ↑q
qR0 : 0 < ↑↑q
bq0 : 0 < ↑b * ↑↑q
a0 : a * ↑q - ↑b * p ≠ 0
e : ℕ
he : ↑e = abs (a * ↑q - ↑b * p)
a1✝ a1 : ↑e * ↑q ^ (b + 1) < ↑b * ↑q
ap✝ ap : 0 < ↑e
⊢ False

tactic: exact not_le.mpr a1 (Nat.mul_lt_mul_pow_succ (Int.coe_nat_pos.mp ap) (Int.ofNat_lt.mp q1)).le
state_before: case intro.mk'.intro.intro.intro.intro.intro.intro
a : ℤ
b : ℕ
bN0 : b ≠ 0
cop : Nat.coprime (Int.natAbs a) b
h : Liouville (↑a / ↑b)
p : ℤ
b0 : ↑b ≠ 0
q : ℕ
q1 : 1 < ↑q
qR0 : 0 < ↑↑q
bq0 : 0 < ↑b * ↑↑q
a0 : a * ↑q - ↑b * p ≠ 0
e : ℕ
he : ↑e = abs (a * ↑q - ↑b * p)
a1✝ : ↑e * ↑q ^ (b + 1) < ↑b * ↑q
a1 : e * q ^ (b + 1) < b * q
ap✝ ap : 0 < ↑e
⊢ False

tactic: rw [div_sub_div _ _ b0 qR0.ne', abs_div, div_lt_div_iff (abs_pos.mpr bq0.ne') (pow_pos qR0 _),
  abs_of_pos bq0, one_mul] at a1
state_before: case a1
a : ℤ
b : ℕ
bN0 : b ≠ 0
cop : Nat.coprime (Int.natAbs a) b
h : Liouville (↑a / ↑b)
p q : ℤ
q1 : 1 < q
a0 : ↑a / ↑b ≠ ↑p / ↑q
a1 : abs (↑a / ↑b - ↑p / ↑q) < 1 / ↑q ^ (b + 1)
qR0 : 0 < ↑q
b0 : ↑b ≠ 0
bq0 : 0 < ↑b * ↑q
⊢ abs (a * q - ↑b * p) * q ^ (b + 1) < ↑b * q

tactic: exact_mod_cast a1
state_before: case a1
a : ℤ
b : ℕ
bN0 : b ≠ 0
cop : Nat.coprime (Int.natAbs a) b
h : Liouville (↑a / ↑b)
p q : ℤ
q1 : 1 < q
a0 : ↑a / ↑b ≠ ↑p / ↑q
a1 : abs (↑a * ↑q - ↑b * ↑p) * ↑q ^ (b + 1) < ↑b * ↑q
qR0 : 0 < ↑q
b0 : ↑b ≠ 0
bq0 : 0 < ↑b * ↑q
⊢ abs (a * q - ↑b * p) * q ^ (b + 1) < ↑b * q

tactic: rw [Ne.def, div_eq_div_iff b0 qR0.ne', mul_comm (p : ℝ), ← sub_eq_zero] at a0
state_before: case a0
a : ℤ
b : ℕ
bN0 : b ≠ 0
cop : Nat.coprime (Int.natAbs a) b
h : Liouville (↑a / ↑b)
p q : ℤ
q1 : 1 < q
a0 : ↑a / ↑b ≠ ↑p / ↑q
qR0 : 0 < ↑q
b0 : ↑b ≠ 0
bq0 : 0 < ↑b * ↑q
a1 : abs (a * q - ↑b * p) * q ^ (b + 1) < ↑b * q
⊢ a * q - ↑b * p ≠ 0

tactic: exact_mod_cast a0
state_before: case a0
a : ℤ
b : ℕ
bN0 : b ≠ 0
cop : Nat.coprime (Int.natAbs a) b
h : Liouville (↑a / ↑b)
p q : ℤ
q1 : 1 < q
a0✝ : ¬↑a * ↑q = ↑b * ↑p
a0 : ¬↑a * ↑q - ↑b * ↑p = 0
qR0 : 0 < ↑q
b0 : ↑b ≠ 0
bq0 : 0 < ↑b * ↑q
a1 : abs (a * q - ↑b * p) * q ^ (b + 1) < ↑b * q
⊢ a * q - ↑b * p ≠ 0