Theorem: GeneralizedContinuedFraction.abs_sub_convergents_le
File: Mathlib/Algebra/ContinuedFractions/Computation/Approximations.lean

tactic: let g := of v
state_before: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
⊢ |v - (of v).convergents n| ≤ 1 / ((of v).denominators n * (of v).denominators (n + 1))
state_after: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
⊢ |v - (of v).convergents n| ≤ 1 / ((of v).denominators n * (of v).denominators (n + 1))

tactic: let nextConts := g.continuantsAux (n + 2)
state_before: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
⊢ |v - (of v).convergents n| ≤ 1 / ((of v).denominators n * (of v).denominators (n + 1))
state_after: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
⊢ |v - (of v).convergents n| ≤ 1 / ((of v).denominators n * (of v).denominators (n + 1))

tactic: set conts := continuantsAux g (n + 1) with conts_eq
state_before: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
⊢ |v - (of v).convergents n| ≤ 1 / ((of v).denominators n * (of v).denominators (n + 1))
state_after: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
⊢ |v - (of v).convergents n| ≤ 1 / ((of v).denominators n * (of v).denominators (n + 1))

tactic: set pred_conts := continuantsAux g n with pred_conts_eq
state_before: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
⊢ |v - (of v).convergents n| ≤ 1 / ((of v).denominators n * (of v).denominators (n + 1))
state_after: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
⊢ |v - (of v).convergents n| ≤ 1 / ((of v).denominators n * (of v).denominators (n + 1))

tactic: change |v - convergents g n| ≤ 1 / (conts.b * nextConts.b)
state_before: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
⊢ |v - (of v).convergents n| ≤ 1 / ((of v).denominators n * (of v).denominators (n + 1))
state_after: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
⊢ |v - g.convergents n| ≤ 1 / (conts.b * nextConts.b)

tactic: obtain ⟨gp, s_nth_eq⟩ : ∃ gp, g.s.get? n = some gp :=
  Option.ne_none_iff_exists'.1 not_terminated_at_n
state_before: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
⊢ |v - g.convergents n| ≤ 1 / (conts.b * nextConts.b)
state_after: case intro
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
⊢ |v - g.convergents n| ≤ 1 / (conts.b * nextConts.b)

tactic: have gp_a_eq_one : gp.a = 1 := of_part_num_eq_one (part_num_eq_s_a s_nth_eq)
state_before: case intro
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
⊢ |v - g.convergents n| ≤ 1 / (conts.b * nextConts.b)
state_after: case intro
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
⊢ |v - g.convergents n| ≤ 1 / (conts.b * nextConts.b)

tactic: have nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b := by
  simp [nextConts, continuantsAux_recurrence s_nth_eq pred_conts_eq conts_eq, gp_a_eq_one,
    pred_conts_eq.symm, conts_eq.symm, add_comm]
state_before: case intro
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
⊢ |v - g.convergents n| ≤ 1 / (conts.b * nextConts.b)
state_after: case intro
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
⊢ |v - g.convergents n| ≤ 1 / (conts.b * nextConts.b)

tactic: let denom := conts.b * (pred_conts.b + gp.b * conts.b)
state_before: case intro
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
⊢ |v - g.convergents n| ≤ 1 / (conts.b * nextConts.b)
state_after: case intro
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
⊢ |v - g.convergents n| ≤ 1 / (conts.b * nextConts.b)

tactic: suffices |v - g.convergents n| ≤ 1 / denom by rw [nextConts_b_eq]; congr 1
state_before: case intro
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
⊢ |v - g.convergents n| ≤ 1 / (conts.b * nextConts.b)
state_after: case intro
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
⊢ |v - g.convergents n| ≤ 1 / denom

