ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- ENNReal.sum_eq_top_iff
theorem sum_eq_top_iff {s : Finset α} {f : α → ℝ≥0∞} : ∑ x ∈ s, f x = ∞ ↔ ∃ a ∈ s, f a = ∞ 
Arguments: {α : Type u_1} {s : Finset α} {f : α → ℝ≥0∞}
Goal: ∑ x ∈ s, f x = ⊤ ↔ ∃ a ∈ s, f a = ⊤
-- ENNReal.lt_top_of_sum_ne_top
theorem lt_top_of_sum_ne_top {s : Finset α} {f : α → ℝ≥0∞} (h : ∑ x ∈ s, f x ≠ ∞) {a : α}
    (ha : a ∈ s) : f a < ∞ 
Arguments: {α : Type u_1} {s : Finset α} {f : α → ℝ≥0∞} (h : ∑ x ∈ s, f x ≠ ⊤) {a : α} (ha : a ∈ s)
Goal: f a < ⊤
-- ENNReal.toNNReal_sum
theorem toNNReal_sum {s : Finset α} {f : α → ℝ≥0∞} (hf : ∀ a ∈ s, f a ≠ ∞) :
    ENNReal.toNNReal (∑ a ∈ s, f a) = ∑ a ∈ s, ENNReal.toNNReal (f a) 
Arguments: {α : Type u_1} {s : Finset α} {f : α → ℝ≥0∞} (hf : ∀ a ∈ s, f a ≠ ⊤)
Goal: (∑ a ∈ s, f a).toNNReal = ∑ a ∈ s, (f a).toNNReal
-- ENNReal.toReal_sum
theorem toReal_sum {s : Finset α} {f : α → ℝ≥0∞} (hf : ∀ a ∈ s, f a ≠ ∞) :
    ENNReal.toReal (∑ a ∈ s, f a) = ∑ a ∈ s, ENNReal.toReal (f a) 
Arguments: {α : Type u_1} {s : Finset α} {f : α → ℝ≥0∞} (hf : ∀ a ∈ s, f a ≠ ⊤)
Goal: (∑ a ∈ s, f a).toReal = ∑ a ∈ s, (f a).toReal
-- ENNReal.ofReal_sum_of_nonneg
theorem ofReal_sum_of_nonneg {s : Finset α} {f : α → ℝ} (hf : ∀ i, i ∈ s → 0 ≤ f i) :
    ENNReal.ofReal (∑ i ∈ s, f i) = ∑ i ∈ s, ENNReal.ofReal (f i) 
Arguments: {α : Type u_1} {s : Finset α} {f : α → ℝ} (hf : ∀ i ∈ s, 0 ≤ f i)
Goal: ENNReal.ofReal (∑ i ∈ s, f i) = ∑ i ∈ s, ENNReal.ofReal (f i)
-- ENNReal.sum_lt_sum_of_nonempty
theorem sum_lt_sum_of_nonempty {s : Finset α} (hs : s.Nonempty) {f g : α → ℝ≥0∞}
    (Hlt : ∀ i ∈ s, f i < g i) : ∑ i ∈ s, f i < ∑ i ∈ s, g i 
Arguments: {α : Type u_1} {s : Finset α} (hs : s.Nonempty) {f g : α → ℝ≥0∞} (Hlt : ∀ i ∈ s, f i < g i)
Goal: ∑ i ∈ s, f i < ∑ i ∈ s, g i
-- ENNReal.exists_le_of_sum_le
theorem exists_le_of_sum_le {s : Finset α} (hs : s.Nonempty) {f g : α → ℝ≥0∞}
    (Hle : ∑ i ∈ s, f i ≤ ∑ i ∈ s, g i) : ∃ i ∈ s, f i ≤ g i 
Arguments: {α : Type u_1} {s : Finset α} (hs : s.Nonempty) {f g : α → ℝ≥0∞} (Hle : ∑ i ∈ s, f i ≤ ∑ i ∈ s, g i)
Goal: ∃ i ∈ s, f i ≤ g i
-- ENNReal.Ico_eq_Iio
protected theorem Ico_eq_Iio : Ico 0 y = Iio y 
Arguments: {y : ℝ≥0∞}
Goal: Set.Ico 0 y = Set.Iio y
-- ENNReal.mem_Iio_self_add
theorem mem_Iio_self_add : x ≠ ∞ → ε ≠ 0 → x ∈ Iio (x + ε) 
Arguments: {x ε : ℝ≥0∞}
Goal: x ≠ ⊤ → ε ≠ 0 → x ∈ Set.Iio (x + ε)
-- ENNReal.mem_Ioo_self_sub_add
theorem mem_Ioo_self_sub_add : x ≠ ∞ → x ≠ 0 → ε₁ ≠ 0 → ε₂ ≠ 0 → x ∈ Ioo (x - ε₁) (x + ε₂) 
Arguments: {x ε₁ ε₂ : ℝ≥0∞}
Goal: x ≠ ⊤ → x ≠ 0 → ε₁ ≠ 0 → ε₂ ≠ 0 → x ∈ Set.Ioo (x - ε₁) (x + ε₂)
-- ENNReal.smul_def
theorem smul_def {M : Type*} [MulAction ℝ≥0∞ M] (c : ℝ≥0) (x : M) : c • x = (c : ℝ≥0∞) • x 
Arguments: {M : Type u_1} [MulAction ℝ≥0∞ M] (c : ℝ≥0) (x : M)
Goal: c • x = ↑c • x
-- ENNReal.coe_smul
theorem coe_smul {R} (r : R) (s : ℝ≥0) [SMul R ℝ≥0] [SMul R ℝ≥0∞] [IsScalarTower R ℝ≥0 ℝ≥0]
    [IsScalarTower R ℝ≥0 ℝ≥0∞] : (↑(r • s) : ℝ≥0∞) = (r : R) • (s : ℝ≥0∞) 
