ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Nat.div_mul_div_comm
lemma div_mul_div_comm : b ∣ a → d ∣ c → (a / b) * (c / d) = (a * c) / (b * d) 
Arguments: {a b c d : ℕ}
Goal: b ∣ a → d ∣ c → a / b * (c / d) = a * c / (b * d)
-- Nat.mul_div_mul_comm
protected lemma mul_div_mul_comm (hba : b ∣ a) (hdc : d ∣ c) : a * c / (b * d) = a / b * (c / d) 
Arguments: {a b c d : ℕ} (hba : b ∣ a) (hdc : d ∣ c)
Goal: a * c / (b * d) = a / b * (c / d)
-- Nat.eq_zero_of_le_div
lemma eq_zero_of_le_div (hn : 2 ≤ n) (h : m ≤ m / n) : m = 0 
Arguments: {m n : ℕ} (hn : 2 ≤ n) (h : m ≤ m / n)
Goal: m = 0
-- Nat.div_mul_div_le_div
lemma div_mul_div_le_div (a b c : ℕ) : a / c * b / a ≤ b / c 
Arguments: (a b c : ℕ)
Goal: a / c * b / a ≤ b / c
-- Nat.eq_zero_of_le_half
lemma eq_zero_of_le_half (h : n ≤ n / 2) : n = 0 
Arguments: {n : ℕ} (h : n ≤ n / 2)
Goal: n = 0
-- Nat.le_half_of_half_lt_sub
lemma le_half_of_half_lt_sub (h : a / 2 < a - b) : b ≤ a / 2 
Arguments: {a b : ℕ} (h : a / 2 < a - b)
Goal: b ≤ a / 2
-- Nat.half_le_of_sub_le_half
lemma half_le_of_sub_le_half (h : a - b ≤ a / 2) : a / 2 ≤ b 
Arguments: {a b : ℕ} (h : a - b ≤ a / 2)
Goal: a / 2 ≤ b
-- Nat.div_le_of_le_mul'
protected lemma div_le_of_le_mul' (h : m ≤ k * n) : m / k ≤ n 
Arguments: {m n k : ℕ} (h : m ≤ k * n)
Goal: m / k ≤ n
-- Nat.div_le_self'
protected lemma div_le_self' (m n : ℕ) : m / n ≤ m 
Arguments: (m n : ℕ)
Goal: m / n ≤ m
-- Nat.two_mul_odd_div_two
lemma two_mul_odd_div_two (hn : n % 2 = 1) : 2 * (n / 2) = n - 1 
Arguments: {n : ℕ} (hn : n % 2 = 1)
Goal: 2 * (n / 2) = n - 1
-- Nat.div_le_div_left
@[gcongr]
lemma div_le_div_left (hcb : c ≤ b) (hc : 0 < c) : a / b ≤ a / c 
Arguments: {a b c : ℕ} (hcb : c ≤ b) (hc : 0 < c)
Goal: a / b ≤ a / c
-- Nat.div_eq_self
lemma div_eq_self : m / n = m ↔ m = 0 ∨ n = 1 
Arguments: {m n : ℕ}
Goal: m / n = m ↔ m = 0 ∨ n = 1
-- Nat.div_eq_sub_mod_div
lemma div_eq_sub_mod_div : m / n = (m - m % n) / n 
Arguments: {m n : ℕ}
Goal: m / n = (m - m % n) / n
-- Nat.eq_div_of_mul_eq_left
protected lemma eq_div_of_mul_eq_left (hc : c ≠ 0) (h : a * c = b) : a = b / c 
Arguments: {a b c : ℕ} (hc : c ≠ 0) (h : a * c = b)
Goal: a = b / c
-- Nat.eq_div_of_mul_eq_right
protected lemma eq_div_of_mul_eq_right (hc : c ≠ 0) (h : c * a = b) : a = b / c 
Arguments: {a b c : ℕ} (hc : c ≠ 0) (h : c * a = b)
Goal: a = b / c
-- Nat.mul_le_of_le_div
protected lemma mul_le_of_le_div (k x y : ℕ) (h : x ≤ y / k) : x * k ≤ y 
Arguments: (k x y : ℕ) (h : x ≤ y / k)
Goal: x * k ≤ y
-- Nat.div_mul_div_le
protected lemma div_mul_div_le (a b c d : ℕ) :
    (a / b) * (c / d) ≤ (a * c) / (b * d) 
Arguments: (a b c d : ℕ)
Goal: a / b * (c / d) ≤ a * c / (b * d)
-- Nat.pow_lt_pow_left
protected lemma pow_lt_pow_left (h : a < b) : ∀ {n : ℕ}, n ≠ 0 → a ^ n < b ^ n
  
