ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Nat.Primes.coe_pnat_inj
@[norm_cast]
theorem coe_pnat_inj (p q : Nat.Primes) : (p : ℕ+) = (q : ℕ+) ↔ p = q 
Arguments: (p q : Nat.Primes)
Goal: ↑p = ↑q ↔ p = q
-- PNat.gcd_coe
@[simp, norm_cast]
theorem gcd_coe (n m : ℕ+) : (gcd n m : ℕ) = Nat.gcd n m 
Arguments: (n m : ℕ+)
Goal: ↑(n.gcd m) = (↑n).gcd ↑m
-- PNat.lcm_coe
@[simp, norm_cast]
theorem lcm_coe (n m : ℕ+) : (lcm n m : ℕ) = Nat.lcm n m 
Arguments: (n m : ℕ+)
Goal: ↑(n.lcm m) = (↑n).lcm ↑m
-- PNat.gcd_dvd_left
theorem gcd_dvd_left (n m : ℕ+) : gcd n m ∣ n 
Arguments: (n m : ℕ+)
Goal: n.gcd m ∣ n
-- PNat.gcd_dvd_right
theorem gcd_dvd_right (n m : ℕ+) : gcd n m ∣ m 
Arguments: (n m : ℕ+)
Goal: n.gcd m ∣ m
-- PNat.dvd_gcd
theorem dvd_gcd {m n k : ℕ+} (hm : k ∣ m) (hn : k ∣ n) : k ∣ gcd m n 
Arguments: {m n k : ℕ+} (hm : k ∣ m) (hn : k ∣ n)
Goal: k ∣ m.gcd n
-- PNat.dvd_lcm_left
theorem dvd_lcm_left (n m : ℕ+) : n ∣ lcm n m 
Arguments: (n m : ℕ+)
Goal: n ∣ n.lcm m
-- PNat.dvd_lcm_right
theorem dvd_lcm_right (n m : ℕ+) : m ∣ lcm n m 
Arguments: (n m : ℕ+)
Goal: m ∣ n.lcm m
-- PNat.lcm_dvd
theorem lcm_dvd {m n k : ℕ+} (hm : m ∣ k) (hn : n ∣ k) : lcm m n ∣ k 
Arguments: {m n k : ℕ+} (hm : m ∣ k) (hn : n ∣ k)
Goal: m.lcm n ∣ k
-- PNat.gcd_mul_lcm
theorem gcd_mul_lcm (n m : ℕ+) : gcd n m * lcm n m = n * m 
Arguments: (n m : ℕ+)
Goal: n.gcd m * n.lcm m = n * m
-- PNat.eq_one_of_lt_two
theorem eq_one_of_lt_two {n : ℕ+} : n < 2 → n = 1 
Arguments: {n : ℕ+}
Goal: n < 2 → n = 1
-- PNat.Prime.one_lt
theorem Prime.one_lt {p : ℕ+} : p.Prime → 1 < p 
Arguments: {p : ℕ+}
Goal: p.Prime → 1 < p
-- PNat.prime_two
theorem prime_two : (2 : ℕ+).Prime 
Goal: PNat.Prime 2
-- PNat.prime_three
theorem prime_three : (3 : ℕ+).Prime 
Goal: PNat.Prime 3
-- PNat.prime_five
theorem prime_five : (5 : ℕ+).Prime 
Goal: PNat.Prime 5
-- PNat.dvd_prime
theorem dvd_prime {p m : ℕ+} (pp : p.Prime) : m ∣ p ↔ m = 1 ∨ m = p 
Arguments: {p m : ℕ+} (pp : p.Prime)
Goal: m ∣ p ↔ m = 1 ∨ m = p
-- PNat.Prime.ne_one
theorem Prime.ne_one {p : ℕ+} : p.Prime → p ≠ 1 
Arguments: {p : ℕ+}
Goal: p.Prime → p ≠ 1
-- PNat.not_prime_one
@[simp]
theorem not_prime_one : ¬(1 : ℕ+).Prime 
Goal: ¬PNat.Prime 1
-- PNat.Prime.not_dvd_one
theorem Prime.not_dvd_one {p : ℕ+} : p.Prime → ¬p ∣ 1 
Arguments: {p : ℕ+}
Goal: p.Prime → ¬p ∣ 1
-- PNat.exists_prime_and_dvd
theorem exists_prime_and_dvd {n : ℕ+} (hn : n ≠ 1) : ∃ p : ℕ+, p.Prime ∧ p ∣ n 
Arguments: {n : ℕ+} (hn : n ≠ 1)
Goal: ∃ p, p.Prime ∧ p ∣ n
-- PNat.coprime_coe
@[simp, norm_cast]
theorem coprime_coe {m n : ℕ+} : Nat.Coprime ↑m ↑n ↔ m.Coprime n 
Arguments: {m n : ℕ+}
Goal: (↑m).Coprime ↑n ↔ m.Coprime n
-- PNat.Coprime.mul
theorem Coprime.mul {k m n : ℕ+} : m.Coprime k → n.Coprime k → (m * n).Coprime k 
Arguments: {k m n : ℕ+}
Goal: m.Coprime k → n.Coprime k → (m * n).Coprime k
-- PNat.Coprime.mul_right
theorem Coprime.mul_right {k m n : ℕ+} : k.Coprime m → k.Coprime n → k.Coprime (m * n) 
Arguments: {k m n : ℕ+}
Goal: k.Coprime m → k.Coprime n → k.Coprime (m * n)
-- PNat.gcd_comm
theorem gcd_comm {m n : ℕ+} : m.gcd n = n.gcd m 
Arguments: {m n : ℕ+}
Goal: m.gcd n = n.gcd m
-- PNat.gcd_eq_left_iff_dvd
theorem gcd_eq_left_iff_dvd {m n : ℕ+} : m ∣ n ↔ m.gcd n = m 
Arguments: {m n : ℕ+}
Goal: m ∣ n ↔ m.gcd n = m
-- PNat.gcd_eq_right_iff_dvd
theorem gcd_eq_right_iff_dvd {m n : ℕ+} : m ∣ n ↔ n.gcd m = m 
Arguments: {m n : ℕ+}
Goal: m ∣ n ↔ n.gcd m = m
-- PNat.Coprime.gcd_mul_left_cancel
theorem Coprime.gcd_mul_left_cancel (m : ℕ+) {n k : ℕ+} :
    k.Coprime n → (k * m).gcd n = m.gcd n 