Arguments: {R : Type u_1} (r : R) (s : ℝ≥0) [SMul R ℝ≥0] [SMul R ℝ≥0∞] [IsScalarTower R ℝ≥0 ℝ≥0] [IsScalarTower R ℝ≥0 ℝ≥0∞]
Goal: ↑(r • s) = r • ↑s
-- ENNReal.smul_top
theorem smul_top {R} [Zero R] [SMulWithZero R ℝ≥0∞] [IsScalarTower R ℝ≥0∞ ℝ≥0∞]
    [NoZeroSMulDivisors R ℝ≥0∞] [DecidableEq R] (c : R) :
    c • ∞ = if c = 0 then 0 else ∞ 
Arguments: {R : Type u_1} [Zero R] [SMulWithZero R ℝ≥0∞] [IsScalarTower R ℝ≥0∞ ℝ≥0∞] [NoZeroSMulDivisors R ℝ≥0∞] [DecidableEq R] (c : R)
Goal: c • ⊤ = if c = 0 then 0 else ⊤
-- Nat.cast_choose
theorem cast_choose {a b : ℕ} (h : a ≤ b) : (b.choose a : K) = b ! / (a ! * (b - a)!) 
Arguments: (K : Type u_1) [DivisionRing K] [CharZero K] {a b : ℕ} (h : a ≤ b)
Goal: ↑(b.choose a) = ↑b ! / (↑a ! * ↑(b - a)!)
-- Nat.cast_add_choose
theorem cast_add_choose {a b : ℕ} : ((a + b).choose a : K) = (a + b)! / (a ! * b !) 
Arguments: (K : Type u_1) [DivisionRing K] [CharZero K] {a b : ℕ}
Goal: ↑((a + b).choose a) = ↑(a + b)! / (↑a ! * ↑b !)
-- Nat.cast_choose_eq_ascPochhammer_div
theorem cast_choose_eq_ascPochhammer_div (a b : ℕ) :
    (a.choose b : K) = (ascPochhammer K b).eval ↑(a - (b - 1)) / b ! 
Arguments: (K : Type u_1) [DivisionRing K] [CharZero K] (a b : ℕ)
Goal: ↑(a.choose b) = Polynomial.eval (↑(a - (b - 1))) (ascPochhammer K b) / ↑b !
-- Nat.cast_choose_two
theorem cast_choose_two (a : ℕ) : (a.choose 2 : K) = a * (a - 1) / 2 
Arguments: (K : Type u_1) [DivisionRing K] [CharZero K] (a : ℕ)
Goal: ↑(a.choose 2) = ↑a * (↑a - 1) / 2
-- Nat.add_choose_eq
theorem Nat.add_choose_eq (m n k : ℕ) :
    (m + n).choose k = ∑ ij ∈ antidiagonal k, m.choose ij.1 * n.choose ij.2 
Arguments: (m n k : ℕ)
Goal: (m + n).choose k = ∑ ij ∈ Finset.antidiagonal k, m.choose ij.1 * n.choose ij.2
-- Nat.gcd_greatest
theorem gcd_greatest {a b d : ℕ} (hda : d ∣ a) (hdb : d ∣ b) (hd : ∀ e : ℕ, e ∣ a → e ∣ b → e ∣ d) :
    d = a.gcd b 
