ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Fin.castAdd_natAdd
theorem castAdd_natAdd (p m : Nat) {n : Nat} (i : Fin n) :
    castAdd p (natAdd m i) = cast (Nat.add_assoc ..).symm (natAdd m (castAdd p i)) 
Arguments: (p m : Nat) {n : Nat} (i : Fin n)
Goal: Fin.castAdd p (Fin.natAdd m i) = Fin.cast ⋯ (Fin.natAdd m (Fin.castAdd p i))
-- Fin.natAdd_castAdd
theorem natAdd_castAdd (p m : Nat) {n : Nat} (i : Fin n) :
    natAdd m (castAdd p i) = cast (Nat.add_assoc ..) (castAdd p (natAdd m i)) 
Arguments: (p m : Nat) {n : Nat} (i : Fin n)
Goal: Fin.natAdd m (Fin.castAdd p i) = Fin.cast ⋯ (Fin.castAdd p (Fin.natAdd m i))
-- Fin.natAdd_natAdd
theorem natAdd_natAdd (m n : Nat) {p : Nat} (i : Fin p) :
    natAdd m (natAdd n i) = cast (Nat.add_assoc ..) (natAdd (m + n) i) 
Arguments: (m n : Nat) {p : Nat} (i : Fin p)
Goal: Fin.natAdd m (Fin.natAdd n i) = Fin.cast ⋯ (Fin.natAdd (m + n) i)
-- Fin.cast_natAdd_zero
@[simp]
theorem cast_natAdd_zero {n n' : Nat} (i : Fin n) (h : 0 + n = n') :
    cast h (natAdd 0 i) = cast ((Nat.zero_add _).symm.trans h) i 
Arguments: {n n' : Nat} (i : Fin n) (h : 0 + n = n')
Goal: Fin.cast h (Fin.natAdd 0 i) = Fin.cast ⋯ i
-- Fin.cast_natAdd
@[simp]
theorem cast_natAdd (n : Nat) {m : Nat} (i : Fin m) :
    cast (Nat.add_comm ..) (natAdd n i) = addNat i n 
Arguments: (n : Nat) {m : Nat} (i : Fin m)
Goal: Fin.cast ⋯ (Fin.natAdd n i) = i.addNat n
-- Fin.cast_addNat
@[simp]
theorem cast_addNat {n : Nat} (m : Nat) (i : Fin n) :
    cast (Nat.add_comm ..) (addNat i m) = natAdd m i 
Arguments: {n : Nat} (m : Nat) (i : Fin n)
Goal: Fin.cast ⋯ (i.addNat m) = Fin.natAdd m i
-- Fin.natAdd_last
@[simp] theorem natAdd_last {m n : Nat} : natAdd n (last m) = last (n + m) 
Arguments: {m n : Nat}
Goal: Fin.natAdd n (Fin.last m) = Fin.last (n + m)
-- Fin.natAdd_castSucc
theorem natAdd_castSucc {m n : Nat} {i : Fin m} : natAdd n (castSucc i) = castSucc (natAdd n i) 
Arguments: {m n : Nat} {i : Fin m}
Goal: Fin.natAdd n i.castSucc = (Fin.natAdd n i).castSucc
-- Fin.rev_castAdd
theorem rev_castAdd (k : Fin n) (m : Nat) : rev (castAdd m k) = addNat (rev k) m 
Arguments: {n : Nat} (k : Fin n) (m : Nat)
Goal: (Fin.castAdd m k).rev = k.rev.addNat m
-- Fin.rev_addNat
theorem rev_addNat (k : Fin n) (m : Nat) : rev (addNat k m) = castAdd m (rev k) 
Arguments: {n : Nat} (k : Fin n) (m : Nat)
Goal: (k.addNat m).rev = Fin.castAdd m k.rev
-- Fin.rev_castSucc
theorem rev_castSucc (k : Fin n) : rev (castSucc k) = succ (rev k) 
Arguments: {n : Nat} (k : Fin n)
Goal: k.castSucc.rev = k.rev.succ
-- Fin.rev_succ
theorem rev_succ (k : Fin n) : rev (succ k) = castSucc (rev k) 
Arguments: {n : Nat} (k : Fin n)
Goal: k.succ.rev = k.rev.castSucc
-- Fin.coe_pred
@[simp] theorem coe_pred (j : Fin (n + 1)) (h : j ≠ 0) : (j.pred h : Nat) = j - 1 
Arguments: {n : Nat} (j : Fin (n + 1)) (h : j ≠ 0)
Goal: ↑(j.pred h) = ↑j - 1
-- Fin.succ_pred
@[simp] theorem succ_pred : ∀ (i : Fin (n + 1)) (h : i ≠ 0), (i.pred h).succ = i
  