Arguments: (m : ℕ+) {n k : ℕ+}
Goal: k.Coprime n → (k * m).gcd n = m.gcd n
-- PNat.Coprime.gcd_mul_right_cancel
theorem Coprime.gcd_mul_right_cancel (m : ℕ+) {n k : ℕ+} :
    k.Coprime n → (m * k).gcd n = m.gcd n 
Arguments: (m : ℕ+) {n k : ℕ+}
Goal: k.Coprime n → (m * k).gcd n = m.gcd n
-- PNat.Coprime.gcd_mul_left_cancel_right
theorem Coprime.gcd_mul_left_cancel_right (m : ℕ+) {n k : ℕ+} :
    k.Coprime m → m.gcd (k * n) = m.gcd n 
Arguments: (m : ℕ+) {n k : ℕ+}
Goal: k.Coprime m → m.gcd (k * n) = m.gcd n
-- PNat.Coprime.gcd_mul_right_cancel_right
theorem Coprime.gcd_mul_right_cancel_right (m : ℕ+) {n k : ℕ+} :
    k.Coprime m → m.gcd (n * k) = m.gcd n 
Arguments: (m : ℕ+) {n k : ℕ+}
Goal: k.Coprime m → m.gcd (n * k) = m.gcd n
-- PNat.one_gcd
@[simp]
theorem one_gcd {n : ℕ+} : gcd 1 n = 1 
Arguments: {n : ℕ+}
Goal: PNat.gcd 1 n = 1
-- PNat.gcd_one
@[simp]
theorem gcd_one {n : ℕ+} : gcd n 1 = 1 
Arguments: {n : ℕ+}
Goal: n.gcd 1 = 1
-- PNat.Coprime.symm
@[symm]
theorem Coprime.symm {m n : ℕ+} : m.Coprime n → n.Coprime m 
Arguments: {m n : ℕ+}
Goal: m.Coprime n → n.Coprime m
-- PNat.one_coprime
@[simp]
theorem one_coprime {n : ℕ+} : (1 : ℕ+).Coprime n 
Arguments: {n : ℕ+}
Goal: PNat.Coprime 1 n
-- PNat.coprime_one
@[simp]
theorem coprime_one {n : ℕ+} : n.Coprime 1 
Arguments: {n : ℕ+}
Goal: n.Coprime 1
-- PNat.Coprime.coprime_dvd_left
theorem Coprime.coprime_dvd_left {m k n : ℕ+} : m ∣ k → k.Coprime n → m.Coprime n 
Arguments: {m k n : ℕ+}
Goal: m ∣ k → k.Coprime n → m.Coprime n
-- PNat.Coprime.factor_eq_gcd_left
theorem Coprime.factor_eq_gcd_left {a b m n : ℕ+} (cop : m.Coprime n) (am : a ∣ m) (bn : b ∣ n) :
    a = (a * b).gcd m 
Arguments: {a b m n : ℕ+} (cop : m.Coprime n) (am : a ∣ m) (bn : b ∣ n)
Goal: a = (a * b).gcd m
-- PNat.Coprime.factor_eq_gcd_right
theorem Coprime.factor_eq_gcd_right {a b m n : ℕ+} (cop : m.Coprime n) (am : a ∣ m) (bn : b ∣ n) :
    a = (b * a).gcd m 
