Theorem: Real.pi_lt_sqrtTwoAddSeries
File: Mathlib/Data/Real/Pi/Bounds.lean

tactic: apply lt_of_lt_of_le this (le_of_eq _)
state_before: n : ℕ
this : π < (√(2 - sqrtTwoAddSeries 0 n) / 2 + 1 / (2 ^ n) ^ 3 / 4) * 2 ^ (n + 2)
⊢ π < 2 ^ (n + 1) * √(2 - sqrtTwoAddSeries 0 n) + 1 / 4 ^ n
state_after: n : ℕ
this : π < (√(2 - sqrtTwoAddSeries 0 n) / 2 + 1 / (2 ^ n) ^ 3 / 4) * 2 ^ (n + 2)
⊢ (√(2 - sqrtTwoAddSeries 0 n) / 2 + 1 / (2 ^ n) ^ 3 / 4) * 2 ^ (n + 2) =
    2 ^ (n + 1) * √(2 - sqrtTwoAddSeries 0 n) + 1 / 4 ^ n

tactic: rw [add_mul]
state_before: n : ℕ
this : π < (√(2 - sqrtTwoAddSeries 0 n) / 2 + 1 / (2 ^ n) ^ 3 / 4) * 2 ^ (n + 2)
⊢ (√(2 - sqrtTwoAddSeries 0 n) / 2 + 1 / (2 ^ n) ^ 3 / 4) * 2 ^ (n + 2) =
    2 ^ (n + 1) * √(2 - sqrtTwoAddSeries 0 n) + 1 / 4 ^ n
state_after: n : ℕ
this : π < (√(2 - sqrtTwoAddSeries 0 n) / 2 + 1 / (2 ^ n) ^ 3 / 4) * 2 ^ (n + 2)
⊢ √(2 - sqrtTwoAddSeries 0 n) / 2 * 2 ^ (n + 2) + 1 / (2 ^ n) ^ 3 / 4 * 2 ^ (n + 2) =
    2 ^ (n + 1) * √(2 - sqrtTwoAddSeries 0 n) + 1 / 4 ^ n

tactic: congr 1
state_before: n : ℕ
this : π < (√(2 - sqrtTwoAddSeries 0 n) / 2 + 1 / (2 ^ n) ^ 3 / 4) * 2 ^ (n + 2)
⊢ √(2 - sqrtTwoAddSeries 0 n) / 2 * 2 ^ (n + 2) + 1 / (2 ^ n) ^ 3 / 4 * 2 ^ (n + 2) =
    2 ^ (n + 1) * √(2 - sqrtTwoAddSeries 0 n) + 1 / 4 ^ n
state_after: case e_a
n : ℕ
this : π < (√(2 - sqrtTwoAddSeries 0 n) / 2 + 1 / (2 ^ n) ^ 3 / 4) * 2 ^ (n + 2)
⊢ √(2 - sqrtTwoAddSeries 0 n) / 2 * 2 ^ (n + 2) = 2 ^ (n + 1) * √(2 - sqrtTwoAddSeries 0 n)

case e_a
n : ℕ
this : π < (√(2 - sqrtTwoAddSeries 0 n) / 2 + 1 / (2 ^ n) ^ 3 / 4) * 2 ^ (n + 2)
⊢ 1 / (2 ^ n) ^ 3 / 4 * 2 ^ (n + 2) = 1 / 4 ^ n

tactic: simp only [show (4 : ℝ) = 2 ^ 2 by norm_num, ← pow_mul, div_div, ← pow_add]
state_before: case e_a
n : ℕ
this : π < (√(2 - sqrtTwoAddSeries 0 n) / 2 + 1 / (2 ^ n) ^ 3 / 4) * 2 ^ (n + 2)
⊢ 1 / (2 ^ n) ^ 3 / 4 * 2 ^ (n + 2) = 1 / 4 ^ n
state_after: case e_a
n : ℕ
this : π < (√(2 - sqrtTwoAddSeries 0 n) / 2 + 1 / (2 ^ n) ^ 3 / 4) * 2 ^ (n + 2)
⊢ 1 / 2 ^ (n * 3 + 2) * 2 ^ (n + 2) = 1 / 2 ^ (2 * n)