Arguments: {n : Nat} (i : Fin (n + 1)) (h : i ≠ 0)
Goal: (i.pred h).succ = i
-- Fin.pred_succ
@[simp]
theorem pred_succ (i : Fin n) {h : i.succ ≠ 0} : i.succ.pred h = i 
Arguments: {n : Nat} (i : Fin n) {h : i.succ ≠ 0}
Goal: i.succ.pred h = i
-- Fin.pred_eq_iff_eq_succ
theorem pred_eq_iff_eq_succ {n : Nat} (i : Fin (n + 1)) (hi : i ≠ 0) (j : Fin n) :
    i.pred hi = j ↔ i = j.succ 
Arguments: {n : Nat} (i : Fin (n + 1)) (hi : i ≠ 0) (j : Fin n)
Goal: i.pred hi = j ↔ i = j.succ
-- Fin.pred_mk_succ
theorem pred_mk_succ (i : Nat) (h : i < n + 1) :
    Fin.pred ⟨i + 1, Nat.add_lt_add_right h 1⟩ (ne_of_val_ne (Nat.ne_of_gt (mk_succ_pos i h))) =
      ⟨i, h⟩ 
Arguments: {n : Nat} (i : Nat) (h : i < n + 1)
Goal: ⟨i + 1, ⋯⟩.pred ⋯ = ⟨i, h⟩
-- Fin.pred_mk_succ'
@[simp] theorem pred_mk_succ' (i : Nat) (h₁ : i + 1 < n + 1 + 1) (h₂) :
    Fin.pred ⟨i + 1, h₁⟩ h₂ = ⟨i, Nat.lt_of_succ_lt_succ h₁⟩ 
Arguments: {n : Nat} (i : Nat) (h₁ : i + 1 < n + 1 + 1) (h₂ : ⟨i + 1, h₁⟩ ≠ 0)
Goal: ⟨i + 1, h₁⟩.pred h₂ = ⟨i, ⋯⟩
-- Fin.pred_mk
theorem pred_mk {n : Nat} (i : Nat) (h : i < n + 1) (w) : Fin.pred ⟨i, h⟩ w =
    ⟨i - 1, Nat.sub_lt_right_of_lt_add (Nat.pos_iff_ne_zero.2 (Fin.val_ne_of_ne w)) h⟩ 
Arguments: {n : Nat} (i : Nat) (h : i < n + 1) (w : ⟨i, h⟩ ≠ 0)
Goal: ⟨i, h⟩.pred w = ⟨i - 1, ⋯⟩
-- Fin.pred_le_pred_iff
@[simp] theorem pred_le_pred_iff {n : Nat} {a b : Fin n.succ} {ha : a ≠ 0} {hb : b ≠ 0} :
    a.pred ha ≤ b.pred hb ↔ a ≤ b 
Arguments: {n : Nat} {a b : Fin n.succ} {ha : a ≠ 0} {hb : b ≠ 0}
Goal: a.pred ha ≤ b.pred hb ↔ a ≤ b
-- Fin.pred_lt_pred_iff
@[simp] theorem pred_lt_pred_iff {n : Nat} {a b : Fin n.succ} {ha : a ≠ 0} {hb : b ≠ 0} :
    a.pred ha < b.pred hb ↔ a < b 
Arguments: {n : Nat} {a b : Fin n.succ} {ha : a ≠ 0} {hb : b ≠ 0}
Goal: a.pred ha < b.pred hb ↔ a < b
-- Fin.pred_inj
@[simp] theorem pred_inj :
    ∀ {a b : Fin (n + 1)} {ha : a ≠ 0} {hb : b ≠ 0}, a.pred ha = b.pred hb ↔ a = b
  
Arguments: {n : Nat} {a b : Fin (n + 1)} {ha : a ≠ 0} {hb : b ≠ 0}
Goal: a.pred ha = b.pred hb ↔ a = b
-- Fin.pred_one
@[simp] theorem pred_one {n : Nat} :
    Fin.pred (1 : Fin (n + 2)) (Ne.symm (Fin.ne_of_lt one_pos)) = 0 
Arguments: {n : Nat}
Goal: Fin.pred 1 ⋯ = 0
-- Fin.pred_add_one
theorem pred_add_one (i : Fin (n + 2)) (h : (i : Nat) < n + 1) :
    pred (i + 1) (Fin.ne_of_gt (add_one_pos _ (lt_def.2 h))) = castLT i h 
Arguments: {n : Nat} (i : Fin (n + 2)) (h : ↑i < n + 1)
Goal: (i + 1).pred ⋯ = i.castLT h
-- Fin.coe_subNat
@[simp] theorem coe_subNat (i : Fin (n + m)) (h : m ≤ i) : (i.subNat m h : Nat) = i - m 
Arguments: {n m : Nat} (i : Fin (n + m)) (h : m ≤ ↑i)
Goal: ↑(Fin.subNat m i h) = ↑i - m
-- Fin.subNat_mk
@[simp] theorem subNat_mk {i : Nat} (h₁ : i < n + m) (h₂ : m ≤ i) :
    subNat m ⟨i, h₁⟩ h₂ = ⟨i - m, Nat.sub_lt_right_of_lt_add h₂ h₁⟩ 
