ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Zsqrtd.norm_one
@[simp]
theorem norm_one : norm (1 : ℤ√d) = 1 
Arguments: {d : ℤ}
Goal: Zsqrtd.norm 1 = 1
-- Zsqrtd.norm_intCast
@[simp]
theorem norm_intCast (n : ℤ) : norm (n : ℤ√d) = n * n 
Arguments: {d : ℤ} (n : ℤ)
Goal: (↑n).norm = n * n
-- Zsqrtd.norm_natCast
@[simp]
theorem norm_natCast (n : ℕ) : norm (n : ℤ√d) = n * n 
Arguments: {d : ℤ} (n : ℕ)
Goal: (↑n).norm = ↑n * ↑n
-- Zsqrtd.norm_mul
@[simp]
theorem norm_mul (n m : ℤ√d) : norm (n * m) = norm n * norm m 
Arguments: {d : ℤ} (n m : ℤ√d)
Goal: (n * m).norm = n.norm * m.norm
-- Zsqrtd.norm_eq_mul_conj
theorem norm_eq_mul_conj (n : ℤ√d) : (norm n : ℤ√d) = n * star n 
Arguments: {d : ℤ} (n : ℤ√d)
Goal: ↑n.norm = n * star n
-- Zsqrtd.norm_neg
@[simp]
theorem norm_neg (x : ℤ√d) : (-x).norm = x.norm 
Arguments: {d : ℤ} (x : ℤ√d)
Goal: (-x).norm = x.norm
-- Zsqrtd.norm_conj
@[simp]
theorem norm_conj (x : ℤ√d) : (star x).norm = x.norm 
Arguments: {d : ℤ} (x : ℤ√d)
Goal: (star x).norm = x.norm
-- Zsqrtd.norm_nonneg
theorem norm_nonneg (hd : d ≤ 0) (n : ℤ√d) : 0 ≤ n.norm 
Arguments: {d : ℤ} (hd : d ≤ 0) (n : ℤ√d)
Goal: 0 ≤ n.norm
-- Zsqrtd.norm_eq_one_iff
theorem norm_eq_one_iff {x : ℤ√d} : x.norm.natAbs = 1 ↔ IsUnit x 
Arguments: {d : ℤ} {x : ℤ√d}
Goal: x.norm.natAbs = 1 ↔ IsUnit x
-- Zsqrtd.isUnit_iff_norm_isUnit
theorem isUnit_iff_norm_isUnit {d : ℤ} (z : ℤ√d) : IsUnit z ↔ IsUnit z.norm 
Arguments: {d : ℤ} (z : ℤ√d)
Goal: IsUnit z ↔ IsUnit z.norm
-- Zsqrtd.norm_eq_one_iff'
theorem norm_eq_one_iff' {d : ℤ} (hd : d ≤ 0) (z : ℤ√d) : z.norm = 1 ↔ IsUnit z 
Arguments: {d : ℤ} (hd : d ≤ 0) (z : ℤ√d)
Goal: z.norm = 1 ↔ IsUnit z
-- Zsqrtd.norm_eq_zero_iff
theorem norm_eq_zero_iff {d : ℤ} (hd : d < 0) (z : ℤ√d) : z.norm = 0 ↔ z = 0 
Arguments: {d : ℤ} (hd : d < 0) (z : ℤ√d)
Goal: z.norm = 0 ↔ z = 0
-- Zsqrtd.norm_eq_of_associated
theorem norm_eq_of_associated {d : ℤ} (hd : d ≤ 0) {x y : ℤ√d} (h : Associated x y) :
    x.norm = y.norm 
Arguments: {d : ℤ} (hd : d ≤ 0) {x y : ℤ√d} (h : Associated x y)
Goal: x.norm = y.norm
-- Zsqrtd.nonneg_cases
theorem nonneg_cases : ∀ {a : ℤ√d}, Nonneg a → ∃ x y : ℕ, a = ⟨x, y⟩ ∨ a = ⟨x, -y⟩ ∨ a = ⟨-x, y⟩
  
Arguments: {d : ℕ} {a : ℤ√↑d}
Goal: a.Nonneg → ∃ x y, a = { re := ↑x, im := ↑y } ∨ a = { re := ↑x, im := -↑y } ∨ a = { re := -↑x, im := ↑y }
-- Zsqrtd.nonneg_add_lem
theorem nonneg_add_lem {x y z w : ℕ} (xy : Nonneg (⟨x, -y⟩ : ℤ√d)) (zw : Nonneg (⟨-z, w⟩ : ℤ√d)) :
    Nonneg (⟨x, -y⟩ + ⟨-z, w⟩ : ℤ√d) 
