ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- HurwitzZeta.hasSum_nat_completedSinZeta
lemma hasSum_nat_completedSinZeta (a : ℝ) {s : ℂ} (hs : 1 < re s) :
    HasSum (fun n : ℕ ↦ Gammaℝ (s + 1) * Real.sin (2 * π * a * n) / (n : ℂ) ^ s)
    (completedSinZeta a s) 
Arguments: (a : ℝ) {s : ℂ} (hs : 1 < s.re)
Goal: HasSum (fun n => (s + 1).Gammaℝ * ↑(Real.sin (2 * π * a * ↑n)) / ↑n ^ s) (HurwitzZeta.completedSinZeta (↑a) s)
-- HurwitzZeta.hasSum_int_completedHurwitzZetaOdd
lemma hasSum_int_completedHurwitzZetaOdd (a : ℝ) {s : ℂ} (hs : 1 < re s) :
    HasSum (fun n : ℤ ↦ Gammaℝ (s + 1) * SignType.sign (n + a) / (↑|n + a| : ℂ) ^ s / 2)
    (completedHurwitzZetaOdd a s) 
Arguments: (a : ℝ) {s : ℂ} (hs : 1 < s.re)
Goal: HasSum (fun n => (s + 1).Gammaℝ * ↑(SignType.sign (↑n + a)) / ↑|↑n + a| ^ s / 2)
  (HurwitzZeta.completedHurwitzZetaOdd (↑a) s)
-- HurwitzZeta.hurwitzZetaOdd_neg
lemma hurwitzZetaOdd_neg (a : UnitAddCircle) (s : ℂ) :
    hurwitzZetaOdd (-a) s = -hurwitzZetaOdd a s 
Arguments: (a : UnitAddCircle) (s : ℂ)
Goal: HurwitzZeta.hurwitzZetaOdd (-a) s = -HurwitzZeta.hurwitzZetaOdd a s
-- HurwitzZeta.differentiable_hurwitzZetaOdd
lemma differentiable_hurwitzZetaOdd (a : UnitAddCircle) :
    Differentiable ℂ (hurwitzZetaOdd a) 
Arguments: (a : UnitAddCircle)
Goal: Differentiable ℂ (HurwitzZeta.hurwitzZetaOdd a)
-- HurwitzZeta.sinZeta_neg
lemma sinZeta_neg (a : UnitAddCircle) (s : ℂ) :
    sinZeta (-a) s = -sinZeta a s 
Arguments: (a : UnitAddCircle) (s : ℂ)
Goal: HurwitzZeta.sinZeta (-a) s = -HurwitzZeta.sinZeta a s
-- HurwitzZeta.differentiableAt_sinZeta
lemma differentiableAt_sinZeta (a : UnitAddCircle) :
    Differentiable ℂ (sinZeta a) 
Arguments: (a : UnitAddCircle)
Goal: Differentiable ℂ (HurwitzZeta.sinZeta a)
-- HurwitzZeta.hasSum_int_hurwitzZetaOdd
theorem hasSum_int_hurwitzZetaOdd (a : ℝ) {s : ℂ} (hs : 1 < re s) :
    HasSum (fun n : ℤ ↦ SignType.sign (n + a) / (↑|n + a| : ℂ) ^ s / 2) (hurwitzZetaOdd a s) 
Arguments: (a : ℝ) {s : ℂ} (hs : 1 < s.re)
Goal: HasSum (fun n => ↑(SignType.sign (↑n + a)) / ↑|↑n + a| ^ s / 2) (HurwitzZeta.hurwitzZetaOdd (↑a) s)
-- HurwitzZeta.hasSum_nat_hurwitzZetaOdd
lemma hasSum_nat_hurwitzZetaOdd (a : ℝ) {s : ℂ} (hs : 1 < re s) :
    HasSum (fun n : ℕ ↦ (SignType.sign (n + a) / (↑|n + a| : ℂ) ^ s
      - SignType.sign (n + 1 - a) / (↑|n + 1 - a| : ℂ) ^ s) / 2) (hurwitzZetaOdd a s) 
Arguments: (a : ℝ) {s : ℂ} (hs : 1 < s.re)
Goal: HasSum (fun n => (↑(SignType.sign (↑n + a)) / ↑|↑n + a| ^ s - ↑(SignType.sign (↑n + 1 - a)) / ↑|↑n + 1 - a| ^ s) / 2)
  (HurwitzZeta.hurwitzZetaOdd (↑a) s)