Arguments: {n m i : Nat} (h₁ : i < n + m) (h₂ : m ≤ i)
Goal: Fin.subNat m ⟨i, h₁⟩ h₂ = ⟨i - m, ⋯⟩
-- Fin.pred_castSucc_succ
@[simp] theorem pred_castSucc_succ (i : Fin n) :
    pred (castSucc i.succ) (Fin.ne_of_gt (castSucc_pos i.succ_pos)) = castSucc i 
Arguments: {n : Nat} (i : Fin n)
Goal: i.succ.castSucc.pred ⋯ = i.castSucc
-- Fin.addNat_subNat
@[simp] theorem addNat_subNat {i : Fin (n + m)} (h : m ≤ i) : addNat (subNat m i h) m = i 
Arguments: {n m : Nat} {i : Fin (n + m)} (h : m ≤ ↑i)
Goal: (Fin.subNat m i h).addNat m = i
-- Fin.subNat_addNat
@[simp] theorem subNat_addNat (i : Fin n) (m : Nat) (h : m ≤ addNat i m := le_coe_addNat m i) :
    subNat m (addNat i m) h = i 
Arguments: {n : Nat} (i : Fin n) (m : Nat) (h : m ≤ ↑(i.addNat m) := ⋯)
Goal: Fin.subNat m (i.addNat m) h = i
-- Fin.natAdd_subNat_cast
@[simp] theorem natAdd_subNat_cast {i : Fin (n + m)} (h : n ≤ i) :
    natAdd n (subNat n (cast (Nat.add_comm ..) i) h) = i 
Arguments: {n m : Nat} {i : Fin (n + m)} (h : n ≤ ↑i)
Goal: Fin.natAdd n (Fin.subNat n (Fin.cast ⋯ i) h) = i
-- Fin.succRecOn_zero
@[simp] theorem succRecOn_zero {motive : ∀ n, Fin n → Sort _} {zero succ} (n) :
    @Fin.succRecOn (n + 1) 0 motive zero succ = zero n 
Arguments: {motive : (n : Nat) → Fin n → Sort u_1} {zero : (n : Nat) → motive (n + 1) 0} {succ : (n : Nat) → (i : Fin n) → motive n i → motive n.succ i.succ} (n : Nat)
Goal: Fin.succRecOn 0 zero succ = zero n
-- Fin.succRecOn_succ
@[simp] theorem succRecOn_succ {motive : ∀ n, Fin n → Sort _} {zero succ} {n} (i : Fin n) :
    @Fin.succRecOn (n + 1) i.succ motive zero succ = succ n i (Fin.succRecOn i zero succ) 
Arguments: {motive : (n : Nat) → Fin n → Sort u_1} {zero : (n : Nat) → motive (n + 1) 0} {succ : (n : Nat) → (i : Fin n) → motive n i → motive n.succ i.succ} {n : Nat} (i : Fin n)
Goal: i.succ.succRecOn zero succ = succ n i (i.succRecOn zero succ)
-- Fin.induction_zero
@[simp] theorem induction_zero {motive : Fin (n + 1) → Sort _} (zero : motive 0)
    (hs : ∀ i : Fin n, motive (castSucc i) → motive i.succ) :
    (induction zero hs : ∀ i : Fin (n + 1), motive i) 0 = zero 
Arguments: {n : Nat} {motive : Fin (n + 1) → Sort u_1} (zero : motive 0) (hs : (i : Fin n) → motive i.castSucc → motive i.succ)
Goal: (fun i => Fin.induction zero hs i) 0 = zero
-- Fin.induction_succ
@[simp] theorem induction_succ {motive : Fin (n + 1) → Sort _} (zero : motive 0)
    (succ : ∀ i : Fin n, motive (castSucc i) → motive i.succ) (i : Fin n) :
    induction (motive := motive) zero succ i.succ = succ i (induction zero succ (castSucc i)) 
Arguments: {n : Nat} {motive : Fin (n + 1) → Sort u_1} (zero : motive 0) (succ : (i : Fin n) → motive i.castSucc → motive i.succ) (i : Fin n)
Goal: Fin.induction zero succ i.succ = succ i (Fin.induction zero succ i.castSucc)
-- Fin.cases_zero
@[simp] theorem cases_zero {n} {motive : Fin (n + 1) → Sort _} {zero succ} :
    @Fin.cases n motive zero succ 0 = zero 
Arguments: {n : Nat} {motive : Fin (n + 1) → Sort u_1} {zero : motive 0} {succ : (i : Fin n) → motive i.succ}
Goal: Fin.cases zero succ 0 = zero
-- Fin.cases_succ
@[simp] theorem cases_succ {n} {motive : Fin (n + 1) → Sort _} {zero succ} (i : Fin n) :
    @Fin.cases n motive zero succ i.succ = succ i 
Arguments: {n : Nat} {motive : Fin (n + 1) → Sort u_1} {zero : motive 0} {succ : (i : Fin n) → motive i.succ} (i : Fin n)
Goal: Fin.cases zero succ i.succ = succ i
-- Fin.cases_succ'
@[simp] theorem cases_succ' {n} {motive : Fin (n + 1) → Sort _} {zero succ}
    {i : Nat} (h : i + 1 < n + 1) :
    @Fin.cases n motive zero succ ⟨i.succ, h⟩ = succ ⟨i, Nat.lt_of_succ_lt_succ h⟩ 