tactic: rw [one_div, one_div, inv_mul_eq_iff_eq_mul₀, eq_comm, mul_inv_eq_iff_eq_mul₀, ← pow_add]
state_before: case e_a
n : ℕ
this : π < (√(2 - sqrtTwoAddSeries 0 n) / 2 + 1 / (2 ^ n) ^ 3 / 4) * 2 ^ (n + 2)
⊢ 1 / 2 ^ (n * 3 + 2) * 2 ^ (n + 2) = 1 / 2 ^ (2 * n)
state_after: case e_a
n : ℕ
this : π < (√(2 - sqrtTwoAddSeries 0 n) / 2 + 1 / (2 ^ n) ^ 3 / 4) * 2 ^ (n + 2)
⊢ 2 ^ (n * 3 + 2) = 2 ^ (n + 2 + 2 * n)

case e_a
n : ℕ
this : π < (√(2 - sqrtTwoAddSeries 0 n) / 2 + 1 / (2 ^ n) ^ 3 / 4) * 2 ^ (n + 2)
⊢ 2 ^ (2 * n) ≠ 0

case e_a
n : ℕ
this : π < (√(2 - sqrtTwoAddSeries 0 n) / 2 + 1 / (2 ^ n) ^ 3 / 4) * 2 ^ (n + 2)
⊢ 2 ^ (n * 3 + 2) ≠ 0

tactic: all_goals norm_num
state_before: case e_a
n : ℕ
this : π < (√(2 - sqrtTwoAddSeries 0 n) / 2 + 1 / (2 ^ n) ^ 3 / 4) * 2 ^ (n + 2)
⊢ 2 ^ (2 * n) ≠ 0

case e_a
n : ℕ
this : π < (√(2 - sqrtTwoAddSeries 0 n) / 2 + 1 / (2 ^ n) ^ 3 / 4) * 2 ^ (n + 2)
⊢ 2 ^ (n * 3 + 2) ≠ 0
state_after: no goals

tactic: rw [← div_lt_iff (by norm_num), ← sin_pi_over_two_pow_succ]
state_before: n : ℕ
⊢ π < (√(2 - sqrtTwoAddSeries 0 n) / 2 + 1 / (2 ^ n) ^ 3 / 4) * 2 ^ (n + 2)
state_after: n : ℕ
⊢ π / 2 ^ (n + 2) < sin (π / 2 ^ (n + 2)) + 1 / (2 ^ n) ^ 3 / 4

tactic: refine lt_of_lt_of_le (lt_add_of_sub_right_lt (sin_gt_sub_cube ?_ ?_)) ?_
state_before: n : ℕ
⊢ π / 2 ^ (n + 2) < sin (π / 2 ^ (n + 2)) + 1 / (2 ^ n) ^ 3 / 4
state_after: case refine_1
n : ℕ
⊢ 0 < π / 2 ^ (n + 2)

case refine_2
n : ℕ
⊢ π / 2 ^ (n + 2) ≤ 1

case refine_3
n : ℕ
⊢ sin (π / 2 ^ (n + 2)) + (π / 2 ^ (n + 2)) ^ 3 / 4 ≤ sin (π / 2 ^ (n + 2)) + 1 / (2 ^ n) ^ 3 / 4

tactic: apply add_le_add_left
state_before: case refine_3
n : ℕ
⊢ sin (π / 2 ^ (n + 2)) + (π / 2 ^ (n + 2)) ^ 3 / 4 ≤ sin (π / 2 ^ (n + 2)) + 1 / (2 ^ n) ^ 3 / 4
state_after: case refine_3.bc
n : ℕ
⊢ (π / 2 ^ (n + 2)) ^ 3 / 4 ≤ 1 / (2 ^ n) ^ 3 / 4

tactic: rw [div_le_div_right (by norm_num)]
state_before: case refine_3.bc
n : ℕ
⊢ (π / 2 ^ (n + 2)) ^ 3 / 4 ≤ 1 / (2 ^ n) ^ 3 / 4
state_after: case refine_3.bc
n : ℕ
⊢ (π / 2 ^ (n + 2)) ^ 3 ≤ 1 / (2 ^ n) ^ 3

tactic: rw [le_div_iff (by norm_num), ← mul_pow]
state_before: case refine_3.bc
n : ℕ
⊢ (π / 2 ^ (n + 2)) ^ 3 ≤ 1 / (2 ^ n) ^ 3
state_after: case refine_3.bc
n : ℕ
⊢ (π / 2 ^ (n + 2) * 2 ^ n) ^ 3 ≤ 1

tactic: refine le_trans ?_ (le_of_eq (one_pow 3))
state_before: case refine_3.bc
n : ℕ
⊢ (π / 2 ^ (n + 2) * 2 ^ n) ^ 3 ≤ 1
state_after: case refine_3.bc
n : ℕ
⊢ (π / 2 ^ (n + 2) * 2 ^ n) ^ 3 ≤ 1 ^ 3