Arguments: {a b : ℕ} (h : a < b) {n : ℕ}
Goal: n ≠ 0 → a ^ n < b ^ n
-- Nat.pow_lt_pow_right
protected lemma pow_lt_pow_right (ha : 1 < a) (h : m < n) : a ^ m < a ^ n 
Arguments: {a m n : ℕ} (ha : 1 < a) (h : m < n)
Goal: a ^ m < a ^ n
-- Nat.pow_le_pow_iff_left
protected lemma pow_le_pow_iff_left {n : ℕ} (hn : n ≠ 0) : a ^ n ≤ b ^ n ↔ a ≤ b 
Arguments: {a b n : ℕ} (hn : n ≠ 0)
Goal: a ^ n ≤ b ^ n ↔ a ≤ b
-- Nat.pow_lt_pow_iff_left
protected lemma pow_lt_pow_iff_left (hn : n ≠ 0) : a ^ n < b ^ n ↔ a < b 
Arguments: {a b n : ℕ} (hn : n ≠ 0)
Goal: a ^ n < b ^ n ↔ a < b
-- Nat.pow_left_injective
lemma pow_left_injective (hn : n ≠ 0) : Injective (fun a : ℕ ↦ a ^ n) 
Arguments: {n : ℕ} (hn : n ≠ 0)
Goal: Function.Injective fun a => a ^ n
-- Nat.pow_right_injective
protected lemma pow_right_injective (ha : 2 ≤ a) : Injective (a ^ ·) 
Arguments: {a : ℕ} (ha : 2 ≤ a)
Goal: Function.Injective fun x => a ^ x
-- Nat.pow_eq_zero
@[simp, nolint simpNF] protected lemma pow_eq_zero {a : ℕ} : ∀ {n : ℕ}, a ^ n = 0 ↔ a = 0 ∧ n ≠ 0
  
Arguments: {a n : ℕ}
Goal: a ^ n = 0 ↔ a = 0 ∧ n ≠ 0
-- Nat.pow_eq_self_iff
lemma pow_eq_self_iff {a b : ℕ} (ha : 1 < a) : a ^ b = a ↔ b = 1 
Arguments: {a b : ℕ} (ha : 1 < a)
Goal: a ^ b = a ↔ b = 1
-- Nat.le_self_pow
lemma le_self_pow (hn : n ≠ 0) : ∀ a : ℕ, a ≤ a ^ n
  
Arguments: {n : ℕ} (hn : n ≠ 0) (a : ℕ)
Goal: a ≤ a ^ n
-- Nat.lt_pow_self
lemma lt_pow_self (ha : 1 < a) : ∀ n : ℕ, n < a ^ n
  
Arguments: {a : ℕ} (ha : 1 < a) (n : ℕ)
Goal: n < a ^ n
-- Nat.lt_two_pow
lemma lt_two_pow (n : ℕ) : n < 2 ^ n 
Arguments: (n : ℕ)
Goal: n < 2 ^ n
-- Nat.one_le_pow
lemma one_le_pow (n m : ℕ) (h : 0 < m) : 1 ≤ m ^ n 
Arguments: (n m : ℕ) (h : 0 < m)
Goal: 1 ≤ m ^ n
-- Nat.one_le_pow'
lemma one_le_pow' (n m : ℕ) : 1 ≤ (m + 1) ^ n 
Arguments: (n m : ℕ)
Goal: 1 ≤ (m + 1) ^ n
-- Nat.one_lt_pow
lemma one_lt_pow (hn : n ≠ 0) (ha : 1 < a) : 1 < a ^ n 
Arguments: {a n : ℕ} (hn : n ≠ 0) (ha : 1 < a)
Goal: 1 < a ^ n
-- Nat.two_pow_succ
lemma two_pow_succ (n : ℕ) : 2 ^ (n + 1) = 2 ^ n + 2 ^ n 
Arguments: (n : ℕ)
Goal: 2 ^ (n + 1) = 2 ^ n + 2 ^ n
-- Nat.one_lt_pow'
lemma one_lt_pow' (n m : ℕ) : 1 < (m + 2) ^ (n + 1) 
Arguments: (n m : ℕ)
Goal: 1 < (m + 2) ^ (n + 1)
-- Nat.one_lt_pow_iff
@[simp] lemma one_lt_pow_iff {n : ℕ} (hn : n ≠ 0) : ∀ {a}, 1 < a ^ n ↔ 1 < a
 
Arguments: {n : ℕ} (hn : n ≠ 0) {a : ℕ}
Goal: 1 < a ^ n ↔ 1 < a
-- Nat.one_lt_two_pow'
lemma one_lt_two_pow' (n : ℕ) : 1 < 2 ^ (n + 1) 
Arguments: (n : ℕ)
Goal: 1 < 2 ^ (n + 1)
-- Nat.mul_lt_mul_pow_succ
lemma mul_lt_mul_pow_succ (ha : 0 < a) (hb : 1 < b) : n * b < a * b ^ (n + 1) 
Arguments: {a b n : ℕ} (ha : 0 < a) (hb : 1 < b)
Goal: n * b < a * b ^ (n + 1)
-- Nat.sq_sub_sq
lemma sq_sub_sq (a b : ℕ) : a ^ 2 - b ^ 2 = (a + b) * (a - b) 
Arguments: (a b : ℕ)
Goal: a ^ 2 - b ^ 2 = (a + b) * (a - b)
-- Nat.div_pow
protected lemma div_pow (h : a ∣ b) : (b / a) ^ c = b ^ c / a ^ c 
Arguments: {a b c : ℕ} (h : a ∣ b)
Goal: (b / a) ^ c = b ^ c / a ^ c
-- Nat.rec_zero
@[simp]
lemma rec_zero {C : ℕ → Sort*} (h0 : C 0) (h : ∀ n, C n → C (n + 1)) : Nat.rec h0 h 0 = h0 
Arguments: {C : ℕ → Sort u_1} (h0 : C 0) (h : (n : ℕ) → C n → C (n + 1))
Goal: Nat.rec h0 h 0 = h0
-- Nat.rec_add_one
lemma rec_add_one {C : ℕ → Sort*} (h0 : C 0) (h : ∀ n, C n → C (n + 1)) (n : ℕ) :
    Nat.rec h0 h (n + 1) = h n (Nat.rec h0 h n) 
