Theorem: AbsoluteValue.IsAdmissible.exists_approx_aux
File: Mathlib/NumberTheory/ClassNumber/AdmissibleAbsoluteValue.lean

tactic: haveI := Classical.decEq R
state_before: R : Type u_1
inst✝ : EuclideanDomain R
abv : AbsoluteValue R ℤ
n : ℕ
h : IsAdmissible abv
⊢ ∀ {ε : ℝ},
    0 < ε →
      ∀ {b : R},
        b ≠ 0 →
          ∀ (A : Fin (Nat.succ (IsAdmissible.card h ε ^ n)) → Fin n → R),
            ∃ i₀ i₁, i₀ ≠ i₁ ∧ ∀ (k : Fin n), ↑(↑abv (A i₁ k % b - A i₀ k % b)) < ↑abv b • ε

tactic: induction' n with n ih
state_before: R : Type u_1
inst✝ : EuclideanDomain R
abv : AbsoluteValue R ℤ
n : ℕ
h : IsAdmissible abv
this : DecidableEq R
⊢ ∀ {ε : ℝ},
    0 < ε →
      ∀ {b : R},
        b ≠ 0 →
          ∀ (A : Fin (Nat.succ (IsAdmissible.card h ε ^ n)) → Fin n → R),
            ∃ i₀ i₁, i₀ ≠ i₁ ∧ ∀ (k : Fin n), ↑(↑abv (A i₁ k % b - A i₀ k % b)) < ↑abv b • ε

tactic: intro ε hε b hb A
state_before: case succ
R : Type u_1
inst✝ : EuclideanDomain R
abv : AbsoluteValue R ℤ
h : IsAdmissible abv
this : DecidableEq R
n : ℕ
ih :
  ∀ {ε : ℝ},
    0 < ε →
      ∀ {b : R},
        b ≠ 0 →
          ∀ (A : Fin (Nat.succ (IsAdmissible.card h ε ^ n)) → Fin n → R),
            ∃ i₀ i₁, i₀ ≠ i₁ ∧ ∀ (k : Fin n), ↑(↑abv (A i₁ k % b - A i₀ k % b)) < ↑abv b • ε
⊢ ∀ {ε : ℝ},
    0 < ε →
      ∀ {b : R},
        b ≠ 0 →
          ∀ (A : Fin (Nat.succ (IsAdmissible.card h ε ^ Nat.succ n)) → Fin (Nat.succ n) → R),
            ∃ i₀ i₁, i₀ ≠ i₁ ∧ ∀ (k : Fin (Nat.succ n)), ↑(↑abv (A i₁ k % b - A i₀ k % b)) < ↑abv b • ε

tactic: let M := h.card ε
state_before: case succ
R : Type u_1
inst✝ : EuclideanDomain R
abv : AbsoluteValue R ℤ
h : IsAdmissible abv
this : DecidableEq R
n : ℕ
ih :
  ∀ {ε : ℝ},
    0 < ε →
      ∀ {b : R},
        b ≠ 0 →
          ∀ (A : Fin (Nat.succ (IsAdmissible.card h ε ^ n)) → Fin n → R),
            ∃ i₀ i₁, i₀ ≠ i₁ ∧ ∀ (k : Fin n), ↑(↑abv (A i₁ k % b - A i₀ k % b)) < ↑abv b • ε
ε : ℝ
hε : 0 < ε
b : R
hb : b ≠ 0
A : Fin (Nat.succ (IsAdmissible.card h ε ^ Nat.succ n)) → Fin (Nat.succ n) → R
⊢ ∃ i₀ i₁, i₀ ≠ i₁ ∧ ∀ (k : Fin (Nat.succ n)), ↑(↑abv (A i₁ k % b - A i₀ k % b)) < ↑abv b • ε

tactic: obtain ⟨k₀, k₁, hk, h⟩ := ih hε hb fun x ↦ Fin.tail (A (s x))
state_before: case succ.intro.intro
R : Type u_1
inst✝ : EuclideanDomain R
abv : AbsoluteValue R ℤ
h : IsAdmissible abv
this : DecidableEq R
n : ℕ
ih :
  ∀ {ε : ℝ},
    0 < ε →
      ∀ {b : R},
        b ≠ 0 →
          ∀ (A : Fin (Nat.succ (IsAdmissible.card h ε ^ n)) → Fin n → R),
            ∃ i₀ i₁, i₀ ≠ i₁ ∧ ∀ (k : Fin n), ↑(↑abv (A i₁ k % b - A i₀ k % b)) < ↑abv b • ε
ε : ℝ
hε : 0 < ε
b : R
hb : b ≠ 0
A : Fin (Nat.succ (IsAdmissible.card h ε ^ Nat.succ n)) → Fin (Nat.succ n) → R
M : ℕ := IsAdmissible.card h ε
s : Fin (Nat.succ (M ^ n)) → Fin (Nat.succ (M ^ Nat.succ n))
s_inj : Function.Injective s
hs : ∀ (i₀ i₁ : Fin (Nat.succ (M ^ n))), ↑(↑abv (A (s i₁) 0 % b - A (s i₀) 0 % b)) < ↑abv b • ε
⊢ ∃ i₀ i₁, i₀ ≠ i₁ ∧ ∀ (k : Fin (Nat.succ n)), ↑(↑abv (A i₁ k % b - A i₀ k % b)) < ↑abv b • ε

