ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Real.sign_neg
theorem sign_neg {r : ℝ} : sign (-r) = -sign r 
Arguments: {r : ℝ}
Goal: (-r).sign = -r.sign
-- Real.sign_mul_nonneg
theorem sign_mul_nonneg (r : ℝ) : 0 ≤ sign r * r 
Arguments: (r : ℝ)
Goal: 0 ≤ r.sign * r
-- Real.sign_mul_pos_of_ne_zero
theorem sign_mul_pos_of_ne_zero (r : ℝ) (hr : r ≠ 0) : 0 < sign r * r 
Arguments: (r : ℝ) (hr : r ≠ 0)
Goal: 0 < r.sign * r
-- Real.inv_sign
@[simp]
theorem inv_sign (r : ℝ) : (sign r)⁻¹ = sign r 
Arguments: (r : ℝ)
Goal: r.sign⁻¹ = r.sign
-- Real.sign_inv
@[simp]
theorem sign_inv (r : ℝ) : sign r⁻¹ = sign r 
Arguments: (r : ℝ)
Goal: r⁻¹.sign = r.sign
-- Nat.squarefree_iff_nodup_primeFactorsList
theorem squarefree_iff_nodup_primeFactorsList {n : ℕ} (h0 : n ≠ 0) :
    Squarefree n ↔ n.primeFactorsList.Nodup 
Arguments: {n : ℕ} (h0 : n ≠ 0)
Goal: Squarefree n ↔ n.primeFactorsList.Nodup
-- Squarefree.nodup_primeFactorsList
theorem Squarefree.nodup_primeFactorsList {n : ℕ} (hn : Squarefree n) : n.primeFactorsList.Nodup 
Arguments: {n : ℕ} (hn : Squarefree n)
Goal: n.primeFactorsList.Nodup
-- Nat.squarefree_iff_prime_squarefree
theorem squarefree_iff_prime_squarefree {n : ℕ} : Squarefree n ↔ ∀ x, Prime x → ¬x * x ∣ n 
Arguments: {n : ℕ}
Goal: Squarefree n ↔ ∀ (x : ℕ), Nat.Prime x → ¬x * x ∣ n
-- Squarefree.natFactorization_le_one
theorem _root_.Squarefree.natFactorization_le_one {n : ℕ} (p : ℕ) (hn : Squarefree n) :
    n.factorization p ≤ 1 
Arguments: {n : ℕ} (p : ℕ) (hn : Squarefree n)
Goal: n.factorization p ≤ 1
-- Nat.factorization_eq_one_of_squarefree
lemma factorization_eq_one_of_squarefree (hn : Squarefree n) (hp : p.Prime) (hpn : p ∣ n) :
    factorization n p = 1 