Arguments: {C : ℕ → Sort u_1} (h0 : C 0) (h : (n : ℕ) → C n → C (n + 1)) (n : ℕ)
Goal: Nat.rec h0 h (n + 1) = h n (Nat.rec h0 h n)
-- Nat.rec_one
@[simp] lemma rec_one {C : ℕ → Sort*} (h0 : C 0) (h : ∀ n, C n → C (n + 1)) :
    Nat.rec (motive := C) h0 h 1 = h 0 h0 
Arguments: {C : ℕ → Sort u_1} (h0 : C 0) (h : (n : ℕ) → C n → C (n + 1))
Goal: Nat.rec h0 h 1 = h 0 h0
-- Nat.leRec_eq_leRec
theorem leRec_eq_leRec : @Nat.leRec.{0} = @Nat.le.rec 
Goal: @Nat.leRec = @Nat.le.rec
-- Nat.leRec_self
@[simp]
lemma leRec_self {n} {motive : (m : ℕ) → n ≤ m → Sort*}
    (refl : motive n le_rfl)
    (le_succ_of_le : ∀ ⦃k⦄ (h : n ≤ k), motive k h → motive (k + 1) (le_succ_of_le h)) :
    (leRec (motive := motive) refl le_succ_of_le le_rfl : motive n le_rfl) = refl 
Arguments: {n : ℕ} {motive : (m : ℕ) → n ≤ m → Sort u_1} (refl : motive n ⋯) (le_succ_of_le : ⦃k : ℕ⦄ → (h : n ≤ k) → motive k h → motive (k + 1) ⋯)
Goal: Nat.leRec refl le_succ_of_le ⋯ = refl
-- Nat.leRec_succ
@[simp]
lemma leRec_succ {n} {motive : (m : ℕ) → n ≤ m → Sort*}
    (refl : motive n le_rfl)
    (le_succ_of_le : ∀ ⦃k⦄ (h : n ≤ k), motive k h → motive (k + 1) (le_succ_of_le h))
    (h1 : n ≤ m) {h2 : n ≤ m + 1} :
    (leRec (motive := motive) refl le_succ_of_le h2) =
      le_succ_of_le h1 (leRec (motive := motive) refl le_succ_of_le h1) 
Arguments: {m n : ℕ} {motive : (m : ℕ) → n ≤ m → Sort u_1} (refl : motive n ⋯) (le_succ_of_le : ⦃k : ℕ⦄ → (h : n ≤ k) → motive k h → motive (k + 1) ⋯) (h1 : n ≤ m) {h2 : n ≤ m + 1}
Goal: Nat.leRec refl le_succ_of_le h2 = le_succ_of_le h1 (Nat.leRec refl le_succ_of_le h1)
-- Nat.leRec_succ'
lemma leRec_succ' {n} {motive : (m : ℕ) → n ≤ m → Sort*} (refl le_succ_of_le) :
    (leRec (motive := motive) refl le_succ_of_le (le_succ _)) = le_succ_of_le _ refl 
Arguments: {n : ℕ} {motive : (m : ℕ) → n ≤ m → Sort u_1} (refl : motive n ⋯) (le_succ_of_le : ⦃k : ℕ⦄ → (h : n ≤ k) → motive k h → motive (k + 1) ⋯)
Goal: Nat.leRec refl le_succ_of_le ⋯ = le_succ_of_le ⋯ refl
-- Nat.leRec_trans
lemma leRec_trans {n m k} {motive : (m : ℕ) → n ≤ m → Sort*} (refl le_succ_of_le)
    (hnm : n ≤ m) (hmk : m ≤ k) :
    leRec (motive := motive) refl le_succ_of_le (Nat.le_trans hnm hmk) =
      leRec
        (leRec refl (fun _ h => le_succ_of_le h) hnm)
        (fun _ h => le_succ_of_le <| Nat.le_trans hnm h) hmk 
Arguments: {n m k : ℕ} {motive : (m : ℕ) → n ≤ m → Sort u_1} (refl : motive n ⋯) (le_succ_of_le : ⦃k : ℕ⦄ → (h : n ≤ k) → motive k h → motive (k + 1) ⋯) (hnm : n ≤ m) (hmk : m ≤ k)
Goal: Nat.leRec refl le_succ_of_le ⋯ =
  Nat.leRec (Nat.leRec refl (fun x h => le_succ_of_le h) hnm) (fun x h => le_succ_of_le ⋯) hmk
-- Nat.leRec_succ_left
lemma leRec_succ_left {motive : (m : ℕ) → n ≤ m → Sort*}
    (refl le_succ_of_le) {m} (h1 : n ≤ m) (h2 : n + 1 ≤ m) :
    -- the `@` is needed for this to elaborate, even though we only provide explicit arguments!
    @leRec _ _ (le_succ_of_le le_rfl refl) (fun k h ih => le_succ_of_le (le_of_succ_le h) ih) _ h2 =
      leRec (motive := motive) refl le_succ_of_le h1 