tactic: refine' ⟨s k₀, s k₁, fun h ↦ hk (s_inj h), fun i ↦ Fin.cases _ (fun i ↦ _) i⟩
state_before: case succ.intro.intro.intro.intro.intro
R : Type u_1
inst✝ : EuclideanDomain R
abv : AbsoluteValue R ℤ
h✝ : IsAdmissible abv
this : DecidableEq R
n : ℕ
ih :
  ∀ {ε : ℝ},
    0 < ε →
      ∀ {b : R},
        b ≠ 0 →
          ∀ (A : Fin (Nat.succ (IsAdmissible.card h✝ ε ^ n)) → Fin n → R),
            ∃ i₀ i₁, i₀ ≠ i₁ ∧ ∀ (k : Fin n), ↑(↑abv (A i₁ k % b - A i₀ k % b)) < ↑abv b • ε
ε : ℝ
hε : 0 < ε
b : R
hb : b ≠ 0
A : Fin (Nat.succ (IsAdmissible.card h✝ ε ^ Nat.succ n)) → Fin (Nat.succ n) → R
M : ℕ := IsAdmissible.card h✝ ε
s : Fin (Nat.succ (M ^ n)) → Fin (Nat.succ (M ^ Nat.succ n))
s_inj : Function.Injective s
hs : ∀ (i₀ i₁ : Fin (Nat.succ (M ^ n))), ↑(↑abv (A (s i₁) 0 % b - A (s i₀) 0 % b)) < ↑abv b • ε
k₀ k₁ : Fin (Nat.succ (IsAdmissible.card h✝ ε ^ n))
hk : k₀ ≠ k₁
h : ∀ (k : Fin n), ↑(↑abv (Fin.tail (A (s k₁)) k % b - Fin.tail (A (s k₀)) k % b)) < ↑abv b • ε
⊢ ∃ i₀ i₁, i₀ ≠ i₁ ∧ ∀ (k : Fin (Nat.succ n)), ↑(↑abv (A i₁ k % b - A i₀ k % b)) < ↑abv b • ε

tactic: intro ε _hε b _hb A
state_before: case zero
R : Type u_1
inst✝ : EuclideanDomain R
abv : AbsoluteValue R ℤ
h : IsAdmissible abv
this : DecidableEq R
⊢ ∀ {ε : ℝ},
    0 < ε →
      ∀ {b : R},
        b ≠ 0 →
          ∀ (A : Fin (Nat.succ (IsAdmissible.card h ε ^ Nat.zero)) → Fin Nat.zero → R),
            ∃ i₀ i₁, i₀ ≠ i₁ ∧ ∀ (k : Fin Nat.zero), ↑(↑abv (A i₁ k % b - A i₀ k % b)) < ↑abv b • ε

tactic: refine' ⟨0, 1, _, _⟩
state_before: case zero
R : Type u_1
inst✝ : EuclideanDomain R
abv : AbsoluteValue R ℤ
h : IsAdmissible abv
this : DecidableEq R
ε : ℝ
_hε : 0 < ε
b : R
_hb : b ≠ 0
A : Fin (Nat.succ (IsAdmissible.card h ε ^ Nat.zero)) → Fin Nat.zero → R
⊢ ∃ i₀ i₁, i₀ ≠ i₁ ∧ ∀ (k : Fin Nat.zero), ↑(↑abv (A i₁ k % b - A i₀ k % b)) < ↑abv b • ε

tactic: rintro ⟨i, ⟨⟩⟩
state_before: case zero.refine'_2
R : Type u_1
inst✝ : EuclideanDomain R
abv : AbsoluteValue R ℤ
h : IsAdmissible abv
this : DecidableEq R
ε : ℝ
_hε : 0 < ε
b : R
_hb : b ≠ 0
A : Fin (Nat.succ (IsAdmissible.card h ε ^ Nat.zero)) → Fin Nat.zero → R
⊢ ∀ (k : Fin Nat.zero), ↑(↑abv (A 1 k % b - A 0 k % b)) < ↑abv b • ε

tactic: simp
state_before: case zero.refine'_1
R : Type u_1
inst✝ : EuclideanDomain R
abv : AbsoluteValue R ℤ
h : IsAdmissible abv
this : DecidableEq R
ε : ℝ
_hε : 0 < ε
b : R
_hb : b ≠ 0
A : Fin (Nat.succ (IsAdmissible.card h ε ^ Nat.zero)) → Fin Nat.zero → R
⊢ 0 ≠ 1