Arguments: {a b m n : ℕ+} (cop : m.Coprime n) (am : a ∣ m) (bn : b ∣ n)
Goal: a = (b * a).gcd m
-- PNat.Coprime.factor_eq_gcd_left_right
theorem Coprime.factor_eq_gcd_left_right {a b m n : ℕ+} (cop : m.Coprime n) (am : a ∣ m)
    (bn : b ∣ n) : a = m.gcd (a * b) 
Arguments: {a b m n : ℕ+} (cop : m.Coprime n) (am : a ∣ m) (bn : b ∣ n)
Goal: a = m.gcd (a * b)
-- PNat.Coprime.factor_eq_gcd_right_right
theorem Coprime.factor_eq_gcd_right_right {a b m n : ℕ+} (cop : m.Coprime n) (am : a ∣ m)
    (bn : b ∣ n) : a = m.gcd (b * a) 
Arguments: {a b m n : ℕ+} (cop : m.Coprime n) (am : a ∣ m) (bn : b ∣ n)
Goal: a = m.gcd (b * a)
-- PNat.Coprime.gcd_mul
theorem Coprime.gcd_mul (k : ℕ+) {m n : ℕ+} (h : m.Coprime n) :
    k.gcd (m * n) = k.gcd m * k.gcd n 
Arguments: (k : ℕ+) {m n : ℕ+} (h : m.Coprime n)
Goal: k.gcd (m * n) = k.gcd m * k.gcd n
-- PNat.gcd_eq_left
theorem gcd_eq_left {m n : ℕ+} : m ∣ n → m.gcd n = m 
Arguments: {m n : ℕ+}
Goal: m ∣ n → m.gcd n = m
-- PNat.Coprime.pow
theorem Coprime.pow {m n : ℕ+} (k l : ℕ) (h : m.Coprime n) : (m ^ k : ℕ).Coprime (n ^ l) 
Arguments: {m n : ℕ+} (k l : ℕ) (h : m.Coprime n)
Goal: (↑m ^ k).Coprime (↑n ^ l)
-- PNat.one_add_natPred
@[simp]
theorem one_add_natPred (n : ℕ+) : 1 + n.natPred = n 
Arguments: (n : ℕ+)
Goal: 1 + n.natPred = ↑n
-- PNat.natPred_add_one
@[simp]
theorem natPred_add_one (n : ℕ+) : n.natPred + 1 = n 
Arguments: (n : ℕ+)
Goal: n.natPred + 1 = ↑n
-- PNat.natPred_strictMono
@[mono]
theorem natPred_strictMono : StrictMono natPred 
Goal: StrictMono PNat.natPred
-- PNat.natPred_monotone
@[mono]
theorem natPred_monotone : Monotone natPred 
Goal: Monotone PNat.natPred
-- PNat.natPred_injective
theorem natPred_injective : Function.Injective natPred 
Goal: Function.Injective PNat.natPred
-- PNat.natPred_lt_natPred
@[simp]
theorem natPred_lt_natPred {m n : ℕ+} : m.natPred < n.natPred ↔ m < n 
Arguments: {m n : ℕ+}
Goal: m.natPred < n.natPred ↔ m < n
-- PNat.natPred_le_natPred
@[simp]
theorem natPred_le_natPred {m n : ℕ+} : m.natPred ≤ n.natPred ↔ m ≤ n 
Arguments: {m n : ℕ+}
Goal: m.natPred ≤ n.natPred ↔ m ≤ n
-- PNat.natPred_inj
@[simp]
theorem natPred_inj {m n : ℕ+} : m.natPred = n.natPred ↔ m = n 
Arguments: {m n : ℕ+}
Goal: m.natPred = n.natPred ↔ m = n
-- PNat.val_ofNat
@[simp, norm_cast]
lemma val_ofNat (n : ℕ) [NeZero n] :
    ((no_index (OfNat.ofNat n) : ℕ+) : ℕ) = OfNat.ofNat n 