Arguments: {n : ℕ} {motive : (m : ℕ) → n ≤ m → Sort u_1} (refl : motive n ⋯) (le_succ_of_le : ⦃k : ℕ⦄ → (h : n ≤ k) → motive k h → motive (k + 1) ⋯) {m : ℕ} (h1 : n ≤ m) (h2 : n + 1 ≤ m)
Goal: Nat.leRec (le_succ_of_le ⋯ refl) (fun k h ih => le_succ_of_le ⋯ ih) h2 = Nat.leRec refl le_succ_of_le h1
-- Nat.leRecOn_self
lemma leRecOn_self {C : ℕ → Sort*} {n} {next : ∀ {k}, C k → C (k + 1)} (x : C n) :
    (leRecOn n.le_refl next x : C n) = x 
Arguments: {C : ℕ → Sort u_1} {n : ℕ} {next : {k : ℕ} → C k → C (k + 1)} (x : C n)
Goal: Nat.leRecOn ⋯ (fun {k} => next) x = x
-- Nat.leRecOn_succ
lemma leRecOn_succ {C : ℕ → Sort*} {n m} (h1 : n ≤ m) {h2 : n ≤ m + 1} {next} (x : C n) :
    (leRecOn h2 next x : C (m + 1)) = next (leRecOn h1 next x : C m) 
Arguments: {C : ℕ → Sort u_1} {n m : ℕ} (h1 : n ≤ m) {h2 : n ≤ m + 1} {next : {k : ℕ} → C k → C (k + 1)} (x : C n)
Goal: Nat.leRecOn h2 next x = next (Nat.leRecOn h1 (fun {k} => next) x)
-- Nat.leRecOn_succ'
lemma leRecOn_succ' {C : ℕ → Sort*} {n} {h : n ≤ n + 1} {next : ∀ {k}, C k → C (k + 1)} (x : C n) :
    (leRecOn h next x : C (n + 1)) = next x 
Arguments: {C : ℕ → Sort u_1} {n : ℕ} {h : n ≤ n + 1} {next : {k : ℕ} → C k → C (k + 1)} (x : C n)
Goal: Nat.leRecOn h (fun {k} => next) x = next x
-- Nat.leRecOn_trans
lemma leRecOn_trans {C : ℕ → Sort*} {n m k} (hnm : n ≤ m) (hmk : m ≤ k) {next} (x : C n) :
    (leRecOn (Nat.le_trans hnm hmk) (@next) x : C k) =
      leRecOn hmk (@next) (leRecOn hnm (@next) x) 
Arguments: {C : ℕ → Sort u_1} {n m k : ℕ} (hnm : n ≤ m) (hmk : m ≤ k) {next : {k : ℕ} → C k → C (k + 1)} (x : C n)
Goal: Nat.leRecOn ⋯ next x = Nat.leRecOn hmk next (Nat.leRecOn hnm next x)
-- Nat.leRecOn_succ_left
lemma leRecOn_succ_left {C : ℕ → Sort*} {n m}
    {next : ∀ {k}, C k → C (k + 1)} (x : C n) (h1 : n ≤ m) (h2 : n + 1 ≤ m) :
    (leRecOn h2 next (next x) : C m) = (leRecOn h1 next x : C m) 
Arguments: {C : ℕ → Sort u_1} {n m : ℕ} {next : {k : ℕ} → C k → C (k + 1)} (x : C n) (h1 : n ≤ m) (h2 : n + 1 ≤ m)
Goal: Nat.leRecOn h2 (fun {k} => next) (next x) = Nat.leRecOn h1 (fun {k} => next) x
-- Nat.leRecOn_injective
lemma leRecOn_injective {C : ℕ → Sort*} {n m} (hnm : n ≤ m) (next : ∀ {k}, C k → C (k + 1))
    (Hnext : ∀ n, Injective (@next n)) : Injective (@leRecOn C n m hnm next) 
Arguments: {C : ℕ → Sort u_1} {n m : ℕ} (hnm : n ≤ m) (next : {k : ℕ} → C k → C (k + 1)) (Hnext : ∀ (n : ℕ), Function.Injective next)
Goal: Function.Injective (Nat.leRecOn hnm fun {k} => next)
-- Nat.leRecOn_surjective
lemma leRecOn_surjective {C : ℕ → Sort*} {n m} (hnm : n ≤ m) (next : ∀ {k}, C k → C (k + 1))
    (Hnext : ∀ n, Surjective (@next n)) : Surjective (@leRecOn C n m hnm next) 
Arguments: {C : ℕ → Sort u_1} {n m : ℕ} (hnm : n ≤ m) (next : {k : ℕ} → C k → C (k + 1)) (Hnext : ∀ (n : ℕ), Function.Surjective next)
Goal: Function.Surjective (Nat.leRecOn hnm fun {k} => next)
-- Nat.strongRecOn'_beta
lemma strongRecOn'_beta {P : ℕ → Sort*} {h} :
    (strongRecOn' n h : P n) = h n fun m _ ↦ (strongRecOn' m h : P m) 