tactic: obtain ⟨t, ht⟩ :
  ∃ t : Fin (M ^ n.succ).succ → Fin M,
    ∀ i₀ i₁, t i₀ = t i₁ → (abv (A i₁ 0 % b - A i₀ 0 % b) : ℝ) < abv b • ε :=
  h.exists_partition hε hb fun x ↦ A x 0
state_before: R : Type u_1
inst✝ : EuclideanDomain R
abv : AbsoluteValue R ℤ
h : IsAdmissible abv
this : DecidableEq R
n : ℕ
ih :
  ∀ {ε : ℝ},
    0 < ε →
      ∀ {b : R},
        b ≠ 0 →
          ∀ (A : Fin (Nat.succ (IsAdmissible.card h ε ^ n)) → Fin n → R),
            ∃ i₀ i₁, i₀ ≠ i₁ ∧ ∀ (k : Fin n), ↑(↑abv (A i₁ k % b - A i₀ k % b)) < ↑abv b • ε
ε : ℝ
hε : 0 < ε
b : R
hb : b ≠ 0
A : Fin (Nat.succ (IsAdmissible.card h ε ^ Nat.succ n)) → Fin (Nat.succ n) → R
M : ℕ := IsAdmissible.card h ε
⊢ ∃ s, Function.Injective s ∧ ∀ (i₀ i₁ : Fin (Nat.succ (M ^ n))), ↑(↑abv (A (s i₁) 0 % b - A (s i₀) 0 % b)) < ↑abv b • ε

tactic: obtain ⟨s, hs⟩ :=
  @Fintype.exists_lt_card_fiber_of_mul_lt_card _ _ _ _ _ t (M ^ n)
    (by simpa only [Fintype.card_fin, pow_succ] using Nat.lt_succ_self (M ^ n.succ))
state_before: case intro
R : Type u_1
inst✝ : EuclideanDomain R
abv : AbsoluteValue R ℤ
h : IsAdmissible abv
this : DecidableEq R
n : ℕ
ih :
  ∀ {ε : ℝ},
    0 < ε →
      ∀ {b : R},
        b ≠ 0 →
          ∀ (A : Fin (Nat.succ (IsAdmissible.card h ε ^ n)) → Fin n → R),
            ∃ i₀ i₁, i₀ ≠ i₁ ∧ ∀ (k : Fin n), ↑(↑abv (A i₁ k % b - A i₀ k % b)) < ↑abv b • ε
ε : ℝ
hε : 0 < ε
b : R
hb : b ≠ 0
A : Fin (Nat.succ (IsAdmissible.card h ε ^ Nat.succ n)) → Fin (Nat.succ n) → R
M : ℕ := IsAdmissible.card h ε
t : Fin (Nat.succ (M ^ Nat.succ n)) → Fin M
ht : ∀ (i₀ i₁ : Fin (Nat.succ (M ^ Nat.succ n))), t i₀ = t i₁ → ↑(↑abv (A i₁ 0 % b - A i₀ 0 % b)) < ↑abv b • ε
⊢ ∃ s, Function.Injective s ∧ ∀ (i₀ i₁ : Fin (Nat.succ (M ^ n))), ↑(↑abv (A (s i₁) 0 % b - A (s i₀) 0 % b)) < ↑abv b • ε

tactic: refine'
  ⟨fun i ↦ (Finset.univ.filter fun x ↦ t x = s).toList.nthLe i _, _, fun i₀ i₁ ↦ ht _ _ _⟩
state_before: case intro.intro
R : Type u_1
inst✝ : EuclideanDomain R
abv : AbsoluteValue R ℤ
h : IsAdmissible abv
this : DecidableEq R
n : ℕ
ih :
  ∀ {ε : ℝ},
    0 < ε →
      ∀ {b : R},
        b ≠ 0 →
          ∀ (A : Fin (Nat.succ (IsAdmissible.card h ε ^ n)) → Fin n → R),
            ∃ i₀ i₁, i₀ ≠ i₁ ∧ ∀ (k : Fin n), ↑(↑abv (A i₁ k % b - A i₀ k % b)) < ↑abv b • ε
ε : ℝ
hε : 0 < ε
b : R
hb : b ≠ 0
A : Fin (Nat.succ (IsAdmissible.card h ε ^ Nat.succ n)) → Fin (Nat.succ n) → R
M : ℕ := IsAdmissible.card h ε
t : Fin (Nat.succ (M ^ Nat.succ n)) → Fin M
ht : ∀ (i₀ i₁ : Fin (Nat.succ (M ^ Nat.succ n))), t i₀ = t i₁ → ↑(↑abv (A i₁ 0 % b - A i₀ 0 % b)) < ↑abv b • ε
s : Fin M
hs : M ^ n < Finset.card (Finset.filter (fun x => t x = s) Finset.univ)
⊢ ∃ s, Function.Injective s ∧ ∀ (i₀ i₁ : Fin (Nat.succ (M ^ n))), ↑(↑abv (A (s i₁) 0 % b - A (s i₀) 0 % b)) < ↑abv b • ε