tactic: obtain ⟨ifp_succ_n, succ_nth_stream_eq, ifp_succ_n_b_eq_gp_b⟩ :
    ∃ ifp_succ_n, IntFractPair.stream v (n + 1) = some ifp_succ_n ∧ (ifp_succ_n.b : K) = gp.b :=
  IntFractPair.exists_succ_get?_stream_of_gcf_of_get?_eq_some s_nth_eq
state_before: case intro
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
⊢ |v - g.convergents n| ≤ 1 / denom
state_after: case intro.intro.intro
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
⊢ |v - g.convergents n| ≤ 1 / denom

tactic: obtain ⟨ifp_n, stream_nth_eq, stream_nth_fr_ne_zero, if_of_eq_ifp_succ_n⟩ :
  ∃ ifp_n, IntFractPair.stream v n = some ifp_n ∧ ifp_n.fr ≠ 0
    ∧ IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n :=
  IntFractPair.succ_nth_stream_eq_some_iff.1 succ_nth_stream_eq
state_before: case intro.intro.intro
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
⊢ |v - g.convergents n| ≤ 1 / denom
state_after: case intro.intro.intro.intro.intro.intro
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
⊢ |v - g.convergents n| ≤ 1 / denom

tactic: let denom' := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
state_before: case intro.intro.intro.intro.intro.intro
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
⊢ |v - g.convergents n| ≤ 1 / denom
state_after: case intro.intro.intro.intro.intro.intro
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
⊢ |v - g.convergents n| ≤ 1 / denom

tactic: suffices |(-1) ^ n / denom'| ≤ 1 / denom by
  have : v - g.convergents n = (-1) ^ n / denom' := by
    have tmp := sub_convergents_eq stream_nth_eq
    simp only [stream_nth_fr_ne_zero, conts_eq.symm, pred_conts_eq.symm, if_false] at tmp
    rw [tmp]
    ring
  rwa [this]
state_before: case intro.intro.intro.intro.intro.intro
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
⊢ |v - g.convergents n| ≤ 1 / denom
state_after: case intro.intro.intro.intro.intro.intro
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
⊢ |(-1) ^ n / denom'| ≤ 1 / denom

tactic: have nextConts_b_ineq : (fib (n + 2) : K) ≤ pred_conts.b + gp.b * conts.b := by
  have : (fib (n + 2) : K) ≤ nextConts.b :=
    fib_le_of_continuantsAux_b (Or.inr not_terminated_at_n)
  rwa [nextConts_b_eq] at this
state_before: case intro.intro.intro.intro.intro.intro
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
⊢ |(-1) ^ n / denom'| ≤ 1 / denom
state_after: case intro.intro.intro.intro.intro.intro
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
⊢ |(-1) ^ n / denom'| ≤ 1 / denom

tactic: have conts_b_ineq : (fib (n + 1) : K) ≤ conts.b :=
  haveI : ¬g.TerminatedAt (n - 1) := mt (terminated_stable n.pred_le) not_terminated_at_n
  fib_le_of_continuantsAux_b <| Or.inr this
state_before: case intro.intro.intro.intro.intro.intro
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
⊢ |(-1) ^ n / denom'| ≤ 1 / denom
state_after: case intro.intro.intro.intro.intro.intro
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
⊢ |(-1) ^ n / denom'| ≤ 1 / denom

tactic: have zero_lt_conts_b : 0 < conts.b :=
  conts_b_ineq.trans_lt' <| mod_cast fib_pos.2 n.succ_pos
state_before: case intro.intro.intro.intro.intro.intro
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
⊢ |(-1) ^ n / denom'| ≤ 1 / denom
state_after: case intro.intro.intro.intro.intro.intro
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
zero_lt_conts_b : 0 < conts.b
⊢ |(-1) ^ n / denom'| ≤ 1 / denom