Arguments: {d x y z w : ℕ} (xy : { re := ↑x, im := -↑y }.Nonneg) (zw : { re := -↑z, im := ↑w }.Nonneg)
Goal: ({ re := ↑x, im := -↑y } + { re := -↑z, im := ↑w }).Nonneg
-- Zsqrtd.Nonneg.add
theorem Nonneg.add {a b : ℤ√d} (ha : Nonneg a) (hb : Nonneg b) : Nonneg (a + b) 
Arguments: {d : ℕ} {a b : ℤ√↑d} (ha : a.Nonneg) (hb : b.Nonneg)
Goal: (a + b).Nonneg
-- Zsqrtd.nonneg_iff_zero_le
theorem nonneg_iff_zero_le {a : ℤ√d} : Nonneg a ↔ 0 ≤ a 
Arguments: {d : ℕ} {a : ℤ√↑d}
Goal: a.Nonneg ↔ 0 ≤ a
-- Zsqrtd.le_of_le_le
theorem le_of_le_le {x y z w : ℤ} (xz : x ≤ z) (yw : y ≤ w) : (⟨x, y⟩ : ℤ√d) ≤ ⟨z, w⟩ 
Arguments: {d : ℕ} {x y z w : ℤ} (xz : x ≤ z) (yw : y ≤ w)
Goal: { re := x, im := y } ≤ { re := z, im := w }
-- Zsqrtd.nonneg_total
protected theorem nonneg_total : ∀ a : ℤ√d, Nonneg a ∨ Nonneg (-a)
  
Arguments: {d : ℕ} (a : ℤ√↑d)
Goal: a.Nonneg ∨ (-a).Nonneg
-- Zsqrtd.le_total
protected theorem le_total (a b : ℤ√d) : a ≤ b ∨ b ≤ a 
Arguments: {d : ℕ} (a b : ℤ√↑d)
Goal: a ≤ b ∨ b ≤ a
-- Zsqrtd.le_arch
theorem le_arch (a : ℤ√d) : ∃ n : ℕ, a ≤ n 
Arguments: {d : ℕ} (a : ℤ√↑d)
Goal: ∃ n, a ≤ ↑n
-- Zsqrtd.add_le_add_left
protected theorem add_le_add_left (a b : ℤ√d) (ab : a ≤ b) (c : ℤ√d) : c + a ≤ c + b 
Arguments: {d : ℕ} (a b : ℤ√↑d) (ab : a ≤ b) (c : ℤ√↑d)
Goal: c + a ≤ c + b
-- Zsqrtd.le_of_add_le_add_left
protected theorem le_of_add_le_add_left (a b c : ℤ√d) (h : c + a ≤ c + b) : a ≤ b 
Arguments: {d : ℕ} (a b c : ℤ√↑d) (h : c + a ≤ c + b)
Goal: a ≤ b
-- Zsqrtd.add_lt_add_left
protected theorem add_lt_add_left (a b : ℤ√d) (h : a < b) (c) : c + a < c + b 
Arguments: {d : ℕ} (a b : ℤ√↑d) (h : a < b) (c : ℤ√↑d)
Goal: c + a < c + b
-- Zsqrtd.nonneg_smul
theorem nonneg_smul {a : ℤ√d} {n : ℕ} (ha : Nonneg a) : Nonneg ((n : ℤ√d) * a) 
Arguments: {d : ℕ} {a : ℤ√↑d} {n : ℕ} (ha : a.Nonneg)
Goal: (↑n * a).Nonneg
-- Zsqrtd.nonneg_muld
theorem nonneg_muld {a : ℤ√d} (ha : Nonneg a) : Nonneg (sqrtd * a) 
Arguments: {d : ℕ} {a : ℤ√↑d} (ha : a.Nonneg)
Goal: (Zsqrtd.sqrtd * a).Nonneg
-- Zsqrtd.nonneg_mul_lem
theorem nonneg_mul_lem {x y : ℕ} {a : ℤ√d} (ha : Nonneg a) : Nonneg (⟨x, y⟩ * a) 
Arguments: {d x y : ℕ} {a : ℤ√↑d} (ha : a.Nonneg)
Goal: ({ re := ↑x, im := ↑y } * a).Nonneg
-- Zsqrtd.nonneg_mul
theorem nonneg_mul {a b : ℤ√d} (ha : Nonneg a) (hb : Nonneg b) : Nonneg (a * b) 
Arguments: {d : ℕ} {a b : ℤ√↑d} (ha : a.Nonneg) (hb : b.Nonneg)
Goal: (a * b).Nonneg
-- Zsqrtd.mul_nonneg
protected theorem mul_nonneg (a b : ℤ√d) : 0 ≤ a → 0 ≤ b → 0 ≤ a * b 
Arguments: {d : ℕ} (a b : ℤ√↑d)
Goal: 0 ≤ a → 0 ≤ b → 0 ≤ a * b
-- Zsqrtd.not_sqLe_succ
theorem not_sqLe_succ (c d y) (h : 0 < c) : ¬SqLe (y + 1) c 0 d 
Arguments: (c d y : ℕ) (h : 0 < c)
Goal: ¬Zsqrtd.SqLe (y + 1) c 0 d
-- Zsqrtd.Nonsquare.ns'
class Nonsquare (x : ℕ) : Prop where
  ns' : ∀ n : ℕ, x ≠ n * n