tactic: have : ∀ i h, (Finset.univ.filter fun x ↦ t x = s).toList.nthLe i h ∈
    Finset.univ.filter fun x ↦ t x = s := by
  intro i h
  exact Finset.mem_toList.mp (List.get_mem _ i h)
state_before: case intro.intro.refine'_3
R : Type u_1
inst✝ : EuclideanDomain R
abv : AbsoluteValue R ℤ
h : IsAdmissible abv
this : DecidableEq R
n : ℕ
ih :
  ∀ {ε : ℝ},
    0 < ε →
      ∀ {b : R},
        b ≠ 0 →
          ∀ (A : Fin (Nat.succ (IsAdmissible.card h ε ^ n)) → Fin n → R),
            ∃ i₀ i₁, i₀ ≠ i₁ ∧ ∀ (k : Fin n), ↑(↑abv (A i₁ k % b - A i₀ k % b)) < ↑abv b • ε
ε : ℝ
hε : 0 < ε
b : R
hb : b ≠ 0
A : Fin (Nat.succ (IsAdmissible.card h ε ^ Nat.succ n)) → Fin (Nat.succ n) → R
M : ℕ := IsAdmissible.card h ε
t : Fin (Nat.succ (M ^ Nat.succ n)) → Fin M
ht : ∀ (i₀ i₁ : Fin (Nat.succ (M ^ Nat.succ n))), t i₀ = t i₁ → ↑(↑abv (A i₁ 0 % b - A i₀ 0 % b)) < ↑abv b • ε
s : Fin M
hs : M ^ n < Finset.card (Finset.filter (fun x => t x = s) Finset.univ)
i₀ i₁ : Fin (Nat.succ (M ^ n))
⊢ t
      ((fun i =>
          List.nthLe (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ)) ↑i
            (_ : ↑i < List.length (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ))))
        i₀) =
    t
      ((fun i =>
          List.nthLe (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ)) ↑i
            (_ : ↑i < List.length (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ))))
        i₁)

tactic: obtain ⟨_, h₀⟩ := Finset.mem_filter.mp (this i₀ _)
state_before: case intro.intro.refine'_3
R : Type u_1
inst✝ : EuclideanDomain R
abv : AbsoluteValue R ℤ
h : IsAdmissible abv
this✝ : DecidableEq R
n : ℕ
ih :
  ∀ {ε : ℝ},
    0 < ε →
      ∀ {b : R},
        b ≠ 0 →
          ∀ (A : Fin (Nat.succ (IsAdmissible.card h ε ^ n)) → Fin n → R),
            ∃ i₀ i₁, i₀ ≠ i₁ ∧ ∀ (k : Fin n), ↑(↑abv (A i₁ k % b - A i₀ k % b)) < ↑abv b • ε
ε : ℝ
hε : 0 < ε
b : R
hb : b ≠ 0
A : Fin (Nat.succ (IsAdmissible.card h ε ^ Nat.succ n)) → Fin (Nat.succ n) → R
M : ℕ := IsAdmissible.card h ε
t : Fin (Nat.succ (M ^ Nat.succ n)) → Fin M
ht : ∀ (i₀ i₁ : Fin (Nat.succ (M ^ Nat.succ n))), t i₀ = t i₁ → ↑(↑abv (A i₁ 0 % b - A i₀ 0 % b)) < ↑abv b • ε
s : Fin M
hs : M ^ n < Finset.card (Finset.filter (fun x => t x = s) Finset.univ)
i₀ i₁ : Fin (Nat.succ (M ^ n))
this :
  ∀ (i : ℕ) (h : i < List.length (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ))),
    List.nthLe (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ)) i h ∈
      Finset.filter (fun x => t x = s) Finset.univ
⊢ t
      ((fun i =>
          List.nthLe (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ)) ↑i
            (_ : ↑i < List.length (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ))))
        i₀) =
    t
      ((fun i =>
          List.nthLe (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ)) ↑i
            (_ : ↑i < List.length (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ))))
        i₁)

tactic: obtain ⟨_, h₁⟩ := Finset.mem_filter.mp (this i₁ _)
state_before: case intro.intro.refine'_3.intro
R : Type u_1
inst✝ : EuclideanDomain R
abv : AbsoluteValue R ℤ
h : IsAdmissible abv
this✝ : DecidableEq R
n : ℕ
ih :
  ∀ {ε : ℝ},
    0 < ε →
      ∀ {b : R},
        b ≠ 0 →
          ∀ (A : Fin (Nat.succ (IsAdmissible.card h ε ^ n)) → Fin n → R),
            ∃ i₀ i₁, i₀ ≠ i₁ ∧ ∀ (k : Fin n), ↑(↑abv (A i₁ k % b - A i₀ k % b)) < ↑abv b • ε