tactic: suffices 1 / denom' ≤ 1 / denom by
  have : |(-1) ^ n / denom'| = 1 / denom' := by
    suffices 1 / |denom'| = 1 / denom' by rwa [abs_div, abs_neg_one_pow n]
    have : 0 < denom' := by
      have : 0 ≤ pred_conts.b :=
        haveI : (fib n : K) ≤ pred_conts.b :=
          haveI : ¬g.TerminatedAt (n - 2) :=
            mt (terminated_stable (n.sub_le 2)) not_terminated_at_n
          fib_le_of_continuantsAux_b <| Or.inr this
        le_trans (mod_cast (fib n).zero_le) this
      have : 0 < ifp_n.fr⁻¹ :=
        haveI zero_le_ifp_n_fract : 0 ≤ ifp_n.fr :=
          IntFractPair.nth_stream_fr_nonneg stream_nth_eq
        inv_pos.2 (lt_of_le_of_ne zero_le_ifp_n_fract stream_nth_fr_ne_zero.symm)
      positivity
    rw [abs_of_pos this]
  rwa [this]
state_before: case intro.intro.intro.intro.intro.intro
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
zero_lt_conts_b : 0 < conts.b
⊢ |(-1) ^ n / denom'| ≤ 1 / denom
state_after: case intro.intro.intro.intro.intro.intro
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
zero_lt_conts_b : 0 < conts.b
⊢ 1 / denom' ≤ 1 / denom

tactic: suffices 0 < denom ∧ denom ≤ denom' from div_le_div_of_nonneg_left zero_le_one this.1 this.2
state_before: case intro.intro.intro.intro.intro.intro
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
zero_lt_conts_b : 0 < conts.b
⊢ 1 / denom' ≤ 1 / denom
state_after: case intro.intro.intro.intro.intro.intro
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
zero_lt_conts_b : 0 < conts.b
⊢ 0 < denom ∧ denom ≤ denom'

tactic: constructor
state_before: case intro.intro.intro.intro.intro.intro
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
zero_lt_conts_b : 0 < conts.b
⊢ 0 < denom ∧ denom ≤ denom'
state_after: case intro.intro.intro.intro.intro.intro.left
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
zero_lt_conts_b : 0 < conts.b
⊢ 0 < denom

case intro.intro.intro.intro.intro.intro.right
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
zero_lt_conts_b : 0 < conts.b
⊢ denom ≤ denom'

tactic: simp [nextConts, continuantsAux_recurrence s_nth_eq pred_conts_eq conts_eq, gp_a_eq_one,
  pred_conts_eq.symm, conts_eq.symm, add_comm]
state_before: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
⊢ nextConts.b = pred_conts.b + gp.b * conts.b
state_after: no goals

tactic: rw [nextConts_b_eq]
state_before: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
this : |v - g.convergents n| ≤ 1 / denom
⊢ |v - g.convergents n| ≤ 1 / (conts.b * nextConts.b)
state_after: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
this : |v - g.convergents n| ≤ 1 / denom
⊢ |v - g.convergents n| ≤ 1 / (conts.b * (pred_conts.b + gp.b * conts.b))

tactic: congr 1
state_before: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
this : |v - g.convergents n| ≤ 1 / denom
⊢ |v - g.convergents n| ≤ 1 / (conts.b * (pred_conts.b + gp.b * conts.b))
state_after: no goals

tactic: have : v - g.convergents n = (-1) ^ n / denom' := by
  have tmp := sub_convergents_eq stream_nth_eq
  simp only [stream_nth_fr_ne_zero, conts_eq.symm, pred_conts_eq.symm, if_false] at tmp
  rw [tmp]
  ring
state_before: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
this : |(-1) ^ n / denom'| ≤ 1 / denom
⊢ |v - g.convergents n| ≤ 1 / denom
state_after: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
this✝ : |(-1) ^ n / denom'| ≤ 1 / denom
this : v - g.convergents n = (-1) ^ n / denom'
⊢ |v - g.convergents n| ≤ 1 / denom