-- HurwitzZeta.hasSum_nat_hurwitzZetaOdd_of_mem_Icc
lemma hasSum_nat_hurwitzZetaOdd_of_mem_Icc {a : ℝ} (ha : a ∈ Icc 0 1) {s : ℂ} (hs : 1 < re s) :
    HasSum (fun n : ℕ ↦ (1 / (n + a : ℂ) ^ s - 1 / (n + 1 - a : ℂ) ^ s) / 2)
    (hurwitzZetaOdd a s) 
Arguments: {a : ℝ} (ha : a ∈ Set.Icc 0 1) {s : ℂ} (hs : 1 < s.re)
Goal: HasSum (fun n => (1 / (↑n + ↑a) ^ s - 1 / (↑n + 1 - ↑a) ^ s) / 2) (HurwitzZeta.hurwitzZetaOdd (↑a) s)
-- HurwitzZeta.hasSum_int_sinZeta
theorem hasSum_int_sinZeta (a : ℝ) {s : ℂ} (hs : 1 < re s) :
    HasSum (fun n : ℤ ↦ -I * n.sign * cexp (2 * π * I * a * n) / ↑|n| ^ s / 2) (sinZeta a s) 
Arguments: (a : ℝ) {s : ℂ} (hs : 1 < s.re)
Goal: HasSum (fun n => -Complex.I * ↑n.sign * cexp (2 * ↑π * Complex.I * ↑a * ↑n) / ↑|n| ^ s / 2) (HurwitzZeta.sinZeta (↑a) s)
-- HurwitzZeta.hasSum_nat_sinZeta
lemma hasSum_nat_sinZeta (a : ℝ) {s : ℂ} (hs : 1 < re s) :
    HasSum (fun n : ℕ ↦ Real.sin (2 * π * a * n) / (n : ℂ) ^ s) (sinZeta a s) 
Arguments: (a : ℝ) {s : ℂ} (hs : 1 < s.re)
Goal: HasSum (fun n => ↑(Real.sin (2 * π * a * ↑n)) / ↑n ^ s) (HurwitzZeta.sinZeta (↑a) s)
-- HurwitzZeta.LSeriesHasSum_sin
lemma LSeriesHasSum_sin (a : ℝ) {s : ℂ} (hs : 1 < re s) :
    LSeriesHasSum (Real.sin <| 2 * π * a * ·) s (sinZeta a s) 
Arguments: (a : ℝ) {s : ℂ} (hs : 1 < s.re)
Goal: LSeriesHasSum (fun x => ↑(Real.sin (2 * π * a * ↑x))) s (HurwitzZeta.sinZeta (↑a) s)
-- HurwitzZeta.hurwitzZetaOdd_neg_two_mul_nat_sub_one
theorem hurwitzZetaOdd_neg_two_mul_nat_sub_one (a : UnitAddCircle) (n : ℕ) :
    hurwitzZetaOdd a (-2 * n - 1) = 0 
Arguments: (a : UnitAddCircle) (n : ℕ)
Goal: HurwitzZeta.hurwitzZetaOdd a (-2 * ↑n - 1) = 0
-- HurwitzZeta.sinZeta_neg_two_mul_nat_sub_one
theorem sinZeta_neg_two_mul_nat_sub_one (a : UnitAddCircle) (n : ℕ) :
    sinZeta a (-2 * n - 1) = 0 
Arguments: (a : UnitAddCircle) (n : ℕ)
Goal: HurwitzZeta.sinZeta a (-2 * ↑n - 1) = 0
-- HurwitzZeta.hurwitzZetaOdd_one_sub
lemma hurwitzZetaOdd_one_sub (a : UnitAddCircle) {s : ℂ} (hs : ∀ (n : ℕ), s ≠ -n) :
    hurwitzZetaOdd a (1 - s) = 2 * (2 * π) ^ (-s) * Gamma s * sin (π * s / 2) * sinZeta a s 
Arguments: (a : UnitAddCircle) {s : ℂ} (hs : ∀ (n : ℕ), s ≠ -↑n)
Goal: HurwitzZeta.hurwitzZetaOdd a (1 - s) =
  2 * (2 * ↑π) ^ (-s) * Complex.Gamma s * Complex.sin (↑π * s / 2) * HurwitzZeta.sinZeta a s
-- HurwitzZeta.sinZeta_one_sub
lemma sinZeta_one_sub (a : UnitAddCircle) {s : ℂ} (hs : ∀ (n : ℕ), s ≠ -n) :
    sinZeta a (1 - s) = 2 * (2 * π) ^ (-s) * Gamma s * sin (π * s / 2) * hurwitzZetaOdd a s 
Arguments: (a : UnitAddCircle) {s : ℂ} (hs : ∀ (n : ℕ), s ≠ -↑n)
Goal: HurwitzZeta.sinZeta a (1 - s) =
  2 * (2 * ↑π) ^ (-s) * Complex.Gamma s * Complex.sin (↑π * s / 2) * HurwitzZeta.hurwitzZetaOdd a s
