ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- quadraticChar_zero
theorem quadraticChar_zero : quadraticChar F 0 = 0 
Arguments: {F : Type u_1} [Field F] [Fintype F] [DecidableEq F]
Goal: (quadraticChar F) 0 = 0
-- quadraticChar_one_iff_isSquare
theorem quadraticChar_one_iff_isSquare {a : F} (ha : a ≠ 0) :
    quadraticChar F a = 1 ↔ IsSquare a 
Arguments: {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {a : F} (ha : a ≠ 0)
Goal: (quadraticChar F) a = 1 ↔ IsSquare a
-- quadraticChar_sq_one'
theorem quadraticChar_sq_one' {a : F} (ha : a ≠ 0) : quadraticChar F (a ^ 2) = 1 
Arguments: {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {a : F} (ha : a ≠ 0)
Goal: (quadraticChar F) (a ^ 2) = 1
-- quadraticChar_sq_one
theorem quadraticChar_sq_one {a : F} (ha : a ≠ 0) : quadraticChar F a ^ 2 = 1 
Arguments: {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {a : F} (ha : a ≠ 0)
Goal: (quadraticChar F) a ^ 2 = 1
-- quadraticChar_dichotomy
theorem quadraticChar_dichotomy {a : F} (ha : a ≠ 0) :
    quadraticChar F a = 1 ∨ quadraticChar F a = -1 
Arguments: {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {a : F} (ha : a ≠ 0)
Goal: (quadraticChar F) a = 1 ∨ (quadraticChar F) a = -1
-- quadraticChar_eq_neg_one_iff_not_one
theorem quadraticChar_eq_neg_one_iff_not_one {a : F} (ha : a ≠ 0) :
    quadraticChar F a = -1 ↔ ¬quadraticChar F a = 1 
Arguments: {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {a : F} (ha : a ≠ 0)
Goal: (quadraticChar F) a = -1 ↔ ¬(quadraticChar F) a = 1
-- quadraticChar_neg_one_iff_not_isSquare
theorem quadraticChar_neg_one_iff_not_isSquare {a : F} : quadraticChar F a = -1 ↔ ¬IsSquare a 
Arguments: {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {a : F}
Goal: (quadraticChar F) a = -1 ↔ ¬IsSquare a
-- quadraticChar_exists_neg_one
theorem quadraticChar_exists_neg_one (hF : ringChar F ≠ 2) : ∃ a, quadraticChar F a = -1 
Arguments: {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] (hF : ringChar F ≠ 2)
Goal: ∃ a, (quadraticChar F) a = -1
-- quadraticChar_exists_neg_one'
lemma quadraticChar_exists_neg_one' (hF : ringChar F ≠ 2) : ∃ a : Fˣ, quadraticChar F a = -1 
Arguments: {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] (hF : ringChar F ≠ 2)
Goal: ∃ a, (quadraticChar F) ↑a = -1
-- quadraticChar_eq_one_of_char_two
theorem quadraticChar_eq_one_of_char_two (hF : ringChar F = 2) {a : F} (ha : a ≠ 0) :
    quadraticChar F a = 1 
Arguments: {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] (hF : ringChar F = 2) {a : F} (ha : a ≠ 0)
Goal: (quadraticChar F) a = 1
-- quadraticChar_eq_pow_of_char_ne_two
theorem quadraticChar_eq_pow_of_char_ne_two (hF : ringChar F ≠ 2) {a : F} (ha : a ≠ 0) :
    quadraticChar F a = if a ^ (Fintype.card F / 2) = 1 then 1 else -1 
Arguments: {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] (hF : ringChar F ≠ 2) {a : F} (ha : a ≠ 0)
Goal: (quadraticChar F) a = if a ^ (Fintype.card F / 2) = 1 then 1 else -1
-- quadraticChar_eq_pow_of_char_ne_two'
theorem quadraticChar_eq_pow_of_char_ne_two' (hF : ringChar F ≠ 2) (a : F) :
    (quadraticChar F a : F) = a ^ (Fintype.card F / 2) 
Arguments: {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] (hF : ringChar F ≠ 2) (a : F)
Goal: ↑((quadraticChar F) a) = a ^ (Fintype.card F / 2)
-- quadraticChar_isQuadratic
theorem quadraticChar_isQuadratic : (quadraticChar F).IsQuadratic 
Arguments: (F : Type u_1) [Field F] [Fintype F] [DecidableEq F]
Goal: (quadraticChar F).IsQuadratic
-- quadraticChar_ne_one
theorem quadraticChar_ne_one (hF : ringChar F ≠ 2) : quadraticChar F ≠ 1 
Arguments: {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] (hF : ringChar F ≠ 2)
Goal: quadraticChar F ≠ 1
-- quadraticChar_isNontrivial
@[deprecated quadraticChar_ne_one (since := "2024-06-16")]
theorem quadraticChar_isNontrivial (hF : ringChar F ≠ 2) : (quadraticChar F).IsNontrivial 
Arguments: {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] (hF : ringChar F ≠ 2)
Goal: (quadraticChar F).IsNontrivial
-- quadraticChar_card_sqrts
theorem quadraticChar_card_sqrts (hF : ringChar F ≠ 2) (a : F) :
    ↑{x : F | x ^ 2 = a}.toFinset.card = quadraticChar F a + 1 
Arguments: {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] (hF : ringChar F ≠ 2) (a : F)
Goal: ↑{x | x ^ 2 = a}.toFinset.card = (quadraticChar F) a + 1
-- quadraticChar_sum_zero
theorem quadraticChar_sum_zero (hF : ringChar F ≠ 2) : ∑ a : F, quadraticChar F a = 0 
Arguments: {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] (hF : ringChar F ≠ 2)
Goal: ∑ a : F, (quadraticChar F) a = 0
-- quadraticChar_neg_one
theorem quadraticChar_neg_one [DecidableEq F] (hF : ringChar F ≠ 2) :
    quadraticChar F (-1) = χ₄ (Fintype.card F) 
Arguments: {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] (hF : ringChar F ≠ 2)
Goal: (quadraticChar F) (-1) = ZMod.χ₄ ↑(Fintype.card F)
-- FiniteField.isSquare_neg_one_iff
theorem FiniteField.isSquare_neg_one_iff : IsSquare (-1 : F) ↔ Fintype.card F % 4 ≠ 3 
Arguments: {F : Type u_1} [Field F] [Fintype F]
Goal: IsSquare (-1) ↔ Fintype.card F % 4 ≠ 3
-- HurwitzKernelBounds.isBigO_exp_neg_mul_of_le
lemma isBigO_exp_neg_mul_of_le {c d : ℝ} (hcd : c ≤ d) :
    (fun t ↦ exp (-d * t)) =O[atTop] fun t ↦ exp (-c * t) 
Arguments: {c d : ℝ} (hcd : c ≤ d)
Goal: (fun t => rexp (-d * t)) =O[Filter.atTop] fun t => rexp (-c * t)
-- _private.Mathlib.NumberTheory.ModularForms.JacobiTheta.Bounds.0.HurwitzKernelBounds.exp_lt_aux
private lemma exp_lt_aux {t : ℝ} (ht : 0 < t) : rexp (-π * t) < 1 
Arguments: {t : ℝ} (ht : 0 < t)
Goal: rexp (-π * t) < 1
-- _private.Mathlib.NumberTheory.ModularForms.JacobiTheta.Bounds.0.HurwitzKernelBounds.isBigO_one_aux
private lemma isBigO_one_aux :
    IsBigO atTop (fun t : ℝ ↦ (1 - rexp (-π * t))⁻¹) (fun _ ↦ (1 : ℝ)) 
Goal: (fun t => (1 - rexp (-π * t))⁻¹) =O[Filter.atTop] fun x => 1
-- HurwitzKernelBounds.f_le_g_nat
lemma f_le_g_nat (k : ℕ) {a t : ℝ} (ha : 0 ≤ a) (ht : 0 < t) (n : ℕ) :
    ‖f_nat k a t n‖ ≤ g_nat k a t n 
Arguments: (k : ℕ) {a t : ℝ} (ha : 0 ≤ a) (ht : 0 < t) (n : ℕ)
Goal: ‖HurwitzKernelBounds.f_nat k a t n‖ ≤ HurwitzKernelBounds.g_nat k a t n
-- HurwitzKernelBounds.summable_f_nat
lemma summable_f_nat (k : ℕ) (a : ℝ) {t : ℝ} (ht : 0 < t) : Summable (f_nat k a t) 
Arguments: (k : ℕ) (a : ℝ) {t : ℝ} (ht : 0 < t)
Goal: Summable (HurwitzKernelBounds.f_nat k a t)
-- HurwitzKernelBounds.F_nat_zero_le
lemma F_nat_zero_le {a : ℝ} (ha : 0 ≤ a) {t : ℝ} (ht : 0 < t) :
    ‖F_nat 0 a t‖ ≤ rexp (-π * a ^ 2 * t) / (1 - rexp (-π * t)) 
Arguments: {a : ℝ} (ha : 0 ≤ a) {t : ℝ} (ht : 0 < t)
Goal: ‖HurwitzKernelBounds.F_nat 0 a t‖ ≤ rexp (-π * a ^ 2 * t) / (1 - rexp (-π * t))
-- HurwitzKernelBounds.F_nat_zero_zero_sub_le
lemma F_nat_zero_zero_sub_le {t : ℝ} (ht : 0 < t) :
    ‖F_nat 0 0 t - 1‖ ≤ rexp (-π * t) / (1 - rexp (-π * t)) 
Arguments: {t : ℝ} (ht : 0 < t)
Goal: ‖HurwitzKernelBounds.F_nat 0 0 t - 1‖ ≤ rexp (-π * t) / (1 - rexp (-π * t))
-- HurwitzKernelBounds.isBigO_atTop_F_nat_zero_sub
lemma isBigO_atTop_F_nat_zero_sub {a : ℝ} (ha : 0 ≤ a) : ∃ p, 0 < p ∧
    (fun t ↦ F_nat 0 a t - (if a = 0 then 1 else 0)) =O[atTop] fun t ↦ exp (-p * t) 
Arguments: {a : ℝ} (ha : 0 ≤ a)
Goal: ∃ p, 0 < p ∧ (fun t => HurwitzKernelBounds.F_nat 0 a t - if a = 0 then 1 else 0) =O[Filter.atTop] fun t => rexp (-p * t)
-- HurwitzKernelBounds.F_nat_one_le
lemma F_nat_one_le {a : ℝ} (ha : 0 ≤ a) {t : ℝ} (ht : 0 < t) :
    ‖F_nat 1 a t‖ ≤ rexp (-π * (a ^ 2 + 1) * t) / (1 - rexp (-π * t)) ^ 2
      + a * rexp (-π * a ^ 2 * t) / (1 - rexp (-π * t)) 
Arguments: {a : ℝ} (ha : 0 ≤ a) {t : ℝ} (ht : 0 < t)
Goal: ‖HurwitzKernelBounds.F_nat 1 a t‖ ≤
  rexp (-π * (a ^ 2 + 1) * t) / (1 - rexp (-π * t)) ^ 2 + a * rexp (-π * a ^ 2 * t) / (1 - rexp (-π * t))
-- HurwitzKernelBounds.isBigO_atTop_F_nat_one
lemma isBigO_atTop_F_nat_one {a : ℝ} (ha : 0 ≤ a) : ∃ p, 0 < p ∧
    F_nat 1 a =O[atTop] fun t ↦ exp (-p * t) 
Arguments: {a : ℝ} (ha : 0 ≤ a)
Goal: ∃ p, 0 < p ∧ HurwitzKernelBounds.F_nat 1 a =O[Filter.atTop] fun t => rexp (-p * t)
-- HurwitzKernelBounds.f_int_ofNat
lemma f_int_ofNat (k : ℕ) {a : ℝ} (ha : 0 ≤ a) (t : ℝ) (n : ℕ) :
    f_int k a t (Int.ofNat n) = f_nat k a t n 
Arguments: (k : ℕ) {a : ℝ} (ha : 0 ≤ a) (t : ℝ) (n : ℕ)
Goal: HurwitzKernelBounds.f_int k a t (Int.ofNat n) = HurwitzKernelBounds.f_nat k a t n
-- HurwitzKernelBounds.f_int_negSucc
lemma f_int_negSucc (k : ℕ) {a : ℝ} (ha : a ≤ 1) (t : ℝ) (n : ℕ) :
    f_int k a t (Int.negSucc n) = f_nat k (1 - a) t n 
Arguments: (k : ℕ) {a : ℝ} (ha : a ≤ 1) (t : ℝ) (n : ℕ)
Goal: HurwitzKernelBounds.f_int k a t (Int.negSucc n) = HurwitzKernelBounds.f_nat k (1 - a) t n
-- HurwitzKernelBounds.summable_f_int
lemma summable_f_int (k : ℕ) (a : ℝ) {t : ℝ} (ht : 0 < t) : Summable (f_int k a t) 
Arguments: (k : ℕ) (a : ℝ) {t : ℝ} (ht : 0 < t)
Goal: Summable (HurwitzKernelBounds.f_int k a t)
-- HurwitzKernelBounds.F_int_eq_of_mem_Icc
lemma F_int_eq_of_mem_Icc (k : ℕ) {a : ℝ} (ha : a ∈ Icc 0 1) {t : ℝ} (ht : 0 < t) :
    F_int k a t = (F_nat k a t) + (F_nat k (1 - a) t) 
Arguments: (k : ℕ) {a : ℝ} (ha : a ∈ Set.Icc 0 1) {t : ℝ} (ht : 0 < t)
Goal: HurwitzKernelBounds.F_int k (↑a) t = HurwitzKernelBounds.F_nat k a t + HurwitzKernelBounds.F_nat k (1 - a) t
-- HurwitzKernelBounds.isBigO_atTop_F_int_zero_sub
lemma isBigO_atTop_F_int_zero_sub (a : UnitAddCircle) : ∃ p, 0 < p ∧
    (fun t ↦ F_int 0 a t - (if a = 0 then 1 else 0)) =O[atTop] fun t ↦ exp (-p * t) 
Arguments: (a : UnitAddCircle)
Goal: ∃ p, 0 < p ∧ (fun t => HurwitzKernelBounds.F_int 0 a t - if a = 0 then 1 else 0) =O[Filter.atTop] fun t => rexp (-p * t)
-- HurwitzKernelBounds.isBigO_atTop_F_int_one
lemma isBigO_atTop_F_int_one (a : UnitAddCircle) : ∃ p, 0 < p ∧
    F_int 1 a =O[atTop] fun t ↦ exp (-p * t) 
Arguments: (a : UnitAddCircle)
Goal: ∃ p, 0 < p ∧ HurwitzKernelBounds.F_int 1 a =O[Filter.atTop] fun t => rexp (-p * t)
-- quadraticChar_two
theorem quadraticChar_two [DecidableEq F] (hF : ringChar F ≠ 2) :
    quadraticChar F 2 = χ₈ (Fintype.card F) 
Arguments: {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] (hF : ringChar F ≠ 2)
Goal: (quadraticChar F) 2 = ZMod.χ₈ ↑(Fintype.card F)
-- FiniteField.isSquare_two_iff
theorem FiniteField.isSquare_two_iff :
    IsSquare (2 : F) ↔ Fintype.card F % 8 ≠ 3 ∧ Fintype.card F % 8 ≠ 5 
Arguments: {F : Type u_1} [Field F] [Fintype F]
Goal: IsSquare 2 ↔ Fintype.card F % 8 ≠ 3 ∧ Fintype.card F % 8 ≠ 5
-- quadraticChar_neg_two
theorem quadraticChar_neg_two [DecidableEq F] (hF : ringChar F ≠ 2) :
    quadraticChar F (-2) = χ₈' (Fintype.card F) 
Arguments: {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] (hF : ringChar F ≠ 2)
Goal: (quadraticChar F) (-2) = ZMod.χ₈' ↑(Fintype.card F)
-- FiniteField.isSquare_neg_two_iff
theorem FiniteField.isSquare_neg_two_iff :
    IsSquare (-2 : F) ↔ Fintype.card F % 8 ≠ 5 ∧ Fintype.card F % 8 ≠ 7 
Arguments: {F : Type u_1} [Field F] [Fintype F]
Goal: IsSquare (-2) ↔ Fintype.card F % 8 ≠ 5 ∧ Fintype.card F % 8 ≠ 7
-- quadraticChar_card_card
theorem quadraticChar_card_card [DecidableEq F] (hF : ringChar F ≠ 2) {F' : Type*} [Field F']
    [Fintype F'] [DecidableEq F'] (hF' : ringChar F' ≠ 2) (h : ringChar F' ≠ ringChar F) :
    quadraticChar F (Fintype.card F') =
    quadraticChar F' (quadraticChar F (-1) * Fintype.card F) 
Arguments: {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] (hF : ringChar F ≠ 2) {F' : Type u_2} [Field F'] [Fintype F'] [DecidableEq F'] (hF' : ringChar F' ≠ 2) (h : ringChar F' ≠ ringChar F)
Goal: (quadraticChar F) ↑(Fintype.card F') = (quadraticChar F') (↑((quadraticChar F) (-1)) * ↑(Fintype.card F))
-- quadraticChar_odd_prime
theorem quadraticChar_odd_prime [DecidableEq F] (hF : ringChar F ≠ 2) {p : ℕ} [Fact p.Prime]
    (hp₁ : p ≠ 2) (hp₂ : ringChar F ≠ p) :
    quadraticChar F p = quadraticChar (ZMod p) (χ₄ (Fintype.card F) * Fintype.card F) 
Arguments: {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] (hF : ringChar F ≠ 2) {p : ℕ} [Fact (Nat.Prime p)] (hp₁ : p ≠ 2) (hp₂ : ringChar F ≠ p)
Goal: (quadraticChar F) ↑p = (quadraticChar (ZMod p)) (↑(ZMod.χ₄ ↑(Fintype.card F)) * ↑(Fintype.card F))
-- FiniteField.isSquare_odd_prime_iff
theorem FiniteField.isSquare_odd_prime_iff (hF : ringChar F ≠ 2) {p : ℕ} [Fact p.Prime]
    (hp : p ≠ 2) :
    IsSquare (p : F) ↔ quadraticChar (ZMod p) (χ₄ (Fintype.card F) * Fintype.card F) ≠ -1 
Arguments: {F : Type u_1} [Field F] [Fintype F] (hF : ringChar F ≠ 2) {p : ℕ} [Fact (Nat.Prime p)] (hp : p ≠ 2)
Goal: IsSquare ↑p ↔ (quadraticChar (ZMod p)) (↑(ZMod.χ₄ ↑(Fintype.card F)) * ↑(Fintype.card F)) ≠ -1
-- AddChar.val_mem_rootsOfUnity
lemma val_mem_rootsOfUnity (φ : AddChar R R') (a : R) (h : 0 < ringChar R) :
    (φ.val_isUnit a).unit ∈ rootsOfUnity (ringChar R).toPNat' R' 
Arguments: {R : Type u} [CommRing R] {R' : Type v} [CommMonoid R'] (φ : AddChar R R') (a : R) (h : 0 < ringChar R)
Goal: ⋯.unit ∈ rootsOfUnity (ringChar R).toPNat' R'
-- AddChar.IsPrimitive.compMulHom_of_isPrimitive
lemma IsPrimitive.compMulHom_of_isPrimitive {R'' : Type*} [CommMonoid R''] {φ : AddChar R R'}
    {f : R' →* R''} (hφ : φ.IsPrimitive) (hf : Function.Injective f) :
    (f.compAddChar φ).IsPrimitive 
Arguments: {R : Type u} [CommRing R] {R' : Type v} [CommMonoid R'] {R'' : Type u_1} [CommMonoid R''] {φ : AddChar R R'} {f : R' →* R''} (hφ : φ.IsPrimitive) (hf : Function.Injective ⇑f)
Goal: (f.compAddChar φ).IsPrimitive
-- AddChar.to_mulShift_inj_of_isPrimitive
theorem to_mulShift_inj_of_isPrimitive {ψ : AddChar R R'} (hψ : IsPrimitive ψ) :
    Function.Injective ψ.mulShift 
Arguments: {R : Type u} [CommRing R] {R' : Type v} [CommMonoid R'] {ψ : AddChar R R'} (hψ : ψ.IsPrimitive)
Goal: Function.Injective ψ.mulShift
-- AddChar.IsPrimitive.of_ne_one
theorem IsPrimitive.of_ne_one {F : Type u} [Field F] {ψ : AddChar F R'} (hψ : ψ ≠ 1) :
    IsPrimitive ψ 
Arguments: {R' : Type v} [CommMonoid R'] {F : Type u} [Field F] {ψ : AddChar F R'} (hψ : ψ ≠ 1)
Goal: ψ.IsPrimitive
-- AddChar.not_isPrimitive_mulShift
lemma not_isPrimitive_mulShift [Finite R] (e : AddChar R R') {r : R}
    (hr : ¬ IsUnit r) : ¬ IsPrimitive (e.mulShift r) 
Arguments: {R : Type u} [CommRing R] {R' : Type v} [CommMonoid R'] [Finite R] (e : AddChar R R') {r : R} (hr : ¬IsUnit r)
Goal: ¬(e.mulShift r).IsPrimitive
-- AddChar.PrimitiveAddChar.prim
-- Porting note(#5171): this linter isn't ported yet.
-- can't prove that they always exist (referring to providing an `Inhabited` instance)
-- @[nolint has_nonempty_instance]
structure PrimitiveAddChar (R : Type u) [CommRing R] (R' : Type v) [Field R'] where
    n : ℕ+
    char : AddChar R (CyclotomicField n R')
    prim : IsPrimitive char
Arguments: {R : Type u} [CommRing R] {R' : Type v} [Field R'] (self : AddChar.PrimitiveAddChar R R')
Goal: self.char.IsPrimitive
-- AddChar.exists_divisor_of_not_isPrimitive
lemma exists_divisor_of_not_isPrimitive (he : ¬e.IsPrimitive) :
    ∃ d : ℕ, d ∣ N ∧ d < N ∧ e.mulShift d = 1 
Arguments: {N : ℕ} [NeZero N] {R : Type u_1} [CommRing R] (e : AddChar (ZMod N) R) (he : ¬e.IsPrimitive)
Goal: ∃ d, d ∣ N ∧ d < N ∧ e.mulShift ↑d = 1
-- AddChar.zmodChar_apply
theorem zmodChar_apply {n : ℕ} [NeZero n] {ζ : C} (hζ : ζ ^ n = 1) (a : ZMod n) :
    zmodChar n hζ a = ζ ^ a.val 
Arguments: {C : Type v} [CommMonoid C] {n : ℕ} [NeZero n] {ζ : C} (hζ : ζ ^ n = 1) (a : ZMod n)
Goal: (AddChar.zmodChar n hζ) a = ζ ^ a.val
-- AddChar.zmodChar_apply'
theorem zmodChar_apply' {n : ℕ} [NeZero n] {ζ : C} (hζ : ζ ^ n = 1) (a : ℕ) :
    zmodChar n hζ a = ζ ^ a 
Arguments: {C : Type v} [CommMonoid C] {n : ℕ} [NeZero n] {ζ : C} (hζ : ζ ^ n = 1) (a : ℕ)
Goal: (AddChar.zmodChar n hζ) ↑a = ζ ^ a
-- AddChar.zmod_char_ne_one_iff
theorem zmod_char_ne_one_iff (n : ℕ) [NeZero n] (ψ : AddChar (ZMod n) C) : ψ ≠ 1 ↔ ψ 1 ≠ 1 
Arguments: {C : Type v} [CommMonoid C] (n : ℕ) [NeZero n] (ψ : AddChar (ZMod n) C)
Goal: ψ ≠ 1 ↔ ψ 1 ≠ 1
-- AddChar.IsPrimitive.zmod_char_eq_one_iff
theorem IsPrimitive.zmod_char_eq_one_iff (n : ℕ) [NeZero n]
    {ψ : AddChar (ZMod n) C} (hψ : IsPrimitive ψ) (a : ZMod n) :
    ψ a = 1 ↔ a = 0 
Arguments: {C : Type v} [CommMonoid C] (n : ℕ) [NeZero n] {ψ : AddChar (ZMod n) C} (hψ : ψ.IsPrimitive) (a : ZMod n)
Goal: ψ a = 1 ↔ a = 0
-- AddChar.zmod_char_primitive_of_eq_one_only_at_zero
theorem zmod_char_primitive_of_eq_one_only_at_zero (n : ℕ) (ψ : AddChar (ZMod n) C)
    (hψ : ∀ a, ψ a = 1 → a = 0) : IsPrimitive ψ 
Arguments: {C : Type v} [CommMonoid C] (n : ℕ) (ψ : AddChar (ZMod n) C) (hψ : ∀ (a : ZMod n), ψ a = 1 → a = 0)
Goal: ψ.IsPrimitive
-- AddChar.zmodChar_primitive_of_primitive_root
theorem zmodChar_primitive_of_primitive_root (n : ℕ) [NeZero n] {ζ : C} (h : IsPrimitiveRoot ζ n) :
    IsPrimitive (zmodChar n ((IsPrimitiveRoot.iff_def ζ n).mp h).left) 
Arguments: {C : Type v} [CommMonoid C] (n : ℕ) [NeZero n] {ζ : C} (h : IsPrimitiveRoot ζ n)
Goal: (AddChar.zmodChar n ⋯).IsPrimitive
-- AddChar.sum_eq_zero_of_ne_one
theorem sum_eq_zero_of_ne_one [IsDomain R'] {ψ : AddChar R R'} (hψ : ψ ≠ 1) : ∑ a, ψ a = 0 
Arguments: {R : Type u_1} [AddGroup R] [Fintype R] {R' : Type u_2} [CommRing R'] [IsDomain R'] {ψ : AddChar R R'} (hψ : ψ ≠ 1)
Goal: ∑ a : R, ψ a = 0
-- AddChar.sum_eq_card_of_eq_one
theorem sum_eq_card_of_eq_one {ψ : AddChar R R'} (hψ : ψ = 1) :
    ∑ a, ψ a = Fintype.card R 
Arguments: {R : Type u_1} [AddGroup R] [Fintype R] {R' : Type u_2} [CommRing R'] {ψ : AddChar R R'} (hψ : ψ = 1)
Goal: ∑ a : R, ψ a = ↑(Fintype.card R)
-- AddChar.sum_mulShift
theorem sum_mulShift {R : Type*} [CommRing R] [Fintype R] [DecidableEq R]
    {R' : Type*} [CommRing R'] [IsDomain R'] {ψ : AddChar R R'} (b : R)
    (hψ : IsPrimitive ψ) : ∑ x : R, ψ (x * b) = if b = 0 then Fintype.card R else 0 
Arguments: {R : Type u_1} [CommRing R] [Fintype R] [DecidableEq R] {R' : Type u_2} [CommRing R'] [IsDomain R'] {ψ : AddChar R R'} (b : R) (hψ : ψ.IsPrimitive)
Goal: ∑ x : R, ψ (x * b) = ↑(if b = 0 then Fintype.card R else 0)
-- AddChar.starComp_eq_inv
lemma starComp_eq_inv (hR : 0 < ringChar R) {φ : AddChar R ℂ} :
    (starRingEnd ℂ).compAddChar φ = φ⁻¹ 
Arguments: {R : Type u_1} [CommRing R] (hR : 0 < ringChar R) {φ : AddChar R ℂ}
Goal: (↑(starRingEnd ℂ)).compAddChar φ = φ⁻¹
-- AddChar.starComp_apply
lemma starComp_apply (hR : 0 < ringChar R) {φ : AddChar R ℂ} (a : R) :
    (starRingEnd ℂ) (φ a) = φ⁻¹ a 
Arguments: {R : Type u_1} [CommRing R] (hR : 0 < ringChar R) {φ : AddChar R ℂ} (a : R)
Goal: (starRingEnd ℂ) (φ a) = φ⁻¹ a
-- _private.Mathlib.NumberTheory.LegendreSymbol.AddCharacter.0.AddChar.ringChar_ne
private lemma ringChar_ne : ringChar ℂ ≠ ringChar F 
Arguments: (F : Type u_1) [Field F] [Finite F]
Goal: ringChar ℂ ≠ ringChar F
-- AddChar.FiniteField.primitiveChar_to_Complex_isPrimitive
lemma FiniteField.primitiveChar_to_Complex_isPrimitive :
    (primitiveChar_to_Complex F).IsPrimitive 
Arguments: (F : Type u_1) [Field F] [Finite F]
Goal: (AddChar.FiniteField.primitiveChar_to_Complex F).IsPrimitive
-- liouvilleWith_one
theorem liouvilleWith_one (x : ℝ) : LiouvilleWith 1 x 
Arguments: (x : ℝ)
Goal: LiouvilleWith 1 x
-- LiouvilleWith.exists_pos
theorem exists_pos (h : LiouvilleWith p x) :
    ∃ (C : ℝ) (_h₀ : 0 < C),
      ∃ᶠ n : ℕ in atTop, 1 ≤ n ∧ ∃ m : ℤ, x ≠ m / n ∧ |x - m / n| < C / n ^ p 
Arguments: {p x : ℝ} (h : LiouvilleWith p x)
Goal: ∃ C, ∃ (_ : 0 < C), ∃ᶠ (n : ℕ) in Filter.atTop, 1 ≤ n ∧ ∃ m, x ≠ ↑m / ↑n ∧ |x - ↑m / ↑n| < C / ↑n ^ p
-- LiouvilleWith.mono
theorem mono (h : LiouvilleWith p x) (hle : q ≤ p) : LiouvilleWith q x 
Arguments: {p q x : ℝ} (h : LiouvilleWith p x) (hle : q ≤ p)
Goal: LiouvilleWith q x
-- LiouvilleWith.frequently_lt_rpow_neg
theorem frequently_lt_rpow_neg (h : LiouvilleWith p x) (hlt : q < p) :
    ∃ᶠ n : ℕ in atTop, ∃ m : ℤ, x ≠ m / n ∧ |x - m / n| < n ^ (-q) 
Arguments: {p q x : ℝ} (h : LiouvilleWith p x) (hlt : q < p)
Goal: ∃ᶠ (n : ℕ) in Filter.atTop, ∃ m, x ≠ ↑m / ↑n ∧ |x - ↑m / ↑n| < ↑n ^ (-q)
-- LiouvilleWith.mul_rat
theorem mul_rat (h : LiouvilleWith p x) (hr : r ≠ 0) : LiouvilleWith p (x * r) 
Arguments: {p x : ℝ} {r : ℚ} (h : LiouvilleWith p x) (hr : r ≠ 0)
Goal: LiouvilleWith p (x * ↑r)
-- LiouvilleWith.mul_rat_iff
theorem mul_rat_iff (hr : r ≠ 0) : LiouvilleWith p (x * r) ↔ LiouvilleWith p x 
Arguments: {p x : ℝ} {r : ℚ} (hr : r ≠ 0)
Goal: LiouvilleWith p (x * ↑r) ↔ LiouvilleWith p x
-- LiouvilleWith.rat_mul_iff
theorem rat_mul_iff (hr : r ≠ 0) : LiouvilleWith p (r * x) ↔ LiouvilleWith p x 
Arguments: {p x : ℝ} {r : ℚ} (hr : r ≠ 0)
Goal: LiouvilleWith p (↑r * x) ↔ LiouvilleWith p x
-- LiouvilleWith.rat_mul
theorem rat_mul (h : LiouvilleWith p x) (hr : r ≠ 0) : LiouvilleWith p (r * x) 
Arguments: {p x : ℝ} {r : ℚ} (h : LiouvilleWith p x) (hr : r ≠ 0)
Goal: LiouvilleWith p (↑r * x)
-- LiouvilleWith.mul_int_iff
theorem mul_int_iff (hm : m ≠ 0) : LiouvilleWith p (x * m) ↔ LiouvilleWith p x 
Arguments: {p x : ℝ} {m : ℤ} (hm : m ≠ 0)
Goal: LiouvilleWith p (x * ↑m) ↔ LiouvilleWith p x
-- LiouvilleWith.mul_int
theorem mul_int (h : LiouvilleWith p x) (hm : m ≠ 0) : LiouvilleWith p (x * m) 
Arguments: {p x : ℝ} {m : ℤ} (h : LiouvilleWith p x) (hm : m ≠ 0)
Goal: LiouvilleWith p (x * ↑m)
-- LiouvilleWith.int_mul_iff
theorem int_mul_iff (hm : m ≠ 0) : LiouvilleWith p (m * x) ↔ LiouvilleWith p x 
Arguments: {p x : ℝ} {m : ℤ} (hm : m ≠ 0)
Goal: LiouvilleWith p (↑m * x) ↔ LiouvilleWith p x
-- LiouvilleWith.int_mul
theorem int_mul (h : LiouvilleWith p x) (hm : m ≠ 0) : LiouvilleWith p (m * x) 
Arguments: {p x : ℝ} {m : ℤ} (h : LiouvilleWith p x) (hm : m ≠ 0)
Goal: LiouvilleWith p (↑m * x)
-- LiouvilleWith.mul_nat_iff
theorem mul_nat_iff (hn : n ≠ 0) : LiouvilleWith p (x * n) ↔ LiouvilleWith p x 
Arguments: {p x : ℝ} {n : ℕ} (hn : n ≠ 0)
Goal: LiouvilleWith p (x * ↑n) ↔ LiouvilleWith p x
-- LiouvilleWith.mul_nat
theorem mul_nat (h : LiouvilleWith p x) (hn : n ≠ 0) : LiouvilleWith p (x * n) 
Arguments: {p x : ℝ} {n : ℕ} (h : LiouvilleWith p x) (hn : n ≠ 0)
Goal: LiouvilleWith p (x * ↑n)
-- LiouvilleWith.nat_mul_iff
theorem nat_mul_iff (hn : n ≠ 0) : LiouvilleWith p (n * x) ↔ LiouvilleWith p x 
Arguments: {p x : ℝ} {n : ℕ} (hn : n ≠ 0)
Goal: LiouvilleWith p (↑n * x) ↔ LiouvilleWith p x
-- LiouvilleWith.nat_mul
theorem nat_mul (h : LiouvilleWith p x) (hn : n ≠ 0) : LiouvilleWith p (n * x) 
Arguments: {p x : ℝ} {n : ℕ} (h : LiouvilleWith p x) (hn : n ≠ 0)
Goal: LiouvilleWith p (↑n * x)
-- LiouvilleWith.add_rat
theorem add_rat (h : LiouvilleWith p x) (r : ℚ) : LiouvilleWith p (x + r) 
Arguments: {p x : ℝ} (h : LiouvilleWith p x) (r : ℚ)
Goal: LiouvilleWith p (x + ↑r)
-- LiouvilleWith.add_rat_iff
@[simp]
theorem add_rat_iff : LiouvilleWith p (x + r) ↔ LiouvilleWith p x 
Arguments: {p x : ℝ} {r : ℚ}
Goal: LiouvilleWith p (x + ↑r) ↔ LiouvilleWith p x
-- LiouvilleWith.rat_add_iff
@[simp]
theorem rat_add_iff : LiouvilleWith p (r + x) ↔ LiouvilleWith p x 
Arguments: {p x : ℝ} {r : ℚ}
Goal: LiouvilleWith p (↑r + x) ↔ LiouvilleWith p x
-- LiouvilleWith.rat_add
theorem rat_add (h : LiouvilleWith p x) (r : ℚ) : LiouvilleWith p (r + x) 
Arguments: {p x : ℝ} (h : LiouvilleWith p x) (r : ℚ)
Goal: LiouvilleWith p (↑r + x)
-- LiouvilleWith.add_int_iff
@[simp]
theorem add_int_iff : LiouvilleWith p (x + m) ↔ LiouvilleWith p x 
Arguments: {p x : ℝ} {m : ℤ}
Goal: LiouvilleWith p (x + ↑m) ↔ LiouvilleWith p x
-- LiouvilleWith.int_add_iff
@[simp]
theorem int_add_iff : LiouvilleWith p (m + x) ↔ LiouvilleWith p x 
Arguments: {p x : ℝ} {m : ℤ}
Goal: LiouvilleWith p (↑m + x) ↔ LiouvilleWith p x
-- LiouvilleWith.add_nat_iff
@[simp]
theorem add_nat_iff : LiouvilleWith p (x + n) ↔ LiouvilleWith p x 
Arguments: {p x : ℝ} {n : ℕ}
Goal: LiouvilleWith p (x + ↑n) ↔ LiouvilleWith p x
-- LiouvilleWith.nat_add_iff
@[simp]
theorem nat_add_iff : LiouvilleWith p (n + x) ↔ LiouvilleWith p x 
Arguments: {p x : ℝ} {n : ℕ}
Goal: LiouvilleWith p (↑n + x) ↔ LiouvilleWith p x
-- LiouvilleWith.add_int
theorem add_int (h : LiouvilleWith p x) (m : ℤ) : LiouvilleWith p (x + m) 
Arguments: {p x : ℝ} (h : LiouvilleWith p x) (m : ℤ)
Goal: LiouvilleWith p (x + ↑m)
-- LiouvilleWith.int_add
theorem int_add (h : LiouvilleWith p x) (m : ℤ) : LiouvilleWith p (m + x) 
Arguments: {p x : ℝ} (h : LiouvilleWith p x) (m : ℤ)
Goal: LiouvilleWith p (↑m + x)
-- LiouvilleWith.add_nat
theorem add_nat (h : LiouvilleWith p x) (n : ℕ) : LiouvilleWith p (x + n) 
Arguments: {p x : ℝ} (h : LiouvilleWith p x) (n : ℕ)
Goal: LiouvilleWith p (x + ↑n)
-- LiouvilleWith.nat_add
theorem nat_add (h : LiouvilleWith p x) (n : ℕ) : LiouvilleWith p (n + x) 
Arguments: {p x : ℝ} (h : LiouvilleWith p x) (n : ℕ)
Goal: LiouvilleWith p (↑n + x)
-- LiouvilleWith.neg
protected theorem neg (h : LiouvilleWith p x) : LiouvilleWith p (-x) 
Arguments: {p x : ℝ} (h : LiouvilleWith p x)
Goal: LiouvilleWith p (-x)