Arguments: {n : ℕ} {P : ℕ → Sort u_1} {h : (n : ℕ) → ((m : ℕ) → m < n → P m) → P n}
Goal: n.strongRecOn' h = h n fun m x => m.strongRecOn' h
-- Nat.le_induction
@[elab_as_elim]
lemma le_induction {m : ℕ} {P : ∀ n, m ≤ n → Prop} (base : P m m.le_refl)
    (succ : ∀ n hmn, P n hmn → P (n + 1) (le_succ_of_le hmn)) : ∀ n hmn, P n hmn 
Arguments: {m : ℕ} {P : (n : ℕ) → m ≤ n → Prop} (base : P m ⋯) (succ : ∀ (n : ℕ) (hmn : m ≤ n), P n hmn → P (n + 1) ⋯) (n : ℕ) (hmn : m ≤ n)
Goal: P n hmn
-- Nat.decreasingInduction_self
@[simp]
lemma decreasingInduction_self {n} {motive : (m : ℕ) → m ≤ n → Sort*} (of_succ self) :
    (decreasingInduction (motive := motive) of_succ self le_rfl) = self 
Arguments: {n : ℕ} {motive : (m : ℕ) → m ≤ n → Sort u_1} (of_succ : (k : ℕ) → (h : k < n) → motive (k + 1) h → motive k ⋯) (self : motive n ⋯)
Goal: Nat.decreasingInduction of_succ self ⋯ = self
-- Nat.decreasingInduction_succ
lemma decreasingInduction_succ {n} {motive : (m : ℕ) → m ≤ n + 1 → Sort*} (of_succ self)
    (mn : m ≤ n) (msn : m ≤ n + 1) :
    (decreasingInduction (motive := motive) of_succ self msn : motive m msn) =
      decreasingInduction (motive := fun m h => motive m (le_succ_of_le h))
        (fun i hi => of_succ _ _) (of_succ _ _ self) mn 
Arguments: {m n : ℕ} {motive : (m : ℕ) → m ≤ n + 1 → Sort u_1} (of_succ : (k : ℕ) → (h : k < n + 1) → motive (k + 1) h → motive k ⋯) (self : motive (n + 1) ⋯) (mn : m ≤ n) (msn : m ≤ n + 1)
Goal: Nat.decreasingInduction of_succ self msn = Nat.decreasingInduction (fun i hi => of_succ i ⋯) (of_succ n ⋯ self) mn
-- Nat.decreasingInduction_succ'
@[simp]
lemma decreasingInduction_succ' {n} {motive : (m : ℕ) → m ≤ n + 1 → Sort*} (of_succ self) :
    decreasingInduction (motive := motive) of_succ self n.le_succ = of_succ _ _ self 
Arguments: {n : ℕ} {motive : (m : ℕ) → m ≤ n + 1 → Sort u_1} (of_succ : (k : ℕ) → (h : k < n + 1) → motive (k + 1) h → motive k ⋯) (self : motive (n + 1) ⋯)
Goal: Nat.decreasingInduction of_succ self ⋯ = of_succ n ⋯ self
-- Nat.decreasingInduction_trans
lemma decreasingInduction_trans {motive : (m : ℕ) → m ≤ k → Sort*} (hmn : m ≤ n) (hnk : n ≤ k)
    (of_succ self) :
    (decreasingInduction (motive := motive) of_succ self (Nat.le_trans hmn hnk) : motive m _) =
    decreasingInduction (fun n ih => of_succ _ _) (decreasingInduction of_succ self hnk) hmn 
Arguments: {m n k : ℕ} {motive : (m : ℕ) → m ≤ k → Sort u_1} (hmn : m ≤ n) (hnk : n ≤ k) (of_succ : (k_1 : ℕ) → (h : k_1 < k) → motive (k_1 + 1) h → motive k_1 ⋯) (self : motive k ⋯)
Goal: Nat.decreasingInduction of_succ self ⋯ =
  Nat.decreasingInduction (fun n_1 ih => of_succ n_1 ⋯) (Nat.decreasingInduction of_succ self hnk) hmn
-- Nat.decreasingInduction_succ_left
lemma decreasingInduction_succ_left  {motive : (m : ℕ) → m ≤ n → Sort*} (of_succ self)
    (smn : m + 1 ≤ n) (mn : m ≤ n) :
    decreasingInduction (motive := motive) of_succ self mn =
      of_succ m smn (decreasingInduction of_succ self smn) 
Arguments: {m n : ℕ} {motive : (m : ℕ) → m ≤ n → Sort u_1} (of_succ : (k : ℕ) → (h : k < n) → motive (k + 1) h → motive k ⋯) (self : motive n ⋯) (smn : m + 1 ≤ n) (mn : m ≤ n)
Goal: Nat.decreasingInduction of_succ self mn = of_succ m smn (Nat.decreasingInduction of_succ self smn)
-- Nat.diag_induction
@[elab_as_elim]
theorem diag_induction (P : ℕ → ℕ → Prop) (ha : ∀ a, P (a + 1) (a + 1)) (hb : ∀ b, P 0 (b + 1))
    (hd : ∀ a b, a < b → P (a + 1) b → P a (b + 1) → P (a + 1) (b + 1)) : ∀ a b, a < b → P a b
  