Arguments: {n : Nat} {motive : Fin (n + 1) → Sort u_1} {zero : motive 0} {succ : (i : Fin n) → motive i.succ} {i : Nat} (h : i + 1 < n + 1)
Goal: Fin.cases zero succ ⟨i.succ, h⟩ = succ ⟨i, ⋯⟩
-- Fin.forall_fin_succ
theorem forall_fin_succ {P : Fin (n + 1) → Prop} : (∀ i, P i) ↔ P 0 ∧ ∀ i : Fin n, P i.succ 
Arguments: {n : Nat} {P : Fin (n + 1) → Prop}
Goal: (∀ (i : Fin (n + 1)), P i) ↔ P 0 ∧ ∀ (i : Fin n), P i.succ
-- Fin.exists_fin_succ
theorem exists_fin_succ {P : Fin (n + 1) → Prop} : (∃ i, P i) ↔ P 0 ∨ ∃ i : Fin n, P i.succ 
Arguments: {n : Nat} {P : Fin (n + 1) → Prop}
Goal: (∃ i, P i) ↔ P 0 ∨ ∃ i, P i.succ
-- Fin.forall_fin_one
theorem forall_fin_one {p : Fin 1 → Prop} : (∀ i, p i) ↔ p 0 
Arguments: {p : Fin 1 → Prop}
Goal: (∀ (i : Fin 1), p i) ↔ p 0
-- Fin.exists_fin_one
theorem exists_fin_one {p : Fin 1 → Prop} : (∃ i, p i) ↔ p 0 
Arguments: {p : Fin 1 → Prop}
Goal: (∃ i, p i) ↔ p 0
-- Fin.forall_fin_two
theorem forall_fin_two {p : Fin 2 → Prop} : (∀ i, p i) ↔ p 0 ∧ p 1 
Arguments: {p : Fin 2 → Prop}
Goal: (∀ (i : Fin 2), p i) ↔ p 0 ∧ p 1
-- Fin.exists_fin_two
theorem exists_fin_two {p : Fin 2 → Prop} : (∃ i, p i) ↔ p 0 ∨ p 1 
Arguments: {p : Fin 2 → Prop}
Goal: (∃ i, p i) ↔ p 0 ∨ p 1
-- Fin.fin_two_eq_of_eq_zero_iff
theorem fin_two_eq_of_eq_zero_iff : ∀ {a b : Fin 2}, (a = 0 ↔ b = 0) → a = b 
Arguments: {a b : Fin 2}
Goal: (a = 0 ↔ b = 0) → a = b
-- Fin.reverseInduction_last
@[simp] theorem reverseInduction_last {n : Nat} {motive : Fin (n + 1) → Sort _} {zero succ} :
    (reverseInduction zero succ (Fin.last n) : motive (Fin.last n)) = zero 
Arguments: {n : Nat} {motive : Fin (n + 1) → Sort u_1} {zero : motive (Fin.last n)} {succ : (i : Fin n) → motive i.succ → motive i.castSucc}
Goal: Fin.reverseInduction zero succ (Fin.last n) = zero
-- Fin.reverseInduction_castSucc
@[simp] theorem reverseInduction_castSucc {n : Nat} {motive : Fin (n + 1) → Sort _} {zero succ}
    (i : Fin n) : reverseInduction (motive := motive) zero succ (castSucc i) =
      succ i (reverseInduction zero succ i.succ) 
Arguments: {n : Nat} {motive : Fin (n + 1) → Sort u_1} {zero : motive (Fin.last n)} {succ : (i : Fin n) → motive i.succ → motive i.castSucc} (i : Fin n)
Goal: Fin.reverseInduction zero succ i.castSucc = succ i (Fin.reverseInduction zero succ i.succ)
-- Fin.lastCases_last
@[simp] theorem lastCases_last {n : Nat} {motive : Fin (n + 1) → Sort _} {last cast} :
    (Fin.lastCases last cast (Fin.last n) : motive (Fin.last n)) = last 
Arguments: {n : Nat} {motive : Fin (n + 1) → Sort u_1} {last : motive (Fin.last n)} {cast : (i : Fin n) → motive i.castSucc}
Goal: Fin.lastCases last cast (Fin.last n) = last
-- Fin.lastCases_castSucc
@[simp] theorem lastCases_castSucc {n : Nat} {motive : Fin (n + 1) → Sort _} {last cast}
    (i : Fin n) : (Fin.lastCases last cast (Fin.castSucc i) : motive (Fin.castSucc i)) = cast i 
