ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- finCongr_apply_mk
@[simp] lemma _root_.finCongr_apply_mk (h : m = n) (k : ℕ) (hk : k < m) :
    finCongr h ⟨k, hk⟩ = ⟨k, h ▸ hk⟩ 
Arguments: {n m : ℕ} (h : m = n) (k : ℕ) (hk : k < m)
Goal: (finCongr h) ⟨k, hk⟩ = ⟨k, ⋯⟩
-- finCongr_refl
@[simp]
lemma _root_.finCongr_refl (h : n = n := rfl) : finCongr h = Equiv.refl (Fin n) 
Arguments: {n : ℕ} (h : n = n := ⋯)
Goal: finCongr h = Equiv.refl (Fin n)
-- finCongr_symm
@[simp] lemma _root_.finCongr_symm (h : m = n) : (finCongr h).symm = finCongr h.symm 
Arguments: {n m : ℕ} (h : m = n)
Goal: (finCongr h).symm = finCongr ⋯
-- finCongr_apply_coe
@[simp] lemma _root_.finCongr_apply_coe (h : m = n) (k : Fin m) : (finCongr h k : ℕ) = k 
Arguments: {n m : ℕ} (h : m = n) (k : Fin m)
Goal: ↑((finCongr h) k) = ↑k
-- finCongr_symm_apply_coe
lemma _root_.finCongr_symm_apply_coe (h : m = n) (k : Fin n) : ((finCongr h).symm k : ℕ) = k 
Arguments: {n m : ℕ} (h : m = n) (k : Fin n)
Goal: ↑((finCongr h).symm k) = ↑k
-- finCongr_eq_equivCast
lemma _root_.finCongr_eq_equivCast (h : n = m) : finCongr h = .cast (h ▸ rfl) 
Arguments: {n m : ℕ} (h : n = m)
Goal: finCongr h = Equiv.cast ⋯
-- Fin.cast_zero
@[simp]
theorem cast_zero {n' : ℕ} [NeZero n] {h : n = n'} : cast h (0 : Fin n) =
    by { haveI : NeZero n' := by {rw [← h]; infer_instance}; exact 0} 
Arguments: {n n' : ℕ} [NeZero n] {h : n = n'}
Goal: Fin.cast h 0 = 0
-- Fin.cast_eq_cast
theorem cast_eq_cast (h : n = m) : (cast h : Fin n → Fin m) = _root_.cast (h ▸ rfl) 
Arguments: {n m : ℕ} (h : n = m)
Goal: Fin.cast h = cast ⋯
-- Fin.castAddEmb_apply
@[simps! apply]
def castAddEmb (m) : Fin n ↪ Fin (n + m) 
Arguments: {n : ℕ} (m : ℕ) (i : Fin n)
Goal: (Fin.castAddEmb m) i = Fin.castLE ⋯ i
-- Fin.castSuccEmb_apply
@[simps! apply]
def castSuccEmb : Fin n ↪ Fin (n + 1) 
Arguments: {n : ℕ} (i : Fin n)
Goal: Fin.castSuccEmb i = Fin.castLE ⋯ i
-- Fin.coe_castSuccEmb
@[simp, norm_cast] lemma coe_castSuccEmb : (castSuccEmb : Fin n → Fin (n + 1)) = Fin.castSucc 
Arguments: {n : ℕ}
Goal: ⇑Fin.castSuccEmb = Fin.castSucc
-- Fin.castSucc_le_castSucc_iff
@[simp]
theorem castSucc_le_castSucc_iff {a b : Fin n} : castSucc a ≤ castSucc b ↔ a ≤ b 
Arguments: {n : ℕ} {a b : Fin n}
Goal: a.castSucc ≤ b.castSucc ↔ a ≤ b
-- Fin.succ_le_castSucc_iff
@[simp]
theorem succ_le_castSucc_iff {a b : Fin n} : succ a ≤ castSucc b ↔ a < b 
Arguments: {n : ℕ} {a b : Fin n}
Goal: a.succ ≤ b.castSucc ↔ a < b
-- Fin.castSucc_lt_succ_iff
@[simp]
theorem castSucc_lt_succ_iff {a b : Fin n} : castSucc a < succ b ↔ a ≤ b 
Arguments: {n : ℕ} {a b : Fin n}
Goal: a.castSucc < b.succ ↔ a ≤ b
-- Fin.le_of_castSucc_lt_of_succ_lt
theorem le_of_castSucc_lt_of_succ_lt {a b : Fin (n + 1)} {i : Fin n}
    (hl : castSucc i < a) (hu : b < succ i) : b < a 
Arguments: {n : ℕ} {a b : Fin (n + 1)} {i : Fin n} (hl : i.castSucc < a) (hu : b < i.succ)
Goal: b < a
-- Fin.castSucc_lt_or_lt_succ
theorem castSucc_lt_or_lt_succ (p : Fin (n + 1)) (i : Fin n) : castSucc i < p ∨ p < i.succ 
Arguments: {n : ℕ} (p : Fin (n + 1)) (i : Fin n)
Goal: i.castSucc < p ∨ p < i.succ
-- Fin.succ_le_or_le_castSucc
theorem succ_le_or_le_castSucc (p : Fin (n + 1)) (i : Fin n) : succ i ≤ p ∨ p ≤ i.castSucc 
Arguments: {n : ℕ} (p : Fin (n + 1)) (i : Fin n)
Goal: i.succ ≤ p ∨ p ≤ i.castSucc
-- Fin.exists_castSucc_eq_of_ne_last
theorem exists_castSucc_eq_of_ne_last {x : Fin (n + 1)} (h : x ≠ (last _)) :
    ∃ y, Fin.castSucc y = x 
Arguments: {n : ℕ} {x : Fin (n + 1)} (h : x ≠ Fin.last n)
Goal: ∃ y, y.castSucc = x
-- Fin.forall_fin_succ'
theorem forall_fin_succ' {P : Fin (n + 1) → Prop} :
    (∀ i, P i) ↔ (∀ i : Fin n, P i.castSucc) ∧ P (.last _) 
Arguments: {n : ℕ} {P : Fin (n + 1) → Prop}
Goal: (∀ (i : Fin (n + 1)), P i) ↔ (∀ (i : Fin n), P i.castSucc) ∧ P (Fin.last n)
-- Fin.eq_castSucc_or_eq_last
theorem eq_castSucc_or_eq_last {n : Nat} (i : Fin (n + 1)) :
    (∃ j : Fin n, i = j.castSucc) ∨ i = last n 
Arguments: {n : ℕ} (i : Fin (n + 1))
Goal: (∃ j, i = j.castSucc) ∨ i = Fin.last n
-- Fin.exists_fin_succ'
theorem exists_fin_succ' {P : Fin (n + 1) → Prop} :
    (∃ i, P i) ↔ (∃ i : Fin n, P i.castSucc) ∨ P (.last _) 
Arguments: {n : ℕ} {P : Fin (n + 1) → Prop}
Goal: (∃ i, P i) ↔ (∃ i, P i.castSucc) ∨ P (Fin.last n)
-- Fin.castSucc_zero'
@[simp]
theorem castSucc_zero' [NeZero n] : castSucc (0 : Fin n) = 0 
Arguments: {n : ℕ} [NeZero n]
Goal: Fin.castSucc 0 = 0
-- Fin.castSucc_pos'
theorem castSucc_pos' [NeZero n] {i : Fin n} (h : 0 < i) : 0 < castSucc i 
Arguments: {n : ℕ} [NeZero n] {i : Fin n} (h : 0 < i)
Goal: 0 < i.castSucc
-- Fin.castSucc_eq_zero_iff'
@[simp]
theorem castSucc_eq_zero_iff' [NeZero n] (a : Fin n) : castSucc a = 0 ↔ a = 0 
Arguments: {n : ℕ} [NeZero n] (a : Fin n)
Goal: a.castSucc = 0 ↔ a = 0
-- Fin.castSucc_ne_zero_iff'
theorem castSucc_ne_zero_iff' [NeZero n] (a : Fin n) : castSucc a ≠ 0 ↔ a ≠ 0 
Arguments: {n : ℕ} [NeZero n] (a : Fin n)
Goal: a.castSucc ≠ 0 ↔ a ≠ 0
-- Fin.castSucc_ne_zero_of_lt
theorem castSucc_ne_zero_of_lt {p i : Fin n} (h : p < i) : castSucc i ≠ 0 
Arguments: {n : ℕ} {p i : Fin n} (h : p < i)
Goal: i.castSucc ≠ 0
-- Fin.succ_ne_last_iff
theorem succ_ne_last_iff (a : Fin (n + 1)) : succ a ≠ last (n + 1) ↔ a ≠ last n 
Arguments: {n : ℕ} (a : Fin (n + 1))
Goal: a.succ ≠ Fin.last (n + 1) ↔ a ≠ Fin.last n
-- Fin.succ_ne_last_of_lt
theorem succ_ne_last_of_lt {p i : Fin n} (h : i < p) : succ i ≠ last n 
Arguments: {n : ℕ} {p i : Fin n} (h : i < p)
Goal: i.succ ≠ Fin.last n
-- Fin.coe_eq_castSucc
@[norm_cast, simp]
theorem coe_eq_castSucc {a : Fin n} : (a : Fin (n + 1)) = castSucc a 
Arguments: {n : ℕ} {a : Fin n}
Goal: ↑↑a = a.castSucc
-- Fin.coe_succ_lt_iff_lt
theorem coe_succ_lt_iff_lt {n : ℕ} {j k : Fin n} : (j : Fin <| n + 1) < k ↔ j < k 
Arguments: {n : ℕ} {j k : Fin n}
Goal: ↑↑j < ↑↑k ↔ j < k
-- Fin.range_castSucc
@[simp]
theorem range_castSucc {n : ℕ} : Set.range (castSucc : Fin n → Fin n.succ) =
    ({ i | (i : ℕ) < n } : Set (Fin n.succ)) 
Arguments: {n : ℕ}
Goal: Set.range Fin.castSucc = {i | ↑i < n}
-- Fin.coe_of_injective_castSucc_symm
@[simp]
theorem coe_of_injective_castSucc_symm {n : ℕ} (i : Fin n.succ) (hi) :
    ((Equiv.ofInjective castSucc (castSucc_injective _)).symm ⟨i, hi⟩ : ℕ) = i 
Arguments: {n : ℕ} (i : Fin n.succ) (hi : i ∈ Set.range Fin.castSucc)
Goal: ↑((Equiv.ofInjective Fin.castSucc ⋯).symm ⟨i, hi⟩) = ↑i
-- Fin.addNatEmb_apply
@[simps! apply]
def addNatEmb (m) : Fin n ↪ Fin (n + m) 
Arguments: {n : ℕ} (m : ℕ)
Goal: ∀ (x : Fin n), (Fin.addNatEmb m) x = x.addNat m
-- Fin.natAddEmb_apply
@[simps! apply]
def natAddEmb (n) {m} : Fin m ↪ Fin (n + m) 
Arguments: (n : ℕ) {m : ℕ} (i : Fin m)
Goal: (Fin.natAddEmb n) i = Fin.natAdd n i
-- Fin.pred_one'
theorem pred_one' [NeZero n] (h := (zero_ne_one' (n := n)).symm) :
    Fin.pred (1 : Fin (n + 1)) h = 0 