Arguments: {a b d : ℕ} (hda : d ∣ a) (hdb : d ∣ b) (hd : ∀ (e : ℕ), e ∣ a → e ∣ b → e ∣ d)
Goal: d = a.gcd b
-- Nat.gcd_add_mul_right_right
@[simp]
theorem gcd_add_mul_right_right (m n k : ℕ) : gcd m (n + k * m) = gcd m n 
Arguments: (m n k : ℕ)
Goal: m.gcd (n + k * m) = m.gcd n
-- Nat.gcd_add_mul_left_right
@[simp]
theorem gcd_add_mul_left_right (m n k : ℕ) : gcd m (n + m * k) = gcd m n 
Arguments: (m n k : ℕ)
Goal: m.gcd (n + m * k) = m.gcd n
-- Nat.gcd_mul_right_add_right
@[simp]
theorem gcd_mul_right_add_right (m n k : ℕ) : gcd m (k * m + n) = gcd m n 
Arguments: (m n k : ℕ)
Goal: m.gcd (k * m + n) = m.gcd n
-- Nat.gcd_mul_left_add_right
@[simp]
theorem gcd_mul_left_add_right (m n k : ℕ) : gcd m (m * k + n) = gcd m n 
Arguments: (m n k : ℕ)
Goal: m.gcd (m * k + n) = m.gcd n
-- Nat.gcd_add_mul_right_left
@[simp]
theorem gcd_add_mul_right_left (m n k : ℕ) : gcd (m + k * n) n = gcd m n 
Arguments: (m n k : ℕ)
Goal: (m + k * n).gcd n = m.gcd n
-- Nat.gcd_add_mul_left_left
@[simp]
theorem gcd_add_mul_left_left (m n k : ℕ) : gcd (m + n * k) n = gcd m n 
Arguments: (m n k : ℕ)
Goal: (m + n * k).gcd n = m.gcd n
-- Nat.gcd_mul_right_add_left
@[simp]
theorem gcd_mul_right_add_left (m n k : ℕ) : gcd (k * n + m) n = gcd m n 
Arguments: (m n k : ℕ)
Goal: (k * n + m).gcd n = m.gcd n
-- Nat.gcd_mul_left_add_left
@[simp]
theorem gcd_mul_left_add_left (m n k : ℕ) : gcd (n * k + m) n = gcd m n 
Arguments: (m n k : ℕ)
Goal: (n * k + m).gcd n = m.gcd n
-- Nat.gcd_add_self_right
@[simp]
theorem gcd_add_self_right (m n : ℕ) : gcd m (n + m) = gcd m n 
Arguments: (m n : ℕ)
Goal: m.gcd (n + m) = m.gcd n
-- Nat.gcd_add_self_left
@[simp]
theorem gcd_add_self_left (m n : ℕ) : gcd (m + n) n = gcd m n 
Arguments: (m n : ℕ)
Goal: (m + n).gcd n = m.gcd n
-- Nat.gcd_self_add_left
@[simp]
theorem gcd_self_add_left (m n : ℕ) : gcd (m + n) m = gcd n m 
Arguments: (m n : ℕ)
Goal: (m + n).gcd m = n.gcd m
-- Nat.gcd_self_add_right
@[simp]
theorem gcd_self_add_right (m n : ℕ) : gcd m (m + n) = gcd m n 
Arguments: (m n : ℕ)
Goal: m.gcd (m + n) = m.gcd n
-- Nat.gcd_sub_self_left
@[simp]
theorem gcd_sub_self_left {m n : ℕ} (h : m ≤ n) : gcd (n - m) m = gcd n m 
Arguments: {m n : ℕ} (h : m ≤ n)
Goal: (n - m).gcd m = n.gcd m
-- Nat.gcd_sub_self_right
@[simp]
theorem gcd_sub_self_right {m n : ℕ} (h : m ≤ n) : gcd m (n - m) = gcd m n 
Arguments: {m n : ℕ} (h : m ≤ n)
Goal: m.gcd (n - m) = m.gcd n
-- Nat.gcd_self_sub_left
@[simp]
theorem gcd_self_sub_left {m n : ℕ} (h : m ≤ n) : gcd (n - m) n = gcd m n 
Arguments: {m n : ℕ} (h : m ≤ n)
Goal: (n - m).gcd n = m.gcd n
-- Nat.gcd_self_sub_right
@[simp]
theorem gcd_self_sub_right {m n : ℕ} (h : m ≤ n) : gcd n (n - m) = gcd n m 
Arguments: {m n : ℕ} (h : m ≤ n)
Goal: n.gcd (n - m) = n.gcd m
-- Nat.lcm_dvd_mul
theorem lcm_dvd_mul (m n : ℕ) : lcm m n ∣ m * n 
Arguments: (m n : ℕ)
Goal: m.lcm n ∣ m * n
-- Nat.lcm_dvd_iff
theorem lcm_dvd_iff {m n k : ℕ} : lcm m n ∣ k ↔ m ∣ k ∧ n ∣ k 
Arguments: {m n k : ℕ}
Goal: m.lcm n ∣ k ↔ m ∣ k ∧ n ∣ k
-- Nat.lcm_pos
theorem lcm_pos {m n : ℕ} : 0 < m → 0 < n → 0 < m.lcm n 
Arguments: {m n : ℕ}
Goal: 0 < m → 0 < n → 0 < m.lcm n
-- Nat.lcm_mul_left
theorem lcm_mul_left {m n k : ℕ} : (m * n).lcm (m * k) = m * n.lcm k 
Arguments: {m n k : ℕ}
Goal: (m * n).lcm (m * k) = m * n.lcm k
-- Nat.lcm_mul_right
theorem lcm_mul_right {m n k : ℕ} : (m * n).lcm (k * n) = m.lcm k * n 
Arguments: {m n k : ℕ}
Goal: (m * n).lcm (k * n) = m.lcm k * n
-- Nat.Coprime.lcm_eq_mul
theorem Coprime.lcm_eq_mul {m n : ℕ} (h : Coprime m n) : lcm m n = m * n 
Arguments: {m n : ℕ} (h : m.Coprime n)
Goal: m.lcm n = m * n
-- Nat.Coprime.symmetric
theorem Coprime.symmetric : Symmetric Coprime 
Goal: Symmetric Nat.Coprime
-- Nat.Coprime.dvd_mul_right
theorem Coprime.dvd_mul_right {m n k : ℕ} (H : Coprime k n) : k ∣ m * n ↔ k ∣ m 
Arguments: {m n k : ℕ} (H : k.Coprime n)
Goal: k ∣ m * n ↔ k ∣ m
-- Nat.Coprime.dvd_mul_left
theorem Coprime.dvd_mul_left {m n k : ℕ} (H : Coprime k m) : k ∣ m * n ↔ k ∣ n 
Arguments: {m n k : ℕ} (H : k.Coprime m)
Goal: k ∣ m * n ↔ k ∣ n
-- Nat.coprime_add_self_right
@[simp]
theorem coprime_add_self_right {m n : ℕ} : Coprime m (n + m) ↔ Coprime m n 
Arguments: {m n : ℕ}
Goal: m.Coprime (n + m) ↔ m.Coprime n
-- Nat.coprime_self_add_right
@[simp]
theorem coprime_self_add_right {m n : ℕ} : Coprime m (m + n) ↔ Coprime m n 
Arguments: {m n : ℕ}
Goal: m.Coprime (m + n) ↔ m.Coprime n
-- Nat.coprime_add_self_left
@[simp]
theorem coprime_add_self_left {m n : ℕ} : Coprime (m + n) n ↔ Coprime m n 
Arguments: {m n : ℕ}
Goal: (m + n).Coprime n ↔ m.Coprime n
-- Nat.coprime_self_add_left
@[simp]
theorem coprime_self_add_left {m n : ℕ} : Coprime (m + n) m ↔ Coprime n m 
Arguments: {m n : ℕ}
Goal: (m + n).Coprime m ↔ n.Coprime m
-- Nat.coprime_add_mul_right_right
@[simp]
theorem coprime_add_mul_right_right (m n k : ℕ) : Coprime m (n + k * m) ↔ Coprime m n 
Arguments: (m n k : ℕ)
Goal: m.Coprime (n + k * m) ↔ m.Coprime n
-- Nat.coprime_add_mul_left_right
@[simp]
theorem coprime_add_mul_left_right (m n k : ℕ) : Coprime m (n + m * k) ↔ Coprime m n 
Arguments: (m n k : ℕ)
Goal: m.Coprime (n + m * k) ↔ m.Coprime n
-- Nat.coprime_mul_right_add_right
@[simp]
theorem coprime_mul_right_add_right (m n k : ℕ) : Coprime m (k * m + n) ↔ Coprime m n 
Arguments: (m n k : ℕ)
Goal: m.Coprime (k * m + n) ↔ m.Coprime n
-- Nat.coprime_mul_left_add_right
@[simp]
theorem coprime_mul_left_add_right (m n k : ℕ) : Coprime m (m * k + n) ↔ Coprime m n 
Arguments: (m n k : ℕ)
Goal: m.Coprime (m * k + n) ↔ m.Coprime n
-- Nat.coprime_add_mul_right_left
@[simp]
theorem coprime_add_mul_right_left (m n k : ℕ) : Coprime (m + k * n) n ↔ Coprime m n 
Arguments: (m n k : ℕ)
Goal: (m + k * n).Coprime n ↔ m.Coprime n
-- Nat.coprime_add_mul_left_left
@[simp]
theorem coprime_add_mul_left_left (m n k : ℕ) : Coprime (m + n * k) n ↔ Coprime m n 
Arguments: (m n k : ℕ)
Goal: (m + n * k).Coprime n ↔ m.Coprime n
-- Nat.coprime_mul_right_add_left
@[simp]
theorem coprime_mul_right_add_left (m n k : ℕ) : Coprime (k * n + m) n ↔ Coprime m n 
Arguments: (m n k : ℕ)
Goal: (k * n + m).Coprime n ↔ m.Coprime n
-- Nat.coprime_mul_left_add_left
@[simp]
theorem coprime_mul_left_add_left (m n k : ℕ) : Coprime (n * k + m) n ↔ Coprime m n 
Arguments: (m n k : ℕ)
Goal: (n * k + m).Coprime n ↔ m.Coprime n
-- Nat.coprime_sub_self_left
@[simp]
theorem coprime_sub_self_left {m n : ℕ} (h : m ≤ n) : Coprime (n - m) m ↔ Coprime n m 
Arguments: {m n : ℕ} (h : m ≤ n)
Goal: (n - m).Coprime m ↔ n.Coprime m
-- Nat.coprime_sub_self_right
@[simp]
theorem coprime_sub_self_right {m n : ℕ} (h : m ≤ n) : Coprime m (n - m) ↔ Coprime m n 
Arguments: {m n : ℕ} (h : m ≤ n)
Goal: m.Coprime (n - m) ↔ m.Coprime n
-- Nat.coprime_self_sub_left
@[simp]
theorem coprime_self_sub_left {m n : ℕ} (h : m ≤ n) : Coprime (n - m) n ↔ Coprime m n 
Arguments: {m n : ℕ} (h : m ≤ n)
Goal: (n - m).Coprime n ↔ m.Coprime n
-- Nat.coprime_self_sub_right
@[simp]
theorem coprime_self_sub_right {m n : ℕ} (h : m ≤ n) : Coprime n (n - m) ↔ Coprime n m 
Arguments: {m n : ℕ} (h : m ≤ n)
Goal: n.Coprime (n - m) ↔ n.Coprime m
-- Nat.coprime_pow_left_iff
@[simp]
theorem coprime_pow_left_iff {n : ℕ} (hn : 0 < n) (a b : ℕ) :
    Nat.Coprime (a ^ n) b ↔ Nat.Coprime a b 