Arguments: {n : Nat} {motive : Fin (n + 1) → Sort u_1} {last : motive (Fin.last n)} {cast : (i : Fin n) → motive i.castSucc} (i : Fin n)
Goal: Fin.lastCases last cast i.castSucc = cast i
-- Fin.addCases_left
@[simp] theorem addCases_left {m n : Nat} {motive : Fin (m + n) → Sort _} {left right} (i : Fin m) :
    addCases (motive := motive) left right (Fin.castAdd n i) = left i 
Arguments: {m n : Nat} {motive : Fin (m + n) → Sort u_1} {left : (i : Fin m) → motive (Fin.castAdd n i)} {right : (i : Fin n) → motive (Fin.natAdd m i)} (i : Fin m)
Goal: Fin.addCases left right (Fin.castAdd n i) = left i
-- Fin.addCases_right
@[simp]
theorem addCases_right {m n : Nat} {motive : Fin (m + n) → Sort _} {left right} (i : Fin n) :
    addCases (motive := motive) left right (natAdd m i) = right i 
Arguments: {m n : Nat} {motive : Fin (m + n) → Sort u_1} {left : (i : Fin m) → motive (Fin.castAdd n i)} {right : (i : Fin n) → motive (Fin.natAdd m i)} (i : Fin n)
Goal: Fin.addCases left right (Fin.natAdd m i) = right i
-- Fin.ofNat'_add
@[simp] theorem ofNat'_add (x : Nat) (lt : 0 < n) (y : Fin n) :
    Fin.ofNat' x lt + y = Fin.ofNat' (x + y.val) lt 
Arguments: {n : Nat} (x : Nat) (lt : 0 < n) (y : Fin n)
Goal: Fin.ofNat' x lt + y = Fin.ofNat' (x + ↑y) lt
-- Fin.add_ofNat'
@[simp] theorem add_ofNat' (x : Fin n) (y : Nat) (lt : 0 < n) :
    x + Fin.ofNat' y lt = Fin.ofNat' (x.val + y) lt 
Arguments: {n : Nat} (x : Fin n) (y : Nat) (lt : 0 < n)
Goal: x + Fin.ofNat' y lt = Fin.ofNat' (↑x + y) lt
-- Fin.coe_sub
protected theorem coe_sub (a b : Fin n) : ((a - b : Fin n) : Nat) = ((n - b) + a) % n 
Arguments: {n : Nat} (a b : Fin n)
Goal: ↑(a - b) = (n - ↑b + ↑a) % n
-- Fin.ofNat'_sub
@[simp] theorem ofNat'_sub (x : Nat) (lt : 0 < n) (y : Fin n) :
    Fin.ofNat' x lt - y = Fin.ofNat' ((n - y.val) + x) lt 
Arguments: {n : Nat} (x : Nat) (lt : 0 < n) (y : Fin n)
Goal: Fin.ofNat' x lt - y = Fin.ofNat' (n - ↑y + x) lt
-- Fin.sub_ofNat'
@[simp] theorem sub_ofNat' (x : Fin n) (y : Nat) (lt : 0 < n) :
    x - Fin.ofNat' y lt = Fin.ofNat' ((n - y % n) + x.val) lt 
Arguments: {n : Nat} (x : Fin n) (y : Nat) (lt : 0 < n)
Goal: x - Fin.ofNat' y lt = Fin.ofNat' (n - y % n + ↑x) lt
-- _private.«.lake».packages.lean4.src.lean.Init.Data.Fin.Lemmas.0.Nat.mod_eq_sub_of_lt_two_mul
private theorem _root_.Nat.mod_eq_sub_of_lt_two_mul {x n} (h₁ : n ≤ x) (h₂ : x < 2 * n) :
    x % n = x - n 
Arguments: {x n : Nat} (h₁ : n ≤ x) (h₂ : x < 2 * n)
Goal: x % n = x - n
-- Fin.coe_sub_iff_le
theorem coe_sub_iff_le {a b : Fin n} : (↑(a - b) : Nat) = a - b ↔ b ≤ a 
Arguments: {n : Nat} {a b : Fin n}
Goal: ↑(a - b) = ↑a - ↑b ↔ b ≤ a
-- Fin.coe_sub_iff_lt
theorem coe_sub_iff_lt {a b : Fin n} : (↑(a - b) : Nat) = n + a - b ↔ a < b 
Arguments: {n : Nat} {a b : Fin n}
Goal: ↑(a - b) = n + ↑a - ↑b ↔ a < b
-- Fin.val_mul
theorem val_mul {n : Nat} : ∀ 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.coe_mul
theorem coe_mul {n : Nat} : ∀ a b : Fin n, ((a * b : Fin n) : Nat) = a * b % n
  