Arguments: {n p : ℕ} (hn : Squarefree n) (hp : Nat.Prime p) (hpn : p ∣ n)
Goal: n.factorization p = 1
-- Nat.squarefree_of_factorization_le_one
theorem squarefree_of_factorization_le_one {n : ℕ} (hn : n ≠ 0) (hn' : ∀ p, n.factorization p ≤ 1) :
    Squarefree n 
Arguments: {n : ℕ} (hn : n ≠ 0) (hn' : ∀ (p : ℕ), n.factorization p ≤ 1)
Goal: Squarefree n
-- Nat.squarefree_iff_factorization_le_one
theorem squarefree_iff_factorization_le_one {n : ℕ} (hn : n ≠ 0) :
    Squarefree n ↔ ∀ p, n.factorization p ≤ 1 
Arguments: {n : ℕ} (hn : n ≠ 0)
Goal: Squarefree n ↔ ∀ (p : ℕ), n.factorization p ≤ 1
-- Nat.Squarefree.ext_iff
theorem Squarefree.ext_iff {n m : ℕ} (hn : Squarefree n) (hm : Squarefree m) :
    n = m ↔ ∀ p, Prime p → (p ∣ n ↔ p ∣ m) 
Arguments: {n m : ℕ} (hn : Squarefree n) (hm : Squarefree m)
Goal: n = m ↔ ∀ (p : ℕ), Nat.Prime p → (p ∣ n ↔ p ∣ m)
-- Nat.squarefree_pow_iff
theorem squarefree_pow_iff {n k : ℕ} (hn : n ≠ 1) (hk : k ≠ 0) :
    Squarefree (n ^ k) ↔ Squarefree n ∧ k = 1 
Arguments: {n k : ℕ} (hn : n ≠ 1) (hk : k ≠ 0)
Goal: Squarefree (n ^ k) ↔ Squarefree n ∧ k = 1
-- Nat.squarefree_and_prime_pow_iff_prime
theorem squarefree_and_prime_pow_iff_prime {n : ℕ} : Squarefree n ∧ IsPrimePow n ↔ Prime n 
Arguments: {n : ℕ}
Goal: Squarefree n ∧ IsPrimePow n ↔ Nat.Prime n
-- Nat.minSqFacProp_div
theorem minSqFacProp_div (n) {k} (pk : Prime k) (dk : k ∣ n) (dkk : ¬k * k ∣ n) {o}
    (H : MinSqFacProp (n / k) o) : MinSqFacProp n o 
Arguments: (n : ℕ) {k : ℕ} (pk : Nat.Prime k) (dk : k ∣ n) (dkk : ¬k * k ∣ n) {o : Option ℕ} (H : (n / k).MinSqFacProp o)
Goal: n.MinSqFacProp o
-- Nat.minSqFacAux_has_prop
theorem minSqFacAux_has_prop {n : ℕ} (k) (n0 : 0 < n) (i) (e : k = 2 * i + 3)
    (ih : ∀ m, Prime m → m ∣ n → k ≤ m) : MinSqFacProp n (minSqFacAux n k) 
Arguments: {n : ℕ} (k : ℕ) (n0 : 0 < n) (i : ℕ) (e : k = 2 * i + 3) (ih : ∀ (m : ℕ), Nat.Prime m → m ∣ n → k ≤ m)
Goal: n.MinSqFacProp (n.minSqFacAux k)
-- Nat.minSqFac_has_prop
theorem minSqFac_has_prop (n : ℕ) : MinSqFacProp n (minSqFac n) 
Arguments: (n : ℕ)
Goal: n.MinSqFacProp n.minSqFac
-- Nat.minSqFac_prime
theorem minSqFac_prime {n d : ℕ} (h : n.minSqFac = some d) : Prime d 
Arguments: {n d : ℕ} (h : n.minSqFac = some d)
Goal: Nat.Prime d
-- Nat.minSqFac_dvd
theorem minSqFac_dvd {n d : ℕ} (h : n.minSqFac = some d) : d * d ∣ n 
Arguments: {n d : ℕ} (h : n.minSqFac = some d)
Goal: d * d ∣ n
-- Nat.minSqFac_le_of_dvd
theorem minSqFac_le_of_dvd {n d : ℕ} (h : n.minSqFac = some d) {m} (m2 : 2 ≤ m) (md : m * m ∣ n) :
    d ≤ m 
Arguments: {n d : ℕ} (h : n.minSqFac = some d) {m : ℕ} (m2 : 2 ≤ m) (md : m * m ∣ n)
Goal: d ≤ m
-- Nat.squarefree_iff_minSqFac
theorem squarefree_iff_minSqFac {n : ℕ} : Squarefree n ↔ n.minSqFac = none 
Arguments: {n : ℕ}
Goal: Squarefree n ↔ n.minSqFac = none
-- Nat.squarefree_two
theorem squarefree_two : Squarefree 2 
Goal: Squarefree 2
-- Nat.divisors_filter_squarefree_of_squarefree
theorem divisors_filter_squarefree_of_squarefree {n : ℕ} (hn : Squarefree n) :
    n.divisors.filter Squarefree = n.divisors 
Arguments: {n : ℕ} (hn : Squarefree n)
Goal: Finset.filter Squarefree n.divisors = n.divisors
-- Nat.divisors_filter_squarefree
theorem divisors_filter_squarefree {n : ℕ} (h0 : n ≠ 0) :
    (n.divisors.filter Squarefree).val =
      (UniqueFactorizationMonoid.normalizedFactors n).toFinset.powerset.val.map fun x =>
        x.val.prod 
Arguments: {n : ℕ} (h0 : n ≠ 0)
Goal: (Finset.filter Squarefree n.divisors).val =
  Multiset.map (fun x => x.val.prod) (UniqueFactorizationMonoid.normalizedFactors n).toFinset.powerset.val
-- Nat.sum_divisors_filter_squarefree
theorem sum_divisors_filter_squarefree {n : ℕ} (h0 : n ≠ 0) {α : Type*} [AddCommMonoid α]
    {f : ℕ → α} :
    ∑ i ∈ n.divisors.filter Squarefree, f i =
      ∑ i ∈ (UniqueFactorizationMonoid.normalizedFactors n).toFinset.powerset, f i.val.prod 
Arguments: {n : ℕ} (h0 : n ≠ 0) {α : Type u_1} [AddCommMonoid α] {f : ℕ → α}
Goal: ∑ i ∈ Finset.filter Squarefree n.divisors, f i =
  ∑ i ∈ (UniqueFactorizationMonoid.normalizedFactors n).toFinset.powerset, f i.val.prod
-- Nat.sq_mul_squarefree_of_pos
theorem sq_mul_squarefree_of_pos {n : ℕ} (hn : 0 < n) :
    ∃ a b : ℕ, 0 < a ∧ 0 < b ∧ b ^ 2 * a = n ∧ Squarefree a 
Arguments: {n : ℕ} (hn : 0 < n)
Goal: ∃ a b, 0 < a ∧ 0 < b ∧ b ^ 2 * a = n ∧ Squarefree a
-- Nat.sq_mul_squarefree_of_pos'
theorem sq_mul_squarefree_of_pos' {n : ℕ} (h : 0 < n) :
    ∃ a b : ℕ, (b + 1) ^ 2 * (a + 1) = n ∧ Squarefree (a + 1) 
Arguments: {n : ℕ} (h : 0 < n)
Goal: ∃ a b, (b + 1) ^ 2 * (a + 1) = n ∧ Squarefree (a + 1)
-- Nat.sq_mul_squarefree
theorem sq_mul_squarefree (n : ℕ) : ∃ a b : ℕ, b ^ 2 * a = n ∧ Squarefree a 
Arguments: (n : ℕ)
Goal: ∃ a b, b ^ 2 * a = n ∧ Squarefree a
-- Nat.squarefree_mul
theorem squarefree_mul {m n : ℕ} (hmn : m.Coprime n) :
    Squarefree (m * n) ↔ Squarefree m ∧ Squarefree n 
Arguments: {m n : ℕ} (hmn : m.Coprime n)
Goal: Squarefree (m * n) ↔ Squarefree m ∧ Squarefree n
-- Nat.coprime_of_squarefree_mul
theorem coprime_of_squarefree_mul {m n : ℕ} (h : Squarefree (m * n)) : m.Coprime n 
Arguments: {m n : ℕ} (h : Squarefree (m * n))
Goal: m.Coprime n
-- Nat.squarefree_mul_iff
theorem squarefree_mul_iff {m n : ℕ} :
    Squarefree (m * n) ↔ m.Coprime n ∧ Squarefree m ∧ Squarefree n 
Arguments: {m n : ℕ}
Goal: Squarefree (m * n) ↔ m.Coprime n ∧ Squarefree m ∧ Squarefree n
-- Nat.coprime_div_gcd_of_squarefree
lemma coprime_div_gcd_of_squarefree (hm : Squarefree m) (hn : n ≠ 0) : Coprime (m / gcd m n) n 
Arguments: {m n : ℕ} (hm : Squarefree m) (hn : n ≠ 0)
Goal: (m / m.gcd n).Coprime n
-- Nat.prod_primeFactors_of_squarefree
lemma prod_primeFactors_of_squarefree (hn : Squarefree n) : ∏ p ∈ n.primeFactors, p = n 
Arguments: {n : ℕ} (hn : Squarefree n)
Goal: ∏ p ∈ n.primeFactors, p = n
-- Nat.primeFactors_prod
lemma primeFactors_prod (hs : ∀ p ∈ s, p.Prime) : primeFactors (∏ p ∈ s, p) = s 
Arguments: {s : Finset ℕ} (hs : ∀ p ∈ s, Nat.Prime p)
Goal: (∏ p ∈ s, p).primeFactors = s
-- Nat.primeFactors_div_gcd
lemma primeFactors_div_gcd (hm : Squarefree m) (hn : n ≠ 0) :
    primeFactors (m / m.gcd n) = primeFactors m \ primeFactors n 
Arguments: {m n : ℕ} (hm : Squarefree m) (hn : n ≠ 0)
Goal: (m / m.gcd n).primeFactors = m.primeFactors \ n.primeFactors
-- Nat.prod_primeFactors_invOn_squarefree
lemma prod_primeFactors_invOn_squarefree :
    Set.InvOn (fun n : ℕ ↦ (factorization n).support) (fun s ↦ ∏ p ∈ s, p)
      {s | ∀ p ∈ s, p.Prime} {n | Squarefree n} 
Goal: Set.InvOn (fun n => n.factorization.support) (fun s => ∏ p ∈ s, p) {s | ∀ p ∈ s, Nat.Prime p} {n | Squarefree n}
-- Nat.prod_primeFactors_sdiff_of_squarefree
theorem prod_primeFactors_sdiff_of_squarefree {n : ℕ} (hn : Squarefree n) {t : Finset ℕ}
    (ht : t ⊆ n.primeFactors) :
    ∏ a ∈ (n.primeFactors \ t), a = n / ∏ a ∈ t, a 
Arguments: {n : ℕ} (hn : Squarefree n) {t : Finset ℕ} (ht : t ⊆ n.primeFactors)
Goal: ∏ a ∈ n.primeFactors \ t, a = n / ∏ a ∈ t, a
-- Nat.default_eq_zero
@[simp] theorem default_eq_zero : default = 0 
Goal: default = 0
-- Nat.succ_pos'
lemma succ_pos' : 0 < succ n 
Arguments: {n : ℕ}
Goal: 0 < n.succ
-- Nat.succ_injective
lemma succ_injective : Injective Nat.succ 
Goal: Function.Injective Nat.succ
-- Nat.succ_ne_succ
lemma succ_ne_succ : succ m ≠ succ n ↔ m ≠ n 
Arguments: {m n : ℕ}
Goal: m.succ ≠ n.succ ↔ m ≠ n
-- Nat.succ_succ_ne_one
lemma succ_succ_ne_one (n : ℕ) : n.succ.succ ≠ 1 
Arguments: (n : ℕ)
Goal: n.succ.succ ≠ 1
-- Nat.one_lt_succ_succ
lemma one_lt_succ_succ (n : ℕ) : 1 < n.succ.succ 
Arguments: (n : ℕ)
Goal: 1 < n.succ.succ
-- Nat.not_succ_lt_self
lemma not_succ_lt_self : ¬ succ n < n 
Arguments: {n : ℕ}
Goal: ¬n.succ < n
-- Nat.succ_le_iff
lemma succ_le_iff : succ m ≤ n ↔ m < n 
Arguments: {m n : ℕ}
Goal: m.succ ≤ n ↔ m < n
-- Nat.le_succ_iff
lemma le_succ_iff : m ≤ n.succ ↔ m ≤ n ∨ m = n.succ 
Arguments: {m n : ℕ}
Goal: m ≤ n.succ ↔ m ≤ n ∨ m = n.succ
-- Nat.lt_iff_le_pred
lemma lt_iff_le_pred : ∀ {n}, 0 < n → (m < n ↔ m ≤ n - 1) 
Arguments: {m n : ℕ}
Goal: 0 < n → (m < n ↔ m ≤ n - 1)
-- Nat.le_of_pred_lt
lemma le_of_pred_lt : ∀ {m}, pred m < n → m ≤ n
  
Arguments: {n : ℕ} {m : ℕ}
Goal: m.pred < n → m ≤ n
-- Nat.lt_iff_add_one_le
lemma lt_iff_add_one_le : m < n ↔ m + 1 ≤ n 
Arguments: {m n : ℕ}
Goal: m < n ↔ m + 1 ≤ n
-- Nat.lt_one_add_iff
lemma lt_one_add_iff : m < 1 + n ↔ m ≤ n 
Arguments: {m n : ℕ}
Goal: m < 1 + n ↔ m ≤ n
-- Nat.one_add_le_iff
lemma one_add_le_iff : 1 + m ≤ n ↔ m < n 
Arguments: {m n : ℕ}
Goal: 1 + m ≤ n ↔ m < n
-- Nat.one_le_iff_ne_zero
lemma one_le_iff_ne_zero : 1 ≤ n ↔ n ≠ 0 
Arguments: {n : ℕ}
Goal: 1 ≤ n ↔ n ≠ 0
-- Nat.one_lt_iff_ne_zero_and_ne_one
lemma one_lt_iff_ne_zero_and_ne_one : ∀ {n : ℕ}, 1 < n ↔ n ≠ 0 ∧ n ≠ 1
  
Arguments: {n : ℕ}
Goal: 1 < n ↔ n ≠ 0 ∧ n ≠ 1
-- Nat.le_one_iff_eq_zero_or_eq_one
lemma le_one_iff_eq_zero_or_eq_one : ∀ {n : ℕ}, n ≤ 1 ↔ n = 0 ∨ n = 1 
Arguments: {n : ℕ}
Goal: n ≤ 1 ↔ n = 0 ∨ n = 1
-- Nat.lt_one_iff
@[simp] lemma lt_one_iff : n < 1 ↔ n = 0 
Arguments: {n : ℕ}
Goal: n < 1 ↔ n = 0
-- Nat.one_le_of_lt
lemma one_le_of_lt (h : a < b) : 1 ≤ b 
Arguments: {a b : ℕ} (h : a < b)
Goal: 1 ≤ b
-- Nat.min_eq_zero_iff
@[simp] lemma min_eq_zero_iff : min m n = 0 ↔ m = 0 ∨ n = 0 
Arguments: {m n : ℕ}
Goal: min m n = 0 ↔ m = 0 ∨ n = 0
-- Nat.max_eq_zero_iff
@[simp] lemma max_eq_zero_iff : max m n = 0 ↔ m = 0 ∧ n = 0 
Arguments: {m n : ℕ}
Goal: max m n = 0 ↔ m = 0 ∧ n = 0
-- Nat.pred_one_add
lemma pred_one_add (n : ℕ) : pred (1 + n) = n 
Arguments: (n : ℕ)
Goal: (1 + n).pred = n
-- Nat.pred_eq_self_iff
lemma pred_eq_self_iff : n.pred = n ↔ n = 0 
Arguments: {n : ℕ}
Goal: n.pred = n ↔ n = 0
-- Nat.pred_eq_of_eq_succ
lemma pred_eq_of_eq_succ (H : m = n.succ) : m.pred = n 
Arguments: {m n : ℕ} (H : m = n.succ)
Goal: m.pred = n
-- Nat.pred_eq_succ_iff
@[simp] lemma pred_eq_succ_iff : n - 1 = m + 1 ↔ n = m + 2 
Arguments: {m n : ℕ}
Goal: n - 1 = m + 1 ↔ n = m + 2
-- Nat.and_forall_succ
lemma and_forall_succ : p 0 ∧ (∀ n, p (n + 1)) ↔ ∀ n, p n 
Arguments: {p : ℕ → Prop}
Goal: (p 0 ∧ ∀ (n : ℕ), p (n + 1)) ↔ ∀ (n : ℕ), p n
-- Nat.or_exists_succ
lemma or_exists_succ : p 0 ∨ (∃ n, p (n + 1)) ↔ ∃ n, p n 
Arguments: {p : ℕ → Prop}
Goal: (p 0 ∨ ∃ n, p (n + 1)) ↔ ∃ n, p n
-- Nat.forall_lt_succ
lemma forall_lt_succ : (∀ m < n + 1, p m) ↔ (∀ m < n, p m) ∧ p n 
Arguments: {n : ℕ} {p : ℕ → Prop}
Goal: (∀ (m : ℕ), m < n + 1 → p m) ↔ (∀ (m : ℕ), m < n → p m) ∧ p n
-- Nat.exists_lt_succ
lemma exists_lt_succ : (∃ m < n + 1, p m) ↔ (∃ m < n, p m) ∨ p n 
Arguments: {n : ℕ} {p : ℕ → Prop}
Goal: (∃ m, m < n + 1 ∧ p m) ↔ (∃ m, m < n ∧ p m) ∨ p n
-- Nat.two_lt_of_ne
lemma two_lt_of_ne : ∀ {n}, n ≠ 0 → n ≠ 1 → n ≠ 2 → 2 < n
  
Arguments: {n : ℕ}
Goal: n ≠ 0 → n ≠ 1 → n ≠ 2 → 2 < n
-- Nat.add_succ_sub_one
@[simp] lemma add_succ_sub_one (m n : ℕ) : m + succ n - 1 = m + n 
Arguments: (m n : ℕ)
Goal: m + n.succ - 1 = m + n
-- Nat.succ_add_sub_one
@[simp]
lemma succ_add_sub_one (n m : ℕ) : succ m + n - 1 = m + n 
Arguments: (n m : ℕ)
Goal: m.succ + n - 1 = m + n
-- Nat.pred_sub
lemma pred_sub (n m : ℕ) : pred n - m = pred (n - m) 
Arguments: (n m : ℕ)
Goal: n.pred - m = (n - m).pred
-- Nat.self_add_sub_one
lemma self_add_sub_one : ∀ n, n + (n - 1) = 2 * n - 1
  
Arguments: (n : ℕ)
Goal: n + (n - 1) = 2 * n - 1
-- Nat.sub_one_add_self
lemma sub_one_add_self (n : ℕ) : (n - 1) + n = 2 * n - 1 
Arguments: (n : ℕ)
Goal: n - 1 + n = 2 * n - 1
-- Nat.self_add_pred
lemma self_add_pred (n : ℕ) : n + pred n = (2 * n).pred 
Arguments: (n : ℕ)
Goal: n + n.pred = (2 * n).pred
-- Nat.pred_add_self
lemma pred_add_self (n : ℕ) : pred n + n = (2 * n).pred 
Arguments: (n : ℕ)
Goal: n.pred + n = (2 * n).pred
-- Nat.pred_le_iff
lemma pred_le_iff : pred m ≤ n ↔ m ≤ succ n 
Arguments: {m n : ℕ}
Goal: m.pred ≤ n ↔ m ≤ n.succ
-- Nat.lt_of_lt_pred
lemma lt_of_lt_pred (h : m < n - 1) : m < n 
Arguments: {m n : ℕ} (h : m < n - 1)
Goal: m < n
-- Nat.le_add_pred_of_pos
lemma le_add_pred_of_pos (a : ℕ) (hb : b ≠ 0) : a ≤ b + (a - 1) 
Arguments: {b : ℕ} (a : ℕ) (hb : b ≠ 0)
Goal: a ≤ b + (a - 1)
-- Nat.add_def
@[simp] lemma add_def : Nat.add m n = m + n 
Arguments: {m n : ℕ}
Goal: m.add n = m + n
-- Nat.add_eq_left
@[simp, nolint simpNF] protected lemma add_eq_left : a + b = a ↔ b = 0 
Arguments: {a b : ℕ}
Goal: a + b = a ↔ b = 0
-- Nat.add_eq_right
@[simp, nolint simpNF] protected lemma add_eq_right : a + b = b ↔ a = 0 
Arguments: {a b : ℕ}
Goal: a + b = b ↔ a = 0
-- Nat.two_le_iff
lemma two_le_iff : ∀ n, 2 ≤ n ↔ n ≠ 0 ∧ n ≠ 1
  
Arguments: (n : ℕ)
Goal: 2 ≤ n ↔ n ≠ 0 ∧ n ≠ 1
-- Nat.add_eq_max_iff
lemma add_eq_max_iff : m + n = max m n ↔ m = 0 ∨ n = 0 
Arguments: {m n : ℕ}
Goal: m + n = max m n ↔ m = 0 ∨ n = 0
-- Nat.add_eq_min_iff
lemma add_eq_min_iff : m + n = min m n ↔ m = 0 ∧ n = 0 
Arguments: {m n : ℕ}
Goal: m + n = min m n ↔ m = 0 ∧ n = 0
-- Nat.add_eq_zero
@[simp, nolint simpNF] protected lemma add_eq_zero : m + n = 0 ↔ m = 0 ∧ n = 0 
Arguments: {m n : ℕ}
Goal: m + n = 0 ↔ m = 0 ∧ n = 0
-- Nat.add_pos_iff_pos_or_pos
lemma add_pos_iff_pos_or_pos : 0 < m + n ↔ 0 < m ∨ 0 < n 
Arguments: {m n : ℕ}
Goal: 0 < m + n ↔ 0 < m ∨ 0 < n
-- Nat.add_eq_one_iff
lemma add_eq_one_iff : m + n = 1 ↔ m = 0 ∧ n = 1 ∨ m = 1 ∧ n = 0 
Arguments: {m n : ℕ}
Goal: m + n = 1 ↔ m = 0 ∧ n = 1 ∨ m = 1 ∧ n = 0
-- Nat.add_eq_two_iff
lemma add_eq_two_iff : m + n = 2 ↔ m = 0 ∧ n = 2 ∨ m = 1 ∧ n = 1 ∨ m = 2 ∧ n = 0 
Arguments: {m n : ℕ}
Goal: m + n = 2 ↔ m = 0 ∧ n = 2 ∨ m = 1 ∧ n = 1 ∨ m = 2 ∧ n = 0
-- Nat.add_eq_three_iff
lemma add_eq_three_iff :
    m + n = 3 ↔ m = 0 ∧ n = 3 ∨ m = 1 ∧ n = 2 ∨ m = 2 ∧ n = 1 ∨ m = 3 ∧ n = 0 
Arguments: {m n : ℕ}
Goal: m + n = 3 ↔ m = 0 ∧ n = 3 ∨ m = 1 ∧ n = 2 ∨ m = 2 ∧ n = 1 ∨ m = 3 ∧ n = 0
-- Nat.le_add_one_iff
lemma le_add_one_iff : m ≤ n + 1 ↔ m ≤ n ∨ m = n + 1 
Arguments: {m n : ℕ}
Goal: m ≤ n + 1 ↔ m ≤ n ∨ m = n + 1
-- Nat.le_and_le_add_one_iff
lemma le_and_le_add_one_iff : n ≤ m ∧ m ≤ n + 1 ↔ m = n ∨ m = n + 1 
Arguments: {m n : ℕ}
Goal: n ≤ m ∧ m ≤ n + 1 ↔ m = n ∨ m = n + 1
-- Nat.add_succ_lt_add
lemma add_succ_lt_add (hab : a < b) (hcd : c < d) : a + c + 1 < b + d 
Arguments: {a b c d : ℕ} (hab : a < b) (hcd : c < d)
Goal: a + c + 1 < b + d
-- Nat.le_or_le_of_add_eq_add_pred
theorem le_or_le_of_add_eq_add_pred (h : a + c = b + d - 1) : b ≤ a ∨ d ≤ c 
Arguments: {a b c d : ℕ} (h : a + c = b + d - 1)
Goal: b ≤ a ∨ d ≤ c
-- Nat.sub_succ'
lemma sub_succ' (m n : ℕ) : m - n.succ = m - n - 1 
Arguments: (m n : ℕ)
Goal: m - n.succ = m - n - 1
-- Nat.sub_eq_of_eq_add'
protected lemma sub_eq_of_eq_add' (h : a = b + c) : a - b = c 
Arguments: {a b c : ℕ} (h : a = b + c)
Goal: a - b = c
-- Nat.eq_sub_of_add_eq
protected lemma eq_sub_of_add_eq (h : c + b = a) : c = a - b 
Arguments: {a b c : ℕ} (h : c + b = a)
Goal: c = a - b
-- Nat.eq_sub_of_add_eq'
protected lemma eq_sub_of_add_eq' (h : b + c = a) : c = a - b 
Arguments: {a b c : ℕ} (h : b + c = a)
Goal: c = a - b
-- Nat.lt_sub_iff_add_lt
protected lemma lt_sub_iff_add_lt : a < c - b ↔ a + b < c 
Arguments: {a b c : ℕ}
Goal: a < c - b ↔ a + b < c
-- Nat.lt_sub_iff_add_lt'
protected lemma lt_sub_iff_add_lt' : a < c - b ↔ b + a < c 
Arguments: {a b c : ℕ}
Goal: a < c - b ↔ b + a < c
-- Nat.sub_lt_iff_lt_add
protected lemma sub_lt_iff_lt_add (hba : b ≤ a) : a - b < c ↔ a < b + c 
Arguments: {a b c : ℕ} (hba : b ≤ a)
Goal: a - b < c ↔ a < b + c
-- Nat.sub_lt_iff_lt_add'
protected lemma sub_lt_iff_lt_add' (hba : b ≤ a) : a - b < c ↔ a < c + b 
Arguments: {a b c : ℕ} (hba : b ≤ a)
Goal: a - b < c ↔ a < c + b
-- Nat.sub_sub_sub_cancel_right
protected lemma sub_sub_sub_cancel_right (h : c ≤ b) : a - c - (b - c) = a - b 
Arguments: {a b c : ℕ} (h : c ≤ b)
Goal: a - c - (b - c) = a - b
-- Nat.add_sub_sub_cancel
protected lemma add_sub_sub_cancel (h : c ≤ a) : a + b - (a - c) = b + c 
Arguments: {a b c : ℕ} (h : c ≤ a)
Goal: a + b - (a - c) = b + c
-- Nat.sub_add_sub_cancel
protected lemma sub_add_sub_cancel (hab : b ≤ a) (hcb : c ≤ b) : a - b + (b - c) = a - c 
Arguments: {a b c : ℕ} (hab : b ≤ a) (hcb : c ≤ b)
Goal: a - b + (b - c) = a - c
-- Nat.lt_pred_iff
lemma lt_pred_iff : a < pred b ↔ succ a < b 
Arguments: {a b : ℕ}
Goal: a < b.pred ↔ a.succ < b
-- Nat.sub_lt_sub_iff_right
protected lemma sub_lt_sub_iff_right (h : c ≤ a) : a - c < b - c ↔ a < b 
Arguments: {a b c : ℕ} (h : c ≤ a)
Goal: a - c < b - c ↔ a < b
-- Nat.mul_def
@[simp] lemma mul_def : Nat.mul m n = m * n 
Arguments: {m n : ℕ}
Goal: m.mul n = m * n
-- Nat.zero_eq_mul
protected lemma zero_eq_mul : 0 = m * n ↔ m = 0 ∨ n = 0 
Arguments: {m n : ℕ}
Goal: 0 = m * n ↔ m = 0 ∨ n = 0
-- Nat.two_mul_ne_two_mul_add_one
lemma two_mul_ne_two_mul_add_one : 2 * n ≠ 2 * m + 1 
Arguments: {m n : ℕ}
Goal: 2 * n ≠ 2 * m + 1
-- Nat.mul_left_inj
protected lemma mul_left_inj (ha : a ≠ 0) : b * a = c * a ↔ b = c 
Arguments: {a b c : ℕ} (ha : a ≠ 0)
Goal: b * a = c * a ↔ b = c
-- Nat.mul_right_inj
protected lemma mul_right_inj (ha : a ≠ 0) : a * b = a * c ↔ b = c 
Arguments: {a b c : ℕ} (ha : a ≠ 0)
Goal: a * b = a * c ↔ b = c
-- Nat.mul_ne_mul_left
protected lemma mul_ne_mul_left (ha : a ≠ 0) : b * a ≠ c * a ↔ b ≠ c 
Arguments: {a b c : ℕ} (ha : a ≠ 0)
Goal: b * a ≠ c * a ↔ b ≠ c
-- Nat.mul_ne_mul_right
protected lemma mul_ne_mul_right (ha : a ≠ 0) : a * b ≠ a * c ↔ b ≠ c 
Arguments: {a b c : ℕ} (ha : a ≠ 0)
Goal: a * b ≠ a * c ↔ b ≠ c
-- Nat.mul_eq_left
lemma mul_eq_left (ha : a ≠ 0) : a * b = a ↔ b = 1 
Arguments: {a b : ℕ} (ha : a ≠ 0)
Goal: a * b = a ↔ b = 1
-- Nat.mul_eq_right
lemma mul_eq_right (hb : b ≠ 0) : a * b = b ↔ a = 1 
Arguments: {a b : ℕ} (hb : b ≠ 0)
Goal: a * b = b ↔ a = 1
-- Nat.mul_right_eq_self_iff
lemma mul_right_eq_self_iff (ha : 0 < a) : a * b = a ↔ b = 1 
Arguments: {a b : ℕ} (ha : 0 < a)
Goal: a * b = a ↔ b = 1
-- Nat.mul_left_eq_self_iff
lemma mul_left_eq_self_iff (hb : 0 < b) : a * b = b ↔ a = 1 
Arguments: {a b : ℕ} (hb : 0 < b)
Goal: a * b = b ↔ a = 1
-- Nat.le_of_mul_le_mul_right
protected lemma le_of_mul_le_mul_right (h : a * c ≤ b * c) (hc : 0 < c) : a ≤ b 
Arguments: {a b c : ℕ} (h : a * c ≤ b * c) (hc : 0 < c)
Goal: a ≤ b
-- Nat.one_lt_mul_iff
lemma one_lt_mul_iff : 1 < m * n ↔ 0 < m ∧ 0 < n ∧ (1 < m ∨ 1 < n) 
Arguments: {m n : ℕ}
Goal: 1 < m * n ↔ 0 < m ∧ 0 < n ∧ (1 < m ∨ 1 < n)
-- Nat.eq_one_of_mul_eq_one_right
lemma eq_one_of_mul_eq_one_right (H : m * n = 1) : m = 1 
Arguments: {m n : ℕ} (H : m * n = 1)
Goal: m = 1
-- Nat.eq_one_of_mul_eq_one_left
lemma eq_one_of_mul_eq_one_left (H : m * n = 1) : n = 1 
Arguments: {m n : ℕ} (H : m * n = 1)
Goal: n = 1
-- Nat.lt_mul_iff_one_lt_left
@[simp] protected lemma lt_mul_iff_one_lt_left (hb : 0 < b) : b < a * b ↔ 1 < a 
Arguments: {a b : ℕ} (hb : 0 < b)
Goal: b < a * b ↔ 1 < a
-- Nat.lt_mul_iff_one_lt_right
@[simp] protected lemma lt_mul_iff_one_lt_right (ha : 0 < a) : a < a * b ↔ 1 < b 
Arguments: {a b : ℕ} (ha : 0 < a)
Goal: a < a * b ↔ 1 < b
-- Nat.eq_zero_of_double_le
lemma eq_zero_of_double_le (h : 2 * n ≤ n) : n = 0 
Arguments: {n : ℕ} (h : 2 * n ≤ n)
Goal: n = 0
-- Nat.eq_zero_of_mul_le
lemma eq_zero_of_mul_le (hb : 2 ≤ n) (h : n * m ≤ m) : m = 0 
Arguments: {m n : ℕ} (hb : 2 ≤ n) (h : n * m ≤ m)
Goal: m = 0
-- Nat.succ_mul_pos
lemma succ_mul_pos (m : ℕ) (hn : 0 < n) : 0 < succ m * n 
Arguments: {n : ℕ} (m : ℕ) (hn : 0 < n)
Goal: 0 < m.succ * n
-- Nat.mul_self_le_mul_self
lemma mul_self_le_mul_self (h : m ≤ n) : m * m ≤ n * n 
Arguments: {m n : ℕ} (h : m ≤ n)
Goal: m * m ≤ n * n
-- Nat.mul_lt_mul''
lemma mul_lt_mul'' (hac : a < c) (hbd : b < d) : a * b < c * d 
Arguments: {a b c d : ℕ} (hac : a < c) (hbd : b < d)
Goal: a * b < c * d
-- Nat.mul_self_lt_mul_self
lemma mul_self_lt_mul_self (h : m < n) : m * m < n * n 
Arguments: {m n : ℕ} (h : m < n)
Goal: m * m < n * n
-- Nat.mul_self_le_mul_self_iff
lemma mul_self_le_mul_self_iff : m * m ≤ n * n ↔ m ≤ n 
Arguments: {m n : ℕ}
Goal: m * m ≤ n * n ↔ m ≤ n
-- Nat.mul_self_lt_mul_self_iff
lemma mul_self_lt_mul_self_iff : m * m < n * n ↔ m < n 
Arguments: {m n : ℕ}
Goal: m * m < n * n ↔ m < n
-- Nat.le_mul_self
lemma le_mul_self : ∀ n : ℕ, n ≤ n * n
  
Arguments: (n : ℕ)
Goal: n ≤ n * n
-- Nat.mul_self_inj
lemma mul_self_inj : m * m = n * n ↔ m = n 
Arguments: {m n : ℕ}
Goal: m * m = n * n ↔ m = n
-- Nat.lt_mul_self_iff
@[simp] lemma lt_mul_self_iff : ∀ {n : ℕ}, n < n * n ↔ 1 < n
  
Arguments: {n : ℕ}
Goal: n < n * n ↔ 1 < n
-- Nat.add_sub_one_le_mul
lemma add_sub_one_le_mul (ha : a ≠ 0) (hb : b ≠ 0) : a + b - 1 ≤ a * b 
Arguments: {a b : ℕ} (ha : a ≠ 0) (hb : b ≠ 0)
Goal: a + b - 1 ≤ a * b
-- Nat.add_le_mul
protected lemma add_le_mul {a : ℕ} (ha : 2 ≤ a) : ∀ {b : ℕ} (_ : 2 ≤ b), a + b ≤ a * b
  
Arguments: {a : ℕ} (ha : 2 ≤ a) {b : ℕ}
Goal: 2 ≤ b → a + b ≤ a * b
-- Nat.div_le_iff_le_mul_add_pred
lemma div_le_iff_le_mul_add_pred (hb : 0 < b) : a / b ≤ c ↔ a ≤ b * c + (b - 1) 
Arguments: {a b c : ℕ} (hb : 0 < b)
Goal: a / b ≤ c ↔ a ≤ b * c + (b - 1)
-- Nat.div_lt_self'
lemma div_lt_self' (a b : ℕ) : (a + 1) / (b + 2) < a + 1 
Arguments: (a b : ℕ)
Goal: (a + 1) / (b + 2) < a + 1
-- Nat.le_div_iff_mul_le'
lemma le_div_iff_mul_le' (hb : 0 < b) : a ≤ c / b ↔ a * b ≤ c 
Arguments: {a b c : ℕ} (hb : 0 < b)
Goal: a ≤ c / b ↔ a * b ≤ c
-- Nat.div_lt_iff_lt_mul'
lemma div_lt_iff_lt_mul' (hb : 0 < b) : a / b < c ↔ a < c * b 
Arguments: {a b c : ℕ} (hb : 0 < b)
Goal: a / b < c ↔ a < c * b
-- Nat.one_le_div_iff
lemma one_le_div_iff (hb : 0 < b) : 1 ≤ a / b ↔ b ≤ a 
Arguments: {a b : ℕ} (hb : 0 < b)
Goal: 1 ≤ a / b ↔ b ≤ a
-- Nat.div_lt_one_iff
lemma div_lt_one_iff (hb : 0 < b) : a / b < 1 ↔ a < b 
Arguments: {a b : ℕ} (hb : 0 < b)
Goal: a / b < 1 ↔ a < b
-- Nat.div_le_div_right
@[gcongr]
protected lemma div_le_div_right (h : a ≤ b) : a / c ≤ b / c 
Arguments: {a b c : ℕ} (h : a ≤ b)
Goal: a / c ≤ b / c
-- Nat.lt_of_div_lt_div
lemma lt_of_div_lt_div (h : a / c < b / c) : a < b 
Arguments: {a b c : ℕ} (h : a / c < b / c)
Goal: a < b
-- Nat.div_pos
protected lemma div_pos (hba : b ≤ a) (hb : 0 < b) : 0 < a / b 
Arguments: {a b : ℕ} (hba : b ≤ a) (hb : 0 < b)
Goal: 0 < a / b
-- Nat.lt_mul_of_div_lt
lemma lt_mul_of_div_lt (h : a / c < b) (hc : 0 < c) : a < b * c 
Arguments: {a b c : ℕ} (h : a / c < b) (hc : 0 < c)
Goal: a < b * c
-- Nat.mul_div_le_mul_div_assoc
lemma mul_div_le_mul_div_assoc (a b c : ℕ) : a * (b / c) ≤ a * b / c 
Arguments: (a b c : ℕ)
Goal: a * (b / c) ≤ a * b / c
-- Nat.eq_mul_of_div_eq_left
protected lemma eq_mul_of_div_eq_left (H1 : b ∣ a) (H2 : a / b = c) : a = c * b 
Arguments: {a b c : ℕ} (H1 : b ∣ a) (H2 : a / b = c)
Goal: a = c * b
-- Nat.mul_div_cancel_left'
protected lemma mul_div_cancel_left' (Hd : a ∣ b) : a * (b / a) = b 
Arguments: {a b : ℕ} (Hd : a ∣ b)
Goal: a * (b / a) = b
-- Nat.lt_div_mul_add
lemma lt_div_mul_add (hb : 0 < b) : a < a / b * b + b 
Arguments: {a b : ℕ} (hb : 0 < b)
Goal: a < a / b * b + b
-- Nat.div_left_inj
@[simp]
protected lemma div_left_inj (hda : d ∣ a) (hdb : d ∣ b) : a / d = b / d ↔ a = b 
Arguments: {a b d : ℕ} (hda : d ∣ a) (hdb : d ∣ b)
Goal: a / d = b / d ↔ a = b