Arguments: {n : ℕ} (hn : 0 < n) (a b : ℕ)
Goal: (a ^ n).Coprime b ↔ a.Coprime b
-- Nat.coprime_pow_right_iff
@[simp]
theorem coprime_pow_right_iff {n : ℕ} (hn : 0 < n) (a b : ℕ) :
    Nat.Coprime a (b ^ n) ↔ Nat.Coprime a b 
Arguments: {n : ℕ} (hn : 0 < n) (a b : ℕ)
Goal: a.Coprime (b ^ n) ↔ a.Coprime b
-- Nat.not_coprime_zero_zero
theorem not_coprime_zero_zero : ¬Coprime 0 0 
Goal: ¬Nat.Coprime 0 0
-- Nat.coprime_one_left_iff
theorem coprime_one_left_iff (n : ℕ) : Coprime 1 n ↔ True 
Arguments: (n : ℕ)
Goal: Nat.Coprime 1 n ↔ True
-- Nat.coprime_one_right_iff
theorem coprime_one_right_iff (n : ℕ) : Coprime n 1 ↔ True 
Arguments: (n : ℕ)
Goal: n.Coprime 1 ↔ True
-- Nat.gcd_mul_of_coprime_of_dvd
theorem gcd_mul_of_coprime_of_dvd {a b c : ℕ} (hac : Coprime a c) (b_dvd_c : b ∣ c) :
    gcd (a * b) c = b 