-- MulChar.map_nonunit'
structure MulChar extends MonoidHom R R' where
  map_nonunit' : ∀ a : R, ¬IsUnit a → toFun a = 0
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommMonoidWithZero R'] (self : MulChar R R') (a : R)
Goal: ¬IsUnit a → (↑self.toMonoidHom).toFun a = 0
-- MulCharClass.map_nonunit
class MulCharClass (F : Type*) (R R' : outParam Type*) [CommMonoid R]
  [CommMonoidWithZero R'] [FunLike F R R'] extends MonoidHomClass F R R' : Prop where
  map_nonunit : ∀ (χ : F) {a : R} (_ : ¬IsUnit a), χ a = 0
Arguments: {F : Type u_3} {R : outParam (Type u_4)} {R' : outParam (Type u_5)} [CommMonoid R] [CommMonoidWithZero R'] [FunLike F R R'] [self : MulCharClass F R R'] (χ : F) {a : R}
Goal: ¬IsUnit a → χ a = 0
-- MulChar.trivial_apply
@[simps]
noncomputable def trivial : MulChar R R' 
Arguments: (R : Type u_1) [CommMonoid R] (R' : Type u_2) [CommMonoidWithZero R'] (x : R)
Goal: (MulChar.trivial R R') x = if IsUnit x then 1 else 0
-- MulChar.coe_mk
@[simp]
theorem coe_mk (f : R →* R') (hf) : (MulChar.mk f hf : R → R') = f 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommMonoidWithZero R'] (f : R →* R') (hf : ∀ (a : R), ¬IsUnit a → (↑f).toFun a = 0)
Goal: ⇑{ toMonoidHom := f, map_nonunit' := hf } = ⇑f
-- MulChar.ext'
theorem ext' {χ χ' : MulChar R R'} (h : ∀ a, χ a = χ' a) : χ = χ' 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommMonoidWithZero R'] {χ χ' : MulChar R R'} (h : ∀ (a : R), χ a = χ' a)
Goal: χ = χ'
-- MulChar.map_nonunit
theorem map_nonunit (χ : MulChar R R') {a : R} (ha : ¬IsUnit a) : χ a = 0 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommMonoidWithZero R'] (χ : MulChar R R') {a : R} (ha : ¬IsUnit a)
Goal: χ a = 0
-- MulChar.ext
@[ext]
theorem ext {χ χ' : MulChar R R'} (h : ∀ a : Rˣ, χ a = χ' a) : χ = χ' 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommMonoidWithZero R'] {χ χ' : MulChar R R'} (h : ∀ (a : Rˣ), χ ↑a = χ' ↑a)
Goal: χ = χ'
-- MulChar.ext_iff
theorem ext_iff {χ χ' : MulChar R R'} : χ = χ' ↔ ∀ a : Rˣ, χ a = χ' a 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommMonoidWithZero R'] {χ χ' : MulChar R R'}
Goal: χ = χ' ↔ ∀ (a : Rˣ), χ ↑a = χ' ↑a
-- MulChar.coe_toUnitHom
theorem coe_toUnitHom (χ : MulChar R R') (a : Rˣ) : ↑(χ.toUnitHom a) = χ a 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommMonoidWithZero R'] (χ : MulChar R R') (a : Rˣ)
Goal: ↑(χ.toUnitHom a) = χ ↑a
-- MulChar.ofUnitHom_coe
theorem ofUnitHom_coe (f : Rˣ →* R'ˣ) (a : Rˣ) : ofUnitHom f ↑a = f a 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommMonoidWithZero R'] (f : Rˣ →* R'ˣ) (a : Rˣ)
Goal: (MulChar.ofUnitHom f) ↑a = ↑(f a)
-- MulChar.toUnitHom_eq
@[simp]
theorem toUnitHom_eq (χ : MulChar R R') : toUnitHom χ = equivToUnitHom χ 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommMonoidWithZero R'] (χ : MulChar R R')
Goal: χ.toUnitHom = MulChar.equivToUnitHom χ
-- MulChar.ofUnitHom_eq
@[simp]
theorem ofUnitHom_eq (χ : Rˣ →* R'ˣ) : ofUnitHom χ = equivToUnitHom.symm χ 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommMonoidWithZero R'] (χ : Rˣ →* R'ˣ)
Goal: MulChar.ofUnitHom χ = MulChar.equivToUnitHom.symm χ
-- MulChar.coe_equivToUnitHom
@[simp]
theorem coe_equivToUnitHom (χ : MulChar R R') (a : Rˣ) : ↑(equivToUnitHom χ a) = χ a 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommMonoidWithZero R'] (χ : MulChar R R') (a : Rˣ)
Goal: ↑((MulChar.equivToUnitHom χ) a) = χ ↑a
-- MulChar.equivToUnitHom_symm_coe
@[simp]
theorem equivToUnitHom_symm_coe (f : Rˣ →* R'ˣ) (a : Rˣ) : equivToUnitHom.symm f ↑a = f a 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommMonoidWithZero R'] (f : Rˣ →* R'ˣ) (a : Rˣ)
Goal: (MulChar.equivToUnitHom.symm f) ↑a = ↑(f a)
-- MulChar.coe_toMonoidHom
@[simp]
lemma coe_toMonoidHom [CommMonoid R] (χ : MulChar R R')
    (x : R) : χ.toMonoidHom x = χ x 
Arguments: {R : Type u_1} {R' : Type u_2} [CommMonoidWithZero R'] [CommMonoid R] (χ : MulChar R R') (x : R)
Goal: χ.toMonoidHom x = χ x
-- MulChar.map_one
protected theorem map_one (χ : MulChar R R') : χ (1 : R) = 1 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommMonoidWithZero R'] (χ : MulChar R R')
Goal: χ 1 = 1
-- MulChar.map_zero
protected theorem map_zero {R : Type*} [CommMonoidWithZero R] [Nontrivial R] (χ : MulChar R R') :
    χ (0 : R) = 0 
Arguments: {R' : Type u_2} [CommMonoidWithZero R'] {R : Type u_3} [CommMonoidWithZero R] [Nontrivial R] (χ : MulChar R R')
Goal: χ 0 = 0
-- MulChar.toMonoidWithZeroHom_apply
@[coe, simps]
def toMonoidWithZeroHom {R : Type*} [CommMonoidWithZero R] [Nontrivial R] (χ : MulChar R R') :
    R →*₀ R' 
Arguments: {R' : Type u_2} [CommMonoidWithZero R'] {R : Type u_3} [CommMonoidWithZero R] [Nontrivial R] (χ : MulChar R R')
Goal: ∀ (a : R), ↑χ a = (↑χ.toMonoidHom).toFun a
-- MulChar.map_ringChar
theorem map_ringChar {R : Type*} [CommRing R] [Nontrivial R] (χ : MulChar R R') :
    χ (ringChar R) = 0 
Arguments: {R' : Type u_2} [CommMonoidWithZero R'] {R : Type u_3} [CommRing R] [Nontrivial R] (χ : MulChar R R')
Goal: χ ↑(ringChar R) = 0
-- MulChar.one_apply_coe
@[simp]
theorem one_apply_coe (a : Rˣ) : (1 : MulChar R R') a = 1 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommMonoidWithZero R'] (a : Rˣ)
Goal: 1 ↑a = 1
-- MulChar.one_apply
lemma one_apply {x : R} (hx : IsUnit x) : (1 : MulChar R R') x = 1 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommMonoidWithZero R'] {x : R} (hx : IsUnit x)
Goal: 1 x = 1
-- MulChar.mul_apply
theorem mul_apply (χ χ' : MulChar R R') (a : R) : (χ * χ') a = χ a * χ' a 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommMonoidWithZero R'] (χ χ' : MulChar R R') (a : R)
Goal: (χ * χ') a = χ a * χ' a
-- MulChar.coeToFun_mul
@[simp]
theorem coeToFun_mul (χ χ' : MulChar R R') : ⇑(χ * χ') = χ * χ' 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommMonoidWithZero R'] (χ χ' : MulChar R R')
Goal: ⇑(χ * χ') = ⇑χ * ⇑χ'
-- MulChar.one_mul
protected theorem one_mul (χ : MulChar R R') : (1 : MulChar R R') * χ = χ 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommMonoidWithZero R'] (χ : MulChar R R')
Goal: 1 * χ = χ
-- MulChar.mul_one
protected theorem mul_one (χ : MulChar R R') : χ * 1 = χ 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommMonoidWithZero R'] (χ : MulChar R R')
Goal: χ * 1 = χ
-- MulChar.inv_apply_eq_inv
theorem inv_apply_eq_inv (χ : MulChar R R') (a : R) : χ⁻¹ a = Ring.inverse (χ a) 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommMonoidWithZero R'] (χ : MulChar R R') (a : R)
Goal: χ⁻¹ a = Ring.inverse (χ a)
-- MulChar.inv_apply_eq_inv'
theorem inv_apply_eq_inv' {R' : Type*} [Field R'] (χ : MulChar R R') (a : R) : χ⁻¹ a = (χ a)⁻¹ 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_3} [Field R'] (χ : MulChar R R') (a : R)
Goal: χ⁻¹ a = (χ a)⁻¹
-- MulChar.inv_apply
theorem inv_apply {R : Type*} [CommMonoidWithZero R] (χ : MulChar R R') (a : R) :
    χ⁻¹ a = χ (Ring.inverse a) 
Arguments: {R' : Type u_2} [CommMonoidWithZero R'] {R : Type u_3} [CommMonoidWithZero R] (χ : MulChar R R') (a : R)
Goal: χ⁻¹ a = χ (Ring.inverse a)
-- MulChar.inv_apply'
theorem inv_apply' {R : Type*} [Field R] (χ : MulChar R R') (a : R) : χ⁻¹ a = χ a⁻¹ 
Arguments: {R' : Type u_2} [CommMonoidWithZero R'] {R : Type u_3} [Field R] (χ : MulChar R R') (a : R)
Goal: χ⁻¹ a = χ a⁻¹
-- MulChar.inv_mul
-- Porting note (#10618): @[simp] can prove this (later)
theorem inv_mul (χ : MulChar R R') : χ⁻¹ * χ = 1 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommMonoidWithZero R'] (χ : MulChar R R')
Goal: χ⁻¹ * χ = 1
-- MulChar.pow_apply_coe
theorem pow_apply_coe (χ : MulChar R R') (n : ℕ) (a : Rˣ) : (χ ^ n) a = χ a ^ n 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommMonoidWithZero R'] (χ : MulChar R R') (n : ℕ) (a : Rˣ)
Goal: (χ ^ n) ↑a = χ ↑a ^ n
-- MulChar.pow_apply'
theorem pow_apply' (χ : MulChar R R') {n : ℕ} (hn : n ≠ 0) (a : R) : (χ ^ n) a = χ a ^ n 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommMonoidWithZero R'] (χ : MulChar R R') {n : ℕ} (hn : n ≠ 0) (a : R)
Goal: (χ ^ n) a = χ a ^ n
-- MulChar.equivToUnitHom_mul_apply
lemma equivToUnitHom_mul_apply (χ₁ χ₂ : MulChar R R') (a : Rˣ) :
    equivToUnitHom (χ₁ * χ₂) a = equivToUnitHom χ₁ a * equivToUnitHom χ₂ a 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommMonoidWithZero R'] (χ₁ χ₂ : MulChar R R') (a : Rˣ)
Goal: (MulChar.equivToUnitHom (χ₁ * χ₂)) a = (MulChar.equivToUnitHom χ₁) a * (MulChar.equivToUnitHom χ₂) a
-- MulChar.eq_one_iff
lemma eq_one_iff {χ : MulChar R R'} : χ = 1 ↔ ∀ a : Rˣ, χ a = 1 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommMonoidWithZero R'] {χ : MulChar R R'}
Goal: χ = 1 ↔ ∀ (a : Rˣ), χ ↑a = 1
-- MulChar.ne_one_iff
lemma ne_one_iff {χ : MulChar R R'} : χ ≠ 1 ↔ ∃ a : Rˣ, χ a ≠ 1 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommMonoidWithZero R'] {χ : MulChar R R'}
Goal: χ ≠ 1 ↔ ∃ a, χ ↑a ≠ 1
-- MulChar.isNontrivial_iff
@[deprecated (since := "2024-06-16")]
theorem isNontrivial_iff (χ : MulChar R R') : χ.IsNontrivial ↔ χ ≠ 1 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommMonoidWithZero R'] (χ : MulChar R R')
Goal: χ.IsNontrivial ↔ χ ≠ 1
-- MulChar.IsQuadratic.eq_of_eq_coe
theorem IsQuadratic.eq_of_eq_coe {χ : MulChar R ℤ} (hχ : IsQuadratic χ) {χ' : MulChar R' ℤ}
    (hχ' : IsQuadratic χ') [Nontrivial R''] (hR'' : ringChar R'' ≠ 2) {a : R} {a' : R'}
    (h : (χ a : R'') = χ' a') : χ a = χ' a' 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommRing R'] {R'' : Type u_3} [CommRing R''] {χ : MulChar R ℤ} (hχ : χ.IsQuadratic) {χ' : MulChar R' ℤ} (hχ' : χ'.IsQuadratic) [Nontrivial R''] (hR'' : ringChar R'' ≠ 2) {a : R} {a' : R'} (h : ↑(χ a) = ↑(χ' a'))
Goal: χ a = χ' a'
-- MulChar.ringHomComp_apply
@[simps]
def ringHomComp (χ : MulChar R R') (f : R' →+* R'') : MulChar R R'' 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommRing R'] {R'' : Type u_3} [CommRing R''] (χ : MulChar R R') (f : R' →+* R'') (a : R)
Goal: (χ.ringHomComp f) a = f (χ a)
-- MulChar.ringHomComp_one
@[simp]
lemma ringHomComp_one (f : R' →+* R'') : (1 : MulChar R R').ringHomComp f = 1 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommRing R'] {R'' : Type u_3} [CommRing R''] (f : R' →+* R'')
Goal: MulChar.ringHomComp 1 f = 1
-- MulChar.ringHomComp_inv
lemma ringHomComp_inv {R : Type*} [CommRing R] (χ : MulChar R R') (f : R' →+* R'') :
    (χ.ringHomComp f)⁻¹ = χ⁻¹.ringHomComp f 
Arguments: {R' : Type u_2} [CommRing R'] {R'' : Type u_3} [CommRing R''] {R : Type u_4} [CommRing R] (χ : MulChar R R') (f : R' →+* R'')
Goal: (χ.ringHomComp f)⁻¹ = χ⁻¹.ringHomComp f
-- MulChar.ringHomComp_mul
lemma ringHomComp_mul (χ φ : MulChar R R') (f : R' →+* R'') :
    (χ * φ).ringHomComp f = χ.ringHomComp f * φ.ringHomComp f 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommRing R'] {R'' : Type u_3} [CommRing R''] (χ φ : MulChar R R') (f : R' →+* R'')
Goal: (χ * φ).ringHomComp f = χ.ringHomComp f * φ.ringHomComp f
-- MulChar.ringHomComp_pow
lemma ringHomComp_pow (χ : MulChar R R') (f : R' →+* R'') (n : ℕ) :
    χ.ringHomComp f ^ n = (χ ^ n).ringHomComp f 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommRing R'] {R'' : Type u_3} [CommRing R''] (χ : MulChar R R') (f : R' →+* R'') (n : ℕ)
Goal: χ.ringHomComp f ^ n = (χ ^ n).ringHomComp f
-- MulChar.injective_ringHomComp
lemma injective_ringHomComp {f : R' →+* R''} (hf : Function.Injective f) :
    Function.Injective (ringHomComp (R := R) · f) 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommRing R'] {R'' : Type u_3} [CommRing R''] {f : R' →+* R''} (hf : Function.Injective ⇑f)
Goal: Function.Injective fun x => x.ringHomComp f
-- MulChar.ringHomComp_eq_one_iff
lemma ringHomComp_eq_one_iff {f : R' →+* R''} (hf : Function.Injective f) {χ : MulChar R R'} :
    χ.ringHomComp f = 1 ↔ χ = 1 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommRing R'] {R'' : Type u_3} [CommRing R''] {f : R' →+* R''} (hf : Function.Injective ⇑f) {χ : MulChar R R'}
Goal: χ.ringHomComp f = 1 ↔ χ = 1
-- MulChar.ringHomComp_ne_one_iff
lemma ringHomComp_ne_one_iff {f : R' →+* R''} (hf : Function.Injective f) {χ : MulChar R R'} :
    χ.ringHomComp f ≠ 1 ↔ χ ≠ 1 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommRing R'] {R'' : Type u_3} [CommRing R''] {f : R' →+* R''} (hf : Function.Injective ⇑f) {χ : MulChar R R'}
Goal: χ.ringHomComp f ≠ 1 ↔ χ ≠ 1
-- MulChar.IsNontrivial.comp
@[deprecated ringHomComp_ne_one_iff (since := "2024-06-16")]
theorem IsNontrivial.comp {χ : MulChar R R'} (hχ : χ.IsNontrivial) {f : R' →+* R''}
    (hf : Function.Injective f) : (χ.ringHomComp f).IsNontrivial 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommRing R'] {R'' : Type u_3} [CommRing R''] {χ : MulChar R R'} (hχ : χ.IsNontrivial) {f : R' →+* R''} (hf : Function.Injective ⇑f)
Goal: (χ.ringHomComp f).IsNontrivial
-- MulChar.IsQuadratic.comp
theorem IsQuadratic.comp {χ : MulChar R R'} (hχ : χ.IsQuadratic) (f : R' →+* R'') :
    (χ.ringHomComp f).IsQuadratic 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommRing R'] {R'' : Type u_3} [CommRing R''] {χ : MulChar R R'} (hχ : χ.IsQuadratic) (f : R' →+* R'')
Goal: (χ.ringHomComp f).IsQuadratic
-- MulChar.IsQuadratic.inv
theorem IsQuadratic.inv {χ : MulChar R R'} (hχ : χ.IsQuadratic) : χ⁻¹ = χ 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommRing R'] {χ : MulChar R R'} (hχ : χ.IsQuadratic)
Goal: χ⁻¹ = χ
-- MulChar.IsQuadratic.sq_eq_one
theorem IsQuadratic.sq_eq_one {χ : MulChar R R'} (hχ : χ.IsQuadratic) : χ ^ 2 = 1 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommRing R'] {χ : MulChar R R'} (hχ : χ.IsQuadratic)
Goal: χ ^ 2 = 1
-- MulChar.IsQuadratic.pow_char
theorem IsQuadratic.pow_char {χ : MulChar R R'} (hχ : χ.IsQuadratic) (p : ℕ) [hp : Fact p.Prime]
    [CharP R' p] : χ ^ p = χ 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommRing R'] {χ : MulChar R R'} (hχ : χ.IsQuadratic) (p : ℕ) [hp : Fact (Nat.Prime p)] [CharP R' p]
Goal: χ ^ p = χ
-- MulChar.IsQuadratic.pow_even
theorem IsQuadratic.pow_even {χ : MulChar R R'} (hχ : χ.IsQuadratic) {n : ℕ} (hn : Even n) :
    χ ^ n = 1 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommRing R'] {χ : MulChar R R'} (hχ : χ.IsQuadratic) {n : ℕ} (hn : Even n)
Goal: χ ^ n = 1
-- MulChar.IsQuadratic.pow_odd
theorem IsQuadratic.pow_odd {χ : MulChar R R'} (hχ : χ.IsQuadratic) {n : ℕ} (hn : Odd n) :
    χ ^ n = χ 
Arguments: {R : Type u_1} [CommMonoid R] {R' : Type u_2} [CommRing R'] {χ : MulChar R R'} (hχ : χ.IsQuadratic) {n : ℕ} (hn : Odd n)
Goal: χ ^ n = χ
-- MulChar.pow_card_eq_one
protected lemma pow_card_eq_one [Fintype Mˣ] (χ : MulChar M R) : χ ^ (Fintype.card Mˣ) = 1 
Arguments: {M : Type u_1} [CommMonoid M] {R : Type u_2} [CommMonoidWithZero R] [Fintype Mˣ] (χ : MulChar M R)
Goal: χ ^ Fintype.card Mˣ = 1
-- MulChar.orderOf_pos
lemma orderOf_pos [Finite Mˣ] (χ : MulChar M R) : 0 < orderOf χ 
Arguments: {M : Type u_1} [CommMonoid M] {R : Type u_2} [CommMonoidWithZero R] [Finite Mˣ] (χ : MulChar M R)
Goal: 0 < orderOf χ
-- MulChar.sum_eq_zero_of_ne_one
theorem sum_eq_zero_of_ne_one [IsDomain R'] {χ : MulChar R R'} (hχ : χ ≠ 1) : ∑ a, χ a = 0 
Arguments: {R : Type u_1} [CommMonoid R] [Fintype R] {R' : Type u_2} [CommRing R'] [IsDomain R'] {χ : MulChar R R'} (hχ : χ ≠ 1)
Goal: ∑ a : R, χ a = 0
-- MulChar.IsNontrivial.sum_eq_zero
@[deprecated (since := "2024-06-16")]
lemma IsNontrivial.sum_eq_zero [IsDomain R'] {χ : MulChar R R'} (hχ : χ.IsNontrivial) :
    ∑ a, χ a = 0 
Arguments: {R : Type u_1} [CommMonoid R] [Fintype R] {R' : Type u_2} [CommRing R'] [IsDomain R'] {χ : MulChar R R'} (hχ : χ.IsNontrivial)
Goal: ∑ a : R, χ a = 0
-- MulChar.sum_one_eq_card_units
theorem sum_one_eq_card_units [DecidableEq R] :
    (∑ a, (1 : MulChar R R') a) = Fintype.card Rˣ 
Arguments: {R : Type u_1} [CommMonoid R] [Fintype R] {R' : Type u_2} [CommRing R'] [DecidableEq R]
Goal: ∑ a : R, 1 a = ↑(Fintype.card Rˣ)
-- MulChar.val_neg_one_eq_one_of_odd_order
lemma val_neg_one_eq_one_of_odd_order {χ : MulChar R R'} {n : ℕ} (hn : Odd n) (hχ : χ ^ n = 1) :
    χ (-1) = 1 
Arguments: {R : Type u_1} {R' : Type u_2} [CommRing R] [CommMonoidWithZero R'] {χ : MulChar R R'} {n : ℕ} (hn : Odd n) (hχ : χ ^ n = 1)
Goal: χ (-1) = 1
-- PadicInt.ext
theorem ext {x y : ℤ_[p]} : (x : ℚ_[p]) = y → x = y 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {x y : ℤ_[p]}
Goal: ↑x = ↑y → x = y
-- PadicInt.mem_subring_iff
@[simp]
theorem mem_subring_iff {x : ℚ_[p]} : x ∈ subring p ↔ ‖x‖ ≤ 1 
Arguments: (p : ℕ) [Fact (Nat.Prime p)] {x : ℚ_[p]}
Goal: x ∈ PadicInt.subring p ↔ ‖x‖ ≤ 1
-- PadicInt.mk_zero
@[simp]
theorem mk_zero {h} : (⟨0, h⟩ : ℤ_[p]) = (0 : ℤ_[p]) 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {h : ‖0‖ ≤ 1}
Goal: ⟨0, h⟩ = 0
-- PadicInt.coe_add
@[simp, norm_cast]
theorem coe_add (z1 z2 : ℤ_[p]) : ((z1 + z2 : ℤ_[p]) : ℚ_[p]) = z1 + z2 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] (z1 z2 : ℤ_[p])
Goal: ↑(z1 + z2) = ↑z1 + ↑z2
-- PadicInt.coe_mul
@[simp, norm_cast]
theorem coe_mul (z1 z2 : ℤ_[p]) : ((z1 * z2 : ℤ_[p]) : ℚ_[p]) = z1 * z2 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] (z1 z2 : ℤ_[p])
Goal: ↑(z1 * z2) = ↑z1 * ↑z2
-- PadicInt.coe_neg
@[simp, norm_cast]
theorem coe_neg (z1 : ℤ_[p]) : ((-z1 : ℤ_[p]) : ℚ_[p]) = -z1 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] (z1 : ℤ_[p])
Goal: ↑(-z1) = -↑z1
-- PadicInt.coe_sub
@[simp, norm_cast]
theorem coe_sub (z1 z2 : ℤ_[p]) : ((z1 - z2 : ℤ_[p]) : ℚ_[p]) = z1 - z2 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] (z1 z2 : ℤ_[p])
Goal: ↑(z1 - z2) = ↑z1 - ↑z2
-- PadicInt.coe_one
@[simp, norm_cast]
theorem coe_one : ((1 : ℤ_[p]) : ℚ_[p]) = 1 
Arguments: {p : ℕ} [Fact (Nat.Prime p)]
Goal: ↑1 = 1
-- PadicInt.coe_zero
@[simp, norm_cast]
theorem coe_zero : ((0 : ℤ_[p]) : ℚ_[p]) = 0 
Arguments: {p : ℕ} [Fact (Nat.Prime p)]
Goal: ↑0 = 0
-- PadicInt.coe_eq_zero
theorem coe_eq_zero (z : ℤ_[p]) : (z : ℚ_[p]) = 0 ↔ z = 0 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] (z : ℤ_[p])
Goal: ↑z = 0 ↔ z = 0
-- PadicInt.coe_ne_zero
theorem coe_ne_zero (z : ℤ_[p]) : (z : ℚ_[p]) ≠ 0 ↔ z ≠ 0 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] (z : ℤ_[p])
Goal: ↑z ≠ 0 ↔ z ≠ 0
-- PadicInt.coe_natCast
@[simp, norm_cast]
theorem coe_natCast (n : ℕ) : ((n : ℤ_[p]) : ℚ_[p]) = n 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] (n : ℕ)
Goal: ↑↑n = ↑n
-- PadicInt.coe_intCast
@[simp, norm_cast]
theorem coe_intCast (z : ℤ) : ((z : ℤ_[p]) : ℚ_[p]) = z 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] (z : ℤ)
Goal: ↑↑z = ↑z
-- PadicInt.coe_pow
@[simp, norm_cast]
theorem coe_pow (x : ℤ_[p]) (n : ℕ) : (↑(x ^ n) : ℚ_[p]) = (↑x : ℚ_[p]) ^ n 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] (x : ℤ_[p]) (n : ℕ)
Goal: ↑(x ^ n) = ↑x ^ n
-- PadicInt.mk_coe
theorem mk_coe (k : ℤ_[p]) : (⟨k, k.2⟩ : ℤ_[p]) = k 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] (k : ℤ_[p])
Goal: ⟨↑k, ⋯⟩ = k
-- PadicInt.intCast_eq
@[norm_cast] -- @[simp] -- Porting note: not in simpNF
theorem intCast_eq (z1 z2 : ℤ) : (z1 : ℤ_[p]) = z2 ↔ z1 = z2 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] (z1 z2 : ℤ)
Goal: ↑z1 = ↑z2 ↔ z1 = z2
-- PadicInt.norm_def
theorem norm_def {z : ℤ_[p]} : ‖z‖ = ‖(z : ℚ_[p])‖ 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {z : ℤ_[p]}
Goal: ‖z‖ = ‖↑z‖