tactic: rwa [this]
state_before: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
this✝ : |(-1) ^ n / denom'| ≤ 1 / denom
this : v - g.convergents n = (-1) ^ n / denom'
⊢ |v - g.convergents n| ≤ 1 / denom
state_after: no goals

tactic: have tmp := sub_convergents_eq stream_nth_eq
state_before: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
this : |(-1) ^ n / denom'| ≤ 1 / denom
⊢ v - g.convergents n = (-1) ^ n / denom'
state_after: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
this : |(-1) ^ n / denom'| ≤ 1 / denom
tmp :
  let g := of v;
  let B := (g.continuantsAux (n + 1)).b;
  let pB := (g.continuantsAux n).b;
  v - g.convergents n = if ifp_n.fr = 0 then 0 else (-1) ^ n / (B * (ifp_n.fr⁻¹ * B + pB))
⊢ v - g.convergents n = (-1) ^ n / denom'

tactic: simp only [stream_nth_fr_ne_zero, conts_eq.symm, pred_conts_eq.symm, if_false] at tmp
state_before: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
this : |(-1) ^ n / denom'| ≤ 1 / denom
tmp :
  let g := of v;
  let B := (g.continuantsAux (n + 1)).b;
  let pB := (g.continuantsAux n).b;
  v - g.convergents n = if ifp_n.fr = 0 then 0 else (-1) ^ n / (B * (ifp_n.fr⁻¹ * B + pB))
⊢ v - g.convergents n = (-1) ^ n / denom'
state_after: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
this : |(-1) ^ n / denom'| ≤ 1 / denom
tmp : v - (of v).convergents n = (-1) ^ n / (conts.b * (ifp_n.fr⁻¹ * conts.b + pred_conts.b))
⊢ v - g.convergents n = (-1) ^ n / denom'

tactic: rw [tmp]
state_before: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
this : |(-1) ^ n / denom'| ≤ 1 / denom
tmp : v - (of v).convergents n = (-1) ^ n / (conts.b * (ifp_n.fr⁻¹ * conts.b + pred_conts.b))
⊢ v - g.convergents n = (-1) ^ n / denom'
state_after: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
this : |(-1) ^ n / denom'| ≤ 1 / denom
tmp : v - (of v).convergents n = (-1) ^ n / (conts.b * (ifp_n.fr⁻¹ * conts.b + pred_conts.b))
⊢ (-1) ^ n / (conts.b * (ifp_n.fr⁻¹ * conts.b + pred_conts.b)) = (-1) ^ n / denom'

tactic: ring
state_before: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
this : |(-1) ^ n / denom'| ≤ 1 / denom
tmp : v - (of v).convergents n = (-1) ^ n / (conts.b * (ifp_n.fr⁻¹ * conts.b + pred_conts.b))
⊢ (-1) ^ n / (conts.b * (ifp_n.fr⁻¹ * conts.b + pred_conts.b)) = (-1) ^ n / denom'
state_after: no goals

tactic: have : (fib (n + 2) : K) ≤ nextConts.b :=
  fib_le_of_continuantsAux_b (Or.inr not_terminated_at_n)
state_before: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
⊢ ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
state_after: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
this : ↑(fib (n + 2)) ≤ nextConts.b
⊢ ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b

tactic: rwa [nextConts_b_eq] at this
state_before: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
this : ↑(fib (n + 2)) ≤ nextConts.b
⊢ ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
state_after: no goals

tactic: have : |(-1) ^ n / denom'| = 1 / denom' := by
  suffices 1 / |denom'| = 1 / denom' by rwa [abs_div, abs_neg_one_pow n]
  have : 0 < denom' := by
    have : 0 ≤ pred_conts.b :=
      haveI : (fib n : K) ≤ pred_conts.b :=
        haveI : ¬g.TerminatedAt (n - 2) :=
          mt (terminated_stable (n.sub_le 2)) not_terminated_at_n
        fib_le_of_continuantsAux_b <| Or.inr this
      le_trans (mod_cast (fib n).zero_le) this
    have : 0 < ifp_n.fr⁻¹ :=
      haveI zero_le_ifp_n_fract : 0 ≤ ifp_n.fr :=
        IntFractPair.nth_stream_fr_nonneg stream_nth_eq
      inv_pos.2 (lt_of_le_of_ne zero_le_ifp_n_fract stream_nth_fr_ne_zero.symm)
    positivity
  rw [abs_of_pos this]
