[GOAL]
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
x : α
u : Fin m → α
i : Fin m
⊢ vecCons x u (Fin.succ i) = u i
[PROOFSTEP]
simp [vecCons]
[GOAL]
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
i : ℕ
h : Nat.succ i < Nat.succ m
x : α
u : Fin m → α
⊢ vecCons x u { val := Nat.succ i, isLt := h } = u { val := i, isLt := (_ : i < m) }
[PROOFSTEP]
simp only [vecCons, Fin.cons, Fin.cases_succ']
[GOAL]
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
x : α
u : Fin m → α
⊢ vecTail (vecCons x u) = u
[PROOFSTEP]
ext
[GOAL]
case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
x : α
u : Fin m → α
x✝ : Fin m
⊢ vecTail (vecCons x u) x✝ = u x✝
[PROOFSTEP]
simp [vecTail]
[GOAL]
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
x : α
u : Fin n → α
y : α
⊢ y ∈ Set.range (vecCons x u) ↔ y ∈ {x} ∪ Set.range u
[PROOFSTEP]
simp [Fin.exists_fin_succ, eq_comm]
[GOAL]
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
x : α
u : Fin 0 → α
⊢ Set.range (vecCons x u) = {x}
[PROOFSTEP]
rw [range_cons, range_empty, Set.union_empty]
[GOAL]
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
x y : α
u : Fin 0 → α
⊢ Set.range (vecCons x (vecCons y u)) = {x, y}
[PROOFSTEP]
rw [range_cons, range_cons_empty, Set.singleton_union]
[GOAL]
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
x : α
u : Fin 0 → α
⊢ ∀ (i : Fin 1), vecCons x u i = x
[PROOFSTEP]
rw [Fin.forall_fin_one]
[GOAL]
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
x : α
u : Fin 0 → α
⊢ vecCons x u 0 = x
[PROOFSTEP]
rfl
[GOAL]
α✝ : Type u
m n o✝ : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
α : Type u_4
o : ℕ
ho : o = m + n
u : Fin m → α
v : Fin n → α
⊢ vecAppend ho u v = fun i =>
    if h : ↑i < m then u { val := ↑i, isLt := h } else v { val := ↑i - m, isLt := (_ : ↑i - m < n) }
[PROOFSTEP]
ext i
[GOAL]
case h
α✝ : Type u
m n o✝ : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
α : Type u_4
o : ℕ
ho : o = m + n
u : Fin m → α
v : Fin n → α
i : Fin o
⊢ vecAppend ho u v i = if h : ↑i < m then u { val := ↑i, isLt := h } else v { val := ↑i - m, isLt := (_ : ↑i - m < n) }
[PROOFSTEP]
rw [vecAppend, Fin.append, Function.comp_apply, Fin.addCases]
[GOAL]
case h
α✝ : Type u
m n o✝ : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
α : Type u_4
o : ℕ
ho : o = m + n
u : Fin m → α
v : Fin n → α
i : Fin o
⊢ (if hi : ↑(↑(Fin.castIso ho) i) < m then
      (_ : Fin.castAdd n (Fin.castLT (↑(Fin.castIso ho) i) hi) = ↑(Fin.castIso ho) i) ▸
        u (Fin.castLT (↑(Fin.castIso ho) i) hi)
    else
      (_ :
          Fin.natAdd m
              (Fin.subNat m (Fin.cast (_ : m + n = n + m) (↑(Fin.castIso ho) i)) (_ : m ≤ ↑(↑(Fin.castIso ho) i))) =
            ↑(Fin.castIso ho) i) ▸
        v (Fin.subNat m (Fin.cast (_ : m + n = n + m) (↑(Fin.castIso ho) i)) (_ : m ≤ ↑(↑(Fin.castIso ho) i)))) =
    if h : ↑i < m then u { val := ↑i, isLt := h } else v { val := ↑i - m, isLt := (_ : ↑i - m < n) }
[PROOFSTEP]
congr with hi
[GOAL]
case h.e_e.h
α✝ : Type u
m n o✝ : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
α : Type u_4
o : ℕ
ho : o = m + n
u : Fin m → α
v : Fin n → α
i : Fin o
hi : ¬↑(↑(Fin.castIso ho) i) < m
⊢ (_ :
        Fin.natAdd m
            (Fin.subNat m (Fin.cast (_ : m + n = n + m) (↑(Fin.castIso ho) i)) (_ : m ≤ ↑(↑(Fin.castIso ho) i))) =
          ↑(Fin.castIso ho) i) ▸
      v (Fin.subNat m (Fin.cast (_ : m + n = n + m) (↑(Fin.castIso ho) i)) (_ : m ≤ ↑(↑(Fin.castIso ho) i))) =
    v { val := ↑i - m, isLt := (_ : ↑i - m < n) }
[PROOFSTEP]
simp only [eq_rec_constant]
[GOAL]
case h.e_e.h
α✝ : Type u
m n o✝ : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
α : Type u_4
o : ℕ
ho : o = m + n
u : Fin m → α
v : Fin n → α
i : Fin o
hi : ¬↑(↑(Fin.castIso ho) i) < m
⊢ v (Fin.subNat m (Fin.cast (_ : m + n = n + m) (↑(Fin.castIso ho) i)) (_ : m ≤ ↑(↑(Fin.castIso ho) i))) =
    v { val := ↑i - m, isLt := (_ : ↑i - m < n) }
[PROOFSTEP]
rfl
[GOAL]
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
⊢ vecAppend (_ : n = 0 + n) ![] v = v
[PROOFSTEP]
ext
[GOAL]
case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
x✝ : Fin n
⊢ vecAppend (_ : n = 0 + n) ![] v x✝ = v x✝
[PROOFSTEP]
simp [vecAppend_eq_ite]
[GOAL]
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
ho : o + 1 = m + 1 + n
x : α
u : Fin m → α
v : Fin n → α
⊢ o = m + n
[PROOFSTEP]
rwa [add_assoc, add_comm 1, ← add_assoc, add_right_cancel_iff] at ho
[GOAL]
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
ho : o + 1 = m + 1 + n
x : α
u : Fin m → α
v : Fin n → α
⊢ vecAppend ho (vecCons x u) v = vecCons x (vecAppend (_ : o = m + n) u v)
[PROOFSTEP]
ext i
[GOAL]
case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
ho : o + 1 = m + 1 + n
x : α
u : Fin m → α
v : Fin n → α
i : Fin (o + 1)
⊢ vecAppend ho (vecCons x u) v i = vecCons x (vecAppend (_ : o = m + n) u v) i
[PROOFSTEP]
simp_rw [vecAppend_eq_ite]
[GOAL]
case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
ho : o + 1 = m + 1 + n
x : α
u : Fin m → α
v : Fin n → α
i : Fin (o + 1)
⊢ (if h : ↑i < m + 1 then vecCons x u { val := ↑i, isLt := h }
    else v { val := ↑i - (m + 1), isLt := (_ : ↑i - (m + 1) < n) }) =
    vecCons x
      (fun i => if h : ↑i < m then u { val := ↑i, isLt := h } else v { val := ↑i - m, isLt := (_ : ↑i - m < n) }) i
[PROOFSTEP]
split_ifs with h
[GOAL]
case pos
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
ho : o + 1 = m + 1 + n
x : α
u : Fin m → α
v : Fin n → α
i : Fin (o + 1)
h : ↑i < m + 1
⊢ vecCons x u { val := ↑i, isLt := h } =
    vecCons x
      (fun i => if h : ↑i < m then u { val := ↑i, isLt := h } else v { val := ↑i - m, isLt := (_ : ↑i - m < n) }) i
[PROOFSTEP]
rcases i with ⟨⟨⟩ | i, hi⟩
[GOAL]
case pos.mk.zero
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
ho : o + 1 = m + 1 + n
x : α
u : Fin m → α
v : Fin n → α
hi : Nat.zero < o + 1
h : ↑{ val := Nat.zero, isLt := hi } < m + 1
⊢ vecCons x u { val := ↑{ val := Nat.zero, isLt := hi }, isLt := h } =
    vecCons x
      (fun i => if h : ↑i < m then u { val := ↑i, isLt := h } else v { val := ↑i - m, isLt := (_ : ↑i - m < n) })
      { val := Nat.zero, isLt := hi }
[PROOFSTEP]
simp
[GOAL]
case pos.mk.succ
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
ho : o + 1 = m + 1 + n
x : α
u : Fin m → α
v : Fin n → α
i : ℕ
hi : Nat.succ i < o + 1
h : ↑{ val := Nat.succ i, isLt := hi } < m + 1
⊢ vecCons x u { val := ↑{ val := Nat.succ i, isLt := hi }, isLt := h } =
    vecCons x
      (fun i => if h : ↑i < m then u { val := ↑i, isLt := h } else v { val := ↑i - m, isLt := (_ : ↑i - m < n) })
      { val := Nat.succ i, isLt := hi }
[PROOFSTEP]
simp only [Nat.succ_eq_add_one, add_lt_add_iff_right, Fin.val_mk] at h
[GOAL]
case pos.mk.succ
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
ho : o + 1 = m + 1 + n
x : α
u : Fin m → α
v : Fin n → α
i : ℕ
hi : Nat.succ i < o + 1
h✝ : ↑{ val := Nat.succ i, isLt := hi } < m + 1
h : i < m
⊢ vecCons x u { val := ↑{ val := Nat.succ i, isLt := hi }, isLt := h✝ } =
    vecCons x
      (fun i => if h : ↑i < m then u { val := ↑i, isLt := h } else v { val := ↑i - m, isLt := (_ : ↑i - m < n) })
      { val := Nat.succ i, isLt := hi }
[PROOFSTEP]
simp [h]
[GOAL]
case neg
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
ho : o + 1 = m + 1 + n
x : α
u : Fin m → α
v : Fin n → α
i : Fin (o + 1)
h : ¬↑i < m + 1
⊢ v { val := ↑i - (m + 1), isLt := (_ : ↑i - (m + 1) < n) } =
    vecCons x
      (fun i => if h : ↑i < m then u { val := ↑i, isLt := h } else v { val := ↑i - m, isLt := (_ : ↑i - m < n) }) i
[PROOFSTEP]
rcases i with ⟨⟨⟩ | i, hi⟩
[GOAL]
case neg.mk.zero
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
ho : o + 1 = m + 1 + n
x : α
u : Fin m → α
v : Fin n → α
hi : Nat.zero < o + 1
h : ¬↑{ val := Nat.zero, isLt := hi } < m + 1
⊢ v
      { val := ↑{ val := Nat.zero, isLt := hi } - (m + 1),
        isLt := (_ : ↑{ val := Nat.zero, isLt := hi } - (m + 1) < n) } =
    vecCons x
      (fun i => if h : ↑i < m then u { val := ↑i, isLt := h } else v { val := ↑i - m, isLt := (_ : ↑i - m < n) })
      { val := Nat.zero, isLt := hi }
[PROOFSTEP]
simp at h
[GOAL]
case neg.mk.succ
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
ho : o + 1 = m + 1 + n
x : α
u : Fin m → α
v : Fin n → α
i : ℕ
hi : Nat.succ i < o + 1
h : ¬↑{ val := Nat.succ i, isLt := hi } < m + 1
⊢ v
      { val := ↑{ val := Nat.succ i, isLt := hi } - (m + 1),
        isLt := (_ : ↑{ val := Nat.succ i, isLt := hi } - (m + 1) < n) } =
    vecCons x
      (fun i => if h : ↑i < m then u { val := ↑i, isLt := h } else v { val := ↑i - m, isLt := (_ : ↑i - m < n) })
      { val := Nat.succ i, isLt := hi }
[PROOFSTEP]
rw [not_lt, Fin.val_mk, Nat.succ_eq_add_one, add_le_add_iff_right] at h
[GOAL]
case neg.mk.succ
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
ho : o + 1 = m + 1 + n
x : α
u : Fin m → α
v : Fin n → α
i : ℕ
hi : Nat.succ i < o + 1
h✝ : ¬↑{ val := Nat.succ i, isLt := hi } < m + 1
h : m ≤ i
⊢ v
      { val := ↑{ val := Nat.succ i, isLt := hi } - (m + 1),
        isLt := (_ : ↑{ val := Nat.succ i, isLt := hi } - (m + 1) < n) } =
    vecCons x
      (fun i => if h : ↑i < m then u { val := ↑i, isLt := h } else v { val := ↑i - m, isLt := (_ : ↑i - m < n) })
      { val := Nat.succ i, isLt := hi }
[PROOFSTEP]
simp [h, not_lt.2 h]
[GOAL]
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
⊢ vecAlt0 (_ : n + n = n + n) (vecAppend (_ : n + n = n + n) v v) = v ∘ bit0
[PROOFSTEP]
ext i
[GOAL]
case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
i : Fin n
⊢ vecAlt0 (_ : n + n = n + n) (vecAppend (_ : n + n = n + n) v v) i = (v ∘ bit0) i
[PROOFSTEP]
simp_rw [Function.comp, bit0, vecAlt0, vecAppend_eq_ite]
[GOAL]
case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
i : Fin n
⊢ (if h : ↑i + ↑i < n then v { val := ↑i + ↑i, isLt := (_ : ↑{ val := ↑i + ↑i, isLt := (_ : ↑i + ↑i < n + n) } < n) }
    else v { val := ↑i + ↑i - n, isLt := (_ : ↑{ val := ↑i + ↑i, isLt := (_ : ↑i + ↑i < n + n) } - n < n) }) =
    v (i + i)
[PROOFSTEP]
split_ifs with h
[GOAL]
case pos
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
i : Fin n
h : ↑i + ↑i < n
⊢ v { val := ↑i + ↑i, isLt := (_ : ↑{ val := ↑i + ↑i, isLt := (_ : ↑i + ↑i < n + n) } < n) } = v (i + i)
[PROOFSTEP]
congr
[GOAL]
case neg
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
i : Fin n
h : ¬↑i + ↑i < n
⊢ v { val := ↑i + ↑i - n, isLt := (_ : ↑{ val := ↑i + ↑i, isLt := (_ : ↑i + ↑i < n + n) } - n < n) } = v (i + i)
[PROOFSTEP]
congr
[GOAL]
case pos.e_a.e_val
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
i : Fin n
h : ↑i + ↑i < n
⊢ ↑i + ↑i = (↑i + ↑i) % n
[PROOFSTEP]
rw [Fin.val_mk] at h
[GOAL]
case pos.e_a.e_val
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
i : Fin n
h : ↑i + ↑i < n
⊢ ↑i + ↑i = (↑i + ↑i) % n
[PROOFSTEP]
exact (Nat.mod_eq_of_lt h).symm
[GOAL]
case neg.e_a.e_val
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
i : Fin n
h : ¬↑i + ↑i < n
⊢ ↑i + ↑i - n = (↑i + ↑i) % n
[PROOFSTEP]
rw [Fin.val_mk, not_lt] at h
[GOAL]
case neg.e_a.e_val
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
i : Fin n
h : n ≤ ↑i + ↑i
⊢ ↑i + ↑i - n = (↑i + ↑i) % n
[PROOFSTEP]
simp only [Fin.ext_iff, Fin.val_add, Fin.val_mk, Nat.mod_eq_sub_mod h]
[GOAL]
case neg.e_a.e_val
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
i : Fin n
h : n ≤ ↑i + ↑i
⊢ ↑i + ↑i - n = (↑i + ↑i - n) % n
[PROOFSTEP]
refine' (Nat.mod_eq_of_lt _).symm
[GOAL]
case neg.e_a.e_val
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
i : Fin n
h : n ≤ ↑i + ↑i
⊢ ↑i + ↑i - n < n
[PROOFSTEP]
rw [tsub_lt_iff_left h]
[GOAL]
case neg.e_a.e_val
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
i : Fin n
h : n ≤ ↑i + ↑i
⊢ ↑i + ↑i < n + n
[PROOFSTEP]
exact add_lt_add i.2 i.2
[GOAL]
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin (n + 1) → α
⊢ vecAlt1 (_ : n + 1 + (n + 1) = n + 1 + (n + 1)) (vecAppend (_ : n + 1 + (n + 1) = n + 1 + (n + 1)) v v) = v ∘ bit1
[PROOFSTEP]
ext i
[GOAL]
case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin (n + 1) → α
i : Fin (n + 1)
⊢ vecAlt1 (_ : n + 1 + (n + 1) = n + 1 + (n + 1)) (vecAppend (_ : n + 1 + (n + 1) = n + 1 + (n + 1)) v v) i =
    (v ∘ bit1) i
[PROOFSTEP]
simp_rw [Function.comp, vecAlt1, vecAppend_eq_ite]
[GOAL]
case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin (n + 1) → α
i : Fin (n + 1)
⊢ (if h : ↑i + ↑i + 1 < n + 1 then
      v
        { val := ↑i + ↑i + 1,
          isLt := (_ : ↑{ val := ↑i + ↑i + 1, isLt := (_ : ↑i + ↑i + 1 < n + 1 + (n + 1)) } < n + 1) }
    else
      v
        { val := ↑i + ↑i + 1 - (n + 1),
          isLt := (_ : ↑{ val := ↑i + ↑i + 1, isLt := (_ : ↑i + ↑i + 1 < n + 1 + (n + 1)) } - (n + 1) < n + 1) }) =
    v (bit1 i)
[PROOFSTEP]
cases n with
| zero =>
  cases' i with i hi
  simp only [Nat.zero_eq, zero_add, Nat.lt_one_iff] at hi ; subst i; rfl
| succ n =>
  split_ifs with h <;> simp_rw [bit1, bit0] <;> congr
  · rw [Fin.val_mk] at h
    rw [Nat.mod_eq_of_lt (Nat.lt_of_succ_lt h)]
    erw [Nat.mod_eq_of_lt h]
  · rw [Fin.val_mk, not_lt] at h
    simp only [Fin.ext_iff, Fin.val_add, Fin.val_mk, Nat.mod_add_mod, Fin.val_one, Nat.mod_eq_sub_mod h,
      show 1 % (n + 2) = 1 from Nat.mod_eq_of_lt (by simp)]
    refine (Nat.mod_eq_of_lt ?_).symm
    rw [tsub_lt_iff_left h]
    exact Nat.add_succ_lt_add i.2 i.2
[GOAL]
case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin (n + 1) → α
i : Fin (n + 1)
⊢ (if h : ↑i + ↑i + 1 < n + 1 then
      v
        { val := ↑i + ↑i + 1,
          isLt := (_ : ↑{ val := ↑i + ↑i + 1, isLt := (_ : ↑i + ↑i + 1 < n + 1 + (n + 1)) } < n + 1) }
    else
      v
        { val := ↑i + ↑i + 1 - (n + 1),
          isLt := (_ : ↑{ val := ↑i + ↑i + 1, isLt := (_ : ↑i + ↑i + 1 < n + 1 + (n + 1)) } - (n + 1) < n + 1) }) =
    v (bit1 i)
[PROOFSTEP]
cases n with
| zero =>
  cases' i with i hi
  simp only [Nat.zero_eq, zero_add, Nat.lt_one_iff] at hi ; subst i; rfl
| succ n =>
  split_ifs with h <;> simp_rw [bit1, bit0] <;> congr
  · rw [Fin.val_mk] at h
    rw [Nat.mod_eq_of_lt (Nat.lt_of_succ_lt h)]
    erw [Nat.mod_eq_of_lt h]
  · rw [Fin.val_mk, not_lt] at h
    simp only [Fin.ext_iff, Fin.val_add, Fin.val_mk, Nat.mod_add_mod, Fin.val_one, Nat.mod_eq_sub_mod h,
      show 1 % (n + 2) = 1 from Nat.mod_eq_of_lt (by simp)]
    refine (Nat.mod_eq_of_lt ?_).symm
    rw [tsub_lt_iff_left h]
    exact Nat.add_succ_lt_add i.2 i.2
[GOAL]
case h.zero
α : Type u
m o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin (Nat.zero + 1) → α
i : Fin (Nat.zero + 1)
⊢ (if h : ↑i + ↑i + 1 < Nat.zero + 1 then
      v
        { val := ↑i + ↑i + 1,
          isLt :=
            (_ : ↑{ val := ↑i + ↑i + 1, isLt := (_ : ↑i + ↑i + 1 < Nat.zero + 1 + (Nat.zero + 1)) } < Nat.zero + 1) }
    else
      v
        { val := ↑i + ↑i + 1 - (Nat.zero + 1),
          isLt :=
            (_ :
              ↑{ val := ↑i + ↑i + 1, isLt := (_ : ↑i + ↑i + 1 < Nat.zero + 1 + (Nat.zero + 1)) } - (Nat.zero + 1) <
                Nat.zero + 1) }) =
    v (bit1 i)
[PROOFSTEP]

| zero =>
  cases' i with i hi
  simp only [Nat.zero_eq, zero_add, Nat.lt_one_iff] at hi ; subst i; rfl
[GOAL]
case h.zero
α : Type u
m o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin (Nat.zero + 1) → α
i : Fin (Nat.zero + 1)
⊢ (if h : ↑i + ↑i + 1 < Nat.zero + 1 then
      v
        { val := ↑i + ↑i + 1,
          isLt :=
            (_ : ↑{ val := ↑i + ↑i + 1, isLt := (_ : ↑i + ↑i + 1 < Nat.zero + 1 + (Nat.zero + 1)) } < Nat.zero + 1) }
    else
      v
        { val := ↑i + ↑i + 1 - (Nat.zero + 1),
          isLt :=
            (_ :
              ↑{ val := ↑i + ↑i + 1, isLt := (_ : ↑i + ↑i + 1 < Nat.zero + 1 + (Nat.zero + 1)) } - (Nat.zero + 1) <
                Nat.zero + 1) }) =
    v (bit1 i)
[PROOFSTEP]
cases' i with i hi
[GOAL]
case h.zero.mk
α : Type u
m o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin (Nat.zero + 1) → α
i : ℕ
hi : i < Nat.zero + 1
⊢ (if h : ↑{ val := i, isLt := hi } + ↑{ val := i, isLt := hi } + 1 < Nat.zero + 1 then
      v
        { val := ↑{ val := i, isLt := hi } + ↑{ val := i, isLt := hi } + 1,
          isLt :=
            (_ :
              ↑{ val := ↑{ val := i, isLt := hi } + ↑{ val := i, isLt := hi } + 1,
                    isLt :=
                      (_ :
                        ↑{ val := i, isLt := hi } + ↑{ val := i, isLt := hi } + 1 < Nat.zero + 1 + (Nat.zero + 1)) } <
                Nat.zero + 1) }
    else
      v
        { val := ↑{ val := i, isLt := hi } + ↑{ val := i, isLt := hi } + 1 - (Nat.zero + 1),
          isLt :=
            (_ :
              ↑{ val := ↑{ val := i, isLt := hi } + ↑{ val := i, isLt := hi } + 1,
                      isLt :=
                        (_ :
                          ↑{ val := i, isLt := hi } + ↑{ val := i, isLt := hi } + 1 < Nat.zero + 1 + (Nat.zero + 1)) } -
                  (Nat.zero + 1) <
                Nat.zero + 1) }) =
    v (bit1 { val := i, isLt := hi })
[PROOFSTEP]
simp only [Nat.zero_eq, zero_add, Nat.lt_one_iff] at hi
[GOAL]
case h.zero.mk
α : Type u
m o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin (Nat.zero + 1) → α
i : ℕ
hi✝ : i < Nat.zero + 1
hi : i = 0
⊢ (if h : ↑{ val := i, isLt := hi✝ } + ↑{ val := i, isLt := hi✝ } + 1 < Nat.zero + 1 then
      v
        { val := ↑{ val := i, isLt := hi✝ } + ↑{ val := i, isLt := hi✝ } + 1,
          isLt :=
            (_ :
              ↑{ val := ↑{ val := i, isLt := hi✝ } + ↑{ val := i, isLt := hi✝ } + 1,
                    isLt :=
                      (_ :
                        ↑{ val := i, isLt := hi✝ } + ↑{ val := i, isLt := hi✝ } + 1 < Nat.zero + 1 + (Nat.zero + 1)) } <
                Nat.zero + 1) }
    else
      v
        { val := ↑{ val := i, isLt := hi✝ } + ↑{ val := i, isLt := hi✝ } + 1 - (Nat.zero + 1),
          isLt :=
            (_ :
              ↑{ val := ↑{ val := i, isLt := hi✝ } + ↑{ val := i, isLt := hi✝ } + 1,
                      isLt :=
                        (_ :
                          ↑{ val := i, isLt := hi✝ } + ↑{ val := i, isLt := hi✝ } + 1 <
                            Nat.zero + 1 + (Nat.zero + 1)) } -
                  (Nat.zero + 1) <
                Nat.zero + 1) }) =
    v (bit1 { val := i, isLt := hi✝ })
[PROOFSTEP]
subst i
[GOAL]
case h.zero.mk
α : Type u
m o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin (Nat.zero + 1) → α
hi : 0 < Nat.zero + 1
⊢ (if h : ↑{ val := 0, isLt := hi } + ↑{ val := 0, isLt := hi } + 1 < Nat.zero + 1 then
      v
        { val := ↑{ val := 0, isLt := hi } + ↑{ val := 0, isLt := hi } + 1,
          isLt :=
            (_ :
              ↑{ val := ↑{ val := 0, isLt := hi } + ↑{ val := 0, isLt := hi } + 1,
                    isLt :=
                      (_ :
                        ↑{ val := 0, isLt := hi } + ↑{ val := 0, isLt := hi } + 1 < Nat.zero + 1 + (Nat.zero + 1)) } <
                Nat.zero + 1) }
    else
      v
        { val := ↑{ val := 0, isLt := hi } + ↑{ val := 0, isLt := hi } + 1 - (Nat.zero + 1),
          isLt :=
            (_ :
              ↑{ val := ↑{ val := 0, isLt := hi } + ↑{ val := 0, isLt := hi } + 1,
                      isLt :=
                        (_ :
                          ↑{ val := 0, isLt := hi } + ↑{ val := 0, isLt := hi } + 1 < Nat.zero + 1 + (Nat.zero + 1)) } -
                  (Nat.zero + 1) <
                Nat.zero + 1) }) =
    v (bit1 { val := 0, isLt := hi })
[PROOFSTEP]
rfl
[GOAL]
case h.succ
α : Type u
m o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
n : ℕ
v : Fin (Nat.succ n + 1) → α
i : Fin (Nat.succ n + 1)
⊢ (if h : ↑i + ↑i + 1 < Nat.succ n + 1 then
      v
        { val := ↑i + ↑i + 1,
          isLt :=
            (_ :
              ↑{ val := ↑i + ↑i + 1, isLt := (_ : ↑i + ↑i + 1 < Nat.succ n + 1 + (Nat.succ n + 1)) } < Nat.succ n + 1) }
    else
      v
        { val := ↑i + ↑i + 1 - (Nat.succ n + 1),
          isLt :=
            (_ :
              ↑{ val := ↑i + ↑i + 1, isLt := (_ : ↑i + ↑i + 1 < Nat.succ n + 1 + (Nat.succ n + 1)) } -
                  (Nat.succ n + 1) <
                Nat.succ n + 1) }) =
    v (bit1 i)
[PROOFSTEP]

| succ n =>
  split_ifs with h <;> simp_rw [bit1, bit0] <;> congr
  · rw [Fin.val_mk] at h
    rw [Nat.mod_eq_of_lt (Nat.lt_of_succ_lt h)]
    erw [Nat.mod_eq_of_lt h]
  · rw [Fin.val_mk, not_lt] at h
    simp only [Fin.ext_iff, Fin.val_add, Fin.val_mk, Nat.mod_add_mod, Fin.val_one, Nat.mod_eq_sub_mod h,
      show 1 % (n + 2) = 1 from Nat.mod_eq_of_lt (by simp)]
    refine (Nat.mod_eq_of_lt ?_).symm
    rw [tsub_lt_iff_left h]
    exact Nat.add_succ_lt_add i.2 i.2
[GOAL]
case h.succ
α : Type u
m o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
n : ℕ
v : Fin (Nat.succ n + 1) → α
i : Fin (Nat.succ n + 1)
⊢ (if h : ↑i + ↑i + 1 < Nat.succ n + 1 then
      v
        { val := ↑i + ↑i + 1,
          isLt :=
            (_ :
              ↑{ val := ↑i + ↑i + 1, isLt := (_ : ↑i + ↑i + 1 < Nat.succ n + 1 + (Nat.succ n + 1)) } < Nat.succ n + 1) }
    else
      v
        { val := ↑i + ↑i + 1 - (Nat.succ n + 1),
          isLt :=
            (_ :
              ↑{ val := ↑i + ↑i + 1, isLt := (_ : ↑i + ↑i + 1 < Nat.succ n + 1 + (Nat.succ n + 1)) } -
                  (Nat.succ n + 1) <
                Nat.succ n + 1) }) =
    v (bit1 i)
[PROOFSTEP]
split_ifs with h
[GOAL]
case pos
α : Type u
m o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
n : ℕ
v : Fin (Nat.succ n + 1) → α
i : Fin (Nat.succ n + 1)
h : ↑i + ↑i + 1 < Nat.succ n + 1
⊢ v
      { val := ↑i + ↑i + 1,
        isLt :=
          (_ :
            ↑{ val := ↑i + ↑i + 1, isLt := (_ : ↑i + ↑i + 1 < Nat.succ n + 1 + (Nat.succ n + 1)) } < Nat.succ n + 1) } =
    v (bit1 i)
[PROOFSTEP]
simp_rw [bit1, bit0]
[GOAL]
case neg
α : Type u
m o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
n : ℕ
v : Fin (Nat.succ n + 1) → α
i : Fin (Nat.succ n + 1)
h : ¬↑i + ↑i + 1 < Nat.succ n + 1
⊢ v
      { val := ↑i + ↑i + 1 - (Nat.succ n + 1),
        isLt :=
          (_ :
            ↑{ val := ↑i + ↑i + 1, isLt := (_ : ↑i + ↑i + 1 < Nat.succ n + 1 + (Nat.succ n + 1)) } - (Nat.succ n + 1) <
              Nat.succ n + 1) } =
    v (bit1 i)
[PROOFSTEP]
simp_rw [bit1, bit0]
[GOAL]
case pos
α : Type u
m o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
n : ℕ
v : Fin (Nat.succ n + 1) → α
i : Fin (Nat.succ n + 1)
h : ↑i + ↑i + 1 < Nat.succ n + 1
⊢ v
      { val := ↑i + ↑i + 1,
        isLt :=
          (_ :
            ↑{ val := ↑i + ↑i + 1, isLt := (_ : ↑i + ↑i + 1 < Nat.succ n + 1 + (Nat.succ n + 1)) } < Nat.succ n + 1) } =
    v (i + i + 1)
[PROOFSTEP]
congr
[GOAL]
case neg
α : Type u
m o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
n : ℕ
v : Fin (Nat.succ n + 1) → α
i : Fin (Nat.succ n + 1)
h : ¬↑i + ↑i + 1 < Nat.succ n + 1
⊢ v
      { val := ↑i + ↑i + 1 - (Nat.succ n + 1),
        isLt :=
          (_ :
            ↑{ val := ↑i + ↑i + 1, isLt := (_ : ↑i + ↑i + 1 < Nat.succ n + 1 + (Nat.succ n + 1)) } - (Nat.succ n + 1) <
              Nat.succ n + 1) } =
    v (i + i + 1)
[PROOFSTEP]
congr
[GOAL]
case pos.e_a.e_val
α : Type u
m o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
n : ℕ
v : Fin (Nat.succ n + 1) → α
i : Fin (Nat.succ n + 1)
h : ↑i + ↑i + 1 < Nat.succ n + 1
⊢ ↑i + ↑i + 1 = ((↑i + ↑i) % (Nat.succ n + 1) + 1 % (Nat.succ n + 1)) % (Nat.succ n + 1)
[PROOFSTEP]
rw [Fin.val_mk] at h
[GOAL]
case pos.e_a.e_val
α : Type u
m o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
n : ℕ
v : Fin (Nat.succ n + 1) → α
i : Fin (Nat.succ n + 1)
h : ↑i + ↑i + 1 < Nat.succ n + 1
⊢ ↑i + ↑i + 1 = ((↑i + ↑i) % (Nat.succ n + 1) + 1 % (Nat.succ n + 1)) % (Nat.succ n + 1)
[PROOFSTEP]
rw [Nat.mod_eq_of_lt (Nat.lt_of_succ_lt h)]
[GOAL]
case pos.e_a.e_val
α : Type u
m o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
n : ℕ
v : Fin (Nat.succ n + 1) → α
i : Fin (Nat.succ n + 1)
h : ↑i + ↑i + 1 < Nat.succ n + 1
⊢ ↑i + ↑i + 1 = (↑i + ↑i + 1 % (Nat.succ n + 1)) % (Nat.succ n + 1)
[PROOFSTEP]
erw [Nat.mod_eq_of_lt h]
[GOAL]
case neg.e_a.e_val
α : Type u
m o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
n : ℕ
v : Fin (Nat.succ n + 1) → α
i : Fin (Nat.succ n + 1)
h : ¬↑i + ↑i + 1 < Nat.succ n + 1
⊢ ↑i + ↑i + 1 - (Nat.succ n + 1) = ((↑i + ↑i) % (Nat.succ n + 1) + 1 % (Nat.succ n + 1)) % (Nat.succ n + 1)
[PROOFSTEP]
rw [Fin.val_mk, not_lt] at h
[GOAL]
case neg.e_a.e_val
α : Type u
m o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
n : ℕ
v : Fin (Nat.succ n + 1) → α
i : Fin (Nat.succ n + 1)
h : Nat.succ n + 1 ≤ ↑i + ↑i + 1
⊢ ↑i + ↑i + 1 - (Nat.succ n + 1) = ((↑i + ↑i) % (Nat.succ n + 1) + 1 % (Nat.succ n + 1)) % (Nat.succ n + 1)
[PROOFSTEP]
simp only [Fin.ext_iff, Fin.val_add, Fin.val_mk, Nat.mod_add_mod, Fin.val_one, Nat.mod_eq_sub_mod h,
  show 1 % (n + 2) = 1 from Nat.mod_eq_of_lt (by simp)]
[GOAL]
α : Type u
m o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
n : ℕ
v : Fin (Nat.succ n + 1) → α
i : Fin (Nat.succ n + 1)
h : Nat.succ n + 1 ≤ ↑i + ↑i + 1
⊢ 1 < n + 2
[PROOFSTEP]
simp
[GOAL]
case neg.e_a.e_val
α : Type u
m o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
n : ℕ
v : Fin (Nat.succ n + 1) → α
i : Fin (Nat.succ n + 1)
h : Nat.succ n + 1 ≤ ↑i + ↑i + 1
⊢ ↑i + ↑i + 1 - (Nat.succ n + 1) = (↑i + ↑i + 1 - (Nat.succ n + 1)) % (Nat.succ n + 1)
[PROOFSTEP]
refine (Nat.mod_eq_of_lt ?_).symm
[GOAL]
case neg.e_a.e_val
α : Type u
m o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
n : ℕ
v : Fin (Nat.succ n + 1) → α
i : Fin (Nat.succ n + 1)
h : Nat.succ n + 1 ≤ ↑i + ↑i + 1
⊢ ↑i + ↑i + 1 - (Nat.succ n + 1) < Nat.succ n + 1
[PROOFSTEP]
rw [tsub_lt_iff_left h]
[GOAL]
case neg.e_a.e_val
α : Type u
m o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
n : ℕ
v : Fin (Nat.succ n + 1) → α
i : Fin (Nat.succ n + 1)
h : Nat.succ n + 1 ≤ ↑i + ↑i + 1
⊢ ↑i + ↑i + 1 < Nat.succ n + 1 + (Nat.succ n + 1)
[PROOFSTEP]
exact Nat.add_succ_lt_add i.2 i.2
[GOAL]
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
hm : m + 2 = n + 1 + (n + 1)
v : Fin (m + 2) → α
⊢ vecHead (vecAlt1 hm v) = v 1
[PROOFSTEP]
simp [vecHead, vecAlt1]
[GOAL]
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
x : α
u : Fin n → α
i : Fin (n + 1)
⊢ vecCons x u (bit0 i) =
    vecAlt0 (_ : Nat.succ n + Nat.succ n = Nat.succ n + Nat.succ n)
      (vecAppend (_ : Nat.succ n + Nat.succ n = Nat.succ n + Nat.succ n) (vecCons x u) (vecCons x u)) i
[PROOFSTEP]
rw [vecAlt0_vecAppend]
[GOAL]
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
x : α
u : Fin n → α
i : Fin (n + 1)
⊢ vecCons x u (bit0 i) = (vecCons x u ∘ bit0) i
[PROOFSTEP]
rfl
[GOAL]
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
x : α
u : Fin n → α
i : Fin (n + 1)
⊢ vecCons x u (bit1 i) =
    vecAlt1 (_ : Nat.succ n + Nat.succ n = Nat.succ n + Nat.succ n)
      (vecAppend (_ : Nat.succ n + Nat.succ n = Nat.succ n + Nat.succ n) (vecCons x u) (vecCons x u)) i
[PROOFSTEP]
rw [vecAlt1_vecAppend]
[GOAL]
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
x : α
u : Fin n → α
i : Fin (n + 1)
⊢ vecCons x u (bit1 i) = (vecCons x u ∘ bit1) i
[PROOFSTEP]
rfl
[GOAL]
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
h : m + 1 + 1 = n + 1 + (n + 1)
x y : α
u : Fin m → α
⊢ m = n + n
[PROOFSTEP]
rwa [add_assoc n, add_comm 1, ← add_assoc, ← add_assoc, add_right_cancel_iff, add_right_cancel_iff] at h
[GOAL]
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
h : m + 1 + 1 = n + 1 + (n + 1)
x y : α
u : Fin m → α
⊢ vecAlt0 h (vecCons x (vecCons y u)) = vecCons x (vecAlt0 (_ : m = n + n) u)
[PROOFSTEP]
ext i
[GOAL]
case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
h : m + 1 + 1 = n + 1 + (n + 1)
x y : α
u : Fin m → α
i : Fin (n + 1)
⊢ vecAlt0 h (vecCons x (vecCons y u)) i = vecCons x (vecAlt0 (_ : m = n + n) u) i
[PROOFSTEP]
simp_rw [vecAlt0]
[GOAL]
case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
h : m + 1 + 1 = n + 1 + (n + 1)
x y : α
u : Fin m → α
i : Fin (n + 1)
⊢ vecCons x (vecCons y u) { val := ↑i + ↑i, isLt := (_ : ↑i + ↑i < m + 1 + 1) } =
    vecCons x (fun k => u { val := ↑k + ↑k, isLt := (_ : ↑k + ↑k < m) }) i
[PROOFSTEP]
rcases i with ⟨⟨⟩ | i, hi⟩
[GOAL]
case h.mk.zero
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
h : m + 1 + 1 = n + 1 + (n + 1)
x y : α
u : Fin m → α
hi : Nat.zero < n + 1
⊢ vecCons x (vecCons y u)
      { val := ↑{ val := Nat.zero, isLt := hi } + ↑{ val := Nat.zero, isLt := hi },
        isLt := (_ : ↑{ val := Nat.zero, isLt := hi } + ↑{ val := Nat.zero, isLt := hi } < m + 1 + 1) } =
    vecCons x (fun k => u { val := ↑k + ↑k, isLt := (_ : ↑k + ↑k < m) }) { val := Nat.zero, isLt := hi }
[PROOFSTEP]
rfl
[GOAL]
case h.mk.succ
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
h : m + 1 + 1 = n + 1 + (n + 1)
x y : α
u : Fin m → α
i : ℕ
hi : Nat.succ i < n + 1
⊢ vecCons x (vecCons y u)
      { val := ↑{ val := Nat.succ i, isLt := hi } + ↑{ val := Nat.succ i, isLt := hi },
        isLt := (_ : ↑{ val := Nat.succ i, isLt := hi } + ↑{ val := Nat.succ i, isLt := hi } < m + 1 + 1) } =
    vecCons x (fun k => u { val := ↑k + ↑k, isLt := (_ : ↑k + ↑k < m) }) { val := Nat.succ i, isLt := hi }
[PROOFSTEP]
simp [vecAlt0, Nat.add_succ, Nat.succ_add]
[GOAL]
α✝ : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
α : Type u_4
h : 0 = 0 + 0
⊢ vecAlt0 h ![] = ![]
[PROOFSTEP]
simp
[GOAL]
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
h : m + 1 + 1 = n + 1 + (n + 1)
x y : α
u : Fin m → α
⊢ m = n + n
[PROOFSTEP]
rwa [add_assoc n, add_comm 1, ← add_assoc, ← add_assoc, add_right_cancel_iff, add_right_cancel_iff] at h
[GOAL]
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
h : m + 1 + 1 = n + 1 + (n + 1)
x y : α
u : Fin m → α
⊢ vecAlt1 h (vecCons x (vecCons y u)) = vecCons y (vecAlt1 (_ : m = n + n) u)
[PROOFSTEP]
ext i
[GOAL]
case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
h : m + 1 + 1 = n + 1 + (n + 1)
x y : α
u : Fin m → α
i : Fin (n + 1)
⊢ vecAlt1 h (vecCons x (vecCons y u)) i = vecCons y (vecAlt1 (_ : m = n + n) u) i
[PROOFSTEP]
simp_rw [vecAlt1]
[GOAL]
case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
h : m + 1 + 1 = n + 1 + (n + 1)
x y : α
u : Fin m → α
i : Fin (n + 1)
⊢ vecCons x (vecCons y u) { val := ↑i + ↑i + 1, isLt := (_ : ↑i + ↑i + 1 < m + 1 + 1) } =
    vecCons y (fun k => u { val := ↑k + ↑k + 1, isLt := (_ : ↑k + ↑k + 1 < m) }) i
[PROOFSTEP]
rcases i with ⟨⟨⟩ | i, hi⟩
[GOAL]
case h.mk.zero
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
h : m + 1 + 1 = n + 1 + (n + 1)
x y : α
u : Fin m → α
hi : Nat.zero < n + 1
⊢ vecCons x (vecCons y u)
      { val := ↑{ val := Nat.zero, isLt := hi } + ↑{ val := Nat.zero, isLt := hi } + 1,
        isLt := (_ : ↑{ val := Nat.zero, isLt := hi } + ↑{ val := Nat.zero, isLt := hi } + 1 < m + 1 + 1) } =
    vecCons y (fun k => u { val := ↑k + ↑k + 1, isLt := (_ : ↑k + ↑k + 1 < m) }) { val := Nat.zero, isLt := hi }
[PROOFSTEP]
rfl
[GOAL]
case h.mk.succ
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
h : m + 1 + 1 = n + 1 + (n + 1)
x y : α
u : Fin m → α
i : ℕ
hi : Nat.succ i < n + 1
⊢ vecCons x (vecCons y u)
      { val := ↑{ val := Nat.succ i, isLt := hi } + ↑{ val := Nat.succ i, isLt := hi } + 1,
        isLt := (_ : ↑{ val := Nat.succ i, isLt := hi } + ↑{ val := Nat.succ i, isLt := hi } + 1 < m + 1 + 1) } =
    vecCons y (fun k => u { val := ↑k + ↑k + 1, isLt := (_ : ↑k + ↑k + 1 < m) }) { val := Nat.succ i, isLt := hi }
[PROOFSTEP]
simp [vecAlt1, Nat.add_succ, Nat.succ_add]
[GOAL]
α✝ : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
α : Type u_4
h : 0 = 0 + 0
⊢ vecAlt1 h ![] = ![]
[PROOFSTEP]
simp
[GOAL]
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
M : Type u_4
inst✝ : SMul M α
x : M
y : α
v : Fin n → α
⊢ x • vecCons y v = vecCons (x • y) (x • v)
[PROOFSTEP]
ext i
[GOAL]
case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
M : Type u_4
inst✝ : SMul M α
x : M
y : α
v : Fin n → α
i : Fin (Nat.succ n)
⊢ (x • vecCons y v) i = vecCons (x • y) (x • v) i
[PROOFSTEP]
refine' Fin.cases _ _ i
[GOAL]
case h.refine'_1
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
M : Type u_4
inst✝ : SMul M α
x : M
y : α
v : Fin n → α
i : Fin (Nat.succ n)
⊢ (x • vecCons y v) 0 = vecCons (x • y) (x • v) 0
[PROOFSTEP]
simp
[GOAL]
case h.refine'_2
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
M : Type u_4
inst✝ : SMul M α
x : M
y : α
v : Fin n → α
i : Fin (Nat.succ n)
⊢ ∀ (i : Fin n), (x • vecCons y v) (Fin.succ i) = vecCons (x • y) (x • v) (Fin.succ i)
[PROOFSTEP]
simp
[GOAL]
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
inst✝ : Add α
x : α
v : Fin n → α
w : Fin (Nat.succ n) → α
⊢ vecCons x v + w = vecCons (x + vecHead w) (v + vecTail w)
[PROOFSTEP]
ext i
[GOAL]
case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
inst✝ : Add α
x : α
v : Fin n → α
w : Fin (Nat.succ n) → α
i : Fin (Nat.succ n)
⊢ (vecCons x v + w) i = vecCons (x + vecHead w) (v + vecTail w) i
[PROOFSTEP]
refine' Fin.cases _ _ i
[GOAL]
case h.refine'_1
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
inst✝ : Add α
x : α
v : Fin n → α
w : Fin (Nat.succ n) → α
i : Fin (Nat.succ n)
⊢ (vecCons x v + w) 0 = vecCons (x + vecHead w) (v + vecTail w) 0
[PROOFSTEP]
simp [vecHead, vecTail]
[GOAL]
case h.refine'_2
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
inst✝ : Add α
x : α
v : Fin n → α
w : Fin (Nat.succ n) → α
i : Fin (Nat.succ n)
⊢ ∀ (i : Fin n), (vecCons x v + w) (Fin.succ i) = vecCons (x + vecHead w) (v + vecTail w) (Fin.succ i)
[PROOFSTEP]
simp [vecHead, vecTail]
[GOAL]
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
inst✝ : Add α
v : Fin (Nat.succ n) → α
y : α
w : Fin n → α
⊢ v + vecCons y w = vecCons (vecHead v + y) (vecTail v + w)
[PROOFSTEP]
ext i
[GOAL]
case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
inst✝ : Add α
v : Fin (Nat.succ n) → α
y : α
w : Fin n → α
i : Fin (Nat.succ n)
⊢ (v + vecCons y w) i = vecCons (vecHead v + y) (vecTail v + w) i
[PROOFSTEP]
refine' Fin.cases _ _ i
[GOAL]
case h.refine'_1
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
inst✝ : Add α
v : Fin (Nat.succ n) → α
y : α
w : Fin n → α
i : Fin (Nat.succ n)
⊢ (v + vecCons y w) 0 = vecCons (vecHead v + y) (vecTail v + w) 0
[PROOFSTEP]
simp [vecHead, vecTail]
[GOAL]
case h.refine'_2
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
inst✝ : Add α
v : Fin (Nat.succ n) → α
y : α
w : Fin n → α
i : Fin (Nat.succ n)
⊢ ∀ (i : Fin n), (v + vecCons y w) (Fin.succ i) = vecCons (vecHead v + y) (vecTail v + w) (Fin.succ i)
[PROOFSTEP]
simp [vecHead, vecTail]
[GOAL]
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
inst✝ : Add α
x : α
v : Fin n → α
y : α
w : Fin n → α
⊢ vecCons x v + vecCons y w = vecCons (x + y) (v + w)
[PROOFSTEP]
simp
[GOAL]
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
inst✝ : Sub α
x : α
v : Fin n → α
w : Fin (Nat.succ n) → α
⊢ vecCons x v - w = vecCons (x - vecHead w) (v - vecTail w)
[PROOFSTEP]
ext i
[GOAL]
case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
inst✝ : Sub α
x : α
v : Fin n → α
w : Fin (Nat.succ n) → α
i : Fin (Nat.succ n)
⊢ (vecCons x v - w) i = vecCons (x - vecHead w) (v - vecTail w) i
[PROOFSTEP]
refine' Fin.cases _ _ i
[GOAL]
case h.refine'_1
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
inst✝ : Sub α
x : α
v : Fin n → α
w : Fin (Nat.succ n) → α
i : Fin (Nat.succ n)
⊢ (vecCons x v - w) 0 = vecCons (x - vecHead w) (v - vecTail w) 0
[PROOFSTEP]
simp [vecHead, vecTail]
[GOAL]
case h.refine'_2
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
inst✝ : Sub α
x : α
v : Fin n → α
w : Fin (Nat.succ n) → α
i : Fin (Nat.succ n)
⊢ ∀ (i : Fin n), (vecCons x v - w) (Fin.succ i) = vecCons (x - vecHead w) (v - vecTail w) (Fin.succ i)
[PROOFSTEP]
simp [vecHead, vecTail]
[GOAL]
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
inst✝ : Sub α
v : Fin (Nat.succ n) → α
y : α
w : Fin n → α
⊢ v - vecCons y w = vecCons (vecHead v - y) (vecTail v - w)
[PROOFSTEP]
ext i
[GOAL]
case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
inst✝ : Sub α
v : Fin (Nat.succ n) → α
y : α
w : Fin n → α
i : Fin (Nat.succ n)
⊢ (v - vecCons y w) i = vecCons (vecHead v - y) (vecTail v - w) i
[PROOFSTEP]
refine' Fin.cases _ _ i
[GOAL]
case h.refine'_1
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
inst✝ : Sub α
v : Fin (Nat.succ n) → α
y : α
w : Fin n → α
i : Fin (Nat.succ n)
⊢ (v - vecCons y w) 0 = vecCons (vecHead v - y) (vecTail v - w) 0
[PROOFSTEP]
simp [vecHead, vecTail]
[GOAL]
case h.refine'_2
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
inst✝ : Sub α
v : Fin (Nat.succ n) → α
y : α
w : Fin n → α
i : Fin (Nat.succ n)
⊢ ∀ (i : Fin n), (v - vecCons y w) (Fin.succ i) = vecCons (vecHead v - y) (vecTail v - w) (Fin.succ i)
[PROOFSTEP]
simp [vecHead, vecTail]
[GOAL]
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
inst✝ : Sub α
x : α
v : Fin n → α
y : α
w : Fin n → α
⊢ vecCons x v - vecCons y w = vecCons (x - y) (v - w)
[PROOFSTEP]
simp
[GOAL]
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
inst✝ : Zero α
⊢ vecCons 0 0 = 0
[PROOFSTEP]
ext i
[GOAL]
case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
inst✝ : Zero α
i : Fin (Nat.succ n)
⊢ vecCons 0 0 i = OfNat.ofNat 0 i
[PROOFSTEP]
refine' Fin.cases _ _ i
[GOAL]
case h.refine'_1
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
inst✝ : Zero α
i : Fin (Nat.succ n)
⊢ vecCons 0 0 0 = OfNat.ofNat 0 0
[PROOFSTEP]
rfl
[GOAL]
case h.refine'_2
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
inst✝ : Zero α
i : Fin (Nat.succ n)
⊢ ∀ (i : Fin n), vecCons 0 0 (Fin.succ i) = OfNat.ofNat 0 (Fin.succ i)
[PROOFSTEP]
simp
[GOAL]
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
inst✝ : Zero α
v : Fin n → α
x : α
h : vecCons x v = 0
⊢ v = 0
[PROOFSTEP]
convert congr_arg vecTail h
[GOAL]
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
inst✝ : Zero α
v : Fin n → α
x : α
x✝ : x = 0 ∧ v = 0
hx : x = 0
hv : v = 0
⊢ vecCons x v = 0
[PROOFSTEP]
simp [hx, hv]
[GOAL]
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
inst✝ : Neg α
x : α
v : Fin n → α
⊢ -vecCons x v = vecCons (-x) (-v)
[PROOFSTEP]
ext i
[GOAL]
case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
inst✝ : Neg α
x : α
v : Fin n → α
i : Fin (Nat.succ n)
⊢ (-vecCons x v) i = vecCons (-x) (-v) i
[PROOFSTEP]
refine' Fin.cases _ _ i
[GOAL]
case h.refine'_1
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
inst✝ : Neg α
x : α
v : Fin n → α
i : Fin (Nat.succ n)
⊢ (-vecCons x v) 0 = vecCons (-x) (-v) 0
[PROOFSTEP]
simp
[GOAL]
case h.refine'_2
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
inst✝ : Neg α
x : α
v : Fin n → α
i : Fin (Nat.succ n)
⊢ ∀ (i : Fin n), (-vecCons x v) (Fin.succ i) = vecCons (-x) (-v) (Fin.succ i)
[PROOFSTEP]
simp


[GOAL]
α✝ : Type u
β : Type v
inst✝² : Monoid α✝
inst✝¹ : Monoid β
α : Type u_1
inst✝ : CommMonoid α
a b : α
x✝ : IsConj a b
c : αˣ
hc : SemiconjBy (↑c) a b
⊢ a = b
[PROOFSTEP]
rw [SemiconjBy, mul_comm, ← Units.mul_inv_eq_iff_eq_mul, mul_assoc, c.mul_inv, mul_one] at hc
[GOAL]
α✝ : Type u
β : Type v
inst✝² : Monoid α✝
inst✝¹ : Monoid β
α : Type u_1
inst✝ : CommMonoid α
a b : α
x✝ : IsConj a b
c : αˣ
hc : a = b
⊢ a = b
[PROOFSTEP]
exact hc
[GOAL]
α✝ : Type u
β : Type v
inst✝² : Monoid α✝
inst✝¹ : Monoid β
α : Type u_1
inst✝ : CommMonoid α
a b : α
h : a = b
⊢ IsConj a b
[PROOFSTEP]
rw [h]
[GOAL]
α : Type u
β : Type v
inst✝¹ : Monoid α
inst✝ : Monoid β
f : α →* β
a b : α
c : αˣ
hc : SemiconjBy (↑c) a b
⊢ SemiconjBy (↑(↑(Units.map f) c)) (↑f a) (↑f b)
[PROOFSTEP]
rw [Units.coe_map, SemiconjBy, ← f.map_mul, hc.eq, f.map_mul]
[GOAL]
α : Type u
β : Type v
inst✝ : CancelMonoid α
a : α
h : a = 1
⊢ IsConj 1 a
[PROOFSTEP]
rw [h]
[GOAL]
α : Type u
β : Type v
inst✝ : Group α
i : ℕ
a b : α
⊢ (a * b * a⁻¹) ^ i = a * b ^ i * a⁻¹
[PROOFSTEP]
induction' i with i hi
[GOAL]
case zero
α : Type u
β : Type v
inst✝ : Group α
a b : α
⊢ (a * b * a⁻¹) ^ Nat.zero = a * b ^ Nat.zero * a⁻¹
[PROOFSTEP]
simp
[GOAL]
case succ
α : Type u
β : Type v
inst✝ : Group α
a b : α
i : ℕ
hi : (a * b * a⁻¹) ^ i = a * b ^ i * a⁻¹
⊢ (a * b * a⁻¹) ^ Nat.succ i = a * b ^ Nat.succ i * a⁻¹
[PROOFSTEP]
simp [pow_succ, hi]
[GOAL]
α : Type u
β : Type v
inst✝ : Group α
i : ℤ
a b : α
⊢ (a * b * a⁻¹) ^ i = a * b ^ i * a⁻¹
[PROOFSTEP]
induction' i
[GOAL]
case ofNat
α : Type u
β : Type v
inst✝ : Group α
a b : α
a✝ : ℕ
⊢ (a * b * a⁻¹) ^ Int.ofNat a✝ = a * b ^ Int.ofNat a✝ * a⁻¹
[PROOFSTEP]
change (a * b * a⁻¹) ^ (_ : ℤ) = a * b ^ (_ : ℤ) * a⁻¹
[GOAL]
case ofNat
α : Type u
β : Type v
inst✝ : Group α
a b : α
a✝ : ℕ
⊢ (a * b * a⁻¹) ^ Int.ofNat a✝ = a * b ^ Int.ofNat a✝ * a⁻¹
[PROOFSTEP]
simp [zpow_ofNat]
[GOAL]
case negSucc
α : Type u
β : Type v
inst✝ : Group α
a b : α
a✝ : ℕ
⊢ (a * b * a⁻¹) ^ Int.negSucc a✝ = a * b ^ Int.negSucc a✝ * a⁻¹
[PROOFSTEP]
simp [zpow_negSucc, conj_pow]
[GOAL]
case negSucc
α : Type u
β : Type v
inst✝ : Group α
a b : α
a✝ : ℕ
⊢ a * ((b ^ (a✝ + 1))⁻¹ * a⁻¹) = a * (b ^ (a✝ + 1))⁻¹ * a⁻¹
[PROOFSTEP]
rw [mul_assoc]
  -- Porting note: Added `change`, `zpow_ofNat`, and `rw`.
[GOAL]
α : Type u
β : Type v
inst✝ : GroupWithZero α
a b : α
x✝ : IsConj a b
c : αˣ
hc : SemiconjBy (↑c) a b
⊢ ↑c ≠ 0 ∧ ↑c * a * (↑c)⁻¹ = b
[PROOFSTEP]
rw [← Units.val_inv_eq_inv_val, Units.mul_inv_eq_iff_eq_mul]
[GOAL]
α : Type u
β : Type v
inst✝ : GroupWithZero α
a b : α
x✝ : IsConj a b
c : αˣ
hc : SemiconjBy (↑c) a b
⊢ ↑c ≠ 0 ∧ ↑c * a = b * ↑c
[PROOFSTEP]
exact ⟨c.ne_zero, hc⟩
[GOAL]
α : Type u
β : Type v
inst✝ : GroupWithZero α
a b : α
x✝ : ∃ c, c ≠ 0 ∧ c * a * c⁻¹ = b
c : α
c0 : c ≠ 0
hc : c * a * c⁻¹ = b
⊢ SemiconjBy (↑(Units.mk0 c c0)) a b
[PROOFSTEP]
rw [SemiconjBy, ← Units.mul_inv_eq_iff_eq_mul, Units.val_inv_eq_inv_val, Units.val_mk0]
[GOAL]
α : Type u
β : Type v
inst✝ : GroupWithZero α
a b : α
x✝ : ∃ c, c ≠ 0 ∧ c * a * c⁻¹ = b
c : α
c0 : c ≠ 0
hc : c * a * c⁻¹ = b
⊢ c * a * c⁻¹ = b
[PROOFSTEP]
exact hc
[GOAL]
α : Type u
β : Type v
inst✝¹ : Monoid α
inst✝ : Monoid β
f : α →* β
hf : Function.Surjective ↑f
⊢ Function.Surjective (map f)
[PROOFSTEP]
intro b
[GOAL]
α : Type u
β : Type v
inst✝¹ : Monoid α
inst✝ : Monoid β
f : α →* β
hf : Function.Surjective ↑f
b : ConjClasses β
⊢ ∃ a, map f a = b
[PROOFSTEP]
obtain ⟨b, rfl⟩ := ConjClasses.mk_surjective b
[GOAL]
case intro
α : Type u
β : Type v
inst✝¹ : Monoid α
inst✝ : Monoid β
f : α →* β
hf : Function.Surjective ↑f
b : β
⊢ ∃ a, map f a = ConjClasses.mk b
[PROOFSTEP]
obtain ⟨a, rfl⟩ := hf b
[GOAL]
case intro.intro
α : Type u
β : Type v
inst✝¹ : Monoid α
inst✝ : Monoid β
f : α →* β
hf : Function.Surjective ↑f
a : α
⊢ ∃ a_1, map f a_1 = ConjClasses.mk (↑f a)
[PROOFSTEP]
exact ⟨ConjClasses.mk a, rfl⟩
[GOAL]
α : Type u
β : Type v
inst✝ : CommMonoid α
⊢ Function.RightInverse (Quotient.lift id (_ : ∀ (a b : α), IsConj a b → a = b)) ConjClasses.mk
[PROOFSTEP]
rw [Function.RightInverse, Function.LeftInverse, forall_isConj]
[GOAL]
α : Type u
β : Type v
inst✝ : CommMonoid α
⊢ ∀ (a : α),
    ConjClasses.mk (Quotient.lift id (_ : ∀ (a b : α), IsConj a b → a = b) (ConjClasses.mk a)) = ConjClasses.mk a
[PROOFSTEP]
intro x
[GOAL]
α : Type u
β : Type v
inst✝ : CommMonoid α
x : α
⊢ ConjClasses.mk (Quotient.lift id (_ : ∀ (a b : α), IsConj a b → a = b) (ConjClasses.mk x)) = ConjClasses.mk x
[PROOFSTEP]
rw [← quotient_mk_eq_mk, ← quotient_mk_eq_mk, Quotient.lift_mk, id.def]
[GOAL]
α : Type u
β : Type v
inst✝ : Monoid α
a b : α
h : conjugatesOf a = conjugatesOf b
⊢ IsConj a b
[PROOFSTEP]
have ha := @mem_conjugatesOf_self _ _ b
[GOAL]
α : Type u
β : Type v
inst✝ : Monoid α
a b : α
h : conjugatesOf a = conjugatesOf b
ha : b ∈ conjugatesOf b
⊢ IsConj a b
[PROOFSTEP]
rwa [← h] at ha
[GOAL]
α : Type u
β : Type v
inst✝ : Monoid α
a : α
b : ConjClasses α
⊢ a ∈ carrier b ↔ ConjClasses.mk a = b
[PROOFSTEP]
revert b
[GOAL]
α : Type u
β : Type v
inst✝ : Monoid α
a : α
⊢ ∀ {b : ConjClasses α}, a ∈ carrier b ↔ ConjClasses.mk a = b
[PROOFSTEP]
rw [forall_isConj]
[GOAL]
α : Type u
β : Type v
inst✝ : Monoid α
a : α
⊢ ∀ (a_1 : α), a ∈ carrier (ConjClasses.mk a_1) ↔ ConjClasses.mk a = ConjClasses.mk a_1
[PROOFSTEP]
intro b
[GOAL]
α : Type u
β : Type v
inst✝ : Monoid α
a b : α
⊢ a ∈ carrier (ConjClasses.mk b) ↔ ConjClasses.mk a = ConjClasses.mk b
[PROOFSTEP]
rw [carrier, eq_comm, mk_eq_mk_iff_isConj, ← quotient_mk_eq_mk, Quotient.lift_mk]
[GOAL]
α : Type u
β : Type v
inst✝ : Monoid α
a b : α
⊢ a ∈ conjugatesOf b ↔ IsConj b a
[PROOFSTEP]
rfl


[GOAL]
⊢ {x | ∃ p, p > 2 ∧ LiouvilleWith p x} ⊆
    ⋃ (m : ℤ),
      (fun x => x + ↑m) ⁻¹'
        ⋃ (n : ℕ) (_ : n > 0),
          {x | ∃ᶠ (b : ℕ) in atTop, ∃ a, a ∈ Finset.Icc 0 ↑b ∧ |x - ↑a / ↑b| < 1 / ↑b ^ (2 + 1 / ↑n)}
[PROOFSTEP]
rintro x ⟨p, hp, hxp⟩
[GOAL]
case intro.intro
x p : ℝ
hp : p > 2
hxp : LiouvilleWith p x
⊢ x ∈
    ⋃ (m : ℤ),
      (fun x => x + ↑m) ⁻¹'
        ⋃ (n : ℕ) (_ : n > 0),
          {x | ∃ᶠ (b : ℕ) in atTop, ∃ a, a ∈ Finset.Icc 0 ↑b ∧ |x - ↑a / ↑b| < 1 / ↑b ^ (2 + 1 / ↑n)}
[PROOFSTEP]
rcases exists_nat_one_div_lt (sub_pos.2 hp) with ⟨n, hn⟩
[GOAL]
case intro.intro.intro
x p : ℝ
hp : p > 2
hxp : LiouvilleWith p x
n : ℕ
hn : 1 / (↑n + 1) < p - 2
⊢ x ∈
    ⋃ (m : ℤ),
      (fun x => x + ↑m) ⁻¹'
        ⋃ (n : ℕ) (_ : n > 0),
          {x | ∃ᶠ (b : ℕ) in atTop, ∃ a, a ∈ Finset.Icc 0 ↑b ∧ |x - ↑a / ↑b| < 1 / ↑b ^ (2 + 1 / ↑n)}
[PROOFSTEP]
rw [lt_sub_iff_add_lt'] at hn
[GOAL]
case intro.intro.intro
x p : ℝ
hp : p > 2
hxp : LiouvilleWith p x
n : ℕ
hn : 2 + 1 / (↑n + 1) < p
⊢ x ∈
    ⋃ (m : ℤ),
      (fun x => x + ↑m) ⁻¹'
        ⋃ (n : ℕ) (_ : n > 0),
          {x | ∃ᶠ (b : ℕ) in atTop, ∃ a, a ∈ Finset.Icc 0 ↑b ∧ |x - ↑a / ↑b| < 1 / ↑b ^ (2 + 1 / ↑n)}
[PROOFSTEP]
suffices
  ∀ y : ℝ,
    LiouvilleWith p y →
      y ∈ Ico (0 : ℝ) 1 →
        ∃ᶠ b : ℕ in atTop, ∃ a ∈ Finset.Icc (0 : ℤ) b, |y - a / b| < 1 / (b : ℝ) ^ (2 + 1 / (n + 1 : ℕ) : ℝ)
  by
  simp only [mem_iUnion, mem_preimage]
  have hx : x + ↑(-⌊x⌋) ∈ Ico (0 : ℝ) 1 := by
    simp only [Int.floor_le, Int.lt_floor_add_one, add_neg_lt_iff_le_add', zero_add, and_self_iff, mem_Ico,
      Int.cast_neg, le_add_neg_iff_add_le]
  refine' ⟨-⌊x⌋, n + 1, n.succ_pos, this _ (hxp.add_int _) hx⟩
[GOAL]
x p : ℝ
hp : p > 2
hxp : LiouvilleWith p x
n : ℕ
hn : 2 + 1 / (↑n + 1) < p
this :
  ∀ (y : ℝ),
    LiouvilleWith p y →
      y ∈ Ico 0 1 → ∃ᶠ (b : ℕ) in atTop, ∃ a, a ∈ Finset.Icc 0 ↑b ∧ |y - ↑a / ↑b| < 1 / ↑b ^ (2 + 1 / ↑(n + 1))
⊢ x ∈
    ⋃ (m : ℤ),
      (fun x => x + ↑m) ⁻¹'
        ⋃ (n : ℕ) (_ : n > 0),
          {x | ∃ᶠ (b : ℕ) in atTop, ∃ a, a ∈ Finset.Icc 0 ↑b ∧ |x - ↑a / ↑b| < 1 / ↑b ^ (2 + 1 / ↑n)}
[PROOFSTEP]
simp only [mem_iUnion, mem_preimage]
[GOAL]
x p : ℝ
hp : p > 2
hxp : LiouvilleWith p x
n : ℕ
hn : 2 + 1 / (↑n + 1) < p
this :
  ∀ (y : ℝ),
    LiouvilleWith p y →
      y ∈ Ico 0 1 → ∃ᶠ (b : ℕ) in atTop, ∃ a, a ∈ Finset.Icc 0 ↑b ∧ |y - ↑a / ↑b| < 1 / ↑b ^ (2 + 1 / ↑(n + 1))
⊢ ∃ i i_1 i_2, x + ↑i ∈ {x | ∃ᶠ (b : ℕ) in atTop, ∃ a, a ∈ Finset.Icc 0 ↑b ∧ |x - ↑a / ↑b| < 1 / ↑b ^ (2 + 1 / ↑i_1)}
[PROOFSTEP]
have hx : x + ↑(-⌊x⌋) ∈ Ico (0 : ℝ) 1 := by
  simp only [Int.floor_le, Int.lt_floor_add_one, add_neg_lt_iff_le_add', zero_add, and_self_iff, mem_Ico, Int.cast_neg,
    le_add_neg_iff_add_le]
[GOAL]
x p : ℝ
hp : p > 2
hxp : LiouvilleWith p x
n : ℕ
hn : 2 + 1 / (↑n + 1) < p
this :
  ∀ (y : ℝ),
    LiouvilleWith p y →
      y ∈ Ico 0 1 → ∃ᶠ (b : ℕ) in atTop, ∃ a, a ∈ Finset.Icc 0 ↑b ∧ |y - ↑a / ↑b| < 1 / ↑b ^ (2 + 1 / ↑(n + 1))
⊢ x + ↑(-⌊x⌋) ∈ Ico 0 1
[PROOFSTEP]
simp only [Int.floor_le, Int.lt_floor_add_one, add_neg_lt_iff_le_add', zero_add, and_self_iff, mem_Ico, Int.cast_neg,
  le_add_neg_iff_add_le]
[GOAL]
x p : ℝ
hp : p > 2
hxp : LiouvilleWith p x
n : ℕ
hn : 2 + 1 / (↑n + 1) < p
this :
  ∀ (y : ℝ),
    LiouvilleWith p y →
      y ∈ Ico 0 1 → ∃ᶠ (b : ℕ) in atTop, ∃ a, a ∈ Finset.Icc 0 ↑b ∧ |y - ↑a / ↑b| < 1 / ↑b ^ (2 + 1 / ↑(n + 1))
hx : x + ↑(-⌊x⌋) ∈ Ico 0 1
⊢ ∃ i i_1 i_2, x + ↑i ∈ {x | ∃ᶠ (b : ℕ) in atTop, ∃ a, a ∈ Finset.Icc 0 ↑b ∧ |x - ↑a / ↑b| < 1 / ↑b ^ (2 + 1 / ↑i_1)}
[PROOFSTEP]
refine' ⟨-⌊x⌋, n + 1, n.succ_pos, this _ (hxp.add_int _) hx⟩
[GOAL]
case intro.intro.intro
x p : ℝ
hp : p > 2
hxp : LiouvilleWith p x
n : ℕ
hn : 2 + 1 / (↑n + 1) < p
⊢ ∀ (y : ℝ),
    LiouvilleWith p y →
      y ∈ Ico 0 1 → ∃ᶠ (b : ℕ) in atTop, ∃ a, a ∈ Finset.Icc 0 ↑b ∧ |y - ↑a / ↑b| < 1 / ↑b ^ (2 + 1 / ↑(n + 1))
[PROOFSTEP]
clear hxp x
[GOAL]
case intro.intro.intro
p : ℝ
hp : p > 2
n : ℕ
hn : 2 + 1 / (↑n + 1) < p
⊢ ∀ (y : ℝ),
    LiouvilleWith p y →
      y ∈ Ico 0 1 → ∃ᶠ (b : ℕ) in atTop, ∃ a, a ∈ Finset.Icc 0 ↑b ∧ |y - ↑a / ↑b| < 1 / ↑b ^ (2 + 1 / ↑(n + 1))
[PROOFSTEP]
intro x hxp hx01
[GOAL]
case intro.intro.intro
p : ℝ
hp : p > 2
n : ℕ
hn : 2 + 1 / (↑n + 1) < p
x : ℝ
hxp : LiouvilleWith p x
hx01 : x ∈ Ico 0 1
⊢ ∃ᶠ (b : ℕ) in atTop, ∃ a, a ∈ Finset.Icc 0 ↑b ∧ |x - ↑a / ↑b| < 1 / ↑b ^ (2 + 1 / ↑(n + 1))
[PROOFSTEP]
refine' ((hxp.frequently_lt_rpow_neg hn).and_eventually (eventually_ge_atTop 1)).mono _
[GOAL]
case intro.intro.intro
p : ℝ
hp : p > 2
n : ℕ
hn : 2 + 1 / (↑n + 1) < p
x : ℝ
hxp : LiouvilleWith p x
hx01 : x ∈ Ico 0 1
⊢ ∀ (x_1 : ℕ),
    (∃ m, x ≠ ↑m / ↑x_1 ∧ |x - ↑m / ↑x_1| < ↑x_1 ^ (-(2 + 1 / (↑n + 1)))) ∧ 1 ≤ x_1 →
      ∃ a, a ∈ Finset.Icc 0 ↑x_1 ∧ |x - ↑a / ↑x_1| < 1 / ↑x_1 ^ (2 + 1 / ↑(n + 1))
[PROOFSTEP]
rintro b ⟨⟨a, -, hlt⟩, hb⟩
[GOAL]
case intro.intro.intro.intro.intro.intro
p : ℝ
hp : p > 2
n : ℕ
hn : 2 + 1 / (↑n + 1) < p
x : ℝ
hxp : LiouvilleWith p x
hx01 : x ∈ Ico 0 1
b : ℕ
hb : 1 ≤ b
a : ℤ
hlt : |x - ↑a / ↑b| < ↑b ^ (-(2 + 1 / (↑n + 1)))
⊢ ∃ a, a ∈ Finset.Icc 0 ↑b ∧ |x - ↑a / ↑b| < 1 / ↑b ^ (2 + 1 / ↑(n + 1))
[PROOFSTEP]
rw [rpow_neg b.cast_nonneg, ← one_div, ← Nat.cast_succ] at hlt
[GOAL]
case intro.intro.intro.intro.intro.intro
p : ℝ
hp : p > 2
n : ℕ
hn : 2 + 1 / (↑n + 1) < p
x : ℝ
hxp : LiouvilleWith p x
hx01 : x ∈ Ico 0 1
b : ℕ
hb : 1 ≤ b
a : ℤ
hlt : |x - ↑a / ↑b| < 1 / ↑b ^ (2 + 1 / ↑(Nat.succ n))
⊢ ∃ a, a ∈ Finset.Icc 0 ↑b ∧ |x - ↑a / ↑b| < 1 / ↑b ^ (2 + 1 / ↑(n + 1))
[PROOFSTEP]
refine' ⟨a, _, hlt⟩
[GOAL]
case intro.intro.intro.intro.intro.intro
p : ℝ
hp : p > 2
n : ℕ
hn : 2 + 1 / (↑n + 1) < p
x : ℝ
hxp : LiouvilleWith p x
hx01 : x ∈ Ico 0 1
b : ℕ
hb : 1 ≤ b
a : ℤ
hlt : |x - ↑a / ↑b| < 1 / ↑b ^ (2 + 1 / ↑(Nat.succ n))
⊢ a ∈ Finset.Icc 0 ↑b
[PROOFSTEP]
replace hb : (1 : ℝ) ≤ b
[GOAL]
case hb
p : ℝ
hp : p > 2
n : ℕ
hn : 2 + 1 / (↑n + 1) < p
x : ℝ
hxp : LiouvilleWith p x
hx01 : x ∈ Ico 0 1
b : ℕ
hb : 1 ≤ b
a : ℤ
hlt : |x - ↑a / ↑b| < 1 / ↑b ^ (2 + 1 / ↑(Nat.succ n))
⊢ 1 ≤ ↑b
case intro.intro.intro.intro.intro.intro
p : ℝ
hp : p > 2
n : ℕ
hn : 2 + 1 / (↑n + 1) < p
x : ℝ
hxp : LiouvilleWith p x
hx01 : x ∈ Ico 0 1
b : ℕ
a : ℤ
hlt : |x - ↑a / ↑b| < 1 / ↑b ^ (2 + 1 / ↑(Nat.succ n))
hb : 1 ≤ ↑b
⊢ a ∈ Finset.Icc 0 ↑b
[PROOFSTEP]
exact Nat.one_le_cast.2 hb
[GOAL]
case intro.intro.intro.intro.intro.intro
p : ℝ
hp : p > 2
n : ℕ
hn : 2 + 1 / (↑n + 1) < p
x : ℝ
hxp : LiouvilleWith p x
hx01 : x ∈ Ico 0 1
b : ℕ
a : ℤ
hlt : |x - ↑a / ↑b| < 1 / ↑b ^ (2 + 1 / ↑(Nat.succ n))
hb : 1 ≤ ↑b
⊢ a ∈ Finset.Icc 0 ↑b
[PROOFSTEP]
have hb0 : (0 : ℝ) < b := zero_lt_one.trans_le hb
[GOAL]
case intro.intro.intro.intro.intro.intro
p : ℝ
hp : p > 2
n : ℕ
hn : 2 + 1 / (↑n + 1) < p
x : ℝ
hxp : LiouvilleWith p x
hx01 : x ∈ Ico 0 1
b : ℕ
a : ℤ
hlt : |x - ↑a / ↑b| < 1 / ↑b ^ (2 + 1 / ↑(Nat.succ n))
hb : 1 ≤ ↑b
hb0 : 0 < ↑b
⊢ a ∈ Finset.Icc 0 ↑b
[PROOFSTEP]
replace hlt : |x - a / b| < 1 / b
[GOAL]
case hlt
p : ℝ
hp : p > 2
n : ℕ
hn : 2 + 1 / (↑n + 1) < p
x : ℝ
hxp : LiouvilleWith p x
hx01 : x ∈ Ico 0 1
b : ℕ
a : ℤ
hlt : |x - ↑a / ↑b| < 1 / ↑b ^ (2 + 1 / ↑(Nat.succ n))
hb : 1 ≤ ↑b
hb0 : 0 < ↑b
⊢ |x - ↑a / ↑b| < 1 / ↑b
[PROOFSTEP]
refine' hlt.trans_le (one_div_le_one_div_of_le hb0 _)
[GOAL]
case hlt
p : ℝ
hp : p > 2
n : ℕ
hn : 2 + 1 / (↑n + 1) < p
x : ℝ
hxp : LiouvilleWith p x
hx01 : x ∈ Ico 0 1
b : ℕ
a : ℤ
hlt : |x - ↑a / ↑b| < 1 / ↑b ^ (2 + 1 / ↑(Nat.succ n))
hb : 1 ≤ ↑b
hb0 : 0 < ↑b
⊢ ↑b ≤ ↑b ^ (2 + 1 / ↑(Nat.succ n))
[PROOFSTEP]
calc
  (b : ℝ) = (b : ℝ) ^ (1 : ℝ) := (rpow_one _).symm
  _ ≤ (b : ℝ) ^ (2 + 1 / (n + 1 : ℕ) : ℝ) := rpow_le_rpow_of_exponent_le hb (one_le_two.trans ?_)
[GOAL]
case hlt
p : ℝ
hp : p > 2
n : ℕ
hn : 2 + 1 / (↑n + 1) < p
x : ℝ
hxp : LiouvilleWith p x
hx01 : x ∈ Ico 0 1
b : ℕ
a : ℤ
hlt : |x - ↑a / ↑b| < 1 / ↑b ^ (2 + 1 / ↑(Nat.succ n))
hb : 1 ≤ ↑b
hb0 : 0 < ↑b
⊢ 2 ≤ 2 + 1 / ↑(n + 1)
[PROOFSTEP]
simpa using n.cast_add_one_pos.le
[GOAL]
case intro.intro.intro.intro.intro.intro
p : ℝ
hp : p > 2
n : ℕ
hn : 2 + 1 / (↑n + 1) < p
x : ℝ
hxp : LiouvilleWith p x
hx01 : x ∈ Ico 0 1
b : ℕ
a : ℤ
hb : 1 ≤ ↑b
hb0 : 0 < ↑b
hlt : |x - ↑a / ↑b| < 1 / ↑b
⊢ a ∈ Finset.Icc 0 ↑b
[PROOFSTEP]
rw [sub_div' _ _ _ hb0.ne', abs_div, abs_of_pos hb0, div_lt_div_right hb0, abs_sub_lt_iff, sub_lt_iff_lt_add,
  sub_lt_iff_lt_add, ← sub_lt_iff_lt_add'] at hlt
[GOAL]
case intro.intro.intro.intro.intro.intro
p : ℝ
hp : p > 2
n : ℕ
hn : 2 + 1 / (↑n + 1) < p
x : ℝ
hxp : LiouvilleWith p x
hx01 : x ∈ Ico 0 1
b : ℕ
a : ℤ
hb : 1 ≤ ↑b
hb0 : 0 < ↑b
hlt : x * ↑b - 1 < ↑a ∧ ↑a < 1 + x * ↑b
⊢ a ∈ Finset.Icc 0 ↑b
[PROOFSTEP]
rw [Finset.mem_Icc, ← Int.lt_add_one_iff, ← Int.lt_add_one_iff, ← neg_lt_iff_pos_add, add_comm, ← @Int.cast_lt ℝ, ←
  @Int.cast_lt ℝ]
[GOAL]
case intro.intro.intro.intro.intro.intro
p : ℝ
hp : p > 2
n : ℕ
hn : 2 + 1 / (↑n + 1) < p
x : ℝ
hxp : LiouvilleWith p x
hx01 : x ∈ Ico 0 1
b : ℕ
a : ℤ
hb : 1 ≤ ↑b
hb0 : 0 < ↑b
hlt : x * ↑b - 1 < ↑a ∧ ↑a < 1 + x * ↑b
⊢ ↑(-1) < ↑a ∧ ↑a < ↑(1 + ↑b)
[PROOFSTEP]
push_cast
[GOAL]
case intro.intro.intro.intro.intro.intro
p : ℝ
hp : p > 2
n : ℕ
hn : 2 + 1 / (↑n + 1) < p
x : ℝ
hxp : LiouvilleWith p x
hx01 : x ∈ Ico 0 1
b : ℕ
a : ℤ
hb : 1 ≤ ↑b
hb0 : 0 < ↑b
hlt : x * ↑b - 1 < ↑a ∧ ↑a < 1 + x * ↑b
⊢ -1 < ↑a ∧ ↑a < 1 + ↑b
[PROOFSTEP]
refine' ⟨lt_of_le_of_lt _ hlt.1, hlt.2.trans_le _⟩
[GOAL]
case intro.intro.intro.intro.intro.intro.refine'_1
p : ℝ
hp : p > 2
n : ℕ
hn : 2 + 1 / (↑n + 1) < p
x : ℝ
hxp : LiouvilleWith p x
hx01 : x ∈ Ico 0 1
b : ℕ
a : ℤ
hb : 1 ≤ ↑b
hb0 : 0 < ↑b
hlt : x * ↑b - 1 < ↑a ∧ ↑a < 1 + x * ↑b
⊢ -1 ≤ x * ↑b - 1
[PROOFSTEP]
simp only [mul_nonneg hx01.left b.cast_nonneg, neg_le_sub_iff_le_add, le_add_iff_nonneg_left]
[GOAL]
case intro.intro.intro.intro.intro.intro.refine'_2
p : ℝ
hp : p > 2
n : ℕ
hn : 2 + 1 / (↑n + 1) < p
x : ℝ
hxp : LiouvilleWith p x
hx01 : x ∈ Ico 0 1
b : ℕ
a : ℤ
hb : 1 ≤ ↑b
hb0 : 0 < ↑b
hlt : x * ↑b - 1 < ↑a ∧ ↑a < 1 + x * ↑b
⊢ 1 + x * ↑b ≤ 1 + ↑b
[PROOFSTEP]
rw [add_le_add_iff_left]
[GOAL]
case intro.intro.intro.intro.intro.intro.refine'_2
p : ℝ
hp : p > 2
n : ℕ
hn : 2 + 1 / (↑n + 1) < p
x : ℝ
hxp : LiouvilleWith p x
hx01 : x ∈ Ico 0 1
b : ℕ
a : ℤ
hb : 1 ≤ ↑b
hb0 : 0 < ↑b
hlt : x * ↑b - 1 < ↑a ∧ ↑a < 1 + x * ↑b
⊢ x * ↑b ≤ ↑b
[PROOFSTEP]
exact mul_le_of_le_one_left hb0.le hx01.2.le
[GOAL]
⊢ ↑↑volume (⋃ (p : ℝ) (_ : 2 < p), {x | LiouvilleWith p x}) = 0
[PROOFSTEP]
simp only [← setOf_exists, exists_prop]
[GOAL]
⊢ ↑↑volume {x | ∃ i, 2 < i ∧ LiouvilleWith i x} = 0
[PROOFSTEP]
refine' measure_mono_null setOf_liouvilleWith_subset_aux _
[GOAL]
⊢ ↑↑volume
      (⋃ (m : ℤ),
        (fun x => x + ↑m) ⁻¹'
          ⋃ (n : ℕ) (_ : n > 0),
            {x | ∃ᶠ (b : ℕ) in atTop, ∃ a, a ∈ Finset.Icc 0 ↑b ∧ |x - ↑a / ↑b| < 1 / ↑b ^ (2 + 1 / ↑n)}) =
    0
[PROOFSTEP]
rw [measure_iUnion_null_iff]
[GOAL]
⊢ ∀ (i : ℤ),
    ↑↑volume
        ((fun x => x + ↑i) ⁻¹'
          ⋃ (n : ℕ) (_ : n > 0),
            {x | ∃ᶠ (b : ℕ) in atTop, ∃ a, a ∈ Finset.Icc 0 ↑b ∧ |x - ↑a / ↑b| < 1 / ↑b ^ (2 + 1 / ↑n)}) =
      0
[PROOFSTEP]
intro m
[GOAL]
m : ℤ
⊢ ↑↑volume
      ((fun x => x + ↑m) ⁻¹'
        ⋃ (n : ℕ) (_ : n > 0),
          {x | ∃ᶠ (b : ℕ) in atTop, ∃ a, a ∈ Finset.Icc 0 ↑b ∧ |x - ↑a / ↑b| < 1 / ↑b ^ (2 + 1 / ↑n)}) =
    0
[PROOFSTEP]
rw [measure_preimage_add_right]
[GOAL]
m : ℤ
⊢ ↑↑volume
      (⋃ (n : ℕ) (_ : n > 0),
        {x | ∃ᶠ (b : ℕ) in atTop, ∃ a, a ∈ Finset.Icc 0 ↑b ∧ |x - ↑a / ↑b| < 1 / ↑b ^ (2 + 1 / ↑n)}) =
    0
[PROOFSTEP]
clear m
[GOAL]
⊢ ↑↑volume
      (⋃ (n : ℕ) (_ : n > 0),
        {x | ∃ᶠ (b : ℕ) in atTop, ∃ a, a ∈ Finset.Icc 0 ↑b ∧ |x - ↑a / ↑b| < 1 / ↑b ^ (2 + 1 / ↑n)}) =
    0
[PROOFSTEP]
refine' (measure_biUnion_null_iff <| to_countable _).2 fun n (hn : 1 ≤ n) => _
[GOAL]
n : ℕ
hn : 1 ≤ n
⊢ ↑↑volume {x | ∃ᶠ (b : ℕ) in atTop, ∃ a, a ∈ Finset.Icc 0 ↑b ∧ |x - ↑a / ↑b| < 1 / ↑b ^ (2 + 1 / ↑n)} = 0
[PROOFSTEP]
generalize hr : (2 + 1 / n : ℝ) = r
[GOAL]
n : ℕ
hn : 1 ≤ n
r : ℝ
hr : 2 + 1 / ↑n = r
⊢ ↑↑volume {x | ∃ᶠ (b : ℕ) in atTop, ∃ a, a ∈ Finset.Icc 0 ↑b ∧ |x - ↑a / ↑b| < 1 / ↑b ^ r} = 0
[PROOFSTEP]
replace hr : 2 < r
[GOAL]
case hr
n : ℕ
hn : 1 ≤ n
r : ℝ
hr : 2 + 1 / ↑n = r
⊢ 2 < r
[PROOFSTEP]
simp [← hr, zero_lt_one.trans_le hn]
[GOAL]
n : ℕ
hn : 1 ≤ n
r : ℝ
hr : 2 < r
⊢ ↑↑volume {x | ∃ᶠ (b : ℕ) in atTop, ∃ a, a ∈ Finset.Icc 0 ↑b ∧ |x - ↑a / ↑b| < 1 / ↑b ^ r} = 0
[PROOFSTEP]
clear hn n
[GOAL]
r : ℝ
hr : 2 < r
⊢ ↑↑volume {x | ∃ᶠ (b : ℕ) in atTop, ∃ a, a ∈ Finset.Icc 0 ↑b ∧ |x - ↑a / ↑b| < 1 / ↑b ^ r} = 0
[PROOFSTEP]
refine' measure_setOf_frequently_eq_zero _
[GOAL]
r : ℝ
hr : 2 < r
⊢ ∑' (i : ℕ), ↑↑volume {x | ∃ a, a ∈ Finset.Icc 0 ↑i ∧ |x - ↑a / ↑i| < 1 / ↑i ^ r} ≠ ⊤
[PROOFSTEP]
simp only [setOf_exists, ← exists_prop, ← Real.dist_eq, ← mem_ball, setOf_mem_eq]
[GOAL]
r : ℝ
hr : 2 < r
⊢ ∑' (i : ℕ), ↑↑volume (⋃ (i_1 : ℤ) (_ : i_1 ∈ Finset.Icc 0 ↑i), ball (↑i_1 / ↑i) (1 / ↑i ^ r)) ≠ ⊤
[PROOFSTEP]
set B : ℤ → ℕ → Set ℝ := fun a b => ball (a / b) (1 / (b : ℝ) ^ r)
[GOAL]
r : ℝ
hr : 2 < r
B : ℤ → ℕ → Set ℝ := fun a b => ball (↑a / ↑b) (1 / ↑b ^ r)
⊢ ∑' (i : ℕ), ↑↑volume (⋃ (i_1 : ℤ) (_ : i_1 ∈ Finset.Icc 0 ↑i), ball (↑i_1 / ↑i) (1 / ↑i ^ r)) ≠ ⊤
[PROOFSTEP]
have hB : ∀ a b, volume (B a b) = ↑((2 : ℝ≥0) / (b : ℝ≥0) ^ r) := fun a b ↦ by
  rw [Real.volume_ball, mul_one_div, ← NNReal.coe_two, ← NNReal.coe_nat_cast, ← NNReal.coe_rpow, ← NNReal.coe_div,
    ENNReal.ofReal_coe_nnreal]
[GOAL]
r : ℝ
hr : 2 < r
B : ℤ → ℕ → Set ℝ := fun a b => ball (↑a / ↑b) (1 / ↑b ^ r)
a : ℤ
b : ℕ
⊢ ↑↑volume (B a b) = ↑(2 / ↑b ^ r)
[PROOFSTEP]
rw [Real.volume_ball, mul_one_div, ← NNReal.coe_two, ← NNReal.coe_nat_cast, ← NNReal.coe_rpow, ← NNReal.coe_div,
  ENNReal.ofReal_coe_nnreal]
[GOAL]
r : ℝ
hr : 2 < r
B : ℤ → ℕ → Set ℝ := fun a b => ball (↑a / ↑b) (1 / ↑b ^ r)
hB : ∀ (a : ℤ) (b : ℕ), ↑↑volume (B a b) = ↑(2 / ↑b ^ r)
⊢ ∑' (i : ℕ), ↑↑volume (⋃ (i_1 : ℤ) (_ : i_1 ∈ Finset.Icc 0 ↑i), ball (↑i_1 / ↑i) (1 / ↑i ^ r)) ≠ ⊤
[PROOFSTEP]
have : ∀ b : ℕ, volume (⋃ a ∈ Finset.Icc (0 : ℤ) b, B a b) ≤ ↑(2 * ((b : ℝ≥0) ^ (1 - r) + (b : ℝ≥0) ^ (-r))) := fun b ↦
  calc
    volume (⋃ a ∈ Finset.Icc (0 : ℤ) b, B a b) ≤ ∑ a in Finset.Icc (0 : ℤ) b, volume (B a b) :=
      measure_biUnion_finset_le _ _
    _ = ↑((b + 1) * (2 / (b : ℝ≥0) ^ r)) := by
      simp only [hB, Int.card_Icc, Finset.sum_const, nsmul_eq_mul, sub_zero, ← Int.ofNat_succ, Int.toNat_coe_nat, ←
        Nat.cast_succ, ENNReal.coe_mul, ENNReal.coe_nat]
    _ = _ := by
      have : 1 - r ≠ 0 := by linarith
      rw [ENNReal.coe_eq_coe]
      simp [add_mul, div_eq_mul_inv, NNReal.rpow_neg, NNReal.rpow_sub' _ this, mul_add, mul_left_comm]
[GOAL]
r : ℝ
hr : 2 < r
B : ℤ → ℕ → Set ℝ := fun a b => ball (↑a / ↑b) (1 / ↑b ^ r)
hB : ∀ (a : ℤ) (b : ℕ), ↑↑volume (B a b) = ↑(2 / ↑b ^ r)
b : ℕ
⊢ ∑ a in Finset.Icc 0 ↑b, ↑↑volume (B a b) = ↑((↑b + 1) * (2 / ↑b ^ r))
[PROOFSTEP]
simp only [hB, Int.card_Icc, Finset.sum_const, nsmul_eq_mul, sub_zero, ← Int.ofNat_succ, Int.toNat_coe_nat, ←
  Nat.cast_succ, ENNReal.coe_mul, ENNReal.coe_nat]
[GOAL]
r : ℝ
hr : 2 < r
B : ℤ → ℕ → Set ℝ := fun a b => ball (↑a / ↑b) (1 / ↑b ^ r)
hB : ∀ (a : ℤ) (b : ℕ), ↑↑volume (B a b) = ↑(2 / ↑b ^ r)
b : ℕ
⊢ ↑((↑b + 1) * (2 / ↑b ^ r)) = ↑(2 * (↑b ^ (1 - r) + ↑b ^ (-r)))
[PROOFSTEP]
have : 1 - r ≠ 0 := by linarith
[GOAL]
r : ℝ
hr : 2 < r
B : ℤ → ℕ → Set ℝ := fun a b => ball (↑a / ↑b) (1 / ↑b ^ r)
hB : ∀ (a : ℤ) (b : ℕ), ↑↑volume (B a b) = ↑(2 / ↑b ^ r)
b : ℕ
⊢ 1 - r ≠ 0
[PROOFSTEP]
linarith
[GOAL]
r : ℝ
hr : 2 < r
B : ℤ → ℕ → Set ℝ := fun a b => ball (↑a / ↑b) (1 / ↑b ^ r)
hB : ∀ (a : ℤ) (b : ℕ), ↑↑volume (B a b) = ↑(2 / ↑b ^ r)
b : ℕ
this : 1 - r ≠ 0
⊢ ↑((↑b + 1) * (2 / ↑b ^ r)) = ↑(2 * (↑b ^ (1 - r) + ↑b ^ (-r)))
[PROOFSTEP]
rw [ENNReal.coe_eq_coe]
[GOAL]
r : ℝ
hr : 2 < r
B : ℤ → ℕ → Set ℝ := fun a b => ball (↑a / ↑b) (1 / ↑b ^ r)
hB : ∀ (a : ℤ) (b : ℕ), ↑↑volume (B a b) = ↑(2 / ↑b ^ r)
b : ℕ
this : 1 - r ≠ 0
⊢ (↑b + 1) * (2 / ↑b ^ r) = 2 * (↑b ^ (1 - r) + ↑b ^ (-r))
[PROOFSTEP]
simp [add_mul, div_eq_mul_inv, NNReal.rpow_neg, NNReal.rpow_sub' _ this, mul_add, mul_left_comm]
[GOAL]
r : ℝ
hr : 2 < r
B : ℤ → ℕ → Set ℝ := fun a b => ball (↑a / ↑b) (1 / ↑b ^ r)
hB : ∀ (a : ℤ) (b : ℕ), ↑↑volume (B a b) = ↑(2 / ↑b ^ r)
this : ∀ (b : ℕ), ↑↑volume (⋃ (a : ℤ) (_ : a ∈ Finset.Icc 0 ↑b), B a b) ≤ ↑(2 * (↑b ^ (1 - r) + ↑b ^ (-r)))
⊢ ∑' (i : ℕ), ↑↑volume (⋃ (i_1 : ℤ) (_ : i_1 ∈ Finset.Icc 0 ↑i), ball (↑i_1 / ↑i) (1 / ↑i ^ r)) ≠ ⊤
[PROOFSTEP]
refine' ne_top_of_le_ne_top (ENNReal.tsum_coe_ne_top_iff_summable.2 _) (ENNReal.tsum_le_tsum this)
[GOAL]
r : ℝ
hr : 2 < r
B : ℤ → ℕ → Set ℝ := fun a b => ball (↑a / ↑b) (1 / ↑b ^ r)
hB : ∀ (a : ℤ) (b : ℕ), ↑↑volume (B a b) = ↑(2 / ↑b ^ r)
this : ∀ (b : ℕ), ↑↑volume (⋃ (a : ℤ) (_ : a ∈ Finset.Icc 0 ↑b), B a b) ≤ ↑(2 * (↑b ^ (1 - r) + ↑b ^ (-r)))
⊢ Summable fun a => 2 * (↑a ^ (1 - r) + ↑a ^ (-r))
[PROOFSTEP]
refine' (Summable.add _ _).mul_left _
[GOAL]
case refine'_1
r : ℝ
hr : 2 < r
B : ℤ → ℕ → Set ℝ := fun a b => ball (↑a / ↑b) (1 / ↑b ^ r)
hB : ∀ (a : ℤ) (b : ℕ), ↑↑volume (B a b) = ↑(2 / ↑b ^ r)
this : ∀ (b : ℕ), ↑↑volume (⋃ (a : ℤ) (_ : a ∈ Finset.Icc 0 ↑b), B a b) ≤ ↑(2 * (↑b ^ (1 - r) + ↑b ^ (-r)))
⊢ Summable fun a => ↑a ^ (1 - r)
[PROOFSTEP]
simp only [NNReal.summable_rpow]
[GOAL]
case refine'_2
r : ℝ
hr : 2 < r
B : ℤ → ℕ → Set ℝ := fun a b => ball (↑a / ↑b) (1 / ↑b ^ r)
hB : ∀ (a : ℤ) (b : ℕ), ↑↑volume (B a b) = ↑(2 / ↑b ^ r)
this : ∀ (b : ℕ), ↑↑volume (⋃ (a : ℤ) (_ : a ∈ Finset.Icc 0 ↑b), B a b) ≤ ↑(2 * (↑b ^ (1 - r) + ↑b ^ (-r)))
⊢ Summable fun a => ↑a ^ (-r)
[PROOFSTEP]
simp only [NNReal.summable_rpow]
[GOAL]
case refine'_1
r : ℝ
hr : 2 < r
B : ℤ → ℕ → Set ℝ := fun a b => ball (↑a / ↑b) (1 / ↑b ^ r)
hB : ∀ (a : ℤ) (b : ℕ), ↑↑volume (B a b) = ↑(2 / ↑b ^ r)
this : ∀ (b : ℕ), ↑↑volume (⋃ (a : ℤ) (_ : a ∈ Finset.Icc 0 ↑b), B a b) ≤ ↑(2 * (↑b ^ (1 - r) + ↑b ^ (-r)))
⊢ 1 - r < -1
[PROOFSTEP]
linarith
[GOAL]
case refine'_2
r : ℝ
hr : 2 < r
B : ℤ → ℕ → Set ℝ := fun a b => ball (↑a / ↑b) (1 / ↑b ^ r)
hB : ∀ (a : ℤ) (b : ℕ), ↑↑volume (B a b) = ↑(2 / ↑b ^ r)
this : ∀ (b : ℕ), ↑↑volume (⋃ (a : ℤ) (_ : a ∈ Finset.Icc 0 ↑b), B a b) ≤ ↑(2 * (↑b ^ (1 - r) + ↑b ^ (-r)))
⊢ -r < -1
[PROOFSTEP]
linarith
[GOAL]
⊢ ∀ᵐ (x : ℝ), ∀ (p : ℝ), p > 2 → ¬LiouvilleWith p x
[PROOFSTEP]
simpa only [ae_iff, not_forall, Classical.not_not, setOf_exists] using volume_iUnion_setOf_liouvilleWith
[GOAL]
x : ℝ
h₁ : ∀ (p : ℝ), p > 2 → ¬LiouvilleWith p x
h₂ : Liouville x
⊢ 3 > 2
[PROOFSTEP]
norm_num
[GOAL]
⊢ ↑↑volume {x | Liouville x} = 0
[PROOFSTEP]
simpa only [ae_iff, Classical.not_not] using ae_not_liouville


[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp2 : p = 2
x✝ : Irreducible ↑p
not_unit✝ : ¬IsUnit ↑p
h : ∀ (a b : ℤ[i]), ↑p = a * b → IsUnit a ∨ IsUnit b
⊢ False
[PROOFSTEP]
have := h ⟨1, 1⟩ ⟨1, -1⟩ (hp2.symm ▸ rfl)
[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp2 : p = 2
x✝ : Irreducible ↑p
not_unit✝ : ¬IsUnit ↑p
h : ∀ (a b : ℤ[i]), ↑p = a * b → IsUnit a ∨ IsUnit b
this : IsUnit { re := 1, im := 1 } ∨ IsUnit { re := 1, im := -1 }
⊢ False
[PROOFSTEP]
rw [← norm_eq_one_iff, ← norm_eq_one_iff] at this
[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp2 : p = 2
x✝ : Irreducible ↑p
not_unit✝ : ¬IsUnit ↑p
h : ∀ (a b : ℤ[i]), ↑p = a * b → IsUnit a ∨ IsUnit b
this : Int.natAbs (Zsqrtd.norm { re := 1, im := 1 }) = 1 ∨ Int.natAbs (Zsqrtd.norm { re := 1, im := -1 }) = 1
⊢ False
[PROOFSTEP]
exact absurd this (by decide)
[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp2 : p = 2
x✝ : Irreducible ↑p
not_unit✝ : ¬IsUnit ↑p
h : ∀ (a b : ℤ[i]), ↑p = a * b → IsUnit a ∨ IsUnit b
this : Int.natAbs (Zsqrtd.norm { re := 1, im := 1 }) = 1 ∨ Int.natAbs (Zsqrtd.norm { re := 1, im := -1 }) = 1
⊢ ¬(Int.natAbs (Zsqrtd.norm { re := 1, im := 1 }) = 1 ∨ Int.natAbs (Zsqrtd.norm { re := 1, im := -1 }) = 1)
[PROOFSTEP]
decide
[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 2 = 1
hp3 : p % 4 ≠ 3
⊢ False
[PROOFSTEP]
have hp41 : p % 4 = 1 := by
  rw [← Nat.mod_mul_left_mod p 2 2, show 2 * 2 = 4 from rfl] at hp1
  have := Nat.mod_lt p (show 0 < 4 by decide)
  revert this hp3 hp1
  generalize p % 4 = m
  intros;
  interval_cases m <;>
    simp_all
      -- Porting note: was `decide!`
[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 2 = 1
hp3 : p % 4 ≠ 3
⊢ p % 4 = 1
[PROOFSTEP]
rw [← Nat.mod_mul_left_mod p 2 2, show 2 * 2 = 4 from rfl] at hp1
[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 4 % 2 = 1
hp3 : p % 4 ≠ 3
⊢ p % 4 = 1
[PROOFSTEP]
have := Nat.mod_lt p (show 0 < 4 by decide)
[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 4 % 2 = 1
hp3 : p % 4 ≠ 3
⊢ 0 < 4
[PROOFSTEP]
decide
[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 4 % 2 = 1
hp3 : p % 4 ≠ 3
this : p % 4 < 4
⊢ p % 4 = 1
[PROOFSTEP]
revert this hp3 hp1
[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
⊢ p % 4 % 2 = 1 → p % 4 ≠ 3 → p % 4 < 4 → p % 4 = 1
[PROOFSTEP]
generalize p % 4 = m
[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
m : ℕ
⊢ m % 2 = 1 → m ≠ 3 → m < 4 → m = 1
[PROOFSTEP]
intros
[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
m : ℕ
hp1✝ : m % 2 = 1
hp3✝ : m ≠ 3
this✝ : m < 4
⊢ m = 1
[PROOFSTEP]
interval_cases m
[GOAL]
case «0»
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
m : ℕ
hp1✝ : 0 % 2 = 1
hp3✝ : 0 ≠ 3
this✝ : 0 < 4
⊢ 0 = 1
[PROOFSTEP]
simp_all
  -- Porting note: was `decide!`
[GOAL]
case «1»
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
m : ℕ
hp1✝ : 1 % 2 = 1
hp3✝ : 1 ≠ 3
this✝ : 1 < 4
⊢ 1 = 1
[PROOFSTEP]
simp_all
  -- Porting note: was `decide!`
[GOAL]
case «2»
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
m : ℕ
hp1✝ : 2 % 2 = 1
hp3✝ : 2 ≠ 3
this✝ : 2 < 4
⊢ 2 = 1
[PROOFSTEP]
simp_all
  -- Porting note: was `decide!`
[GOAL]
case «3»
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
m : ℕ
hp1✝ : 3 % 2 = 1
hp3✝ : 3 ≠ 3
this✝ : 3 < 4
⊢ 3 = 1
[PROOFSTEP]
simp_all
  -- Porting note: was `decide!`
[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 2 = 1
hp3 : p % 4 ≠ 3
hp41 : p % 4 = 1
⊢ False
[PROOFSTEP]
let ⟨k, hk⟩ := (ZMod.exists_sq_eq_neg_one_iff (p := p)).2 <| by rw [hp41]; exact by decide
[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 2 = 1
hp3 : p % 4 ≠ 3
hp41 : p % 4 = 1
⊢ p % 4 ≠ 3
[PROOFSTEP]
rw [hp41]
[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 2 = 1
hp3 : p % 4 ≠ 3
hp41 : p % 4 = 1
⊢ 1 ≠ 3
[PROOFSTEP]
exact by decide
[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 2 = 1
hp3 : p % 4 ≠ 3
hp41 : p % 4 = 1
⊢ 1 ≠ 3
[PROOFSTEP]
decide
[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 2 = 1
hp3 : p % 4 ≠ 3
hp41 : p % 4 = 1
k : ZMod p
hk : -1 = k * k
⊢ False
[PROOFSTEP]
obtain ⟨k, k_lt_p, rfl⟩ : ∃ (k' : ℕ) (_ : k' < p), (k' : ZMod p) = k := by
  refine' ⟨k.val, k.val_lt, ZMod.nat_cast_zmod_val k⟩
[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 2 = 1
hp3 : p % 4 ≠ 3
hp41 : p % 4 = 1
k : ZMod p
hk : -1 = k * k
⊢ ∃ k' x, ↑k' = k
[PROOFSTEP]
refine' ⟨k.val, k.val_lt, ZMod.nat_cast_zmod_val k⟩
[GOAL]
case intro.intro
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 2 = 1
hp3 : p % 4 ≠ 3
hp41 : p % 4 = 1
k : ℕ
k_lt_p : k < p
hk : -1 = ↑k * ↑k
⊢ False
[PROOFSTEP]
have hpk : p ∣ k ^ 2 + 1 := by
  rw [pow_two, ← CharP.cast_eq_zero_iff (ZMod p) p, Nat.cast_add, Nat.cast_mul, Nat.cast_one, ← hk, add_left_neg]
[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 2 = 1
hp3 : p % 4 ≠ 3
hp41 : p % 4 = 1
k : ℕ
k_lt_p : k < p
hk : -1 = ↑k * ↑k
⊢ p ∣ k ^ 2 + 1
[PROOFSTEP]
rw [pow_two, ← CharP.cast_eq_zero_iff (ZMod p) p, Nat.cast_add, Nat.cast_mul, Nat.cast_one, ← hk, add_left_neg]
[GOAL]
case intro.intro
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 2 = 1
hp3 : p % 4 ≠ 3
hp41 : p % 4 = 1
k : ℕ
k_lt_p : k < p
hk : -1 = ↑k * ↑k
hpk : p ∣ k ^ 2 + 1
⊢ False
[PROOFSTEP]
have hkmul : (k ^ 2 + 1 : ℤ[i]) = ⟨k, 1⟩ * ⟨k, -1⟩ := by simp [sq, Zsqrtd.ext]
[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 2 = 1
hp3 : p % 4 ≠ 3
hp41 : p % 4 = 1
k : ℕ
k_lt_p : k < p
hk : -1 = ↑k * ↑k
hpk : p ∣ k ^ 2 + 1
⊢ ↑(k ^ 2) + 1 = { re := ↑k, im := 1 } * { re := ↑k, im := -1 }
[PROOFSTEP]
simp [sq, Zsqrtd.ext]
[GOAL]
case intro.intro
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 2 = 1
hp3 : p % 4 ≠ 3
hp41 : p % 4 = 1
k : ℕ
k_lt_p : k < p
hk : -1 = ↑k * ↑k
hpk : p ∣ k ^ 2 + 1
hkmul : ↑(k ^ 2) + 1 = { re := ↑k, im := 1 } * { re := ↑k, im := -1 }
⊢ False
[PROOFSTEP]
have hkltp : 1 + k * k < p * p :=
  calc
    1 + k * k ≤ k + k * k := by
      apply add_le_add_right
      exact (Nat.pos_of_ne_zero fun (hk0 : k = 0) => by clear_aux_decl; simp_all [pow_succ'])
    _ = k * (k + 1) := by simp [add_comm, mul_add]
    _ < p * p := mul_lt_mul k_lt_p k_lt_p (Nat.succ_pos _) (Nat.zero_le _)
[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 2 = 1
hp3 : p % 4 ≠ 3
hp41 : p % 4 = 1
k : ℕ
k_lt_p : k < p
hk : -1 = ↑k * ↑k
hpk : p ∣ k ^ 2 + 1
hkmul : ↑(k ^ 2) + 1 = { re := ↑k, im := 1 } * { re := ↑k, im := -1 }
⊢ 1 + k * k ≤ k + k * k
[PROOFSTEP]
apply add_le_add_right
[GOAL]
case bc
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 2 = 1
hp3 : p % 4 ≠ 3
hp41 : p % 4 = 1
k : ℕ
k_lt_p : k < p
hk : -1 = ↑k * ↑k
hpk : p ∣ k ^ 2 + 1
hkmul : ↑(k ^ 2) + 1 = { re := ↑k, im := 1 } * { re := ↑k, im := -1 }
⊢ 1 ≤ k
[PROOFSTEP]
exact (Nat.pos_of_ne_zero fun (hk0 : k = 0) => by clear_aux_decl; simp_all [pow_succ'])
[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 2 = 1
hp3 : p % 4 ≠ 3
hp41 : p % 4 = 1
k : ℕ
k_lt_p : k < p
hk : -1 = ↑k * ↑k
hpk : p ∣ k ^ 2 + 1
hkmul : ↑(k ^ 2) + 1 = { re := ↑k, im := 1 } * { re := ↑k, im := -1 }
hk0 : k = 0
⊢ False
[PROOFSTEP]
clear_aux_decl
[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 2 = 1
hp3 : p % 4 ≠ 3
hp41 : p % 4 = 1
k : ℕ
k_lt_p : k < p
hk : -1 = ↑k * ↑k
hpk : p ∣ k ^ 2 + 1
hkmul : ↑(k ^ 2) + 1 = { re := ↑k, im := 1 } * { re := ↑k, im := -1 }
hk0 : k = 0
⊢ False
[PROOFSTEP]
simp_all [pow_succ']
[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 2 = 1
hp3 : p % 4 ≠ 3
hp41 : p % 4 = 1
k : ℕ
k_lt_p : k < p
hk : -1 = ↑k * ↑k
hpk : p ∣ k ^ 2 + 1
hkmul : ↑(k ^ 2) + 1 = { re := ↑k, im := 1 } * { re := ↑k, im := -1 }
⊢ k + k * k = k * (k + 1)
[PROOFSTEP]
simp [add_comm, mul_add]
[GOAL]
case intro.intro
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 2 = 1
hp3 : p % 4 ≠ 3
hp41 : p % 4 = 1
k : ℕ
k_lt_p : k < p
hk : -1 = ↑k * ↑k
hpk : p ∣ k ^ 2 + 1
hkmul : ↑(k ^ 2) + 1 = { re := ↑k, im := 1 } * { re := ↑k, im := -1 }
hkltp : 1 + k * k < p * p
⊢ False
[PROOFSTEP]
have hpk₁ : ¬(p : ℤ[i]) ∣ ⟨k, -1⟩ := fun ⟨x, hx⟩ =>
  lt_irrefl (p * x : ℤ[i]).norm.natAbs <|
    calc
      (norm (p * x : ℤ[i])).natAbs = (Zsqrtd.norm ⟨k, -1⟩).natAbs := by rw [hx]
      _ < (norm (p : ℤ[i])).natAbs := by simpa [add_comm, Zsqrtd.norm] using hkltp
      _ ≤ (norm (p * x : ℤ[i])).natAbs :=
        norm_le_norm_mul_left _ fun hx0 => show (-1 : ℤ) ≠ 0 by decide <| by simpa [hx0] using congr_arg Zsqrtd.im hx
[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 2 = 1
hp3 : p % 4 ≠ 3
hp41 : p % 4 = 1
k : ℕ
k_lt_p : k < p
hk : -1 = ↑k * ↑k
hpk : p ∣ k ^ 2 + 1
hkmul : ↑(k ^ 2) + 1 = { re := ↑k, im := 1 } * { re := ↑k, im := -1 }
hkltp : 1 + k * k < p * p
x✝ : ↑p ∣ { re := ↑k, im := -1 }
x : ℤ[i]
hx : { re := ↑k, im := -1 } = ↑p * x
⊢ Int.natAbs (Zsqrtd.norm (↑p * x)) = Int.natAbs (Zsqrtd.norm { re := ↑k, im := -1 })
[PROOFSTEP]
rw [hx]
[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 2 = 1
hp3 : p % 4 ≠ 3
hp41 : p % 4 = 1
k : ℕ
k_lt_p : k < p
hk : -1 = ↑k * ↑k
hpk : p ∣ k ^ 2 + 1
hkmul : ↑(k ^ 2) + 1 = { re := ↑k, im := 1 } * { re := ↑k, im := -1 }
hkltp : 1 + k * k < p * p
x✝ : ↑p ∣ { re := ↑k, im := -1 }
x : ℤ[i]
hx : { re := ↑k, im := -1 } = ↑p * x
⊢ Int.natAbs (Zsqrtd.norm { re := ↑k, im := -1 }) < Int.natAbs (Zsqrtd.norm ↑p)
[PROOFSTEP]
simpa [add_comm, Zsqrtd.norm] using hkltp
[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 2 = 1
hp3 : p % 4 ≠ 3
hp41 : p % 4 = 1
k : ℕ
k_lt_p : k < p
hk : -1 = ↑k * ↑k
hpk : p ∣ k ^ 2 + 1
hkmul : ↑(k ^ 2) + 1 = { re := ↑k, im := 1 } * { re := ↑k, im := -1 }
hkltp : 1 + k * k < p * p
x✝ : ↑p ∣ { re := ↑k, im := -1 }
x : ℤ[i]
hx : { re := ↑k, im := -1 } = ↑p * x
hx0 : x = 0
⊢ -1 ≠ 0
[PROOFSTEP]
decide
[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 2 = 1
hp3 : p % 4 ≠ 3
hp41 : p % 4 = 1
k : ℕ
k_lt_p : k < p
hk : -1 = ↑k * ↑k
hpk : p ∣ k ^ 2 + 1
hkmul : ↑(k ^ 2) + 1 = { re := ↑k, im := 1 } * { re := ↑k, im := -1 }
hkltp : 1 + k * k < p * p
x✝ : ↑p ∣ { re := ↑k, im := -1 }
x : ℤ[i]
hx : { re := ↑k, im := -1 } = ↑p * x
hx0 : x = 0
⊢ -1 = 0
[PROOFSTEP]
simpa [hx0] using congr_arg Zsqrtd.im hx
[GOAL]
case intro.intro
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 2 = 1
hp3 : p % 4 ≠ 3
hp41 : p % 4 = 1
k : ℕ
k_lt_p : k < p
hk : -1 = ↑k * ↑k
hpk : p ∣ k ^ 2 + 1
hkmul : ↑(k ^ 2) + 1 = { re := ↑k, im := 1 } * { re := ↑k, im := -1 }
hkltp : 1 + k * k < p * p
hpk₁ : ¬↑p ∣ { re := ↑k, im := -1 }
⊢ False
[PROOFSTEP]
have hpk₂ : ¬(p : ℤ[i]) ∣ ⟨k, 1⟩ := fun ⟨x, hx⟩ =>
  lt_irrefl (p * x : ℤ[i]).norm.natAbs <|
    calc
      (norm (p * x : ℤ[i])).natAbs = (Zsqrtd.norm ⟨k, 1⟩).natAbs := by rw [hx]
      _ < (norm (p : ℤ[i])).natAbs := by simpa [add_comm, Zsqrtd.norm] using hkltp
      _ ≤ (norm (p * x : ℤ[i])).natAbs :=
        norm_le_norm_mul_left _ fun hx0 => show (1 : ℤ) ≠ 0 by decide <| by simpa [hx0] using congr_arg Zsqrtd.im hx
[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 2 = 1
hp3 : p % 4 ≠ 3
hp41 : p % 4 = 1
k : ℕ
k_lt_p : k < p
hk : -1 = ↑k * ↑k
hpk : p ∣ k ^ 2 + 1
hkmul : ↑(k ^ 2) + 1 = { re := ↑k, im := 1 } * { re := ↑k, im := -1 }
hkltp : 1 + k * k < p * p
hpk₁ : ¬↑p ∣ { re := ↑k, im := -1 }
x✝ : ↑p ∣ { re := ↑k, im := 1 }
x : ℤ[i]
hx : { re := ↑k, im := 1 } = ↑p * x
⊢ Int.natAbs (Zsqrtd.norm (↑p * x)) = Int.natAbs (Zsqrtd.norm { re := ↑k, im := 1 })
[PROOFSTEP]
rw [hx]
[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 2 = 1
hp3 : p % 4 ≠ 3
hp41 : p % 4 = 1
k : ℕ
k_lt_p : k < p
hk : -1 = ↑k * ↑k
hpk : p ∣ k ^ 2 + 1
hkmul : ↑(k ^ 2) + 1 = { re := ↑k, im := 1 } * { re := ↑k, im := -1 }
hkltp : 1 + k * k < p * p
hpk₁ : ¬↑p ∣ { re := ↑k, im := -1 }
x✝ : ↑p ∣ { re := ↑k, im := 1 }
x : ℤ[i]
hx : { re := ↑k, im := 1 } = ↑p * x
⊢ Int.natAbs (Zsqrtd.norm { re := ↑k, im := 1 }) < Int.natAbs (Zsqrtd.norm ↑p)
[PROOFSTEP]
simpa [add_comm, Zsqrtd.norm] using hkltp
[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 2 = 1
hp3 : p % 4 ≠ 3
hp41 : p % 4 = 1
k : ℕ
k_lt_p : k < p
hk : -1 = ↑k * ↑k
hpk : p ∣ k ^ 2 + 1
hkmul : ↑(k ^ 2) + 1 = { re := ↑k, im := 1 } * { re := ↑k, im := -1 }
hkltp : 1 + k * k < p * p
hpk₁ : ¬↑p ∣ { re := ↑k, im := -1 }
x✝ : ↑p ∣ { re := ↑k, im := 1 }
x : ℤ[i]
hx : { re := ↑k, im := 1 } = ↑p * x
hx0 : x = 0
⊢ 1 ≠ 0
[PROOFSTEP]
decide
[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 2 = 1
hp3 : p % 4 ≠ 3
hp41 : p % 4 = 1
k : ℕ
k_lt_p : k < p
hk : -1 = ↑k * ↑k
hpk : p ∣ k ^ 2 + 1
hkmul : ↑(k ^ 2) + 1 = { re := ↑k, im := 1 } * { re := ↑k, im := -1 }
hkltp : 1 + k * k < p * p
hpk₁ : ¬↑p ∣ { re := ↑k, im := -1 }
x✝ : ↑p ∣ { re := ↑k, im := 1 }
x : ℤ[i]
hx : { re := ↑k, im := 1 } = ↑p * x
hx0 : x = 0
⊢ 1 = 0
[PROOFSTEP]
simpa [hx0] using congr_arg Zsqrtd.im hx
[GOAL]
case intro.intro
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 2 = 1
hp3 : p % 4 ≠ 3
hp41 : p % 4 = 1
k : ℕ
k_lt_p : k < p
hk : -1 = ↑k * ↑k
hpk : p ∣ k ^ 2 + 1
hkmul : ↑(k ^ 2) + 1 = { re := ↑k, im := 1 } * { re := ↑k, im := -1 }
hkltp : 1 + k * k < p * p
hpk₁ : ¬↑p ∣ { re := ↑k, im := -1 }
hpk₂ : ¬↑p ∣ { re := ↑k, im := 1 }
⊢ False
[PROOFSTEP]
obtain ⟨y, hy⟩ := hpk
[GOAL]
case intro.intro.intro
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 2 = 1
hp3 : p % 4 ≠ 3
hp41 : p % 4 = 1
k : ℕ
k_lt_p : k < p
hk : -1 = ↑k * ↑k
hkmul : ↑(k ^ 2) + 1 = { re := ↑k, im := 1 } * { re := ↑k, im := -1 }
hkltp : 1 + k * k < p * p
hpk₁ : ¬↑p ∣ { re := ↑k, im := -1 }
hpk₂ : ¬↑p ∣ { re := ↑k, im := 1 }
y : ℕ
hy : k ^ 2 + 1 = p * y
⊢ False
[PROOFSTEP]
have := hpi.2.2 ⟨k, 1⟩ ⟨k, -1⟩ ⟨y, by rw [← hkmul, ← Nat.cast_mul p, ← hy]; simp⟩
[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 2 = 1
hp3 : p % 4 ≠ 3
hp41 : p % 4 = 1
k : ℕ
k_lt_p : k < p
hk : -1 = ↑k * ↑k
hkmul : ↑(k ^ 2) + 1 = { re := ↑k, im := 1 } * { re := ↑k, im := -1 }
hkltp : 1 + k * k < p * p
hpk₁ : ¬↑p ∣ { re := ↑k, im := -1 }
hpk₂ : ¬↑p ∣ { re := ↑k, im := 1 }
y : ℕ
hy : k ^ 2 + 1 = p * y
⊢ { re := ↑k, im := 1 } * { re := ↑k, im := -1 } = ↑p * ↑y
[PROOFSTEP]
rw [← hkmul, ← Nat.cast_mul p, ← hy]
[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 2 = 1
hp3 : p % 4 ≠ 3
hp41 : p % 4 = 1
k : ℕ
k_lt_p : k < p
hk : -1 = ↑k * ↑k
hkmul : ↑(k ^ 2) + 1 = { re := ↑k, im := 1 } * { re := ↑k, im := -1 }
hkltp : 1 + k * k < p * p
hpk₁ : ¬↑p ∣ { re := ↑k, im := -1 }
hpk₂ : ¬↑p ∣ { re := ↑k, im := 1 }
y : ℕ
hy : k ^ 2 + 1 = p * y
⊢ ↑(k ^ 2) + 1 = ↑(k ^ 2 + 1)
[PROOFSTEP]
simp
[GOAL]
case intro.intro.intro
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 2 = 1
hp3 : p % 4 ≠ 3
hp41 : p % 4 = 1
k : ℕ
k_lt_p : k < p
hk : -1 = ↑k * ↑k
hkmul : ↑(k ^ 2) + 1 = { re := ↑k, im := 1 } * { re := ↑k, im := -1 }
hkltp : 1 + k * k < p * p
hpk₁ : ¬↑p ∣ { re := ↑k, im := -1 }
hpk₂ : ¬↑p ∣ { re := ↑k, im := 1 }
y : ℕ
hy : k ^ 2 + 1 = p * y
this : ↑p ∣ { re := ↑k, im := 1 } ∨ ↑p ∣ { re := ↑k, im := -1 }
⊢ False
[PROOFSTEP]
clear_aux_decl
[GOAL]
case intro.intro.intro
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 2 = 1
hp3 : p % 4 ≠ 3
hp41 : p % 4 = 1
k : ℕ
k_lt_p : k < p
hk : -1 = ↑k * ↑k
hkmul : ↑(k ^ 2) + 1 = { re := ↑k, im := 1 } * { re := ↑k, im := -1 }
hkltp : 1 + k * k < p * p
hpk₁ : ¬↑p ∣ { re := ↑k, im := -1 }
hpk₂ : ¬↑p ∣ { re := ↑k, im := 1 }
y : ℕ
hy : k ^ 2 + 1 = p * y
this : ↑p ∣ { re := ↑k, im := 1 } ∨ ↑p ∣ { re := ↑k, im := -1 }
⊢ False
[PROOFSTEP]
tauto
[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hp3 : p % 4 = 3
hpi : ¬Irreducible ↑p
a b : ℕ
hab : a ^ 2 + b ^ 2 = p
⊢ ∀ (a b : ZMod 4), a ^ 2 + b ^ 2 ≠ ↑p
[PROOFSTEP]
erw [← ZMod.nat_cast_mod p 4, hp3]
[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hp3 : p % 4 = 3
hpi : ¬Irreducible ↑p
a b : ℕ
hab : a ^ 2 + b ^ 2 = p
⊢ ∀ (a b : ZMod 4), a ^ 2 + b ^ 2 ≠ ↑3
[PROOFSTEP]
exact by decide
[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hp3 : p % 4 = 3
hpi : ¬Irreducible ↑p
a b : ℕ
hab : a ^ 2 + b ^ 2 = p
⊢ ∀ (a b : ZMod 4), a ^ 2 + b ^ 2 ≠ ↑3
[PROOFSTEP]
decide
[GOAL]
p : ℕ
hp : Fact (Nat.Prime p)
hp3 : p % 4 = 3
hpi : ¬Irreducible ↑p
a b : ℕ
hab : a ^ 2 + b ^ 2 = p
this : ∀ (a b : ZMod 4), a ^ 2 + b ^ 2 ≠ ↑p
⊢ ↑a ^ 2 + ↑b ^ 2 = ↑(a ^ 2 + b ^ 2)
[PROOFSTEP]
simp