Equivalent Cauchy sequences

Аналіз I, Розділ 5.2: Еквівалентні послідовності Коші

Я (прим. перекл. Терренс Тао) намагався зробити переклад якомога точнішим перефразуванням оригінального тексту. Коли є вибір між більш ідіоматичним підходом Lean та більш точним перекладом, я зазвичай обирав останній. Зокрема, будуть місця, де код Lean можна було б "підправити", щоб зробити його більш елегантним та ідіоматичним, але я свідомо уникав цього вибору.

Основні конструкції та результати цього розділу:

Поняття ε-близьких та зрештою ε-близьких послідовностей раціональних чисел.
Поняття еквівалентної послідовності Коші раціональних чисел.

Підказки від попередніх користувачів

Користувачі супровідного матеріалу, які виконали вправи в цьому розділі, можуть надсилати свої поради майбутнім користувачам цього розділу як PRи.

(Додайте підказку тут)

abbrev Rat.CloseSeq (ε: ℚ) (a b: Chapter5.Sequence) : Prop :=
  ∀ n, n ≥ a.n₀ → n ≥ b.n₀ → ε.Close (a n) (b n)

abbrev Rat.EventuallyClose (ε: ℚ) (a b: Chapter5.Sequence) : Prop :=
  ∃ N, ε.CloseSeq (a.from N) (b.from N)

namespace Chapter5

Визначення 5.2.1 ($ε$-близькі послідовності)

lemma Rat.closeSeq_def (ε: ℚ) (a b: Sequence) :
    ε.CloseSeq a b ↔ ∀ n, n ≥ a.n₀ → n ≥ b.n₀ → ε.Close (a n) (b n) := byε:ℚa:Sequenceb:Sequence⊢ ε.CloseSeq a b ↔ ∀ n ≥ a.n₀, n ≥ b.n₀ → ε.Close (a.seq n) (b.seq n) rflAll goals completed! 🐙

Приклад 5.2.2

declaration uses 'sorry'example : (0.1:ℚ).CloseSeq ((fun n:ℕ ↦ ((-1)^n:ℚ)):Sequence)
((fun n:ℕ ↦ ((1.1:ℚ) * (-1)^n)):Sequence) := by⊢ Rat.CloseSeq 0.1 (↑fun n => (-1) ^ n) ↑fun n => 1.1 * (-1) ^ n sorryAll goals completed! 🐙

Приклад 5.2.2

declaration uses 'sorry'example : ¬ (0.1:ℚ).Steady ((fun n:ℕ ↦ ((-1)^n:ℚ)):Sequence) := by⊢ ¬Rat.Steady 0.1 ↑fun n => (-1) ^ n sorryAll goals completed! 🐙

Приклад 5.2.2

declaration uses 'sorry'example : ¬ (0.1:ℚ).Steady ((fun n:ℕ ↦ ((1.1:ℚ) * (-1)^n)):Sequence) := by⊢ ¬Rat.Steady 0.1 ↑fun n => 1.1 * (-1) ^ n sorryAll goals completed! 🐙

Визначення 5.2.3 (Зрештою ε-близькі послідовності)

lemma Rat.eventuallyClose_def (ε: ℚ) (a b: Sequence) :
    ε.EventuallyClose a b ↔ ∃ N, ε.CloseSeq (a.from N) (b.from N) := byε:ℚa:Sequenceb:Sequence⊢ ε.EventuallyClose a b ↔ ∃ N, ε.CloseSeq (a.from N) (b.from N) rflAll goals completed! 🐙

Визначення 5.2.3 (Зрештою ε-близькі послідовності)

lemma declaration uses 'sorry'Rat.eventuallyClose_iff (ε: ℚ) (a b: ℕ → ℚ) :
    ε.EventuallyClose (a:Sequence) (b:Sequence) ↔ ∃ N, ∀ n ≥ N, |a n - b n| ≤ ε := byε:ℚa:ℕ → ℚb:ℕ → ℚ⊢ ε.EventuallyClose ↑a ↑b ↔ ∃ N, ∀ n ≥ N, |a n - b n| ≤ ε sorryAll goals completed! 🐙

Приклад 5.2.5

declaration uses 'sorry'example : ¬ (0.1:ℚ).CloseSeq ((fun n:ℕ ↦ (1:ℚ)+10^(-(n:ℤ)-1)):Sequence)
  ((fun n:ℕ ↦ (1:ℚ)-10^(-(n:ℤ)-1)):Sequence) := by⊢ ¬Rat.CloseSeq 0.1 (↑fun n => 1 + 10 ^ (-↑n - 1)) ↑fun n => 1 - 10 ^ (-↑n - 1) sorryAll goals completed! 🐙

declaration uses 'sorry'example : (0.1:ℚ).EventuallyClose ((fun n:ℕ ↦ (1:ℚ)+10^(-(n:ℤ)-1)):Sequence)
  ((fun n:ℕ ↦ (1:ℚ)-10^(-(n:ℤ)-1)):Sequence) := by⊢ Rat.EventuallyClose 0.1 (↑fun n => 1 + 10 ^ (-↑n - 1)) ↑fun n => 1 - 10 ^ (-↑n - 1) sorryAll goals completed! 🐙

declaration uses 'sorry'example : (0.01:ℚ).EventuallyClose ((fun n:ℕ ↦ (1:ℚ)+10^(-(n:ℤ)-1)):Sequence)
  ((fun n:ℕ ↦ (1:ℚ)-10^(-(n:ℤ)-1)):Sequence) := by⊢ Rat.EventuallyClose 1e-2 (↑fun n => 1 + 10 ^ (-↑n - 1)) ↑fun n => 1 - 10 ^ (-↑n - 1) sorryAll goals completed! 🐙

Визначення 5.2.6 (Еквівалентні послідовності)

abbrev Sequence.Equiv (a b: ℕ → ℚ) : Prop :=
  ∀ ε > (0:ℚ), ε.EventuallyClose (a:Sequence) (b:Sequence)

Визначення 5.2.6 (Еквівалентні послідовності)

lemma Sequence.equiv_def (a b: ℕ → ℚ) :
    Equiv a b ↔ ∀ (ε:ℚ), ε > 0 → ε.EventuallyClose (a:Sequence) (b:Sequence) := bya:ℕ → ℚb:ℕ → ℚ⊢ Equiv a b ↔ ∀ ε > 0, ε.EventuallyClose ↑a ↑b rflAll goals completed! 🐙

Визначення 5.2.6 (Еквівалентні послідовності)

lemma declaration uses 'sorry'Sequence.equiv_iff (a b: ℕ → ℚ) : Equiv a b ↔ ∀ ε > 0, ∃ N, ∀ n ≥ N, |a n - b n| ≤ ε := bya:ℕ → ℚb:ℕ → ℚ⊢ Equiv a b ↔ ∀ ε > 0, ∃ N, ∀ n ≥ N, |a n - b n| ≤ ε
  sorryAll goals completed! 🐙

Твердження 5.2.8