Arguments: {a b c : ℕ} (hac : a.Coprime c) (b_dvd_c : b ∣ c)
Goal: (a * b).gcd c = b
-- Nat.Coprime.eq_of_mul_eq_zero
theorem Coprime.eq_of_mul_eq_zero {m n : ℕ} (h : m.Coprime n) (hmn : m * n = 0) :
    m = 0 ∧ n = 1 ∨ m = 1 ∧ n = 0 
Arguments: {m n : ℕ} (h : m.Coprime n) (hmn : m * n = 0)
Goal: m = 0 ∧ n = 1 ∨ m = 1 ∧ n = 0
-- Nat.dvd_mul
theorem dvd_mul {x m n : ℕ} : x ∣ m * n ↔ ∃ y z, y ∣ m ∧ z ∣ n ∧ y * z = x 
Arguments: {x m n : ℕ}
Goal: x ∣ m * n ↔ ∃ y z, y ∣ m ∧ z ∣ n ∧ y * z = x
-- Nat.pow_dvd_pow_iff
theorem pow_dvd_pow_iff {a b n : ℕ} (n0 : n ≠ 0) : a ^ n ∣ b ^ n ↔ a ∣ b 
Arguments: {a b n : ℕ} (n0 : n ≠ 0)
Goal: a ^ n ∣ b ^ n ↔ a ∣ b
-- Nat.coprime_iff_isRelPrime
theorem coprime_iff_isRelPrime {m n : ℕ} : m.Coprime n ↔ IsRelPrime m n 
Arguments: {m n : ℕ}
Goal: m.Coprime n ↔ IsRelPrime m n
-- Nat.eq_one_of_dvd_coprimes
theorem eq_one_of_dvd_coprimes {a b k : ℕ} (h_ab_coprime : Coprime a b) (hka : k ∣ a)
    (hkb : k ∣ b) : k = 1 
Arguments: {a b k : ℕ} (h_ab_coprime : a.Coprime b) (hka : k ∣ a) (hkb : k ∣ b)
Goal: k = 1
-- Nat.Coprime.mul_add_mul_ne_mul
theorem Coprime.mul_add_mul_ne_mul {m n a b : ℕ} (cop : Coprime m n) (ha : a ≠ 0) (hb : b ≠ 0) :
    a * m + b * n ≠ m * n 
Arguments: {m n a b : ℕ} (cop : m.Coprime n) (ha : a ≠ 0) (hb : b ≠ 0)
Goal: a * m + b * n ≠ m * n
-- Nat.dvd_gcd_mul_iff_dvd_mul
theorem dvd_gcd_mul_iff_dvd_mul : x ∣ gcd x n * m ↔ x ∣ n * m 
Arguments: {x n m : ℕ}
Goal: x ∣ x.gcd n * m ↔ x ∣ n * m
-- Nat.dvd_mul_gcd_iff_dvd_mul
theorem dvd_mul_gcd_iff_dvd_mul : x ∣ n * gcd x m ↔ x ∣ n * m 
Arguments: {x n m : ℕ}
Goal: x ∣ n * x.gcd m ↔ x ∣ n * m
-- Nat.dvd_gcd_mul_gcd_iff_dvd_mul
theorem dvd_gcd_mul_gcd_iff_dvd_mul : x ∣ gcd x n * gcd x m ↔ x ∣ n * m 
Arguments: {x n m : ℕ}
Goal: x ∣ x.gcd n * x.gcd m ↔ x ∣ n * m
-- Nat.gcd_mul_gcd_eq_iff_dvd_mul_of_coprime
theorem gcd_mul_gcd_eq_iff_dvd_mul_of_coprime (hcop : Coprime n m) :
    gcd x n * gcd x m = x ↔ x ∣ n * m 
Arguments: {x n m : ℕ} (hcop : n.Coprime m)
Goal: x.gcd n * x.gcd m = x ↔ x ∣ n * m
-- Nat.periodic_gcd
theorem periodic_gcd (a : ℕ) : Periodic (gcd a) a 
Arguments: (a : ℕ)
Goal: Function.Periodic a.gcd a
-- Nat.periodic_coprime
theorem periodic_coprime (a : ℕ) : Periodic (Coprime a) a 
Arguments: (a : ℕ)
Goal: Function.Periodic a.Coprime a
-- Nat.periodic_mod
theorem periodic_mod (a : ℕ) : Periodic (fun n => n % a) a 
Arguments: (a : ℕ)
Goal: Function.Periodic (fun n => n % a) a
-- Function.Periodic.map_mod_nat
theorem _root_.Function.Periodic.map_mod_nat {α : Type*} {f : ℕ → α} {a : ℕ} (hf : Periodic f a) :
    ∀ n, f (n % a) = f n 