Arguments: (P : ℕ → ℕ → Prop) (ha : ∀ (a : ℕ), P (a + 1) (a + 1)) (hb : ∀ (b : ℕ), P 0 (b + 1)) (hd : ∀ (a b : ℕ), a < b → P (a + 1) b → P a (b + 1) → P (a + 1) (b + 1)) (a b : ℕ)
Goal: a < b → P a b
-- Nat.set_induction_bounded
lemma set_induction_bounded {S : Set ℕ} (hk : k ∈ S) (h_ind : ∀ k : ℕ, k ∈ S → k + 1 ∈ S)
    (hnk : k ≤ n) : n ∈ S 
Arguments: {n k : ℕ} {S : Set ℕ} (hk : k ∈ S) (h_ind : ∀ (k : ℕ), k ∈ S → k + 1 ∈ S) (hnk : k ≤ n)
Goal: n ∈ S
-- Nat.set_induction
lemma set_induction {S : Set ℕ} (hb : 0 ∈ S) (h_ind : ∀ k : ℕ, k ∈ S → k + 1 ∈ S) (n : ℕ) :
    n ∈ S 
Arguments: {S : Set ℕ} (hb : 0 ∈ S) (h_ind : ∀ (k : ℕ), k ∈ S → k + 1 ∈ S) (n : ℕ)
Goal: n ∈ S
-- Nat.mod_two_ne_one
@[simp] lemma mod_two_ne_one : ¬n % 2 = 1 ↔ n % 2 = 0 
Arguments: {n : ℕ}
Goal: ¬n % 2 = 1 ↔ n % 2 = 0
-- Nat.mod_two_ne_zero
@[simp] lemma mod_two_ne_zero : ¬n % 2 = 0 ↔ n % 2 = 1 
Arguments: {n : ℕ}
Goal: ¬n % 2 = 0 ↔ n % 2 = 1
-- Nat.div_mod_eq_mod_mul_div
@[deprecated mod_mul_right_div_self (since := "2024-05-29")]
lemma div_mod_eq_mod_mul_div (a b c : ℕ) : a / b % c = a % (b * c) / b 
Arguments: (a b c : ℕ)
Goal: a / b % c = a % (b * c) / b
-- Nat.lt_div_iff_mul_lt
protected lemma lt_div_iff_mul_lt (hdn : d ∣ n) (a : ℕ) : a < n / d ↔ d * a < n 
Arguments: {d n : ℕ} (hdn : d ∣ n) (a : ℕ)
Goal: a < n / d ↔ d * a < n
-- Nat.mul_div_eq_iff_dvd
lemma mul_div_eq_iff_dvd {n d : ℕ} : d * (n / d) = n ↔ d ∣ n 
Arguments: {n d : ℕ}
Goal: d * (n / d) = n ↔ d ∣ n
-- Nat.mul_div_lt_iff_not_dvd
lemma mul_div_lt_iff_not_dvd : d * (n / d) < n ↔ ¬ d ∣ n 
Arguments: {d n : ℕ}
Goal: d * (n / d) < n ↔ ¬d ∣ n
-- Nat.div_eq_iff_eq_of_dvd_dvd
lemma div_eq_iff_eq_of_dvd_dvd (hn : n ≠ 0) (ha : a ∣ n) (hb : b ∣ n) : n / a = n / b ↔ a = b 
Arguments: {a b n : ℕ} (hn : n ≠ 0) (ha : a ∣ n) (hb : b ∣ n)
Goal: n / a = n / b ↔ a = b
-- Nat.div_eq_zero_iff
protected lemma div_eq_zero_iff (hb : 0 < b) : a / b = 0 ↔ a < b 
Arguments: {a b : ℕ} (hb : 0 < b)
Goal: a / b = 0 ↔ a < b
-- Nat.div_ne_zero_iff
protected lemma div_ne_zero_iff (hb : b ≠ 0) : a / b ≠ 0 ↔ b ≤ a 
Arguments: {a b : ℕ} (hb : b ≠ 0)
Goal: a / b ≠ 0 ↔ b ≤ a
-- Nat.div_pos_iff
protected lemma div_pos_iff (hb : b ≠ 0) : 0 < a / b ↔ b ≤ a 
Arguments: {a b : ℕ} (hb : b ≠ 0)
Goal: 0 < a / b ↔ b ≤ a
-- Nat.le_iff_ne_zero_of_dvd
lemma le_iff_ne_zero_of_dvd (ha : a ≠ 0) (hab : a ∣ b) : a ≤ b ↔ b ≠ 0 
Arguments: {a b : ℕ} (ha : a ≠ 0) (hab : a ∣ b)
Goal: a ≤ b ↔ b ≠ 0
-- Nat.div_ne_zero_iff_of_dvd
lemma div_ne_zero_iff_of_dvd (hba : b ∣ a) : a / b ≠ 0 ↔ a ≠ 0 ∧ b ≠ 0 
Arguments: {a b : ℕ} (hba : b ∣ a)
Goal: a / b ≠ 0 ↔ a ≠ 0 ∧ b ≠ 0
-- Nat.mul_mod_mod
@[simp] lemma mul_mod_mod (a b c : ℕ) : (a * (b % c)) % c = a * b % c 
Arguments: (a b c : ℕ)
Goal: a * (b % c) % c = a * b % c
-- Nat.mod_mul_mod
@[simp] lemma mod_mul_mod (a b c : ℕ) : (a % c * b) % c = a * b % c 
Arguments: (a b c : ℕ)
Goal: a % c * b % c = a * b % c
-- Nat.pow_mod
lemma pow_mod (a b n : ℕ) : a ^ b % n = (a % n) ^ b % n 
Arguments: (a b n : ℕ)
Goal: a ^ b % n = (a % n) ^ b % n
-- Nat.not_pos_pow_dvd
lemma not_pos_pow_dvd : ∀ {a n : ℕ} (_ : 1 < a) (_ : 1 < n), ¬ a ^ n ∣ a
  