Arguments: (n : ℕ) [NeZero n]
Goal: ↑(OfNat.ofNat n) = OfNat.ofNat n
-- PNat.mk_ofNat
@[simp]
lemma mk_ofNat (n : ℕ) (h : 0 < n) :
    @Eq ℕ+ (⟨no_index (OfNat.ofNat n), h⟩ : ℕ+) (haveI : NeZero n := ⟨h.ne'⟩; OfNat.ofNat n) 
Arguments: (n : ℕ) (h : 0 < n)
Goal: ⟨OfNat.ofNat n, h⟩ = OfNat.ofNat n
-- Nat.succPNat_strictMono
@[mono]
theorem succPNat_strictMono : StrictMono succPNat 
Goal: StrictMono Nat.succPNat
-- Nat.succPNat_mono
@[mono]
theorem succPNat_mono : Monotone succPNat 
Goal: Monotone Nat.succPNat
-- Nat.succPNat_lt_succPNat
@[simp]
theorem succPNat_lt_succPNat {m n : ℕ} : m.succPNat < n.succPNat ↔ m < n 
Arguments: {m n : ℕ}
Goal: m.succPNat < n.succPNat ↔ m < n
-- Nat.succPNat_le_succPNat
@[simp]
theorem succPNat_le_succPNat {m n : ℕ} : m.succPNat ≤ n.succPNat ↔ m ≤ n 
Arguments: {m n : ℕ}
Goal: m.succPNat ≤ n.succPNat ↔ m ≤ n
-- Nat.succPNat_injective
theorem succPNat_injective : Function.Injective succPNat 
Goal: Function.Injective Nat.succPNat
-- Nat.succPNat_inj
@[simp]
theorem succPNat_inj {n m : ℕ} : succPNat n = succPNat m ↔ n = m 
Arguments: {n m : ℕ}
Goal: n.succPNat = m.succPNat ↔ n = m
-- PNat.coe_inj
@[simp, norm_cast]
theorem coe_inj {m n : ℕ+} : (m : ℕ) = n ↔ m = n 
Arguments: {m n : ℕ+}
Goal: ↑m = ↑n ↔ m = n
-- PNat.add_coe
@[simp, norm_cast]
theorem add_coe (m n : ℕ+) : ((m + n : ℕ+) : ℕ) = m + n 
Arguments: (m n : ℕ+)
Goal: ↑(m + n) = ↑m + ↑n
-- OrderIso.pnatIsoNat_apply
@[simps! (config := .asFn) apply]
def _root_.OrderIso.pnatIsoNat : ℕ+ ≃o ℕ 
Goal: ⇑OrderIso.pnatIsoNat = PNat.natPred
-- OrderIso.pnatIsoNat_symm_apply
@[simp]
theorem _root_.OrderIso.pnatIsoNat_symm_apply : OrderIso.pnatIsoNat.symm = Nat.succPNat 
Goal: ⇑OrderIso.pnatIsoNat.symm = Nat.succPNat
-- PNat.lt_add_one_iff
theorem lt_add_one_iff : ∀ {a b : ℕ+}, a < b + 1 ↔ a ≤ b 
Arguments: {a b : ℕ+}
Goal: a < b + 1 ↔ a ≤ b
-- PNat.add_one_le_iff
theorem add_one_le_iff : ∀ {a b : ℕ+}, a + 1 ≤ b ↔ a < b 
Arguments: {a b : ℕ+}
Goal: a + 1 ≤ b ↔ a < b
-- PNat.bot_eq_one
@[simp]
theorem bot_eq_one : (⊥ : ℕ+) = 1 
Goal: ⊥ = 1
-- PNat.recOn_one
@[simp]
theorem recOn_one {p} (p1 hp) : @PNat.recOn 1 p p1 hp = p1 
Arguments: {p : ℕ+ → Sort u_1} (p1 : p 1) (hp : (n : ℕ+) → p n → p (n + 1))
Goal: PNat.recOn 1 p1 hp = p1
-- PNat.recOn_succ
@[simp]
theorem recOn_succ (n : ℕ+) {p : ℕ+ → Sort*} (p1 hp) :
    @PNat.recOn (n + 1) p p1 hp = hp n (@PNat.recOn n p p1 hp) 
Arguments: (n : ℕ+) {p : ℕ+ → Sort u_1} (p1 : p 1) (hp : (n : ℕ+) → p n → p (n + 1))
Goal: (n + 1).recOn p1 hp = hp n (n.recOn p1 hp)
-- PNat.ofNat_le_ofNat
@[simp]
theorem ofNat_le_ofNat {m n : ℕ} [NeZero m] [NeZero n] :
    (no_index (OfNat.ofNat m) : ℕ+) ≤ no_index (OfNat.ofNat n) ↔ OfNat.ofNat m ≤ OfNat.ofNat n 
Arguments: {m n : ℕ} [NeZero m] [NeZero n]
Goal: OfNat.ofNat m ≤ OfNat.ofNat n ↔ OfNat.ofNat m ≤ OfNat.ofNat n
-- PNat.ofNat_lt_ofNat
@[simp]
theorem ofNat_lt_ofNat {m n : ℕ} [NeZero m] [NeZero n] :
    (no_index (OfNat.ofNat m) : ℕ+) < no_index (OfNat.ofNat n) ↔ OfNat.ofNat m < OfNat.ofNat n 
Arguments: {m n : ℕ} [NeZero m] [NeZero n]
Goal: OfNat.ofNat m < OfNat.ofNat n ↔ OfNat.ofNat m < OfNat.ofNat n
-- PNat.ofNat_inj
@[simp]
theorem ofNat_inj {m n : ℕ} [NeZero m] [NeZero n] :
    (no_index (OfNat.ofNat m) : ℕ+) = no_index (OfNat.ofNat n) ↔ OfNat.ofNat m = OfNat.ofNat n 
Arguments: {m n : ℕ} [NeZero m] [NeZero n]
Goal: OfNat.ofNat m = OfNat.ofNat n ↔ OfNat.ofNat m = OfNat.ofNat n
-- PNat.mul_coe
@[simp, norm_cast]
theorem mul_coe (m n : ℕ+) : ((m * n : ℕ+) : ℕ) = m * n 
Arguments: (m n : ℕ+)
Goal: ↑(m * n) = ↑m * ↑n
-- PNat.coe_coeMonoidHom
@[simp]
theorem coe_coeMonoidHom : (coeMonoidHom : ℕ+ → ℕ) = Coe.coe 
Goal: ⇑PNat.coeMonoidHom = Coe.coe
-- PNat.le_one_iff
@[simp]
theorem le_one_iff {n : ℕ+} : n ≤ 1 ↔ n = 1 
Arguments: {n : ℕ+}
Goal: n ≤ 1 ↔ n = 1
-- PNat.lt_add_left
theorem lt_add_left (n m : ℕ+) : n < m + n 
Arguments: (n m : ℕ+)
Goal: n < m + n
-- PNat.lt_add_right
theorem lt_add_right (n m : ℕ+) : n < n + m 
Arguments: (n m : ℕ+)
Goal: n < n + m
-- PNat.pow_coe
@[simp, norm_cast]
theorem pow_coe (m : ℕ+) (n : ℕ) : ↑(m ^ n) = (m : ℕ) ^ n 
Arguments: (m : ℕ+) (n : ℕ)
Goal: ↑(m ^ n) = ↑m ^ n
-- PNat.one_lt_of_lt
theorem one_lt_of_lt {a b : ℕ+} (hab : a < b) : 1 < b 
Arguments: {a b : ℕ+} (hab : a < b)
Goal: 1 < b
-- PNat.add_one
theorem add_one (a : ℕ+) : a + 1 = succPNat a 
Arguments: (a : ℕ+)
Goal: a + 1 = (↑a).succPNat
-- PNat.lt_succ_self
theorem lt_succ_self (a : ℕ+) : a < succPNat a 
Arguments: (a : ℕ+)
Goal: a < (↑a).succPNat
-- PNat.sub_coe
theorem sub_coe (a b : ℕ+) : ((a - b : ℕ+) : ℕ) = ite (b < a) (a - b : ℕ) 1 
Arguments: (a b : ℕ+)
Goal: ↑(a - b) = if b < a then ↑a - ↑b else 1
-- PNat.sub_le
theorem sub_le (a b : ℕ+) : a - b ≤ a 
Arguments: (a b : ℕ+)
Goal: a - b ≤ a
-- PNat.le_sub_one_of_lt
theorem le_sub_one_of_lt {a b : ℕ+} (hab : a < b) : a ≤ b - (1 : ℕ+) 
Arguments: {a b : ℕ+} (hab : a < b)
Goal: a ≤ b - 1
-- PNat.add_sub_of_lt
theorem add_sub_of_lt {a b : ℕ+} : a < b → a + (b - a) = b 
Arguments: {a b : ℕ+}
Goal: a < b → a + (b - a) = b
-- PNat.exists_eq_succ_of_ne_one
theorem exists_eq_succ_of_ne_one : ∀ {n : ℕ+} (_ : n ≠ 1), ∃ k : ℕ+, n = k + 1
  
Arguments: {n : ℕ+}
Goal: n ≠ 1 → ∃ k, n = k + 1
-- PNat.modDivAux_spec
theorem modDivAux_spec :
    ∀ (k : ℕ+) (r q : ℕ) (_ : ¬(r = 0 ∧ q = 0)),
      ((modDivAux k r q).1 : ℕ) + k * (modDivAux k r q).2 = r + k * q
  
Arguments: (k : ℕ+) (r q : ℕ)
Goal: ¬(r = 0 ∧ q = 0) → ↑(k.modDivAux r q).1 + ↑k * (k.modDivAux r q).2 = r + ↑k * q
-- PNat.mod_add_div
theorem mod_add_div (m k : ℕ+) : (mod m k + k * div m k : ℕ) = m 
Arguments: (m k : ℕ+)
Goal: ↑(m.mod k) + ↑k * m.div k = ↑m
-- PNat.div_add_mod
theorem div_add_mod (m k : ℕ+) : (k * div m k + mod m k : ℕ) = m 
Arguments: (m k : ℕ+)
Goal: ↑k * m.div k + ↑(m.mod k) = ↑m
-- PNat.mod_add_div'
theorem mod_add_div' (m k : ℕ+) : (mod m k + div m k * k : ℕ) = m 
Arguments: (m k : ℕ+)
Goal: ↑(m.mod k) + m.div k * ↑k = ↑m
-- PNat.div_add_mod'
theorem div_add_mod' (m k : ℕ+) : (div m k * k + mod m k : ℕ) = m 
Arguments: (m k : ℕ+)
Goal: m.div k * ↑k + ↑(m.mod k) = ↑m
-- PNat.mod_le
theorem mod_le (m k : ℕ+) : mod m k ≤ m ∧ mod m k ≤ k 
Arguments: (m k : ℕ+)
Goal: m.mod k ≤ m ∧ m.mod k ≤ k
-- PNat.dvd_iff
theorem dvd_iff {k m : ℕ+} : k ∣ m ↔ (k : ℕ) ∣ (m : ℕ) 
Arguments: {k m : ℕ+}
Goal: k ∣ m ↔ ↑k ∣ ↑m
-- PNat.dvd_iff'
theorem dvd_iff' {k m : ℕ+} : k ∣ m ↔ mod m k = k 
Arguments: {k m : ℕ+}
Goal: k ∣ m ↔ m.mod k = k
-- PNat.le_of_dvd
theorem le_of_dvd {m n : ℕ+} : m ∣ n → m ≤ n 
Arguments: {m n : ℕ+}
Goal: m ∣ n → m ≤ n
-- PNat.mul_div_exact
theorem mul_div_exact {m k : ℕ+} (h : k ∣ m) : k * divExact m k = m 
Arguments: {m k : ℕ+} (h : k ∣ m)
Goal: k * m.divExact k = m
-- PNat.dvd_antisymm
theorem dvd_antisymm {m n : ℕ+} : m ∣ n → n ∣ m → m = n 
Arguments: {m n : ℕ+}
Goal: m ∣ n → n ∣ m → m = n
-- PNat.dvd_one_iff
theorem dvd_one_iff (n : ℕ+) : n ∣ 1 ↔ n = 1 
Arguments: (n : ℕ+)
Goal: n ∣ 1 ↔ n = 1
-- PNat.pos_of_div_pos
theorem pos_of_div_pos {n : ℕ+} {a : ℕ} (h : a ∣ n) : 0 < a 
Arguments: {n : ℕ+} {a : ℕ} (h : a ∣ ↑n)
Goal: 0 < a
-- Fin.mem_piFinset_succ
lemma mem_piFinset_succ {x : ∀ i, α i} {s : ∀ i, Finset (α i)} :
    x ∈ piFinset s ↔ x 0 ∈ s 0 ∧ tail x ∈ piFinset (tail s) 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u_1} {x : (i : Fin (n + 1)) → α i} {s : (i : Fin (n + 1)) → Finset (α i)}