state_before: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
zero_lt_conts_b : 0 < conts.b
this : 1 / denom' ≤ 1 / denom
⊢ |(-1) ^ n / denom'| ≤ 1 / denom
state_after: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
zero_lt_conts_b : 0 < conts.b
this✝ : 1 / denom' ≤ 1 / denom
this : |(-1) ^ n / denom'| = 1 / denom'
⊢ |(-1) ^ n / denom'| ≤ 1 / denom

tactic: rwa [this]
state_before: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
zero_lt_conts_b : 0 < conts.b
this✝ : 1 / denom' ≤ 1 / denom
this : |(-1) ^ n / denom'| = 1 / denom'
⊢ |(-1) ^ n / denom'| ≤ 1 / denom
state_after: no goals

tactic: suffices 1 / |denom'| = 1 / denom' by rwa [abs_div, abs_neg_one_pow n]
state_before: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
zero_lt_conts_b : 0 < conts.b
this : 1 / denom' ≤ 1 / denom
⊢ |(-1) ^ n / denom'| = 1 / denom'
state_after: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
zero_lt_conts_b : 0 < conts.b
this : 1 / denom' ≤ 1 / denom
⊢ 1 / |denom'| = 1 / denom'

tactic: have : 0 < denom' := by
  have : 0 ≤ pred_conts.b :=
    haveI : (fib n : K) ≤ pred_conts.b :=
      haveI : ¬g.TerminatedAt (n - 2) :=
        mt (terminated_stable (n.sub_le 2)) not_terminated_at_n
      fib_le_of_continuantsAux_b <| Or.inr this
    le_trans (mod_cast (fib n).zero_le) this
  have : 0 < ifp_n.fr⁻¹ :=
    haveI zero_le_ifp_n_fract : 0 ≤ ifp_n.fr :=
      IntFractPair.nth_stream_fr_nonneg stream_nth_eq
    inv_pos.2 (lt_of_le_of_ne zero_le_ifp_n_fract stream_nth_fr_ne_zero.symm)
  positivity
state_before: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
zero_lt_conts_b : 0 < conts.b
this : 1 / denom' ≤ 1 / denom
⊢ 1 / |denom'| = 1 / denom'
state_after: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
zero_lt_conts_b : 0 < conts.b
this✝ : 1 / denom' ≤ 1 / denom
this : 0 < denom'
⊢ 1 / |denom'| = 1 / denom'

tactic: rw [abs_of_pos this]
state_before: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
zero_lt_conts_b : 0 < conts.b
this✝ : 1 / denom' ≤ 1 / denom
this : 0 < denom'
⊢ 1 / |denom'| = 1 / denom'
state_after: no goals

tactic: rwa [abs_div, abs_neg_one_pow n]
state_before: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
zero_lt_conts_b : 0 < conts.b
this✝ : 1 / denom' ≤ 1 / denom
this : 1 / |denom'| = 1 / denom'
⊢ |(-1) ^ n / denom'| = 1 / denom'
state_after: no goals

tactic: have : 0 ≤ pred_conts.b :=
  haveI : (fib n : K) ≤ pred_conts.b :=
    haveI : ¬g.TerminatedAt (n - 2) :=
      mt (terminated_stable (n.sub_le 2)) not_terminated_at_n
    fib_le_of_continuantsAux_b <| Or.inr this
  le_trans (mod_cast (fib n).zero_le) this