Arguments: {a n : ℕ}
Goal: 1 < a → 1 < n → ¬a ^ n ∣ a
-- Nat.lt_of_pow_dvd_right
lemma lt_of_pow_dvd_right (hb : b ≠ 0) (ha : 2 ≤ a) (h : a ^ n ∣ b) : n < b 
Arguments: {a b n : ℕ} (hb : b ≠ 0) (ha : 2 ≤ a) (h : a ^ n ∣ b)
Goal: n < b
-- Nat.div_dvd_of_dvd
lemma div_dvd_of_dvd (h : n ∣ m) : m / n ∣ m 
Arguments: {m n : ℕ} (h : n ∣ m)
Goal: m / n ∣ m
-- Nat.div_div_self
protected lemma div_div_self (h : n ∣ m) (hm : m ≠ 0) : m / (m / n) = n 
Arguments: {m n : ℕ} (h : n ∣ m) (hm : m ≠ 0)
Goal: m / (m / n) = n
-- Nat.not_dvd_of_pos_of_lt
lemma not_dvd_of_pos_of_lt (h1 : 0 < n) (h2 : n < m) : ¬m ∣ n 
Arguments: {m n : ℕ} (h1 : 0 < n) (h2 : n < m)
Goal: ¬m ∣ n
-- Nat.eq_of_dvd_of_lt_two_mul
lemma eq_of_dvd_of_lt_two_mul (ha : a ≠ 0) (hdvd : b ∣ a) (hlt : a < 2 * b) : a = b 
Arguments: {a b : ℕ} (ha : a ≠ 0) (hdvd : b ∣ a) (hlt : a < 2 * b)
Goal: a = b
-- Nat.mod_eq_iff_lt
lemma mod_eq_iff_lt (hn : n ≠ 0) : m % n = m ↔ m < n 
Arguments: {m n : ℕ} (hn : n ≠ 0)
Goal: m % n = m ↔ m < n
-- Nat.mod_succ_eq_iff_lt
@[simp]
lemma mod_succ_eq_iff_lt : m % n.succ = m ↔ m < n.succ 
Arguments: {m n : ℕ}
Goal: m % n.succ = m ↔ m < n.succ
-- Nat.mod_succ
@[simp] lemma mod_succ (n : ℕ) : n % n.succ = n 
Arguments: (n : ℕ)
Goal: n % n.succ = n
-- Nat.mod_add_div'
lemma mod_add_div' (a b : ℕ) : a % b + a / b * b = a 
Arguments: (a b : ℕ)
Goal: a % b + a / b * b = a
-- Nat.div_add_mod'
lemma div_add_mod' (a b : ℕ) : a / b * b + a % b = a 
Arguments: (a b : ℕ)
Goal: a / b * b + a % b = a
-- Nat.div_mod_unique
protected lemma div_mod_unique (h : 0 < b) :
    a / b = d ∧ a % b = c ↔ c + b * d = a ∧ c < b 
Arguments: {a b c d : ℕ} (h : 0 < b)
Goal: a / b = d ∧ a % b = c ↔ c + b * d = a ∧ c < b
-- Nat.sub_mod_eq_zero_of_mod_eq
lemma sub_mod_eq_zero_of_mod_eq (h : m % k = n % k) : (m - n) % k = 0 
Arguments: {m n k : ℕ} (h : m % k = n % k)
Goal: (m - n) % k = 0
-- Nat.one_mod
@[simp] lemma one_mod (n : ℕ) : 1 % (n + 2) = 1 
Arguments: (n : ℕ)
Goal: 1 % (n + 2) = 1
-- Nat.one_mod_of_ne_one
lemma one_mod_of_ne_one : ∀ {n : ℕ}, n ≠ 1 → 1 % n = 1
  
Arguments: {n : ℕ}
Goal: n ≠ 1 → 1 % n = 1
-- Nat.dvd_sub_mod
lemma dvd_sub_mod (k : ℕ) : n ∣ k - k % n 
Arguments: {n : ℕ} (k : ℕ)
Goal: n ∣ k - k % n
-- Nat.add_mod_eq_ite
lemma add_mod_eq_ite :
    (m + n) % k = if k ≤ m % k + n % k then m % k + n % k - k else m % k + n % k 