Goal: x ∈ Fintype.piFinset s ↔ x 0 ∈ s 0 ∧ Fin.tail x ∈ Fintype.piFinset (Fin.tail s)
-- Fin.mem_piFinset_succ'
lemma mem_piFinset_succ' {x : ∀ i, α i} {s : ∀ i, Finset (α i)} :
    x ∈ piFinset s ↔ init x ∈ piFinset (init s) ∧ x (last n) ∈ s (last n) 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u_1} {x : (i : Fin (n + 1)) → α i} {s : (i : Fin (n + 1)) → Finset (α i)}
Goal: x ∈ Fintype.piFinset s ↔ Fin.init x ∈ Fintype.piFinset (Fin.init s) ∧ x (Fin.last n) ∈ s (Fin.last n)
-- Fin.cons_mem_piFinset_cons
lemma cons_mem_piFinset_cons {x₀ : α 0} {x : ∀ i : Fin n, α i.succ}
    {s₀ : Finset (α 0)} {s : ∀ i : Fin n, Finset (α i.succ)} :
    cons x₀ x ∈ piFinset (cons s₀ s) ↔ x₀ ∈ s₀ ∧ x ∈ piFinset s 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u_1} {x₀ : α 0} {x : (i : Fin n) → α i.succ} {s₀ : Finset (α 0)} {s : (i : Fin n) → Finset (α i.succ)}