Arguments: {x : ℕ} [self : Zsqrtd.Nonsquare x] (n : ℕ)
Goal: x ≠ n * n
-- Zsqrtd.Nonsquare.ns
theorem Nonsquare.ns (x : ℕ) [Nonsquare x] : ∀ n : ℕ, x ≠ n * n 
Arguments: (x : ℕ) [Zsqrtd.Nonsquare x] (n : ℕ)
Goal: x ≠ n * n
-- Zsqrtd.d_pos
theorem d_pos : 0 < d 
Arguments: {d : ℕ} [dnsq : Zsqrtd.Nonsquare d]
Goal: 0 < d
-- Zsqrtd.divides_sq_eq_zero
theorem divides_sq_eq_zero {x y} (h : x * x = d * y * y) : x = 0 ∧ y = 0 
Arguments: {d : ℕ} [dnsq : Zsqrtd.Nonsquare d] {x y : ℕ} (h : x * x = d * y * y)
Goal: x = 0 ∧ y = 0
-- Zsqrtd.divides_sq_eq_zero_z
theorem divides_sq_eq_zero_z {x y : ℤ} (h : x * x = d * y * y) : x = 0 ∧ y = 0 
Arguments: {d : ℕ} [dnsq : Zsqrtd.Nonsquare d] {x y : ℤ} (h : x * x = ↑d * y * y)
Goal: x = 0 ∧ y = 0
-- Zsqrtd.not_divides_sq
theorem not_divides_sq (x y) : (x + 1) * (x + 1) ≠ d * (y + 1) * (y + 1) 
Arguments: {d : ℕ} [dnsq : Zsqrtd.Nonsquare d] (x y : ℕ)
Goal: (x + 1) * (x + 1) ≠ d * (y + 1) * (y + 1)
-- Zsqrtd.nonneg_antisymm
theorem nonneg_antisymm : ∀ {a : ℤ√d}, Nonneg a → Nonneg (-a) → a = 0
  
Arguments: {d : ℕ} [dnsq : Zsqrtd.Nonsquare d] {a : ℤ√↑d}
Goal: a.Nonneg → (-a).Nonneg → a = 0
-- Zsqrtd.le_antisymm
theorem le_antisymm {a b : ℤ√d} (ab : a ≤ b) (ba : b ≤ a) : a = b 
Arguments: {d : ℕ} [dnsq : Zsqrtd.Nonsquare d] {a b : ℤ√↑d} (ab : a ≤ b) (ba : b ≤ a)
Goal: a = b
-- Zsqrtd.eq_zero_or_eq_zero_of_mul_eq_zero
protected theorem eq_zero_or_eq_zero_of_mul_eq_zero : ∀ {a b : ℤ√d}, a * b = 0 → a = 0 ∨ b = 0
  