lemma Sequence.equiv_example :
  -- Це доведення, можливо, складніше, ніж потрібно; можлива коротша версія,
  -- яка все ще відповідає оригінальному тексту.
  Equiv (fun n:ℕ ↦ (1:ℚ)+10^(-(n:ℤ)-1)) (fun n:ℕ ↦ (1:ℚ)-10^(-(n:ℤ)-1)) := by⊢ Equiv (fun n => 1 + 10 ^ (-↑n - 1)) fun n => 1 - 10 ^ (-↑n - 1)
  set a := fun n:ℕ ↦ (1:ℚ)+10^(-(n:ℤ)-1)a:ℕ → ℚ := fun n => 1 + 10 ^ (-↑n - 1)⊢ Equiv a fun n => 1 - 10 ^ (-↑n - 1)
  set b := fun n:ℕ ↦ (1:ℚ)-10^(-(n:ℤ)-1)a:ℕ → ℚ := fun n => 1 + 10 ^ (-↑n - 1)b:ℕ → ℚ := fun n => 1 - 10 ^ (-↑n - 1)⊢ Equiv a b
  rw [equiv_iff]a:ℕ → ℚ := fun n => 1 + 10 ^ (-↑n - 1)b:ℕ → ℚ := fun n => 1 - 10 ^ (-↑n - 1)⊢ ∀ ε > 0, ∃ N, ∀ n ≥ N, |a n - b n| ≤ ε
  intro ε hεa:ℕ → ℚ := fun n => 1 + 10 ^ (-↑n - 1)b:ℕ → ℚ := fun n => 1 - 10 ^ (-↑n - 1)ε:ℚhε:ε > 0⊢ ∃ N, ∀ n ≥ N, |a n - b n| ≤ ε
  have hab (n:ℕ) : |a n - b n| = 2 * 10 ^ (-(n:ℤ)-1) := calc
    _ = |((1:ℚ) + (10:ℚ)^(-(n:ℤ)-1)) - ((1:ℚ) - (10:ℚ)^(-(n:ℤ)-1))| := rfl
    _ = |2 * (10:ℚ)^(-(n:ℤ)-1)| := bya:ℕ → ℚ := fun n => 1 + 10 ^ (-↑n - 1)b:ℕ → ℚ := fun n => 1 - 10 ^ (-↑n - 1)ε:ℚhε:ε > 0n:ℕ⊢ |1 + 10 ^ (-↑n - 1) - (1 - 10 ^ (-↑n - 1))| = |2 * 10 ^ (-↑n - 1)| ring_nfAll goals completed! 🐙
    _ = _ := abs_of_nonneg (bya:ℕ → ℚ := fun n => 1 + 10 ^ (-↑n - 1)b:ℕ → ℚ := fun n => 1 - 10 ^ (-↑n - 1)ε:ℚhε:ε > 0n:ℕ⊢ 0 ≤ 2 * 10 ^ (-↑n - 1) positivityAll goals completed! 🐙)
  have hab' (N:ℕ) : ∀ n ≥ N, |a n - b n| ≤ 2 * 10 ^(-(N:ℤ)-1) := by⊢ Equiv (fun n => 1 + 10 ^ (-↑n - 1)) fun n => 1 - 10 ^ (-↑n - 1)
    intro n hna:ℕ → ℚ := fun n => 1 + 10 ^ (-↑n - 1)b:ℕ → ℚ := fun n => 1 - 10 ^ (-↑n - 1)ε:ℚhε:ε > 0hab:∀ (n : ℕ), |@_fvar.5075 n - @_fvar.5310 n| = 2 * 10 ^ (-↑n - 1) := fun n => Trans.trans (Trans.trans rfl (@?_mvar.6548 n)) (abs_of_nonneg (@?_mvar.6549 n))N:ℕn:ℕhn:n ≥ N⊢ |a n - b n| ≤ 2 * 10 ^ (-↑N - 1); rw [hab n]a:ℕ → ℚ := fun n => 1 + 10 ^ (-↑n - 1)b:ℕ → ℚ := fun n => 1 - 10 ^ (-↑n - 1)ε:ℚhε:ε > 0hab:∀ (n : ℕ), |@_fvar.5075 n - @_fvar.5310 n| = 2 * 10 ^ (-↑n - 1) := fun n => Trans.trans (Trans.trans rfl (@?_mvar.6548 n)) (abs_of_nonneg (@?_mvar.6549 n))N:ℕn:ℕhn:n ≥ N⊢ 2 * 10 ^ (-↑n - 1) ≤ 2 * 10 ^ (-↑N - 1); gcongrh.haa:ℕ → ℚ := fun n => 1 + 10 ^ (-↑n - 1)b:ℕ → ℚ := fun n => 1 - 10 ^ (-↑n - 1)ε:ℚhε:ε > 0hab:∀ (n : ℕ), |@_fvar.5075 n - @_fvar.5310 n| = 2 * 10 ^ (-↑n - 1) := fun n => Trans.trans (Trans.trans rfl (@?_mvar.6548 n)) (abs_of_nonneg (@?_mvar.6549 n))N:ℕn:ℕhn:n ≥ N⊢ 1 ≤ 10; norm_numAll goals completed! 🐙
  have hN : ∃ N:ℕ, 2 * (10:ℚ) ^(-(N:ℤ)-1) ≤ ε := by⊢ Equiv (fun n => 1 + 10 ^ (-↑n - 1)) fun n => 1 - 10 ^ (-↑n - 1)
    have hN' (N:ℕ) : 2 * (10:ℚ)^(-(N:ℤ)-1) ≤ 2/(N+1) := calc
      _ = 2 / (10:ℚ)^(N+1) := bya:ℕ → ℚ := fun n => 1 + 10 ^ (-↑n - 1)b:ℕ → ℚ := fun n => 1 - 10 ^ (-↑n - 1)ε:ℚhε:ε > 0hab:∀ (n : ℕ), |@_fvar.5075 n - @_fvar.5310 n| = 2 * 10 ^ (-↑n - 1) := 
  fun n =>
    Trans.trans
      (Trans.trans rfl
        (of_eq_true
          (Eq.trans
            (congr
              (congrArg (fun x => Eq |x|)
                (Eq.trans
                  (Mathlib.Tactic.Ring.sub_congr
                    (Mathlib.Tactic.Ring.add_congr
                      (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1)))
                      (Mathlib.Tactic.Ring.atom_pf'
                        (congrArg (HPow.hPow 10)
                          (Eq.trans
                            (Mathlib.Tactic.Ring.sub_congr
                              (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                    (Mathlib.Tactic.Ring.neg_one_mul
                                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                          (Eq.refl (Int.negOfNat 1))))))
                                  Mathlib.Tactic.Ring.neg_zero))
                              (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                              (Mathlib.Tactic.Ring.sub_pf
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1)))))
                                  Mathlib.Tactic.Ring.neg_zero)
                                (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                  (Mathlib.Tactic.Ring.add_pf_add_zero
                                    (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                            (Eq.trans
                              (congr
                                (congrArg HAdd.hAdd
                                  (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                    (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                (Eq.trans
                                  (congrArg (fun x => x + 0)
                                    (Eq.trans
                                      (Eq.trans
                                        (congr
                                          (congrArg HMul.hMul
                                            (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                              (pow_one ↑n)))
                                          (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                            (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                        (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                      (congrArg Neg.neg (mul_one ↑n))))
                                  (add_zero (-↑n))))
                              (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                      (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                        (Mathlib.Tactic.Ring.add_pf_zero_add ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))))
                    (Mathlib.Tactic.Ring.sub_congr
                      (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1)))
                      (Mathlib.Tactic.Ring.atom_pf'
                        (congrArg (HPow.hPow 10)
                          (Eq.trans
                            (Mathlib.Tactic.Ring.sub_congr
                              (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                    (Mathlib.Tactic.Ring.neg_one_mul
                                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                          (Eq.refl (Int.negOfNat 1))))))
                                  Mathlib.Tactic.Ring.neg_zero))
                              (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                              (Mathlib.Tactic.Ring.sub_pf
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1)))))
                                  Mathlib.Tactic.Ring.neg_zero)
                                (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                  (Mathlib.Tactic.Ring.add_pf_add_zero
                                    (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                            (Eq.trans
                              (congr
                                (congrArg HAdd.hAdd
                                  (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                    (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                (Eq.trans
                                  (congrArg (fun x => x + 0)
                                    (Eq.trans
                                      (Eq.trans
                                        (congr
                                          (congrArg HMul.hMul
                                            (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                              (pow_one ↑n)))
                                          (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                            (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                        (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                      (congrArg Neg.neg (mul_one ↑n))))
                                  (add_zero (-↑n))))
                              (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                      (Mathlib.Tactic.Ring.sub_pf
                        (Mathlib.Tactic.Ring.neg_add
                          (Mathlib.Tactic.Ring.neg_mul (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Tactic.Ring.neg_one_mul
                              (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                  (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                                  (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                                  (Eq.refl (Int.negOfNat 1))))))
                          Mathlib.Tactic.Ring.neg_zero)
                        (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                          (Mathlib.Tactic.Ring.add_pf_zero_add
                            ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                    (Mathlib.Tactic.Ring.sub_pf
                      (Mathlib.Tactic.Ring.neg_add
                        (Mathlib.Tactic.Ring.neg_one_mul
                          (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                            (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                              (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                              (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                              (Eq.refl (Int.negOfNat 1)))))
                        (Mathlib.Tactic.Ring.neg_add
                          (Mathlib.Tactic.Ring.neg_mul (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Tactic.Ring.neg_one_mul
                              (Mathlib.Meta.NormNum.IsNat.to_raw_eq
                                (Mathlib.Meta.NormNum.IsInt.to_isNat
                                  (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                    (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                                    (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 1)))))))
                          Mathlib.Tactic.Ring.neg_zero))
                      (Mathlib.Tactic.Ring.add_pf_add_overlap_zero
                        (Mathlib.Meta.NormNum.IsInt.to_isNat
                          (Mathlib.Meta.NormNum.isInt_add (Eq.refl HAdd.hAdd)
                            (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                            (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 0))))
                        (Mathlib.Tactic.Ring.add_pf_add_overlap
                          (Mathlib.Tactic.Ring.add_overlap_pf (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Meta.NormNum.IsNat.to_raw_eq
                              (Mathlib.Meta.NormNum.isNat_add (Eq.refl HAdd.hAdd) (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1)
                                (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1) (Eq.refl 2))))
                          (Mathlib.Tactic.Ring.add_pf_zero_add 0)))))
                  (Eq.trans
                    (congrArg (fun x => x * 2 + 0)
                      (Eq.trans (congrArg (HPow.hPow (10 ^ (-1 - ↑n))) Mathlib.Tactic.RingNF.nat_rawCast_1)
                        (pow_one (10 ^ (-1 - ↑n)))))
                    (add_zero (10 ^ (-1 - ↑n) * 2)))))
              (congrArg abs
                (Eq.trans
                  (Mathlib.Tactic.Ring.mul_congr
                    (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2)))
                    (Mathlib.Tactic.Ring.atom_pf'
                      (congrArg (HPow.hPow 10)
                        (Eq.trans
                          (Mathlib.Tactic.Ring.sub_congr
                            (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                              (Mathlib.Tactic.Ring.neg_add
                                (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1))))))
                                Mathlib.Tactic.Ring.neg_zero))
                            (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                            (Mathlib.Tactic.Ring.sub_pf
                              (Mathlib.Tactic.Ring.neg_add
                                (Mathlib.Tactic.Ring.neg_one_mul
                                  (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                    (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                      (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                      (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                      (Eq.refl (Int.negOfNat 1)))))
                                Mathlib.Tactic.Ring.neg_zero)
                              (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                (Mathlib.Tactic.Ring.add_pf_add_zero
                                  (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                          (Eq.trans
                            (congr
                              (congrArg HAdd.hAdd
                                (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                  (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                              (Eq.trans
                                (congrArg (fun x => x + 0)
                                  (Eq.trans
                                    (Eq.trans
                                      (congr
                                        (congrArg HMul.hMul
                                          (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                            (pow_one ↑n)))
                                        (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                          (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                      (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                    (congrArg Neg.neg (mul_one ↑n))))
                                (add_zero (-↑n))))
                            (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                    (Mathlib.Tactic.Ring.add_mul
                      (Mathlib.Tactic.Ring.mul_add
                        (Mathlib.Tactic.Ring.mul_pf_right (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                          (Mathlib.Tactic.Ring.mul_one (Nat.rawCast 2)))
                        (Mathlib.Tactic.Ring.mul_zero (Nat.rawCast 2))
                        (Mathlib.Tactic.Ring.add_pf_add_zero ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 2 + 0)))
                      (Mathlib.Tactic.Ring.zero_mul ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))
                      (Mathlib.Tactic.Ring.add_pf_add_zero ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 2 + 0))))
                  (Eq.trans
                    (congrArg (fun x => x * 2 + 0)
                      (Eq.trans (congrArg (HPow.hPow (10 ^ (-1 - ↑n))) Mathlib.Tactic.RingNF.nat_rawCast_1)
                        (pow_one (10 ^ (-1 - ↑n)))))
                    (add_zero (10 ^ (-1 - ↑n) * 2))))))
            (eq_self |10 ^ (-1 - ↑n) * 2|))))
      (abs_of_nonneg
        (le_of_lt
          (mul_pos
            (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2))
              (Eq.refl (Nat.ble 1 2)))
            (zpow_pos
              (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 10))
                (Eq.refl (Nat.ble 1 10)))
              (-↑n - 1)))))hab':∀ (N n : ℕ), n ≥ N → |@_fvar.5075 n - @_fvar.5310 n| ≤ 2 * 10 ^ (-↑N - 1) := 
  fun N n hn =>
    Eq.mpr (id (congrArg (fun _a => _a ≤ 2 * 10 ^ (-↑N - 1)) (@_fvar.6550 n)))
      (mul_le_mul_of_nonneg_left
        (zpow_le_zpow_right₀
          (Mathlib.Meta.NormNum.isNat_le_true (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1))
            (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 10)) (Eq.refl true))
          (sub_le_sub_right (neg_le_neg (GCongr.natCast_le_natCast hn)) 1))
        (le_of_lt
          (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2))
            (Eq.refl (Nat.ble 1 2)))))N:ℕ⊢ 2 * 10 ^ (-↑N - 1) = 2 / 10 ^ (N + 1)
        field_simpa:ℕ → ℚ := fun n => 1 + 10 ^ (-↑n - 1)b:ℕ → ℚ := fun n => 1 - 10 ^ (-↑n - 1)ε:ℚhε:ε > 0hab:∀ (n : ℕ), |@_fvar.5075 n - @_fvar.5310 n| = 2 * 10 ^ (-↑n - 1) := 
  fun n =>
    Trans.trans
      (Trans.trans rfl
        (of_eq_true
          (Eq.trans
            (congr
              (congrArg (fun x => Eq |x|)
                (Eq.trans
                  (Mathlib.Tactic.Ring.sub_congr
                    (Mathlib.Tactic.Ring.add_congr
                      (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1)))
                      (Mathlib.Tactic.Ring.atom_pf'
                        (congrArg (HPow.hPow 10)
                          (Eq.trans
                            (Mathlib.Tactic.Ring.sub_congr
                              (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                    (Mathlib.Tactic.Ring.neg_one_mul
                                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                          (Eq.refl (Int.negOfNat 1))))))
                                  Mathlib.Tactic.Ring.neg_zero))
                              (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                              (Mathlib.Tactic.Ring.sub_pf
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1)))))
                                  Mathlib.Tactic.Ring.neg_zero)
                                (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                  (Mathlib.Tactic.Ring.add_pf_add_zero
                                    (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                            (Eq.trans
                              (congr
                                (congrArg HAdd.hAdd
                                  (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                    (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                (Eq.trans
                                  (congrArg (fun x => x + 0)
                                    (Eq.trans
                                      (Eq.trans
                                        (congr
                                          (congrArg HMul.hMul
                                            (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                              (pow_one ↑n)))
                                          (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                            (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                        (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                      (congrArg Neg.neg (mul_one ↑n))))
                                  (add_zero (-↑n))))
                              (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                      (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                        (Mathlib.Tactic.Ring.add_pf_zero_add ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))))
                    (Mathlib.Tactic.Ring.sub_congr
                      (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1)))
                      (Mathlib.Tactic.Ring.atom_pf'
                        (congrArg (HPow.hPow 10)
                          (Eq.trans
                            (Mathlib.Tactic.Ring.sub_congr
                              (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                    (Mathlib.Tactic.Ring.neg_one_mul
                                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                          (Eq.refl (Int.negOfNat 1))))))
                                  Mathlib.Tactic.Ring.neg_zero))
                              (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                              (Mathlib.Tactic.Ring.sub_pf
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1)))))
                                  Mathlib.Tactic.Ring.neg_zero)
                                (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                  (Mathlib.Tactic.Ring.add_pf_add_zero
                                    (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                            (Eq.trans
                              (congr
                                (congrArg HAdd.hAdd
                                  (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                    (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                (Eq.trans
                                  (congrArg (fun x => x + 0)
                                    (Eq.trans
                                      (Eq.trans
                                        (congr
                                          (congrArg HMul.hMul
                                            (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                              (pow_one ↑n)))
                                          (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                            (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                        (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                      (congrArg Neg.neg (mul_one ↑n))))
                                  (add_zero (-↑n))))
                              (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                      (Mathlib.Tactic.Ring.sub_pf
                        (Mathlib.Tactic.Ring.neg_add
                          (Mathlib.Tactic.Ring.neg_mul (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Tactic.Ring.neg_one_mul
                              (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                  (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                                  (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                                  (Eq.refl (Int.negOfNat 1))))))
                          Mathlib.Tactic.Ring.neg_zero)
                        (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                          (Mathlib.Tactic.Ring.add_pf_zero_add
                            ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                    (Mathlib.Tactic.Ring.sub_pf
                      (Mathlib.Tactic.Ring.neg_add
                        (Mathlib.Tactic.Ring.neg_one_mul
                          (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                            (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                              (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                              (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                              (Eq.refl (Int.negOfNat 1)))))
                        (Mathlib.Tactic.Ring.neg_add
                          (Mathlib.Tactic.Ring.neg_mul (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Tactic.Ring.neg_one_mul
                              (Mathlib.Meta.NormNum.IsNat.to_raw_eq
                                (Mathlib.Meta.NormNum.IsInt.to_isNat
                                  (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                    (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                                    (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 1)))))))
                          Mathlib.Tactic.Ring.neg_zero))
                      (Mathlib.Tactic.Ring.add_pf_add_overlap_zero
                        (Mathlib.Meta.NormNum.IsInt.to_isNat
                          (Mathlib.Meta.NormNum.isInt_add (Eq.refl HAdd.hAdd)
                            (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                            (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 0))))
                        (Mathlib.Tactic.Ring.add_pf_add_overlap
                          (Mathlib.Tactic.Ring.add_overlap_pf (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Meta.NormNum.IsNat.to_raw_eq
                              (Mathlib.Meta.NormNum.isNat_add (Eq.refl HAdd.hAdd) (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1)
                                (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1) (Eq.refl 2))))
                          (Mathlib.Tactic.Ring.add_pf_zero_add 0)))))
                  (Eq.trans
                    (congrArg (fun x => x * 2 + 0)
                      (Eq.trans (congrArg (HPow.hPow (10 ^ (-1 - ↑n))) Mathlib.Tactic.RingNF.nat_rawCast_1)
                        (pow_one (10 ^ (-1 - ↑n)))))
                    (add_zero (10 ^ (-1 - ↑n) * 2)))))
              (congrArg abs
                (Eq.trans
                  (Mathlib.Tactic.Ring.mul_congr
                    (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2)))
                    (Mathlib.Tactic.Ring.atom_pf'
                      (congrArg (HPow.hPow 10)
                        (Eq.trans
                          (Mathlib.Tactic.Ring.sub_congr
                            (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                              (Mathlib.Tactic.Ring.neg_add
                                (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1))))))
                                Mathlib.Tactic.Ring.neg_zero))
                            (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                            (Mathlib.Tactic.Ring.sub_pf
                              (Mathlib.Tactic.Ring.neg_add
                                (Mathlib.Tactic.Ring.neg_one_mul
                                  (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                    (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                      (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                      (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                      (Eq.refl (Int.negOfNat 1)))))
                                Mathlib.Tactic.Ring.neg_zero)
                              (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                (Mathlib.Tactic.Ring.add_pf_add_zero
                                  (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                          (Eq.trans
                            (congr
                              (congrArg HAdd.hAdd
                                (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                  (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                              (Eq.trans
                                (congrArg (fun x => x + 0)
                                  (Eq.trans
                                    (Eq.trans
                                      (congr
                                        (congrArg HMul.hMul
                                          (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                            (pow_one ↑n)))
                                        (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                          (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                      (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                    (congrArg Neg.neg (mul_one ↑n))))
                                (add_zero (-↑n))))
                            (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                    (Mathlib.Tactic.Ring.add_mul
                      (Mathlib.Tactic.Ring.mul_add
                        (Mathlib.Tactic.Ring.mul_pf_right (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                          (Mathlib.Tactic.Ring.mul_one (Nat.rawCast 2)))
                        (Mathlib.Tactic.Ring.mul_zero (Nat.rawCast 2))
                        (Mathlib.Tactic.Ring.add_pf_add_zero ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 2 + 0)))
                      (Mathlib.Tactic.Ring.zero_mul ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))
                      (Mathlib.Tactic.Ring.add_pf_add_zero ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 2 + 0))))
                  (Eq.trans
                    (congrArg (fun x => x * 2 + 0)
                      (Eq.trans (congrArg (HPow.hPow (10 ^ (-1 - ↑n))) Mathlib.Tactic.RingNF.nat_rawCast_1)
                        (pow_one (10 ^ (-1 - ↑n)))))
                    (add_zero (10 ^ (-1 - ↑n) * 2))))))
            (eq_self |10 ^ (-1 - ↑n) * 2|))))
      (abs_of_nonneg
        (le_of_lt
          (mul_pos
            (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2))
              (Eq.refl (Nat.ble 1 2)))
            (zpow_pos
              (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 10))
                (Eq.refl (Nat.ble 1 10)))
              (-↑n - 1)))))hab':∀ (N n : ℕ), n ≥ N → |@_fvar.5075 n - @_fvar.5310 n| ≤ 2 * 10 ^ (-↑N - 1) := 
  fun N n hn =>
    Eq.mpr (id (congrArg (fun _a => _a ≤ 2 * 10 ^ (-↑N - 1)) (@_fvar.6550 n)))
      (mul_le_mul_of_nonneg_left
        (zpow_le_zpow_right₀
          (Mathlib.Meta.NormNum.isNat_le_true (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1))
            (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 10)) (Eq.refl true))
          (sub_le_sub_right (neg_le_neg (GCongr.natCast_le_natCast hn)) 1))
        (le_of_lt
          (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2))
            (Eq.refl (Nat.ble 1 2)))))N:ℕ⊢ 2 * 10 ^ (-↑N - 1) * 10 ^ (N + 1) = 2
        simp [mul_assoc, ←Section_4_3.pow_eq_zpow, ←zpow_add₀ (show 10 ≠ (0:ℚ) by norm_num)]All goals completed! 🐙
      _ ≤ _ := bya:ℕ → ℚ := fun n => 1 + 10 ^ (-↑n - 1)b:ℕ → ℚ := fun n => 1 - 10 ^ (-↑n - 1)ε:ℚhε:ε > 0hab:∀ (n : ℕ), |@_fvar.5075 n - @_fvar.5310 n| = 2 * 10 ^ (-↑n - 1) := 
  fun n =>
    Trans.trans
      (Trans.trans rfl
        (of_eq_true
          (Eq.trans
            (congr
              (congrArg (fun x => Eq |x|)
                (Eq.trans
                  (Mathlib.Tactic.Ring.sub_congr
                    (Mathlib.Tactic.Ring.add_congr
                      (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1)))
                      (Mathlib.Tactic.Ring.atom_pf'
                        (congrArg (HPow.hPow 10)
                          (Eq.trans
                            (Mathlib.Tactic.Ring.sub_congr
                              (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                    (Mathlib.Tactic.Ring.neg_one_mul
                                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                          (Eq.refl (Int.negOfNat 1))))))
                                  Mathlib.Tactic.Ring.neg_zero))
                              (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                              (Mathlib.Tactic.Ring.sub_pf
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1)))))
                                  Mathlib.Tactic.Ring.neg_zero)
                                (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                  (Mathlib.Tactic.Ring.add_pf_add_zero
                                    (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                            (Eq.trans
                              (congr
                                (congrArg HAdd.hAdd
                                  (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                    (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                (Eq.trans
                                  (congrArg (fun x => x + 0)
                                    (Eq.trans
                                      (Eq.trans
                                        (congr
                                          (congrArg HMul.hMul
                                            (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                              (pow_one ↑n)))
                                          (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                            (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                        (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                      (congrArg Neg.neg (mul_one ↑n))))
                                  (add_zero (-↑n))))
                              (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                      (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                        (Mathlib.Tactic.Ring.add_pf_zero_add ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))))
                    (Mathlib.Tactic.Ring.sub_congr
                      (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1)))
                      (Mathlib.Tactic.Ring.atom_pf'
                        (congrArg (HPow.hPow 10)
                          (Eq.trans
                            (Mathlib.Tactic.Ring.sub_congr
                              (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                    (Mathlib.Tactic.Ring.neg_one_mul
                                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                          (Eq.refl (Int.negOfNat 1))))))
                                  Mathlib.Tactic.Ring.neg_zero))
                              (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                              (Mathlib.Tactic.Ring.sub_pf
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1)))))
                                  Mathlib.Tactic.Ring.neg_zero)
                                (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                  (Mathlib.Tactic.Ring.add_pf_add_zero
                                    (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                            (Eq.trans
                              (congr
                                (congrArg HAdd.hAdd
                                  (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                    (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                (Eq.trans
                                  (congrArg (fun x => x + 0)
                                    (Eq.trans
                                      (Eq.trans
                                        (congr
                                          (congrArg HMul.hMul
                                            (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                              (pow_one ↑n)))
                                          (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                            (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                        (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                      (congrArg Neg.neg (mul_one ↑n))))
                                  (add_zero (-↑n))))
                              (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                      (Mathlib.Tactic.Ring.sub_pf
                        (Mathlib.Tactic.Ring.neg_add
                          (Mathlib.Tactic.Ring.neg_mul (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Tactic.Ring.neg_one_mul
                              (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                  (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                                  (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                                  (Eq.refl (Int.negOfNat 1))))))
                          Mathlib.Tactic.Ring.neg_zero)
                        (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                          (Mathlib.Tactic.Ring.add_pf_zero_add
                            ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                    (Mathlib.Tactic.Ring.sub_pf
                      (Mathlib.Tactic.Ring.neg_add
                        (Mathlib.Tactic.Ring.neg_one_mul
                          (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                            (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                              (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                              (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                              (Eq.refl (Int.negOfNat 1)))))
                        (Mathlib.Tactic.Ring.neg_add
                          (Mathlib.Tactic.Ring.neg_mul (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Tactic.Ring.neg_one_mul
                              (Mathlib.Meta.NormNum.IsNat.to_raw_eq
                                (Mathlib.Meta.NormNum.IsInt.to_isNat
                                  (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                    (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                                    (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 1)))))))
                          Mathlib.Tactic.Ring.neg_zero))
                      (Mathlib.Tactic.Ring.add_pf_add_overlap_zero
                        (Mathlib.Meta.NormNum.IsInt.to_isNat
                          (Mathlib.Meta.NormNum.isInt_add (Eq.refl HAdd.hAdd)
                            (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                            (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 0))))
                        (Mathlib.Tactic.Ring.add_pf_add_overlap
                          (Mathlib.Tactic.Ring.add_overlap_pf (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Meta.NormNum.IsNat.to_raw_eq
                              (Mathlib.Meta.NormNum.isNat_add (Eq.refl HAdd.hAdd) (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1)
                                (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1) (Eq.refl 2))))
                          (Mathlib.Tactic.Ring.add_pf_zero_add 0)))))
                  (Eq.trans
                    (congrArg (fun x => x * 2 + 0)
                      (Eq.trans (congrArg (HPow.hPow (10 ^ (-1 - ↑n))) Mathlib.Tactic.RingNF.nat_rawCast_1)
                        (pow_one (10 ^ (-1 - ↑n)))))
                    (add_zero (10 ^ (-1 - ↑n) * 2)))))
              (congrArg abs
                (Eq.trans
                  (Mathlib.Tactic.Ring.mul_congr
                    (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2)))
                    (Mathlib.Tactic.Ring.atom_pf'
                      (congrArg (HPow.hPow 10)
                        (Eq.trans
                          (Mathlib.Tactic.Ring.sub_congr
                            (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                              (Mathlib.Tactic.Ring.neg_add
                                (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1))))))
                                Mathlib.Tactic.Ring.neg_zero))
                            (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                            (Mathlib.Tactic.Ring.sub_pf
                              (Mathlib.Tactic.Ring.neg_add
                                (Mathlib.Tactic.Ring.neg_one_mul
                                  (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                    (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                      (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                      (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                      (Eq.refl (Int.negOfNat 1)))))
                                Mathlib.Tactic.Ring.neg_zero)
                              (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                (Mathlib.Tactic.Ring.add_pf_add_zero
                                  (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                          (Eq.trans
                            (congr
                              (congrArg HAdd.hAdd
                                (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                  (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                              (Eq.trans
                                (congrArg (fun x => x + 0)
                                  (Eq.trans
                                    (Eq.trans
                                      (congr
                                        (congrArg HMul.hMul
                                          (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                            (pow_one ↑n)))
                                        (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                          (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                      (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                    (congrArg Neg.neg (mul_one ↑n))))
                                (add_zero (-↑n))))
                            (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                    (Mathlib.Tactic.Ring.add_mul
                      (Mathlib.Tactic.Ring.mul_add
                        (Mathlib.Tactic.Ring.mul_pf_right (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                          (Mathlib.Tactic.Ring.mul_one (Nat.rawCast 2)))
                        (Mathlib.Tactic.Ring.mul_zero (Nat.rawCast 2))
                        (Mathlib.Tactic.Ring.add_pf_add_zero ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 2 + 0)))
                      (Mathlib.Tactic.Ring.zero_mul ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))
                      (Mathlib.Tactic.Ring.add_pf_add_zero ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 2 + 0))))
                  (Eq.trans
                    (congrArg (fun x => x * 2 + 0)
                      (Eq.trans (congrArg (HPow.hPow (10 ^ (-1 - ↑n))) Mathlib.Tactic.RingNF.nat_rawCast_1)
                        (pow_one (10 ^ (-1 - ↑n)))))
                    (add_zero (10 ^ (-1 - ↑n) * 2))))))
            (eq_self |10 ^ (-1 - ↑n) * 2|))))
      (abs_of_nonneg
        (le_of_lt
          (mul_pos
            (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2))
              (Eq.refl (Nat.ble 1 2)))
            (zpow_pos
              (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 10))
                (Eq.refl (Nat.ble 1 10)))
              (-↑n - 1)))))hab':∀ (N n : ℕ), n ≥ N → |@_fvar.5075 n - @_fvar.5310 n| ≤ 2 * 10 ^ (-↑N - 1) := 
  fun N n hn =>
    Eq.mpr (id (congrArg (fun _a => _a ≤ 2 * 10 ^ (-↑N - 1)) (@_fvar.6550 n)))
      (mul_le_mul_of_nonneg_left
        (zpow_le_zpow_right₀
          (Mathlib.Meta.NormNum.isNat_le_true (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1))
            (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 10)) (Eq.refl true))
          (sub_le_sub_right (neg_le_neg (GCongr.natCast_le_natCast hn)) 1))
        (le_of_lt
          (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2))
            (Eq.refl (Nat.ble 1 2)))))N:ℕ⊢ 2 / 10 ^ (N + 1) ≤ 2 / (↑N + 1)
        gcongrhdba:ℕ → ℚ := fun n => 1 + 10 ^ (-↑n - 1)b:ℕ → ℚ := fun n => 1 - 10 ^ (-↑n - 1)ε:ℚhε:ε > 0hab:∀ (n : ℕ), |@_fvar.5075 n - @_fvar.5310 n| = 2 * 10 ^ (-↑n - 1) := 
  fun n =>
    Trans.trans
      (Trans.trans rfl
        (of_eq_true
          (Eq.trans
            (congr
              (congrArg (fun x => Eq |x|)
                (Eq.trans
                  (Mathlib.Tactic.Ring.sub_congr
                    (Mathlib.Tactic.Ring.add_congr
                      (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1)))
                      (Mathlib.Tactic.Ring.atom_pf'
                        (congrArg (HPow.hPow 10)
                          (Eq.trans
                            (Mathlib.Tactic.Ring.sub_congr
                              (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                    (Mathlib.Tactic.Ring.neg_one_mul
                                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                          (Eq.refl (Int.negOfNat 1))))))
                                  Mathlib.Tactic.Ring.neg_zero))
                              (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                              (Mathlib.Tactic.Ring.sub_pf
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1)))))
                                  Mathlib.Tactic.Ring.neg_zero)
                                (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                  (Mathlib.Tactic.Ring.add_pf_add_zero
                                    (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                            (Eq.trans
                              (congr
                                (congrArg HAdd.hAdd
                                  (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                    (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                (Eq.trans
                                  (congrArg (fun x => x + 0)
                                    (Eq.trans
                                      (Eq.trans
                                        (congr
                                          (congrArg HMul.hMul
                                            (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                              (pow_one ↑n)))
                                          (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                            (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                        (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                      (congrArg Neg.neg (mul_one ↑n))))
                                  (add_zero (-↑n))))
                              (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                      (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                        (Mathlib.Tactic.Ring.add_pf_zero_add ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))))
                    (Mathlib.Tactic.Ring.sub_congr
                      (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1)))
                      (Mathlib.Tactic.Ring.atom_pf'
                        (congrArg (HPow.hPow 10)
                          (Eq.trans
                            (Mathlib.Tactic.Ring.sub_congr
                              (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                    (Mathlib.Tactic.Ring.neg_one_mul
                                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                          (Eq.refl (Int.negOfNat 1))))))
                                  Mathlib.Tactic.Ring.neg_zero))
                              (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                              (Mathlib.Tactic.Ring.sub_pf
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1)))))
                                  Mathlib.Tactic.Ring.neg_zero)
                                (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                  (Mathlib.Tactic.Ring.add_pf_add_zero
                                    (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                            (Eq.trans
                              (congr
                                (congrArg HAdd.hAdd
                                  (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                    (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                (Eq.trans
                                  (congrArg (fun x => x + 0)
                                    (Eq.trans
                                      (Eq.trans
                                        (congr
                                          (congrArg HMul.hMul
                                            (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                              (pow_one ↑n)))
                                          (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                            (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                        (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                      (congrArg Neg.neg (mul_one ↑n))))
                                  (add_zero (-↑n))))
                              (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                      (Mathlib.Tactic.Ring.sub_pf
                        (Mathlib.Tactic.Ring.neg_add
                          (Mathlib.Tactic.Ring.neg_mul (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Tactic.Ring.neg_one_mul
                              (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                  (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                                  (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                                  (Eq.refl (Int.negOfNat 1))))))
                          Mathlib.Tactic.Ring.neg_zero)
                        (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                          (Mathlib.Tactic.Ring.add_pf_zero_add
                            ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                    (Mathlib.Tactic.Ring.sub_pf
                      (Mathlib.Tactic.Ring.neg_add
                        (Mathlib.Tactic.Ring.neg_one_mul
                          (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                            (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                              (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                              (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                              (Eq.refl (Int.negOfNat 1)))))
                        (Mathlib.Tactic.Ring.neg_add
                          (Mathlib.Tactic.Ring.neg_mul (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Tactic.Ring.neg_one_mul
                              (Mathlib.Meta.NormNum.IsNat.to_raw_eq
                                (Mathlib.Meta.NormNum.IsInt.to_isNat
                                  (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                    (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                                    (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 1)))))))
                          Mathlib.Tactic.Ring.neg_zero))
                      (Mathlib.Tactic.Ring.add_pf_add_overlap_zero
                        (Mathlib.Meta.NormNum.IsInt.to_isNat
                          (Mathlib.Meta.NormNum.isInt_add (Eq.refl HAdd.hAdd)
                            (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                            (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 0))))
                        (Mathlib.Tactic.Ring.add_pf_add_overlap
                          (Mathlib.Tactic.Ring.add_overlap_pf (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Meta.NormNum.IsNat.to_raw_eq
                              (Mathlib.Meta.NormNum.isNat_add (Eq.refl HAdd.hAdd) (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1)
                                (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1) (Eq.refl 2))))
                          (Mathlib.Tactic.Ring.add_pf_zero_add 0)))))
                  (Eq.trans
                    (congrArg (fun x => x * 2 + 0)
                      (Eq.trans (congrArg (HPow.hPow (10 ^ (-1 - ↑n))) Mathlib.Tactic.RingNF.nat_rawCast_1)
                        (pow_one (10 ^ (-1 - ↑n)))))
                    (add_zero (10 ^ (-1 - ↑n) * 2)))))
              (congrArg abs
                (Eq.trans
                  (Mathlib.Tactic.Ring.mul_congr
                    (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2)))
                    (Mathlib.Tactic.Ring.atom_pf'
                      (congrArg (HPow.hPow 10)
                        (Eq.trans
                          (Mathlib.Tactic.Ring.sub_congr
                            (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                              (Mathlib.Tactic.Ring.neg_add
                                (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1))))))
                                Mathlib.Tactic.Ring.neg_zero))
                            (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                            (Mathlib.Tactic.Ring.sub_pf
                              (Mathlib.Tactic.Ring.neg_add
                                (Mathlib.Tactic.Ring.neg_one_mul
                                  (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                    (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                      (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                      (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                      (Eq.refl (Int.negOfNat 1)))))
                                Mathlib.Tactic.Ring.neg_zero)
                              (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                (Mathlib.Tactic.Ring.add_pf_add_zero
                                  (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                          (Eq.trans
                            (congr
                              (congrArg HAdd.hAdd
                                (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                  (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                              (Eq.trans
                                (congrArg (fun x => x + 0)
                                  (Eq.trans
                                    (Eq.trans
                                      (congr
                                        (congrArg HMul.hMul
                                          (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                            (pow_one ↑n)))
                                        (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                          (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                      (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                    (congrArg Neg.neg (mul_one ↑n))))
                                (add_zero (-↑n))))
                            (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                    (Mathlib.Tactic.Ring.add_mul
                      (Mathlib.Tactic.Ring.mul_add
                        (Mathlib.Tactic.Ring.mul_pf_right (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                          (Mathlib.Tactic.Ring.mul_one (Nat.rawCast 2)))
                        (Mathlib.Tactic.Ring.mul_zero (Nat.rawCast 2))
                        (Mathlib.Tactic.Ring.add_pf_add_zero ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 2 + 0)))
                      (Mathlib.Tactic.Ring.zero_mul ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))
                      (Mathlib.Tactic.Ring.add_pf_add_zero ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 2 + 0))))
                  (Eq.trans
                    (congrArg (fun x => x * 2 + 0)
                      (Eq.trans (congrArg (HPow.hPow (10 ^ (-1 - ↑n))) Mathlib.Tactic.RingNF.nat_rawCast_1)
                        (pow_one (10 ^ (-1 - ↑n)))))
                    (add_zero (10 ^ (-1 - ↑n) * 2))))))
            (eq_self |10 ^ (-1 - ↑n) * 2|))))
      (abs_of_nonneg
        (le_of_lt
          (mul_pos
            (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2))
              (Eq.refl (Nat.ble 1 2)))
            (zpow_pos
              (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 10))
                (Eq.refl (Nat.ble 1 10)))
              (-↑n - 1)))))hab':∀ (N n : ℕ), n ≥ N → |@_fvar.5075 n - @_fvar.5310 n| ≤ 2 * 10 ^ (-↑N - 1) := 
  fun N n hn =>
    Eq.mpr (id (congrArg (fun _a => _a ≤ 2 * 10 ^ (-↑N - 1)) (@_fvar.6550 n)))
      (mul_le_mul_of_nonneg_left
        (zpow_le_zpow_right₀
          (Mathlib.Meta.NormNum.isNat_le_true (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1))
            (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 10)) (Eq.refl true))
          (sub_le_sub_right (neg_le_neg (GCongr.natCast_le_natCast hn)) 1))
        (le_of_lt
          (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2))
            (Eq.refl (Nat.ble 1 2)))))N:ℕ⊢ ↑N + 1 ≤ 10 ^ (N + 1)
        apply le_trans _ (pow_le_pow_left₀ (show 0 ≤ (2:ℚ) bya:ℕ → ℚ := fun n => 1 + 10 ^ (-↑n - 1)b:ℕ → ℚ := fun n => 1 - 10 ^ (-↑n - 1)ε:ℚhε:ε > 0hab:∀ (n : ℕ), |@_fvar.5075 n - @_fvar.5310 n| = 2 * 10 ^ (-↑n - 1) := 
  fun n =>
    Trans.trans
      (Trans.trans rfl
        (of_eq_true
          (Eq.trans
            (congr
              (congrArg (fun x => Eq |x|)
                (Eq.trans
                  (Mathlib.Tactic.Ring.sub_congr
                    (Mathlib.Tactic.Ring.add_congr
                      (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1)))
                      (Mathlib.Tactic.Ring.atom_pf'
                        (congrArg (HPow.hPow 10)
                          (Eq.trans
                            (Mathlib.Tactic.Ring.sub_congr
                              (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                    (Mathlib.Tactic.Ring.neg_one_mul
                                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                          (Eq.refl (Int.negOfNat 1))))))
                                  Mathlib.Tactic.Ring.neg_zero))
                              (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                              (Mathlib.Tactic.Ring.sub_pf
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1)))))
                                  Mathlib.Tactic.Ring.neg_zero)
                                (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                  (Mathlib.Tactic.Ring.add_pf_add_zero
                                    (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                            (Eq.trans
                              (congr
                                (congrArg HAdd.hAdd
                                  (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                    (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                (Eq.trans
                                  (congrArg (fun x => x + 0)
                                    (Eq.trans
                                      (Eq.trans
                                        (congr
                                          (congrArg HMul.hMul
                                            (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                              (pow_one ↑n)))
                                          (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                            (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                        (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                      (congrArg Neg.neg (mul_one ↑n))))
                                  (add_zero (-↑n))))
                              (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                      (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                        (Mathlib.Tactic.Ring.add_pf_zero_add ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))))
                    (Mathlib.Tactic.Ring.sub_congr
                      (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1)))
                      (Mathlib.Tactic.Ring.atom_pf'
                        (congrArg (HPow.hPow 10)
                          (Eq.trans
                            (Mathlib.Tactic.Ring.sub_congr
                              (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                    (Mathlib.Tactic.Ring.neg_one_mul
                                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                          (Eq.refl (Int.negOfNat 1))))))
                                  Mathlib.Tactic.Ring.neg_zero))
                              (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                              (Mathlib.Tactic.Ring.sub_pf
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1)))))
                                  Mathlib.Tactic.Ring.neg_zero)
                                (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                  (Mathlib.Tactic.Ring.add_pf_add_zero
                                    (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                            (Eq.trans
                              (congr
                                (congrArg HAdd.hAdd
                                  (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                    (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                (Eq.trans
                                  (congrArg (fun x => x + 0)
                                    (Eq.trans
                                      (Eq.trans
                                        (congr
                                          (congrArg HMul.hMul
                                            (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                              (pow_one ↑n)))
                                          (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                            (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                        (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                      (congrArg Neg.neg (mul_one ↑n))))
                                  (add_zero (-↑n))))
                              (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                      (Mathlib.Tactic.Ring.sub_pf
                        (Mathlib.Tactic.Ring.neg_add
                          (Mathlib.Tactic.Ring.neg_mul (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Tactic.Ring.neg_one_mul
                              (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                  (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                                  (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                                  (Eq.refl (Int.negOfNat 1))))))
                          Mathlib.Tactic.Ring.neg_zero)
                        (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                          (Mathlib.Tactic.Ring.add_pf_zero_add
                            ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                    (Mathlib.Tactic.Ring.sub_pf
                      (Mathlib.Tactic.Ring.neg_add
                        (Mathlib.Tactic.Ring.neg_one_mul
                          (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                            (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                              (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                              (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                              (Eq.refl (Int.negOfNat 1)))))
                        (Mathlib.Tactic.Ring.neg_add
                          (Mathlib.Tactic.Ring.neg_mul (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Tactic.Ring.neg_one_mul
                              (Mathlib.Meta.NormNum.IsNat.to_raw_eq
                                (Mathlib.Meta.NormNum.IsInt.to_isNat
                                  (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                    (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                                    (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 1)))))))
                          Mathlib.Tactic.Ring.neg_zero))
                      (Mathlib.Tactic.Ring.add_pf_add_overlap_zero
                        (Mathlib.Meta.NormNum.IsInt.to_isNat
                          (Mathlib.Meta.NormNum.isInt_add (Eq.refl HAdd.hAdd)
                            (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                            (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 0))))
                        (Mathlib.Tactic.Ring.add_pf_add_overlap
                          (Mathlib.Tactic.Ring.add_overlap_pf (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Meta.NormNum.IsNat.to_raw_eq
                              (Mathlib.Meta.NormNum.isNat_add (Eq.refl HAdd.hAdd) (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1)
                                (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1) (Eq.refl 2))))
                          (Mathlib.Tactic.Ring.add_pf_zero_add 0)))))
                  (Eq.trans
                    (congrArg (fun x => x * 2 + 0)
                      (Eq.trans (congrArg (HPow.hPow (10 ^ (-1 - ↑n))) Mathlib.Tactic.RingNF.nat_rawCast_1)
                        (pow_one (10 ^ (-1 - ↑n)))))
                    (add_zero (10 ^ (-1 - ↑n) * 2)))))
              (congrArg abs
                (Eq.trans
                  (Mathlib.Tactic.Ring.mul_congr
                    (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2)))
                    (Mathlib.Tactic.Ring.atom_pf'
                      (congrArg (HPow.hPow 10)
                        (Eq.trans
                          (Mathlib.Tactic.Ring.sub_congr
                            (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                              (Mathlib.Tactic.Ring.neg_add
                                (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1))))))
                                Mathlib.Tactic.Ring.neg_zero))
                            (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                            (Mathlib.Tactic.Ring.sub_pf
                              (Mathlib.Tactic.Ring.neg_add
                                (Mathlib.Tactic.Ring.neg_one_mul
                                  (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                    (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                      (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                      (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                      (Eq.refl (Int.negOfNat 1)))))
                                Mathlib.Tactic.Ring.neg_zero)
                              (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                (Mathlib.Tactic.Ring.add_pf_add_zero
                                  (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                          (Eq.trans
                            (congr
                              (congrArg HAdd.hAdd
                                (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                  (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                              (Eq.trans
                                (congrArg (fun x => x + 0)
                                  (Eq.trans
                                    (Eq.trans
                                      (congr
                                        (congrArg HMul.hMul
                                          (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                            (pow_one ↑n)))
                                        (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                          (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                      (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                    (congrArg Neg.neg (mul_one ↑n))))
                                (add_zero (-↑n))))
                            (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                    (Mathlib.Tactic.Ring.add_mul
                      (Mathlib.Tactic.Ring.mul_add
                        (Mathlib.Tactic.Ring.mul_pf_right (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                          (Mathlib.Tactic.Ring.mul_one (Nat.rawCast 2)))
                        (Mathlib.Tactic.Ring.mul_zero (Nat.rawCast 2))
                        (Mathlib.Tactic.Ring.add_pf_add_zero ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 2 + 0)))
                      (Mathlib.Tactic.Ring.zero_mul ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))
                      (Mathlib.Tactic.Ring.add_pf_add_zero ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 2 + 0))))
                  (Eq.trans
                    (congrArg (fun x => x * 2 + 0)
                      (Eq.trans (congrArg (HPow.hPow (10 ^ (-1 - ↑n))) Mathlib.Tactic.RingNF.nat_rawCast_1)
                        (pow_one (10 ^ (-1 - ↑n)))))
                    (add_zero (10 ^ (-1 - ↑n) * 2))))))
            (eq_self |10 ^ (-1 - ↑n) * 2|))))
      (abs_of_nonneg
        (le_of_lt
          (mul_pos
            (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2))
              (Eq.refl (Nat.ble 1 2)))
            (zpow_pos
              (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 10))
                (Eq.refl (Nat.ble 1 10)))
              (-↑n - 1)))))hab':∀ (N n : ℕ), n ≥ N → |@_fvar.5075 n - @_fvar.5310 n| ≤ 2 * 10 ^ (-↑N - 1) := 
  fun N n hn =>
    Eq.mpr (id (congrArg (fun _a => _a ≤ 2 * 10 ^ (-↑N - 1)) (@_fvar.6550 n)))
      (mul_le_mul_of_nonneg_left
        (zpow_le_zpow_right₀
          (Mathlib.Meta.NormNum.isNat_le_true (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1))
            (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 10)) (Eq.refl true))
          (sub_le_sub_right (neg_le_neg (GCongr.natCast_le_natCast hn)) 1))
        (le_of_lt
          (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2))
            (Eq.refl (Nat.ble 1 2)))))N:ℕ⊢ 2 / 10 ^ (N + 1) ≤ 2 / (↑N + 1) norm_numAll goals completed! 🐙)
          (show (2:ℚ) ≤ 10 bya:ℕ → ℚ := fun n => 1 + 10 ^ (-↑n - 1)b:ℕ → ℚ := fun n => 1 - 10 ^ (-↑n - 1)ε:ℚhε:ε > 0hab:∀ (n : ℕ), |@_fvar.5075 n - @_fvar.5310 n| = 2 * 10 ^ (-↑n - 1) := 
  fun n =>
    Trans.trans
      (Trans.trans rfl
        (of_eq_true
          (Eq.trans
            (congr
              (congrArg (fun x => Eq |x|)
                (Eq.trans
                  (Mathlib.Tactic.Ring.sub_congr
                    (Mathlib.Tactic.Ring.add_congr
                      (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1)))
                      (Mathlib.Tactic.Ring.atom_pf'
                        (congrArg (HPow.hPow 10)
                          (Eq.trans
                            (Mathlib.Tactic.Ring.sub_congr
                              (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                    (Mathlib.Tactic.Ring.neg_one_mul
                                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                          (Eq.refl (Int.negOfNat 1))))))
                                  Mathlib.Tactic.Ring.neg_zero))
                              (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                              (Mathlib.Tactic.Ring.sub_pf
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1)))))
                                  Mathlib.Tactic.Ring.neg_zero)
                                (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                  (Mathlib.Tactic.Ring.add_pf_add_zero
                                    (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                            (Eq.trans
                              (congr
                                (congrArg HAdd.hAdd
                                  (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                    (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                (Eq.trans
                                  (congrArg (fun x => x + 0)
                                    (Eq.trans
                                      (Eq.trans
                                        (congr
                                          (congrArg HMul.hMul
                                            (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                              (pow_one ↑n)))
                                          (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                            (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                        (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                      (congrArg Neg.neg (mul_one ↑n))))
                                  (add_zero (-↑n))))
                              (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                      (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                        (Mathlib.Tactic.Ring.add_pf_zero_add ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))))
                    (Mathlib.Tactic.Ring.sub_congr
                      (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1)))
                      (Mathlib.Tactic.Ring.atom_pf'
                        (congrArg (HPow.hPow 10)
                          (Eq.trans
                            (Mathlib.Tactic.Ring.sub_congr
                              (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                    (Mathlib.Tactic.Ring.neg_one_mul
                                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                          (Eq.refl (Int.negOfNat 1))))))
                                  Mathlib.Tactic.Ring.neg_zero))
                              (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                              (Mathlib.Tactic.Ring.sub_pf
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1)))))
                                  Mathlib.Tactic.Ring.neg_zero)
                                (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                  (Mathlib.Tactic.Ring.add_pf_add_zero
                                    (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                            (Eq.trans
                              (congr
                                (congrArg HAdd.hAdd
                                  (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                    (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                (Eq.trans
                                  (congrArg (fun x => x + 0)
                                    (Eq.trans
                                      (Eq.trans
                                        (congr
                                          (congrArg HMul.hMul
                                            (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                              (pow_one ↑n)))
                                          (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                            (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                        (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                      (congrArg Neg.neg (mul_one ↑n))))
                                  (add_zero (-↑n))))
                              (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                      (Mathlib.Tactic.Ring.sub_pf
                        (Mathlib.Tactic.Ring.neg_add
                          (Mathlib.Tactic.Ring.neg_mul (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Tactic.Ring.neg_one_mul
                              (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                  (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                                  (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                                  (Eq.refl (Int.negOfNat 1))))))
                          Mathlib.Tactic.Ring.neg_zero)
                        (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                          (Mathlib.Tactic.Ring.add_pf_zero_add
                            ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                    (Mathlib.Tactic.Ring.sub_pf
                      (Mathlib.Tactic.Ring.neg_add
                        (Mathlib.Tactic.Ring.neg_one_mul
                          (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                            (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                              (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                              (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                              (Eq.refl (Int.negOfNat 1)))))
                        (Mathlib.Tactic.Ring.neg_add
                          (Mathlib.Tactic.Ring.neg_mul (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Tactic.Ring.neg_one_mul
                              (Mathlib.Meta.NormNum.IsNat.to_raw_eq
                                (Mathlib.Meta.NormNum.IsInt.to_isNat
                                  (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                    (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                                    (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 1)))))))
                          Mathlib.Tactic.Ring.neg_zero))
                      (Mathlib.Tactic.Ring.add_pf_add_overlap_zero
                        (Mathlib.Meta.NormNum.IsInt.to_isNat
                          (Mathlib.Meta.NormNum.isInt_add (Eq.refl HAdd.hAdd)
                            (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                            (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 0))))
                        (Mathlib.Tactic.Ring.add_pf_add_overlap
                          (Mathlib.Tactic.Ring.add_overlap_pf (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Meta.NormNum.IsNat.to_raw_eq
                              (Mathlib.Meta.NormNum.isNat_add (Eq.refl HAdd.hAdd) (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1)
                                (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1) (Eq.refl 2))))
                          (Mathlib.Tactic.Ring.add_pf_zero_add 0)))))
                  (Eq.trans
                    (congrArg (fun x => x * 2 + 0)
                      (Eq.trans (congrArg (HPow.hPow (10 ^ (-1 - ↑n))) Mathlib.Tactic.RingNF.nat_rawCast_1)
                        (pow_one (10 ^ (-1 - ↑n)))))
                    (add_zero (10 ^ (-1 - ↑n) * 2)))))
              (congrArg abs
                (Eq.trans
                  (Mathlib.Tactic.Ring.mul_congr
                    (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2)))
                    (Mathlib.Tactic.Ring.atom_pf'
                      (congrArg (HPow.hPow 10)
                        (Eq.trans
                          (Mathlib.Tactic.Ring.sub_congr
                            (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                              (Mathlib.Tactic.Ring.neg_add
                                (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1))))))
                                Mathlib.Tactic.Ring.neg_zero))
                            (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                            (Mathlib.Tactic.Ring.sub_pf
                              (Mathlib.Tactic.Ring.neg_add
                                (Mathlib.Tactic.Ring.neg_one_mul
                                  (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                    (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                      (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                      (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                      (Eq.refl (Int.negOfNat 1)))))
                                Mathlib.Tactic.Ring.neg_zero)
                              (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                (Mathlib.Tactic.Ring.add_pf_add_zero
                                  (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                          (Eq.trans
                            (congr
                              (congrArg HAdd.hAdd
                                (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                  (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                              (Eq.trans
                                (congrArg (fun x => x + 0)
                                  (Eq.trans
                                    (Eq.trans
                                      (congr
                                        (congrArg HMul.hMul
                                          (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                            (pow_one ↑n)))
                                        (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                          (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                      (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                    (congrArg Neg.neg (mul_one ↑n))))
                                (add_zero (-↑n))))
                            (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                    (Mathlib.Tactic.Ring.add_mul
                      (Mathlib.Tactic.Ring.mul_add
                        (Mathlib.Tactic.Ring.mul_pf_right (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                          (Mathlib.Tactic.Ring.mul_one (Nat.rawCast 2)))
                        (Mathlib.Tactic.Ring.mul_zero (Nat.rawCast 2))
                        (Mathlib.Tactic.Ring.add_pf_add_zero ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 2 + 0)))
                      (Mathlib.Tactic.Ring.zero_mul ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))
                      (Mathlib.Tactic.Ring.add_pf_add_zero ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 2 + 0))))
                  (Eq.trans
                    (congrArg (fun x => x * 2 + 0)
                      (Eq.trans (congrArg (HPow.hPow (10 ^ (-1 - ↑n))) Mathlib.Tactic.RingNF.nat_rawCast_1)
                        (pow_one (10 ^ (-1 - ↑n)))))
                    (add_zero (10 ^ (-1 - ↑n) * 2))))))
            (eq_self |10 ^ (-1 - ↑n) * 2|))))
      (abs_of_nonneg
        (le_of_lt
          (mul_pos
            (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2))
              (Eq.refl (Nat.ble 1 2)))
            (zpow_pos
              (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 10))
                (Eq.refl (Nat.ble 1 10)))
              (-↑n - 1)))))hab':∀ (N n : ℕ), n ≥ N → |@_fvar.5075 n - @_fvar.5310 n| ≤ 2 * 10 ^ (-↑N - 1) := 
  fun N n hn =>
    Eq.mpr (id (congrArg (fun _a => _a ≤ 2 * 10 ^ (-↑N - 1)) (@_fvar.6550 n)))
      (mul_le_mul_of_nonneg_left
        (zpow_le_zpow_right₀
          (Mathlib.Meta.NormNum.isNat_le_true (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1))
            (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 10)) (Eq.refl true))
          (sub_le_sub_right (neg_le_neg (GCongr.natCast_le_natCast hn)) 1))
        (le_of_lt
          (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2))
            (Eq.refl (Nat.ble 1 2)))))N:ℕ⊢ 2 / 10 ^ (N + 1) ≤ 2 / (↑N + 1) norm_numAll goals completed! 🐙) _)
        convert Nat.cast_le.mpr (Section_4_3.two_pow_geq (N+1)) using 1h.e'_3a:ℕ → ℚ := fun n => 1 + 10 ^ (-↑n - 1)b:ℕ → ℚ := fun n => 1 - 10 ^ (-↑n - 1)ε:ℚhε:ε > 0hab:∀ (n : ℕ), |@_fvar.5075 n - @_fvar.5310 n| = 2 * 10 ^ (-↑n - 1) := 
  fun n =>
    Trans.trans
      (Trans.trans rfl
        (of_eq_true
          (Eq.trans
            (congr
              (congrArg (fun x => Eq |x|)
                (Eq.trans
                  (Mathlib.Tactic.Ring.sub_congr
                    (Mathlib.Tactic.Ring.add_congr
                      (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1)))
                      (Mathlib.Tactic.Ring.atom_pf'
                        (congrArg (HPow.hPow 10)
                          (Eq.trans
                            (Mathlib.Tactic.Ring.sub_congr
                              (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                    (Mathlib.Tactic.Ring.neg_one_mul
                                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                          (Eq.refl (Int.negOfNat 1))))))
                                  Mathlib.Tactic.Ring.neg_zero))
                              (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                              (Mathlib.Tactic.Ring.sub_pf
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1)))))
                                  Mathlib.Tactic.Ring.neg_zero)
                                (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                  (Mathlib.Tactic.Ring.add_pf_add_zero
                                    (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                            (Eq.trans
                              (congr
                                (congrArg HAdd.hAdd
                                  (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                    (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                (Eq.trans
                                  (congrArg (fun x => x + 0)
                                    (Eq.trans
                                      (Eq.trans
                                        (congr
                                          (congrArg HMul.hMul
                                            (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                              (pow_one ↑n)))
                                          (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                            (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                        (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                      (congrArg Neg.neg (mul_one ↑n))))
                                  (add_zero (-↑n))))
                              (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                      (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                        (Mathlib.Tactic.Ring.add_pf_zero_add ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))))
                    (Mathlib.Tactic.Ring.sub_congr
                      (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1)))
                      (Mathlib.Tactic.Ring.atom_pf'
                        (congrArg (HPow.hPow 10)
                          (Eq.trans
                            (Mathlib.Tactic.Ring.sub_congr
                              (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                    (Mathlib.Tactic.Ring.neg_one_mul
                                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                          (Eq.refl (Int.negOfNat 1))))))
                                  Mathlib.Tactic.Ring.neg_zero))
                              (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                              (Mathlib.Tactic.Ring.sub_pf
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1)))))
                                  Mathlib.Tactic.Ring.neg_zero)
                                (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                  (Mathlib.Tactic.Ring.add_pf_add_zero
                                    (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                            (Eq.trans
                              (congr
                                (congrArg HAdd.hAdd
                                  (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                    (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                (Eq.trans
                                  (congrArg (fun x => x + 0)
                                    (Eq.trans
                                      (Eq.trans
                                        (congr
                                          (congrArg HMul.hMul
                                            (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                              (pow_one ↑n)))
                                          (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                            (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                        (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                      (congrArg Neg.neg (mul_one ↑n))))
                                  (add_zero (-↑n))))
                              (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                      (Mathlib.Tactic.Ring.sub_pf
                        (Mathlib.Tactic.Ring.neg_add
                          (Mathlib.Tactic.Ring.neg_mul (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Tactic.Ring.neg_one_mul
                              (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                  (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                                  (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                                  (Eq.refl (Int.negOfNat 1))))))
                          Mathlib.Tactic.Ring.neg_zero)
                        (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                          (Mathlib.Tactic.Ring.add_pf_zero_add
                            ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                    (Mathlib.Tactic.Ring.sub_pf
                      (Mathlib.Tactic.Ring.neg_add
                        (Mathlib.Tactic.Ring.neg_one_mul
                          (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                            (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                              (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                              (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                              (Eq.refl (Int.negOfNat 1)))))
                        (Mathlib.Tactic.Ring.neg_add
                          (Mathlib.Tactic.Ring.neg_mul (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Tactic.Ring.neg_one_mul
                              (Mathlib.Meta.NormNum.IsNat.to_raw_eq
                                (Mathlib.Meta.NormNum.IsInt.to_isNat
                                  (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                    (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                                    (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 1)))))))
                          Mathlib.Tactic.Ring.neg_zero))
                      (Mathlib.Tactic.Ring.add_pf_add_overlap_zero
                        (Mathlib.Meta.NormNum.IsInt.to_isNat
                          (Mathlib.Meta.NormNum.isInt_add (Eq.refl HAdd.hAdd)
                            (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                            (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 0))))
                        (Mathlib.Tactic.Ring.add_pf_add_overlap
                          (Mathlib.Tactic.Ring.add_overlap_pf (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Meta.NormNum.IsNat.to_raw_eq
                              (Mathlib.Meta.NormNum.isNat_add (Eq.refl HAdd.hAdd) (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1)
                                (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1) (Eq.refl 2))))
                          (Mathlib.Tactic.Ring.add_pf_zero_add 0)))))
                  (Eq.trans
                    (congrArg (fun x => x * 2 + 0)
                      (Eq.trans (congrArg (HPow.hPow (10 ^ (-1 - ↑n))) Mathlib.Tactic.RingNF.nat_rawCast_1)
                        (pow_one (10 ^ (-1 - ↑n)))))
                    (add_zero (10 ^ (-1 - ↑n) * 2)))))
              (congrArg abs
                (Eq.trans
                  (Mathlib.Tactic.Ring.mul_congr
                    (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2)))
                    (Mathlib.Tactic.Ring.atom_pf'
                      (congrArg (HPow.hPow 10)
                        (Eq.trans
                          (Mathlib.Tactic.Ring.sub_congr
                            (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                              (Mathlib.Tactic.Ring.neg_add
                                (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1))))))
                                Mathlib.Tactic.Ring.neg_zero))
                            (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                            (Mathlib.Tactic.Ring.sub_pf
                              (Mathlib.Tactic.Ring.neg_add
                                (Mathlib.Tactic.Ring.neg_one_mul
                                  (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                    (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                      (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                      (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                      (Eq.refl (Int.negOfNat 1)))))
                                Mathlib.Tactic.Ring.neg_zero)
                              (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                (Mathlib.Tactic.Ring.add_pf_add_zero
                                  (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                          (Eq.trans
                            (congr
                              (congrArg HAdd.hAdd
                                (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                  (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                              (Eq.trans
                                (congrArg (fun x => x + 0)
                                  (Eq.trans
                                    (Eq.trans
                                      (congr
                                        (congrArg HMul.hMul
                                          (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                            (pow_one ↑n)))
                                        (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                          (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                      (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                    (congrArg Neg.neg (mul_one ↑n))))
                                (add_zero (-↑n))))
                            (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                    (Mathlib.Tactic.Ring.add_mul
                      (Mathlib.Tactic.Ring.mul_add
                        (Mathlib.Tactic.Ring.mul_pf_right (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                          (Mathlib.Tactic.Ring.mul_one (Nat.rawCast 2)))
                        (Mathlib.Tactic.Ring.mul_zero (Nat.rawCast 2))
                        (Mathlib.Tactic.Ring.add_pf_add_zero ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 2 + 0)))
                      (Mathlib.Tactic.Ring.zero_mul ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))
                      (Mathlib.Tactic.Ring.add_pf_add_zero ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 2 + 0))))
                  (Eq.trans
                    (congrArg (fun x => x * 2 + 0)
                      (Eq.trans (congrArg (HPow.hPow (10 ^ (-1 - ↑n))) Mathlib.Tactic.RingNF.nat_rawCast_1)
                        (pow_one (10 ^ (-1 - ↑n)))))
                    (add_zero (10 ^ (-1 - ↑n) * 2))))))
            (eq_self |10 ^ (-1 - ↑n) * 2|))))
      (abs_of_nonneg
        (le_of_lt
          (mul_pos
            (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2))
              (Eq.refl (Nat.ble 1 2)))
            (zpow_pos
              (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 10))
                (Eq.refl (Nat.ble 1 10)))
              (-↑n - 1)))))hab':∀ (N n : ℕ), n ≥ N → |@_fvar.5075 n - @_fvar.5310 n| ≤ 2 * 10 ^ (-↑N - 1) := 
  fun N n hn =>
    Eq.mpr (id (congrArg (fun _a => _a ≤ 2 * 10 ^ (-↑N - 1)) (@_fvar.6550 n)))
      (mul_le_mul_of_nonneg_left
        (zpow_le_zpow_right₀
          (Mathlib.Meta.NormNum.isNat_le_true (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1))
            (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 10)) (Eq.refl true))
          (sub_le_sub_right (neg_le_neg (GCongr.natCast_le_natCast hn)) 1))
        (le_of_lt
          (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2))
            (Eq.refl (Nat.ble 1 2)))))N:ℕ⊢ ↑N + 1 = ↑(N + 1)h.e'_4a:ℕ → ℚ := fun n => 1 + 10 ^ (-↑n - 1)b:ℕ → ℚ := fun n => 1 - 10 ^ (-↑n - 1)ε:ℚhε:ε > 0hab:∀ (n : ℕ), |@_fvar.5075 n - @_fvar.5310 n| = 2 * 10 ^ (-↑n - 1) := 
  fun n =>
    Trans.trans
      (Trans.trans rfl
        (of_eq_true
          (Eq.trans
            (congr
              (congrArg (fun x => Eq |x|)
                (Eq.trans
                  (Mathlib.Tactic.Ring.sub_congr
                    (Mathlib.Tactic.Ring.add_congr
                      (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1)))
                      (Mathlib.Tactic.Ring.atom_pf'
                        (congrArg (HPow.hPow 10)
                          (Eq.trans
                            (Mathlib.Tactic.Ring.sub_congr
                              (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                    (Mathlib.Tactic.Ring.neg_one_mul
                                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                          (Eq.refl (Int.negOfNat 1))))))
                                  Mathlib.Tactic.Ring.neg_zero))
                              (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                              (Mathlib.Tactic.Ring.sub_pf
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1)))))
                                  Mathlib.Tactic.Ring.neg_zero)
                                (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                  (Mathlib.Tactic.Ring.add_pf_add_zero
                                    (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                            (Eq.trans
                              (congr
                                (congrArg HAdd.hAdd
                                  (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                    (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                (Eq.trans
                                  (congrArg (fun x => x + 0)
                                    (Eq.trans
                                      (Eq.trans
                                        (congr
                                          (congrArg HMul.hMul
                                            (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                              (pow_one ↑n)))
                                          (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                            (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                        (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                      (congrArg Neg.neg (mul_one ↑n))))
                                  (add_zero (-↑n))))
                              (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                      (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                        (Mathlib.Tactic.Ring.add_pf_zero_add ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))))
                    (Mathlib.Tactic.Ring.sub_congr
                      (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1)))
                      (Mathlib.Tactic.Ring.atom_pf'
                        (congrArg (HPow.hPow 10)
                          (Eq.trans
                            (Mathlib.Tactic.Ring.sub_congr
                              (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                    (Mathlib.Tactic.Ring.neg_one_mul
                                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                          (Eq.refl (Int.negOfNat 1))))))
                                  Mathlib.Tactic.Ring.neg_zero))
                              (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                              (Mathlib.Tactic.Ring.sub_pf
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1)))))
                                  Mathlib.Tactic.Ring.neg_zero)
                                (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                  (Mathlib.Tactic.Ring.add_pf_add_zero
                                    (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                            (Eq.trans
                              (congr
                                (congrArg HAdd.hAdd
                                  (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                    (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                (Eq.trans
                                  (congrArg (fun x => x + 0)
                                    (Eq.trans
                                      (Eq.trans
                                        (congr
                                          (congrArg HMul.hMul
                                            (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                              (pow_one ↑n)))
                                          (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                            (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                        (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                      (congrArg Neg.neg (mul_one ↑n))))
                                  (add_zero (-↑n))))
                              (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                      (Mathlib.Tactic.Ring.sub_pf
                        (Mathlib.Tactic.Ring.neg_add
                          (Mathlib.Tactic.Ring.neg_mul (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Tactic.Ring.neg_one_mul
                              (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                  (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                                  (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                                  (Eq.refl (Int.negOfNat 1))))))
                          Mathlib.Tactic.Ring.neg_zero)
                        (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                          (Mathlib.Tactic.Ring.add_pf_zero_add
                            ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                    (Mathlib.Tactic.Ring.sub_pf
                      (Mathlib.Tactic.Ring.neg_add
                        (Mathlib.Tactic.Ring.neg_one_mul
                          (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                            (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                              (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                              (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                              (Eq.refl (Int.negOfNat 1)))))
                        (Mathlib.Tactic.Ring.neg_add
                          (Mathlib.Tactic.Ring.neg_mul (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Tactic.Ring.neg_one_mul
                              (Mathlib.Meta.NormNum.IsNat.to_raw_eq
                                (Mathlib.Meta.NormNum.IsInt.to_isNat
                                  (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                    (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                                    (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 1)))))))
                          Mathlib.Tactic.Ring.neg_zero))
                      (Mathlib.Tactic.Ring.add_pf_add_overlap_zero
                        (Mathlib.Meta.NormNum.IsInt.to_isNat
                          (Mathlib.Meta.NormNum.isInt_add (Eq.refl HAdd.hAdd)
                            (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                            (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 0))))
                        (Mathlib.Tactic.Ring.add_pf_add_overlap
                          (Mathlib.Tactic.Ring.add_overlap_pf (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Meta.NormNum.IsNat.to_raw_eq
                              (Mathlib.Meta.NormNum.isNat_add (Eq.refl HAdd.hAdd) (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1)
                                (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1) (Eq.refl 2))))
                          (Mathlib.Tactic.Ring.add_pf_zero_add 0)))))
                  (Eq.trans
                    (congrArg (fun x => x * 2 + 0)
                      (Eq.trans (congrArg (HPow.hPow (10 ^ (-1 - ↑n))) Mathlib.Tactic.RingNF.nat_rawCast_1)
                        (pow_one (10 ^ (-1 - ↑n)))))
                    (add_zero (10 ^ (-1 - ↑n) * 2)))))
              (congrArg abs
                (Eq.trans
                  (Mathlib.Tactic.Ring.mul_congr
                    (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2)))
                    (Mathlib.Tactic.Ring.atom_pf'
                      (congrArg (HPow.hPow 10)
                        (Eq.trans
                          (Mathlib.Tactic.Ring.sub_congr
                            (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                              (Mathlib.Tactic.Ring.neg_add
                                (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1))))))
                                Mathlib.Tactic.Ring.neg_zero))
                            (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                            (Mathlib.Tactic.Ring.sub_pf
                              (Mathlib.Tactic.Ring.neg_add
                                (Mathlib.Tactic.Ring.neg_one_mul
                                  (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                    (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                      (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                      (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                      (Eq.refl (Int.negOfNat 1)))))
                                Mathlib.Tactic.Ring.neg_zero)
                              (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                (Mathlib.Tactic.Ring.add_pf_add_zero
                                  (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                          (Eq.trans
                            (congr
                              (congrArg HAdd.hAdd
                                (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                  (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                              (Eq.trans
                                (congrArg (fun x => x + 0)
                                  (Eq.trans
                                    (Eq.trans
                                      (congr
                                        (congrArg HMul.hMul
                                          (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                            (pow_one ↑n)))
                                        (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                          (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                      (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                    (congrArg Neg.neg (mul_one ↑n))))
                                (add_zero (-↑n))))
                            (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                    (Mathlib.Tactic.Ring.add_mul
                      (Mathlib.Tactic.Ring.mul_add
                        (Mathlib.Tactic.Ring.mul_pf_right (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                          (Mathlib.Tactic.Ring.mul_one (Nat.rawCast 2)))
                        (Mathlib.Tactic.Ring.mul_zero (Nat.rawCast 2))
                        (Mathlib.Tactic.Ring.add_pf_add_zero ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 2 + 0)))
                      (Mathlib.Tactic.Ring.zero_mul ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))
                      (Mathlib.Tactic.Ring.add_pf_add_zero ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 2 + 0))))
                  (Eq.trans
                    (congrArg (fun x => x * 2 + 0)
                      (Eq.trans (congrArg (HPow.hPow (10 ^ (-1 - ↑n))) Mathlib.Tactic.RingNF.nat_rawCast_1)
                        (pow_one (10 ^ (-1 - ↑n)))))
                    (add_zero (10 ^ (-1 - ↑n) * 2))))))
            (eq_self |10 ^ (-1 - ↑n) * 2|))))
      (abs_of_nonneg
        (le_of_lt
          (mul_pos
            (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2))
              (Eq.refl (Nat.ble 1 2)))
            (zpow_pos
              (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 10))
                (Eq.refl (Nat.ble 1 10)))
              (-↑n - 1)))))hab':∀ (N n : ℕ), n ≥ N → |@_fvar.5075 n - @_fvar.5310 n| ≤ 2 * 10 ^ (-↑N - 1) := 
  fun N n hn =>
    Eq.mpr (id (congrArg (fun _a => _a ≤ 2 * 10 ^ (-↑N - 1)) (@_fvar.6550 n)))
      (mul_le_mul_of_nonneg_left
        (zpow_le_zpow_right₀
          (Mathlib.Meta.NormNum.isNat_le_true (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1))
            (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 10)) (Eq.refl true))
          (sub_le_sub_right (neg_le_neg (GCongr.natCast_le_natCast hn)) 1))
        (le_of_lt
          (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2))
            (Eq.refl (Nat.ble 1 2)))))N:ℕ⊢ 2 ^ (N + 1) = ↑(2 ^ (N + 1))convert_2a:ℕ → ℚ := fun n => 1 + 10 ^ (-↑n - 1)b:ℕ → ℚ := fun n => 1 - 10 ^ (-↑n - 1)ε:ℚhε:ε > 0hab:∀ (n : ℕ), |@_fvar.5075 n - @_fvar.5310 n| = 2 * 10 ^ (-↑n - 1) := 
  fun n =>
    Trans.trans
      (Trans.trans rfl
        (of_eq_true
          (Eq.trans
            (congr
              (congrArg (fun x => Eq |x|)
                (Eq.trans
                  (Mathlib.Tactic.Ring.sub_congr
                    (Mathlib.Tactic.Ring.add_congr
                      (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1)))
                      (Mathlib.Tactic.Ring.atom_pf'
                        (congrArg (HPow.hPow 10)
                          (Eq.trans
                            (Mathlib.Tactic.Ring.sub_congr
                              (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                    (Mathlib.Tactic.Ring.neg_one_mul
                                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                          (Eq.refl (Int.negOfNat 1))))))
                                  Mathlib.Tactic.Ring.neg_zero))
                              (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                              (Mathlib.Tactic.Ring.sub_pf
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1)))))
                                  Mathlib.Tactic.Ring.neg_zero)
                                (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                  (Mathlib.Tactic.Ring.add_pf_add_zero
                                    (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                            (Eq.trans
                              (congr
                                (congrArg HAdd.hAdd
                                  (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                    (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                (Eq.trans
                                  (congrArg (fun x => x + 0)
                                    (Eq.trans
                                      (Eq.trans
                                        (congr
                                          (congrArg HMul.hMul
                                            (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                              (pow_one ↑n)))
                                          (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                            (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                        (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                      (congrArg Neg.neg (mul_one ↑n))))
                                  (add_zero (-↑n))))
                              (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                      (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                        (Mathlib.Tactic.Ring.add_pf_zero_add ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))))
                    (Mathlib.Tactic.Ring.sub_congr
                      (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1)))
                      (Mathlib.Tactic.Ring.atom_pf'
                        (congrArg (HPow.hPow 10)
                          (Eq.trans
                            (Mathlib.Tactic.Ring.sub_congr
                              (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                    (Mathlib.Tactic.Ring.neg_one_mul
                                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                          (Eq.refl (Int.negOfNat 1))))))
                                  Mathlib.Tactic.Ring.neg_zero))
                              (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                              (Mathlib.Tactic.Ring.sub_pf
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1)))))
                                  Mathlib.Tactic.Ring.neg_zero)
                                (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                  (Mathlib.Tactic.Ring.add_pf_add_zero
                                    (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                            (Eq.trans
                              (congr
                                (congrArg HAdd.hAdd
                                  (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                    (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                (Eq.trans
                                  (congrArg (fun x => x + 0)
                                    (Eq.trans
                                      (Eq.trans
                                        (congr
                                          (congrArg HMul.hMul
                                            (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                              (pow_one ↑n)))
                                          (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                            (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                        (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                      (congrArg Neg.neg (mul_one ↑n))))
                                  (add_zero (-↑n))))
                              (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                      (Mathlib.Tactic.Ring.sub_pf
                        (Mathlib.Tactic.Ring.neg_add
                          (Mathlib.Tactic.Ring.neg_mul (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Tactic.Ring.neg_one_mul
                              (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                  (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                                  (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                                  (Eq.refl (Int.negOfNat 1))))))
                          Mathlib.Tactic.Ring.neg_zero)
                        (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                          (Mathlib.Tactic.Ring.add_pf_zero_add
                            ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                    (Mathlib.Tactic.Ring.sub_pf
                      (Mathlib.Tactic.Ring.neg_add
                        (Mathlib.Tactic.Ring.neg_one_mul
                          (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                            (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                              (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                              (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                              (Eq.refl (Int.negOfNat 1)))))
                        (Mathlib.Tactic.Ring.neg_add
                          (Mathlib.Tactic.Ring.neg_mul (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Tactic.Ring.neg_one_mul
                              (Mathlib.Meta.NormNum.IsNat.to_raw_eq
                                (Mathlib.Meta.NormNum.IsInt.to_isNat
                                  (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                    (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                                    (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 1)))))))
                          Mathlib.Tactic.Ring.neg_zero))
                      (Mathlib.Tactic.Ring.add_pf_add_overlap_zero
                        (Mathlib.Meta.NormNum.IsInt.to_isNat
                          (Mathlib.Meta.NormNum.isInt_add (Eq.refl HAdd.hAdd)
                            (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                            (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 0))))
                        (Mathlib.Tactic.Ring.add_pf_add_overlap
                          (Mathlib.Tactic.Ring.add_overlap_pf (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Meta.NormNum.IsNat.to_raw_eq
                              (Mathlib.Meta.NormNum.isNat_add (Eq.refl HAdd.hAdd) (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1)
                                (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1) (Eq.refl 2))))
                          (Mathlib.Tactic.Ring.add_pf_zero_add 0)))))
                  (Eq.trans
                    (congrArg (fun x => x * 2 + 0)
                      (Eq.trans (congrArg (HPow.hPow (10 ^ (-1 - ↑n))) Mathlib.Tactic.RingNF.nat_rawCast_1)
                        (pow_one (10 ^ (-1 - ↑n)))))
                    (add_zero (10 ^ (-1 - ↑n) * 2)))))
              (congrArg abs
                (Eq.trans
                  (Mathlib.Tactic.Ring.mul_congr
                    (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2)))
                    (Mathlib.Tactic.Ring.atom_pf'
                      (congrArg (HPow.hPow 10)
                        (Eq.trans
                          (Mathlib.Tactic.Ring.sub_congr
                            (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                              (Mathlib.Tactic.Ring.neg_add
                                (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1))))))
                                Mathlib.Tactic.Ring.neg_zero))
                            (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                            (Mathlib.Tactic.Ring.sub_pf
                              (Mathlib.Tactic.Ring.neg_add
                                (Mathlib.Tactic.Ring.neg_one_mul
                                  (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                    (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                      (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                      (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                      (Eq.refl (Int.negOfNat 1)))))
                                Mathlib.Tactic.Ring.neg_zero)
                              (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                (Mathlib.Tactic.Ring.add_pf_add_zero
                                  (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                          (Eq.trans
                            (congr
                              (congrArg HAdd.hAdd
                                (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                  (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                              (Eq.trans
                                (congrArg (fun x => x + 0)
                                  (Eq.trans
                                    (Eq.trans
                                      (congr
                                        (congrArg HMul.hMul
                                          (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                            (pow_one ↑n)))
                                        (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                          (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                      (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                    (congrArg Neg.neg (mul_one ↑n))))
                                (add_zero (-↑n))))
                            (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                    (Mathlib.Tactic.Ring.add_mul
                      (Mathlib.Tactic.Ring.mul_add
                        (Mathlib.Tactic.Ring.mul_pf_right (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                          (Mathlib.Tactic.Ring.mul_one (Nat.rawCast 2)))
                        (Mathlib.Tactic.Ring.mul_zero (Nat.rawCast 2))
                        (Mathlib.Tactic.Ring.add_pf_add_zero ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 2 + 0)))
                      (Mathlib.Tactic.Ring.zero_mul ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))
                      (Mathlib.Tactic.Ring.add_pf_add_zero ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 2 + 0))))
                  (Eq.trans
                    (congrArg (fun x => x * 2 + 0)
                      (Eq.trans (congrArg (HPow.hPow (10 ^ (-1 - ↑n))) Mathlib.Tactic.RingNF.nat_rawCast_1)
                        (pow_one (10 ^ (-1 - ↑n)))))
                    (add_zero (10 ^ (-1 - ↑n) * 2))))))
            (eq_self |10 ^ (-1 - ↑n) * 2|))))
      (abs_of_nonneg
        (le_of_lt
          (mul_pos
            (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2))
              (Eq.refl (Nat.ble 1 2)))
            (zpow_pos
              (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 10))
                (Eq.refl (Nat.ble 1 10)))
              (-↑n - 1)))))hab':∀ (N n : ℕ), n ≥ N → |@_fvar.5075 n - @_fvar.5310 n| ≤ 2 * 10 ^ (-↑N - 1) := 
  fun N n hn =>
    Eq.mpr (id (congrArg (fun _a => _a ≤ 2 * 10 ^ (-↑N - 1)) (@_fvar.6550 n)))
      (mul_le_mul_of_nonneg_left
        (zpow_le_zpow_right₀
          (Mathlib.Meta.NormNum.isNat_le_true (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1))
            (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 10)) (Eq.refl true))
          (sub_le_sub_right (neg_le_neg (GCongr.natCast_le_natCast hn)) 1))
        (le_of_lt
          (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2))
            (Eq.refl (Nat.ble 1 2)))))N:ℕ⊢ AddMonoidWithOne ℚconvert_4a:ℕ → ℚ := fun n => 1 + 10 ^ (-↑n - 1)b:ℕ → ℚ := fun n => 1 - 10 ^ (-↑n - 1)ε:ℚhε:ε > 0hab:∀ (n : ℕ), |@_fvar.5075 n - @_fvar.5310 n| = 2 * 10 ^ (-↑n - 1) := 
  fun n =>
    Trans.trans
      (Trans.trans rfl
        (of_eq_true
          (Eq.trans
            (congr
              (congrArg (fun x => Eq |x|)
                (Eq.trans
                  (Mathlib.Tactic.Ring.sub_congr
                    (Mathlib.Tactic.Ring.add_congr
                      (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1)))
                      (Mathlib.Tactic.Ring.atom_pf'
                        (congrArg (HPow.hPow 10)
                          (Eq.trans
                            (Mathlib.Tactic.Ring.sub_congr
                              (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                    (Mathlib.Tactic.Ring.neg_one_mul
                                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                          (Eq.refl (Int.negOfNat 1))))))
                                  Mathlib.Tactic.Ring.neg_zero))
                              (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                              (Mathlib.Tactic.Ring.sub_pf
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1)))))
                                  Mathlib.Tactic.Ring.neg_zero)
                                (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                  (Mathlib.Tactic.Ring.add_pf_add_zero
                                    (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                            (Eq.trans
                              (congr
                                (congrArg HAdd.hAdd
                                  (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                    (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                (Eq.trans
                                  (congrArg (fun x => x + 0)
                                    (Eq.trans
                                      (Eq.trans
                                        (congr
                                          (congrArg HMul.hMul
                                            (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                              (pow_one ↑n)))
                                          (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                            (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                        (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                      (congrArg Neg.neg (mul_one ↑n))))
                                  (add_zero (-↑n))))
                              (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                      (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                        (Mathlib.Tactic.Ring.add_pf_zero_add ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))))
                    (Mathlib.Tactic.Ring.sub_congr
                      (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1)))
                      (Mathlib.Tactic.Ring.atom_pf'
                        (congrArg (HPow.hPow 10)
                          (Eq.trans
                            (Mathlib.Tactic.Ring.sub_congr
                              (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                    (Mathlib.Tactic.Ring.neg_one_mul
                                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                          (Eq.refl (Int.negOfNat 1))))))
                                  Mathlib.Tactic.Ring.neg_zero))
                              (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                              (Mathlib.Tactic.Ring.sub_pf
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1)))))
                                  Mathlib.Tactic.Ring.neg_zero)
                                (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                  (Mathlib.Tactic.Ring.add_pf_add_zero
                                    (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                            (Eq.trans
                              (congr
                                (congrArg HAdd.hAdd
                                  (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                    (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                (Eq.trans
                                  (congrArg (fun x => x + 0)
                                    (Eq.trans
                                      (Eq.trans
                                        (congr
                                          (congrArg HMul.hMul
                                            (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                              (pow_one ↑n)))
                                          (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                            (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                        (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                      (congrArg Neg.neg (mul_one ↑n))))
                                  (add_zero (-↑n))))
                              (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                      (Mathlib.Tactic.Ring.sub_pf
                        (Mathlib.Tactic.Ring.neg_add
                          (Mathlib.Tactic.Ring.neg_mul (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Tactic.Ring.neg_one_mul
                              (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                  (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                                  (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                                  (Eq.refl (Int.negOfNat 1))))))
                          Mathlib.Tactic.Ring.neg_zero)
                        (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                          (Mathlib.Tactic.Ring.add_pf_zero_add
                            ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                    (Mathlib.Tactic.Ring.sub_pf
                      (Mathlib.Tactic.Ring.neg_add
                        (Mathlib.Tactic.Ring.neg_one_mul
                          (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                            (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                              (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                              (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                              (Eq.refl (Int.negOfNat 1)))))
                        (Mathlib.Tactic.Ring.neg_add
                          (Mathlib.Tactic.Ring.neg_mul (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Tactic.Ring.neg_one_mul
                              (Mathlib.Meta.NormNum.IsNat.to_raw_eq
                                (Mathlib.Meta.NormNum.IsInt.to_isNat
                                  (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                    (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                                    (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 1)))))))
                          Mathlib.Tactic.Ring.neg_zero))
                      (Mathlib.Tactic.Ring.add_pf_add_overlap_zero
                        (Mathlib.Meta.NormNum.IsInt.to_isNat
                          (Mathlib.Meta.NormNum.isInt_add (Eq.refl HAdd.hAdd)
                            (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                            (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 0))))
                        (Mathlib.Tactic.Ring.add_pf_add_overlap
                          (Mathlib.Tactic.Ring.add_overlap_pf (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Meta.NormNum.IsNat.to_raw_eq
                              (Mathlib.Meta.NormNum.isNat_add (Eq.refl HAdd.hAdd) (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1)
                                (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1) (Eq.refl 2))))
                          (Mathlib.Tactic.Ring.add_pf_zero_add 0)))))
                  (Eq.trans
                    (congrArg (fun x => x * 2 + 0)
                      (Eq.trans (congrArg (HPow.hPow (10 ^ (-1 - ↑n))) Mathlib.Tactic.RingNF.nat_rawCast_1)
                        (pow_one (10 ^ (-1 - ↑n)))))
                    (add_zero (10 ^ (-1 - ↑n) * 2)))))
              (congrArg abs
                (Eq.trans
                  (Mathlib.Tactic.Ring.mul_congr
                    (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2)))
                    (Mathlib.Tactic.Ring.atom_pf'
                      (congrArg (HPow.hPow 10)
                        (Eq.trans
                          (Mathlib.Tactic.Ring.sub_congr
                            (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                              (Mathlib.Tactic.Ring.neg_add
                                (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1))))))
                                Mathlib.Tactic.Ring.neg_zero))
                            (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                            (Mathlib.Tactic.Ring.sub_pf
                              (Mathlib.Tactic.Ring.neg_add
                                (Mathlib.Tactic.Ring.neg_one_mul
                                  (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                    (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                      (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                      (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                      (Eq.refl (Int.negOfNat 1)))))
                                Mathlib.Tactic.Ring.neg_zero)
                              (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                (Mathlib.Tactic.Ring.add_pf_add_zero
                                  (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                          (Eq.trans
                            (congr
                              (congrArg HAdd.hAdd
                                (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                  (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                              (Eq.trans
                                (congrArg (fun x => x + 0)
                                  (Eq.trans
                                    (Eq.trans
                                      (congr
                                        (congrArg HMul.hMul
                                          (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                            (pow_one ↑n)))
                                        (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                          (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                      (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                    (congrArg Neg.neg (mul_one ↑n))))
                                (add_zero (-↑n))))
                            (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                    (Mathlib.Tactic.Ring.add_mul
                      (Mathlib.Tactic.Ring.mul_add
                        (Mathlib.Tactic.Ring.mul_pf_right (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                          (Mathlib.Tactic.Ring.mul_one (Nat.rawCast 2)))
                        (Mathlib.Tactic.Ring.mul_zero (Nat.rawCast 2))
                        (Mathlib.Tactic.Ring.add_pf_add_zero ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 2 + 0)))
                      (Mathlib.Tactic.Ring.zero_mul ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))
                      (Mathlib.Tactic.Ring.add_pf_add_zero ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 2 + 0))))
                  (Eq.trans
                    (congrArg (fun x => x * 2 + 0)
                      (Eq.trans (congrArg (HPow.hPow (10 ^ (-1 - ↑n))) Mathlib.Tactic.RingNF.nat_rawCast_1)
                        (pow_one (10 ^ (-1 - ↑n)))))
                    (add_zero (10 ^ (-1 - ↑n) * 2))))))
            (eq_self |10 ^ (-1 - ↑n) * 2|))))
      (abs_of_nonneg
        (le_of_lt
          (mul_pos
            (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2))
              (Eq.refl (Nat.ble 1 2)))
            (zpow_pos
              (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 10))
                (Eq.refl (Nat.ble 1 10)))
              (-↑n - 1)))))hab':∀ (N n : ℕ), n ≥ N → |@_fvar.5075 n - @_fvar.5310 n| ≤ 2 * 10 ^ (-↑N - 1) := 
  fun N n hn =>
    Eq.mpr (id (congrArg (fun _a => _a ≤ 2 * 10 ^ (-↑N - 1)) (@_fvar.6550 n)))
      (mul_le_mul_of_nonneg_left
        (zpow_le_zpow_right₀
          (Mathlib.Meta.NormNum.isNat_le_true (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1))
            (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 10)) (Eq.refl true))
          (sub_le_sub_right (neg_le_neg (GCongr.natCast_le_natCast hn)) 1))
        (le_of_lt
          (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2))
            (Eq.refl (Nat.ble 1 2)))))N:ℕ⊢ AddLeftMono ℚconvert_5a:ℕ → ℚ := fun n => 1 + 10 ^ (-↑n - 1)b:ℕ → ℚ := fun n => 1 - 10 ^ (-↑n - 1)ε:ℚhε:ε > 0hab:∀ (n : ℕ), |@_fvar.5075 n - @_fvar.5310 n| = 2 * 10 ^ (-↑n - 1) := 
  fun n =>
    Trans.trans
      (Trans.trans rfl
        (of_eq_true
          (Eq.trans
            (congr
              (congrArg (fun x => Eq |x|)
                (Eq.trans
                  (Mathlib.Tactic.Ring.sub_congr
                    (Mathlib.Tactic.Ring.add_congr
                      (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1)))
                      (Mathlib.Tactic.Ring.atom_pf'
                        (congrArg (HPow.hPow 10)
                          (Eq.trans
                            (Mathlib.Tactic.Ring.sub_congr
                              (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                    (Mathlib.Tactic.Ring.neg_one_mul
                                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                          (Eq.refl (Int.negOfNat 1))))))
                                  Mathlib.Tactic.Ring.neg_zero))
                              (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                              (Mathlib.Tactic.Ring.sub_pf
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1)))))
                                  Mathlib.Tactic.Ring.neg_zero)
                                (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                  (Mathlib.Tactic.Ring.add_pf_add_zero
                                    (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                            (Eq.trans
                              (congr
                                (congrArg HAdd.hAdd
                                  (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                    (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                (Eq.trans
                                  (congrArg (fun x => x + 0)
                                    (Eq.trans
                                      (Eq.trans
                                        (congr
                                          (congrArg HMul.hMul
                                            (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                              (pow_one ↑n)))
                                          (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                            (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                        (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                      (congrArg Neg.neg (mul_one ↑n))))
                                  (add_zero (-↑n))))
                              (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                      (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                        (Mathlib.Tactic.Ring.add_pf_zero_add ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))))
                    (Mathlib.Tactic.Ring.sub_congr
                      (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1)))
                      (Mathlib.Tactic.Ring.atom_pf'
                        (congrArg (HPow.hPow 10)
                          (Eq.trans
                            (Mathlib.Tactic.Ring.sub_congr
                              (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                    (Mathlib.Tactic.Ring.neg_one_mul
                                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                          (Eq.refl (Int.negOfNat 1))))))
                                  Mathlib.Tactic.Ring.neg_zero))
                              (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                              (Mathlib.Tactic.Ring.sub_pf
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1)))))
                                  Mathlib.Tactic.Ring.neg_zero)
                                (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                  (Mathlib.Tactic.Ring.add_pf_add_zero
                                    (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                            (Eq.trans
                              (congr
                                (congrArg HAdd.hAdd
                                  (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                    (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                (Eq.trans
                                  (congrArg (fun x => x + 0)
                                    (Eq.trans
                                      (Eq.trans
                                        (congr
                                          (congrArg HMul.hMul
                                            (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                              (pow_one ↑n)))
                                          (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                            (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                        (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                      (congrArg Neg.neg (mul_one ↑n))))
                                  (add_zero (-↑n))))
                              (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                      (Mathlib.Tactic.Ring.sub_pf
                        (Mathlib.Tactic.Ring.neg_add
                          (Mathlib.Tactic.Ring.neg_mul (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Tactic.Ring.neg_one_mul
                              (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                  (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                                  (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                                  (Eq.refl (Int.negOfNat 1))))))
                          Mathlib.Tactic.Ring.neg_zero)
                        (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                          (Mathlib.Tactic.Ring.add_pf_zero_add
                            ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                    (Mathlib.Tactic.Ring.sub_pf
                      (Mathlib.Tactic.Ring.neg_add
                        (Mathlib.Tactic.Ring.neg_one_mul
                          (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                            (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                              (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                              (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                              (Eq.refl (Int.negOfNat 1)))))
                        (Mathlib.Tactic.Ring.neg_add
                          (Mathlib.Tactic.Ring.neg_mul (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Tactic.Ring.neg_one_mul
                              (Mathlib.Meta.NormNum.IsNat.to_raw_eq
                                (Mathlib.Meta.NormNum.IsInt.to_isNat
                                  (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                    (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                                    (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 1)))))))
                          Mathlib.Tactic.Ring.neg_zero))
                      (Mathlib.Tactic.Ring.add_pf_add_overlap_zero
                        (Mathlib.Meta.NormNum.IsInt.to_isNat
                          (Mathlib.Meta.NormNum.isInt_add (Eq.refl HAdd.hAdd)
                            (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                            (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 0))))
                        (Mathlib.Tactic.Ring.add_pf_add_overlap
                          (Mathlib.Tactic.Ring.add_overlap_pf (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Meta.NormNum.IsNat.to_raw_eq
                              (Mathlib.Meta.NormNum.isNat_add (Eq.refl HAdd.hAdd) (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1)
                                (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1) (Eq.refl 2))))
                          (Mathlib.Tactic.Ring.add_pf_zero_add 0)))))
                  (Eq.trans
                    (congrArg (fun x => x * 2 + 0)
                      (Eq.trans (congrArg (HPow.hPow (10 ^ (-1 - ↑n))) Mathlib.Tactic.RingNF.nat_rawCast_1)
                        (pow_one (10 ^ (-1 - ↑n)))))
                    (add_zero (10 ^ (-1 - ↑n) * 2)))))
              (congrArg abs
                (Eq.trans
                  (Mathlib.Tactic.Ring.mul_congr
                    (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2)))
                    (Mathlib.Tactic.Ring.atom_pf'
                      (congrArg (HPow.hPow 10)
                        (Eq.trans
                          (Mathlib.Tactic.Ring.sub_congr
                            (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                              (Mathlib.Tactic.Ring.neg_add
                                (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1))))))
                                Mathlib.Tactic.Ring.neg_zero))
                            (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                            (Mathlib.Tactic.Ring.sub_pf
                              (Mathlib.Tactic.Ring.neg_add
                                (Mathlib.Tactic.Ring.neg_one_mul
                                  (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                    (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                      (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                      (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                      (Eq.refl (Int.negOfNat 1)))))
                                Mathlib.Tactic.Ring.neg_zero)
                              (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                (Mathlib.Tactic.Ring.add_pf_add_zero
                                  (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                          (Eq.trans
                            (congr
                              (congrArg HAdd.hAdd
                                (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                  (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                              (Eq.trans
                                (congrArg (fun x => x + 0)
                                  (Eq.trans
                                    (Eq.trans
                                      (congr
                                        (congrArg HMul.hMul
                                          (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                            (pow_one ↑n)))
                                        (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                          (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                      (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                    (congrArg Neg.neg (mul_one ↑n))))
                                (add_zero (-↑n))))
                            (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                    (Mathlib.Tactic.Ring.add_mul
                      (Mathlib.Tactic.Ring.mul_add
                        (Mathlib.Tactic.Ring.mul_pf_right (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                          (Mathlib.Tactic.Ring.mul_one (Nat.rawCast 2)))
                        (Mathlib.Tactic.Ring.mul_zero (Nat.rawCast 2))
                        (Mathlib.Tactic.Ring.add_pf_add_zero ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 2 + 0)))
                      (Mathlib.Tactic.Ring.zero_mul ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))
                      (Mathlib.Tactic.Ring.add_pf_add_zero ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 2 + 0))))
                  (Eq.trans
                    (congrArg (fun x => x * 2 + 0)
                      (Eq.trans (congrArg (HPow.hPow (10 ^ (-1 - ↑n))) Mathlib.Tactic.RingNF.nat_rawCast_1)
                        (pow_one (10 ^ (-1 - ↑n)))))
                    (add_zero (10 ^ (-1 - ↑n) * 2))))))
            (eq_self |10 ^ (-1 - ↑n) * 2|))))
      (abs_of_nonneg
        (le_of_lt
          (mul_pos
            (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2))
              (Eq.refl (Nat.ble 1 2)))
            (zpow_pos
              (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 10))
                (Eq.refl (Nat.ble 1 10)))
              (-↑n - 1)))))hab':∀ (N n : ℕ), n ≥ N → |@_fvar.5075 n - @_fvar.5310 n| ≤ 2 * 10 ^ (-↑N - 1) := 
  fun N n hn =>
    Eq.mpr (id (congrArg (fun _a => _a ≤ 2 * 10 ^ (-↑N - 1)) (@_fvar.6550 n)))
      (mul_le_mul_of_nonneg_left
        (zpow_le_zpow_right₀
          (Mathlib.Meta.NormNum.isNat_le_true (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1))
            (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 10)) (Eq.refl true))
          (sub_le_sub_right (neg_le_neg (GCongr.natCast_le_natCast hn)) 1))
        (le_of_lt
          (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2))
            (Eq.refl (Nat.ble 1 2)))))N:ℕ⊢ ZeroLEOneClass ℚconvert_6a:ℕ → ℚ := fun n => 1 + 10 ^ (-↑n - 1)b:ℕ → ℚ := fun n => 1 - 10 ^ (-↑n - 1)ε:ℚhε:ε > 0hab:∀ (n : ℕ), |@_fvar.5075 n - @_fvar.5310 n| = 2 * 10 ^ (-↑n - 1) := 
  fun n =>
    Trans.trans
      (Trans.trans rfl
        (of_eq_true
          (Eq.trans
            (congr
              (congrArg (fun x => Eq |x|)
                (Eq.trans
                  (Mathlib.Tactic.Ring.sub_congr
                    (Mathlib.Tactic.Ring.add_congr
                      (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1)))
                      (Mathlib.Tactic.Ring.atom_pf'
                        (congrArg (HPow.hPow 10)
                          (Eq.trans
                            (Mathlib.Tactic.Ring.sub_congr
                              (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                    (Mathlib.Tactic.Ring.neg_one_mul
                                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                          (Eq.refl (Int.negOfNat 1))))))
                                  Mathlib.Tactic.Ring.neg_zero))
                              (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                              (Mathlib.Tactic.Ring.sub_pf
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1)))))
                                  Mathlib.Tactic.Ring.neg_zero)
                                (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                  (Mathlib.Tactic.Ring.add_pf_add_zero
                                    (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                            (Eq.trans
                              (congr
                                (congrArg HAdd.hAdd
                                  (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                    (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                (Eq.trans
                                  (congrArg (fun x => x + 0)
                                    (Eq.trans
                                      (Eq.trans
                                        (congr
                                          (congrArg HMul.hMul
                                            (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                              (pow_one ↑n)))
                                          (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                            (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                        (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                      (congrArg Neg.neg (mul_one ↑n))))
                                  (add_zero (-↑n))))
                              (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                      (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                        (Mathlib.Tactic.Ring.add_pf_zero_add ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))))
                    (Mathlib.Tactic.Ring.sub_congr
                      (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1)))
                      (Mathlib.Tactic.Ring.atom_pf'
                        (congrArg (HPow.hPow 10)
                          (Eq.trans
                            (Mathlib.Tactic.Ring.sub_congr
                              (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                    (Mathlib.Tactic.Ring.neg_one_mul
                                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                          (Eq.refl (Int.negOfNat 1))))))
                                  Mathlib.Tactic.Ring.neg_zero))
                              (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                              (Mathlib.Tactic.Ring.sub_pf
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1)))))
                                  Mathlib.Tactic.Ring.neg_zero)
                                (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                  (Mathlib.Tactic.Ring.add_pf_add_zero
                                    (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                            (Eq.trans
                              (congr
                                (congrArg HAdd.hAdd
                                  (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                    (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                (Eq.trans
                                  (congrArg (fun x => x + 0)
                                    (Eq.trans
                                      (Eq.trans
                                        (congr
                                          (congrArg HMul.hMul
                                            (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                              (pow_one ↑n)))
                                          (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                            (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                        (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                      (congrArg Neg.neg (mul_one ↑n))))
                                  (add_zero (-↑n))))
                              (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                      (Mathlib.Tactic.Ring.sub_pf
                        (Mathlib.Tactic.Ring.neg_add
                          (Mathlib.Tactic.Ring.neg_mul (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Tactic.Ring.neg_one_mul
                              (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                  (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                                  (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                                  (Eq.refl (Int.negOfNat 1))))))
                          Mathlib.Tactic.Ring.neg_zero)
                        (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                          (Mathlib.Tactic.Ring.add_pf_zero_add
                            ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                    (Mathlib.Tactic.Ring.sub_pf
                      (Mathlib.Tactic.Ring.neg_add
                        (Mathlib.Tactic.Ring.neg_one_mul
                          (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                            (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                              (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                              (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                              (Eq.refl (Int.negOfNat 1)))))
                        (Mathlib.Tactic.Ring.neg_add
                          (Mathlib.Tactic.Ring.neg_mul (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Tactic.Ring.neg_one_mul
                              (Mathlib.Meta.NormNum.IsNat.to_raw_eq
                                (Mathlib.Meta.NormNum.IsInt.to_isNat
                                  (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                    (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                                    (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 1)))))))
                          Mathlib.Tactic.Ring.neg_zero))
                      (Mathlib.Tactic.Ring.add_pf_add_overlap_zero
                        (Mathlib.Meta.NormNum.IsInt.to_isNat
                          (Mathlib.Meta.NormNum.isInt_add (Eq.refl HAdd.hAdd)
                            (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                            (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 0))))
                        (Mathlib.Tactic.Ring.add_pf_add_overlap
                          (Mathlib.Tactic.Ring.add_overlap_pf (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Meta.NormNum.IsNat.to_raw_eq
                              (Mathlib.Meta.NormNum.isNat_add (Eq.refl HAdd.hAdd) (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1)
                                (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1) (Eq.refl 2))))
                          (Mathlib.Tactic.Ring.add_pf_zero_add 0)))))
                  (Eq.trans
                    (congrArg (fun x => x * 2 + 0)
                      (Eq.trans (congrArg (HPow.hPow (10 ^ (-1 - ↑n))) Mathlib.Tactic.RingNF.nat_rawCast_1)
                        (pow_one (10 ^ (-1 - ↑n)))))
                    (add_zero (10 ^ (-1 - ↑n) * 2)))))
              (congrArg abs
                (Eq.trans
                  (Mathlib.Tactic.Ring.mul_congr
                    (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2)))
                    (Mathlib.Tactic.Ring.atom_pf'
                      (congrArg (HPow.hPow 10)
                        (Eq.trans
                          (Mathlib.Tactic.Ring.sub_congr
                            (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                              (Mathlib.Tactic.Ring.neg_add
                                (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1))))))
                                Mathlib.Tactic.Ring.neg_zero))
                            (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                            (Mathlib.Tactic.Ring.sub_pf
                              (Mathlib.Tactic.Ring.neg_add
                                (Mathlib.Tactic.Ring.neg_one_mul
                                  (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                    (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                      (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                      (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                      (Eq.refl (Int.negOfNat 1)))))
                                Mathlib.Tactic.Ring.neg_zero)
                              (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                (Mathlib.Tactic.Ring.add_pf_add_zero
                                  (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                          (Eq.trans
                            (congr
                              (congrArg HAdd.hAdd
                                (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                  (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                              (Eq.trans
                                (congrArg (fun x => x + 0)
                                  (Eq.trans
                                    (Eq.trans
                                      (congr
                                        (congrArg HMul.hMul
                                          (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                            (pow_one ↑n)))
                                        (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                          (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                      (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                    (congrArg Neg.neg (mul_one ↑n))))
                                (add_zero (-↑n))))
                            (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                    (Mathlib.Tactic.Ring.add_mul
                      (Mathlib.Tactic.Ring.mul_add
                        (Mathlib.Tactic.Ring.mul_pf_right (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                          (Mathlib.Tactic.Ring.mul_one (Nat.rawCast 2)))
                        (Mathlib.Tactic.Ring.mul_zero (Nat.rawCast 2))
                        (Mathlib.Tactic.Ring.add_pf_add_zero ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 2 + 0)))
                      (Mathlib.Tactic.Ring.zero_mul ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))
                      (Mathlib.Tactic.Ring.add_pf_add_zero ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 2 + 0))))
                  (Eq.trans
                    (congrArg (fun x => x * 2 + 0)
                      (Eq.trans (congrArg (HPow.hPow (10 ^ (-1 - ↑n))) Mathlib.Tactic.RingNF.nat_rawCast_1)
                        (pow_one (10 ^ (-1 - ↑n)))))
                    (add_zero (10 ^ (-1 - ↑n) * 2))))))
            (eq_self |10 ^ (-1 - ↑n) * 2|))))
      (abs_of_nonneg
        (le_of_lt
          (mul_pos
            (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2))
              (Eq.refl (Nat.ble 1 2)))
            (zpow_pos
              (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 10))
                (Eq.refl (Nat.ble 1 10)))
              (-↑n - 1)))))hab':∀ (N n : ℕ), n ≥ N → |@_fvar.5075 n - @_fvar.5310 n| ≤ 2 * 10 ^ (-↑N - 1) := 
  fun N n hn =>
    Eq.mpr (id (congrArg (fun _a => _a ≤ 2 * 10 ^ (-↑N - 1)) (@_fvar.6550 n)))
      (mul_le_mul_of_nonneg_left
        (zpow_le_zpow_right₀
          (Mathlib.Meta.NormNum.isNat_le_true (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1))
            (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 10)) (Eq.refl true))
          (sub_le_sub_right (neg_le_neg (GCongr.natCast_le_natCast hn)) 1))
        (le_of_lt
          (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2))
            (Eq.refl (Nat.ble 1 2)))))N:ℕ⊢ CharZero ℚ <;>h.e'_3a:ℕ → ℚ := fun n => 1 + 10 ^ (-↑n - 1)b:ℕ → ℚ := fun n => 1 - 10 ^ (-↑n - 1)ε:ℚhε:ε > 0hab:∀ (n : ℕ), |@_fvar.5075 n - @_fvar.5310 n| = 2 * 10 ^ (-↑n - 1) := 
  fun n =>
    Trans.trans
      (Trans.trans rfl
        (of_eq_true
          (Eq.trans
            (congr
              (congrArg (fun x => Eq |x|)
                (Eq.trans
                  (Mathlib.Tactic.Ring.sub_congr
                    (Mathlib.Tactic.Ring.add_congr
                      (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1)))
                      (Mathlib.Tactic.Ring.atom_pf'
                        (congrArg (HPow.hPow 10)
                          (Eq.trans
                            (Mathlib.Tactic.Ring.sub_congr
                              (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                    (Mathlib.Tactic.Ring.neg_one_mul
                                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                          (Eq.refl (Int.negOfNat 1))))))
                                  Mathlib.Tactic.Ring.neg_zero))
                              (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                              (Mathlib.Tactic.Ring.sub_pf
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1)))))
                                  Mathlib.Tactic.Ring.neg_zero)
                                (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                  (Mathlib.Tactic.Ring.add_pf_add_zero
                                    (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                            (Eq.trans
                              (congr
                                (congrArg HAdd.hAdd
                                  (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                    (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                (Eq.trans
                                  (congrArg (fun x => x + 0)
                                    (Eq.trans
                                      (Eq.trans
                                        (congr
                                          (congrArg HMul.hMul
                                            (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                              (pow_one ↑n)))
                                          (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                            (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                        (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                      (congrArg Neg.neg (mul_one ↑n))))
                                  (add_zero (-↑n))))
                              (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                      (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                        (Mathlib.Tactic.Ring.add_pf_zero_add ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))))
                    (Mathlib.Tactic.Ring.sub_congr
                      (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1)))
                      (Mathlib.Tactic.Ring.atom_pf'
                        (congrArg (HPow.hPow 10)
                          (Eq.trans
                            (Mathlib.Tactic.Ring.sub_congr
                              (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                    (Mathlib.Tactic.Ring.neg_one_mul
                                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                          (Eq.refl (Int.negOfNat 1))))))
                                  Mathlib.Tactic.Ring.neg_zero))
                              (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                              (Mathlib.Tactic.Ring.sub_pf
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1)))))
                                  Mathlib.Tactic.Ring.neg_zero)
                                (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                  (Mathlib.Tactic.Ring.add_pf_add_zero
                                    (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                            (Eq.trans
                              (congr
                                (congrArg HAdd.hAdd
                                  (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                    (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                (Eq.trans
                                  (congrArg (fun x => x + 0)
                                    (Eq.trans
                                      (Eq.trans
                                        (congr
                                          (congrArg HMul.hMul
                                            (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                              (pow_one ↑n)))
                                          (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                            (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                        (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                      (congrArg Neg.neg (mul_one ↑n))))
                                  (add_zero (-↑n))))
                              (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                      (Mathlib.Tactic.Ring.sub_pf
                        (Mathlib.Tactic.Ring.neg_add
                          (Mathlib.Tactic.Ring.neg_mul (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Tactic.Ring.neg_one_mul
                              (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                  (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                                  (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                                  (Eq.refl (Int.negOfNat 1))))))
                          Mathlib.Tactic.Ring.neg_zero)
                        (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                          (Mathlib.Tactic.Ring.add_pf_zero_add
                            ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                    (Mathlib.Tactic.Ring.sub_pf
                      (Mathlib.Tactic.Ring.neg_add
                        (Mathlib.Tactic.Ring.neg_one_mul
                          (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                            (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                              (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                              (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                              (Eq.refl (Int.negOfNat 1)))))
                        (Mathlib.Tactic.Ring.neg_add
                          (Mathlib.Tactic.Ring.neg_mul (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Tactic.Ring.neg_one_mul
                              (Mathlib.Meta.NormNum.IsNat.to_raw_eq
                                (Mathlib.Meta.NormNum.IsInt.to_isNat
                                  (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                    (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                                    (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 1)))))))
                          Mathlib.Tactic.Ring.neg_zero))
                      (Mathlib.Tactic.Ring.add_pf_add_overlap_zero
                        (Mathlib.Meta.NormNum.IsInt.to_isNat
                          (Mathlib.Meta.NormNum.isInt_add (Eq.refl HAdd.hAdd)
                            (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                            (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 0))))
                        (Mathlib.Tactic.Ring.add_pf_add_overlap
                          (Mathlib.Tactic.Ring.add_overlap_pf (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Meta.NormNum.IsNat.to_raw_eq
                              (Mathlib.Meta.NormNum.isNat_add (Eq.refl HAdd.hAdd) (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1)
                                (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1) (Eq.refl 2))))
                          (Mathlib.Tactic.Ring.add_pf_zero_add 0)))))
                  (Eq.trans
                    (congrArg (fun x => x * 2 + 0)
                      (Eq.trans (congrArg (HPow.hPow (10 ^ (-1 - ↑n))) Mathlib.Tactic.RingNF.nat_rawCast_1)
                        (pow_one (10 ^ (-1 - ↑n)))))
                    (add_zero (10 ^ (-1 - ↑n) * 2)))))
              (congrArg abs
                (Eq.trans
                  (Mathlib.Tactic.Ring.mul_congr
                    (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2)))
                    (Mathlib.Tactic.Ring.atom_pf'
                      (congrArg (HPow.hPow 10)
                        (Eq.trans
                          (Mathlib.Tactic.Ring.sub_congr
                            (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                              (Mathlib.Tactic.Ring.neg_add
                                (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1))))))
                                Mathlib.Tactic.Ring.neg_zero))
                            (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                            (Mathlib.Tactic.Ring.sub_pf
                              (Mathlib.Tactic.Ring.neg_add
                                (Mathlib.Tactic.Ring.neg_one_mul
                                  (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                    (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                      (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                      (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                      (Eq.refl (Int.negOfNat 1)))))
                                Mathlib.Tactic.Ring.neg_zero)
                              (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                (Mathlib.Tactic.Ring.add_pf_add_zero
                                  (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                          (Eq.trans
                            (congr
                              (congrArg HAdd.hAdd
                                (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                  (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                              (Eq.trans
                                (congrArg (fun x => x + 0)
                                  (Eq.trans
                                    (Eq.trans
                                      (congr
                                        (congrArg HMul.hMul
                                          (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                            (pow_one ↑n)))
                                        (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                          (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                      (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                    (congrArg Neg.neg (mul_one ↑n))))
                                (add_zero (-↑n))))
                            (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                    (Mathlib.Tactic.Ring.add_mul
                      (Mathlib.Tactic.Ring.mul_add
                        (Mathlib.Tactic.Ring.mul_pf_right (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                          (Mathlib.Tactic.Ring.mul_one (Nat.rawCast 2)))
                        (Mathlib.Tactic.Ring.mul_zero (Nat.rawCast 2))
                        (Mathlib.Tactic.Ring.add_pf_add_zero ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 2 + 0)))
                      (Mathlib.Tactic.Ring.zero_mul ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))
                      (Mathlib.Tactic.Ring.add_pf_add_zero ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 2 + 0))))
                  (Eq.trans
                    (congrArg (fun x => x * 2 + 0)
                      (Eq.trans (congrArg (HPow.hPow (10 ^ (-1 - ↑n))) Mathlib.Tactic.RingNF.nat_rawCast_1)
                        (pow_one (10 ^ (-1 - ↑n)))))
                    (add_zero (10 ^ (-1 - ↑n) * 2))))))
            (eq_self |10 ^ (-1 - ↑n) * 2|))))
      (abs_of_nonneg
        (le_of_lt
          (mul_pos
            (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2))
              (Eq.refl (Nat.ble 1 2)))
            (zpow_pos
              (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 10))
                (Eq.refl (Nat.ble 1 10)))
              (-↑n - 1)))))hab':∀ (N n : ℕ), n ≥ N → |@_fvar.5075 n - @_fvar.5310 n| ≤ 2 * 10 ^ (-↑N - 1) := 
  fun N n hn =>
    Eq.mpr (id (congrArg (fun _a => _a ≤ 2 * 10 ^ (-↑N - 1)) (@_fvar.6550 n)))
      (mul_le_mul_of_nonneg_left
        (zpow_le_zpow_right₀
          (Mathlib.Meta.NormNum.isNat_le_true (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1))
            (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 10)) (Eq.refl true))
          (sub_le_sub_right (neg_le_neg (GCongr.natCast_le_natCast hn)) 1))
        (le_of_lt
          (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2))
            (Eq.refl (Nat.ble 1 2)))))N:ℕ⊢ ↑N + 1 = ↑(N + 1)h.e'_4a:ℕ → ℚ := fun n => 1 + 10 ^ (-↑n - 1)b:ℕ → ℚ := fun n => 1 - 10 ^ (-↑n - 1)ε:ℚhε:ε > 0hab:∀ (n : ℕ), |@_fvar.5075 n - @_fvar.5310 n| = 2 * 10 ^ (-↑n - 1) := 
  fun n =>
    Trans.trans
      (Trans.trans rfl
        (of_eq_true
          (Eq.trans
            (congr
              (congrArg (fun x => Eq |x|)
                (Eq.trans
                  (Mathlib.Tactic.Ring.sub_congr
                    (Mathlib.Tactic.Ring.add_congr
                      (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1)))
                      (Mathlib.Tactic.Ring.atom_pf'
                        (congrArg (HPow.hPow 10)
                          (Eq.trans
                            (Mathlib.Tactic.Ring.sub_congr
                              (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                    (Mathlib.Tactic.Ring.neg_one_mul
                                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                          (Eq.refl (Int.negOfNat 1))))))
                                  Mathlib.Tactic.Ring.neg_zero))
                              (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                              (Mathlib.Tactic.Ring.sub_pf
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1)))))
                                  Mathlib.Tactic.Ring.neg_zero)
                                (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                  (Mathlib.Tactic.Ring.add_pf_add_zero
                                    (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                            (Eq.trans
                              (congr
                                (congrArg HAdd.hAdd
                                  (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                    (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                (Eq.trans
                                  (congrArg (fun x => x + 0)
                                    (Eq.trans
                                      (Eq.trans
                                        (congr
                                          (congrArg HMul.hMul
                                            (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                              (pow_one ↑n)))
                                          (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                            (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                        (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                      (congrArg Neg.neg (mul_one ↑n))))
                                  (add_zero (-↑n))))
                              (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                      (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                        (Mathlib.Tactic.Ring.add_pf_zero_add ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))))
                    (Mathlib.Tactic.Ring.sub_congr
                      (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1)))
                      (Mathlib.Tactic.Ring.atom_pf'
                        (congrArg (HPow.hPow 10)
                          (Eq.trans
                            (Mathlib.Tactic.Ring.sub_congr
                              (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                    (Mathlib.Tactic.Ring.neg_one_mul
                                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                          (Eq.refl (Int.negOfNat 1))))))
                                  Mathlib.Tactic.Ring.neg_zero))
                              (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                              (Mathlib.Tactic.Ring.sub_pf
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1)))))
                                  Mathlib.Tactic.Ring.neg_zero)
                                (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                  (Mathlib.Tactic.Ring.add_pf_add_zero
                                    (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                            (Eq.trans
                              (congr
                                (congrArg HAdd.hAdd
                                  (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                    (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                (Eq.trans
                                  (congrArg (fun x => x + 0)
                                    (Eq.trans
                                      (Eq.trans
                                        (congr
                                          (congrArg HMul.hMul
                                            (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                              (pow_one ↑n)))
                                          (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                            (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                        (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                      (congrArg Neg.neg (mul_one ↑n))))
                                  (add_zero (-↑n))))
                              (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                      (Mathlib.Tactic.Ring.sub_pf
                        (Mathlib.Tactic.Ring.neg_add
                          (Mathlib.Tactic.Ring.neg_mul (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Tactic.Ring.neg_one_mul
                              (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                  (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                                  (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                                  (Eq.refl (Int.negOfNat 1))))))
                          Mathlib.Tactic.Ring.neg_zero)
                        (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                          (Mathlib.Tactic.Ring.add_pf_zero_add
                            ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                    (Mathlib.Tactic.Ring.sub_pf
                      (Mathlib.Tactic.Ring.neg_add
                        (Mathlib.Tactic.Ring.neg_one_mul
                          (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                            (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                              (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                              (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                              (Eq.refl (Int.negOfNat 1)))))
                        (Mathlib.Tactic.Ring.neg_add
                          (Mathlib.Tactic.Ring.neg_mul (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Tactic.Ring.neg_one_mul
                              (Mathlib.Meta.NormNum.IsNat.to_raw_eq
                                (Mathlib.Meta.NormNum.IsInt.to_isNat
                                  (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                    (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                                    (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 1)))))))
                          Mathlib.Tactic.Ring.neg_zero))
                      (Mathlib.Tactic.Ring.add_pf_add_overlap_zero
                        (Mathlib.Meta.NormNum.IsInt.to_isNat
                          (Mathlib.Meta.NormNum.isInt_add (Eq.refl HAdd.hAdd)
                            (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                            (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 0))))
                        (Mathlib.Tactic.Ring.add_pf_add_overlap
                          (Mathlib.Tactic.Ring.add_overlap_pf (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Meta.NormNum.IsNat.to_raw_eq
                              (Mathlib.Meta.NormNum.isNat_add (Eq.refl HAdd.hAdd) (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1)
                                (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1) (Eq.refl 2))))
                          (Mathlib.Tactic.Ring.add_pf_zero_add 0)))))
                  (Eq.trans
                    (congrArg (fun x => x * 2 + 0)
                      (Eq.trans (congrArg (HPow.hPow (10 ^ (-1 - ↑n))) Mathlib.Tactic.RingNF.nat_rawCast_1)
                        (pow_one (10 ^ (-1 - ↑n)))))
                    (add_zero (10 ^ (-1 - ↑n) * 2)))))
              (congrArg abs
                (Eq.trans
                  (Mathlib.Tactic.Ring.mul_congr
                    (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2)))
                    (Mathlib.Tactic.Ring.atom_pf'
                      (congrArg (HPow.hPow 10)
                        (Eq.trans
                          (Mathlib.Tactic.Ring.sub_congr
                            (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                              (Mathlib.Tactic.Ring.neg_add
                                (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1))))))
                                Mathlib.Tactic.Ring.neg_zero))
                            (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                            (Mathlib.Tactic.Ring.sub_pf
                              (Mathlib.Tactic.Ring.neg_add
                                (Mathlib.Tactic.Ring.neg_one_mul
                                  (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                    (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                      (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                      (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                      (Eq.refl (Int.negOfNat 1)))))
                                Mathlib.Tactic.Ring.neg_zero)
                              (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                (Mathlib.Tactic.Ring.add_pf_add_zero
                                  (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                          (Eq.trans
                            (congr
                              (congrArg HAdd.hAdd
                                (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                  (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                              (Eq.trans
                                (congrArg (fun x => x + 0)
                                  (Eq.trans
                                    (Eq.trans
                                      (congr
                                        (congrArg HMul.hMul
                                          (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                            (pow_one ↑n)))
                                        (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                          (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                      (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                    (congrArg Neg.neg (mul_one ↑n))))
                                (add_zero (-↑n))))
                            (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                    (Mathlib.Tactic.Ring.add_mul
                      (Mathlib.Tactic.Ring.mul_add
                        (Mathlib.Tactic.Ring.mul_pf_right (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                          (Mathlib.Tactic.Ring.mul_one (Nat.rawCast 2)))
                        (Mathlib.Tactic.Ring.mul_zero (Nat.rawCast 2))
                        (Mathlib.Tactic.Ring.add_pf_add_zero ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 2 + 0)))
                      (Mathlib.Tactic.Ring.zero_mul ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))
                      (Mathlib.Tactic.Ring.add_pf_add_zero ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 2 + 0))))
                  (Eq.trans
                    (congrArg (fun x => x * 2 + 0)
                      (Eq.trans (congrArg (HPow.hPow (10 ^ (-1 - ↑n))) Mathlib.Tactic.RingNF.nat_rawCast_1)
                        (pow_one (10 ^ (-1 - ↑n)))))
                    (add_zero (10 ^ (-1 - ↑n) * 2))))))
            (eq_self |10 ^ (-1 - ↑n) * 2|))))
      (abs_of_nonneg
        (le_of_lt
          (mul_pos
            (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2))
              (Eq.refl (Nat.ble 1 2)))
            (zpow_pos
              (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 10))
                (Eq.refl (Nat.ble 1 10)))
              (-↑n - 1)))))hab':∀ (N n : ℕ), n ≥ N → |@_fvar.5075 n - @_fvar.5310 n| ≤ 2 * 10 ^ (-↑N - 1) := 
  fun N n hn =>
    Eq.mpr (id (congrArg (fun _a => _a ≤ 2 * 10 ^ (-↑N - 1)) (@_fvar.6550 n)))
      (mul_le_mul_of_nonneg_left
        (zpow_le_zpow_right₀
          (Mathlib.Meta.NormNum.isNat_le_true (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1))
            (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 10)) (Eq.refl true))
          (sub_le_sub_right (neg_le_neg (GCongr.natCast_le_natCast hn)) 1))
        (le_of_lt
          (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2))
            (Eq.refl (Nat.ble 1 2)))))N:ℕ⊢ 2 ^ (N + 1) = ↑(2 ^ (N + 1))convert_2a:ℕ → ℚ := fun n => 1 + 10 ^ (-↑n - 1)b:ℕ → ℚ := fun n => 1 - 10 ^ (-↑n - 1)ε:ℚhε:ε > 0hab:∀ (n : ℕ), |@_fvar.5075 n - @_fvar.5310 n| = 2 * 10 ^ (-↑n - 1) := 
  fun n =>
    Trans.trans
      (Trans.trans rfl
        (of_eq_true
          (Eq.trans
            (congr
              (congrArg (fun x => Eq |x|)
                (Eq.trans
                  (Mathlib.Tactic.Ring.sub_congr
                    (Mathlib.Tactic.Ring.add_congr
                      (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1)))
                      (Mathlib.Tactic.Ring.atom_pf'
                        (congrArg (HPow.hPow 10)
                          (Eq.trans
                            (Mathlib.Tactic.Ring.sub_congr
                              (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                    (Mathlib.Tactic.Ring.neg_one_mul
                                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                          (Eq.refl (Int.negOfNat 1))))))
                                  Mathlib.Tactic.Ring.neg_zero))
                              (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                              (Mathlib.Tactic.Ring.sub_pf
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1)))))
                                  Mathlib.Tactic.Ring.neg_zero)
                                (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                  (Mathlib.Tactic.Ring.add_pf_add_zero
                                    (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                            (Eq.trans
                              (congr
                                (congrArg HAdd.hAdd
                                  (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                    (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                (Eq.trans
                                  (congrArg (fun x => x + 0)
                                    (Eq.trans
                                      (Eq.trans
                                        (congr
                                          (congrArg HMul.hMul
                                            (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                              (pow_one ↑n)))
                                          (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                            (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                        (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                      (congrArg Neg.neg (mul_one ↑n))))
                                  (add_zero (-↑n))))
                              (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                      (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                        (Mathlib.Tactic.Ring.add_pf_zero_add ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))))
                    (Mathlib.Tactic.Ring.sub_congr
                      (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1)))
                      (Mathlib.Tactic.Ring.atom_pf'
                        (congrArg (HPow.hPow 10)
                          (Eq.trans
                            (Mathlib.Tactic.Ring.sub_congr
                              (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                    (Mathlib.Tactic.Ring.neg_one_mul
                                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                          (Eq.refl (Int.negOfNat 1))))))
                                  Mathlib.Tactic.Ring.neg_zero))
                              (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                              (Mathlib.Tactic.Ring.sub_pf
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1)))))
                                  Mathlib.Tactic.Ring.neg_zero)
                                (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                  (Mathlib.Tactic.Ring.add_pf_add_zero
                                    (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                            (Eq.trans
                              (congr
                                (congrArg HAdd.hAdd
                                  (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                    (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                (Eq.trans
                                  (congrArg (fun x => x + 0)
                                    (Eq.trans
                                      (Eq.trans
                                        (congr
                                          (congrArg HMul.hMul
                                            (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                              (pow_one ↑n)))
                                          (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                            (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                        (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                      (congrArg Neg.neg (mul_one ↑n))))
                                  (add_zero (-↑n))))
                              (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                      (Mathlib.Tactic.Ring.sub_pf
                        (Mathlib.Tactic.Ring.neg_add
                          (Mathlib.Tactic.Ring.neg_mul (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Tactic.Ring.neg_one_mul
                              (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                  (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                                  (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                                  (Eq.refl (Int.negOfNat 1))))))
                          Mathlib.Tactic.Ring.neg_zero)
                        (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                          (Mathlib.Tactic.Ring.add_pf_zero_add
                            ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                    (Mathlib.Tactic.Ring.sub_pf
                      (Mathlib.Tactic.Ring.neg_add
                        (Mathlib.Tactic.Ring.neg_one_mul
                          (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                            (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                              (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                              (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                              (Eq.refl (Int.negOfNat 1)))))
                        (Mathlib.Tactic.Ring.neg_add
                          (Mathlib.Tactic.Ring.neg_mul (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Tactic.Ring.neg_one_mul
                              (Mathlib.Meta.NormNum.IsNat.to_raw_eq
                                (Mathlib.Meta.NormNum.IsInt.to_isNat
                                  (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                    (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                                    (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 1)))))))
                          Mathlib.Tactic.Ring.neg_zero))
                      (Mathlib.Tactic.Ring.add_pf_add_overlap_zero
                        (Mathlib.Meta.NormNum.IsInt.to_isNat
                          (Mathlib.Meta.NormNum.isInt_add (Eq.refl HAdd.hAdd)
                            (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                            (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 0))))
                        (Mathlib.Tactic.Ring.add_pf_add_overlap
                          (Mathlib.Tactic.Ring.add_overlap_pf (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Meta.NormNum.IsNat.to_raw_eq
                              (Mathlib.Meta.NormNum.isNat_add (Eq.refl HAdd.hAdd) (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1)
                                (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1) (Eq.refl 2))))
                          (Mathlib.Tactic.Ring.add_pf_zero_add 0)))))
                  (Eq.trans
                    (congrArg (fun x => x * 2 + 0)
                      (Eq.trans (congrArg (HPow.hPow (10 ^ (-1 - ↑n))) Mathlib.Tactic.RingNF.nat_rawCast_1)
                        (pow_one (10 ^ (-1 - ↑n)))))
                    (add_zero (10 ^ (-1 - ↑n) * 2)))))
              (congrArg abs
                (Eq.trans
                  (Mathlib.Tactic.Ring.mul_congr
                    (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2)))
                    (Mathlib.Tactic.Ring.atom_pf'
                      (congrArg (HPow.hPow 10)
                        (Eq.trans
                          (Mathlib.Tactic.Ring.sub_congr
                            (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                              (Mathlib.Tactic.Ring.neg_add
                                (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1))))))
                                Mathlib.Tactic.Ring.neg_zero))
                            (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                            (Mathlib.Tactic.Ring.sub_pf
                              (Mathlib.Tactic.Ring.neg_add
                                (Mathlib.Tactic.Ring.neg_one_mul
                                  (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                    (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                      (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                      (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                      (Eq.refl (Int.negOfNat 1)))))
                                Mathlib.Tactic.Ring.neg_zero)
                              (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                (Mathlib.Tactic.Ring.add_pf_add_zero
                                  (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                          (Eq.trans
                            (congr
                              (congrArg HAdd.hAdd
                                (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                  (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                              (Eq.trans
                                (congrArg (fun x => x + 0)
                                  (Eq.trans
                                    (Eq.trans
                                      (congr
                                        (congrArg HMul.hMul
                                          (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                            (pow_one ↑n)))
                                        (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                          (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                      (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                    (congrArg Neg.neg (mul_one ↑n))))
                                (add_zero (-↑n))))
                            (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                    (Mathlib.Tactic.Ring.add_mul
                      (Mathlib.Tactic.Ring.mul_add
                        (Mathlib.Tactic.Ring.mul_pf_right (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                          (Mathlib.Tactic.Ring.mul_one (Nat.rawCast 2)))
                        (Mathlib.Tactic.Ring.mul_zero (Nat.rawCast 2))
                        (Mathlib.Tactic.Ring.add_pf_add_zero ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 2 + 0)))
                      (Mathlib.Tactic.Ring.zero_mul ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))
                      (Mathlib.Tactic.Ring.add_pf_add_zero ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 2 + 0))))
                  (Eq.trans
                    (congrArg (fun x => x * 2 + 0)
                      (Eq.trans (congrArg (HPow.hPow (10 ^ (-1 - ↑n))) Mathlib.Tactic.RingNF.nat_rawCast_1)
                        (pow_one (10 ^ (-1 - ↑n)))))
                    (add_zero (10 ^ (-1 - ↑n) * 2))))))
            (eq_self |10 ^ (-1 - ↑n) * 2|))))
      (abs_of_nonneg
        (le_of_lt
          (mul_pos
            (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2))
              (Eq.refl (Nat.ble 1 2)))
            (zpow_pos
              (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 10))
                (Eq.refl (Nat.ble 1 10)))
              (-↑n - 1)))))hab':∀ (N n : ℕ), n ≥ N → |@_fvar.5075 n - @_fvar.5310 n| ≤ 2 * 10 ^ (-↑N - 1) := 
  fun N n hn =>
    Eq.mpr (id (congrArg (fun _a => _a ≤ 2 * 10 ^ (-↑N - 1)) (@_fvar.6550 n)))
      (mul_le_mul_of_nonneg_left
        (zpow_le_zpow_right₀
          (Mathlib.Meta.NormNum.isNat_le_true (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1))
            (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 10)) (Eq.refl true))
          (sub_le_sub_right (neg_le_neg (GCongr.natCast_le_natCast hn)) 1))
        (le_of_lt
          (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2))
            (Eq.refl (Nat.ble 1 2)))))N:ℕ⊢ AddMonoidWithOne ℚconvert_4a:ℕ → ℚ := fun n => 1 + 10 ^ (-↑n - 1)b:ℕ → ℚ := fun n => 1 - 10 ^ (-↑n - 1)ε:ℚhε:ε > 0hab:∀ (n : ℕ), |@_fvar.5075 n - @_fvar.5310 n| = 2 * 10 ^ (-↑n - 1) := 
  fun n =>
    Trans.trans
      (Trans.trans rfl
        (of_eq_true
          (Eq.trans
            (congr
              (congrArg (fun x => Eq |x|)
                (Eq.trans
                  (Mathlib.Tactic.Ring.sub_congr
                    (Mathlib.Tactic.Ring.add_congr
                      (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1)))
                      (Mathlib.Tactic.Ring.atom_pf'
                        (congrArg (HPow.hPow 10)
                          (Eq.trans
                            (Mathlib.Tactic.Ring.sub_congr
                              (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                    (Mathlib.Tactic.Ring.neg_one_mul
                                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                          (Eq.refl (Int.negOfNat 1))))))
                                  Mathlib.Tactic.Ring.neg_zero))
                              (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                              (Mathlib.Tactic.Ring.sub_pf
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1)))))
                                  Mathlib.Tactic.Ring.neg_zero)
                                (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                  (Mathlib.Tactic.Ring.add_pf_add_zero
                                    (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                            (Eq.trans
                              (congr
                                (congrArg HAdd.hAdd
                                  (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                    (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                (Eq.trans
                                  (congrArg (fun x => x + 0)
                                    (Eq.trans
                                      (Eq.trans
                                        (congr
                                          (congrArg HMul.hMul
                                            (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                              (pow_one ↑n)))
                                          (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                            (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                        (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                      (congrArg Neg.neg (mul_one ↑n))))
                                  (add_zero (-↑n))))
                              (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                      (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                        (Mathlib.Tactic.Ring.add_pf_zero_add ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))))
                    (Mathlib.Tactic.Ring.sub_congr
                      (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1)))
                      (Mathlib.Tactic.Ring.atom_pf'
                        (congrArg (HPow.hPow 10)
                          (Eq.trans
                            (Mathlib.Tactic.Ring.sub_congr
                              (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                    (Mathlib.Tactic.Ring.neg_one_mul
                                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                          (Eq.refl (Int.negOfNat 1))))))
                                  Mathlib.Tactic.Ring.neg_zero))
                              (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                              (Mathlib.Tactic.Ring.sub_pf
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1)))))
                                  Mathlib.Tactic.Ring.neg_zero)
                                (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                  (Mathlib.Tactic.Ring.add_pf_add_zero
                                    (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                            (Eq.trans
                              (congr
                                (congrArg HAdd.hAdd
                                  (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                    (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                (Eq.trans
                                  (congrArg (fun x => x + 0)
                                    (Eq.trans
                                      (Eq.trans
                                        (congr
                                          (congrArg HMul.hMul
                                            (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                              (pow_one ↑n)))
                                          (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                            (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                        (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                      (congrArg Neg.neg (mul_one ↑n))))
                                  (add_zero (-↑n))))
                              (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                      (Mathlib.Tactic.Ring.sub_pf
                        (Mathlib.Tactic.Ring.neg_add
                          (Mathlib.Tactic.Ring.neg_mul (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Tactic.Ring.neg_one_mul
                              (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                  (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                                  (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                                  (Eq.refl (Int.negOfNat 1))))))
                          Mathlib.Tactic.Ring.neg_zero)
                        (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                          (Mathlib.Tactic.Ring.add_pf_zero_add
                            ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                    (Mathlib.Tactic.Ring.sub_pf
                      (Mathlib.Tactic.Ring.neg_add
                        (Mathlib.Tactic.Ring.neg_one_mul
                          (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                            (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                              (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                              (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                              (Eq.refl (Int.negOfNat 1)))))
                        (Mathlib.Tactic.Ring.neg_add
                          (Mathlib.Tactic.Ring.neg_mul (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Tactic.Ring.neg_one_mul
                              (Mathlib.Meta.NormNum.IsNat.to_raw_eq
                                (Mathlib.Meta.NormNum.IsInt.to_isNat
                                  (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                    (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                                    (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 1)))))))
                          Mathlib.Tactic.Ring.neg_zero))
                      (Mathlib.Tactic.Ring.add_pf_add_overlap_zero
                        (Mathlib.Meta.NormNum.IsInt.to_isNat
                          (Mathlib.Meta.NormNum.isInt_add (Eq.refl HAdd.hAdd)
                            (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                            (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 0))))
                        (Mathlib.Tactic.Ring.add_pf_add_overlap
                          (Mathlib.Tactic.Ring.add_overlap_pf (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Meta.NormNum.IsNat.to_raw_eq
                              (Mathlib.Meta.NormNum.isNat_add (Eq.refl HAdd.hAdd) (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1)
                                (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1) (Eq.refl 2))))
                          (Mathlib.Tactic.Ring.add_pf_zero_add 0)))))
                  (Eq.trans
                    (congrArg (fun x => x * 2 + 0)
                      (Eq.trans (congrArg (HPow.hPow (10 ^ (-1 - ↑n))) Mathlib.Tactic.RingNF.nat_rawCast_1)
                        (pow_one (10 ^ (-1 - ↑n)))))
                    (add_zero (10 ^ (-1 - ↑n) * 2)))))
              (congrArg abs
                (Eq.trans
                  (Mathlib.Tactic.Ring.mul_congr
                    (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2)))
                    (Mathlib.Tactic.Ring.atom_pf'
                      (congrArg (HPow.hPow 10)
                        (Eq.trans
                          (Mathlib.Tactic.Ring.sub_congr
                            (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                              (Mathlib.Tactic.Ring.neg_add
                                (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1))))))
                                Mathlib.Tactic.Ring.neg_zero))
                            (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                            (Mathlib.Tactic.Ring.sub_pf
                              (Mathlib.Tactic.Ring.neg_add
                                (Mathlib.Tactic.Ring.neg_one_mul
                                  (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                    (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                      (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                      (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                      (Eq.refl (Int.negOfNat 1)))))
                                Mathlib.Tactic.Ring.neg_zero)
                              (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                (Mathlib.Tactic.Ring.add_pf_add_zero
                                  (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                          (Eq.trans
                            (congr
                              (congrArg HAdd.hAdd
                                (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                  (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                              (Eq.trans
                                (congrArg (fun x => x + 0)
                                  (Eq.trans
                                    (Eq.trans
                                      (congr
                                        (congrArg HMul.hMul
                                          (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                            (pow_one ↑n)))
                                        (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                          (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                      (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                    (congrArg Neg.neg (mul_one ↑n))))
                                (add_zero (-↑n))))
                            (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                    (Mathlib.Tactic.Ring.add_mul
                      (Mathlib.Tactic.Ring.mul_add
                        (Mathlib.Tactic.Ring.mul_pf_right (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                          (Mathlib.Tactic.Ring.mul_one (Nat.rawCast 2)))
                        (Mathlib.Tactic.Ring.mul_zero (Nat.rawCast 2))
                        (Mathlib.Tactic.Ring.add_pf_add_zero ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 2 + 0)))
                      (Mathlib.Tactic.Ring.zero_mul ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))
                      (Mathlib.Tactic.Ring.add_pf_add_zero ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 2 + 0))))
                  (Eq.trans
                    (congrArg (fun x => x * 2 + 0)
                      (Eq.trans (congrArg (HPow.hPow (10 ^ (-1 - ↑n))) Mathlib.Tactic.RingNF.nat_rawCast_1)
                        (pow_one (10 ^ (-1 - ↑n)))))
                    (add_zero (10 ^ (-1 - ↑n) * 2))))))
            (eq_self |10 ^ (-1 - ↑n) * 2|))))
      (abs_of_nonneg
        (le_of_lt
          (mul_pos
            (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2))
              (Eq.refl (Nat.ble 1 2)))
            (zpow_pos
              (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 10))
                (Eq.refl (Nat.ble 1 10)))
              (-↑n - 1)))))hab':∀ (N n : ℕ), n ≥ N → |@_fvar.5075 n - @_fvar.5310 n| ≤ 2 * 10 ^ (-↑N - 1) := 
  fun N n hn =>
    Eq.mpr (id (congrArg (fun _a => _a ≤ 2 * 10 ^ (-↑N - 1)) (@_fvar.6550 n)))
      (mul_le_mul_of_nonneg_left
        (zpow_le_zpow_right₀
          (Mathlib.Meta.NormNum.isNat_le_true (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1))
            (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 10)) (Eq.refl true))
          (sub_le_sub_right (neg_le_neg (GCongr.natCast_le_natCast hn)) 1))
        (le_of_lt
          (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2))
            (Eq.refl (Nat.ble 1 2)))))N:ℕ⊢ AddLeftMono ℚconvert_5a:ℕ → ℚ := fun n => 1 + 10 ^ (-↑n - 1)b:ℕ → ℚ := fun n => 1 - 10 ^ (-↑n - 1)ε:ℚhε:ε > 0hab:∀ (n : ℕ), |@_fvar.5075 n - @_fvar.5310 n| = 2 * 10 ^ (-↑n - 1) := 
  fun n =>
    Trans.trans
      (Trans.trans rfl
        (of_eq_true
          (Eq.trans
            (congr
              (congrArg (fun x => Eq |x|)
                (Eq.trans
                  (Mathlib.Tactic.Ring.sub_congr
                    (Mathlib.Tactic.Ring.add_congr
                      (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1)))
                      (Mathlib.Tactic.Ring.atom_pf'
                        (congrArg (HPow.hPow 10)
                          (Eq.trans
                            (Mathlib.Tactic.Ring.sub_congr
                              (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                    (Mathlib.Tactic.Ring.neg_one_mul
                                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                          (Eq.refl (Int.negOfNat 1))))))
                                  Mathlib.Tactic.Ring.neg_zero))
                              (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                              (Mathlib.Tactic.Ring.sub_pf
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1)))))
                                  Mathlib.Tactic.Ring.neg_zero)
                                (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                  (Mathlib.Tactic.Ring.add_pf_add_zero
                                    (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                            (Eq.trans
                              (congr
                                (congrArg HAdd.hAdd
                                  (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                    (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                (Eq.trans
                                  (congrArg (fun x => x + 0)
                                    (Eq.trans
                                      (Eq.trans
                                        (congr
                                          (congrArg HMul.hMul
                                            (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                              (pow_one ↑n)))
                                          (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                            (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                        (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                      (congrArg Neg.neg (mul_one ↑n))))
                                  (add_zero (-↑n))))
                              (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                      (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                        (Mathlib.Tactic.Ring.add_pf_zero_add ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))))
                    (Mathlib.Tactic.Ring.sub_congr
                      (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1)))
                      (Mathlib.Tactic.Ring.atom_pf'
                        (congrArg (HPow.hPow 10)
                          (Eq.trans
                            (Mathlib.Tactic.Ring.sub_congr
                              (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                    (Mathlib.Tactic.Ring.neg_one_mul
                                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                          (Eq.refl (Int.negOfNat 1))))))
                                  Mathlib.Tactic.Ring.neg_zero))
                              (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                              (Mathlib.Tactic.Ring.sub_pf
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1)))))
                                  Mathlib.Tactic.Ring.neg_zero)
                                (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                  (Mathlib.Tactic.Ring.add_pf_add_zero
                                    (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                            (Eq.trans
                              (congr
                                (congrArg HAdd.hAdd
                                  (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                    (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                (Eq.trans
                                  (congrArg (fun x => x + 0)
                                    (Eq.trans
                                      (Eq.trans
                                        (congr
                                          (congrArg HMul.hMul
                                            (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                              (pow_one ↑n)))
                                          (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                            (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                        (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                      (congrArg Neg.neg (mul_one ↑n))))
                                  (add_zero (-↑n))))
                              (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                      (Mathlib.Tactic.Ring.sub_pf
                        (Mathlib.Tactic.Ring.neg_add
                          (Mathlib.Tactic.Ring.neg_mul (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Tactic.Ring.neg_one_mul
                              (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                  (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                                  (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                                  (Eq.refl (Int.negOfNat 1))))))
                          Mathlib.Tactic.Ring.neg_zero)
                        (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                          (Mathlib.Tactic.Ring.add_pf_zero_add
                            ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                    (Mathlib.Tactic.Ring.sub_pf
                      (Mathlib.Tactic.Ring.neg_add
                        (Mathlib.Tactic.Ring.neg_one_mul
                          (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                            (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                              (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                              (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                              (Eq.refl (Int.negOfNat 1)))))
                        (Mathlib.Tactic.Ring.neg_add
                          (Mathlib.Tactic.Ring.neg_mul (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Tactic.Ring.neg_one_mul
                              (Mathlib.Meta.NormNum.IsNat.to_raw_eq
                                (Mathlib.Meta.NormNum.IsInt.to_isNat
                                  (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                    (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                                    (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 1)))))))
                          Mathlib.Tactic.Ring.neg_zero))
                      (Mathlib.Tactic.Ring.add_pf_add_overlap_zero
                        (Mathlib.Meta.NormNum.IsInt.to_isNat
                          (Mathlib.Meta.NormNum.isInt_add (Eq.refl HAdd.hAdd)
                            (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                            (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 0))))
                        (Mathlib.Tactic.Ring.add_pf_add_overlap
                          (Mathlib.Tactic.Ring.add_overlap_pf (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Meta.NormNum.IsNat.to_raw_eq
                              (Mathlib.Meta.NormNum.isNat_add (Eq.refl HAdd.hAdd) (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1)
                                (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1) (Eq.refl 2))))
                          (Mathlib.Tactic.Ring.add_pf_zero_add 0)))))
                  (Eq.trans
                    (congrArg (fun x => x * 2 + 0)
                      (Eq.trans (congrArg (HPow.hPow (10 ^ (-1 - ↑n))) Mathlib.Tactic.RingNF.nat_rawCast_1)
                        (pow_one (10 ^ (-1 - ↑n)))))
                    (add_zero (10 ^ (-1 - ↑n) * 2)))))
              (congrArg abs
                (Eq.trans
                  (Mathlib.Tactic.Ring.mul_congr
                    (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2)))
                    (Mathlib.Tactic.Ring.atom_pf'
                      (congrArg (HPow.hPow 10)
                        (Eq.trans
                          (Mathlib.Tactic.Ring.sub_congr
                            (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                              (Mathlib.Tactic.Ring.neg_add
                                (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1))))))
                                Mathlib.Tactic.Ring.neg_zero))
                            (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                            (Mathlib.Tactic.Ring.sub_pf
                              (Mathlib.Tactic.Ring.neg_add
                                (Mathlib.Tactic.Ring.neg_one_mul
                                  (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                    (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                      (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                      (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                      (Eq.refl (Int.negOfNat 1)))))
                                Mathlib.Tactic.Ring.neg_zero)
                              (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                (Mathlib.Tactic.Ring.add_pf_add_zero
                                  (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                          (Eq.trans
                            (congr
                              (congrArg HAdd.hAdd
                                (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                  (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                              (Eq.trans
                                (congrArg (fun x => x + 0)
                                  (Eq.trans
                                    (Eq.trans
                                      (congr
                                        (congrArg HMul.hMul
                                          (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                            (pow_one ↑n)))
                                        (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                          (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                      (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                    (congrArg Neg.neg (mul_one ↑n))))
                                (add_zero (-↑n))))
                            (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                    (Mathlib.Tactic.Ring.add_mul
                      (Mathlib.Tactic.Ring.mul_add
                        (Mathlib.Tactic.Ring.mul_pf_right (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                          (Mathlib.Tactic.Ring.mul_one (Nat.rawCast 2)))
                        (Mathlib.Tactic.Ring.mul_zero (Nat.rawCast 2))
                        (Mathlib.Tactic.Ring.add_pf_add_zero ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 2 + 0)))
                      (Mathlib.Tactic.Ring.zero_mul ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))
                      (Mathlib.Tactic.Ring.add_pf_add_zero ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 2 + 0))))
                  (Eq.trans
                    (congrArg (fun x => x * 2 + 0)
                      (Eq.trans (congrArg (HPow.hPow (10 ^ (-1 - ↑n))) Mathlib.Tactic.RingNF.nat_rawCast_1)
                        (pow_one (10 ^ (-1 - ↑n)))))
                    (add_zero (10 ^ (-1 - ↑n) * 2))))))
            (eq_self |10 ^ (-1 - ↑n) * 2|))))
      (abs_of_nonneg
        (le_of_lt
          (mul_pos
            (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2))
              (Eq.refl (Nat.ble 1 2)))
            (zpow_pos
              (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 10))
                (Eq.refl (Nat.ble 1 10)))
              (-↑n - 1)))))hab':∀ (N n : ℕ), n ≥ N → |@_fvar.5075 n - @_fvar.5310 n| ≤ 2 * 10 ^ (-↑N - 1) := 
  fun N n hn =>
    Eq.mpr (id (congrArg (fun _a => _a ≤ 2 * 10 ^ (-↑N - 1)) (@_fvar.6550 n)))
      (mul_le_mul_of_nonneg_left
        (zpow_le_zpow_right₀
          (Mathlib.Meta.NormNum.isNat_le_true (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1))
            (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 10)) (Eq.refl true))
          (sub_le_sub_right (neg_le_neg (GCongr.natCast_le_natCast hn)) 1))
        (le_of_lt
          (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2))
            (Eq.refl (Nat.ble 1 2)))))N:ℕ⊢ ZeroLEOneClass ℚconvert_6a:ℕ → ℚ := fun n => 1 + 10 ^ (-↑n - 1)b:ℕ → ℚ := fun n => 1 - 10 ^ (-↑n - 1)ε:ℚhε:ε > 0hab:∀ (n : ℕ), |@_fvar.5075 n - @_fvar.5310 n| = 2 * 10 ^ (-↑n - 1) := 
  fun n =>
    Trans.trans
      (Trans.trans rfl
        (of_eq_true
          (Eq.trans
            (congr
              (congrArg (fun x => Eq |x|)
                (Eq.trans
                  (Mathlib.Tactic.Ring.sub_congr
                    (Mathlib.Tactic.Ring.add_congr
                      (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1)))
                      (Mathlib.Tactic.Ring.atom_pf'
                        (congrArg (HPow.hPow 10)
                          (Eq.trans
                            (Mathlib.Tactic.Ring.sub_congr
                              (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                    (Mathlib.Tactic.Ring.neg_one_mul
                                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                          (Eq.refl (Int.negOfNat 1))))))
                                  Mathlib.Tactic.Ring.neg_zero))
                              (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                              (Mathlib.Tactic.Ring.sub_pf
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1)))))
                                  Mathlib.Tactic.Ring.neg_zero)
                                (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                  (Mathlib.Tactic.Ring.add_pf_add_zero
                                    (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                            (Eq.trans
                              (congr
                                (congrArg HAdd.hAdd
                                  (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                    (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                (Eq.trans
                                  (congrArg (fun x => x + 0)
                                    (Eq.trans
                                      (Eq.trans
                                        (congr
                                          (congrArg HMul.hMul
                                            (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                              (pow_one ↑n)))
                                          (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                            (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                        (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                      (congrArg Neg.neg (mul_one ↑n))))
                                  (add_zero (-↑n))))
                              (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                      (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                        (Mathlib.Tactic.Ring.add_pf_zero_add ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))))
                    (Mathlib.Tactic.Ring.sub_congr
                      (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1)))
                      (Mathlib.Tactic.Ring.atom_pf'
                        (congrArg (HPow.hPow 10)
                          (Eq.trans
                            (Mathlib.Tactic.Ring.sub_congr
                              (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                    (Mathlib.Tactic.Ring.neg_one_mul
                                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                          (Eq.refl (Int.negOfNat 1))))))
                                  Mathlib.Tactic.Ring.neg_zero))
                              (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                              (Mathlib.Tactic.Ring.sub_pf
                                (Mathlib.Tactic.Ring.neg_add
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1)))))
                                  Mathlib.Tactic.Ring.neg_zero)
                                (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                  (Mathlib.Tactic.Ring.add_pf_add_zero
                                    (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                            (Eq.trans
                              (congr
                                (congrArg HAdd.hAdd
                                  (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                    (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                (Eq.trans
                                  (congrArg (fun x => x + 0)
                                    (Eq.trans
                                      (Eq.trans
                                        (congr
                                          (congrArg HMul.hMul
                                            (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                              (pow_one ↑n)))
                                          (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                            (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                        (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                      (congrArg Neg.neg (mul_one ↑n))))
                                  (add_zero (-↑n))))
                              (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                      (Mathlib.Tactic.Ring.sub_pf
                        (Mathlib.Tactic.Ring.neg_add
                          (Mathlib.Tactic.Ring.neg_mul (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Tactic.Ring.neg_one_mul
                              (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                  (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                                  (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                                  (Eq.refl (Int.negOfNat 1))))))
                          Mathlib.Tactic.Ring.neg_zero)
                        (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                          (Mathlib.Tactic.Ring.add_pf_zero_add
                            ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                    (Mathlib.Tactic.Ring.sub_pf
                      (Mathlib.Tactic.Ring.neg_add
                        (Mathlib.Tactic.Ring.neg_one_mul
                          (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                            (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                              (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                              (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                              (Eq.refl (Int.negOfNat 1)))))
                        (Mathlib.Tactic.Ring.neg_add
                          (Mathlib.Tactic.Ring.neg_mul (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Tactic.Ring.neg_one_mul
                              (Mathlib.Meta.NormNum.IsNat.to_raw_eq
                                (Mathlib.Meta.NormNum.IsInt.to_isNat
                                  (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                    (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1))
                                    (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 1)))))))
                          Mathlib.Tactic.Ring.neg_zero))
                      (Mathlib.Tactic.Ring.add_pf_add_overlap_zero
                        (Mathlib.Meta.NormNum.IsInt.to_isNat
                          (Mathlib.Meta.NormNum.isInt_add (Eq.refl HAdd.hAdd)
                            (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1))
                            (Mathlib.Meta.NormNum.IsInt.of_raw ℚ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 0))))
                        (Mathlib.Tactic.Ring.add_pf_add_overlap
                          (Mathlib.Tactic.Ring.add_overlap_pf (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                            (Mathlib.Meta.NormNum.IsNat.to_raw_eq
                              (Mathlib.Meta.NormNum.isNat_add (Eq.refl HAdd.hAdd) (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1)
                                (Mathlib.Meta.NormNum.IsNat.of_raw ℚ 1) (Eq.refl 2))))
                          (Mathlib.Tactic.Ring.add_pf_zero_add 0)))))
                  (Eq.trans
                    (congrArg (fun x => x * 2 + 0)
                      (Eq.trans (congrArg (HPow.hPow (10 ^ (-1 - ↑n))) Mathlib.Tactic.RingNF.nat_rawCast_1)
                        (pow_one (10 ^ (-1 - ↑n)))))
                    (add_zero (10 ^ (-1 - ↑n) * 2)))))
              (congrArg abs
                (Eq.trans
                  (Mathlib.Tactic.Ring.mul_congr
                    (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2)))
                    (Mathlib.Tactic.Ring.atom_pf'
                      (congrArg (HPow.hPow 10)
                        (Eq.trans
                          (Mathlib.Tactic.Ring.sub_congr
                            (Mathlib.Tactic.Ring.neg_congr (Mathlib.Tactic.Ring.atom_pf ↑n)
                              (Mathlib.Tactic.Ring.neg_add
                                (Mathlib.Tactic.Ring.neg_mul (↑n) (Nat.rawCast 1)
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                        (Eq.refl (Int.negOfNat 1))))))
                                Mathlib.Tactic.Ring.neg_zero))
                            (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                            (Mathlib.Tactic.Ring.sub_pf
                              (Mathlib.Tactic.Ring.neg_add
                                (Mathlib.Tactic.Ring.neg_one_mul
                                  (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                    (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                      (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                                      (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                                      (Eq.refl (Int.negOfNat 1)))))
                                Mathlib.Tactic.Ring.neg_zero)
                              (Mathlib.Tactic.Ring.add_pf_add_gt (Int.negOfNat 1).rawCast
                                (Mathlib.Tactic.Ring.add_pf_add_zero
                                  (↑n ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                          (Eq.trans
                            (congr
                              (congrArg HAdd.hAdd
                                (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                  (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                              (Eq.trans
                                (congrArg (fun x => x + 0)
                                  (Eq.trans
                                    (Eq.trans
                                      (congr
                                        (congrArg HMul.hMul
                                          (Eq.trans (congrArg (HPow.hPow ↑n) Mathlib.Tactic.RingNF.nat_rawCast_1)
                                            (pow_one ↑n)))
                                        (Eq.trans Mathlib.Tactic.RingNF.int_rawCast_neg
                                          (congrArg Neg.neg Mathlib.Tactic.RingNF.nat_rawCast_1)))
                                      (Mathlib.Tactic.RingNF.mul_neg (↑n) 1))
                                    (congrArg Neg.neg (mul_one ↑n))))
                                (add_zero (-↑n))))
                            (Mathlib.Tactic.RingNF.add_neg (-1) ↑n)))))
                    (Mathlib.Tactic.Ring.add_mul
                      (Mathlib.Tactic.Ring.mul_add
                        (Mathlib.Tactic.Ring.mul_pf_right (10 ^ (-1 - ↑n)) (Nat.rawCast 1)
                          (Mathlib.Tactic.Ring.mul_one (Nat.rawCast 2)))
                        (Mathlib.Tactic.Ring.mul_zero (Nat.rawCast 2))
                        (Mathlib.Tactic.Ring.add_pf_add_zero ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 2 + 0)))
                      (Mathlib.Tactic.Ring.zero_mul ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))
                      (Mathlib.Tactic.Ring.add_pf_add_zero ((10 ^ (-1 - ↑n)) ^ Nat.rawCast 1 * Nat.rawCast 2 + 0))))
                  (Eq.trans
                    (congrArg (fun x => x * 2 + 0)
                      (Eq.trans (congrArg (HPow.hPow (10 ^ (-1 - ↑n))) Mathlib.Tactic.RingNF.nat_rawCast_1)
                        (pow_one (10 ^ (-1 - ↑n)))))
                    (add_zero (10 ^ (-1 - ↑n) * 2))))))
            (eq_self |10 ^ (-1 - ↑n) * 2|))))
      (abs_of_nonneg
        (le_of_lt
          (mul_pos
            (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2))
              (Eq.refl (Nat.ble 1 2)))
            (zpow_pos
              (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 10))
                (Eq.refl (Nat.ble 1 10)))
              (-↑n - 1)))))hab':∀ (N n : ℕ), n ≥ N → |@_fvar.5075 n - @_fvar.5310 n| ≤ 2 * 10 ^ (-↑N - 1) := 
  fun N n hn =>
    Eq.mpr (id (congrArg (fun _a => _a ≤ 2 * 10 ^ (-↑N - 1)) (@_fvar.6550 n)))
      (mul_le_mul_of_nonneg_left
        (zpow_le_zpow_right₀
          (Mathlib.Meta.NormNum.isNat_le_true (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 1))
            (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 10)) (Eq.refl true))
          (sub_le_sub_right (neg_le_neg (GCongr.natCast_le_natCast hn)) 1))
        (le_of_lt
          (Mathlib.Meta.Positivity.pos_of_isNat (Mathlib.Meta.NormNum.isNat_ofNat ℚ (Eq.refl 2))
            (Eq.refl (Nat.ble 1 2)))))N:ℕ⊢ CharZero ℚ try infer_instanceAll goals completed! 🐙
        all_goals simpAll goals completed! 🐙
    choose N hN using exists_nat_gt (2 / ε)a:ℕ → ℚ := fun n => 1 + 10 ^ (-↑n - 1)b:ℕ → ℚ := fun n => 1 - 10 ^ (-↑n - 1)ε:ℚhε:ε > 0hab:∀ (n : ℕ), |@_fvar.5075 n - @_fvar.5310 n| = 2 * 10 ^ (-↑n - 1) := fun n => Trans.trans (Trans.trans rfl (@?_mvar.6548 n)) (abs_of_nonneg (@?_mvar.6549 n))hab':∀ (N n : ℕ), n ≥ N → |@_fvar.5075 n - @_fvar.5310 n| ≤ 2 * 10 ^ (-↑N - 1) := fun N => @?_mvar.12521 NhN':∀ (N : ℕ), 2 * 10 ^ (-↑N - 1) ≤ 2 / (↑N + 1) := fun N => Trans.trans (@?_mvar.20396 N) (@?_mvar.20397 N)N:ℕhN:2 / ε < ↑N⊢ ∃ N, 2 * 10 ^ (-↑N - 1) ≤ ε
    refine ⟨ N, (hN' N).trans ?_ ⟩a:ℕ → ℚ := fun n => 1 + 10 ^ (-↑n - 1)b:ℕ → ℚ := fun n => 1 - 10 ^ (-↑n - 1)ε:ℚhε:ε > 0hab:∀ (n : ℕ), |@_fvar.5075 n - @_fvar.5310 n| = 2 * 10 ^ (-↑n - 1) := fun n => Trans.trans (Trans.trans rfl (@?_mvar.6548 n)) (abs_of_nonneg (@?_mvar.6549 n))hab':∀ (N n : ℕ), n ≥ N → |@_fvar.5075 n - @_fvar.5310 n| ≤ 2 * 10 ^ (-↑N - 1) := fun N => @?_mvar.12521 NhN':∀ (N : ℕ), 2 * 10 ^ (-↑N - 1) ≤ 2 / (↑N + 1) := fun N => Trans.trans (@?_mvar.20396 N) (@?_mvar.20397 N)N:ℕhN:2 / ε < ↑N⊢ 2 / (↑N + 1) ≤ ε
    rw [div_le_iff₀ (by positivity)]a:ℕ → ℚ := fun n => 1 + 10 ^ (-↑n - 1)b:ℕ → ℚ := fun n => 1 - 10 ^ (-↑n - 1)ε:ℚhε:ε > 0hab:∀ (n : ℕ), |@_fvar.5075 n - @_fvar.5310 n| = 2 * 10 ^ (-↑n - 1) := fun n => Trans.trans (Trans.trans rfl (@?_mvar.6548 n)) (abs_of_nonneg (@?_mvar.6549 n))hab':∀ (N n : ℕ), n ≥ N → |@_fvar.5075 n - @_fvar.5310 n| ≤ 2 * 10 ^ (-↑N - 1) := fun N => @?_mvar.12521 NhN':∀ (N : ℕ), 2 * 10 ^ (-↑N - 1) ≤ 2 / (↑N + 1) := fun N => Trans.trans (@?_mvar.20396 N) (@?_mvar.20397 N)N:ℕhN:2 / ε < ↑N⊢ 2 ≤ ε * (↑N + 1)
    rw [div_lt_iff₀ hε] at hNa:ℕ → ℚ := fun n => 1 + 10 ^ (-↑n - 1)b:ℕ → ℚ := fun n => 1 - 10 ^ (-↑n - 1)ε:ℚhε:ε > 0hab:∀ (n : ℕ), |@_fvar.5075 n - @_fvar.5310 n| = 2 * 10 ^ (-↑n - 1) := fun n => Trans.trans (Trans.trans rfl (@?_mvar.6548 n)) (abs_of_nonneg (@?_mvar.6549 n))hab':∀ (N n : ℕ), n ≥ N → |@_fvar.5075 n - @_fvar.5310 n| ≤ 2 * 10 ^ (-↑N - 1) := fun N => @?_mvar.12521 NhN':∀ (N : ℕ), 2 * 10 ^ (-↑N - 1) ≤ 2 / (↑N + 1) := fun N => Trans.trans (@?_mvar.20396 N) (@?_mvar.20397 N)N:ℕhN:2 < ↑N * ε⊢ 2 ≤ ε * (↑N + 1)
    grind [mul_comm]All goals completed! 🐙
  choose N hN using hNa:ℕ → ℚ := fun n => 1 + 10 ^ (-↑n - 1)b:ℕ → ℚ := fun n => 1 - 10 ^ (-↑n - 1)ε:ℚhε:ε > 0hab:∀ (n : ℕ), |@_fvar.5075 n - @_fvar.5310 n| = 2 * 10 ^ (-↑n - 1) := fun n => Trans.trans (Trans.trans rfl (@?_mvar.6548 n)) (abs_of_nonneg (@?_mvar.6549 n))hab':∀ (N n : ℕ), n ≥ N → |@_fvar.5075 n - @_fvar.5310 n| ≤ 2 * 10 ^ (-↑N - 1) := fun N => @?_mvar.12521 NN:ℕhN:2 * 10 ^ (-↑N - 1) ≤ ε⊢ ∃ N, ∀ n ≥ N, |a n - b n| ≤ ε; use Nha:ℕ → ℚ := fun n => 1 + 10 ^ (-↑n - 1)b:ℕ → ℚ := fun n => 1 - 10 ^ (-↑n - 1)ε:ℚhε:ε > 0hab:∀ (n : ℕ), |@_fvar.5075 n - @_fvar.5310 n| = 2 * 10 ^ (-↑n - 1) := fun n => Trans.trans (Trans.trans rfl (@?_mvar.6548 n)) (abs_of_nonneg (@?_mvar.6549 n))hab':∀ (N n : ℕ), n ≥ N → |@_fvar.5075 n - @_fvar.5310 n| ≤ 2 * 10 ^ (-↑N - 1) := fun N => @?_mvar.12521 NN:ℕhN:2 * 10 ^ (-↑N - 1) ≤ ε⊢ ∀ n ≥ N, |a n - b n| ≤ ε; intro n hnha:ℕ → ℚ := fun n => 1 + 10 ^ (-↑n - 1)b:ℕ → ℚ := fun n => 1 - 10 ^ (-↑n - 1)ε:ℚhε:ε > 0hab:∀ (n : ℕ), |@_fvar.5075 n - @_fvar.5310 n| = 2 * 10 ^ (-↑n - 1) := fun n => Trans.trans (Trans.trans rfl (@?_mvar.6548 n)) (abs_of_nonneg (@?_mvar.6549 n))hab':∀ (N n : ℕ), n ≥ N → |@_fvar.5075 n - @_fvar.5310 n| ≤ 2 * 10 ^ (-↑N - 1) := fun N => @?_mvar.12521 NN:ℕhN:2 * 10 ^ (-↑N - 1) ≤ εn:ℕhn:n ≥ N⊢ |a n - b n| ≤ ε
  linarith [hab' N n hn]All goals completed! 🐙

Вправа 5.2.1

theorem declaration uses 'sorry'Sequence.isCauchy_of_equiv {a b: ℕ → ℚ} (hab: Equiv a b) :
    (a:Sequence).IsCauchy ↔ (b:Sequence).IsCauchy := bya:ℕ → ℚb:ℕ → ℚhab:Equiv a b⊢ (↑a).IsCauchy ↔ (↑b).IsCauchy sorryAll goals completed! 🐙

Вправа 5.2.2

theorem declaration uses 'sorry'Sequence.isBounded_of_eventuallyClose {ε:ℚ} {a b: ℕ → ℚ} (hab: ε.EventuallyClose a b) :
    (a:Sequence).IsBounded ↔ (b:Sequence).IsBounded := byε:ℚa:ℕ → ℚb:ℕ → ℚhab:ε.EventuallyClose ↑a ↑b⊢ (↑a).IsBounded ↔ (↑b).IsBounded sorryAll goals completed! 🐙

end Chapter5