Goal: Fin.cons x₀ x ∈ Fintype.piFinset (Fin.cons s₀ s) ↔ x₀ ∈ s₀ ∧ x ∈ Fintype.piFinset s
-- Fin.snoc_mem_piFinset_snoc
lemma snoc_mem_piFinset_snoc {x : ∀ i : Fin n, α i.castSucc} {xₙ : α (.last n)}
    {s : ∀ i : Fin n, Finset (α i.castSucc)} {sₙ : Finset (α $ .last n)} :
    snoc x xₙ ∈ piFinset (snoc s sₙ) ↔ x ∈ piFinset s ∧ xₙ ∈ sₙ 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u_1} {x : (i : Fin n) → α i.castSucc} {xₙ : α (Fin.last n)} {s : (i : Fin n) → Finset (α i.castSucc)} {sₙ : Finset (α (Fin.last n))}
Goal: Fin.snoc x xₙ ∈ Fintype.piFinset (Fin.snoc s sₙ) ↔ x ∈ Fintype.piFinset s ∧ xₙ ∈ sₙ
-- Fin2.IsLT.h
class IsLT (m n : ℕ) : Prop where
    h : m < n
Arguments: {m n : ℕ} [self : Fin2.IsLT m n]
Goal: m < n
-- Fin2.rev_last
@[simp] lemma rev_last {n} : rev (@last n) = fz 
Arguments: {n : ℕ}
Goal: Fin2.last.rev = Fin2.fz
-- Fin2.rev_castSucc
@[simp] lemma rev_castSucc {n} (i : Fin2 n) : rev (castSucc i) = fs (rev i) 
Arguments: {n : ℕ} (i : Fin2 n)
Goal: i.castSucc.rev = i.rev.fs
-- Fin2.rev_rev
@[simp] lemma rev_rev {n} (i : Fin2 n) : i.rev.rev = i 
Arguments: {n : ℕ} (i : Fin2 n)
Goal: i.rev.rev = i
-- Fin2.rev_involutive
theorem rev_involutive {n} : Function.Involutive (@rev n) 
Arguments: {n : ℕ}
Goal: Function.Involutive Fin2.rev
-- Option.map₂_def
theorem map₂_def {α β γ : Type u} (f : α → β → γ) (a : Option α) (b : Option β) :
    map₂ f a b = f <$> a <*> b 