Arguments: {α : Type u_1} {f : ℕ → α} {a : ℕ} (hf : Function.Periodic f a) (n : ℕ)
Goal: f (n % a) = f n
-- Nat.filter_multiset_Ico_card_eq_of_periodic
theorem filter_multiset_Ico_card_eq_of_periodic (n a : ℕ) (p : ℕ → Prop) [DecidablePred p]
    (pp : Periodic p a) : card (filter p (Ico n (n + a))) = a.count p 
Arguments: (n a : ℕ) (p : ℕ → Prop) [DecidablePred p] (pp : Function.Periodic p a)
Goal: Multiset.card (Multiset.filter p (Multiset.Ico n (n + a))) = Nat.count p a
-- Nat.filter_Ico_card_eq_of_periodic
theorem filter_Ico_card_eq_of_periodic (n a : ℕ) (p : ℕ → Prop) [DecidablePred p]
    (pp : Periodic p a) : ((Ico n (n + a)).filter p).card = a.count p 
Arguments: (n a : ℕ) (p : ℕ → Prop) [DecidablePred p] (pp : Function.Periodic p a)
Goal: (Finset.filter p (Finset.Ico n (n + a))).card = Nat.count p a
-- Nat.factorization_choose_le_log
theorem factorization_choose_le_log : (choose n k).factorization p ≤ log p n 
Arguments: {p n k : ℕ}
Goal: (n.choose k).factorization p ≤ Nat.log p n
-- Nat.pow_factorization_choose_le
theorem pow_factorization_choose_le (hn : 0 < n) : p ^ (choose n k).factorization p ≤ n 
Arguments: {p n k : ℕ} (hn : 0 < n)
Goal: p ^ (n.choose k).factorization p ≤ n
-- Nat.factorization_choose_le_one
theorem factorization_choose_le_one (p_large : n < p ^ 2) : (choose n k).factorization p ≤ 1 
Arguments: {p n k : ℕ} (p_large : n < p ^ 2)
Goal: (n.choose k).factorization p ≤ 1
-- Nat.factorization_choose_of_lt_three_mul
theorem factorization_choose_of_lt_three_mul (hp' : p ≠ 2) (hk : p ≤ k) (hk' : p ≤ n - k)
    (hn : n < 3 * p) : (choose n k).factorization p = 0 
Arguments: {p n k : ℕ} (hp' : p ≠ 2) (hk : p ≤ k) (hk' : p ≤ n - k) (hn : n < 3 * p)
Goal: (n.choose k).factorization p = 0
-- Nat.factorization_centralBinom_of_two_mul_self_lt_three_mul
theorem factorization_centralBinom_of_two_mul_self_lt_three_mul (n_big : 2 < n) (p_le_n : p ≤ n)
    (big : 2 * n < 3 * p) : (centralBinom n).factorization p = 0 
Arguments: {p n : ℕ} (n_big : 2 < n) (p_le_n : p ≤ n) (big : 2 * n < 3 * p)
Goal: n.centralBinom.factorization p = 0
-- Nat.factorization_factorial_eq_zero_of_lt
theorem factorization_factorial_eq_zero_of_lt (h : n < p) : (factorial n).factorization p = 0 
Arguments: {p n : ℕ} (h : n < p)
Goal: n.factorial.factorization p = 0
-- Nat.factorization_choose_eq_zero_of_lt
theorem factorization_choose_eq_zero_of_lt (h : n < p) : (choose n k).factorization p = 0 
Arguments: {p n k : ℕ} (h : n < p)
Goal: (n.choose k).factorization p = 0
-- Nat.factorization_centralBinom_eq_zero_of_two_mul_lt
theorem factorization_centralBinom_eq_zero_of_two_mul_lt (h : 2 * n < p) :
    (centralBinom n).factorization p = 0 
Arguments: {p n : ℕ} (h : 2 * n < p)
Goal: n.centralBinom.factorization p = 0
-- Nat.le_two_mul_of_factorization_centralBinom_pos
theorem le_two_mul_of_factorization_centralBinom_pos
    (h_pos : 0 < (centralBinom n).factorization p) : p ≤ 2 * n 
Arguments: {p n : ℕ} (h_pos : 0 < n.centralBinom.factorization p)
Goal: p ≤ 2 * n
-- Nat.prod_pow_factorization_choose
theorem prod_pow_factorization_choose (n k : ℕ) (hkn : k ≤ n) :
    (∏ p ∈ Finset.range (n + 1), p ^ (Nat.choose n k).factorization p) = choose n k 
Arguments: (n k : ℕ) (hkn : k ≤ n)
Goal: ∏ p ∈ Finset.range (n + 1), p ^ (n.choose k).factorization p = n.choose k
-- Nat.prod_pow_factorization_centralBinom
theorem prod_pow_factorization_centralBinom (n : ℕ) :
    (∏ p ∈ Finset.range (2 * n + 1), p ^ (centralBinom n).factorization p) = centralBinom n 