tactic: apply pow_le_pow_left
state_before: case refine_3.bc
n : ℕ
⊢ (π / 2 ^ (n + 2) * 2 ^ n) ^ 3 ≤ 1 ^ 3
state_after: case refine_3.bc.ha
n : ℕ
⊢ 0 ≤ π / 2 ^ (n + 2) * 2 ^ n

case refine_3.bc.hab
n : ℕ
⊢ π / 2 ^ (n + 2) * 2 ^ n ≤ 1

tactic: norm_num
state_before: n : ℕ
⊢ 0 < 2 ^ (n + 2)
state_after: no goals

tactic: apply div_pos pi_pos
state_before: case refine_1
n : ℕ
⊢ 0 < π / 2 ^ (n + 2)
state_after: case refine_1
n : ℕ
⊢ 0 < 2 ^ (n + 2)

tactic: apply pow_pos
state_before: case refine_1
n : ℕ
⊢ 0 < 2 ^ (n + 2)
state_after: case refine_1.H
n : ℕ
⊢ 0 < 2

tactic: norm_num
state_before: case refine_1.H
n : ℕ
⊢ 0 < 2
state_after: no goals

tactic: rw [div_le_iff']
state_before: case refine_2
n : ℕ
⊢ π / 2 ^ (n + 2) ≤ 1
state_after: case refine_2
n : ℕ
⊢ π ≤ 2 ^ (n + 2) * 1

case refine_2
n : ℕ
⊢ 0 < 2 ^ (n + 2)

tactic: refine le_trans pi_le_four ?_
state_before: case refine_2
n : ℕ
⊢ π ≤ 2 ^ (n + 2) * 1
state_after: case refine_2
n : ℕ
⊢ 4 ≤ 2 ^ (n + 2) * 1

tactic: simp only [show (4 : ℝ) = (2 : ℝ) ^ 2 by norm_num, mul_one]
state_before: case refine_2
n : ℕ
⊢ 4 ≤ 2 ^ (n + 2) * 1
state_after: case refine_2
n : ℕ
⊢ 2 ^ 2 ≤ 2 ^ (n + 2)

tactic: apply pow_le_pow_right (by norm_num)
state_before: case refine_2
n : ℕ
⊢ 2 ^ 2 ≤ 2 ^ (n + 2)
state_after: case refine_2
n : ℕ
⊢ 2 ≤ n + 2

tactic: apply le_add_of_nonneg_left
state_before: case refine_2
n : ℕ
⊢ 2 ≤ n + 2
state_after: case refine_2.h
n : ℕ
⊢ 0 ≤ n

tactic: apply Nat.zero_le
state_before: case refine_2.h
n : ℕ
⊢ 0 ≤ n
state_after: no goals

tactic: norm_num
state_before: n : ℕ
⊢ 4 = 2 ^ 2
state_after: no goals

tactic: norm_num
state_before: n : ℕ
⊢ 1 ≤ 2
state_after: no goals

tactic: apply pow_pos
state_before: case refine_2
n : ℕ
⊢ 0 < 2 ^ (n + 2)
state_after: case refine_2.H
n : ℕ
⊢ 0 < 2

tactic: norm_num
state_before: case refine_2.H
n : ℕ
⊢ 0 < 2
state_after: no goals

tactic: norm_num
state_before: n : ℕ
⊢ 0 < 4
state_after: no goals

tactic: norm_num
state_before: n : ℕ
⊢ 0 < (2 ^ n) ^ 3
state_after: no goals

tactic: apply le_of_lt
state_before: case refine_3.bc.ha
n : ℕ
⊢ 0 ≤ π / 2 ^ (n + 2) * 2 ^ n
state_after: case refine_3.bc.ha.a
n : ℕ
⊢ 0 < π / 2 ^ (n + 2) * 2 ^ n

tactic: apply mul_pos
state_before: case refine_3.bc.ha.a
n : ℕ
⊢ 0 < π / 2 ^ (n + 2) * 2 ^ n
state_after: case refine_3.bc.ha.a.ha
n : ℕ
⊢ 0 < π / 2 ^ (n + 2)

case refine_3.bc.ha.a.hb
n : ℕ
⊢ 0 < 2 ^ n

tactic: apply div_pos pi_pos
state_before: case refine_3.bc.ha.a.ha
n : ℕ
⊢ 0 < π / 2 ^ (n + 2)
state_after: case refine_3.bc.ha.a.ha
n : ℕ
⊢ 0 < 2 ^ (n + 2)

tactic: apply pow_pos
state_before: case refine_3.bc.ha.a.ha
n : ℕ
⊢ 0 < 2 ^ (n + 2)
state_after: case refine_3.bc.ha.a.ha.H
n : ℕ
⊢ 0 < 2

tactic: norm_num
state_before: case refine_3.bc.ha.a.ha.H
n : ℕ
⊢ 0 < 2
state_after: no goals

tactic: apply pow_pos
state_before: case refine_3.bc.ha.a.hb
n : ℕ
⊢ 0 < 2 ^ n
state_after: case refine_3.bc.ha.a.hb.H
n : ℕ
⊢ 0 < 2

tactic: norm_num
state_before: case refine_3.bc.ha.a.hb.H
n : ℕ
⊢ 0 < 2
state_after: no goals

tactic: rw [← le_div_iff (by norm_num)]
state_before: case refine_3.bc.hab
n : ℕ
⊢ π / 2 ^ (n + 2) * 2 ^ n ≤ 1
state_after: case refine_3.bc.hab
n : ℕ
⊢ π / 2 ^ (n + 2) ≤ 1 / 2 ^ n

tactic: refine le_trans ((div_le_div_right ?_).mpr pi_le_four) ?_
state_before: case refine_3.bc.hab
n : ℕ
⊢ π / 2 ^ (n + 2) ≤ 1 / 2 ^ n
state_after: case refine_3.bc.hab.refine_1
n : ℕ
⊢ 0 < 2 ^ (n + 2)

case refine_3.bc.hab.refine_2
n : ℕ
⊢ 4 / 2 ^ (n + 2) ≤ 1 / 2 ^ n

tactic: norm_num
state_before: n : ℕ
⊢ 0 < 2 ^ n
state_after: no goals

tactic: apply pow_pos
state_before: case refine_3.bc.hab.refine_1
n : ℕ
⊢ 0 < 2 ^ (n + 2)
state_after: case refine_3.bc.hab.refine_1.H
n : ℕ
⊢ 0 < 2

tactic: norm_num
state_before: case refine_3.bc.hab.refine_1.H
n : ℕ
⊢ 0 < 2
state_after: no goals

tactic: simp only [pow_succ', ← div_div, one_div]
state_before: case refine_3.bc.hab.refine_2
n : ℕ
⊢ 4 / 2 ^ (n + 2) ≤ 1 / 2 ^ n
state_after: case refine_3.bc.hab.refine_2
n : ℕ
⊢ 4 / 2 / 2 / 2 ^ n ≤ (2 ^ n)⁻¹

tactic: norm_num
state_before: case refine_3.bc.hab.refine_2
n : ℕ
⊢ 4 / 2 / 2 / 2 ^ n ≤ (2 ^ n)⁻¹
state_after: no goals

tactic: ring
state_before: case e_a
n : ℕ
this : π < (√(2 - sqrtTwoAddSeries 0 n) / 2 + 1 / (2 ^ n) ^ 3 / 4) * 2 ^ (n + 2)
⊢ √(2 - sqrtTwoAddSeries 0 n) / 2 * 2 ^ (n + 2) = 2 ^ (n + 1) * √(2 - sqrtTwoAddSeries 0 n)
state_after: no goals

tactic: norm_num
state_before: n : ℕ
this : π < (√(2 - sqrtTwoAddSeries 0 n) / 2 + 1 / (2 ^ n) ^ 3 / 4) * 2 ^ (n + 2)
⊢ 4 = 2 ^ 2
state_after: no goals

tactic: rw [add_assoc, Nat.mul_succ, add_comm, add_comm n, add_assoc, mul_comm n]
state_before: case e_a
n : ℕ
this : π < (√(2 - sqrtTwoAddSeries 0 n) / 2 + 1 / (2 ^ n) ^ 3 / 4) * 2 ^ (n + 2)
⊢ 2 ^ (n * 3 + 2) = 2 ^ (n + 2 + 2 * n)
state_after: no goals

tactic: norm_num
state_before: case e_a
n : ℕ
this : π < (√(2 - sqrtTwoAddSeries 0 n) / 2 + 1 / (2 ^ n) ^ 3 / 4) * 2 ^ (n + 2)
⊢ 2 ^ (n * 3 + 2) ≠ 0
state_after: no goals