Arguments: {α β γ : Type u} (f : α → β → γ) (a : Option α) (b : Option β)
Goal: Option.map₂ f a b = Seq.seq (f <$> a) fun x => b
-- Option.map₂_some_some
theorem map₂_some_some (f : α → β → γ) (a : α) (b : β) : map₂ f (some a) (some b) = f a b 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β → γ) (a : α) (b : β)
Goal: Option.map₂ f (some a) (some b) = some (f a b)
-- Option.map₂_coe_coe
theorem map₂_coe_coe (f : α → β → γ) (a : α) (b : β) : map₂ f a b = f a b 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β → γ) (a : α) (b : β)
Goal: Option.map₂ f (some a) (some b) = some (f a b)
-- Option.map₂_none_left
@[simp]
theorem map₂_none_left (f : α → β → γ) (b : Option β) : map₂ f none b = none 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β → γ) (b : Option β)
Goal: Option.map₂ f none b = none
-- Option.map₂_none_right
@[simp]
theorem map₂_none_right (f : α → β → γ) (a : Option α) : map₂ f a none = none 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β → γ) (a : Option α)
Goal: Option.map₂ f a none = none
-- Option.map₂_coe_left
@[simp]
theorem map₂_coe_left (f : α → β → γ) (a : α) (b : Option β) : map₂ f a b = b.map fun b => f a b 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β → γ) (a : α) (b : Option β)
Goal: Option.map₂ f (some a) b = Option.map (fun b => f a b) b
-- Option.map₂_coe_right
@[simp]
theorem map₂_coe_right (f : α → β → γ) (a : Option α) (b : β) :
    map₂ f a b = a.map fun a => f a b 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β → γ) (a : Option α) (b : β)
Goal: Option.map₂ f a (some b) = Option.map (fun a => f a b) a
-- Option.mem_map₂_iff
theorem mem_map₂_iff {c : γ} : c ∈ map₂ f a b ↔ ∃ a' b', a' ∈ a ∧ b' ∈ b ∧ f a' b' = c 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β → γ} {a : Option α} {b : Option β} {c : γ}
Goal: c ∈ Option.map₂ f a b ↔ ∃ a' b', a' ∈ a ∧ b' ∈ b ∧ f a' b' = c
-- Option.map₂_eq_none_iff
@[simp]
theorem map₂_eq_none_iff : map₂ f a b = none ↔ a = none ∨ b = none 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β → γ} {a : Option α} {b : Option β}
Goal: Option.map₂ f a b = none ↔ a = none ∨ b = none
-- Option.map₂_swap
theorem map₂_swap (f : α → β → γ) (a : Option α) (b : Option β) :
    map₂ f a b = map₂ (fun a b => f b a) b a 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β → γ) (a : Option α) (b : Option β)
Goal: Option.map₂ f a b = Option.map₂ (fun a b => f b a) b a
-- Option.map_map₂
theorem map_map₂ (f : α → β → γ) (g : γ → δ) :
    (map₂ f a b).map g = map₂ (fun a b => g (f a b)) a b 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {a : Option α} {b : Option β} (f : α → β → γ) (g : γ → δ)
Goal: Option.map g (Option.map₂ f a b) = Option.map₂ (fun a b => g (f a b)) a b
-- Option.map₂_map_left
theorem map₂_map_left (f : γ → β → δ) (g : α → γ) :
    map₂ f (a.map g) b = map₂ (fun a b => f (g a) b) a b 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {a : Option α} {b : Option β} (f : γ → β → δ) (g : α → γ)