Arguments: {n : Nat} (a b : Fin n)
Goal: ↑(a * b) = ↑a * ↑b % n
-- Fin.mul_one
protected theorem mul_one (k : Fin (n + 1)) : k * 1 = k 
Arguments: {n : Nat} (k : Fin (n + 1))
Goal: k * 1 = k
-- Fin.mul_comm
protected theorem mul_comm (a b : Fin n) : a * b = b * a 
Arguments: {n : Nat} (a b : Fin n)
Goal: a * b = b * a
-- Fin.mul_assoc
protected theorem mul_assoc (a b c : Fin n) : a * b * c = a * (b * c) 
Arguments: {n : Nat} (a b c : Fin n)
Goal: a * b * c = a * (b * c)
-- Fin.one_mul
protected theorem one_mul (k : Fin (n + 1)) : (1 : Fin (n + 1)) * k = k 
Arguments: {n : Nat} (k : Fin (n + 1))
Goal: 1 * k = k
-- Fin.mul_zero
protected theorem mul_zero (k : Fin (n + 1)) : k * 0 = 0 
Arguments: {n : Nat} (k : Fin (n + 1))
Goal: k * 0 = 0
-- Fin.zero_mul
protected theorem zero_mul (k : Fin (n + 1)) : (0 : Fin (n + 1)) * k = 0 
Arguments: {n : Nat} (k : Fin (n + 1))
Goal: 0 * k = 0
-- Int.dvd_def
protected theorem dvd_def (a b : Int) : (a ∣ b) = Exists (fun c => b = a * c) 
Arguments: (a b : Int)
Goal: (a ∣ b) = ∃ c, b = a * c
-- Int.dvd_zero
protected theorem dvd_zero (n : Int) : n ∣ 0 
Arguments: (n : Int)
Goal: n ∣ 0
-- Int.dvd_refl
protected theorem dvd_refl (n : Int) : n ∣ n 
Arguments: (n : Int)
Goal: n ∣ n
-- Int.one_dvd
protected theorem one_dvd (n : Int) : 1 ∣ n 
Arguments: (n : Int)
Goal: 1 ∣ n
-- Int.dvd_trans
protected theorem dvd_trans : ∀ {a b c : Int}, a ∣ b → b ∣ c → a ∣ c
  
Arguments: {a b c : Int}
Goal: a ∣ b → b ∣ c → a ∣ c
-- Int.ofNat_dvd
@[norm_cast] theorem ofNat_dvd {m n : Nat} : (↑m : Int) ∣ ↑n ↔ m ∣ n 
Arguments: {m n : Nat}
Goal: ↑m ∣ ↑n ↔ m ∣ n
-- Int.dvd_antisymm
theorem dvd_antisymm {a b : Int} (H1 : 0 ≤ a) (H2 : 0 ≤ b) : a ∣ b → b ∣ a → a = b 
Arguments: {a b : Int} (H1 : 0 ≤ a) (H2 : 0 ≤ b)
Goal: a ∣ b → b ∣ a → a = b
-- Int.zero_dvd
@[simp] protected theorem zero_dvd {n : Int} : 0 ∣ n ↔ n = 0 
Arguments: {n : Int}
Goal: 0 ∣ n ↔ n = 0
-- Int.dvd_mul_right
protected theorem dvd_mul_right (a b : Int) : a ∣ a * b 
Arguments: (a b : Int)
Goal: a ∣ a * b
-- Int.dvd_mul_left
protected theorem dvd_mul_left (a b : Int) : b ∣ a * b 
Arguments: (a b : Int)
Goal: b ∣ a * b
-- Int.neg_dvd
protected theorem neg_dvd {a b : Int} : -a ∣ b ↔ a ∣ b 
Arguments: {a b : Int}
Goal: -a ∣ b ↔ a ∣ b
-- Int.dvd_neg
protected theorem dvd_neg {a b : Int} : a ∣ -b ↔ a ∣ b 
Arguments: {a b : Int}
Goal: a ∣ -b ↔ a ∣ b
-- Int.natAbs_dvd_natAbs
@[simp] theorem natAbs_dvd_natAbs {a b : Int} : natAbs a ∣ natAbs b ↔ a ∣ b 
Arguments: {a b : Int}
Goal: a.natAbs ∣ b.natAbs ↔ a ∣ b
-- Int.ofNat_dvd_left
theorem ofNat_dvd_left {n : Nat} {z : Int} : (↑n : Int) ∣ z ↔ n ∣ z.natAbs 
Arguments: {n : Nat} {z : Int}
Goal: ↑n ∣ z ↔ n ∣ z.natAbs
-- Int.dvd_add
protected theorem dvd_add : ∀ {a b c : Int}, a ∣ b → a ∣ c → a ∣ b + c
  
Arguments: {a b c : Int}
Goal: a ∣ b → a ∣ c → a ∣ b + c
-- Int.dvd_sub
protected theorem dvd_sub : ∀ {a b c : Int}, a ∣ b → a ∣ c → a ∣ b - c
  