Arguments: {m n k : ℕ}
Goal: (m + n) % k = if k ≤ m % k + n % k then m % k + n % k - k else m % k + n % k
-- Nat.not_dvd_of_between_consec_multiples
theorem not_dvd_of_between_consec_multiples (h1 : n * k < m) (h2 : m < n * (k + 1)) : ¬n ∣ m 
Arguments: {m n k : ℕ} (h1 : n * k < m) (h2 : m < n * (k + 1))
Goal: ¬n ∣ m
-- Nat.dvd_add_left
protected lemma dvd_add_left (h : a ∣ c) : a ∣ b + c ↔ a ∣ b 
Arguments: {a b c : ℕ} (h : a ∣ c)
Goal: a ∣ b + c ↔ a ∣ b
-- Nat.dvd_add_right
protected lemma dvd_add_right (h : a ∣ b) : a ∣ b + c ↔ a ∣ c 
Arguments: {a b c : ℕ} (h : a ∣ b)
Goal: a ∣ b + c ↔ a ∣ c
-- Nat.mul_dvd_mul_iff_left
protected lemma mul_dvd_mul_iff_left (ha : 0 < a) : a * b ∣ a * c ↔ b ∣ c 
Arguments: {a b c : ℕ} (ha : 0 < a)
Goal: a * b ∣ a * c ↔ b ∣ c
-- Nat.mul_dvd_mul_iff_right
protected lemma mul_dvd_mul_iff_right (hc : 0 < c) : a * c ∣ b * c ↔ a ∣ b 
Arguments: {a b c : ℕ} (hc : 0 < c)
Goal: a * c ∣ b * c ↔ a ∣ b
-- Nat.add_mod_eq_add_mod_right
lemma add_mod_eq_add_mod_right (c : ℕ) (H : a % d = b % d) : (a + c) % d = (b + c) % d 
Arguments: {a b d : ℕ} (c : ℕ) (H : a % d = b % d)
Goal: (a + c) % d = (b + c) % d
-- Nat.add_mod_eq_add_mod_left
lemma add_mod_eq_add_mod_left (c : ℕ) (H : a % d = b % d) : (c + a) % d = (c + b) % d 
Arguments: {a b d : ℕ} (c : ℕ) (H : a % d = b % d)
Goal: (c + a) % d = (c + b) % d
-- Nat.mul_dvd_of_dvd_div
lemma mul_dvd_of_dvd_div (hcb : c ∣ b) (h : a ∣ b / c) : c * a ∣ b 
Arguments: {a b c : ℕ} (hcb : c ∣ b) (h : a ∣ b / c)
Goal: c * a ∣ b
-- Nat.eq_of_dvd_of_div_eq_one
lemma eq_of_dvd_of_div_eq_one (hab : a ∣ b) (h : b / a = 1) : a = b 
Arguments: {a b : ℕ} (hab : a ∣ b) (h : b / a = 1)
Goal: a = b
-- Nat.eq_zero_of_dvd_of_div_eq_zero
lemma eq_zero_of_dvd_of_div_eq_zero (hab : a ∣ b) (h : b / a = 0) : b = 0 
Arguments: {a b : ℕ} (hab : a ∣ b) (h : b / a = 0)
Goal: b = 0
-- Nat.div_le_div
@[gcongr]
protected theorem div_le_div {a b c d : ℕ} (h1 : a ≤ b) (h2 : d ≤ c) (h3 : d ≠ 0) : a / c ≤ b / d 
Arguments: {a b c d : ℕ} (h1 : a ≤ b) (h2 : d ≤ c) (h3 : d ≠ 0)
Goal: a / c ≤ b / d
-- Nat.lt_mul_div_succ
lemma lt_mul_div_succ (a : ℕ) (hb : 0 < b) : a < b * (a / b + 1) 
Arguments: {b : ℕ} (a : ℕ) (hb : 0 < b)
Goal: a < b * (a / b + 1)
-- Nat.mul_add_mod'
lemma mul_add_mod' (a b c : ℕ) : (a * b + c) % b = c % b 
Arguments: (a b c : ℕ)
Goal: (a * b + c) % b = c % b
-- Nat.mul_add_mod_of_lt
lemma mul_add_mod_of_lt (h : c < b) : (a * b + c) % b = c 
Arguments: {a b c : ℕ} (h : c < b)
Goal: (a * b + c) % b = c
-- Nat.not_two_dvd_bit1
@[simp]
protected theorem not_two_dvd_bit1 (n : ℕ) : ¬2 ∣ 2 * n + 1 
Arguments: (n : ℕ)
Goal: ¬2 ∣ 2 * n + 1
-- Nat.dvd_add_self_left
@[simp] protected lemma dvd_add_self_left : m ∣ m + n ↔ m ∣ n 
Arguments: {m n : ℕ}
Goal: m ∣ m + n ↔ m ∣ n
-- Nat.dvd_add_self_right
@[simp] protected lemma dvd_add_self_right : m ∣ n + m ↔ m ∣ n 
Arguments: {m n : ℕ}
Goal: m ∣ n + m ↔ m ∣ n
-- Nat.dvd_sub'
lemma dvd_sub' (h₁ : k ∣ m) (h₂ : k ∣ n) : k ∣ m - n 
Arguments: {m n k : ℕ} (h₁ : k ∣ m) (h₂ : k ∣ n)
Goal: k ∣ m - n
-- Nat.succ_div
lemma succ_div : ∀ a b : ℕ, (a + 1) / b = a / b + if b ∣ a + 1 then 1 else 0
  
Arguments: (a b : ℕ)
Goal: (a + 1) / b = a / b + if b ∣ a + 1 then 1 else 0
-- Nat.succ_div_of_dvd
lemma succ_div_of_dvd (hba : b ∣ a + 1) : (a + 1) / b = a / b + 1 
Arguments: {a b : ℕ} (hba : b ∣ a + 1)
Goal: (a + 1) / b = a / b + 1