ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Fin.succAbove_last_apply
lemma succAbove_last_apply (i : Fin n) : succAbove (last n) i = castSucc i 
Arguments: {n : ℕ} (i : Fin n)
Goal: (Fin.last n).succAbove i = i.castSucc
-- Fin.succAbove_lt_ge
@[deprecated (since := "2024-05-30")]
lemma succAbove_lt_ge (p : Fin (n + 1)) (i : Fin n) :
    castSucc i < p ∨ p ≤ castSucc i 
Arguments: {n : ℕ} (p : Fin (n + 1)) (i : Fin n)
Goal: i.castSucc < p ∨ p ≤ i.castSucc
-- Fin.succAbove_lt_iff_castSucc_lt
lemma succAbove_lt_iff_castSucc_lt (p : Fin (n + 1)) (i : Fin n) :
    p.succAbove i < p ↔ castSucc i < p 
Arguments: {n : ℕ} (p : Fin (n + 1)) (i : Fin n)
Goal: p.succAbove i < p ↔ i.castSucc < p
-- Fin.succAbove_lt_iff_succ_le
lemma succAbove_lt_iff_succ_le (p : Fin (n + 1)) (i : Fin n) :
    p.succAbove i < p ↔ succ i ≤ p 
Arguments: {n : ℕ} (p : Fin (n + 1)) (i : Fin n)
Goal: p.succAbove i < p ↔ i.succ ≤ p
-- Fin.lt_succAbove_iff_le_castSucc
lemma lt_succAbove_iff_le_castSucc (p : Fin (n + 1)) (i : Fin n) :
    p < p.succAbove i ↔ p ≤ castSucc i 
Arguments: {n : ℕ} (p : Fin (n + 1)) (i : Fin n)
Goal: p < p.succAbove i ↔ p ≤ i.castSucc
-- Fin.lt_succAbove_iff_lt_castSucc
lemma lt_succAbove_iff_lt_castSucc (p : Fin (n + 1)) (i : Fin n) :
    p < p.succAbove i ↔ p < succ i 