ε : ℝ
hε : 0 < ε
b : R
hb : b ≠ 0
A : Fin (Nat.succ (IsAdmissible.card h ε ^ Nat.succ n)) → Fin (Nat.succ n) → R
M : ℕ := IsAdmissible.card h ε
t : Fin (Nat.succ (M ^ Nat.succ n)) → Fin M
ht : ∀ (i₀ i₁ : Fin (Nat.succ (M ^ Nat.succ n))), t i₀ = t i₁ → ↑(↑abv (A i₁ 0 % b - A i₀ 0 % b)) < ↑abv b • ε
s : Fin M
hs : M ^ n < Finset.card (Finset.filter (fun x => t x = s) Finset.univ)
i₀ i₁ : Fin (Nat.succ (M ^ n))
this :
  ∀ (i : ℕ) (h : i < List.length (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ))),
    List.nthLe (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ)) i h ∈
      Finset.filter (fun x => t x = s) Finset.univ
left✝ : List.nthLe (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ)) ↑i₀ ?m.75482 ∈ Finset.univ
h₀ : t (List.nthLe (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ)) ↑i₀ ?m.75482) = s
⊢ t
      ((fun i =>
          List.nthLe (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ)) ↑i
            (_ : ↑i < List.length (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ))))
        i₀) =
    t
      ((fun i =>
          List.nthLe (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ)) ↑i
            (_ : ↑i < List.length (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ))))
        i₁)

tactic: exact h₀.trans h₁.symm
state_before: case intro.intro.refine'_3.intro.intro
R : Type u_1
inst✝ : EuclideanDomain R
abv : AbsoluteValue R ℤ
h : IsAdmissible abv
this✝ : DecidableEq R
n : ℕ
ih :
  ∀ {ε : ℝ},
    0 < ε →
      ∀ {b : R},
        b ≠ 0 →
          ∀ (A : Fin (Nat.succ (IsAdmissible.card h ε ^ n)) → Fin n → R),
            ∃ i₀ i₁, i₀ ≠ i₁ ∧ ∀ (k : Fin n), ↑(↑abv (A i₁ k % b - A i₀ k % b)) < ↑abv b • ε
ε : ℝ
hε : 0 < ε
b : R
hb : b ≠ 0
A : Fin (Nat.succ (IsAdmissible.card h ε ^ Nat.succ n)) → Fin (Nat.succ n) → R
M : ℕ := IsAdmissible.card h ε
t : Fin (Nat.succ (M ^ Nat.succ n)) → Fin M
ht : ∀ (i₀ i₁ : Fin (Nat.succ (M ^ Nat.succ n))), t i₀ = t i₁ → ↑(↑abv (A i₁ 0 % b - A i₀ 0 % b)) < ↑abv b • ε
s : Fin M
hs : M ^ n < Finset.card (Finset.filter (fun x => t x = s) Finset.univ)
i₀ i₁ : Fin (Nat.succ (M ^ n))
this :
  ∀ (i : ℕ) (h : i < List.length (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ))),
    List.nthLe (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ)) i h ∈
      Finset.filter (fun x => t x = s) Finset.univ
left✝¹ : List.nthLe (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ)) ↑i₀ ?m.75482 ∈ Finset.univ
h₀ : t (List.nthLe (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ)) ↑i₀ ?m.75482) = s
left✝ : List.nthLe (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ)) ↑i₁ ?m.75842 ∈ Finset.univ
h₁ : t (List.nthLe (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ)) ↑i₁ ?m.75842) = s
⊢ t
      ((fun i =>
          List.nthLe (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ)) ↑i
            (_ : ↑i < List.length (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ))))
        i₀) =
    t
      ((fun i =>
          List.nthLe (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ)) ↑i
            (_ : ↑i < List.length (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ))))
        i₁)

tactic: simpa only [Fintype.card_fin, pow_succ] using Nat.lt_succ_self (M ^ n.succ)
state_before: R : Type u_1
inst✝ : EuclideanDomain R
abv : AbsoluteValue R ℤ
h : IsAdmissible abv
this : DecidableEq R
n : ℕ
ih :
  ∀ {ε : ℝ},
    0 < ε →
      ∀ {b : R},
        b ≠ 0 →
          ∀ (A : Fin (Nat.succ (IsAdmissible.card h ε ^ n)) → Fin n → R),
            ∃ i₀ i₁, i₀ ≠ i₁ ∧ ∀ (k : Fin n), ↑(↑abv (A i₁ k % b - A i₀ k % b)) < ↑abv b • ε
ε : ℝ
hε : 0 < ε
b : R
hb : b ≠ 0
A : Fin (Nat.succ (IsAdmissible.card h ε ^ Nat.succ n)) → Fin (Nat.succ n) → R
M : ℕ := IsAdmissible.card h ε
t : Fin (Nat.succ (M ^ Nat.succ n)) → Fin M
ht : ∀ (i₀ i₁ : Fin (Nat.succ (M ^ Nat.succ n))), t i₀ = t i₁ → ↑(↑abv (A i₁ 0 % b - A i₀ 0 % b)) < ↑abv b • ε
⊢ Fintype.card (Fin M) * M ^ n < Fintype.card (Fin (Nat.succ (M ^ Nat.succ n)))