state_before: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
zero_lt_conts_b : 0 < conts.b
this : 1 / denom' ≤ 1 / denom
⊢ 0 < denom'
state_after: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
zero_lt_conts_b : 0 < conts.b
this✝ : 1 / denom' ≤ 1 / denom
this : 0 ≤ pred_conts.b
⊢ 0 < denom'

tactic: have : 0 < ifp_n.fr⁻¹ :=
  haveI zero_le_ifp_n_fract : 0 ≤ ifp_n.fr :=
    IntFractPair.nth_stream_fr_nonneg stream_nth_eq
  inv_pos.2 (lt_of_le_of_ne zero_le_ifp_n_fract stream_nth_fr_ne_zero.symm)
state_before: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
zero_lt_conts_b : 0 < conts.b
this✝ : 1 / denom' ≤ 1 / denom
this : 0 ≤ pred_conts.b
⊢ 0 < denom'
state_after: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
zero_lt_conts_b : 0 < conts.b
this✝¹ : 1 / denom' ≤ 1 / denom
this✝ : 0 ≤ pred_conts.b
this : 0 < ifp_n.fr⁻¹
⊢ 0 < denom'

tactic: positivity
state_before: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
zero_lt_conts_b : 0 < conts.b
this✝¹ : 1 / denom' ≤ 1 / denom
this✝ : 0 ≤ pred_conts.b
this : 0 < ifp_n.fr⁻¹
⊢ 0 < denom'
state_after: no goals

tactic: have : 0 < pred_conts.b + gp.b * conts.b :=
  nextConts_b_ineq.trans_lt' <| mod_cast fib_pos.2 <| succ_pos _
state_before: case intro.intro.intro.intro.intro.intro.left
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
zero_lt_conts_b : 0 < conts.b
⊢ 0 < denom
state_after: case intro.intro.intro.intro.intro.intro.left
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
zero_lt_conts_b : 0 < conts.b
this : 0 < pred_conts.b + gp.b * conts.b
⊢ 0 < denom

tactic: solve_by_elim [mul_pos]
state_before: case intro.intro.intro.intro.intro.intro.left
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
zero_lt_conts_b : 0 < conts.b
this : 0 < pred_conts.b + gp.b * conts.b
⊢ 0 < denom
state_after: no goals

tactic: suffices gp.b * conts.b ≤ ifp_n.fr⁻¹ * conts.b from
  (mul_le_mul_left zero_lt_conts_b).2 <| (add_le_add_iff_left pred_conts.b).2 this
state_before: case intro.intro.intro.intro.intro.intro.right
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
zero_lt_conts_b : 0 < conts.b
⊢ denom ≤ denom'
state_after: case intro.intro.intro.intro.intro.intro.right
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
zero_lt_conts_b : 0 < conts.b
⊢ gp.b * conts.b ≤ ifp_n.fr⁻¹ * conts.b

tactic: suffices (ifp_succ_n.b : K) * conts.b ≤ ifp_n.fr⁻¹ * conts.b by rwa [← ifp_succ_n_b_eq_gp_b]
state_before: case intro.intro.intro.intro.intro.intro.right
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
zero_lt_conts_b : 0 < conts.b
⊢ gp.b * conts.b ≤ ifp_n.fr⁻¹ * conts.b
state_after: case intro.intro.intro.intro.intro.intro.right
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
zero_lt_conts_b : 0 < conts.b
⊢ ↑ifp_succ_n.b * conts.b ≤ ifp_n.fr⁻¹ * conts.b

tactic: have : (ifp_succ_n.b : K) ≤ ifp_n.fr⁻¹ :=
  IntFractPair.succ_nth_stream_b_le_nth_stream_fr_inv stream_nth_eq succ_nth_stream_eq