Arguments: {d : ℕ} [dnsq : Zsqrtd.Nonsquare d] {a b : ℤ√↑d}
Goal: a * b = 0 → a = 0 ∨ b = 0
-- Zsqrtd.mul_pos
protected theorem mul_pos (a b : ℤ√d) (a0 : 0 < a) (b0 : 0 < b) : 0 < a * b 
Arguments: {d : ℕ} [dnsq : Zsqrtd.Nonsquare d] (a b : ℤ√↑d) (a0 : 0 < a) (b0 : 0 < b)
Goal: 0 < a * b
-- Zsqrtd.norm_eq_zero
theorem norm_eq_zero {d : ℤ} (h_nonsquare : ∀ n : ℤ, d ≠ n * n) (a : ℤ√d) : norm a = 0 ↔ a = 0 
Arguments: {d : ℤ} (h_nonsquare : ∀ (n : ℤ), d ≠ n * n) (a : ℤ√d)
Goal: a.norm = 0 ↔ a = 0
-- Zsqrtd.hom_ext
@[ext]
theorem hom_ext [Ring R] {d : ℤ} (f g : ℤ√d →+* R) (h : f sqrtd = g sqrtd) : f = g 
Arguments: {R : Type} [Ring R] {d : ℤ} (f g : ℤ√d →+* R) (h : f Zsqrtd.sqrtd = g Zsqrtd.sqrtd)
Goal: f = g
-- Zsqrtd.lift_symm_apply_coe
@[simps]
def lift {d : ℤ} : { r : R // r * r = ↑d } ≃ (ℤ√d →+* R) 
Arguments: {R : Type} [CommRing R] {d : ℤ} (f : ℤ√d →+* R)
Goal: ↑(Zsqrtd.lift.symm f) = f Zsqrtd.sqrtd
-- Zsqrtd.lift_apply_apply
@[simps]
def lift {d : ℤ} : { r : R // r * r = ↑d } ≃ (ℤ√d →+* R) 
Arguments: {R : Type} [CommRing R] {d : ℤ} (r : { r // r * r = ↑d }) (a : ℤ√d)
Goal: (Zsqrtd.lift r) a = ↑a.re + ↑a.im * ↑r
-- Zsqrtd.lift_injective
theorem lift_injective [CharZero R] {d : ℤ} (r : { r : R // r * r = ↑d })
    (hd : ∀ n : ℤ, d ≠ n * n) : Function.Injective (lift r) 
Arguments: {R : Type} [CommRing R] [CharZero R] {d : ℤ} (r : { r // r * r = ↑d }) (hd : ∀ (n : ℤ), d ≠ n * n)
Goal: Function.Injective ⇑(Zsqrtd.lift r)
-- Zsqrtd.norm_eq_one_iff_mem_unitary
theorem norm_eq_one_iff_mem_unitary {d : ℤ} {a : ℤ√d} : a.norm = 1 ↔ a ∈ unitary (ℤ√d) 
Arguments: {d : ℤ} {a : ℤ√d}
Goal: a.norm = 1 ↔ a ∈ unitary (ℤ√d)
-- Zsqrtd.mker_norm_eq_unitary
theorem mker_norm_eq_unitary {d : ℤ} : MonoidHom.mker (@normMonoidHom d) = unitary (ℤ√d) 
Arguments: {d : ℤ}
Goal: MonoidHom.mker Zsqrtd.normMonoidHom = unitary (ℤ√d)
-- ArithmeticFunction.toFun_eq
@[simp]
theorem toFun_eq (f : ArithmeticFunction R) : f.toFun = f 
Arguments: {R : Type u_1} [Zero R] (f : ArithmeticFunction R)
Goal: f.toFun = ⇑f
-- ArithmeticFunction.coe_mk
@[simp]
theorem coe_mk (f : ℕ → R) (hf) : @DFunLike.coe (ArithmeticFunction R) _ _ _
    (ZeroHom.mk f hf) = f 
Arguments: {R : Type u_1} [Zero R] (f : ℕ → R) (hf : f 0 = 0)
Goal: ⇑{ toFun := f, map_zero' := hf } = f
-- ArithmeticFunction.map_zero
@[simp]
theorem map_zero {f : ArithmeticFunction R} : f 0 = 0 
Arguments: {R : Type u_1} [Zero R] {f : ArithmeticFunction R}
Goal: f 0 = 0
-- ArithmeticFunction.coe_inj
theorem coe_inj {f g : ArithmeticFunction R} : (f : ℕ → R) = g ↔ f = g 
Arguments: {R : Type u_1} [Zero R] {f g : ArithmeticFunction R}
Goal: ⇑f = ⇑g ↔ f = g
-- ArithmeticFunction.zero_apply
@[simp]
theorem zero_apply {x : ℕ} : (0 : ArithmeticFunction R) x = 0 
Arguments: {R : Type u_1} [Zero R] {x : ℕ}
Goal: 0 x = 0
-- ArithmeticFunction.ext
@[ext]
theorem ext ⦃f g : ArithmeticFunction R⦄ (h : ∀ x, f x = g x) : f = g 
Arguments: {R : Type u_1} [Zero R] ⦃f g : ArithmeticFunction R⦄ (h : ∀ (x : ℕ), f x = g x)
Goal: f = g
-- ArithmeticFunction.ext_iff
theorem ext_iff {f g : ArithmeticFunction R} : f = g ↔ ∀ x, f x = g x 
Arguments: {R : Type u_1} [Zero R] {f g : ArithmeticFunction R}
Goal: f = g ↔ ∀ (x : ℕ), f x = g x
-- ArithmeticFunction.one_apply
theorem one_apply {x : ℕ} : (1 : ArithmeticFunction R) x = ite (x = 1) 1 0 
Arguments: {R : Type u_1} [Zero R] [One R] {x : ℕ}
Goal: 1 x = if x = 1 then 1 else 0
-- ArithmeticFunction.one_one
@[simp]
theorem one_one : (1 : ArithmeticFunction R) 1 = 1 
Arguments: {R : Type u_1} [Zero R] [One R]
Goal: 1 1 = 1
-- ArithmeticFunction.one_apply_ne
@[simp]
theorem one_apply_ne {x : ℕ} (h : x ≠ 1) : (1 : ArithmeticFunction R) x = 0 
Arguments: {R : Type u_1} [Zero R] [One R] {x : ℕ} (h : x ≠ 1)
Goal: 1 x = 0
-- ArithmeticFunction.natCoe_nat
@[simp]
theorem natCoe_nat (f : ArithmeticFunction ℕ) : natToArithmeticFunction f = f 
Arguments: (f : ArithmeticFunction ℕ)
Goal: ↑f = f
-- ArithmeticFunction.natCoe_apply
@[simp]
theorem natCoe_apply [AddMonoidWithOne R] {f : ArithmeticFunction ℕ} {x : ℕ} :
    (f : ArithmeticFunction R) x = f x 
Arguments: {R : Type u_1} [AddMonoidWithOne R] {f : ArithmeticFunction ℕ} {x : ℕ}
Goal: ↑f x = ↑(f x)
-- ArithmeticFunction.intCoe_int
@[simp]
theorem intCoe_int (f : ArithmeticFunction ℤ) : ofInt f = f 
Arguments: (f : ArithmeticFunction ℤ)
Goal: ↑f = f
-- ArithmeticFunction.intCoe_apply
@[simp]
theorem intCoe_apply [AddGroupWithOne R] {f : ArithmeticFunction ℤ} {x : ℕ} :
    (f : ArithmeticFunction R) x = f x 
Arguments: {R : Type u_1} [AddGroupWithOne R] {f : ArithmeticFunction ℤ} {x : ℕ}
Goal: ↑f x = ↑(f x)
-- ArithmeticFunction.coe_coe
@[simp]
theorem coe_coe [AddGroupWithOne R] {f : ArithmeticFunction ℕ} :
    ((f : ArithmeticFunction ℤ) : ArithmeticFunction R) = (f : ArithmeticFunction R) 
Arguments: {R : Type u_1} [AddGroupWithOne R] {f : ArithmeticFunction ℕ}
Goal: ↑↑f = ↑f
-- ArithmeticFunction.natCoe_one
@[simp]
theorem natCoe_one [AddMonoidWithOne R] :
    ((1 : ArithmeticFunction ℕ) : ArithmeticFunction R) = 1 
Arguments: {R : Type u_1} [AddMonoidWithOne R]
Goal: ↑1 = 1
-- ArithmeticFunction.intCoe_one
@[simp]
theorem intCoe_one [AddGroupWithOne R] : ((1 : ArithmeticFunction ℤ) :
    ArithmeticFunction R) = 1 
Arguments: {R : Type u_1} [AddGroupWithOne R]
Goal: ↑1 = 1
-- ArithmeticFunction.add_apply
@[simp]
theorem add_apply {f g : ArithmeticFunction R} {n : ℕ} : (f + g) n = f n + g n 
Arguments: {R : Type u_1} [AddMonoid R] {f g : ArithmeticFunction R} {n : ℕ}
Goal: (f + g) n = f n + g n
-- ArithmeticFunction.smul_apply
@[simp]
theorem smul_apply {f : ArithmeticFunction R} {g : ArithmeticFunction M} {n : ℕ} :
    (f • g) n = ∑ x ∈ divisorsAntidiagonal n, f x.fst • g x.snd 
Arguments: {R : Type u_1} {M : Type u_2} [Zero R] [AddCommMonoid M] [SMul R M] {f : ArithmeticFunction R} {g : ArithmeticFunction M} {n : ℕ}
Goal: (f • g) n = ∑ x ∈ n.divisorsAntidiagonal, f x.1 • g x.2
-- ArithmeticFunction.mul_apply
@[simp]
theorem mul_apply [Semiring R] {f g : ArithmeticFunction R} {n : ℕ} :
    (f * g) n = ∑ x ∈ divisorsAntidiagonal n, f x.fst * g x.snd 
Arguments: {R : Type u_1} [Semiring R] {f g : ArithmeticFunction R} {n : ℕ}
Goal: (f * g) n = ∑ x ∈ n.divisorsAntidiagonal, f x.1 * g x.2
-- ArithmeticFunction.mul_apply_one
theorem mul_apply_one [Semiring R] {f g : ArithmeticFunction R} : (f * g) 1 = f 1 * g 1 
Arguments: {R : Type u_1} [Semiring R] {f g : ArithmeticFunction R}
Goal: (f * g) 1 = f 1 * g 1
-- ArithmeticFunction.natCoe_mul
@[simp, norm_cast]
theorem natCoe_mul [Semiring R] {f g : ArithmeticFunction ℕ} :
    (↑(f * g) : ArithmeticFunction R) = f * g 
Arguments: {R : Type u_1} [Semiring R] {f g : ArithmeticFunction ℕ}
Goal: ↑(f * g) = ↑f * ↑g
-- ArithmeticFunction.intCoe_mul
@[simp, norm_cast]
theorem intCoe_mul [Ring R] {f g : ArithmeticFunction ℤ} :
    (↑(f * g) : ArithmeticFunction R) = ↑f * g 
Arguments: {R : Type u_1} [Ring R] {f g : ArithmeticFunction ℤ}
Goal: ↑(f * g) = ↑f * ↑g
-- ArithmeticFunction.mul_smul'
theorem mul_smul' (f g : ArithmeticFunction R) (h : ArithmeticFunction M) :
    (f * g) • h = f • g • h 
Arguments: {R : Type u_1} {M : Type u_2} [Semiring R] [AddCommMonoid M] [Module R M] (f g : ArithmeticFunction R) (h : ArithmeticFunction M)
Goal: (f * g) • h = f • g • h
-- ArithmeticFunction.one_smul'
theorem one_smul' (b : ArithmeticFunction M) : (1 : ArithmeticFunction R) • b = b 
Arguments: {R : Type u_1} {M : Type u_2} [Semiring R] [AddCommMonoid M] [Module R M] (b : ArithmeticFunction M)
Goal: 1 • b = b
-- ArithmeticFunction.zeta_apply
@[simp]
theorem zeta_apply {x : ℕ} : ζ x = if x = 0 then 0 else 1 
Arguments: {x : ℕ}
Goal: ArithmeticFunction.zeta x = if x = 0 then 0 else 1
-- ArithmeticFunction.zeta_apply_ne
theorem zeta_apply_ne {x : ℕ} (h : x ≠ 0) : ζ x = 1 
Arguments: {x : ℕ} (h : x ≠ 0)
Goal: ArithmeticFunction.zeta x = 1
-- ArithmeticFunction.coe_zeta_smul_apply
theorem coe_zeta_smul_apply {M} [Semiring R] [AddCommMonoid M] [Module R M]
    {f : ArithmeticFunction M} {x : ℕ} :
    ((↑ζ : ArithmeticFunction R) • f) x = ∑ i ∈ divisors x, f i 
Arguments: {R : Type u_1} {M : Type u_2} [Semiring R] [AddCommMonoid M] [Module R M] {f : ArithmeticFunction M} {x : ℕ}
Goal: (↑ArithmeticFunction.zeta • f) x = ∑ i ∈ x.divisors, f i
-- ArithmeticFunction.coe_zeta_mul_apply
theorem coe_zeta_mul_apply [Semiring R] {f : ArithmeticFunction R} {x : ℕ} :
    (↑ζ * f) x = ∑ i ∈ divisors x, f i 
Arguments: {R : Type u_1} [Semiring R] {f : ArithmeticFunction R} {x : ℕ}
Goal: (↑ArithmeticFunction.zeta * f) x = ∑ i ∈ x.divisors, f i
-- ArithmeticFunction.coe_mul_zeta_apply
theorem coe_mul_zeta_apply [Semiring R] {f : ArithmeticFunction R} {x : ℕ} :
    (f * ζ) x = ∑ i ∈ divisors x, f i 
Arguments: {R : Type u_1} [Semiring R] {f : ArithmeticFunction R} {x : ℕ}
Goal: (f * ↑ArithmeticFunction.zeta) x = ∑ i ∈ x.divisors, f i
-- ArithmeticFunction.zeta_mul_apply
theorem zeta_mul_apply {f : ArithmeticFunction ℕ} {x : ℕ} : (ζ * f) x = ∑ i ∈ divisors x, f i 
Arguments: {f : ArithmeticFunction ℕ} {x : ℕ}
Goal: (ArithmeticFunction.zeta * f) x = ∑ i ∈ x.divisors, f i
-- ArithmeticFunction.mul_zeta_apply
theorem mul_zeta_apply {f : ArithmeticFunction ℕ} {x : ℕ} : (f * ζ) x = ∑ i ∈ divisors x, f i 
Arguments: {f : ArithmeticFunction ℕ} {x : ℕ}
Goal: (f * ArithmeticFunction.zeta) x = ∑ i ∈ x.divisors, f i
-- ArithmeticFunction.pmul_apply
@[simp]
theorem pmul_apply [MulZeroClass R] {f g : ArithmeticFunction R} {x : ℕ} : f.pmul g x = f x * g x 
Arguments: {R : Type u_1} [MulZeroClass R] {f g : ArithmeticFunction R} {x : ℕ}
Goal: (f.pmul g) x = f x * g x
-- ArithmeticFunction.pmul_comm
theorem pmul_comm [CommMonoidWithZero R] (f g : ArithmeticFunction R) : f.pmul g = g.pmul f 
Arguments: {R : Type u_1} [CommMonoidWithZero R] (f g : ArithmeticFunction R)
Goal: f.pmul g = g.pmul f
-- ArithmeticFunction.pmul_assoc
lemma pmul_assoc [CommMonoidWithZero R] (f₁ f₂ f₃ : ArithmeticFunction R) :
    pmul (pmul f₁ f₂) f₃ = pmul f₁ (pmul f₂ f₃) 
Arguments: {R : Type u_1} [CommMonoidWithZero R] (f₁ f₂ f₃ : ArithmeticFunction R)
Goal: (f₁.pmul f₂).pmul f₃ = f₁.pmul (f₂.pmul f₃)
-- ArithmeticFunction.pmul_zeta
@[simp]
theorem pmul_zeta (f : ArithmeticFunction R) : f.pmul ↑ζ = f 
Arguments: {R : Type u_1} [NonAssocSemiring R] (f : ArithmeticFunction R)
Goal: f.pmul ↑ArithmeticFunction.zeta = f
-- ArithmeticFunction.zeta_pmul
@[simp]
theorem zeta_pmul (f : ArithmeticFunction R) : (ζ : ArithmeticFunction R).pmul f = f 
Arguments: {R : Type u_1} [NonAssocSemiring R] (f : ArithmeticFunction R)
Goal: (↑ArithmeticFunction.zeta).pmul f = f
-- ArithmeticFunction.ppow_zero
@[simp]
theorem ppow_zero {f : ArithmeticFunction R} : f.ppow 0 = ζ 
Arguments: {R : Type u_1} [Semiring R] {f : ArithmeticFunction R}
Goal: f.ppow 0 = ↑ArithmeticFunction.zeta
-- ArithmeticFunction.ppow_apply
@[simp]
theorem ppow_apply {f : ArithmeticFunction R} {k x : ℕ} (kpos : 0 < k) : f.ppow k x = f x ^ k 
Arguments: {R : Type u_1} [Semiring R] {f : ArithmeticFunction R} {k x : ℕ} (kpos : 0 < k)
Goal: (f.ppow k) x = f x ^ k
-- ArithmeticFunction.ppow_succ'
theorem ppow_succ' {f : ArithmeticFunction R} {k : ℕ} : f.ppow (k + 1) = f.pmul (f.ppow k) 
Arguments: {R : Type u_1} [Semiring R] {f : ArithmeticFunction R} {k : ℕ}
Goal: f.ppow (k + 1) = f.pmul (f.ppow k)
-- ArithmeticFunction.ppow_succ
theorem ppow_succ {f : ArithmeticFunction R} {k : ℕ} {kpos : 0 < k} :
    f.ppow (k + 1) = (f.ppow k).pmul f 
Arguments: {R : Type u_1} [Semiring R] {f : ArithmeticFunction R} {k : ℕ} {kpos : 0 < k}
Goal: f.ppow (k + 1) = (f.ppow k).pmul f
-- ArithmeticFunction.pdiv_apply
@[simp]
theorem pdiv_apply [GroupWithZero R] (f g : ArithmeticFunction R) (n : ℕ) :
    pdiv f g n = f n / g n 
Arguments: {R : Type u_1} [GroupWithZero R] (f g : ArithmeticFunction R) (n : ℕ)
Goal: (f.pdiv g) n = f n / g n
-- ArithmeticFunction.pdiv_zeta
@[simp]
theorem pdiv_zeta [DivisionSemiring R] (f : ArithmeticFunction R) :
    pdiv f zeta = f 
Arguments: {R : Type u_1} [DivisionSemiring R] (f : ArithmeticFunction R)
Goal: f.pdiv ↑ArithmeticFunction.zeta = f
-- ArithmeticFunction.prodPrimeFactors_apply
@[simp]
theorem prodPrimeFactors_apply [CommMonoidWithZero R] {f : ℕ → R} {n : ℕ} (hn : n ≠ 0) :
    ∏ᵖ p ∣ n, f p = ∏ p ∈ n.primeFactors, f p 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {f : ℕ → R} {n : ℕ} (hn : n ≠ 0)
Goal: (ArithmeticFunction.prodPrimeFactors fun p => f p) n = ∏ p ∈ n.primeFactors, f p
-- ArithmeticFunction.IsMultiplicative.map_one
@[simp, arith_mult]
theorem map_one {f : ArithmeticFunction R} (h : f.IsMultiplicative) : f 1 = 1 
Arguments: {R : Type u_1} [MonoidWithZero R] {f : ArithmeticFunction R} (h : f.IsMultiplicative)
Goal: f 1 = 1
-- ArithmeticFunction.IsMultiplicative.map_mul_of_coprime
@[simp]
theorem map_mul_of_coprime {f : ArithmeticFunction R} (hf : f.IsMultiplicative) {m n : ℕ}
    (h : m.Coprime n) : f (m * n) = f m * f n 
Arguments: {R : Type u_1} [MonoidWithZero R] {f : ArithmeticFunction R} (hf : f.IsMultiplicative) {m n : ℕ} (h : m.Coprime n)
Goal: f (m * n) = f m * f n
-- ArithmeticFunction.IsMultiplicative.map_prod
theorem map_prod {ι : Type*} [CommMonoidWithZero R] (g : ι → ℕ) {f : ArithmeticFunction R}
    (hf : f.IsMultiplicative) (s : Finset ι) (hs : (s : Set ι).Pairwise (Coprime on g)) :
    f (∏ i ∈ s, g i) = ∏ i ∈ s, f (g i) 
Arguments: {R : Type u_1} {ι : Type u_2} [CommMonoidWithZero R] (g : ι → ℕ) {f : ArithmeticFunction R} (hf : f.IsMultiplicative) (s : Finset ι) (hs : (↑s).Pairwise (Nat.Coprime on g))
Goal: f (∏ i ∈ s, g i) = ∏ i ∈ s, f (g i)
-- ArithmeticFunction.IsMultiplicative.map_prod_of_prime
theorem map_prod_of_prime [CommSemiring R] {f : ArithmeticFunction R}
    (h_mult : ArithmeticFunction.IsMultiplicative f)
    (t : Finset ℕ) (ht : ∀ p ∈ t, p.Prime) :
    f (∏ a ∈ t, a) = ∏ a ∈ t, f a 
Arguments: {R : Type u_1} [CommSemiring R] {f : ArithmeticFunction R} (h_mult : f.IsMultiplicative) (t : Finset ℕ) (ht : ∀ p ∈ t, Nat.Prime p)
Goal: f (∏ a ∈ t, a) = ∏ a ∈ t, f a
-- ArithmeticFunction.IsMultiplicative.map_prod_of_subset_primeFactors
theorem map_prod_of_subset_primeFactors [CommSemiring R] {f : ArithmeticFunction R}
    (h_mult : ArithmeticFunction.IsMultiplicative f) (l : ℕ)
    (t : Finset ℕ) (ht : t ⊆ l.primeFactors) :
    f (∏ a ∈ t, a) = ∏ a ∈ t, f a 
Arguments: {R : Type u_1} [CommSemiring R] {f : ArithmeticFunction R} (h_mult : f.IsMultiplicative) (l : ℕ) (t : Finset ℕ) (ht : t ⊆ l.primeFactors)
Goal: f (∏ a ∈ t, a) = ∏ a ∈ t, f a
-- ArithmeticFunction.IsMultiplicative.natCast
@[arith_mult]
theorem natCast {f : ArithmeticFunction ℕ} [Semiring R] (h : f.IsMultiplicative) :
    IsMultiplicative (f : ArithmeticFunction R) 
Arguments: {R : Type u_1} {f : ArithmeticFunction ℕ} [Semiring R] (h : f.IsMultiplicative)
Goal: (↑f).IsMultiplicative
-- ArithmeticFunction.IsMultiplicative.intCast
@[arith_mult]
theorem intCast {f : ArithmeticFunction ℤ} [Ring R] (h : f.IsMultiplicative) :
    IsMultiplicative (f : ArithmeticFunction R) 
Arguments: {R : Type u_1} {f : ArithmeticFunction ℤ} [Ring R] (h : f.IsMultiplicative)
Goal: (↑f).IsMultiplicative
-- ArithmeticFunction.IsMultiplicative.mul
@[arith_mult]
theorem mul [CommSemiring R] {f g : ArithmeticFunction R} (hf : f.IsMultiplicative)
    (hg : g.IsMultiplicative) : IsMultiplicative (f * g) 
Arguments: {R : Type u_1} [CommSemiring R] {f g : ArithmeticFunction R} (hf : f.IsMultiplicative) (hg : g.IsMultiplicative)
Goal: (f * g).IsMultiplicative
-- ArithmeticFunction.IsMultiplicative.pmul
@[arith_mult]
theorem pmul [CommSemiring R] {f g : ArithmeticFunction R} (hf : f.IsMultiplicative)
    (hg : g.IsMultiplicative) : IsMultiplicative (f.pmul g) 
Arguments: {R : Type u_1} [CommSemiring R] {f g : ArithmeticFunction R} (hf : f.IsMultiplicative) (hg : g.IsMultiplicative)
Goal: (f.pmul g).IsMultiplicative
-- ArithmeticFunction.IsMultiplicative.pdiv
@[arith_mult]
theorem pdiv [CommGroupWithZero R] {f g : ArithmeticFunction R} (hf : IsMultiplicative f)
    (hg : IsMultiplicative g) : IsMultiplicative (pdiv f g) 
Arguments: {R : Type u_1} [CommGroupWithZero R] {f g : ArithmeticFunction R} (hf : f.IsMultiplicative) (hg : g.IsMultiplicative)
Goal: (f.pdiv g).IsMultiplicative
-- ArithmeticFunction.IsMultiplicative.multiplicative_factorization
nonrec  -- Porting note: added
theorem multiplicative_factorization [CommMonoidWithZero R] (f : ArithmeticFunction R)
    (hf : f.IsMultiplicative) {n : ℕ} (hn : n ≠ 0) :
    f n = n.factorization.prod fun p k => f (p ^ k) 
Arguments: {R : Type u_1} [CommMonoidWithZero R] (f : ArithmeticFunction R) (hf : f.IsMultiplicative) {n : ℕ} (hn : n ≠ 0)
Goal: f n = n.factorization.prod fun p k => f (p ^ k)
-- ArithmeticFunction.IsMultiplicative.iff_ne_zero
theorem iff_ne_zero [MonoidWithZero R] {f : ArithmeticFunction R} :
    IsMultiplicative f ↔
      f 1 = 1 ∧ ∀ {m n : ℕ}, m ≠ 0 → n ≠ 0 → m.Coprime n → f (m * n) = f m * f n 
Arguments: {R : Type u_1} [MonoidWithZero R] {f : ArithmeticFunction R}
Goal: f.IsMultiplicative ↔ f 1 = 1 ∧ ∀ {m n : ℕ}, m ≠ 0 → n ≠ 0 → m.Coprime n → f (m * n) = f m * f n
-- ArithmeticFunction.IsMultiplicative.eq_iff_eq_on_prime_powers
theorem eq_iff_eq_on_prime_powers [CommMonoidWithZero R] (f : ArithmeticFunction R)
    (hf : f.IsMultiplicative) (g : ArithmeticFunction R) (hg : g.IsMultiplicative) :
    f = g ↔ ∀ p i : ℕ, Nat.Prime p → f (p ^ i) = g (p ^ i) 
Arguments: {R : Type u_1} [CommMonoidWithZero R] (f : ArithmeticFunction R) (hf : f.IsMultiplicative) (g : ArithmeticFunction R) (hg : g.IsMultiplicative)
Goal: f = g ↔ ∀ (p i : ℕ), Nat.Prime p → f (p ^ i) = g (p ^ i)
-- ArithmeticFunction.IsMultiplicative.prodPrimeFactors
@[arith_mult]
theorem prodPrimeFactors [CommMonoidWithZero R] (f : ℕ → R) :
    IsMultiplicative (prodPrimeFactors f) 
Arguments: {R : Type u_1} [CommMonoidWithZero R] (f : ℕ → R)
Goal: (ArithmeticFunction.prodPrimeFactors f).IsMultiplicative