ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- DirichletCharacter.conductor_eq_zero_iff_level_eq_zero
lemma conductor_eq_zero_iff_level_eq_zero : conductor χ = 0 ↔ n = 0 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n : ℕ} {χ : DirichletCharacter R n}
Goal: χ.conductor = 0 ↔ n = 0
-- DirichletCharacter.conductor_le_conductor_mem_conductorSet
lemma conductor_le_conductor_mem_conductorSet {d : ℕ} (hd : d ∈ conductorSet χ) :
    χ.conductor ≤ (Classical.choose hd.2).conductor 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n : ℕ} {χ : DirichletCharacter R n} {d : ℕ} (hd : d ∈ χ.conductorSet)
Goal: χ.conductor ≤ (Classical.choose ⋯).conductor
-- DirichletCharacter.isPrimitive_def
lemma isPrimitive_def : IsPrimitive χ ↔ conductor χ = n 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n : ℕ} (χ : DirichletCharacter R n)
Goal: χ.IsPrimitive ↔ χ.conductor = n
-- DirichletCharacter.isPrimitive_one_level_one
lemma isPrimitive_one_level_one : IsPrimitive (1 : DirichletCharacter R 1) 
Arguments: {R : Type u_1} [CommMonoidWithZero R]
Goal: DirichletCharacter.IsPrimitive 1
-- DirichletCharacter.isPritive_one_level_zero
lemma isPritive_one_level_zero : IsPrimitive (1 : DirichletCharacter R 0) 
Arguments: {R : Type u_1} [CommMonoidWithZero R]
Goal: DirichletCharacter.IsPrimitive 1
-- DirichletCharacter.conductor_one_dvd
lemma conductor_one_dvd (n : ℕ) : conductor (1 : DirichletCharacter R 1) ∣ n 
Arguments: {R : Type u_1} [CommMonoidWithZero R] (n : ℕ)
Goal: DirichletCharacter.conductor 1 ∣ n
-- DirichletCharacter.primitiveCharacter_isPrimitive
lemma primitiveCharacter_isPrimitive : IsPrimitive (χ.primitiveCharacter) 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n : ℕ} (χ : DirichletCharacter R n)
Goal: χ.primitiveCharacter.IsPrimitive
-- DirichletCharacter.primitiveCharacter_one
lemma primitiveCharacter_one (hn : n ≠ 0) :
    (1 : DirichletCharacter R n).primitiveCharacter = 1 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n : ℕ} (hn : n ≠ 0)
Goal: DirichletCharacter.primitiveCharacter 1 = 1
-- DirichletCharacter.mul_def
lemma mul_def {n m : ℕ} {χ : DirichletCharacter R n} {ψ : DirichletCharacter R m} :
    χ.primitive_mul ψ = primitiveCharacter (mul χ ψ) 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n m : ℕ} {χ : DirichletCharacter R n} {ψ : DirichletCharacter R m}
Goal: χ.primitive_mul ψ = (χ.mul ψ).primitiveCharacter
-- DirichletCharacter.primitive_mul_isPrimitive
lemma primitive_mul_isPrimitive {m : ℕ} (ψ : DirichletCharacter R m) :
    IsPrimitive (primitive_mul χ ψ) 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n : ℕ} (χ : DirichletCharacter R n) {m : ℕ} (ψ : DirichletCharacter R m)