Arguments: {n : ℕ} [NeZero n] (h : 1 ≠ 0 := ⋯)
Goal: Fin.pred 1 h = 0
-- Fin.pred_last
theorem pred_last (h := Fin.ext_iff.not.2 last_pos'.ne') :
    pred (last (n + 1)) h = last n 
Arguments: {n : ℕ} (h : ¬Fin.last (n + 1) = 0 := ⋯)
Goal: (Fin.last (n + 1)).pred h = Fin.last n
-- Fin.pred_lt_iff
theorem pred_lt_iff {j : Fin n} {i : Fin (n + 1)} (hi : i ≠ 0) : pred i hi < j ↔ i < succ j 
Arguments: {n : ℕ} {j : Fin n} {i : Fin (n + 1)} (hi : i ≠ 0)
Goal: i.pred hi < j ↔ i < j.succ
-- Fin.lt_pred_iff
theorem lt_pred_iff {j : Fin n} {i : Fin (n + 1)} (hi : i ≠ 0) : j < pred i hi ↔ succ j < i 
Arguments: {n : ℕ} {j : Fin n} {i : Fin (n + 1)} (hi : i ≠ 0)
Goal: j < i.pred hi ↔ j.succ < i
-- Fin.pred_le_iff
theorem pred_le_iff {j : Fin n} {i : Fin (n + 1)} (hi : i ≠ 0) : pred i hi ≤ j ↔ i ≤ succ j 
Arguments: {n : ℕ} {j : Fin n} {i : Fin (n + 1)} (hi : i ≠ 0)
Goal: i.pred hi ≤ j ↔ i ≤ j.succ
-- Fin.le_pred_iff
theorem le_pred_iff {j : Fin n} {i : Fin (n + 1)} (hi : i ≠ 0) : j ≤ pred i hi ↔ succ j ≤ i 
Arguments: {n : ℕ} {j : Fin n} {i : Fin (n + 1)} (hi : i ≠ 0)
Goal: j ≤ i.pred hi ↔ j.succ ≤ i
-- Fin.castSucc_pred_eq_pred_castSucc
theorem castSucc_pred_eq_pred_castSucc {a : Fin (n + 1)} (ha : a ≠ 0)
    (ha' := a.castSucc_ne_zero_iff.mpr ha) :
    (a.pred ha).castSucc = (castSucc a).pred ha' 
Arguments: {n : ℕ} {a : Fin (n + 1)} (ha : a ≠ 0) (ha' : a.castSucc ≠ 0 := ⋯)
Goal: (a.pred ha).castSucc = a.castSucc.pred ha'
-- Fin.castSucc_pred_add_one_eq
theorem castSucc_pred_add_one_eq {a : Fin (n + 1)} (ha : a ≠ 0) :
    (a.pred ha).castSucc + 1 = a 
Arguments: {n : ℕ} {a : Fin (n + 1)} (ha : a ≠ 0)
Goal: (a.pred ha).castSucc + 1 = a
-- Fin.le_pred_castSucc_iff
theorem le_pred_castSucc_iff {a b : Fin (n + 1)} (ha : castSucc a ≠ 0) :
    b ≤ (castSucc a).pred ha ↔ b < a 
Arguments: {n : ℕ} {a b : Fin (n + 1)} (ha : a.castSucc ≠ 0)
Goal: b ≤ a.castSucc.pred ha ↔ b < a
-- Fin.pred_castSucc_lt_iff
theorem pred_castSucc_lt_iff {a b : Fin (n + 1)} (ha : castSucc a ≠ 0) :
    (castSucc a).pred ha < b ↔ a ≤ b 
Arguments: {n : ℕ} {a b : Fin (n + 1)} (ha : a.castSucc ≠ 0)
Goal: a.castSucc.pred ha < b ↔ a ≤ b
-- Fin.pred_castSucc_lt
theorem pred_castSucc_lt {a : Fin (n + 1)} (ha : castSucc a ≠ 0) :
    (castSucc a).pred ha < a 
Arguments: {n : ℕ} {a : Fin (n + 1)} (ha : a.castSucc ≠ 0)
Goal: a.castSucc.pred ha < a
-- Fin.le_castSucc_pred_iff
theorem le_castSucc_pred_iff {a b : Fin (n + 1)} (ha : a ≠ 0) :
    b ≤ castSucc (a.pred ha) ↔ b < a 
Arguments: {n : ℕ} {a b : Fin (n + 1)} (ha : a ≠ 0)
Goal: b ≤ (a.pred ha).castSucc ↔ b < a
-- Fin.castSucc_pred_lt_iff
theorem castSucc_pred_lt_iff {a b : Fin (n + 1)} (ha : a ≠ 0) :
    castSucc (a.pred ha) < b ↔ a ≤ b 
Arguments: {n : ℕ} {a b : Fin (n + 1)} (ha : a ≠ 0)
Goal: (a.pred ha).castSucc < b ↔ a ≤ b
-- Fin.castSucc_pred_lt
theorem castSucc_pred_lt {a : Fin (n + 1)} (ha : a ≠ 0) :
    castSucc (a.pred ha) < a 
Arguments: {n : ℕ} {a : Fin (n + 1)} (ha : a ≠ 0)
Goal: (a.pred ha).castSucc < a
-- Fin.castLT_eq_castPred
@[simp]
lemma castLT_eq_castPred (i : Fin (n + 1)) (h : i < last _) (h' := Fin.ext_iff.not.2 h.ne) :
    castLT i h = castPred i h' 
Arguments: {n : ℕ} (i : Fin (n + 1)) (h : i < Fin.last n) (h' : ¬i = Fin.last n := ⋯)
Goal: i.castLT h = i.castPred h'
-- Fin.coe_castPred
@[simp]
lemma coe_castPred (i : Fin (n + 1)) (h : i ≠ last _) : (castPred i h : ℕ) = i 
Arguments: {n : ℕ} (i : Fin (n + 1)) (h : i ≠ Fin.last n)
Goal: ↑(i.castPred h) = ↑i
-- Fin.castPred_castSucc
@[simp]
theorem castPred_castSucc {i : Fin n} (h' := Fin.ext_iff.not.2 (castSucc_lt_last i).ne) :
    castPred (castSucc i) h' = i 
Arguments: {n : ℕ} {i : Fin n} (h' : ¬i.castSucc = Fin.last n := ⋯)
Goal: i.castSucc.castPred h' = i
-- Fin.castSucc_castPred
@[simp]
theorem castSucc_castPred (i : Fin (n + 1)) (h : i ≠ last n) :
    castSucc (i.castPred h) = i 
Arguments: {n : ℕ} (i : Fin (n + 1)) (h : i ≠ Fin.last n)
Goal: (i.castPred h).castSucc = i
-- Fin.castPred_eq_iff_eq_castSucc
theorem castPred_eq_iff_eq_castSucc (i : Fin (n + 1)) (hi : i ≠ last _) (j : Fin n) :
    castPred i hi = j ↔ i = castSucc j 
Arguments: {n : ℕ} (i : Fin (n + 1)) (hi : i ≠ Fin.last n) (j : Fin n)
Goal: i.castPred hi = j ↔ i = j.castSucc
-- Fin.castPred_mk
@[simp]
theorem castPred_mk (i : ℕ) (h₁ : i < n) (h₂ := h₁.trans (Nat.lt_succ_self _))
    (h₃ : ⟨i, h₂⟩ ≠ last _ := (ne_iff_vne _ _).mpr (val_last _ ▸ h₁.ne)) :
  castPred ⟨i, h₂⟩ h₃ = ⟨i, h₁⟩ 
Arguments: {n : ℕ} (i : ℕ) (h₁ : i < n) (h₂ : i < n.succ := ⋯) (h₃ : ⟨i, h₂⟩ ≠ Fin.last n := ⋯)
Goal: ⟨i, h₂⟩.castPred h₃ = ⟨i, h₁⟩
-- Fin.castPred_le_castPred_iff
theorem castPred_le_castPred_iff {i j : Fin (n + 1)} {hi : i ≠ last n} {hj : j ≠ last n} :
    castPred i hi ≤ castPred j hj ↔ i ≤ j 
Arguments: {n : ℕ} {i j : Fin (n + 1)} {hi : i ≠ Fin.last n} {hj : j ≠ Fin.last n}
Goal: i.castPred hi ≤ j.castPred hj ↔ i ≤ j
-- Fin.castPred_lt_castPred_iff
theorem castPred_lt_castPred_iff {i j : Fin (n + 1)} {hi : i ≠ last n} {hj : j ≠ last n} :
    castPred i hi < castPred j hj ↔ i < j 
Arguments: {n : ℕ} {i j : Fin (n + 1)} {hi : i ≠ Fin.last n} {hj : j ≠ Fin.last n}
Goal: i.castPred hi < j.castPred hj ↔ i < j
-- Fin.castPred_lt_iff
theorem castPred_lt_iff {j : Fin n} {i : Fin (n + 1)} (hi : i ≠ last n) :
    castPred i hi < j ↔ i < castSucc j 
Arguments: {n : ℕ} {j : Fin n} {i : Fin (n + 1)} (hi : i ≠ Fin.last n)
Goal: i.castPred hi < j ↔ i < j.castSucc
-- Fin.lt_castPred_iff
theorem lt_castPred_iff {j : Fin n} {i : Fin (n + 1)} (hi : i ≠ last n) :
    j < castPred i hi ↔ castSucc j < i 
Arguments: {n : ℕ} {j : Fin n} {i : Fin (n + 1)} (hi : i ≠ Fin.last n)
Goal: j < i.castPred hi ↔ j.castSucc < i
-- Fin.castPred_le_iff
theorem castPred_le_iff {j : Fin n} {i : Fin (n + 1)} (hi : i ≠ last n) :
    castPred i hi ≤ j ↔ i ≤ castSucc j 
Arguments: {n : ℕ} {j : Fin n} {i : Fin (n + 1)} (hi : i ≠ Fin.last n)
Goal: i.castPred hi ≤ j ↔ i ≤ j.castSucc
-- Fin.le_castPred_iff
theorem le_castPred_iff {j : Fin n} {i : Fin (n + 1)} (hi : i ≠ last n) :
    j ≤ castPred i hi ↔ castSucc j ≤ i 
Arguments: {n : ℕ} {j : Fin n} {i : Fin (n + 1)} (hi : i ≠ Fin.last n)
Goal: j ≤ i.castPred hi ↔ j.castSucc ≤ i
-- Fin.castPred_inj
theorem castPred_inj {i j : Fin (n + 1)} {hi : i ≠ last n} {hj : j ≠ last n} :
    castPred i hi = castPred j hj ↔ i = j 
Arguments: {n : ℕ} {i j : Fin (n + 1)} {hi : i ≠ Fin.last n} {hj : j ≠ Fin.last n}
Goal: i.castPred hi = j.castPred hj ↔ i = j
-- Fin.castPred_zero'
theorem castPred_zero' [NeZero n] (h := Fin.ext_iff.not.2 last_pos'.ne) :
    castPred (0 : Fin (n + 1)) h = 0 
Arguments: {n : ℕ} [NeZero n] (h : ¬0 = Fin.last n := ⋯)
Goal: Fin.castPred 0 h = 0
-- Fin.castPred_zero
theorem castPred_zero (h := Fin.ext_iff.not.2 last_pos.ne)  :
    castPred (0 : Fin (n + 2)) h = 0 
Arguments: {n : ℕ} (h : ¬0 = Fin.last (n + 1) := ⋯)
Goal: Fin.castPred 0 h = 0
-- Fin.castPred_one
@[simp]
theorem castPred_one [NeZero n] (h := Fin.ext_iff.not.2 one_lt_last.ne) :
    castPred (1 : Fin (n + 2)) h = 1 
Arguments: {n : ℕ} [NeZero n] (h : ¬1 = Fin.last (n + 1) := ⋯)
Goal: Fin.castPred 1 h = 1
-- Fin.rev_pred
theorem rev_pred {i : Fin (n + 1)} (h : i ≠ 0) (h' := rev_ne_iff.mpr ((rev_last _).symm ▸ h)) :
    rev (pred i h) = castPred (rev i) h' 
Arguments: {n : ℕ} {i : Fin (n + 1)} (h : i ≠ 0) (h' : i.rev ≠ Fin.last n := ⋯)
Goal: (i.pred h).rev = i.rev.castPred h'
-- Fin.rev_castPred
theorem rev_castPred {i : Fin (n + 1)}
    (h : i ≠ last n) (h' := rev_ne_iff.mpr ((rev_zero _).symm ▸ h)) :
    rev (castPred i h) = pred (rev i) h' 
Arguments: {n : ℕ} {i : Fin (n + 1)} (h : i ≠ Fin.last n) (h' : i.rev ≠ 0 := ⋯)
Goal: (i.castPred h).rev = i.rev.pred h'
-- Fin.succ_castPred_eq_castPred_succ
theorem succ_castPred_eq_castPred_succ {a : Fin (n + 1)} (ha : a ≠ last n)
    (ha' := a.succ_ne_last_iff.mpr ha) :
    (a.castPred ha).succ = (succ a).castPred ha' 
Arguments: {n : ℕ} {a : Fin (n + 1)} (ha : a ≠ Fin.last n) (ha' : a.succ ≠ Fin.last (n + 1) := ⋯)
Goal: (a.castPred ha).succ = a.succ.castPred ha'
-- Fin.succ_castPred_eq_add_one
theorem succ_castPred_eq_add_one {a : Fin (n + 1)} (ha : a ≠ last n) :
    (a.castPred ha).succ = a + 1 
Arguments: {n : ℕ} {a : Fin (n + 1)} (ha : a ≠ Fin.last n)
Goal: (a.castPred ha).succ = a + 1
-- Fin.castpred_succ_le_iff
theorem castpred_succ_le_iff {a b : Fin (n + 1)} (ha : succ a ≠ last (n + 1)) :
    (succ a).castPred ha ≤ b ↔ a < b 
Arguments: {n : ℕ} {a b : Fin (n + 1)} (ha : a.succ ≠ Fin.last (n + 1))
Goal: a.succ.castPred ha ≤ b ↔ a < b
-- Fin.lt_castPred_succ_iff
theorem lt_castPred_succ_iff {a b : Fin (n + 1)} (ha : succ a ≠ last (n + 1)) :
    b < (succ a).castPred ha ↔ b ≤ a 
Arguments: {n : ℕ} {a b : Fin (n + 1)} (ha : a.succ ≠ Fin.last (n + 1))
Goal: b < a.succ.castPred ha ↔ b ≤ a
-- Fin.lt_castPred_succ
theorem lt_castPred_succ {a : Fin (n + 1)} (ha : succ a ≠ last (n + 1)) :
    a < (succ a).castPred ha 
Arguments: {n : ℕ} {a : Fin (n + 1)} (ha : a.succ ≠ Fin.last (n + 1))
Goal: a < a.succ.castPred ha
-- Fin.succ_castPred_le_iff
theorem succ_castPred_le_iff {a b : Fin (n + 1)} (ha : a ≠ last n) :
    succ (a.castPred ha) ≤ b ↔ a < b 
Arguments: {n : ℕ} {a b : Fin (n + 1)} (ha : a ≠ Fin.last n)
Goal: (a.castPred ha).succ ≤ b ↔ a < b
-- Fin.lt_succ_castPred_iff
theorem lt_succ_castPred_iff {a b : Fin (n + 1)} (ha : a ≠ last n) :
    b < succ (a.castPred ha) ↔ b ≤ a 
Arguments: {n : ℕ} {a b : Fin (n + 1)} (ha : a ≠ Fin.last n)
Goal: b < (a.castPred ha).succ ↔ b ≤ a
-- Fin.lt_succ_castPred
theorem lt_succ_castPred {a : Fin (n + 1)} (ha : a ≠ last n) :
    a < succ (a.castPred ha) 
Arguments: {n : ℕ} {a : Fin (n + 1)} (ha : a ≠ Fin.last n)
Goal: a < (a.castPred ha).succ
-- Fin.castPred_le_pred_iff
theorem castPred_le_pred_iff {a b : Fin (n + 1)} (ha : a ≠ last n) (hb : b ≠ 0) :
    castPred a ha ≤ pred b hb ↔ a < b 
Arguments: {n : ℕ} {a b : Fin (n + 1)} (ha : a ≠ Fin.last n) (hb : b ≠ 0)
Goal: a.castPred ha ≤ b.pred hb ↔ a < b
-- Fin.pred_lt_castPred_iff
theorem pred_lt_castPred_iff {a b : Fin (n + 1)} (ha : a ≠ 0) (hb : b ≠ last n) :
    pred a ha < castPred b hb ↔ a ≤ b 
Arguments: {n : ℕ} {a b : Fin (n + 1)} (ha : a ≠ 0) (hb : b ≠ Fin.last n)
Goal: a.pred ha < b.castPred hb ↔ a ≤ b
-- Fin.pred_lt_castPred
theorem pred_lt_castPred {a : Fin (n + 1)} (h₁ : a ≠ 0) (h₂ : a ≠ last n) :
    pred a h₁ < castPred a h₂ 
Arguments: {n : ℕ} {a : Fin (n + 1)} (h₁ : a ≠ 0) (h₂ : a ≠ Fin.last n)
Goal: a.pred h₁ < a.castPred h₂
-- Fin.succAbove_of_castSucc_lt
lemma succAbove_of_castSucc_lt (p : Fin (n + 1)) (i : Fin n) (h : castSucc i < p) :
    p.succAbove i = castSucc i 
Arguments: {n : ℕ} (p : Fin (n + 1)) (i : Fin n) (h : i.castSucc < p)
Goal: p.succAbove i = i.castSucc
-- Fin.succAbove_of_succ_le
lemma succAbove_of_succ_le (p : Fin (n + 1)) (i : Fin n) (h : succ i ≤ p) :
    p.succAbove i = castSucc i 
Arguments: {n : ℕ} (p : Fin (n + 1)) (i : Fin n) (h : i.succ ≤ p)
Goal: p.succAbove i = i.castSucc
-- Fin.succAbove_of_le_castSucc
lemma succAbove_of_le_castSucc (p : Fin (n + 1)) (i : Fin n) (h : p ≤ castSucc i) :
    p.succAbove i = i.succ 
Arguments: {n : ℕ} (p : Fin (n + 1)) (i : Fin n) (h : p ≤ i.castSucc)
Goal: p.succAbove i = i.succ
-- Fin.succAbove_of_lt_succ
lemma succAbove_of_lt_succ (p : Fin (n + 1)) (i : Fin n) (h : p < succ i) :
    p.succAbove i = succ i 
Arguments: {n : ℕ} (p : Fin (n + 1)) (i : Fin n) (h : p < i.succ)
Goal: p.succAbove i = i.succ
-- Fin.succAbove_succ_of_lt
lemma succAbove_succ_of_lt (p i : Fin n) (h : p < i) : succAbove p.succ i = i.succ 
Arguments: {n : ℕ} (p i : Fin n) (h : p < i)
Goal: p.succ.succAbove i = i.succ
-- Fin.succAbove_succ_of_le
lemma succAbove_succ_of_le (p i : Fin n) (h : i ≤ p) : succAbove p.succ i = i.castSucc 
Arguments: {n : ℕ} (p i : Fin n) (h : i ≤ p)
Goal: p.succ.succAbove i = i.castSucc
-- Fin.succAbove_succ_self
@[simp] lemma succAbove_succ_self (j : Fin n) : j.succ.succAbove j = j.castSucc 
Arguments: {n : ℕ} (j : Fin n)
Goal: j.succ.succAbove j = j.castSucc
-- Fin.succAbove_castSucc_of_lt
lemma succAbove_castSucc_of_lt (p i : Fin n) (h : i < p) : succAbove p.castSucc i = i.castSucc 
Arguments: {n : ℕ} (p i : Fin n) (h : i < p)
Goal: p.castSucc.succAbove i = i.castSucc
-- Fin.succAbove_castSucc_of_le
lemma succAbove_castSucc_of_le (p i : Fin n) (h : p ≤ i) : succAbove p.castSucc i = i.succ 
Arguments: {n : ℕ} (p i : Fin n) (h : p ≤ i)
Goal: p.castSucc.succAbove i = i.succ
-- Fin.succAbove_castSucc_self
@[simp] lemma succAbove_castSucc_self (j : Fin n) : succAbove j.castSucc j = j.succ 
Arguments: {n : ℕ} (j : Fin n)
Goal: j.castSucc.succAbove j = j.succ
-- Fin.succAbove_pred_of_lt
lemma succAbove_pred_of_lt (p i : Fin (n + 1)) (h : p < i)
    (hi := Fin.ne_of_gt $ Fin.lt_of_le_of_lt p.zero_le h) : succAbove p (i.pred hi) = i 
Arguments: {n : ℕ} (p i : Fin (n + 1)) (h : p < i) (hi : i ≠ 0 := ⋯)
Goal: p.succAbove (i.pred hi) = i
-- Fin.succAbove_pred_of_le
lemma succAbove_pred_of_le (p i : Fin (n + 1)) (h : i ≤ p) (hi : i ≠ 0) :
    succAbove p (i.pred hi) = (i.pred hi).castSucc 
Arguments: {n : ℕ} (p i : Fin (n + 1)) (h : i ≤ p) (hi : i ≠ 0)
Goal: p.succAbove (i.pred hi) = (i.pred hi).castSucc
-- Fin.succAbove_pred_self
@[simp] lemma succAbove_pred_self (p : Fin (n + 1)) (h : p ≠ 0) :
    succAbove p (p.pred h) = (p.pred h).castSucc 
Arguments: {n : ℕ} (p : Fin (n + 1)) (h : p ≠ 0)
Goal: p.succAbove (p.pred h) = (p.pred h).castSucc
-- Fin.succAbove_castPred_of_lt
lemma succAbove_castPred_of_lt (p i : Fin (n + 1)) (h : i < p)
    (hi := Fin.ne_of_lt $ Nat.lt_of_lt_of_le h p.le_last) : succAbove p (i.castPred hi) = i 
Arguments: {n : ℕ} (p i : Fin (n + 1)) (h : i < p) (hi : i ≠ Fin.last n := ⋯)
Goal: p.succAbove (i.castPred hi) = i
-- Fin.succAbove_castPred_of_le
lemma succAbove_castPred_of_le (p i : Fin (n + 1)) (h : p ≤ i) (hi : i ≠ last n) :
    succAbove p (i.castPred hi) = (i.castPred hi).succ 
Arguments: {n : ℕ} (p i : Fin (n + 1)) (h : p ≤ i) (hi : i ≠ Fin.last n)
Goal: p.succAbove (i.castPred hi) = (i.castPred hi).succ
-- Fin.succAbove_castPred_self
lemma succAbove_castPred_self (p : Fin (n + 1)) (h : p ≠ last n) :
    succAbove p (p.castPred h) = (p.castPred h).succ 
Arguments: {n : ℕ} (p : Fin (n + 1)) (h : p ≠ Fin.last n)
Goal: p.succAbove (p.castPred h) = (p.castPred h).succ
-- Fin.succAbove_rev_left
lemma succAbove_rev_left (p : Fin (n + 1)) (i : Fin n) :
    p.rev.succAbove i = (p.succAbove i.rev).rev 
Arguments: {n : ℕ} (p : Fin (n + 1)) (i : Fin n)
Goal: p.rev.succAbove i = (p.succAbove i.rev).rev
-- Fin.succAbove_rev_right
lemma succAbove_rev_right (p : Fin (n + 1)) (i : Fin n) :
    p.succAbove i.rev = (p.rev.succAbove i).rev 
Arguments: {n : ℕ} (p : Fin (n + 1)) (i : Fin n)
Goal: p.succAbove i.rev = (p.rev.succAbove i).rev
-- Fin.succAbove_ne
lemma succAbove_ne (p : Fin (n + 1)) (i : Fin n) : p.succAbove i ≠ p 
Arguments: {n : ℕ} (p : Fin (n + 1)) (i : Fin n)
Goal: p.succAbove i ≠ p
-- Fin.ne_succAbove
lemma ne_succAbove (p : Fin (n + 1)) (i : Fin n) : p ≠ p.succAbove i 
Arguments: {n : ℕ} (p : Fin (n + 1)) (i : Fin n)
Goal: p ≠ p.succAbove i
-- Fin.succAbove_right_injective
lemma succAbove_right_injective : Injective p.succAbove 
Arguments: {n : ℕ} {p : Fin (n + 1)}
Goal: Function.Injective p.succAbove
-- Fin.succAbove_right_inj
lemma succAbove_right_inj : p.succAbove i = p.succAbove j ↔ i = j 
Arguments: {n : ℕ} {p : Fin (n + 1)} {i j : Fin n}
Goal: p.succAbove i = p.succAbove j ↔ i = j
-- Fin.succAboveEmb_apply
@[simps!]
def succAboveEmb (p : Fin (n + 1)) : Fin n ↪ Fin (n + 1) 
Arguments: {n : ℕ} (p : Fin (n + 1)) (i : Fin n)
Goal: p.succAboveEmb i = p.succAbove i
-- Fin.coe_succAboveEmb
@[simp, norm_cast] lemma coe_succAboveEmb (p : Fin (n + 1)) : p.succAboveEmb = p.succAbove 
Arguments: {n : ℕ} (p : Fin (n + 1))
Goal: ⇑p.succAboveEmb = p.succAbove
-- Fin.succAbove_ne_zero_zero
@[simp]
lemma succAbove_ne_zero_zero [NeZero n] {a : Fin (n + 1)} (ha : a ≠ 0) : a.succAbove 0 = 0 
Arguments: {n : ℕ} [NeZero n] {a : Fin (n + 1)} (ha : a ≠ 0)
Goal: a.succAbove 0 = 0
-- Fin.succAbove_eq_zero_iff
lemma succAbove_eq_zero_iff [NeZero n] {a : Fin (n + 1)} {b : Fin n} (ha : a ≠ 0) :
    a.succAbove b = 0 ↔ b = 0 
Arguments: {n : ℕ} [NeZero n] {a : Fin (n + 1)} {b : Fin n} (ha : a ≠ 0)
Goal: a.succAbove b = 0 ↔ b = 0
-- Fin.succAbove_ne_zero
lemma succAbove_ne_zero [NeZero n] {a : Fin (n + 1)} {b : Fin n} (ha : a ≠ 0) (hb : b ≠ 0) :
    a.succAbove b ≠ 0 
Arguments: {n : ℕ} [NeZero n] {a : Fin (n + 1)} {b : Fin n} (ha : a ≠ 0) (hb : b ≠ 0)
Goal: a.succAbove b ≠ 0
-- Fin.succAbove_zero
@[simp] lemma succAbove_zero : succAbove (0 : Fin (n + 1)) = Fin.succ 
Arguments: {n : ℕ}
Goal: Fin.succAbove 0 = Fin.succ
-- Fin.succAbove_zero_apply
lemma succAbove_zero_apply (i : Fin n) : succAbove 0 i = succ i 
Arguments: {n : ℕ} (i : Fin n)
Goal: Fin.succAbove 0 i = i.succ
-- Fin.succAbove_ne_last_last
@[simp] lemma succAbove_ne_last_last {a : Fin (n + 2)} (h : a ≠ last (n + 1)) :
    a.succAbove (last n) = last (n + 1) 
Arguments: {n : ℕ} {a : Fin (n + 2)} (h : a ≠ Fin.last (n + 1))
Goal: a.succAbove (Fin.last n) = Fin.last (n + 1)
-- Fin.succAbove_eq_last_iff
lemma succAbove_eq_last_iff {a : Fin (n + 2)} {b : Fin (n + 1)} (ha : a ≠ last _) :
    a.succAbove b = last _ ↔ b = last _ 
Arguments: {n : ℕ} {a : Fin (n + 2)} {b : Fin (n + 1)} (ha : a ≠ Fin.last (n + 1))
Goal: a.succAbove b = Fin.last (n + 1) ↔ b = Fin.last n
-- Fin.succAbove_ne_last
lemma succAbove_ne_last {a : Fin (n + 2)} {b : Fin (n + 1)} (ha : a ≠ last _) (hb : b ≠ last _) :
    a.succAbove b ≠ last _ 
Arguments: {n : ℕ} {a : Fin (n + 2)} {b : Fin (n + 1)} (ha : a ≠ Fin.last (n + 1)) (hb : b ≠ Fin.last n)
Goal: a.succAbove b ≠ Fin.last (n + 1)
-- Fin.succAbove_last
@[simp] lemma succAbove_last : succAbove (last n) = castSucc 
Arguments: {n : ℕ}
Goal: (Fin.last n).succAbove = Fin.castSucc