Arguments: (n : ℕ)
Goal: ∏ p ∈ Finset.range (2 * n + 1), p ^ n.centralBinom.factorization p = n.centralBinom
-- Nat.choose_le_pow
theorem choose_le_pow (r n : ℕ) : (n.choose r : α) ≤ (n ^ r : α) / r ! 
Arguments: {α : Type u_1} [LinearOrderedSemifield α] (r n : ℕ)
Goal: ↑(n.choose r) ≤ ↑n ^ r / ↑r !
-- Nat.pow_le_choose
theorem pow_le_choose (r n : ℕ) : ((n + 1 - r : ℕ) ^ r : α) / r ! ≤ n.choose r 
Arguments: {α : Type u_1} [LinearOrderedSemifield α] (r n : ℕ)
Goal: ↑(n + 1 - r) ^ r / ↑r ! ≤ ↑(n.choose r)
-- Nat.sInf_def
theorem sInf_def {s : Set ℕ} (h : s.Nonempty) : sInf s = @Nat.find (fun n ↦ n ∈ s) _ h 
Arguments: {s : Set ℕ} (h : s.Nonempty)
Goal: sInf s = Nat.find h
-- Nat.sSup_def
theorem sSup_def {s : Set ℕ} (h : ∃ n, ∀ a ∈ s, a ≤ n) :
    sSup s = @Nat.find (fun n ↦ ∀ a ∈ s, a ≤ n) _ h 