Goal: (χ.primitive_mul ψ).IsPrimitive
-- DirichletCharacter.even_or_odd
lemma even_or_odd [NoZeroDivisors S] : ψ.Even ∨ ψ.Odd 
Arguments: {S : Type} [CommRing S] {m : ℕ} (ψ : DirichletCharacter S m) [NoZeroDivisors S]
Goal: ψ.Even ∨ ψ.Odd
-- DirichletCharacter.Odd.toUnitHom_eval_neg_one
lemma Odd.toUnitHom_eval_neg_one (hψ : ψ.Odd) : ψ.toUnitHom (-1) = -1 
Arguments: {S : Type} [CommRing S] {m : ℕ} (ψ : DirichletCharacter S m) (hψ : ψ.Odd)
Goal: (MulChar.toUnitHom ψ) (-1) = -1
-- DirichletCharacter.Even.toUnitHom_eval_neg_one
lemma Even.toUnitHom_eval_neg_one (hψ : ψ.Even) : ψ.toUnitHom (-1) = 1 
Arguments: {S : Type} [CommRing S] {m : ℕ} (ψ : DirichletCharacter S m) (hψ : ψ.Even)
Goal: (MulChar.toUnitHom ψ) (-1) = 1
-- DirichletCharacter.Odd.eval_neg
lemma Odd.eval_neg (x : ZMod m) (hψ : ψ.Odd) : ψ (- x) = - ψ x 
Arguments: {S : Type} [CommRing S] {m : ℕ} (ψ : DirichletCharacter S m) (x : ZMod m) (hψ : ψ.Odd)
Goal: ψ (-x) = -ψ x
-- DirichletCharacter.Even.eval_neg
lemma Even.eval_neg (x : ZMod m) (hψ : ψ.Even) : ψ (- x) = ψ x 
Arguments: {S : Type} [CommRing S] {m : ℕ} (ψ : DirichletCharacter S m) (x : ZMod m) (hψ : ψ.Even)
Goal: ψ (-x) = ψ x
-- EisensteinSeries.pairwise_disjoint_gammaSet
lemma pairwise_disjoint_gammaSet : Pairwise (Disjoint on gammaSet N) 
Arguments: (N : ℕ)
Goal: Pairwise (Disjoint on EisensteinSeries.gammaSet N)
-- EisensteinSeries.gammaSet_one_eq
lemma gammaSet_one_eq (a a' : Fin 2 → ZMod 1) : gammaSet 1 a = gammaSet 1 a' 
Arguments: (a a' : Fin 2 → ZMod 1)
Goal: EisensteinSeries.gammaSet 1 a = EisensteinSeries.gammaSet 1 a'
-- EisensteinSeries.vecMul_SL2_mem_gammaSet
lemma vecMul_SL2_mem_gammaSet {v : Fin 2 → ℤ} (hv : v ∈ gammaSet N a) (γ : SL(2, ℤ)) :
    v ᵥ* γ ∈ gammaSet N (a ᵥ* γ) 
Arguments: {N : ℕ} {a : Fin 2 → ZMod N} {v : Fin 2 → ℤ} (hv : v ∈ EisensteinSeries.gammaSet N a) (γ : SL(2, ℤ))
Goal: v ᵥ* ↑γ ∈ EisensteinSeries.gammaSet N (a ᵥ* ↑((Matrix.SpecialLinearGroup.map (Int.castRingHom (ZMod N))) γ))
-- EisensteinSeries.eisSummand_SL2_apply
theorem eisSummand_SL2_apply (k : ℤ) (i : (Fin 2 → ℤ)) (A : SL(2, ℤ)) (z : ℍ) :
    eisSummand k i (A • z) = (z.denom A) ^ k * eisSummand k (i ᵥ* A) z 
Arguments: (k : ℤ) (i : Fin 2 → ℤ) (A : SL(2, ℤ)) (z : ℍ)
Goal: EisensteinSeries.eisSummand k i (A • z) = UpperHalfPlane.denom (↑A) z ^ k * EisensteinSeries.eisSummand k (i ᵥ* ↑A) z
-- EisensteinSeries.eisensteinSeries_slash_apply
lemma eisensteinSeries_slash_apply (k : ℤ) (γ : SL(2, ℤ)) :
    eisensteinSeries a k ∣[k] γ = eisensteinSeries (a ᵥ* γ) k 
Arguments: {N : ℕ} (a : Fin 2 → ZMod N) (k : ℤ) (γ : SL(2, ℤ))
Goal: eisensteinSeries a k ∣[k] γ = eisensteinSeries (a ᵥ* ↑((Matrix.SpecialLinearGroup.map (Int.castRingHom (ZMod N))) γ)) k
-- EisensteinSeries.eisensteinSeries_SIF_apply
lemma eisensteinSeries_SIF_apply (k : ℤ) (z : ℍ) :
    eisensteinSeries_SIF a k z = eisensteinSeries a k z 
Arguments: {N : ℕ} (a : Fin 2 → ZMod N) (k : ℤ) (z : ℍ)
Goal: (EisensteinSeries.eisensteinSeries_SIF a k) z = eisensteinSeries a k z
-- EisensteinSeries.div_linear_zpow_differentiableOn
lemma div_linear_zpow_differentiableOn (k : ℤ) (a : Fin 2 → ℤ) :
    DifferentiableOn ℂ (fun z : ℂ => (a 0 * z + a 1) ^ (-k)) {z : ℂ | 0 < z.im} 
Arguments: (k : ℤ) (a : Fin 2 → ℤ)
Goal: DifferentiableOn ℂ (fun z => (↑(a 0) * z + ↑(a 1)) ^ (-k)) {z | 0 < z.im}
-- EisensteinSeries.eisSummand_extension_differentiableOn
lemma eisSummand_extension_differentiableOn (k : ℤ) (a : Fin 2 → ℤ) :
    DifferentiableOn ℂ (↑ₕeisSummand k a) {z : ℂ | 0 < z.im} 
Arguments: (k : ℤ) (a : Fin 2 → ℤ)
Goal: DifferentiableOn ℂ (EisensteinSeries.eisSummand k a ∘ ↑UpperHalfPlane.ofComplex) {z | 0 < z.im}
-- EisensteinSeries.eisensteinSeries_SIF_MDifferentiable
theorem eisensteinSeries_SIF_MDifferentiable {k : ℤ} {N : ℕ} (hk : 3 ≤ k) (a : Fin 2 → ZMod N) :
    MDifferentiable 𝓘(ℂ) 𝓘(ℂ) (eisensteinSeries_SIF a k) 
Arguments: {k : ℤ} {N : ℕ} (hk : 3 ≤ k) (a : Fin 2 → ZMod N)
Goal: MDifferentiable 𝓘(ℂ, ℂ) 𝓘(ℂ, ℂ) ⇑(EisensteinSeries.eisensteinSeries_SIF a k)
-- setOf_liouvilleWith_subset_aux
theorem setOf_liouvilleWith_subset_aux :
    { x : ℝ | ∃ p > 2, LiouvilleWith p x } ⊆
      ⋃ m : ℤ, (· + (m : ℝ)) ⁻¹' ⋃ n > (0 : ℕ),
        { x : ℝ | ∃ᶠ b : ℕ in atTop, ∃ a ∈ Finset.Icc (0 : ℤ) b,
          |x - (a : ℤ) / b| < 1 / (b : ℝ) ^ (2 + 1 / n : ℝ) } 
Goal: {x | ∃ p > 2, LiouvilleWith p x} ⊆
  ⋃ m,
    (fun x => x + ↑m) ⁻¹'
      ⋃ n, ⋃ (_ : n > 0), {x | ∃ᶠ (b : ℕ) in Filter.atTop, ∃ a ∈ Finset.Icc 0 ↑b, |x - ↑a / ↑b| < 1 / ↑b ^ (2 + 1 / ↑n)}
-- volume_iUnion_setOf_liouvilleWith
@[simp]
theorem volume_iUnion_setOf_liouvilleWith :
    volume (⋃ (p : ℝ) (_hp : 2 < p), { x : ℝ | LiouvilleWith p x }) = 0 
Goal: MeasureTheory.volume (⋃ p, ⋃ (_ : 2 < p), {x | LiouvilleWith p x}) = 0
-- ae_not_liouvilleWith
theorem ae_not_liouvilleWith : ∀ᵐ x, ∀ p > (2 : ℝ), ¬LiouvilleWith p x 
Goal: ∀ᵐ (x : ℝ), ∀ p > 2, ¬LiouvilleWith p x
-- ae_not_liouville
theorem ae_not_liouville : ∀ᵐ x, ¬Liouville x 
Goal: ∀ᵐ (x : ℝ), ¬Liouville x
-- volume_setOf_liouville
@[simp]
theorem volume_setOf_liouville : volume { x : ℝ | Liouville x } = 0 
Goal: MeasureTheory.volume {x | Liouville x} = 0
-- Real.disjoint_residual_ae
theorem Real.disjoint_residual_ae : Disjoint (residual ℝ) (ae volume) 
Goal: Disjoint (residual ℝ) (MeasureTheory.ae MeasureTheory.volume)
-- jacobiTheta_eq_jacobiTheta₂
lemma jacobiTheta_eq_jacobiTheta₂ (τ : ℂ) : jacobiTheta τ = jacobiTheta₂ 0 τ 
Arguments: (τ : ℂ)
Goal: jacobiTheta τ = jacobiTheta₂ 0 τ
-- jacobiTheta_two_add
theorem jacobiTheta_two_add (τ : ℂ) : jacobiTheta (2 + τ) = jacobiTheta τ 
Arguments: (τ : ℂ)
Goal: jacobiTheta (2 + τ) = jacobiTheta τ
-- jacobiTheta_T_sq_smul
theorem jacobiTheta_T_sq_smul (τ : ℍ) : jacobiTheta (ModularGroup.T ^ 2 • τ :) = jacobiTheta τ 
Arguments: (τ : ℍ)
Goal: jacobiTheta ↑(ModularGroup.T ^ 2 • τ) = jacobiTheta ↑τ
-- jacobiTheta_S_smul
theorem jacobiTheta_S_smul (τ : ℍ) :
    jacobiTheta ↑(ModularGroup.S • τ) = (-I * τ) ^ (1 / 2 : ℂ) * jacobiTheta τ 
Arguments: (τ : ℍ)
Goal: jacobiTheta ↑(ModularGroup.S • τ) = (-Complex.I * ↑τ) ^ (1 / 2) * jacobiTheta ↑τ
-- norm_exp_mul_sq_le
theorem norm_exp_mul_sq_le {τ : ℂ} (hτ : 0 < τ.im) (n : ℤ) :
    ‖cexp (π * I * (n : ℂ) ^ 2 * τ)‖ ≤ rexp (-π * τ.im) ^ n.natAbs 
Arguments: {τ : ℂ} (hτ : 0 < τ.im) (n : ℤ)
Goal: ‖cexp (↑π * Complex.I * ↑n ^ 2 * τ)‖ ≤ rexp (-π * τ.im) ^ n.natAbs
-- hasSum_nat_jacobiTheta
theorem hasSum_nat_jacobiTheta {τ : ℂ} (hτ : 0 < im τ) :
    HasSum (fun n : ℕ => cexp (π * I * ((n : ℂ) + 1) ^ 2 * τ)) ((jacobiTheta τ - 1) / 2) 
Arguments: {τ : ℂ} (hτ : 0 < τ.im)
Goal: HasSum (fun n => cexp (↑π * Complex.I * (↑n + 1) ^ 2 * τ)) ((jacobiTheta τ - 1) / 2)
-- jacobiTheta_eq_tsum_nat
theorem jacobiTheta_eq_tsum_nat {τ : ℂ} (hτ : 0 < im τ) :
    jacobiTheta τ = ↑1 + ↑2 * ∑' n : ℕ, cexp (π * I * ((n : ℂ) + 1) ^ 2 * τ) 
Arguments: {τ : ℂ} (hτ : 0 < τ.im)
Goal: jacobiTheta τ = 1 + 2 * ∑' (n : ℕ), cexp (↑π * Complex.I * (↑n + 1) ^ 2 * τ)
-- norm_jacobiTheta_sub_one_le
theorem norm_jacobiTheta_sub_one_le {τ : ℂ} (hτ : 0 < im τ) :
    ‖jacobiTheta τ - 1‖ ≤ 2 / (1 - rexp (-π * τ.im)) * rexp (-π * τ.im) 
Arguments: {τ : ℂ} (hτ : 0 < τ.im)
Goal: ‖jacobiTheta τ - 1‖ ≤ 2 / (1 - rexp (-π * τ.im)) * rexp (-π * τ.im)
-- isBigO_at_im_infty_jacobiTheta_sub_one
theorem isBigO_at_im_infty_jacobiTheta_sub_one :
    (fun τ => jacobiTheta τ - 1) =O[comap im atTop] fun τ => rexp (-π * τ.im) 
Goal: (fun τ => jacobiTheta τ - 1) =O[Filter.comap Complex.im Filter.atTop] fun τ => rexp (-π * τ.im)
-- differentiableAt_jacobiTheta
theorem differentiableAt_jacobiTheta {τ : ℂ} (hτ : 0 < im τ) :
    DifferentiableAt ℂ jacobiTheta τ 
Arguments: {τ : ℂ} (hτ : 0 < τ.im)
Goal: DifferentiableAt ℂ jacobiTheta τ
-- continuousAt_jacobiTheta
theorem continuousAt_jacobiTheta {τ : ℂ} (hτ : 0 < im τ) : ContinuousAt jacobiTheta τ 
Arguments: {τ : ℂ} (hτ : 0 < τ.im)
Goal: ContinuousAt jacobiTheta τ
-- ZMod.euler_criterion_units
theorem euler_criterion_units (x : (ZMod p)ˣ) : (∃ y : (ZMod p)ˣ, y ^ 2 = x) ↔ x ^ (p / 2) = 1 
Arguments: (p : ℕ) [Fact (Nat.Prime p)] (x : (ZMod p)ˣ)
Goal: (∃ y, y ^ 2 = x) ↔ x ^ (p / 2) = 1
-- ZMod.euler_criterion
theorem euler_criterion {a : ZMod p} (ha : a ≠ 0) : IsSquare (a : ZMod p) ↔ a ^ (p / 2) = 1 
Arguments: (p : ℕ) [Fact (Nat.Prime p)] {a : ZMod p} (ha : a ≠ 0)
Goal: IsSquare a ↔ a ^ (p / 2) = 1
-- ZMod.pow_div_two_eq_neg_one_or_one
theorem pow_div_two_eq_neg_one_or_one {a : ZMod p} (ha : a ≠ 0) :
    a ^ (p / 2) = 1 ∨ a ^ (p / 2) = -1 
Arguments: (p : ℕ) [Fact (Nat.Prime p)] {a : ZMod p} (ha : a ≠ 0)
Goal: a ^ (p / 2) = 1 ∨ a ^ (p / 2) = -1
-- legendreSym.eq_pow
theorem eq_pow (a : ℤ) : (legendreSym p a : ZMod p) = (a : ZMod p) ^ (p / 2) 
Arguments: (p : ℕ) [Fact (Nat.Prime p)] (a : ℤ)
Goal: ↑(legendreSym p a) = ↑a ^ (p / 2)
-- legendreSym.eq_one_or_neg_one
theorem eq_one_or_neg_one {a : ℤ} (ha : (a : ZMod p) ≠ 0) :
    legendreSym p a = 1 ∨ legendreSym p a = -1 
Arguments: (p : ℕ) [Fact (Nat.Prime p)] {a : ℤ} (ha : ↑a ≠ 0)
Goal: legendreSym p a = 1 ∨ legendreSym p a = -1
-- legendreSym.eq_neg_one_iff_not_one
theorem eq_neg_one_iff_not_one {a : ℤ} (ha : (a : ZMod p) ≠ 0) :
    legendreSym p a = -1 ↔ ¬legendreSym p a = 1 
Arguments: (p : ℕ) [Fact (Nat.Prime p)] {a : ℤ} (ha : ↑a ≠ 0)
Goal: legendreSym p a = -1 ↔ ¬legendreSym p a = 1
-- legendreSym.eq_zero_iff
theorem eq_zero_iff (a : ℤ) : legendreSym p a = 0 ↔ (a : ZMod p) = 0 
Arguments: (p : ℕ) [Fact (Nat.Prime p)] (a : ℤ)
Goal: legendreSym p a = 0 ↔ ↑a = 0
-- legendreSym.at_zero
@[simp]
theorem at_zero : legendreSym p 0 = 0 
Arguments: (p : ℕ) [Fact (Nat.Prime p)]
Goal: legendreSym p 0 = 0
-- legendreSym.at_one
@[simp]
theorem at_one : legendreSym p 1 = 1 
Arguments: (p : ℕ) [Fact (Nat.Prime p)]
Goal: legendreSym p 1 = 1
-- legendreSym.mul
protected theorem mul (a b : ℤ) : legendreSym p (a * b) = legendreSym p a * legendreSym p b 
Arguments: (p : ℕ) [Fact (Nat.Prime p)] (a b : ℤ)
Goal: legendreSym p (a * b) = legendreSym p a * legendreSym p b
-- legendreSym.hom_apply
@[simps]
def hom : ℤ →*₀ ℤ 
Arguments: (p : ℕ) [Fact (Nat.Prime p)] (a : ℤ)
Goal: (legendreSym.hom p) a = legendreSym p a
-- legendreSym.sq_one
theorem sq_one {a : ℤ} (ha : (a : ZMod p) ≠ 0) : legendreSym p a ^ 2 = 1 
Arguments: (p : ℕ) [Fact (Nat.Prime p)] {a : ℤ} (ha : ↑a ≠ 0)
Goal: legendreSym p a ^ 2 = 1
-- legendreSym.sq_one'
theorem sq_one' {a : ℤ} (ha : (a : ZMod p) ≠ 0) : legendreSym p (a ^ 2) = 1 
Arguments: (p : ℕ) [Fact (Nat.Prime p)] {a : ℤ} (ha : ↑a ≠ 0)
Goal: legendreSym p (a ^ 2) = 1
-- legendreSym.mod
protected theorem mod (a : ℤ) : legendreSym p a = legendreSym p (a % p) 
Arguments: (p : ℕ) [Fact (Nat.Prime p)] (a : ℤ)
Goal: legendreSym p a = legendreSym p (a % ↑p)
-- legendreSym.eq_one_iff
theorem eq_one_iff {a : ℤ} (ha0 : (a : ZMod p) ≠ 0) : legendreSym p a = 1 ↔ IsSquare (a : ZMod p) 
Arguments: (p : ℕ) [Fact (Nat.Prime p)] {a : ℤ} (ha0 : ↑a ≠ 0)
Goal: legendreSym p a = 1 ↔ IsSquare ↑a
-- legendreSym.eq_one_iff'
theorem eq_one_iff' {a : ℕ} (ha0 : (a : ZMod p) ≠ 0) :
    legendreSym p a = 1 ↔ IsSquare (a : ZMod p) 
Arguments: (p : ℕ) [Fact (Nat.Prime p)] {a : ℕ} (ha0 : ↑a ≠ 0)
Goal: legendreSym p ↑a = 1 ↔ IsSquare ↑a
-- legendreSym.eq_neg_one_iff
theorem eq_neg_one_iff {a : ℤ} : legendreSym p a = -1 ↔ ¬IsSquare (a : ZMod p) 
Arguments: (p : ℕ) [Fact (Nat.Prime p)] {a : ℤ}
Goal: legendreSym p a = -1 ↔ ¬IsSquare ↑a
-- legendreSym.eq_neg_one_iff'
theorem eq_neg_one_iff' {a : ℕ} : legendreSym p a = -1 ↔ ¬IsSquare (a : ZMod p) 
Arguments: (p : ℕ) [Fact (Nat.Prime p)] {a : ℕ}
Goal: legendreSym p ↑a = -1 ↔ ¬IsSquare ↑a
-- legendreSym.card_sqrts
theorem card_sqrts (hp : p ≠ 2) (a : ℤ) :
    ↑{x : ZMod p | x ^ 2 = a}.toFinset.card = legendreSym p a + 1 
Arguments: (p : ℕ) [Fact (Nat.Prime p)] (hp : p ≠ 2) (a : ℤ)
Goal: ↑{x | x ^ 2 = ↑a}.toFinset.card = legendreSym p a + 1
-- legendreSym.eq_one_of_sq_sub_mul_sq_eq_zero
theorem eq_one_of_sq_sub_mul_sq_eq_zero {p : ℕ} [Fact p.Prime] {a : ℤ} (ha : (a : ZMod p) ≠ 0)
    {x y : ZMod p} (hy : y ≠ 0) (hxy : x ^ 2 - a * y ^ 2 = 0) : legendreSym p a = 1 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {a : ℤ} (ha : ↑a ≠ 0) {x y : ZMod p} (hy : y ≠ 0) (hxy : x ^ 2 - ↑a * y ^ 2 = 0)
Goal: legendreSym p a = 1
-- legendreSym.eq_one_of_sq_sub_mul_sq_eq_zero'
theorem eq_one_of_sq_sub_mul_sq_eq_zero' {p : ℕ} [Fact p.Prime] {a : ℤ} (ha : (a : ZMod p) ≠ 0)
    {x y : ZMod p} (hx : x ≠ 0) (hxy : x ^ 2 - a * y ^ 2 = 0) : legendreSym p a = 1 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {a : ℤ} (ha : ↑a ≠ 0) {x y : ZMod p} (hx : x ≠ 0) (hxy : x ^ 2 - ↑a * y ^ 2 = 0)
Goal: legendreSym p a = 1
-- legendreSym.eq_zero_mod_of_eq_neg_one
theorem eq_zero_mod_of_eq_neg_one {p : ℕ} [Fact p.Prime] {a : ℤ} (h : legendreSym p a = -1)
    {x y : ZMod p} (hxy : x ^ 2 - a * y ^ 2 = 0) : x = 0 ∧ y = 0 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {a : ℤ} (h : legendreSym p a = -1) {x y : ZMod p} (hxy : x ^ 2 - ↑a * y ^ 2 = 0)
Goal: x = 0 ∧ y = 0
-- legendreSym.prime_dvd_of_eq_neg_one
theorem prime_dvd_of_eq_neg_one {p : ℕ} [Fact p.Prime] {a : ℤ} (h : legendreSym p a = -1) {x y : ℤ}
    (hxy : (p : ℤ) ∣ x ^ 2 - a * y ^ 2) : ↑p ∣ x ∧ ↑p ∣ y 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {a : ℤ} (h : legendreSym p a = -1) {x y : ℤ} (hxy : ↑p ∣ x ^ 2 - a * y ^ 2)
Goal: ↑p ∣ x ∧ ↑p ∣ y
-- legendreSym.at_neg_one
theorem legendreSym.at_neg_one (hp : p ≠ 2) : legendreSym p (-1) = χ₄ p 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] (hp : p ≠ 2)
Goal: legendreSym p (-1) = ZMod.χ₄ ↑p
-- ZMod.exists_sq_eq_neg_one_iff
theorem exists_sq_eq_neg_one_iff : IsSquare (-1 : ZMod p) ↔ p % 4 ≠ 3 
Arguments: {p : ℕ} [Fact (Nat.Prime p)]
Goal: IsSquare (-1) ↔ p % 4 ≠ 3
-- ZMod.mod_four_ne_three_of_sq_eq_neg_one
theorem mod_four_ne_three_of_sq_eq_neg_one {y : ZMod p} (hy : y ^ 2 = -1) : p % 4 ≠ 3 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {y : ZMod p} (hy : y ^ 2 = -1)
Goal: p % 4 ≠ 3
-- ZMod.mod_four_ne_three_of_sq_eq_neg_sq'
theorem mod_four_ne_three_of_sq_eq_neg_sq' {x y : ZMod p} (hy : y ≠ 0) (hxy : x ^ 2 = -y ^ 2) :
    p % 4 ≠ 3 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {x y : ZMod p} (hy : y ≠ 0) (hxy : x ^ 2 = -y ^ 2)
Goal: p % 4 ≠ 3
-- ZMod.mod_four_ne_three_of_sq_eq_neg_sq
theorem mod_four_ne_three_of_sq_eq_neg_sq {x y : ZMod p} (hx : x ≠ 0) (hxy : x ^ 2 = -y ^ 2) :
    p % 4 ≠ 3 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {x y : ZMod p} (hx : x ≠ 0) (hxy : x ^ 2 = -y ^ 2)
Goal: p % 4 ≠ 3
-- EisensteinSeries.norm_eq_max_natAbs
lemma norm_eq_max_natAbs (x : Fin 2 → ℤ) : ‖x‖ = max (x 0).natAbs (x 1).natAbs 
Arguments: (x : Fin 2 → ℤ)
Goal: ‖x‖ = ↑(max (x 0).natAbs (x 1).natAbs)
-- EisensteinSeries.r1_eq
lemma r1_eq : r1 z = 1 / ((z.re / z.im) ^ 2 + 1) 
Arguments: (z : ℍ)
Goal: EisensteinSeries.r1 z = 1 / ((z.re / z.im) ^ 2 + 1)
-- EisensteinSeries.r1_pos
lemma r1_pos : 0 < r1 z 
Arguments: (z : ℍ)
Goal: 0 < EisensteinSeries.r1 z
-- EisensteinSeries.r1_aux_bound
lemma r1_aux_bound (c : ℝ) {d : ℝ} (hd : 1 ≤ d ^ 2) :
    r1 z ≤ (c * z.re + d) ^ 2 + (c * z.im) ^ 2 
Arguments: (z : ℍ) (c : ℝ) {d : ℝ} (hd : 1 ≤ d ^ 2)
Goal: EisensteinSeries.r1 z ≤ (c * z.re + d) ^ 2 + (c * z.im) ^ 2
-- EisensteinSeries.r_pos
lemma r_pos : 0 < r z 
Arguments: (z : ℍ)
Goal: 0 < EisensteinSeries.r z
-- EisensteinSeries.r_lower_bound_on_verticalStrip
lemma r_lower_bound_on_verticalStrip {A B : ℝ} (h : 0 < B) (hz : z ∈ verticalStrip A B) :
    r ⟨⟨A, B⟩, h⟩ ≤ r z 
Arguments: (z : ℍ) {A B : ℝ} (h : 0 < B) (hz : z ∈ UpperHalfPlane.verticalStrip A B)
Goal: EisensteinSeries.r ⟨{ re := A, im := B }, h⟩ ≤ EisensteinSeries.r z
-- EisensteinSeries.auxbound1
lemma auxbound1 {c : ℝ} (d : ℝ) (hc : 1 ≤ c ^ 2) : r z ≤ Complex.abs (c * z + d) 
Arguments: (z : ℍ) {c : ℝ} (d : ℝ) (hc : 1 ≤ c ^ 2)
Goal: EisensteinSeries.r z ≤ Complex.abs (↑c * ↑z + ↑d)
-- EisensteinSeries.auxbound2
lemma auxbound2 (c : ℝ) {d : ℝ} (hd : 1 ≤ d ^ 2) : r z ≤ Complex.abs (c * z + d) 
Arguments: (z : ℍ) (c : ℝ) {d : ℝ} (hd : 1 ≤ d ^ 2)
Goal: EisensteinSeries.r z ≤ Complex.abs (↑c * ↑z + ↑d)
-- EisensteinSeries.div_max_sq_ge_one
lemma div_max_sq_ge_one (x : Fin 2 → ℤ) (hx : x ≠ 0) :
    1 ≤ (x 0 / ‖x‖) ^ 2 ∨ 1 ≤ (x 1 / ‖x‖) ^ 2 
Arguments: (x : Fin 2 → ℤ) (hx : x ≠ 0)
Goal: 1 ≤ (↑(x 0) / ‖x‖) ^ 2 ∨ 1 ≤ (↑(x 1) / ‖x‖) ^ 2
-- EisensteinSeries.r_mul_max_le
lemma r_mul_max_le {x : Fin 2 → ℤ} (hx : x ≠ 0) : r z * ‖x‖ ≤ Complex.abs (x 0 * z + x 1) 
Arguments: (z : ℍ) {x : Fin 2 → ℤ} (hx : x ≠ 0)
Goal: EisensteinSeries.r z * ‖x‖ ≤ Complex.abs (↑(x 0) * ↑z + ↑(x 1))
-- EisensteinSeries.summand_bound
lemma summand_bound {k : ℝ} (hk : 0 ≤ k) (x : Fin 2 → ℤ) :
    Complex.abs (x 0 * z + x 1) ^ (-k) ≤ (r z) ^ (-k) * ‖x‖ ^ (-k) 
Arguments: (z : ℍ) {k : ℝ} (hk : 0 ≤ k) (x : Fin 2 → ℤ)
Goal: Complex.abs (↑(x 0) * ↑z + ↑(x 1)) ^ (-k) ≤ EisensteinSeries.r z ^ (-k) * ‖x‖ ^ (-k)
-- EisensteinSeries.summand_bound_of_mem_verticalStrip
lemma summand_bound_of_mem_verticalStrip {k : ℝ} (hk : 0 ≤ k) (x : Fin 2 → ℤ)
    {A B : ℝ} (hB : 0 < B) (hz : z ∈ verticalStrip A B) :
    Complex.abs (x 0 * z + x 1) ^ (-k) ≤ r ⟨⟨A, B⟩, hB⟩ ^ (-k) * ‖x‖ ^ (-k) 
Arguments: {z : ℍ} {k : ℝ} (hk : 0 ≤ k) (x : Fin 2 → ℤ) {A B : ℝ} (hB : 0 < B) (hz : z ∈ UpperHalfPlane.verticalStrip A B)
Goal: Complex.abs (↑(x 0) * ↑z + ↑(x 1)) ^ (-k) ≤ EisensteinSeries.r ⟨{ re := A, im := B }, hB⟩ ^ (-k) * ‖x‖ ^ (-k)
-- EisensteinSeries.summable_one_div_norm_rpow
lemma summable_one_div_norm_rpow {k : ℝ} (hk : 2 < k) :
    Summable fun (x : Fin 2 → ℤ) ↦ ‖x‖ ^ (-k) 
Arguments: {k : ℝ} (hk : 2 < k)
Goal: Summable fun x => ‖x‖ ^ (-k)
-- EisensteinSeries.eisensteinSeries_tendstoLocallyUniformly
theorem eisensteinSeries_tendstoLocallyUniformly {k : ℤ} (hk : 3 ≤ k) {N : ℕ} (a : Fin 2 → ZMod N) :
    TendstoLocallyUniformly (fun (s : Finset (gammaSet N a)) ↦ (∑ x ∈ s, eisSummand k x ·))
      (eisensteinSeries a k ·) Filter.atTop 
Arguments: {k : ℤ} (hk : 3 ≤ k) {N : ℕ} (a : Fin 2 → ZMod N)
Goal: TendstoLocallyUniformly (fun s x => ∑ x_1 ∈ s, EisensteinSeries.eisSummand k (↑x_1) x) (fun x => eisensteinSeries a k x)
  Filter.atTop
-- EisensteinSeries.eisensteinSeries_tendstoLocallyUniformlyOn
lemma eisensteinSeries_tendstoLocallyUniformlyOn {k : ℤ} {N : ℕ} (hk : 3 ≤ k)
    (a : Fin 2 → ZMod N) : TendstoLocallyUniformlyOn (fun (s : Finset (gammaSet N a )) ↦
      ↑ₕ(fun (z : ℍ) ↦ ∑ x in s, eisSummand k x z )) (↑ₕ(eisensteinSeries_SIF a k).toFun)
          Filter.atTop {z : ℂ | 0 < z.im} 
Arguments: {k : ℤ} {N : ℕ} (hk : 3 ≤ k) (a : Fin 2 → ZMod N)
Goal: TendstoLocallyUniformlyOn
  (fun s => (fun z => ∑ x ∈ s, EisensteinSeries.eisSummand k (↑x) z) ∘ ↑UpperHalfPlane.ofComplex)
  ((EisensteinSeries.eisensteinSeries_SIF a k).toFun ∘ ↑UpperHalfPlane.ofComplex) Filter.atTop {z | 0 < z.im}
-- ModularForm.holo'
structure ModularForm extends SlashInvariantForm Γ k where
  holo' : MDifferentiable 𝓘(ℂ) 𝓘(ℂ) (toSlashInvariantForm : ℍ → ℂ)
  bdd_at_infty' : ∀ A : SL(2, ℤ), IsBoundedAtImInfty (toSlashInvariantForm ∣[k] A)
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} (self : ModularForm Γ k)
Goal: MDifferentiable 𝓘(ℂ, ℂ) 𝓘(ℂ, ℂ) ⇑self.toSlashInvariantForm
-- ModularForm.bdd_at_infty'
structure ModularForm extends SlashInvariantForm Γ k where
  holo' : MDifferentiable 𝓘(ℂ) 𝓘(ℂ) (toSlashInvariantForm : ℍ → ℂ)
  bdd_at_infty' : ∀ A : SL(2, ℤ), IsBoundedAtImInfty (toSlashInvariantForm ∣[k] A)
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} (self : ModularForm Γ k) (A : SL(2, ℤ))
Goal: UpperHalfPlane.IsBoundedAtImInfty (SlashAction.map ℂ k A ⇑self.toSlashInvariantForm)
-- CuspForm.holo'
structure CuspForm extends SlashInvariantForm Γ k where
  holo' : MDifferentiable 𝓘(ℂ) 𝓘(ℂ) (toSlashInvariantForm : ℍ → ℂ)
  zero_at_infty' : ∀ A : SL(2, ℤ), IsZeroAtImInfty (toSlashInvariantForm ∣[k] A)
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} (self : CuspForm Γ k)
Goal: MDifferentiable 𝓘(ℂ, ℂ) 𝓘(ℂ, ℂ) ⇑self.toSlashInvariantForm
-- CuspForm.zero_at_infty'
structure CuspForm extends SlashInvariantForm Γ k where
  holo' : MDifferentiable 𝓘(ℂ) 𝓘(ℂ) (toSlashInvariantForm : ℍ → ℂ)
  zero_at_infty' : ∀ A : SL(2, ℤ), IsZeroAtImInfty (toSlashInvariantForm ∣[k] A)
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} (self : CuspForm Γ k) (A : SL(2, ℤ))
Goal: UpperHalfPlane.IsZeroAtImInfty (SlashAction.map ℂ k A ⇑self.toSlashInvariantForm)
-- ModularFormClass.holo
class ModularFormClass (F : Type*) (Γ : outParam <| Subgroup (SL(2, ℤ))) (k : outParam ℤ)
    [FunLike F ℍ ℂ] extends SlashInvariantFormClass F Γ k : Prop where
  holo : ∀ f : F, MDifferentiable 𝓘(ℂ) 𝓘(ℂ) (f : ℍ → ℂ)
  bdd_at_infty : ∀ (f : F) (A : SL(2, ℤ)), IsBoundedAtImInfty (f ∣[k] A)