tactic: refine' i.2.trans_le _
state_before: case intro.intro.refine'_1
R : Type u_1
inst✝ : EuclideanDomain R
abv : AbsoluteValue R ℤ
h : IsAdmissible abv
this : DecidableEq R
n : ℕ
ih :
  ∀ {ε : ℝ},
    0 < ε →
      ∀ {b : R},
        b ≠ 0 →
          ∀ (A : Fin (Nat.succ (IsAdmissible.card h ε ^ n)) → Fin n → R),
            ∃ i₀ i₁, i₀ ≠ i₁ ∧ ∀ (k : Fin n), ↑(↑abv (A i₁ k % b - A i₀ k % b)) < ↑abv b • ε
ε : ℝ
hε : 0 < ε
b : R
hb : b ≠ 0
A : Fin (Nat.succ (IsAdmissible.card h ε ^ Nat.succ n)) → Fin (Nat.succ n) → R
M : ℕ := IsAdmissible.card h ε
t : Fin (Nat.succ (M ^ Nat.succ n)) → Fin M
ht : ∀ (i₀ i₁ : Fin (Nat.succ (M ^ Nat.succ n))), t i₀ = t i₁ → ↑(↑abv (A i₁ 0 % b - A i₀ 0 % b)) < ↑abv b • ε
s : Fin M
hs : M ^ n < Finset.card (Finset.filter (fun x => t x = s) Finset.univ)
i : Fin (Nat.succ (M ^ n))
⊢ ↑i < List.length (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ))

tactic: rwa [Finset.length_toList]
state_before: case intro.intro.refine'_1
R : Type u_1
inst✝ : EuclideanDomain R
abv : AbsoluteValue R ℤ
h : IsAdmissible abv
this : DecidableEq R
n : ℕ
ih :
  ∀ {ε : ℝ},
    0 < ε →
      ∀ {b : R},
        b ≠ 0 →
          ∀ (A : Fin (Nat.succ (IsAdmissible.card h ε ^ n)) → Fin n → R),
            ∃ i₀ i₁, i₀ ≠ i₁ ∧ ∀ (k : Fin n), ↑(↑abv (A i₁ k % b - A i₀ k % b)) < ↑abv b • ε
ε : ℝ
hε : 0 < ε
b : R
hb : b ≠ 0
A : Fin (Nat.succ (IsAdmissible.card h ε ^ Nat.succ n)) → Fin (Nat.succ n) → R
M : ℕ := IsAdmissible.card h ε
t : Fin (Nat.succ (M ^ Nat.succ n)) → Fin M
ht : ∀ (i₀ i₁ : Fin (Nat.succ (M ^ Nat.succ n))), t i₀ = t i₁ → ↑(↑abv (A i₁ 0 % b - A i₀ 0 % b)) < ↑abv b • ε
s : Fin M
hs : M ^ n < Finset.card (Finset.filter (fun x => t x = s) Finset.univ)
i : Fin (Nat.succ (M ^ n))
⊢ Nat.succ (M ^ n) ≤ List.length (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ))

tactic: intro i j h
state_before: case intro.intro.refine'_2
R : Type u_1
inst✝ : EuclideanDomain R
abv : AbsoluteValue R ℤ
h : IsAdmissible abv
this : DecidableEq R
n : ℕ
ih :
  ∀ {ε : ℝ},
    0 < ε →
      ∀ {b : R},
        b ≠ 0 →
          ∀ (A : Fin (Nat.succ (IsAdmissible.card h ε ^ n)) → Fin n → R),
            ∃ i₀ i₁, i₀ ≠ i₁ ∧ ∀ (k : Fin n), ↑(↑abv (A i₁ k % b - A i₀ k % b)) < ↑abv b • ε
ε : ℝ
hε : 0 < ε
b : R
hb : b ≠ 0
A : Fin (Nat.succ (IsAdmissible.card h ε ^ Nat.succ n)) → Fin (Nat.succ n) → R
M : ℕ := IsAdmissible.card h ε
t : Fin (Nat.succ (M ^ Nat.succ n)) → Fin M
ht : ∀ (i₀ i₁ : Fin (Nat.succ (M ^ Nat.succ n))), t i₀ = t i₁ → ↑(↑abv (A i₁ 0 % b - A i₀ 0 % b)) < ↑abv b • ε
s : Fin M
hs : M ^ n < Finset.card (Finset.filter (fun x => t x = s) Finset.univ)
⊢ Function.Injective fun i =>
    List.nthLe (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ)) ↑i
      (_ : ↑i < List.length (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ)))

tactic: ext
state_before: case intro.intro.refine'_2
R : Type u_1
inst✝ : EuclideanDomain R
abv : AbsoluteValue R ℤ
h✝ : IsAdmissible abv
this : DecidableEq R
n : ℕ
ih :
  ∀ {ε : ℝ},
    0 < ε →
      ∀ {b : R},
        b ≠ 0 →
          ∀ (A : Fin (Nat.succ (IsAdmissible.card h✝ ε ^ n)) → Fin n → R),
            ∃ i₀ i₁, i₀ ≠ i₁ ∧ ∀ (k : Fin n), ↑(↑abv (A i₁ k % b - A i₀ k % b)) < ↑abv b • ε