state_before: case intro.intro.intro.intro.intro.intro.right
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
zero_lt_conts_b : 0 < conts.b
⊢ ↑ifp_succ_n.b * conts.b ≤ ifp_n.fr⁻¹ * conts.b
state_after: case intro.intro.intro.intro.intro.intro.right
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
zero_lt_conts_b : 0 < conts.b
this : ↑ifp_succ_n.b ≤ ifp_n.fr⁻¹
⊢ ↑ifp_succ_n.b * conts.b ≤ ifp_n.fr⁻¹ * conts.b

tactic: have : 0 ≤ conts.b := le_of_lt zero_lt_conts_b
state_before: case intro.intro.intro.intro.intro.intro.right
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
zero_lt_conts_b : 0 < conts.b
this : ↑ifp_succ_n.b ≤ ifp_n.fr⁻¹
⊢ ↑ifp_succ_n.b * conts.b ≤ ifp_n.fr⁻¹ * conts.b
state_after: case intro.intro.intro.intro.intro.intro.right
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
zero_lt_conts_b : 0 < conts.b
this✝ : ↑ifp_succ_n.b ≤ ifp_n.fr⁻¹
this : 0 ≤ conts.b
⊢ ↑ifp_succ_n.b * conts.b ≤ ifp_n.fr⁻¹ * conts.b

tactic: gcongr
state_before: case intro.intro.intro.intro.intro.intro.right
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
zero_lt_conts_b : 0 < conts.b
this✝ : ↑ifp_succ_n.b ≤ ifp_n.fr⁻¹
this : 0 ≤ conts.b
⊢ ↑ifp_succ_n.b * conts.b ≤ ifp_n.fr⁻¹ * conts.b
state_after: case intro.intro.intro.intro.intro.intro.right.a0
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
zero_lt_conts_b : 0 < conts.b
this✝ : ↑ifp_succ_n.b ≤ ifp_n.fr⁻¹
this : 0 ≤ conts.b
⊢ 0 ≤ conts.b

tactic: exact this
state_before: case intro.intro.intro.intro.intro.intro.right.a0
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
zero_lt_conts_b : 0 < conts.b
this✝ : ↑ifp_succ_n.b ≤ ifp_n.fr⁻¹
this : 0 ≤ conts.b
⊢ 0 ≤ conts.b
state_after: no goals

tactic: rwa [← ifp_succ_n_b_eq_gp_b]
state_before: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
not_terminated_at_n : ¬(of v).TerminatedAt n
g : GeneralizedContinuedFraction K := of v
nextConts : Pair K := g.continuantsAux (n + 2)
conts : Pair K := g.continuantsAux (n + 1)
conts_eq : conts = g.continuantsAux (n + 1)
pred_conts : Pair K := g.continuantsAux n
pred_conts_eq : pred_conts = g.continuantsAux n
gp : Pair K
s_nth_eq : g.s.get? n = some gp
gp_a_eq_one : gp.a = 1
nextConts_b_eq : nextConts.b = pred_conts.b + gp.b * conts.b
denom : K := conts.b * (pred_conts.b + gp.b * conts.b)
ifp_succ_n : IntFractPair K
succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
ifp_succ_n_b_eq_gp_b : ↑ifp_succ_n.b = gp.b
ifp_n : IntFractPair K
stream_nth_eq : IntFractPair.stream v n = some ifp_n
stream_nth_fr_ne_zero : ifp_n.fr ≠ 0
if_of_eq_ifp_succ_n : IntFractPair.of ifp_n.fr⁻¹ = ifp_succ_n
denom' : K := conts.b * (pred_conts.b + ifp_n.fr⁻¹ * conts.b)
nextConts_b_ineq : ↑(fib (n + 2)) ≤ pred_conts.b + gp.b * conts.b
conts_b_ineq : ↑(fib (n + 1)) ≤ conts.b
zero_lt_conts_b : 0 < conts.b
this : ↑ifp_succ_n.b * conts.b ≤ ifp_n.fr⁻¹ * conts.b
⊢ gp.b * conts.b ≤ ifp_n.fr⁻¹ * conts.b
state_after: no goals