Arguments: {s : Set ℕ} (h : ∃ n, ∀ a ∈ s, a ≤ n)
Goal: sSup s = Nat.find h
-- Set.Infinite.Nat.sSup_eq_zero
theorem _root_.Set.Infinite.Nat.sSup_eq_zero {s : Set ℕ} (h : s.Infinite) : sSup s = 0 
Arguments: {s : Set ℕ} (h : s.Infinite)
Goal: sSup s = 0
-- Nat.sInf_eq_zero
@[simp]
theorem sInf_eq_zero {s : Set ℕ} : sInf s = 0 ↔ 0 ∈ s ∨ s = ∅ 
Arguments: {s : Set ℕ}
Goal: sInf s = 0 ↔ 0 ∈ s ∨ s = ∅
-- Nat.sInf_empty
@[simp]
theorem sInf_empty : sInf ∅ = 0 
Goal: sInf ∅ = 0
-- Nat.iInf_of_empty
@[simp]
theorem iInf_of_empty {ι : Sort*} [IsEmpty ι] (f : ι → ℕ) : iInf f = 0 
Arguments: {ι : Sort u_1} [IsEmpty ι] (f : ι → ℕ)
Goal: iInf f = 0
-- Nat.iInf_const_zero
@[simp]
lemma iInf_const_zero {ι : Sort*} : ⨅ i : ι, 0 = 0 
Arguments: {ι : Sort u_1}
Goal: ⨅ i, 0 = 0
-- Nat.sInf_mem
theorem sInf_mem {s : Set ℕ} (h : s.Nonempty) : sInf s ∈ s 
Arguments: {s : Set ℕ} (h : s.Nonempty)
Goal: sInf s ∈ s
-- Nat.not_mem_of_lt_sInf
theorem not_mem_of_lt_sInf {s : Set ℕ} {m : ℕ} (hm : m < sInf s) : m ∉ s 
Arguments: {s : Set ℕ} {m : ℕ} (hm : m < sInf s)
Goal: m ∉ s
-- Nat.sInf_le
protected theorem sInf_le {s : Set ℕ} {m : ℕ} (hm : m ∈ s) : sInf s ≤ m 
Arguments: {s : Set ℕ} {m : ℕ} (hm : m ∈ s)
Goal: sInf s ≤ m
-- Nat.nonempty_of_pos_sInf
theorem nonempty_of_pos_sInf {s : Set ℕ} (h : 0 < sInf s) : s.Nonempty 
Arguments: {s : Set ℕ} (h : 0 < sInf s)
Goal: s.Nonempty
-- Nat.nonempty_of_sInf_eq_succ
theorem nonempty_of_sInf_eq_succ {s : Set ℕ} {k : ℕ} (h : sInf s = k + 1) : s.Nonempty 
Arguments: {s : Set ℕ} {k : ℕ} (h : sInf s = k + 1)
Goal: s.Nonempty
-- Nat.eq_Ici_of_nonempty_of_upward_closed
theorem eq_Ici_of_nonempty_of_upward_closed {s : Set ℕ} (hs : s.Nonempty)
    (hs' : ∀ k₁ k₂ : ℕ, k₁ ≤ k₂ → k₁ ∈ s → k₂ ∈ s) : s = Ici (sInf s) 
Arguments: {s : Set ℕ} (hs : s.Nonempty) (hs' : ∀ (k₁ k₂ : ℕ), k₁ ≤ k₂ → k₁ ∈ s → k₂ ∈ s)
Goal: s = Set.Ici (sInf s)
-- Nat.sInf_upward_closed_eq_succ_iff
theorem sInf_upward_closed_eq_succ_iff {s : Set ℕ} (hs : ∀ k₁ k₂ : ℕ, k₁ ≤ k₂ → k₁ ∈ s → k₂ ∈ s)
    (k : ℕ) : sInf s = k + 1 ↔ k + 1 ∈ s ∧ k ∉ s 
Arguments: {s : Set ℕ} (hs : ∀ (k₁ k₂ : ℕ), k₁ ≤ k₂ → k₁ ∈ s → k₂ ∈ s) (k : ℕ)
Goal: sInf s = k + 1 ↔ k + 1 ∈ s ∧ k ∉ s
-- Nat.sSup_mem
theorem sSup_mem {s : Set ℕ} (h₁ : s.Nonempty) (h₂ : BddAbove s) : sSup s ∈ s 
Arguments: {s : Set ℕ} (h₁ : s.Nonempty) (h₂ : BddAbove s)
Goal: sSup s ∈ s
-- Nat.sInf_add
theorem sInf_add {n : ℕ} {p : ℕ → Prop} (hn : n ≤ sInf { m | p m }) :
    sInf { m | p (m + n) } + n = sInf { m | p m } 
Arguments: {n : ℕ} {p : ℕ → Prop} (hn : n ≤ sInf {m | p m})
Goal: sInf {m | p (m + n)} + n = sInf {m | p m}
-- Nat.sInf_add'
theorem sInf_add' {n : ℕ} {p : ℕ → Prop} (h : 0 < sInf { m | p m }) :
    sInf { m | p m } + n = sInf { m | p (m - n) } 
Arguments: {n : ℕ} {p : ℕ → Prop} (h : 0 < sInf {m | p m})
Goal: sInf {m | p m} + n = sInf {m | p (m - n)}
-- Nat.iSup_lt_succ
theorem iSup_lt_succ (u : ℕ → α) (n : ℕ) : ⨆ k < n + 1, u k = (⨆ k < n, u k) ⊔ u n 
Arguments: {α : Type u_1} [CompleteLattice α] (u : ℕ → α) (n : ℕ)
Goal: ⨆ k, ⨆ (_ : k < n + 1), u k = (⨆ k, ⨆ (_ : k < n), u k) ⊔ u n
-- Nat.iSup_lt_succ'
theorem iSup_lt_succ' (u : ℕ → α) (n : ℕ) : ⨆ k < n + 1, u k = u 0 ⊔ ⨆ k < n, u (k + 1) 
Arguments: {α : Type u_1} [CompleteLattice α] (u : ℕ → α) (n : ℕ)
Goal: ⨆ k, ⨆ (_ : k < n + 1), u k = u 0 ⊔ ⨆ k, ⨆ (_ : k < n), u (k + 1)
-- Nat.iInf_lt_succ
theorem iInf_lt_succ (u : ℕ → α) (n : ℕ) : ⨅ k < n + 1, u k = (⨅ k < n, u k) ⊓ u n 
Arguments: {α : Type u_1} [CompleteLattice α] (u : ℕ → α) (n : ℕ)
Goal: ⨅ k, ⨅ (_ : k < n + 1), u k = (⨅ k, ⨅ (_ : k < n), u k) ⊓ u n
-- Nat.iInf_lt_succ'
theorem iInf_lt_succ' (u : ℕ → α) (n : ℕ) : ⨅ k < n + 1, u k = u 0 ⊓ ⨅ k < n, u (k + 1) 
Arguments: {α : Type u_1} [CompleteLattice α] (u : ℕ → α) (n : ℕ)
Goal: ⨅ k, ⨅ (_ : k < n + 1), u k = u 0 ⊓ ⨅ k, ⨅ (_ : k < n), u (k + 1)
-- Nat.iSup_le_succ
theorem iSup_le_succ (u : ℕ → α) (n : ℕ) : ⨆ k ≤ n + 1, u k = (⨆ k ≤ n, u k) ⊔ u (n + 1) 
Arguments: {α : Type u_1} [CompleteLattice α] (u : ℕ → α) (n : ℕ)
Goal: ⨆ k, ⨆ (_ : k ≤ n + 1), u k = (⨆ k, ⨆ (_ : k ≤ n), u k) ⊔ u (n + 1)
-- Nat.iSup_le_succ'
theorem iSup_le_succ' (u : ℕ → α) (n : ℕ) : ⨆ k ≤ n + 1, u k = u 0 ⊔ ⨆ k ≤ n, u (k + 1) 
Arguments: {α : Type u_1} [CompleteLattice α] (u : ℕ → α) (n : ℕ)
Goal: ⨆ k, ⨆ (_ : k ≤ n + 1), u k = u 0 ⊔ ⨆ k, ⨆ (_ : k ≤ n), u (k + 1)
-- Nat.iInf_le_succ
theorem iInf_le_succ (u : ℕ → α) (n : ℕ) : ⨅ k ≤ n + 1, u k = (⨅ k ≤ n, u k) ⊓ u (n + 1) 
Arguments: {α : Type u_1} [CompleteLattice α] (u : ℕ → α) (n : ℕ)
Goal: ⨅ k, ⨅ (_ : k ≤ n + 1), u k = (⨅ k, ⨅ (_ : k ≤ n), u k) ⊓ u (n + 1)
-- Nat.iInf_le_succ'
theorem iInf_le_succ' (u : ℕ → α) (n : ℕ) : ⨅ k ≤ n + 1, u k = u 0 ⊓ ⨅ k ≤ n, u (k + 1) 
Arguments: {α : Type u_1} [CompleteLattice α] (u : ℕ → α) (n : ℕ)
Goal: ⨅ k, ⨅ (_ : k ≤ n + 1), u k = u 0 ⊓ ⨅ k, ⨅ (_ : k ≤ n), u (k + 1)