ε : ℝ
hε : 0 < ε
b : R
hb : b ≠ 0
A : Fin (Nat.succ (IsAdmissible.card h✝ ε ^ Nat.succ n)) → Fin (Nat.succ n) → R
M : ℕ := IsAdmissible.card h✝ ε
t : Fin (Nat.succ (M ^ Nat.succ n)) → Fin M
ht : ∀ (i₀ i₁ : Fin (Nat.succ (M ^ Nat.succ n))), t i₀ = t i₁ → ↑(↑abv (A i₁ 0 % b - A i₀ 0 % b)) < ↑abv b • ε
s : Fin M
hs : M ^ n < Finset.card (Finset.filter (fun x => t x = s) Finset.univ)
i j : Fin (Nat.succ (M ^ n))
h :
  (fun i =>
        List.nthLe (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ)) ↑i
          (_ : ↑i < List.length (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ))))
      i =
    (fun i =>
        List.nthLe (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ)) ↑i
          (_ : ↑i < List.length (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ))))
      j
⊢ i = j

tactic: exact Fin.mk.inj_iff.mp (List.nodup_iff_injective_get.mp (Finset.nodup_toList _) h)
state_before: case intro.intro.refine'_2.h
R : Type u_1
inst✝ : EuclideanDomain R
abv : AbsoluteValue R ℤ
h✝ : IsAdmissible abv
this : DecidableEq R
n : ℕ
ih :
  ∀ {ε : ℝ},
    0 < ε →
      ∀ {b : R},
        b ≠ 0 →
          ∀ (A : Fin (Nat.succ (IsAdmissible.card h✝ ε ^ n)) → Fin n → R),
            ∃ i₀ i₁, i₀ ≠ i₁ ∧ ∀ (k : Fin n), ↑(↑abv (A i₁ k % b - A i₀ k % b)) < ↑abv b • ε
ε : ℝ
hε : 0 < ε
b : R
hb : b ≠ 0
A : Fin (Nat.succ (IsAdmissible.card h✝ ε ^ Nat.succ n)) → Fin (Nat.succ n) → R
M : ℕ := IsAdmissible.card h✝ ε
t : Fin (Nat.succ (M ^ Nat.succ n)) → Fin M
ht : ∀ (i₀ i₁ : Fin (Nat.succ (M ^ Nat.succ n))), t i₀ = t i₁ → ↑(↑abv (A i₁ 0 % b - A i₀ 0 % b)) < ↑abv b • ε
s : Fin M
hs : M ^ n < Finset.card (Finset.filter (fun x => t x = s) Finset.univ)
i j : Fin (Nat.succ (M ^ n))
h :
  (fun i =>
        List.nthLe (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ)) ↑i
          (_ : ↑i < List.length (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ))))
      i =
    (fun i =>
        List.nthLe (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ)) ↑i
          (_ : ↑i < List.length (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ))))
      j
⊢ ↑i = ↑j

tactic: intro i h
state_before: R : Type u_1
inst✝ : EuclideanDomain R
abv : AbsoluteValue R ℤ
h : IsAdmissible abv
this : DecidableEq R
n : ℕ
ih :
  ∀ {ε : ℝ},
    0 < ε →
      ∀ {b : R},
        b ≠ 0 →
          ∀ (A : Fin (Nat.succ (IsAdmissible.card h ε ^ n)) → Fin n → R),
            ∃ i₀ i₁, i₀ ≠ i₁ ∧ ∀ (k : Fin n), ↑(↑abv (A i₁ k % b - A i₀ k % b)) < ↑abv b • ε
ε : ℝ
hε : 0 < ε
b : R
hb : b ≠ 0
A : Fin (Nat.succ (IsAdmissible.card h ε ^ Nat.succ n)) → Fin (Nat.succ n) → R
M : ℕ := IsAdmissible.card h ε
t : Fin (Nat.succ (M ^ Nat.succ n)) → Fin M
ht : ∀ (i₀ i₁ : Fin (Nat.succ (M ^ Nat.succ n))), t i₀ = t i₁ → ↑(↑abv (A i₁ 0 % b - A i₀ 0 % b)) < ↑abv b • ε
s : Fin M
hs : M ^ n < Finset.card (Finset.filter (fun x => t x = s) Finset.univ)
i₀ i₁ : Fin (Nat.succ (M ^ n))
⊢ ∀ (i : ℕ) (h : i < List.length (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ))),
    List.nthLe (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ)) i h ∈
      Finset.filter (fun x => t x = s) Finset.univ

tactic: exact Finset.mem_toList.mp (List.get_mem _ i h)
state_before: R : Type u_1
inst✝ : EuclideanDomain R
abv : AbsoluteValue R ℤ
h✝ : IsAdmissible abv
this : DecidableEq R
n : ℕ
ih :
  ∀ {ε : ℝ},
    0 < ε →
      ∀ {b : R},
        b ≠ 0 →
          ∀ (A : Fin (Nat.succ (IsAdmissible.card h✝ ε ^ n)) → Fin n → R),
            ∃ i₀ i₁, i₀ ≠ i₁ ∧ ∀ (k : Fin n), ↑(↑abv (A i₁ k % b - A i₀ k % b)) < ↑abv b • ε