Arguments: {n : ℕ} (p : Fin (n + 1)) (i : Fin n)
Goal: p < p.succAbove i ↔ p < i.succ
-- Fin.succAbove_pos
lemma succAbove_pos [NeZero n] (p : Fin (n + 1)) (i : Fin n) (h : 0 < i) : 0 < p.succAbove i 
Arguments: {n : ℕ} [NeZero n] (p : Fin (n + 1)) (i : Fin n) (h : 0 < i)
Goal: 0 < p.succAbove i
-- Fin.castPred_succAbove
lemma castPred_succAbove (x : Fin n) (y : Fin (n + 1)) (h : castSucc x < y)
    (h' := Fin.ne_last_of_lt $ (succAbove_lt_iff_castSucc_lt ..).2 h) :
    (y.succAbove x).castPred h' = x 
Arguments: {n : ℕ} (x : Fin n) (y : Fin (n + 1)) (h : x.castSucc < y) (h' : y.succAbove x ≠ Fin.last n := ⋯)
Goal: (y.succAbove x).castPred h' = x
-- Fin.pred_succAbove
lemma pred_succAbove (x : Fin n) (y : Fin (n + 1)) (h : y ≤ castSucc x)
    (h' := Fin.ne_zero_of_lt $ (lt_succAbove_iff_le_castSucc ..).2 h) :
    (y.succAbove x).pred h' = x 
Arguments: {n : ℕ} (x : Fin n) (y : Fin (n + 1)) (h : y ≤ x.castSucc) (h' : y.succAbove x ≠ 0 := ⋯)
Goal: (y.succAbove x).pred h' = x
-- Fin.exists_succAbove_eq
lemma exists_succAbove_eq {x y : Fin (n + 1)} (h : x ≠ y) : ∃ z, y.succAbove z = x 
Arguments: {n : ℕ} {x y : Fin (n + 1)} (h : x ≠ y)
Goal: ∃ z, y.succAbove z = x
-- Fin.exists_succAbove_eq_iff
@[simp] lemma exists_succAbove_eq_iff {x y : Fin (n + 1)} : (∃ z, x.succAbove z = y) ↔ y ≠ x 
Arguments: {n : ℕ} {x y : Fin (n + 1)}
Goal: (∃ z, x.succAbove z = y) ↔ y ≠ x
-- Fin.range_succAbove
@[simp] lemma range_succAbove (p : Fin (n + 1)) : Set.range p.succAbove = {p}ᶜ 
Arguments: {n : ℕ} (p : Fin (n + 1))
Goal: Set.range p.succAbove = {p}ᶜ
-- Fin.range_succ
@[simp] lemma range_succ (n : ℕ) : Set.range (Fin.succ : Fin n → Fin (n + 1)) = {0}ᶜ 
Arguments: (n : ℕ)
Goal: Set.range Fin.succ = {0}ᶜ
-- Fin.succAbove_left_injective
lemma succAbove_left_injective : Injective (@succAbove n) 
Arguments: {n : ℕ}
Goal: Function.Injective Fin.succAbove
-- Fin.succAbove_left_inj
@[simp] lemma succAbove_left_inj {x y : Fin (n + 1)} : x.succAbove = y.succAbove ↔ x = y 
Arguments: {n : ℕ} {x y : Fin (n + 1)}
Goal: x.succAbove = y.succAbove ↔ x = y
-- Fin.zero_succAbove
@[simp] lemma zero_succAbove {n : ℕ} (i : Fin n) : (0 : Fin (n + 1)).succAbove i = i.succ 
Arguments: {n : ℕ} (i : Fin n)
Goal: Fin.succAbove 0 i = i.succ
-- Fin.succ_succAbove_zero
@[simp] lemma succ_succAbove_zero {n : ℕ} [NeZero n] (i : Fin n) : succAbove i.succ 0 = 0 
Arguments: {n : ℕ} [NeZero n] (i : Fin n)
Goal: i.succ.succAbove 0 = 0
-- Fin.succ_succAbove_succ
@[simp] lemma succ_succAbove_succ {n : ℕ} (i : Fin (n + 1)) (j : Fin n) :
    i.succ.succAbove j.succ = (i.succAbove j).succ 
Arguments: {n : ℕ} (i : Fin (n + 1)) (j : Fin n)
Goal: i.succ.succAbove j.succ = (i.succAbove j).succ
-- Fin.castSucc_succAbove_castSucc
@[simp]
lemma castSucc_succAbove_castSucc {n : ℕ} {i : Fin (n + 1)} {j : Fin n} :
    i.castSucc.succAbove j.castSucc = (i.succAbove j).castSucc 
Arguments: {n : ℕ} {i : Fin (n + 1)} {j : Fin n}
Goal: i.castSucc.succAbove j.castSucc = (i.succAbove j).castSucc
-- Fin.pred_succAbove_pred
lemma pred_succAbove_pred {a : Fin (n + 2)} {b : Fin (n + 1)} (ha : a ≠ 0) (hb : b ≠ 0)
    (hk := succAbove_ne_zero ha hb) :
    (a.pred ha).succAbove (b.pred hb) = (a.succAbove b).pred hk 
Arguments: {n : ℕ} {a : Fin (n + 2)} {b : Fin (n + 1)} (ha : a ≠ 0) (hb : b ≠ 0) (hk : a.succAbove b ≠ 0 := ⋯)
Goal: (a.pred ha).succAbove (b.pred hb) = (a.succAbove b).pred hk
-- Fin.castPred_succAbove_castPred
lemma castPred_succAbove_castPred {a : Fin (n + 2)} {b : Fin (n + 1)} (ha : a ≠ last (n + 1))
    (hb : b ≠ last n) (hk := succAbove_ne_last ha hb) :
    (a.castPred ha).succAbove (b.castPred hb) = (a.succAbove b).castPred hk 
Arguments: {n : ℕ} {a : Fin (n + 2)} {b : Fin (n + 1)} (ha : a ≠ Fin.last (n + 1)) (hb : b ≠ Fin.last n) (hk : a.succAbove b ≠ Fin.last (n + 1) := ⋯)
Goal: (a.castPred ha).succAbove (b.castPred hb) = (a.succAbove b).castPred hk
-- Fin.rev_succAbove
lemma rev_succAbove (p : Fin (n + 1)) (i : Fin n) :
    rev (succAbove p i) = succAbove (rev p) (rev i) 
Arguments: {n : ℕ} (p : Fin (n + 1)) (i : Fin n)
Goal: (p.succAbove i).rev = p.rev.succAbove i.rev
-- Fin.one_succAbove_zero
lemma one_succAbove_zero {n : ℕ} : (1 : Fin (n + 2)).succAbove 0 = 0 
Arguments: {n : ℕ}
Goal: Fin.succAbove 1 0 = 0
-- Fin.succ_succAbove_one
@[simp] lemma succ_succAbove_one {n : ℕ} [NeZero n] (i : Fin (n + 1)) :
    i.succ.succAbove 1 = (i.succAbove 0).succ 
Arguments: {n : ℕ} [NeZero n] (i : Fin (n + 1))
Goal: i.succ.succAbove 1 = (i.succAbove 0).succ
-- Fin.one_succAbove_succ
@[simp] lemma one_succAbove_succ {n : ℕ} (j : Fin n) :
    (1 : Fin (n + 2)).succAbove j.succ = j.succ.succ 
Arguments: {n : ℕ} (j : Fin n)
Goal: Fin.succAbove 1 j.succ = j.succ.succ
-- Fin.one_succAbove_one
@[simp] lemma one_succAbove_one {n : ℕ} : (1 : Fin (n + 3)).succAbove 1 = 2 
Arguments: {n : ℕ}
Goal: Fin.succAbove 1 1 = 2
-- Fin.predAbove_of_le_castSucc
lemma predAbove_of_le_castSucc (p : Fin n) (i : Fin (n + 1)) (h : i ≤ castSucc p)
    (hi := Fin.ne_of_lt $ Fin.lt_of_le_of_lt h $ castSucc_lt_last _) :
    p.predAbove i = i.castPred hi 
Arguments: {n : ℕ} (p : Fin n) (i : Fin (n + 1)) (h : i ≤ p.castSucc) (hi : i ≠ Fin.last n := ⋯)
Goal: p.predAbove i = i.castPred hi
-- Fin.predAbove_of_lt_succ
lemma predAbove_of_lt_succ (p : Fin n) (i : Fin (n + 1)) (h : i < succ p)
    (hi := Fin.ne_last_of_lt h) : p.predAbove i = i.castPred hi 
Arguments: {n : ℕ} (p : Fin n) (i : Fin (n + 1)) (h : i < p.succ) (hi : i ≠ Fin.last n := ⋯)
Goal: p.predAbove i = i.castPred hi
-- Fin.predAbove_of_castSucc_lt
lemma predAbove_of_castSucc_lt (p : Fin n) (i : Fin (n + 1)) (h : castSucc p < i)
    (hi := Fin.ne_zero_of_lt h) : p.predAbove i = i.pred hi 
Arguments: {n : ℕ} (p : Fin n) (i : Fin (n + 1)) (h : p.castSucc < i) (hi : i ≠ 0 := ⋯)
Goal: p.predAbove i = i.pred hi
-- Fin.predAbove_of_succ_le
lemma predAbove_of_succ_le (p : Fin n) (i : Fin (n + 1)) (h : succ p ≤ i)
    (hi := Fin.ne_of_gt $ Fin.lt_of_lt_of_le (succ_pos _) h) :
    p.predAbove i = i.pred hi 
Arguments: {n : ℕ} (p : Fin n) (i : Fin (n + 1)) (h : p.succ ≤ i) (hi : i ≠ 0 := ⋯)
Goal: p.predAbove i = i.pred hi
-- Fin.predAbove_succ_of_lt
lemma predAbove_succ_of_lt (p i : Fin n) (h : i < p) (hi := succ_ne_last_of_lt h) :
    p.predAbove (succ i) = (i.succ).castPred hi 
Arguments: {n : ℕ} (p i : Fin n) (h : i < p) (hi : i.succ ≠ Fin.last n := ⋯)
Goal: p.predAbove i.succ = i.succ.castPred hi
-- Fin.predAbove_succ_of_le
lemma predAbove_succ_of_le (p i : Fin n) (h : p ≤ i) : p.predAbove (succ i) = i 
Arguments: {n : ℕ} (p i : Fin n) (h : p ≤ i)
Goal: p.predAbove i.succ = i
-- Fin.predAbove_succ_self
@[simp] lemma predAbove_succ_self (p : Fin n) : p.predAbove (succ p) = p 
Arguments: {n : ℕ} (p : Fin n)
Goal: p.predAbove p.succ = p
-- Fin.predAbove_castSucc_of_lt
lemma predAbove_castSucc_of_lt (p i : Fin n) (h : p < i) (hi := castSucc_ne_zero_of_lt h) :
    p.predAbove (castSucc i) = i.castSucc.pred hi 
Arguments: {n : ℕ} (p i : Fin n) (h : p < i) (hi : i.castSucc ≠ 0 := ⋯)
Goal: p.predAbove i.castSucc = i.castSucc.pred hi
-- Fin.predAbove_castSucc_of_le
lemma predAbove_castSucc_of_le (p i : Fin n) (h : i ≤ p) : p.predAbove (castSucc i) = i 
Arguments: {n : ℕ} (p i : Fin n) (h : i ≤ p)
Goal: p.predAbove i.castSucc = i
-- Fin.predAbove_castSucc_self
@[simp] lemma predAbove_castSucc_self (p : Fin n) : p.predAbove (castSucc p) = p 
Arguments: {n : ℕ} (p : Fin n)
Goal: p.predAbove p.castSucc = p
-- Fin.predAbove_pred_of_lt
lemma predAbove_pred_of_lt (p i : Fin (n + 1)) (h : i < p) (hp := Fin.ne_zero_of_lt h)
    (hi := Fin.ne_last_of_lt h) : (pred p hp).predAbove i = castPred i hi 
Arguments: {n : ℕ} (p i : Fin (n + 1)) (h : i < p) (hp : p ≠ 0 := ⋯) (hi : i ≠ Fin.last n := ⋯)
Goal: (p.pred hp).predAbove i = i.castPred hi
-- Fin.predAbove_pred_of_le
lemma predAbove_pred_of_le (p i : Fin (n + 1)) (h : p ≤ i) (hp : p ≠ 0)
    (hi := Fin.ne_of_gt $ Fin.lt_of_lt_of_le (Fin.pos_iff_ne_zero.2 hp) h) :
  (pred p hp).predAbove i = pred i hi 
Arguments: {n : ℕ} (p i : Fin (n + 1)) (h : p ≤ i) (hp : p ≠ 0) (hi : i ≠ 0 := ⋯)
Goal: (p.pred hp).predAbove i = i.pred hi
-- Fin.predAbove_pred_self
lemma predAbove_pred_self (p : Fin (n + 1)) (hp : p ≠ 0) : (pred p hp).predAbove p = pred p hp 
Arguments: {n : ℕ} (p : Fin (n + 1)) (hp : p ≠ 0)
Goal: (p.pred hp).predAbove p = p.pred hp
-- Fin.predAbove_castPred_of_lt
lemma predAbove_castPred_of_lt (p i : Fin (n + 1)) (h : p < i) (hp := Fin.ne_last_of_lt h)
  (hi := Fin.ne_zero_of_lt h) : (castPred p hp).predAbove i = pred i hi 
Arguments: {n : ℕ} (p i : Fin (n + 1)) (h : p < i) (hp : p ≠ Fin.last n := ⋯) (hi : i ≠ 0 := ⋯)
Goal: (p.castPred hp).predAbove i = i.pred hi
-- Fin.predAbove_castPred_of_le
lemma predAbove_castPred_of_le (p i : Fin (n + 1)) (h : i ≤ p) (hp : p ≠ last n)
    (hi := Fin.ne_of_lt $ Fin.lt_of_le_of_lt h $ Fin.lt_last_iff_ne_last.2 hp) :
    (castPred p hp).predAbove i = castPred i hi 
Arguments: {n : ℕ} (p i : Fin (n + 1)) (h : i ≤ p) (hp : p ≠ Fin.last n) (hi : i ≠ Fin.last n := ⋯)
Goal: (p.castPred hp).predAbove i = i.castPred hi
-- Fin.predAbove_castPred_self
lemma predAbove_castPred_self (p : Fin (n + 1)) (hp : p ≠ last n) :
    (castPred p hp).predAbove p = castPred p hp 
Arguments: {n : ℕ} (p : Fin (n + 1)) (hp : p ≠ Fin.last n)
Goal: (p.castPred hp).predAbove p = p.castPred hp
-- Fin.predAbove_rev_left
lemma predAbove_rev_left (p : Fin n) (i : Fin (n + 1)) :
    p.rev.predAbove i = (p.predAbove i.rev).rev 
Arguments: {n : ℕ} (p : Fin n) (i : Fin (n + 1))
Goal: p.rev.predAbove i = (p.predAbove i.rev).rev
-- Fin.predAbove_rev_right
lemma predAbove_rev_right (p : Fin n) (i : Fin (n + 1)) :
    p.predAbove i.rev = (p.rev.predAbove i).rev 
Arguments: {n : ℕ} (p : Fin n) (i : Fin (n + 1))
Goal: p.predAbove i.rev = (p.rev.predAbove i).rev
-- Fin.predAbove_right_zero
@[simp] lemma predAbove_right_zero [NeZero n] {i : Fin n} : predAbove (i : Fin n) 0 = 0 
Arguments: {n : ℕ} [NeZero n] {i : Fin n}
Goal: i.predAbove 0 = 0
-- Fin.predAbove_zero_succ
@[simp] lemma predAbove_zero_succ [NeZero n] {i : Fin n} : predAbove 0 i.succ = i 
Arguments: {n : ℕ} [NeZero n] {i : Fin n}
Goal: Fin.predAbove 0 i.succ = i
-- Fin.succ_predAbove_zero
@[simp]
lemma succ_predAbove_zero [NeZero n] {j : Fin (n + 1)} (h : j ≠ 0) : succ (predAbove 0 j) = j 
Arguments: {n : ℕ} [NeZero n] {j : Fin (n + 1)} (h : j ≠ 0)
Goal: (Fin.predAbove 0 j).succ = j
-- Fin.predAbove_zero_of_ne_zero
@[simp] lemma predAbove_zero_of_ne_zero [NeZero n] {i : Fin (n + 1)} (hi : i ≠ 0) :
    predAbove 0 i = i.pred hi 
Arguments: {n : ℕ} [NeZero n] {i : Fin (n + 1)} (hi : i ≠ 0)
Goal: Fin.predAbove 0 i = i.pred hi
-- Fin.predAbove_zero
lemma predAbove_zero [NeZero n] {i : Fin (n + 1)} :
    predAbove (0 : Fin n) i = if hi : i = 0 then 0 else i.pred hi 
Arguments: {n : ℕ} [NeZero n] {i : Fin (n + 1)}
Goal: Fin.predAbove 0 i = if hi : i = 0 then 0 else i.pred hi
-- Fin.predAbove_right_last
@[simp] lemma predAbove_right_last {i : Fin (n + 1)} : predAbove i (last (n + 1)) = last n 
Arguments: {n : ℕ} {i : Fin (n + 1)}
Goal: i.predAbove (Fin.last (n + 1)) = Fin.last n
-- Fin.predAbove_last_castSucc
@[simp] lemma predAbove_last_castSucc {i : Fin (n + 1)} : predAbove (last n) (i.castSucc) = i 
Arguments: {n : ℕ} {i : Fin (n + 1)}
Goal: (Fin.last n).predAbove i.castSucc = i
-- Fin.predAbove_last_of_ne_last
@[simp] lemma predAbove_last_of_ne_last {i : Fin (n + 2)} (hi : i ≠ last (n + 1)) :
    predAbove (last n) i = castPred i hi 
Arguments: {n : ℕ} {i : Fin (n + 2)} (hi : i ≠ Fin.last (n + 1))
Goal: (Fin.last n).predAbove i = i.castPred hi
-- Fin.predAbove_last_apply
lemma predAbove_last_apply {i : Fin (n + 2)} :
    predAbove (last n) i = if hi : i = last _ then last _ else i.castPred hi 
Arguments: {n : ℕ} {i : Fin (n + 2)}
Goal: (Fin.last n).predAbove i = if hi : i = Fin.last (n + 1) then Fin.last n else i.castPred hi
-- Fin.succAbove_predAbove
@[simp]
lemma succAbove_predAbove {p : Fin n} {i : Fin (n + 1)} (h : i ≠ castSucc p) :
    p.castSucc.succAbove (p.predAbove i) = i 
Arguments: {n : ℕ} {p : Fin n} {i : Fin (n + 1)} (h : i ≠ p.castSucc)
Goal: p.castSucc.succAbove (p.predAbove i) = i
-- Fin.predAbove_succAbove
@[simp]
lemma predAbove_succAbove (p : Fin n) (i : Fin n) : p.predAbove ((castSucc p).succAbove i) = i 
Arguments: {n : ℕ} (p i : Fin n)
Goal: p.predAbove (p.castSucc.succAbove i) = i
-- Fin.succ_predAbove_succ
@[simp] lemma succ_predAbove_succ (a : Fin n) (b : Fin (n + 1)) :
    a.succ.predAbove b.succ = (a.predAbove b).succ 
Arguments: {n : ℕ} (a : Fin n) (b : Fin (n + 1))
Goal: a.succ.predAbove b.succ = (a.predAbove b).succ
-- Fin.castSucc_predAbove_castSucc
@[simp] lemma castSucc_predAbove_castSucc {n : ℕ} (a : Fin n) (b : Fin (n + 1)) :
    a.castSucc.predAbove b.castSucc = (a.predAbove b).castSucc 
Arguments: {n : ℕ} (a : Fin n) (b : Fin (n + 1))
Goal: a.castSucc.predAbove b.castSucc = (a.predAbove b).castSucc
-- Fin.rev_predAbove
lemma rev_predAbove {n : ℕ} (p : Fin n) (i : Fin (n + 1)) :
    (predAbove p i).rev = predAbove p.rev i.rev 
Arguments: {n : ℕ} (p : Fin n) (i : Fin (n + 1))
Goal: (p.predAbove i).rev = p.rev.predAbove i.rev
-- Fin.coe_divNat
@[simp]
theorem coe_divNat (i : Fin (m * n)) : (i.divNat : ℕ) = i / n 
Arguments: {n m : ℕ} (i : Fin (m * n))
Goal: ↑i.divNat = ↑i / n
-- Fin.coe_modNat
@[simp]
theorem coe_modNat (i : Fin (m * n)) : (i.modNat : ℕ) = i % n 
Arguments: {n m : ℕ} (i : Fin (m * n))
Goal: ↑i.modNat = ↑i % n
-- Fin.modNat_rev
theorem modNat_rev (i : Fin (m * n)) : i.rev.modNat = i.modNat.rev 
Arguments: {n m : ℕ} (i : Fin (m * n))
Goal: i.rev.modNat = i.modNat.rev
-- Fin.liftFun_iff_succ
theorem liftFun_iff_succ {α : Type*} (r : α → α → Prop) [IsTrans α r] {f : Fin (n + 1) → α} :
    ((· < ·) ⇒ r) f f ↔ ∀ i : Fin n, r (f (castSucc i)) (f i.succ) 
Arguments: {n : ℕ} {α : Type u_1} (r : α → α → Prop) [IsTrans α r] {f : Fin (n + 1) → α}
Goal: ((fun x x_1 => x < x_1) ⇒ r) f f ↔ ∀ (i : Fin n), r (f i.castSucc) (f i.succ)
-- Fin.neg_def
theorem neg_def (a : Fin n) : -a = ⟨(n - a) % n, Nat.mod_lt _ a.pos⟩ 
Arguments: {n : ℕ} (a : Fin n)
Goal: -a = ⟨(n - ↑a) % n, ⋯⟩
-- Fin.coe_neg
protected theorem coe_neg (a : Fin n) : ((-a : Fin n) : ℕ) = (n - a) % n 
Arguments: {n : ℕ} (a : Fin n)
Goal: ↑(-a) = (n - ↑a) % n
-- Fin.eq_zero
theorem eq_zero (n : Fin 1) : n = 0 
Arguments: (n : Fin 1)
Goal: n = 0
-- Fin.coe_fin_one
@[simp]
theorem coe_fin_one (a : Fin 1) : (a : ℕ) = 0 
Arguments: (a : Fin 1)
Goal: ↑a = 0
-- Fin.eq_one_of_neq_zero
lemma eq_one_of_neq_zero (i : Fin 2) (hi : i ≠ 0) : i = 1 
Arguments: (i : Fin 2) (hi : i ≠ 0)
Goal: i = 1
-- Fin.coe_neg_one
@[simp]
theorem coe_neg_one : ↑(-1 : Fin (n + 1)) = n 
Arguments: {n : ℕ}
Goal: ↑(-1) = n
-- Fin.last_sub
theorem last_sub (i : Fin (n + 1)) : last n - i = Fin.rev i 
Arguments: {n : ℕ} (i : Fin (n + 1))
Goal: Fin.last n - i = i.rev
-- Fin.add_one_le_of_lt
theorem add_one_le_of_lt {n : ℕ} {a b : Fin (n + 1)} (h : a < b) : a + 1 ≤ b 
Arguments: {n : ℕ} {a b : Fin (n + 1)} (h : a < b)
Goal: a + 1 ≤ b
-- Fin.exists_eq_add_of_le
theorem exists_eq_add_of_le {n : ℕ} {a b : Fin n} (h : a ≤ b) : ∃ k ≤ b, b = a + k 
Arguments: {n : ℕ} {a b : Fin n} (h : a ≤ b)
Goal: ∃ k ≤ b, b = a + k
-- Fin.exists_eq_add_of_lt
theorem exists_eq_add_of_lt {n : ℕ} {a b : Fin (n + 1)} (h : a < b) :
    ∃ k < b, k + 1 ≤ b ∧ b = a + k + 1 
Arguments: {n : ℕ} {a b : Fin (n + 1)} (h : a < b)
Goal: ∃ k < b, k + 1 ≤ b ∧ b = a + k + 1
-- Fin.pos_of_ne_zero
lemma pos_of_ne_zero {n : ℕ} {a : Fin (n + 1)} (h : a ≠ 0) :
    0 < a 
Arguments: {n : ℕ} {a : Fin (n + 1)} (h : a ≠ 0)
Goal: 0 < a
-- Fin.coe_ofNat_eq_mod
@[simp]
theorem coe_ofNat_eq_mod (m n : ℕ) [NeZero m] :
    ((n : Fin m) : ℕ) = n % m 
Arguments: (m n : ℕ) [NeZero m]
Goal: ↑↑n = n % m
-- Fin.mul_one'
protected theorem mul_one' [NeZero n] (k : Fin n) : k * 1 = k 
Arguments: {n : ℕ} [NeZero n] (k : Fin n)
Goal: k * 1 = k
-- Fin.one_mul'
protected theorem one_mul' [NeZero n] (k : Fin n) : (1 : Fin n) * k = k 
Arguments: {n : ℕ} [NeZero n] (k : Fin n)
Goal: 1 * k = k
-- Fin.mul_zero'
protected theorem mul_zero' [NeZero n] (k : Fin n) : k * 0 = 0 
Arguments: {n : ℕ} [NeZero n] (k : Fin n)
Goal: k * 0 = 0
-- Fin.zero_mul'
protected theorem zero_mul' [NeZero n] (k : Fin n) : (0 : Fin n) * k = 0 
Arguments: {n : ℕ} [NeZero n] (k : Fin n)
Goal: 0 * k = 0
-- Nat.Subtype.coe_bot
theorem Subtype.coe_bot {s : Set ℕ} [DecidablePred (· ∈ s)] [h : Nonempty s] :
    ((⊥ : s) : ℕ) = Nat.find (nonempty_subtype.1 h) 
Arguments: {s : Set ℕ} [DecidablePred fun x => x ∈ s] [h : Nonempty ↑s]
Goal: ↑⊥ = Nat.find ⋯
-- Nat.set_eq_univ
theorem set_eq_univ {S : Set ℕ} : S = Set.univ ↔ 0 ∈ S ∧ ∀ k : ℕ, k ∈ S → k + 1 ∈ S 
Arguments: {S : Set ℕ}
Goal: S = Set.univ ↔ 0 ∈ S ∧ ∀ k ∈ S, k + 1 ∈ S
-- Nat.exists_not_and_succ_of_not_zero_of_exists
lemma exists_not_and_succ_of_not_zero_of_exists {p : ℕ → Prop} (H' : ¬ p 0) (H : ∃ n, p n) :
    ∃ n, ¬ p n ∧ p (n + 1) 
Arguments: {p : ℕ → Prop} (H' : ¬p 0) (H : ∃ n, p n)
Goal: ∃ n, ¬p n ∧ p (n + 1)
-- Nat.AtLeastTwo.prop
class Nat.AtLeastTwo (n : ℕ) : Prop where
  prop : n ≥ 2
Arguments: {n : ℕ} [self : n.AtLeastTwo]
Goal: n ≥ 2
-- Nat.AtLeastTwo.one_lt
lemma one_lt : 1 < n 
Arguments: {n : ℕ} [n.AtLeastTwo]
Goal: 1 < n
-- Nat.AtLeastTwo.ne_one
lemma ne_one : n ≠ 1 
Arguments: {n : ℕ} [n.AtLeastTwo]
Goal: n ≠ 1
-- Nat.cast_ofNat
@[simp, norm_cast] theorem Nat.cast_ofNat {n : ℕ} [NatCast R] [Nat.AtLeastTwo n] :
  (Nat.cast (no_index (OfNat.ofNat n)) : R) = OfNat.ofNat n 
Arguments: {R : Type u_1} {n : ℕ} [NatCast R] [n.AtLeastTwo]
Goal: ↑(OfNat.ofNat n) = OfNat.ofNat n
-- Nat.cast_eq_ofNat
theorem Nat.cast_eq_ofNat {n : ℕ} [NatCast R] [Nat.AtLeastTwo n] :
    (Nat.cast n : R) = OfNat.ofNat n 
Arguments: {R : Type u_1} {n : ℕ} [NatCast R] [n.AtLeastTwo]
Goal: ↑n = OfNat.ofNat n
-- AddMonoidWithOne.natCast_succ
class AddMonoidWithOne (R : Type*) extends NatCast R, AddMonoid R, One R where
  natCast := Nat.unaryCast
    natCast_zero : natCast 0 = 0 := by intros; rfl
    natCast_succ : ∀ n, natCast (n + 1) = natCast n + 1 := by intros; rfl
Arguments: {R : Type u_2} [self : AddMonoidWithOne R] (n : ℕ)
Goal: NatCast.natCast (n + 1) = NatCast.natCast n + 1
-- AddMonoidWithOne.natCast_zero
class AddMonoidWithOne (R : Type*) extends NatCast R, AddMonoid R, One R where
  natCast := Nat.unaryCast
    natCast_zero : natCast 0 = 0 := by intros; rfl
    natCast_succ : ∀ n, natCast (n + 1) = natCast n + 1 := by intros; rfl
Arguments: {R : Type u_2} [self : AddMonoidWithOne R]
Goal: NatCast.natCast 0 = 0
-- Nat.cast_zero
@[simp, norm_cast]
theorem cast_zero : ((0 : ℕ) : R) = 0 
Arguments: {R : Type u_1} [AddMonoidWithOne R]
Goal: ↑0 = 0
-- Nat.cast_succ
@[norm_cast 500]
theorem cast_succ (n : ℕ) : ((succ n : ℕ) : R) = n + 1 
Arguments: {R : Type u_1} [AddMonoidWithOne R] (n : ℕ)
Goal: ↑n.succ = ↑n + 1
-- Nat.cast_add_one
theorem cast_add_one (n : ℕ) : ((n + 1 : ℕ) : R) = n + 1 
Arguments: {R : Type u_1} [AddMonoidWithOne R] (n : ℕ)
Goal: ↑(n + 1) = ↑n + 1
-- Nat.cast_ite
@[simp, norm_cast]
theorem cast_ite (P : Prop) [Decidable P] (m n : ℕ) :
    ((ite P m n : ℕ) : R) = ite P (m : R) (n : R) 
Arguments: {R : Type u_1} [AddMonoidWithOne R] (P : Prop) [Decidable P] (m n : ℕ)
Goal: ↑(if P then m else n) = if P then ↑m else ↑n
-- Nat.cast_one
@[simp, norm_cast]
theorem cast_one [AddMonoidWithOne R] : ((1 : ℕ) : R) = 1 
Arguments: {R : Type u_1} [AddMonoidWithOne R]
Goal: ↑1 = 1
-- Nat.cast_add
@[simp, norm_cast]
theorem cast_add [AddMonoidWithOne R] (m n : ℕ) : ((m + n : ℕ) : R) = m + n 
Arguments: {R : Type u_1} [AddMonoidWithOne R] (m n : ℕ)
Goal: ↑(m + n) = ↑m + ↑n
-- Nat.binCast_eq
@[simp]
theorem binCast_eq [AddMonoidWithOne R] (n : ℕ) :
    (Nat.binCast n : R) = ((n : ℕ) : R) 
Arguments: {R : Type u_1} [AddMonoidWithOne R] (n : ℕ)
Goal: n.binCast = ↑n
-- Nat.cast_two
theorem cast_two [AddMonoidWithOne R] : ((2 : ℕ) : R) = (2 : R) 
Arguments: {R : Type u_1} [AddMonoidWithOne R]
Goal: ↑2 = 2
-- one_add_one_eq_two
theorem one_add_one_eq_two [AddMonoidWithOne R] : 1 + 1 = (2 : R) 
Arguments: {R : Type u_1} [AddMonoidWithOne R]
Goal: 1 + 1 = 2
-- two_add_one_eq_three
theorem two_add_one_eq_three [AddMonoidWithOne R] : 2 + 1 = (3 : R) 
Arguments: {R : Type u_1} [AddMonoidWithOne R]
Goal: 2 + 1 = 3
-- three_add_one_eq_four
theorem three_add_one_eq_four [AddMonoidWithOne R] : 3 + 1 = (4 : R) 
Arguments: {R : Type u_1} [AddMonoidWithOne R]
Goal: 3 + 1 = 4
-- Nat.succ_eq_succ
@[simp]
theorem succ_eq_succ : Order.succ = succ 
Goal: Order.succ = Nat.succ
-- Nat.pred_eq_pred
@[simp]
theorem pred_eq_pred : Order.pred = pred 
Goal: Order.pred = Nat.pred
-- Nat.succ_iterate
theorem succ_iterate (a : ℕ) : ∀ n, succ^[n] a = a + n
  
Arguments: (a n : ℕ)
Goal: Nat.succ^[n] a = a + n
-- Nat.pred_iterate
theorem pred_iterate (a : ℕ) : ∀ n, pred^[n] a = a - n
  
Arguments: (a n : ℕ)
Goal: Nat.pred^[n] a = a - n
-- Nat.le_succ_iff_eq_or_le
lemma le_succ_iff_eq_or_le : m ≤ n.succ ↔ m = n.succ ∨ m ≤ n 
Arguments: {m n : ℕ}
Goal: m ≤ n.succ ↔ m = n.succ ∨ m ≤ n
-- Nat.forall_ne_zero_iff
lemma forall_ne_zero_iff (P : ℕ → Prop) :
    (∀ i, i ≠ 0 → P i) ↔ (∀ i, P (i + 1)) 
Arguments: (P : ℕ → Prop)
Goal: (∀ (i : ℕ), i ≠ 0 → P i) ↔ ∀ (i : ℕ), P (i + 1)
-- Nat.covBy_iff_succ_eq
protected theorem covBy_iff_succ_eq {m n : ℕ} : m ⋖ n ↔ m + 1 = n 
Arguments: {m n : ℕ}
Goal: m ⋖ n ↔ m + 1 = n
-- Fin.coe_covBy_iff
@[simp, norm_cast]
theorem Fin.coe_covBy_iff {n : ℕ} {a b : Fin n} : (a : ℕ) ⋖ b ↔ a ⋖ b 
Arguments: {n : ℕ} {a b : Fin n}
Goal: ↑a ⋖ ↑b ↔ a ⋖ b
-- hyperoperation_zero
@[simp]
theorem hyperoperation_zero (m : ℕ) : hyperoperation 0 m = Nat.succ 
Arguments: (m : ℕ)
Goal: hyperoperation 0 m = Nat.succ
-- hyperoperation_ge_three_eq_one
theorem hyperoperation_ge_three_eq_one (n m : ℕ) : hyperoperation (n + 3) m 0 = 1 
Arguments: (n m : ℕ)
Goal: hyperoperation (n + 3) m 0 = 1
-- hyperoperation_recursion
theorem hyperoperation_recursion (n m k : ℕ) :
    hyperoperation (n + 1) m (k + 1) = hyperoperation n m (hyperoperation (n + 1) m k) 
Arguments: (n m k : ℕ)
Goal: hyperoperation (n + 1) m (k + 1) = hyperoperation n m (hyperoperation (n + 1) m k)
-- hyperoperation_one
@[simp]
theorem hyperoperation_one : hyperoperation 1 = (· + ·) 
Goal: hyperoperation 1 = fun x x_1 => x + x_1
-- hyperoperation_two
@[simp]
theorem hyperoperation_two : hyperoperation 2 = (· * ·) 
Goal: hyperoperation 2 = fun x x_1 => x * x_1
-- hyperoperation_three
@[simp]
theorem hyperoperation_three : hyperoperation 3 = (· ^ ·) 
Goal: hyperoperation 3 = fun x x_1 => x ^ x_1
-- hyperoperation_ge_two_eq_self
theorem hyperoperation_ge_two_eq_self (n m : ℕ) : hyperoperation (n + 2) m 1 = m 
Arguments: (n m : ℕ)
Goal: hyperoperation (n + 2) m 1 = m
-- hyperoperation_two_two_eq_four
theorem hyperoperation_two_two_eq_four (n : ℕ) : hyperoperation (n + 1) 2 2 = 4 
Arguments: (n : ℕ)
Goal: hyperoperation (n + 1) 2 2 = 4
-- hyperoperation_ge_three_one
theorem hyperoperation_ge_three_one (n : ℕ) : ∀ k : ℕ, hyperoperation (n + 3) 1 k = 1 
Arguments: (n k : ℕ)
Goal: hyperoperation (n + 3) 1 k = 1
-- hyperoperation_ge_four_zero
theorem hyperoperation_ge_four_zero (n k : ℕ) :
    hyperoperation (n + 4) 0 k = if Even k then 1 else 0 
Arguments: (n k : ℕ)
Goal: hyperoperation (n + 4) 0 k = if Even k then 1 else 0
-- ENNReal.none_eq_top
@[simp] theorem none_eq_top : (none : ℝ≥0∞) = ∞ 
Goal: none = ⊤