Arguments: {a b c : Int}
Goal: a ∣ b → a ∣ c → a ∣ b - c
-- Int.dvd_add_left
protected theorem dvd_add_left {a b c : Int} (H : a ∣ c) : a ∣ b + c ↔ a ∣ b 
Arguments: {a b c : Int} (H : a ∣ c)
Goal: a ∣ b + c ↔ a ∣ b
-- Int.dvd_add_right
protected theorem dvd_add_right {a b c : Int} (H : a ∣ b) : a ∣ b + c ↔ a ∣ c 
Arguments: {a b c : Int} (H : a ∣ b)
Goal: a ∣ b + c ↔ a ∣ c
-- Int.dvd_iff_dvd_of_dvd_sub
protected theorem dvd_iff_dvd_of_dvd_sub {a b c : Int} (H : a ∣ b - c) : a ∣ b ↔ a ∣ c 
Arguments: {a b c : Int} (H : a ∣ b - c)
Goal: a ∣ b ↔ a ∣ c
-- Int.dvd_iff_dvd_of_dvd_add
protected theorem dvd_iff_dvd_of_dvd_add {a b c : Int} (H : a ∣ b + c) : a ∣ b ↔ a ∣ c 
Arguments: {a b c : Int} (H : a ∣ b + c)
Goal: a ∣ b ↔ a ∣ c
-- Int.le_of_dvd
theorem le_of_dvd {a b : Int} (bpos : 0 < b) (H : a ∣ b) : a ≤ b 
Arguments: {a b : Int} (bpos : 0 < b) (H : a ∣ b)
Goal: a ≤ b
-- Int.natAbs_dvd
theorem natAbs_dvd {a b : Int} : (a.natAbs : Int) ∣ b ↔ a ∣ b 
Arguments: {a b : Int}
Goal: ↑a.natAbs ∣ b ↔ a ∣ b
-- Int.dvd_natAbs
theorem dvd_natAbs {a b : Int} : a ∣ b.natAbs ↔ a ∣ b 
Arguments: {a b : Int}
Goal: a ∣ ↑b.natAbs ↔ a ∣ b
-- Int.natAbs_dvd_self
theorem natAbs_dvd_self {a : Int} : (a.natAbs : Int) ∣ a 
Arguments: {a : Int}
Goal: ↑a.natAbs ∣ a
-- Int.dvd_natAbs_self
theorem dvd_natAbs_self {a : Int} : a ∣ (a.natAbs : Int) 
Arguments: {a : Int}
Goal: a ∣ ↑a.natAbs
-- Int.ofNat_dvd_right
theorem ofNat_dvd_right {n : Nat} {z : Int} : z ∣ (↑n : Int) ↔ z.natAbs ∣ n 
Arguments: {n : Nat} {z : Int}
Goal: z ∣ ↑n ↔ z.natAbs ∣ n
-- Int.eq_one_of_dvd_one
theorem eq_one_of_dvd_one {a : Int} (H : 0 ≤ a) (H' : a ∣ 1) : a = 1 
Arguments: {a : Int} (H : 0 ≤ a) (H' : a ∣ 1)
Goal: a = 1
-- Int.eq_one_of_mul_eq_one_right
theorem eq_one_of_mul_eq_one_right {a b : Int} (H : 0 ≤ a) (H' : a * b = 1) : a = 1 
Arguments: {a b : Int} (H : 0 ≤ a) (H' : a * b = 1)
Goal: a = 1
-- Int.eq_one_of_mul_eq_one_left
theorem eq_one_of_mul_eq_one_left {a b : Int} (H : 0 ≤ b) (H' : a * b = 1) : b = 1 
Arguments: {a b : Int} (H : 0 ≤ b) (H' : a * b = 1)
Goal: b = 1
-- Int.zero_ediv
@[simp] theorem zero_ediv : ∀ b : Int, 0 / b = 0
  
Arguments: (b : Int)
Goal: 0 / b = 0
-- Int.ediv_zero
@[simp] protected theorem ediv_zero : ∀ a : Int, a / 0 = 0
  
Arguments: (a : Int)
Goal: a / 0 = 0
-- Int.zero_div
@[simp] protected theorem zero_div : ∀ b : Int, div 0 b = 0
  
Arguments: (b : Int)
Goal: Int.div 0 b = 0
-- Int.div_zero
@[simp] protected theorem div_zero : ∀ a : Int, div a 0 = 0
  
Arguments: (a : Int)
Goal: a.div 0 = 0
-- Int.zero_fdiv
@[simp] theorem zero_fdiv (b : Int) : fdiv 0 b = 0 
Arguments: (b : Int)
Goal: Int.fdiv 0 b = 0
-- Int.fdiv_zero
@[simp] protected theorem fdiv_zero : ∀ a : Int, fdiv a 0 = 0
  
Arguments: (a : Int)
Goal: a.fdiv 0 = 0
-- Int.div_eq_ediv
theorem div_eq_ediv : ∀ {a b : Int}, 0 ≤ a → 0 ≤ b → a.div b = a / b
  
Arguments: {a b : Int}
Goal: 0 ≤ a → 0 ≤ b → a.div b = a / b
-- Int.fdiv_eq_ediv
theorem fdiv_eq_ediv : ∀ (a : Int) {b : Int}, 0 ≤ b → fdiv a b = a / b
  
Arguments: (a : Int) {b : Int}
Goal: 0 ≤ b → a.fdiv b = a / b
-- Int.fdiv_eq_div
theorem fdiv_eq_div {a b : Int} (Ha : 0 ≤ a) (Hb : 0 ≤ b) : fdiv a b = div a b 
Arguments: {a b : Int} (Ha : 0 ≤ a) (Hb : 0 ≤ b)
Goal: a.fdiv b = a.div b
-- Int.zero_emod
@[simp] theorem zero_emod (b : Int) : 0 % b = 0 
Arguments: (b : Int)
Goal: 0 % b = 0
-- Int.emod_zero
@[simp] theorem emod_zero : ∀ a : Int, a % 0 = a
  
Arguments: (a : Int)
Goal: a % 0 = a
-- Int.zero_mod
@[simp] theorem zero_mod (b : Int) : mod 0 b = 0 
Arguments: (b : Int)
Goal: Int.mod 0 b = 0
-- Int.mod_zero
@[simp] theorem mod_zero : ∀ a : Int, mod a 0 = a
  
Arguments: (a : Int)
Goal: a.mod 0 = a
-- Int.zero_fmod
@[simp] theorem zero_fmod (b : Int) : fmod 0 b = 0 
Arguments: (b : Int)
Goal: Int.fmod 0 b = 0
-- Int.fmod_zero
@[simp] theorem fmod_zero : ∀ a : Int, fmod a 0 = a
  
Arguments: (a : Int)
Goal: a.fmod 0 = a
-- Int.ofNat_emod
@[simp, norm_cast] theorem ofNat_emod (m n : Nat) : (↑(m % n) : Int) = m % n 
Arguments: (m n : Nat)
Goal: ↑(m % n) = ↑m % ↑n
-- Int.emod_add_ediv.aux
theorem emod_add_ediv : ∀ a b : Int, a % b + b * (a / b) = a
  
Arguments: (m n : Nat)
Goal: ↑n - (↑m % ↑n + 1) - (↑n * (↑m / ↑n) + ↑n) = -[m+1]
-- Int.emod_add_ediv
theorem emod_add_ediv : ∀ a b : Int, a % b + b * (a / b) = a
  
Arguments: (a b : Int)
Goal: a % b + b * (a / b) = a
-- Int.emod_add_ediv'
theorem emod_add_ediv' (a b : Int) : a % b + a / b * b = a 
Arguments: (a b : Int)
Goal: a % b + a / b * b = a
-- Int.ediv_add_emod
theorem ediv_add_emod (a b : Int) : b * (a / b) + a % b = a 
Arguments: (a b : Int)
Goal: b * (a / b) + a % b = a
-- Int.ediv_add_emod'
theorem ediv_add_emod' (a b : Int) : a / b * b + a % b = a 
Arguments: (a b : Int)
Goal: a / b * b + a % b = a
-- Int.emod_def
theorem emod_def (a b : Int) : a % b = a - b * (a / b) 
Arguments: (a b : Int)
Goal: a % b = a - b * (a / b)
-- Int.mod_add_div
theorem mod_add_div : ∀ a b : Int, mod a b + b * (a.div b) = a
  
Arguments: (a b : Int)
Goal: a.mod b + b * a.div b = a
-- Int.div_add_mod
theorem div_add_mod (a b : Int) : b * a.div b + mod a b = a 
Arguments: (a b : Int)
Goal: b * a.div b + a.mod b = a
-- Int.mod_add_div'
theorem mod_add_div' (m k : Int) : mod m k + m.div k * k = m 
Arguments: (m k : Int)
Goal: m.mod k + m.div k * k = m
-- Int.div_add_mod'
theorem div_add_mod' (m k : Int) : m.div k * k + mod m k = m 
Arguments: (m k : Int)
Goal: m.div k * k + m.mod k = m
-- Int.mod_def
theorem mod_def (a b : Int) : mod a b = a - b * a.div b 
Arguments: (a b : Int)
Goal: a.mod b = a - b * a.div b
-- Int.fmod_add_fdiv
theorem fmod_add_fdiv : ∀ a b : Int, a.fmod b + b * a.fdiv b = a
  
Arguments: (a b : Int)
Goal: a.fmod b + b * a.fdiv b = a
-- Int.fdiv_add_fmod
theorem fdiv_add_fmod (a b : Int) : b * a.fdiv b + a.fmod b = a 
Arguments: (a b : Int)
Goal: b * a.fdiv b + a.fmod b = a
-- Int.fmod_def
theorem fmod_def (a b : Int) : a.fmod b = a - b * a.fdiv b 
Arguments: (a b : Int)
Goal: a.fmod b = a - b * a.fdiv b
-- Int.fmod_eq_emod
theorem fmod_eq_emod (a : Int) {b : Int} (hb : 0 ≤ b) : fmod a b = a % b 
Arguments: (a : Int) {b : Int} (hb : 0 ≤ b)
Goal: a.fmod b = a % b
-- Int.mod_eq_emod
theorem mod_eq_emod {a b : Int} (ha : 0 ≤ a) (hb : 0 ≤ b) : mod a b = a % b 
Arguments: {a b : Int} (ha : 0 ≤ a) (hb : 0 ≤ b)
Goal: a.mod b = a % b