Goal: Option.map₂ f (Option.map g a) b = Option.map₂ (fun a b => f (g a) b) a b
-- Option.map₂_map_right
theorem map₂_map_right (f : α → γ → δ) (g : β → γ) :
    map₂ f a (b.map g) = map₂ (fun a b => f a (g b)) a b 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {a : Option α} {b : Option β} (f : α → γ → δ) (g : β → γ)
Goal: Option.map₂ f a (Option.map g b) = Option.map₂ (fun a b => f a (g b)) a b
-- Option.map₂_curry
@[simp]
theorem map₂_curry (f : α × β → γ) (a : Option α) (b : Option β) :
    map₂ (curry f) a b = Option.map f (map₂ Prod.mk a b) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α × β → γ) (a : Option α) (b : Option β)
Goal: Option.map₂ (Function.curry f) a b = Option.map f (Option.map₂ Prod.mk a b)
-- Option.map_uncurry
@[simp]
theorem map_uncurry (f : α → β → γ) (x : Option (α × β)) :
    x.map (uncurry f) = map₂ f (x.map Prod.fst) (x.map Prod.snd) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β → γ) (x : Option (α × β))
Goal: Option.map (Function.uncurry f) x = Option.map₂ f (Option.map Prod.fst x) (Option.map Prod.snd x)
-- Option.map₂_assoc
theorem map₂_assoc {f : δ → γ → ε} {g : α → β → δ} {f' : α → ε' → ε} {g' : β → γ → ε'}
    (h_assoc : ∀ a b c, f (g a b) c = f' a (g' b c)) :
    map₂ f (map₂ g a b) c = map₂ f' a (map₂ g' b c) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {a : Option α} {b : Option β} {c : Option γ} {ε : Type u_8} {ε' : Type u_9} {f : δ → γ → ε} {g : α → β → δ} {f' : α → ε' → ε} {g' : β → γ → ε'} (h_assoc : ∀ (a : α) (b : β) (c : γ), f (g a b) c = f' a (g' b c))
Goal: Option.map₂ f (Option.map₂ g a b) c = Option.map₂ f' a (Option.map₂ g' b c)
-- Option.map₂_comm
theorem map₂_comm {g : β → α → γ} (h_comm : ∀ a b, f a b = g b a) : map₂ f a b = map₂ g b a 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β → γ} {a : Option α} {b : Option β} {g : β → α → γ} (h_comm : ∀ (a : α) (b : β), f a b = g b a)
Goal: Option.map₂ f a b = Option.map₂ g b a
-- Option.map₂_left_comm
theorem map₂_left_comm {f : α → δ → ε} {g : β → γ → δ} {f' : α → γ → δ'} {g' : β → δ' → ε}
    (h_left_comm : ∀ a b c, f a (g b c) = g' b (f' a c)) :
    map₂ f a (map₂ g b c) = map₂ g' b (map₂ f' a c) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {a : Option α} {b : Option β} {c : Option γ} {δ' : Type u_7} {ε : Type u_8} {f : α → δ → ε} {g : β → γ → δ} {f' : α → γ → δ'} {g' : β → δ' → ε} (h_left_comm : ∀ (a : α) (b : β) (c : γ), f a (g b c) = g' b (f' a c))
Goal: Option.map₂ f a (Option.map₂ g b c) = Option.map₂ g' b (Option.map₂ f' a c)
-- Option.map₂_right_comm
theorem map₂_right_comm {f : δ → γ → ε} {g : α → β → δ} {f' : α → γ → δ'} {g' : δ' → β → ε}
    (h_right_comm : ∀ a b c, f (g a b) c = g' (f' a c) b) :
    map₂ f (map₂ g a b) c = map₂ g' (map₂ f' a c) b 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {a : Option α} {b : Option β} {c : Option γ} {δ' : Type u_7} {ε : Type u_8} {f : δ → γ → ε} {g : α → β → δ} {f' : α → γ → δ'} {g' : δ' → β → ε} (h_right_comm : ∀ (a : α) (b : β) (c : γ), f (g a b) c = g' (f' a c) b)
Goal: Option.map₂ f (Option.map₂ g a b) c = Option.map₂ g' (Option.map₂ f' a c) b
-- Option.map_map₂_distrib
theorem map_map₂_distrib {g : γ → δ} {f' : α' → β' → δ} {g₁ : α → α'} {g₂ : β → β'}
    (h_distrib : ∀ a b, g (f a b) = f' (g₁ a) (g₂ b)) :
    (map₂ f a b).map g = map₂ f' (a.map g₁) (b.map g₂) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {f : α → β → γ} {a : Option α} {b : Option β} {α' : Type u_5} {β' : Type u_6} {g : γ → δ} {f' : α' → β' → δ} {g₁ : α → α'} {g₂ : β → β'} (h_distrib : ∀ (a : α) (b : β), g (f a b) = f' (g₁ a) (g₂ b))
Goal: Option.map g (Option.map₂ f a b) = Option.map₂ f' (Option.map g₁ a) (Option.map g₂ b)