ε : ℝ
hε : 0 < ε
b : R
hb : b ≠ 0
A : Fin (Nat.succ (IsAdmissible.card h✝ ε ^ Nat.succ n)) → Fin (Nat.succ n) → R
M : ℕ := IsAdmissible.card h✝ ε
t : Fin (Nat.succ (M ^ Nat.succ n)) → Fin M
ht : ∀ (i₀ i₁ : Fin (Nat.succ (M ^ Nat.succ n))), t i₀ = t i₁ → ↑(↑abv (A i₁ 0 % b - A i₀ 0 % b)) < ↑abv b • ε
s : Fin M
hs : M ^ n < Finset.card (Finset.filter (fun x => t x = s) Finset.univ)
i₀ i₁ : Fin (Nat.succ (M ^ n))
i : ℕ
h : i < List.length (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ))
⊢ List.nthLe (Finset.toList (Finset.filter (fun x => t x = s) Finset.univ)) i h ∈
    Finset.filter (fun x => t x = s) Finset.univ

tactic: exact hs k₀ k₁
state_before: case succ.intro.intro.intro.intro.intro.refine'_1
R : Type u_1
inst✝ : EuclideanDomain R
abv : AbsoluteValue R ℤ
h✝ : IsAdmissible abv
this : DecidableEq R
n : ℕ
ih :
  ∀ {ε : ℝ},
    0 < ε →
      ∀ {b : R},
        b ≠ 0 →
          ∀ (A : Fin (Nat.succ (IsAdmissible.card h✝ ε ^ n)) → Fin n → R),
            ∃ i₀ i₁, i₀ ≠ i₁ ∧ ∀ (k : Fin n), ↑(↑abv (A i₁ k % b - A i₀ k % b)) < ↑abv b • ε
ε : ℝ
hε : 0 < ε
b : R
hb : b ≠ 0
A : Fin (Nat.succ (IsAdmissible.card h✝ ε ^ Nat.succ n)) → Fin (Nat.succ n) → R
M : ℕ := IsAdmissible.card h✝ ε
s : Fin (Nat.succ (M ^ n)) → Fin (Nat.succ (M ^ Nat.succ n))
s_inj : Function.Injective s
hs : ∀ (i₀ i₁ : Fin (Nat.succ (M ^ n))), ↑(↑abv (A (s i₁) 0 % b - A (s i₀) 0 % b)) < ↑abv b • ε
k₀ k₁ : Fin (Nat.succ (IsAdmissible.card h✝ ε ^ n))
hk : k₀ ≠ k₁
h : ∀ (k : Fin n), ↑(↑abv (Fin.tail (A (s k₁)) k % b - Fin.tail (A (s k₀)) k % b)) < ↑abv b • ε
i : Fin (Nat.succ n)
⊢ ↑(↑abv (A (s k₁) 0 % b - A (s k₀) 0 % b)) < ↑abv b • ε

tactic: exact h i
state_before: case succ.intro.intro.intro.intro.intro.refine'_2
R : Type u_1
inst✝ : EuclideanDomain R
abv : AbsoluteValue R ℤ
h✝ : IsAdmissible abv
this : DecidableEq R
n : ℕ
ih :
  ∀ {ε : ℝ},
    0 < ε →
      ∀ {b : R},
        b ≠ 0 →
          ∀ (A : Fin (Nat.succ (IsAdmissible.card h✝ ε ^ n)) → Fin n → R),
            ∃ i₀ i₁, i₀ ≠ i₁ ∧ ∀ (k : Fin n), ↑(↑abv (A i₁ k % b - A i₀ k % b)) < ↑abv b • ε
ε : ℝ
hε : 0 < ε
b : R
hb : b ≠ 0
A : Fin (Nat.succ (IsAdmissible.card h✝ ε ^ Nat.succ n)) → Fin (Nat.succ n) → R
M : ℕ := IsAdmissible.card h✝ ε
s : Fin (Nat.succ (M ^ n)) → Fin (Nat.succ (M ^ Nat.succ n))
s_inj : Function.Injective s
hs : ∀ (i₀ i₁ : Fin (Nat.succ (M ^ n))), ↑(↑abv (A (s i₁) 0 % b - A (s i₀) 0 % b)) < ↑abv b • ε
k₀ k₁ : Fin (Nat.succ (IsAdmissible.card h✝ ε ^ n))
hk : k₀ ≠ k₁
h : ∀ (k : Fin n), ↑(↑abv (Fin.tail (A (s k₁)) k % b - Fin.tail (A (s k₀)) k % b)) < ↑abv b • ε
i✝ : Fin (Nat.succ n)
i : Fin n
⊢ ↑(↑abv (A (s k₁) (Fin.succ i) % b - A (s k₀) (Fin.succ i) % b)) < ↑abv b • ε