Arguments: {F : Type u_2} {Γ : outParam (Subgroup SL(2, ℤ))} {k : outParam ℤ} [FunLike F ℍ ℂ] [self : ModularFormClass F Γ k] (f : F)
Goal: MDifferentiable 𝓘(ℂ, ℂ) 𝓘(ℂ, ℂ) ⇑f
-- ModularFormClass.bdd_at_infty
class ModularFormClass (F : Type*) (Γ : outParam <| Subgroup (SL(2, ℤ))) (k : outParam ℤ)
    [FunLike F ℍ ℂ] extends SlashInvariantFormClass F Γ k : Prop where
  holo : ∀ f : F, MDifferentiable 𝓘(ℂ) 𝓘(ℂ) (f : ℍ → ℂ)
  bdd_at_infty : ∀ (f : F) (A : SL(2, ℤ)), IsBoundedAtImInfty (f ∣[k] A)
Arguments: {F : Type u_2} {Γ : outParam (Subgroup SL(2, ℤ))} {k : outParam ℤ} [FunLike F ℍ ℂ] [self : ModularFormClass F Γ k] (f : F) (A : SL(2, ℤ))
Goal: UpperHalfPlane.IsBoundedAtImInfty (SlashAction.map ℂ k A ⇑f)
-- CuspFormClass.zero_at_infty
class CuspFormClass (F : Type*) (Γ : outParam <| Subgroup (SL(2, ℤ))) (k : outParam ℤ)
    [FunLike F ℍ ℂ] extends SlashInvariantFormClass F Γ k : Prop where
  holo : ∀ f : F, MDifferentiable 𝓘(ℂ) 𝓘(ℂ) (f : ℍ → ℂ)
  zero_at_infty : ∀ (f : F) (A : SL(2, ℤ)), IsZeroAtImInfty (f ∣[k] A)
Arguments: {F : Type u_2} {Γ : outParam (Subgroup SL(2, ℤ))} {k : outParam ℤ} [FunLike F ℍ ℂ] [self : CuspFormClass F Γ k] (f : F) (A : SL(2, ℤ))
Goal: UpperHalfPlane.IsZeroAtImInfty (SlashAction.map ℂ k A ⇑f)