ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Fin.ofNat'_zero_val
@[deprecated ofNat'_zero_val (since := "2024-02-22")]
theorem ofNat'_zero_val : (Fin.ofNat' 0 h).val = 0 
Goal: ∀ {a : Nat} {h : a > 0}, ↑(Fin.ofNat' 0 h) = 0
-- Fin.mod_val
@[simp] theorem mod_val (a b : Fin n) : (a % b).val = a.val % b.val 
Arguments: {n : Nat} (a b : Fin n)
Goal: ↑(a % b) = ↑a % ↑b
-- Fin.div_val
@[simp] theorem div_val (a b : Fin n) : (a / b).val = a.val / b.val 
Arguments: {n : Nat} (a b : Fin n)
Goal: ↑(a / b) = ↑a / ↑b
-- Fin.modn_val
@[simp] theorem modn_val (a : Fin n) (b : Nat) : (a.modn b).val = a.val % b 
Arguments: {n : Nat} (a : Fin n) (b : Nat)
Goal: ↑(a.modn b) = ↑a % b
-- Fin.ite_val
theorem ite_val {n : Nat} {c : Prop} [Decidable c] {x : c → Fin n} (y : ¬c → Fin n) :
    (if h : c then x h else y h).val = if h : c then (x h).val else (y h).val 
Arguments: {n : Nat} {c : Prop} [Decidable c] {x : c → Fin n} (y : ¬c → Fin n)
Goal: ↑(if h : c then x h else y h) = if h : c then ↑(x h) else ↑(y h)
-- Fin.dite_val
theorem dite_val {n : Nat} {c : Prop} [Decidable c] {x y : Fin n} :
    (if c then x else y).val = if c then x.val else y.val 
Arguments: {n : Nat} {c : Prop} [Decidable c] {x y : Fin n}
Goal: ↑(if c then x else y) = if c then ↑x else ↑y
-- Fin.le_def
theorem le_def {a b : Fin n} : a ≤ b ↔ a.1 ≤ b.1 
Arguments: {n : Nat} {a b : Fin n}
Goal: a ≤ b ↔ ↑a ≤ ↑b
-- Fin.lt_def
theorem lt_def {a b : Fin n} : a < b ↔ a.1 < b.1 
Arguments: {n : Nat} {a b : Fin n}
Goal: a < b ↔ ↑a < ↑b
-- Fin.lt_iff_val_lt_val
theorem lt_iff_val_lt_val {a b : Fin n} : a < b ↔ a.val < b.val 
Arguments: {n : Nat} {a b : Fin n}
Goal: a < b ↔ ↑a < ↑b
-- Fin.not_le
@[simp] protected theorem not_le {a b : Fin n} : ¬ a ≤ b ↔ b < a 
Arguments: {n : Nat} {a b : Fin n}
Goal: ¬a ≤ b ↔ b < a
-- Fin.not_lt
@[simp] protected theorem not_lt {a b : Fin n} : ¬ a < b ↔ b ≤ a 
Arguments: {n : Nat} {a b : Fin n}
Goal: ¬a < b ↔ b ≤ a
-- Fin.le_refl
@[simp] protected theorem le_refl (a : Fin n) : a ≤ a 
Arguments: {n : Nat} (a : Fin n)
Goal: a ≤ a
-- Fin.lt_irrefl
@[simp] protected theorem lt_irrefl (a : Fin n) : ¬ a < a 
Arguments: {n : Nat} (a : Fin n)
Goal: ¬a < a
-- Fin.le_trans
protected theorem le_trans {a b c : Fin n} : a ≤ b → b ≤ c → a ≤ c 
Arguments: {n : Nat} {a b c : Fin n}
Goal: a ≤ b → b ≤ c → a ≤ c
-- Fin.lt_trans
protected theorem lt_trans {a b c : Fin n} : a < b → b < c → a < c 
Arguments: {n : Nat} {a b c : Fin n}
Goal: a < b → b < c → a < c
-- Fin.le_total
protected theorem le_total (a b : Fin n) : a ≤ b ∨ b ≤ a 
Arguments: {n : Nat} (a b : Fin n)
Goal: a ≤ b ∨ b ≤ a
-- Fin.lt_asymm
protected theorem lt_asymm {a b : Fin n} (h : a < b) : ¬ b < a 
Arguments: {n : Nat} {a b : Fin n} (h : a < b)
Goal: ¬b < a
-- Fin.ne_of_lt
protected theorem ne_of_lt {a b : Fin n} (h : a < b) : a ≠ b 
Arguments: {n : Nat} {a b : Fin n} (h : a < b)
Goal: a ≠ b
-- Fin.ne_of_gt
protected theorem ne_of_gt {a b : Fin n} (h : a < b) : b ≠ a 
Arguments: {n : Nat} {a b : Fin n} (h : a < b)
Goal: b ≠ a
-- Fin.le_of_lt
protected theorem le_of_lt {a b : Fin n} (h : a < b) : a ≤ b 
Arguments: {n : Nat} {a b : Fin n} (h : a < b)
Goal: a ≤ b
-- Fin.is_le
theorem is_le (i : Fin (n + 1)) : i ≤ n 
Arguments: {n : Nat} (i : Fin (n + 1))
Goal: ↑i ≤ n
-- Fin.is_le'
@[simp] theorem is_le' {a : Fin n} : a ≤ n 
Arguments: {n : Nat} {a : Fin n}
Goal: ↑a ≤ n
-- Fin.mk_lt_of_lt_val
theorem mk_lt_of_lt_val {b : Fin n} {a : Nat} (h : a < b) :
    (⟨a, Nat.lt_trans h b.is_lt⟩ : Fin n) < b 
Arguments: {n : Nat} {b : Fin n} {a : Nat} (h : a < ↑b)
Goal: ⟨a, ⋯⟩ < b
-- Fin.mk_le_of_le_val
theorem mk_le_of_le_val {b : Fin n} {a : Nat} (h : a ≤ b) :
    (⟨a, Nat.lt_of_le_of_lt h b.is_lt⟩ : Fin n) ≤ b 
Arguments: {n : Nat} {b : Fin n} {a : Nat} (h : a ≤ ↑b)
Goal: ⟨a, ⋯⟩ ≤ b
-- Fin.mk_le_mk
@[simp] theorem mk_le_mk {x y : Nat} {hx hy} : (⟨x, hx⟩ : Fin n) ≤ ⟨y, hy⟩ ↔ x ≤ y 
Arguments: {n x y : Nat} {hx : x < n} {hy : y < n}
Goal: ⟨x, hx⟩ ≤ ⟨y, hy⟩ ↔ x ≤ y
-- Fin.mk_lt_mk
@[simp] theorem mk_lt_mk {x y : Nat} {hx hy} : (⟨x, hx⟩ : Fin n) < ⟨y, hy⟩ ↔ x < y 
Arguments: {n x y : Nat} {hx : x < n} {hy : y < n}
Goal: ⟨x, hx⟩ < ⟨y, hy⟩ ↔ x < y
-- Fin.val_zero
@[simp] theorem val_zero (n : Nat) : (0 : Fin (n + 1)).1 = 0 
Arguments: (n : Nat)
Goal: ↑0 = 0
-- Fin.mk_zero
@[simp] theorem mk_zero : (⟨0, Nat.succ_pos n⟩ : Fin (n + 1)) = 0 
Arguments: {n : Nat}
Goal: ⟨0, ⋯⟩ = 0
-- Fin.zero_le
@[simp] theorem zero_le (a : Fin (n + 1)) : 0 ≤ a 
Arguments: {n : Nat} (a : Fin (n + 1))
Goal: 0 ≤ a
-- Fin.zero_lt_one
theorem zero_lt_one : (0 : Fin (n + 2)) < 1 
Arguments: {n : Nat}
Goal: 0 < 1
-- Fin.not_lt_zero
@[simp] theorem not_lt_zero (a : Fin (n + 1)) : ¬a < 0 
Arguments: {n : Nat} (a : Fin (n + 1))
Goal: ¬a < 0
-- Fin.pos_iff_ne_zero
theorem pos_iff_ne_zero {a : Fin (n + 1)} : 0 < a ↔ a ≠ 0 
Arguments: {n : Nat} {a : Fin (n + 1)}
Goal: 0 < a ↔ a ≠ 0
-- Fin.eq_zero_or_eq_succ
theorem eq_zero_or_eq_succ {n : Nat} : ∀ i : Fin (n + 1), i = 0 ∨ ∃ j : Fin n, i = j.succ
  
Arguments: {n : Nat} (i : Fin (n + 1))
Goal: i = 0 ∨ ∃ j, i = j.succ
-- Fin.eq_succ_of_ne_zero
theorem eq_succ_of_ne_zero {n : Nat} {i : Fin (n + 1)} (hi : i ≠ 0) : ∃ j : Fin n, i = j.succ 
Arguments: {n : Nat} {i : Fin (n + 1)} (hi : i ≠ 0)
Goal: ∃ j, i = j.succ
-- Fin.val_rev
@[simp] theorem val_rev (i : Fin n) : rev i = n - (i + 1) 
Arguments: {n : Nat} (i : Fin n)
Goal: ↑i.rev = n - (↑i + 1)
-- Fin.rev_rev
@[simp] theorem rev_rev (i : Fin n) : rev (rev i) = i 
Arguments: {n : Nat} (i : Fin n)
Goal: i.rev.rev = i
-- Fin.rev_le_rev
@[simp] theorem rev_le_rev {i j : Fin n} : rev i ≤ rev j ↔ j ≤ i 
Arguments: {n : Nat} {i j : Fin n}
Goal: i.rev ≤ j.rev ↔ j ≤ i
-- Fin.rev_inj
@[simp] theorem rev_inj {i j : Fin n} : rev i = rev j ↔ i = j 
Arguments: {n : Nat} {i j : Fin n}
Goal: i.rev = j.rev ↔ i = j
-- Fin.rev_eq
theorem rev_eq {n a : Nat} (i : Fin (n + 1)) (h : n = a + i) :
    rev i = ⟨a, Nat.lt_succ_of_le (h ▸ Nat.le_add_right ..)⟩ 
Arguments: {n a : Nat} (i : Fin (n + 1)) (h : n = a + ↑i)
Goal: i.rev = ⟨a, ⋯⟩
-- Fin.rev_lt_rev
@[simp] theorem rev_lt_rev {i j : Fin n} : rev i < rev j ↔ j < i 
Arguments: {n : Nat} {i j : Fin n}
Goal: i.rev < j.rev ↔ j < i
-- Fin.val_last
@[simp] theorem val_last (n : Nat) : last n = n 
Arguments: (n : Nat)
Goal: ↑(Fin.last n) = n
-- Fin.le_last
theorem le_last (i : Fin (n + 1)) : i ≤ last n 
Arguments: {n : Nat} (i : Fin (n + 1))
Goal: i ≤ Fin.last n
-- Fin.last_pos
theorem last_pos : (0 : Fin (n + 2)) < last (n + 1) 
Arguments: {n : Nat}
Goal: 0 < Fin.last (n + 1)
-- Fin.eq_last_of_not_lt
theorem eq_last_of_not_lt {i : Fin (n + 1)} (h : ¬(i : Nat) < n) : i = last n 
Arguments: {n : Nat} {i : Fin (n + 1)} (h : ¬↑i < n)
Goal: i = Fin.last n
-- Fin.val_lt_last
theorem val_lt_last {i : Fin (n + 1)} : i ≠ last n → (i : Nat) < n 
Arguments: {n : Nat} {i : Fin (n + 1)}
Goal: i ≠ Fin.last n → ↑i < n
-- Fin.rev_last
@[simp] theorem rev_last (n : Nat) : rev (last n) = 0 
Arguments: (n : Nat)
Goal: (Fin.last n).rev = 0
-- Fin.rev_zero
@[simp] theorem rev_zero (n : Nat) : rev 0 = last n 
Arguments: (n : Nat)
Goal: Fin.rev 0 = Fin.last n
-- Fin.val_one
@[simp] theorem val_one (n : Nat) : (1 : Fin (n + 2)).val = 1 
Arguments: (n : Nat)
Goal: ↑1 = 1
-- Fin.mk_one
@[simp] theorem mk_one : (⟨1, Nat.succ_lt_succ (Nat.succ_pos n)⟩ : Fin (n + 2)) = (1 : Fin _) 
Arguments: {n : Nat}
Goal: ⟨1, ⋯⟩ = 1
-- Fin.subsingleton_iff_le_one
theorem subsingleton_iff_le_one : Subsingleton (Fin n) ↔ n ≤ 1 
Arguments: {n : Nat}
Goal: Subsingleton (Fin n) ↔ n ≤ 1
-- Fin.fin_one_eq_zero
theorem fin_one_eq_zero (a : Fin 1) : a = 0 
Arguments: (a : Fin 1)
Goal: a = 0
-- Fin.add_def
theorem add_def (a b : Fin n) : a + b = Fin.mk ((a + b) % n) (Nat.mod_lt _ a.size_pos) 
Arguments: {n : Nat} (a b : Fin n)
Goal: a + b = ⟨(↑a + ↑b) % n, ⋯⟩
-- Fin.val_add
theorem val_add (a b : Fin n) : (a + b).val = (a.val + b.val) % n 
Arguments: {n : Nat} (a b : Fin n)
Goal: ↑(a + b) = (↑a + ↑b) % n
-- Fin.val_add_one_of_lt
theorem val_add_one_of_lt {n : Nat} {i : Fin n.succ} (h : i < last _) : (i + 1).1 = i + 1 
Arguments: {n : Nat} {i : Fin n.succ} (h : i < Fin.last n)
Goal: ↑(i + 1) = ↑i + 1
-- Fin.last_add_one
@[simp] theorem last_add_one : ∀ n, last n + 1 = 0
  
Arguments: (n : Nat)
Goal: Fin.last n + 1 = 0
-- Fin.val_add_one
theorem val_add_one {n : Nat} (i : Fin (n + 1)) :
    ((i + 1 : Fin (n + 1)) : Nat) = if i = last _ then (0 : Nat) else i + 1 
Arguments: {n : Nat} (i : Fin (n + 1))
Goal: ↑(i + 1) = if i = Fin.last n then 0 else ↑i + 1
-- Fin.val_two
@[simp] theorem val_two {n : Nat} : (2 : Fin (n + 3)).val = 2 
Arguments: {n : Nat}
Goal: ↑2 = 2
-- Fin.add_one_pos
theorem add_one_pos (i : Fin (n + 1)) (h : i < Fin.last n) : (0 : Fin (n + 1)) < i + 1 
Arguments: {n : Nat} (i : Fin (n + 1)) (h : i < Fin.last n)
Goal: 0 < i + 1
-- Fin.one_pos
theorem one_pos : (0 : Fin (n + 2)) < 1 
Arguments: {n : Nat}
Goal: 0 < 1
-- Fin.zero_ne_one
theorem zero_ne_one : (0 : Fin (n + 2)) ≠ 1 
Arguments: {n : Nat}
Goal: 0 ≠ 1
-- Fin.val_succ
@[simp] theorem val_succ (j : Fin n) : (j.succ : Nat) = j + 1 
Arguments: {n : Nat} (j : Fin n)
Goal: ↑j.succ = ↑j + 1
-- Fin.succ_pos
@[simp] theorem succ_pos (a : Fin n) : (0 : Fin (n + 1)) < a.succ 
Arguments: {n : Nat} (a : Fin n)
Goal: 0 < a.succ
-- Fin.succ_le_succ_iff
@[simp] theorem succ_le_succ_iff {a b : Fin n} : a.succ ≤ b.succ ↔ a ≤ b 
Arguments: {n : Nat} {a b : Fin n}
Goal: a.succ ≤ b.succ ↔ a ≤ b
-- Fin.succ_lt_succ_iff
@[simp] theorem succ_lt_succ_iff {a b : Fin n} : a.succ < b.succ ↔ a < b 
Arguments: {n : Nat} {a b : Fin n}
Goal: a.succ < b.succ ↔ a < b
-- Fin.succ_inj
@[simp] theorem succ_inj {a b : Fin n} : a.succ = b.succ ↔ a = b 
Arguments: {n : Nat} {a b : Fin n}
Goal: a.succ = b.succ ↔ a = b
-- Fin.succ_ne_zero
theorem succ_ne_zero {n} : ∀ k : Fin n, Fin.succ k ≠ 0
  
Arguments: {n : Nat} (k : Fin n)
Goal: k.succ ≠ 0
-- Fin.succ_zero_eq_one
@[simp] theorem succ_zero_eq_one : Fin.succ (0 : Fin (n + 1)) = 1 
Arguments: {n : Nat}
Goal: Fin.succ 0 = 1
-- Fin.succ_one_eq_two
@[simp] theorem succ_one_eq_two : Fin.succ (1 : Fin (n + 2)) = 2 
Arguments: {n : Nat}
Goal: Fin.succ 1 = 2
-- Fin.succ_mk
@[simp] theorem succ_mk (n i : Nat) (h : i < n) :
    Fin.succ ⟨i, h⟩ = ⟨i + 1, Nat.succ_lt_succ h⟩ 
Arguments: (n i : Nat) (h : i < n)
Goal: ⟨i, h⟩.succ = ⟨i + 1, ⋯⟩
-- Fin.mk_succ_pos
theorem mk_succ_pos (i : Nat) (h : i < n) :
    (0 : Fin (n + 1)) < ⟨i.succ, Nat.add_lt_add_right h 1⟩ 
Arguments: {n : Nat} (i : Nat) (h : i < n)
Goal: 0 < ⟨i.succ, ⋯⟩
-- Fin.one_lt_succ_succ
theorem one_lt_succ_succ (a : Fin n) : (1 : Fin (n + 2)) < a.succ.succ 
Arguments: {n : Nat} (a : Fin n)
Goal: 1 < a.succ.succ
-- Fin.add_one_lt_iff
@[simp] theorem add_one_lt_iff {n : Nat} {k : Fin (n + 2)} : k + 1 < k ↔ k = last _ 
Arguments: {n : Nat} {k : Fin (n + 2)}
Goal: k + 1 < k ↔ k = Fin.last (n + 1)
-- Fin.add_one_le_iff
@[simp] theorem add_one_le_iff {n : Nat} : ∀ {k : Fin (n + 1)}, k + 1 ≤ k ↔ k = last _ 
Arguments: {n : Nat} {k : Fin (n + 1)}
Goal: k + 1 ≤ k ↔ k = Fin.last n
-- Fin.last_le_iff
@[simp] theorem last_le_iff {n : Nat} {k : Fin (n + 1)} : last n ≤ k ↔ k = last n 
Arguments: {n : Nat} {k : Fin (n + 1)}
Goal: Fin.last n ≤ k ↔ k = Fin.last n
-- Fin.lt_add_one_iff
@[simp] theorem lt_add_one_iff {n : Nat} {k : Fin (n + 1)} : k < k + 1 ↔ k < last n 
Arguments: {n : Nat} {k : Fin (n + 1)}
Goal: k < k + 1 ↔ k < Fin.last n
-- Fin.le_zero_iff
@[simp] theorem le_zero_iff {n : Nat} {k : Fin (n + 1)} : k ≤ 0 ↔ k = 0 
Arguments: {n : Nat} {k : Fin (n + 1)}
Goal: k ≤ 0 ↔ k = 0
-- Fin.succ_succ_ne_one
theorem succ_succ_ne_one (a : Fin n) : Fin.succ (Fin.succ a) ≠ 1 
Arguments: {n : Nat} (a : Fin n)
Goal: a.succ.succ ≠ 1
-- Fin.coe_castLT
@[simp] theorem coe_castLT (i : Fin m) (h : i.1 < n) : (castLT i h : Nat) = i 
Arguments: {m n : Nat} (i : Fin m) (h : ↑i < n)
Goal: ↑(i.castLT h) = ↑i
-- Fin.castLT_mk
@[simp] theorem castLT_mk (i n m : Nat) (hn : i < n) (hm : i < m) : castLT ⟨i, hn⟩ hm = ⟨i, hm⟩ 
Arguments: (i n m : Nat) (hn : i < n) (hm : i < m)
Goal: ⟨i, hn⟩.castLT hm = ⟨i, hm⟩
-- Fin.coe_castLE
@[simp] theorem coe_castLE (h : n ≤ m) (i : Fin n) : (castLE h i : Nat) = i 
Arguments: {n m : Nat} (h : n ≤ m) (i : Fin n)
Goal: ↑(Fin.castLE h i) = ↑i
-- Fin.castLE_mk
@[simp] theorem castLE_mk (i n m : Nat) (hn : i < n) (h : n ≤ m) :
    castLE h ⟨i, hn⟩ = ⟨i, Nat.lt_of_lt_of_le hn h⟩ 
Arguments: (i n m : Nat) (hn : i < n) (h : n ≤ m)
Goal: Fin.castLE h ⟨i, hn⟩ = ⟨i, ⋯⟩
-- Fin.castLE_zero
@[simp] theorem castLE_zero {n m : Nat} (h : n.succ ≤ m.succ) : castLE h 0 = 0 
Arguments: {n m : Nat} (h : n.succ ≤ m.succ)
Goal: Fin.castLE h 0 = 0
-- Fin.castLE_succ
@[simp] theorem castLE_succ {m n : Nat} (h : m + 1 ≤ n + 1) (i : Fin m) :
    castLE h i.succ = (castLE (Nat.succ_le_succ_iff.mp h) i).succ 
Arguments: {m n : Nat} (h : m + 1 ≤ n + 1) (i : Fin m)
Goal: Fin.castLE h i.succ = (Fin.castLE ⋯ i).succ
-- Fin.castLE_castLE
@[simp] theorem castLE_castLE {k m n} (km : k ≤ m) (mn : m ≤ n) (i : Fin k) :
    Fin.castLE mn (Fin.castLE km i) = Fin.castLE (Nat.le_trans km mn) i 
Arguments: {k m n : Nat} (km : k ≤ m) (mn : m ≤ n) (i : Fin k)
Goal: Fin.castLE mn (Fin.castLE km i) = Fin.castLE ⋯ i
-- Fin.castLE_comp_castLE
@[simp] theorem castLE_comp_castLE {k m n} (km : k ≤ m) (mn : m ≤ n) :
    Fin.castLE mn ∘ Fin.castLE km = Fin.castLE (Nat.le_trans km mn) 
Arguments: {k m n : Nat} (km : k ≤ m) (mn : m ≤ n)
Goal: Fin.castLE mn ∘ Fin.castLE km = Fin.castLE ⋯
-- Fin.coe_cast
@[simp] theorem coe_cast (h : n = m) (i : Fin n) : (cast h i : Nat) = i 
Arguments: {n m : Nat} (h : n = m) (i : Fin n)
Goal: ↑(Fin.cast h i) = ↑i
-- Fin.cast_last
@[simp] theorem cast_last {n' : Nat} {h : n + 1 = n' + 1} : cast h (last n) = last n' 
Arguments: {n n' : Nat} {h : n + 1 = n' + 1}
Goal: Fin.cast h (Fin.last n) = Fin.last n'
-- Fin.cast_mk
@[simp] theorem cast_mk (h : n = m) (i : Nat) (hn : i < n) : cast h ⟨i, hn⟩ = ⟨i, h ▸ hn⟩ 
Arguments: {n m : Nat} (h : n = m) (i : Nat) (hn : i < n)
Goal: Fin.cast h ⟨i, hn⟩ = ⟨i, ⋯⟩
-- Fin.cast_trans
@[simp] theorem cast_trans {k : Nat} (h : n = m) (h' : m = k) {i : Fin n} :
    cast h' (cast h i) = cast (Eq.trans h h') i 
Arguments: {n m k : Nat} (h : n = m) (h' : m = k) {i : Fin n}
Goal: Fin.cast h' (Fin.cast h i) = Fin.cast ⋯ i
-- Fin.castLE_of_eq
theorem castLE_of_eq {m n : Nat} (h : m = n) {h' : m ≤ n} : castLE h' = Fin.cast h 
Arguments: {m n : Nat} (h : m = n) {h' : m ≤ n}
Goal: Fin.castLE h' = Fin.cast h
-- Fin.coe_castAdd
@[simp] theorem coe_castAdd (m : Nat) (i : Fin n) : (castAdd m i : Nat) = i 
Arguments: {n : Nat} (m : Nat) (i : Fin n)
Goal: ↑(Fin.castAdd m i) = ↑i
-- Fin.castAdd_zero
@[simp] theorem castAdd_zero : (castAdd 0 : Fin n → Fin (n + 0)) = cast rfl 
Arguments: {n : Nat}
Goal: Fin.castAdd 0 = Fin.cast ⋯
-- Fin.castAdd_lt
theorem castAdd_lt {m : Nat} (n : Nat) (i : Fin m) : (castAdd n i : Nat) < m 
Arguments: {m : Nat} (n : Nat) (i : Fin m)
Goal: ↑(Fin.castAdd n i) < m
-- Fin.castAdd_mk
@[simp] theorem castAdd_mk (m : Nat) (i : Nat) (h : i < n) :
    castAdd m ⟨i, h⟩ = ⟨i, Nat.lt_add_right m h⟩ 
Arguments: {n : Nat} (m i : Nat) (h : i < n)
Goal: Fin.castAdd m ⟨i, h⟩ = ⟨i, ⋯⟩
-- Fin.castAdd_castLT
@[simp] theorem castAdd_castLT (m : Nat) (i : Fin (n + m)) (hi : i.val < n) :
    castAdd m (castLT i hi) = i 
Arguments: {n : Nat} (m : Nat) (i : Fin (n + m)) (hi : ↑i < n)
Goal: Fin.castAdd m (i.castLT hi) = i
-- Fin.castLT_castAdd
@[simp] theorem castLT_castAdd (m : Nat) (i : Fin n) :
    castLT (castAdd m i) (castAdd_lt m i) = i 
Arguments: {n : Nat} (m : Nat) (i : Fin n)
Goal: (Fin.castAdd m i).castLT ⋯ = i
-- Fin.castAdd_cast
theorem castAdd_cast {n n' : Nat} (m : Nat) (i : Fin n') (h : n' = n) :
    castAdd m (Fin.cast h i) = Fin.cast (congrArg (. + m) h) (castAdd m i) 
Arguments: {n n' : Nat} (m : Nat) (i : Fin n') (h : n' = n)
Goal: Fin.castAdd m (Fin.cast h i) = Fin.cast ⋯ (Fin.castAdd m i)
-- Fin.cast_castAdd_left
theorem cast_castAdd_left {n n' m : Nat} (i : Fin n') (h : n' + m = n + m) :
    cast h (castAdd m i) = castAdd m (cast (Nat.add_right_cancel h) i) 
Arguments: {n n' m : Nat} (i : Fin n') (h : n' + m = n + m)
Goal: Fin.cast h (Fin.castAdd m i) = Fin.castAdd m (Fin.cast ⋯ i)
-- Fin.cast_castAdd_right
@[simp] theorem cast_castAdd_right {n m m' : Nat} (i : Fin n) (h : n + m' = n + m) :
    cast h (castAdd m' i) = castAdd m i 
Arguments: {n m m' : Nat} (i : Fin n) (h : n + m' = n + m)
Goal: Fin.cast h (Fin.castAdd m' i) = Fin.castAdd m i
-- Fin.castAdd_castAdd
theorem castAdd_castAdd {m n p : Nat} (i : Fin m) :
    castAdd p (castAdd n i) = cast (Nat.add_assoc ..).symm (castAdd (n + p) i) 
Arguments: {m n p : Nat} (i : Fin m)
Goal: Fin.castAdd p (Fin.castAdd n i) = Fin.cast ⋯ (Fin.castAdd (n + p) i)
-- Fin.cast_succ_eq
@[simp] theorem cast_succ_eq {n' : Nat} (i : Fin n) (h : n.succ = n'.succ) :
    cast h i.succ = (cast (Nat.succ.inj h) i).succ 
Arguments: {n n' : Nat} (i : Fin n) (h : n.succ = n'.succ)
Goal: Fin.cast h i.succ = (Fin.cast ⋯ i).succ
-- Fin.succ_cast_eq
theorem succ_cast_eq {n' : Nat} (i : Fin n) (h : n = n') :
    (cast h i).succ = cast (by rw [h]) i.succ 
Arguments: {n n' : Nat} (i : Fin n) (h : n = n')
Goal: (Fin.cast h i).succ = Fin.cast ⋯ i.succ
-- Fin.coe_castSucc
@[simp] theorem coe_castSucc (i : Fin n) : (Fin.castSucc i : Nat) = i 
Arguments: {n : Nat} (i : Fin n)
Goal: ↑i.castSucc = ↑i
-- Fin.castSucc_mk
@[simp] theorem castSucc_mk (n i : Nat) (h : i < n) : castSucc ⟨i, h⟩ = ⟨i, Nat.lt.step h⟩ 
Arguments: (n i : Nat) (h : i < n)
Goal: ⟨i, h⟩.castSucc = ⟨i, ⋯⟩
-- Fin.cast_castSucc
@[simp] theorem cast_castSucc {n' : Nat} {h : n + 1 = n' + 1} {i : Fin n} :
    cast h (castSucc i) = castSucc (cast (Nat.succ.inj h) i) 
Arguments: {n n' : Nat} {h : n + 1 = n' + 1} {i : Fin n}
Goal: Fin.cast h i.castSucc = (Fin.cast ⋯ i).castSucc
-- Fin.castSucc_lt_succ
theorem castSucc_lt_succ (i : Fin n) : Fin.castSucc i < i.succ 
Arguments: {n : Nat} (i : Fin n)
Goal: i.castSucc < i.succ
-- Fin.le_castSucc_iff
theorem le_castSucc_iff {i : Fin (n + 1)} {j : Fin n} : i ≤ Fin.castSucc j ↔ i < j.succ 
Arguments: {n : Nat} {i : Fin (n + 1)} {j : Fin n}
Goal: i ≤ j.castSucc ↔ i < j.succ
-- Fin.castSucc_lt_iff_succ_le
theorem castSucc_lt_iff_succ_le {n : Nat} {i : Fin n} {j : Fin (n + 1)} :
    Fin.castSucc i < j ↔ i.succ ≤ j 
Arguments: {n : Nat} {i : Fin n} {j : Fin (n + 1)}
Goal: i.castSucc < j ↔ i.succ ≤ j
-- Fin.succ_last
@[simp] theorem succ_last (n : Nat) : (last n).succ = last n.succ 
Arguments: (n : Nat)
Goal: (Fin.last n).succ = Fin.last n.succ
-- Fin.succ_eq_last_succ
@[simp] theorem succ_eq_last_succ {n : Nat} (i : Fin n.succ) :
    i.succ = last (n + 1) ↔ i = last n 
Arguments: {n : Nat} (i : Fin n.succ)
Goal: i.succ = Fin.last (n + 1) ↔ i = Fin.last n
-- Fin.castSucc_castLT
@[simp] theorem castSucc_castLT (i : Fin (n + 1)) (h : (i : Nat) < n) :
    castSucc (castLT i h) = i 
Arguments: {n : Nat} (i : Fin (n + 1)) (h : ↑i < n)
Goal: (i.castLT h).castSucc = i
-- Fin.castLT_castSucc
@[simp] theorem castLT_castSucc {n : Nat} (a : Fin n) (h : (a : Nat) < n) :
    castLT (castSucc a) h = a 
Arguments: {n : Nat} (a : Fin n) (h : ↑a < n)
Goal: a.castSucc.castLT h = a
-- Fin.castSucc_lt_castSucc_iff
@[simp] theorem castSucc_lt_castSucc_iff {a b : Fin n} :
    Fin.castSucc a < Fin.castSucc b ↔ a < b 
Arguments: {n : Nat} {a b : Fin n}
Goal: a.castSucc < b.castSucc ↔ a < b
-- Fin.castSucc_inj
theorem castSucc_inj {a b : Fin n} : castSucc a = castSucc b ↔ a = b 
Arguments: {n : Nat} {a b : Fin n}
Goal: a.castSucc = b.castSucc ↔ a = b
-- Fin.castSucc_lt_last
theorem castSucc_lt_last (a : Fin n) : castSucc a < last n 
Arguments: {n : Nat} (a : Fin n)
Goal: a.castSucc < Fin.last n
-- Fin.castSucc_zero
@[simp] theorem castSucc_zero : castSucc (0 : Fin (n + 1)) = 0 
Arguments: {n : Nat}
Goal: Fin.castSucc 0 = 0
-- Fin.castSucc_one
@[simp] theorem castSucc_one {n : Nat} : castSucc (1 : Fin (n + 2)) = 1 
Arguments: {n : Nat}
Goal: Fin.castSucc 1 = 1
-- Fin.castSucc_pos
theorem castSucc_pos {i : Fin (n + 1)} (h : 0 < i) : 0 < castSucc i 
Arguments: {n : Nat} {i : Fin (n + 1)} (h : 0 < i)
Goal: 0 < i.castSucc
-- Fin.castSucc_eq_zero_iff
@[simp] theorem castSucc_eq_zero_iff (a : Fin (n + 1)) : castSucc a = 0 ↔ a = 0 
Arguments: {n : Nat} (a : Fin (n + 1))
Goal: a.castSucc = 0 ↔ a = 0
-- Fin.castSucc_ne_zero_iff
theorem castSucc_ne_zero_iff (a : Fin (n + 1)) : castSucc a ≠ 0 ↔ a ≠ 0 
Arguments: {n : Nat} (a : Fin (n + 1))
Goal: a.castSucc ≠ 0 ↔ a ≠ 0
-- Fin.castSucc_fin_succ
theorem castSucc_fin_succ (n : Nat) (j : Fin n) :
    castSucc (Fin.succ j) = Fin.succ (castSucc j) 
Arguments: (n : Nat) (j : Fin n)
Goal: j.succ.castSucc = j.castSucc.succ
-- Fin.coeSucc_eq_succ
@[simp]
theorem coeSucc_eq_succ {a : Fin n} : castSucc a + 1 = a.succ 
Arguments: {n : Nat} {a : Fin n}
Goal: a.castSucc + 1 = a.succ
-- Fin.lt_succ
theorem lt_succ {a : Fin n} : castSucc a < a.succ 
Arguments: {n : Nat} {a : Fin n}
Goal: a.castSucc < a.succ
-- Fin.exists_castSucc_eq
theorem exists_castSucc_eq {n : Nat} {i : Fin (n + 1)} : (∃ j, castSucc j = i) ↔ i ≠ last n 
Arguments: {n : Nat} {i : Fin (n + 1)}
Goal: (∃ j, j.castSucc = i) ↔ i ≠ Fin.last n
-- Fin.succ_castSucc
theorem succ_castSucc {n : Nat} (i : Fin n) : i.castSucc.succ = castSucc i.succ 
Arguments: {n : Nat} (i : Fin n)
Goal: i.castSucc.succ = i.succ.castSucc
-- Fin.coe_addNat
@[simp] theorem coe_addNat (m : Nat) (i : Fin n) : (addNat i m : Nat) = i + m 
Arguments: {n : Nat} (m : Nat) (i : Fin n)
Goal: ↑(i.addNat m) = ↑i + m
-- Fin.addNat_one
@[simp] theorem addNat_one {i : Fin n} : addNat i 1 = i.succ 
Arguments: {n : Nat} {i : Fin n}
Goal: i.addNat 1 = i.succ
-- Fin.le_coe_addNat
theorem le_coe_addNat (m : Nat) (i : Fin n) : m ≤ addNat i m 
Arguments: {n : Nat} (m : Nat) (i : Fin n)
Goal: m ≤ ↑(i.addNat m)
-- Fin.addNat_mk
@[simp] theorem addNat_mk (n i : Nat) (hi : i < m) :
    addNat ⟨i, hi⟩ n = ⟨i + n, Nat.add_lt_add_right hi n⟩ 
Arguments: {m : Nat} (n i : Nat) (hi : i < m)
Goal: ⟨i, hi⟩.addNat n = ⟨i + n, ⋯⟩
-- Fin.cast_addNat_zero
@[simp] theorem cast_addNat_zero {n n' : Nat} (i : Fin n) (h : n + 0 = n') :
    cast h (addNat i 0) = cast ((Nat.add_zero _).symm.trans h) i 
Arguments: {n n' : Nat} (i : Fin n) (h : n + 0 = n')
Goal: Fin.cast h (i.addNat 0) = Fin.cast ⋯ i
-- Fin.addNat_cast
theorem addNat_cast {n n' m : Nat} (i : Fin n') (h : n' = n) :
    addNat (cast h i) m = cast (congrArg (. + m) h) (addNat i m) 
Arguments: {n n' m : Nat} (i : Fin n') (h : n' = n)
Goal: (Fin.cast h i).addNat m = Fin.cast ⋯ (i.addNat m)
-- Fin.cast_addNat_left
theorem cast_addNat_left {n n' m : Nat} (i : Fin n') (h : n' + m = n + m) :
    cast h (addNat i m) = addNat (cast (Nat.add_right_cancel h) i) m 
Arguments: {n n' m : Nat} (i : Fin n') (h : n' + m = n + m)
Goal: Fin.cast h (i.addNat m) = (Fin.cast ⋯ i).addNat m
-- Fin.cast_addNat_right
@[simp] theorem cast_addNat_right {n m m' : Nat} (i : Fin n) (h : n + m' = n + m) :
    cast h (addNat i m') = addNat i m 
Arguments: {n m m' : Nat} (i : Fin n) (h : n + m' = n + m)
Goal: Fin.cast h (i.addNat m') = i.addNat m
-- Fin.coe_natAdd
@[simp] theorem coe_natAdd (n : Nat) {m : Nat} (i : Fin m) : (natAdd n i : Nat) = n + i 
Arguments: (n : Nat) {m : Nat} (i : Fin m)
Goal: ↑(Fin.natAdd n i) = n + ↑i
-- Fin.natAdd_mk
@[simp] theorem natAdd_mk (n i : Nat) (hi : i < m) :
    natAdd n ⟨i, hi⟩ = ⟨n + i, Nat.add_lt_add_left hi n⟩ 
Arguments: {m : Nat} (n i : Nat) (hi : i < m)
Goal: Fin.natAdd n ⟨i, hi⟩ = ⟨n + i, ⋯⟩
-- Fin.le_coe_natAdd
theorem le_coe_natAdd (m : Nat) (i : Fin n) : m ≤ natAdd m i 
Arguments: {n : Nat} (m : Nat) (i : Fin n)
Goal: m ≤ ↑(Fin.natAdd m i)
-- Fin.natAdd_zero
theorem natAdd_zero {n : Nat} : natAdd 0 = cast (Nat.zero_add n).symm 
Arguments: {n : Nat}
Goal: Fin.natAdd 0 = Fin.cast ⋯
-- Fin.natAdd_cast
theorem natAdd_cast {n n' : Nat} (m : Nat) (i : Fin n') (h : n' = n) :
    natAdd m (cast h i) = cast (congrArg _ h) (natAdd m i) 
Arguments: {n n' : Nat} (m : Nat) (i : Fin n') (h : n' = n)
Goal: Fin.natAdd m (Fin.cast h i) = Fin.cast ⋯ (Fin.natAdd m i)
-- Fin.cast_natAdd_right
theorem cast_natAdd_right {n n' m : Nat} (i : Fin n') (h : m + n' = m + n) :
    cast h (natAdd m i) = natAdd m (cast (Nat.add_left_cancel h) i) 
Arguments: {n n' m : Nat} (i : Fin n') (h : m + n' = m + n)
Goal: Fin.cast h (Fin.natAdd m i) = Fin.natAdd m (Fin.cast ⋯ i)
-- Fin.cast_natAdd_left
@[simp] theorem cast_natAdd_left {n m m' : Nat} (i : Fin n) (h : m' + n = m + n) :
    cast h (natAdd m' i) = natAdd m i 
Arguments: {n m m' : Nat} (i : Fin n) (h : m' + n = m + n)
Goal: Fin.cast h (Fin.natAdd m' i) = Fin.natAdd m i