ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CuspFormClass.holo
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)
Goal: MDifferentiable 𝓘(ℂ, ℂ) 𝓘(ℂ, ℂ) ⇑f
-- ModularForm.toFun_eq_coe
theorem ModularForm.toFun_eq_coe (f : ModularForm Γ k) : f.toFun = (f : ℍ → ℂ) 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} (f : ModularForm Γ k)
Goal: f.toFun = ⇑f
-- ModularForm.toSlashInvariantForm_coe
@[simp]
theorem ModularForm.toSlashInvariantForm_coe (f : ModularForm Γ k) : ⇑f.1 = f 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} (f : ModularForm Γ k)
Goal: ⇑f.toSlashInvariantForm = ⇑f
-- CuspForm.toFun_eq_coe
theorem CuspForm.toFun_eq_coe {f : CuspForm Γ k} : f.toFun = (f : ℍ → ℂ) 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} {f : CuspForm Γ k}
Goal: f.toFun = ⇑f
-- CuspForm.toSlashInvariantForm_coe
@[simp]
theorem CuspForm.toSlashInvariantForm_coe (f : CuspForm Γ k) : ⇑f.1 = f 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} (f : CuspForm Γ k)
Goal: ⇑f.toSlashInvariantForm = ⇑f
-- ModularForm.ext
@[ext]
theorem ModularForm.ext {f g : ModularForm Γ k} (h : ∀ x, f x = g x) : f = g 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} {f g : ModularForm Γ k} (h : ∀ (x : ℍ), f x = g x)
Goal: f = g
-- CuspForm.ext
@[ext]
theorem CuspForm.ext {f g : CuspForm Γ k} (h : ∀ x, f x = g x) : f = g 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} {f g : CuspForm Γ k} (h : ∀ (x : ℍ), f x = g x)
Goal: f = g
-- ModularForm.coe_add
@[simp]
theorem coe_add (f g : ModularForm Γ k) : ⇑(f + g) = f + g 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} (f g : ModularForm Γ k)
Goal: ⇑(f + g) = ⇑f + ⇑g
-- ModularForm.add_apply
@[simp]
theorem add_apply (f g : ModularForm Γ k) (z : ℍ) : (f + g) z = f z + g z 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} (f g : ModularForm Γ k) (z : ℍ)
Goal: (f + g) z = f z + g z
-- ModularForm.coe_zero
@[simp]
theorem coe_zero : ⇑(0 : ModularForm Γ k) = (0 : ℍ → ℂ) 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ}
Goal: ⇑0 = 0
-- ModularForm.zero_apply
@[simp]
theorem zero_apply (z : ℍ) : (0 : ModularForm Γ k) z = 0 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} (z : ℍ)
Goal: 0 z = 0
-- ModularForm.coe_smul
@[simp]
theorem coe_smul (f : ModularForm Γ k) (n : α) : ⇑(n • f) = n • ⇑f 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} {α : Type u_2} [SMul α ℂ] [IsScalarTower α ℂ ℂ] (f : ModularForm Γ k) (n : α)
Goal: ⇑(n • f) = n • ⇑f
-- ModularForm.smul_apply
@[simp]
theorem smul_apply (f : ModularForm Γ k) (n : α) (z : ℍ) : (n • f) z = n • f z 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} {α : Type u_2} [SMul α ℂ] [IsScalarTower α ℂ ℂ] (f : ModularForm Γ k) (n : α) (z : ℍ)
Goal: (n • f) z = n • f z
-- ModularForm.coe_neg
@[simp]
theorem coe_neg (f : ModularForm Γ k) : ⇑(-f) = -f 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} (f : ModularForm Γ k)
Goal: ⇑(-f) = -⇑f
-- ModularForm.neg_apply
@[simp]
theorem neg_apply (f : ModularForm Γ k) (z : ℍ) : (-f) z = -f z 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} (f : ModularForm Γ k) (z : ℍ)
Goal: (-f) z = -f z
-- ModularForm.coe_sub
@[simp]
theorem coe_sub (f g : ModularForm Γ k) : ⇑(f - g) = f - g 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} (f g : ModularForm Γ k)
Goal: ⇑(f - g) = ⇑f - ⇑g
-- ModularForm.sub_apply
@[simp]
theorem sub_apply (f g : ModularForm Γ k) (z : ℍ) : (f - g) z = f z - g z 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} (f g : ModularForm Γ k) (z : ℍ)
Goal: (f - g) z = f z - g z
-- ModularForm.coeHom_apply
@[simps]
def coeHom : ModularForm Γ k →+ ℍ → ℂ 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} (f : ModularForm Γ k) (a : ℍ)
Goal: ModularForm.coeHom f a = f a
-- ModularForm.mul_coe
@[simp]
theorem mul_coe {k_1 k_2 : ℤ} {Γ : Subgroup SL(2, ℤ)} (f : ModularForm Γ k_1)
    (g : ModularForm Γ k_2) : (f.mul g : ℍ → ℂ) = f * g 
Arguments: {k_1 k_2 : ℤ} {Γ : Subgroup SL(2, ℤ)} (f : ModularForm Γ k_1) (g : ModularForm Γ k_2)
Goal: ⇑(f.mul g) = ⇑f * ⇑g
-- ModularForm.const_toFun
@[simps! (config := .asFn) toFun toSlashInvariantForm]
def const (x : ℂ) : ModularForm Γ 0 
Arguments: {Γ : Subgroup SL(2, ℤ)} (x : ℂ)
Goal: ⇑(ModularForm.const x) = Function.const ℍ x
-- ModularForm.const_toSlashInvariantForm
@[simps! (config := .asFn) toFun toSlashInvariantForm]
def const (x : ℂ) : ModularForm Γ 0 
Arguments: {Γ : Subgroup SL(2, ℤ)} (x : ℂ)
Goal: (ModularForm.const x).toSlashInvariantForm = SlashInvariantForm.const x
-- ModularForm.one_coe_eq_one
@[simp]
theorem one_coe_eq_one : ⇑(1 : ModularForm Γ 0) = 1 
Arguments: {Γ : Subgroup SL(2, ℤ)}
Goal: ⇑1 = 1
-- ModularForm.coe_natCast
@[simp, norm_cast]
lemma coe_natCast (Γ : Subgroup SL(2, ℤ)) (n : ℕ) :
    ⇑(n : ModularForm Γ 0) = n 
Arguments: (Γ : Subgroup SL(2, ℤ)) (n : ℕ)
Goal: ⇑↑n = ↑n
-- ModularForm.toSlashInvariantForm_natCast
lemma toSlashInvariantForm_natCast (Γ : Subgroup SL(2, ℤ)) (n : ℕ) :
    (n : ModularForm Γ 0).toSlashInvariantForm = n 
Arguments: (Γ : Subgroup SL(2, ℤ)) (n : ℕ)
Goal: (↑n).toSlashInvariantForm = ↑n
-- ModularForm.coe_intCast
@[simp, norm_cast]
lemma coe_intCast (Γ : Subgroup SL(2, ℤ)) (z : ℤ) :
    ⇑(z : ModularForm Γ 0) = z 
Arguments: (Γ : Subgroup SL(2, ℤ)) (z : ℤ)
Goal: ⇑↑z = ↑z
-- ModularForm.toSlashInvariantForm_intCast
lemma toSlashInvariantForm_intCast (Γ : Subgroup SL(2, ℤ)) (z : ℤ) :
    (z : ModularForm Γ 0).toSlashInvariantForm = z 
Arguments: (Γ : Subgroup SL(2, ℤ)) (z : ℤ)
Goal: (↑z).toSlashInvariantForm = ↑z
-- CuspForm.coe_add
@[simp]
theorem coe_add (f g : CuspForm Γ k) : ⇑(f + g) = f + g 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} (f g : CuspForm Γ k)
Goal: ⇑(f + g) = ⇑f + ⇑g
-- CuspForm.add_apply
@[simp]
theorem add_apply (f g : CuspForm Γ k) (z : ℍ) : (f + g) z = f z + g z 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} (f g : CuspForm Γ k) (z : ℍ)
Goal: (f + g) z = f z + g z
-- CuspForm.coe_zero
@[simp]
theorem coe_zero : ⇑(0 : CuspForm Γ k) = (0 : ℍ → ℂ) 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ}
Goal: ⇑0 = 0
-- CuspForm.zero_apply
@[simp]
theorem zero_apply (z : ℍ) : (0 : CuspForm Γ k) z = 0 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} (z : ℍ)
Goal: 0 z = 0
-- CuspForm.coe_smul
@[simp]
theorem coe_smul (f : CuspForm Γ k) (n : α) : ⇑(n • f) = n • ⇑f 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} {α : Type u_2} [SMul α ℂ] [IsScalarTower α ℂ ℂ] (f : CuspForm Γ k) (n : α)
Goal: ⇑(n • f) = n • ⇑f
-- CuspForm.smul_apply
@[simp]
theorem smul_apply (f : CuspForm Γ k) (n : α) {z : ℍ} : (n • f) z = n • f z 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} {α : Type u_2} [SMul α ℂ] [IsScalarTower α ℂ ℂ] (f : CuspForm Γ k) (n : α) {z : ℍ}
Goal: (n • f) z = n • f z
-- CuspForm.coe_neg
@[simp]
theorem coe_neg (f : CuspForm Γ k) : ⇑(-f) = -f 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} (f : CuspForm Γ k)
Goal: ⇑(-f) = -⇑f
-- CuspForm.neg_apply
@[simp]
theorem neg_apply (f : CuspForm Γ k) (z : ℍ) : (-f) z = -f z 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} (f : CuspForm Γ k) (z : ℍ)
Goal: (-f) z = -f z
-- CuspForm.coe_sub
@[simp]
theorem coe_sub (f g : CuspForm Γ k) : ⇑(f - g) = f - g 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} (f g : CuspForm Γ k)
Goal: ⇑(f - g) = ⇑f - ⇑g
-- CuspForm.sub_apply
@[simp]
theorem sub_apply (f g : CuspForm Γ k) (z : ℍ) : (f - g) z = f z - g z 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} (f g : CuspForm Γ k) (z : ℍ)
Goal: (f - g) z = f z - g z
-- CuspForm.coeHom_apply
@[simps]
def coeHom : CuspForm Γ k →+ ℍ → ℂ 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} (f : CuspForm Γ k) (a : ℍ)
Goal: CuspForm.coeHom f a = f a
-- ModularForm.gradedMonoid_eq_of_cast
@[ext]
theorem gradedMonoid_eq_of_cast {Γ : Subgroup SL(2, ℤ)} {a b : GradedMonoid (ModularForm Γ)}
    (h : a.fst = b.fst) (h2 : mcast h a.snd = b.snd) : a = b 
Arguments: {Γ : Subgroup SL(2, ℤ)} {a b : GradedMonoid (ModularForm Γ)} (h : a.fst = b.fst) (h2 : ModularForm.mcast h a.snd = b.snd)
Goal: a = b
-- SL_reduction_mod_hom_val
@[simp]
theorem SL_reduction_mod_hom_val (N : ℕ) (γ : SL(2, ℤ)) :
    ∀ i j : Fin 2, (SLMOD(N) γ : Matrix (Fin 2) (Fin 2) (ZMod N)) i j = ((↑ₘγ i j : ℤ) : ZMod N) 
Arguments: (N : ℕ) (γ : SL(2, ℤ)) (i j : Fin 2)
Goal: ↑((Matrix.SpecialLinearGroup.map (Int.castRingHom (ZMod N))) γ) i j = ↑(↑γ i j)
-- CongruenceSubgroup.Gamma_mem'
theorem Gamma_mem' (N : ℕ) (γ : SL(2, ℤ)) : γ ∈ Gamma N ↔ SLMOD(N) γ = 1 
Arguments: (N : ℕ) (γ : SL(2, ℤ))
Goal: γ ∈ CongruenceSubgroup.Gamma N ↔ (Matrix.SpecialLinearGroup.map (Int.castRingHom (ZMod N))) γ = 1
-- CongruenceSubgroup.Gamma_mem
@[simp]
theorem Gamma_mem (N : ℕ) (γ : SL(2, ℤ)) : γ ∈ Gamma N ↔ ((↑ₘγ 0 0 : ℤ) : ZMod N) = 1 ∧
    ((↑ₘγ 0 1 : ℤ) : ZMod N) = 0 ∧ ((↑ₘγ 1 0 : ℤ) : ZMod N) = 0 ∧ ((↑ₘγ 1 1 : ℤ) : ZMod N) = 1 
Arguments: (N : ℕ) (γ : SL(2, ℤ))
Goal: γ ∈ CongruenceSubgroup.Gamma N ↔ ↑(↑γ 0 0) = 1 ∧ ↑(↑γ 0 1) = 0 ∧ ↑(↑γ 1 0) = 0 ∧ ↑(↑γ 1 1) = 1
-- CongruenceSubgroup.Gamma_normal
theorem Gamma_normal (N : ℕ) : Subgroup.Normal (Gamma N) 
Arguments: (N : ℕ)
Goal: (CongruenceSubgroup.Gamma N).Normal
-- CongruenceSubgroup.Gamma_one_top
theorem Gamma_one_top : Gamma 1 = ⊤ 
Goal: CongruenceSubgroup.Gamma 1 = ⊤
-- CongruenceSubgroup.Gamma_zero_bot
theorem Gamma_zero_bot : Gamma 0 = ⊥ 
Goal: CongruenceSubgroup.Gamma 0 = ⊥
-- CongruenceSubgroup.ModularGroup_T_pow_mem_Gamma
lemma ModularGroup_T_pow_mem_Gamma (N M : ℤ) (hNM : N ∣ M) :
    (ModularGroup.T ^ M) ∈ Gamma (Int.natAbs N) 
Arguments: (N M : ℤ) (hNM : N ∣ M)
Goal: ModularGroup.T ^ M ∈ CongruenceSubgroup.Gamma N.natAbs
-- CongruenceSubgroup.Gamma0_mem
@[simp]
theorem Gamma0_mem (N : ℕ) (A : SL(2, ℤ)) : A ∈ Gamma0 N ↔ ((↑ₘA 1 0 : ℤ) : ZMod N) = 0 
Arguments: (N : ℕ) (A : SL(2, ℤ))
Goal: A ∈ CongruenceSubgroup.Gamma0 N ↔ ↑(↑A 1 0) = 0
-- CongruenceSubgroup.Gamma0_det
theorem Gamma0_det (N : ℕ) (A : Gamma0 N) : (A.1.1.det : ZMod N) = 1 
Arguments: (N : ℕ) (A : ↥(CongruenceSubgroup.Gamma0 N))
Goal: ↑(↑↑A).det = 1
-- CongruenceSubgroup.Gamma1_mem'
@[simp]
theorem Gamma1_mem' (N : ℕ) (γ : Gamma0 N) : γ ∈ Gamma1' N ↔ (Gamma0Map N) γ = 1 
Arguments: (N : ℕ) (γ : ↥(CongruenceSubgroup.Gamma0 N))
Goal: γ ∈ CongruenceSubgroup.Gamma1' N ↔ (CongruenceSubgroup.Gamma0Map N) γ = 1
-- CongruenceSubgroup.Gamma1_to_Gamma0_mem
theorem Gamma1_to_Gamma0_mem (N : ℕ) (A : Gamma0 N) : A ∈ Gamma1' N ↔
    ((↑ₘA 0 0 : ℤ) : ZMod N) = 1 ∧ ((↑ₘA 1 1 : ℤ) : ZMod N) = 1 ∧ ((↑ₘA 1 0 : ℤ) : ZMod N) = 0 
Arguments: (N : ℕ) (A : ↥(CongruenceSubgroup.Gamma0 N))
Goal: A ∈ CongruenceSubgroup.Gamma1' N ↔ ↑(↑↑A 0 0) = 1 ∧ ↑(↑↑A 1 1) = 1 ∧ ↑(↑↑A 1 0) = 0
-- CongruenceSubgroup.Gamma1_mem
@[simp]
theorem Gamma1_mem (N : ℕ) (A : SL(2, ℤ)) : A ∈ Gamma1 N ↔
    ((↑ₘA 0 0 : ℤ) : ZMod N) = 1 ∧ ((↑ₘA 1 1 : ℤ) : ZMod N) = 1 ∧ ((↑ₘA 1 0 : ℤ) : ZMod N) = 0 
Arguments: (N : ℕ) (A : SL(2, ℤ))
Goal: A ∈ CongruenceSubgroup.Gamma1 N ↔ ↑(↑A 0 0) = 1 ∧ ↑(↑A 1 1) = 1 ∧ ↑(↑A 1 0) = 0
-- CongruenceSubgroup.Gamma1_in_Gamma0
theorem Gamma1_in_Gamma0 (N : ℕ) : Gamma1 N ≤ Gamma0 N 
Arguments: (N : ℕ)
Goal: CongruenceSubgroup.Gamma1 N ≤ CongruenceSubgroup.Gamma0 N
-- CongruenceSubgroup.isCongruenceSubgroup_trans
theorem isCongruenceSubgroup_trans (H K : Subgroup SL(2, ℤ)) (h : H ≤ K)
    (h2 : IsCongruenceSubgroup H) : IsCongruenceSubgroup K 
Arguments: (H K : Subgroup SL(2, ℤ)) (h : H ≤ K) (h2 : CongruenceSubgroup.IsCongruenceSubgroup H)
Goal: CongruenceSubgroup.IsCongruenceSubgroup K
-- CongruenceSubgroup.Gamma_is_cong_sub
theorem Gamma_is_cong_sub (N : ℕ+) : IsCongruenceSubgroup (Gamma N) 
Arguments: (N : ℕ+)
Goal: CongruenceSubgroup.IsCongruenceSubgroup (CongruenceSubgroup.Gamma ↑N)
-- CongruenceSubgroup.Gamma1_is_congruence
theorem Gamma1_is_congruence (N : ℕ+) : IsCongruenceSubgroup (Gamma1 N) 
Arguments: (N : ℕ+)
Goal: CongruenceSubgroup.IsCongruenceSubgroup (CongruenceSubgroup.Gamma1 ↑N)
-- CongruenceSubgroup.Gamma0_is_congruence
theorem Gamma0_is_congruence (N : ℕ+) : IsCongruenceSubgroup (Gamma0 N) 
Arguments: (N : ℕ+)
Goal: CongruenceSubgroup.IsCongruenceSubgroup (CongruenceSubgroup.Gamma0 ↑N)
-- CongruenceSubgroup.Gamma_cong_eq_self
theorem Gamma_cong_eq_self (N : ℕ) (g : ConjAct SL(2, ℤ)) : g • Gamma N = Gamma N 
Arguments: (N : ℕ) (g : ConjAct SL(2, ℤ))
Goal: g • CongruenceSubgroup.Gamma N = CongruenceSubgroup.Gamma N
-- CongruenceSubgroup.conj_cong_is_cong
theorem conj_cong_is_cong (g : ConjAct SL(2, ℤ)) (Γ : Subgroup SL(2, ℤ))
    (h : IsCongruenceSubgroup Γ) : IsCongruenceSubgroup (g • Γ) 
Arguments: (g : ConjAct SL(2, ℤ)) (Γ : Subgroup SL(2, ℤ)) (h : CongruenceSubgroup.IsCongruenceSubgroup Γ)
Goal: CongruenceSubgroup.IsCongruenceSubgroup (g • Γ)
-- legendreSym.at_two
theorem at_two : legendreSym p 2 = χ₈ p 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] (hp : p ≠ 2)
Goal: legendreSym p 2 = ZMod.χ₈ ↑p
-- legendreSym.at_neg_two
theorem at_neg_two : legendreSym p (-2) = χ₈' p 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] (hp : p ≠ 2)
Goal: legendreSym p (-2) = ZMod.χ₈' ↑p
-- ZMod.exists_sq_eq_two_iff
theorem exists_sq_eq_two_iff : IsSquare (2 : ZMod p) ↔ p % 8 = 1 ∨ p % 8 = 7 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] (hp : p ≠ 2)
Goal: IsSquare 2 ↔ p % 8 = 1 ∨ p % 8 = 7
-- ZMod.exists_sq_eq_neg_two_iff
theorem exists_sq_eq_neg_two_iff : IsSquare (-2 : ZMod p) ↔ p % 8 = 1 ∨ p % 8 = 3 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] (hp : p ≠ 2)
Goal: IsSquare (-2) ↔ p % 8 = 1 ∨ p % 8 = 3
-- legendreSym.quadratic_reciprocity
theorem quadratic_reciprocity (hp : p ≠ 2) (hq : q ≠ 2) (hpq : p ≠ q) :
    legendreSym q p * legendreSym p q = (-1) ^ (p / 2 * (q / 2)) 
Arguments: {p q : ℕ} [Fact (Nat.Prime p)] [Fact (Nat.Prime q)] (hp : p ≠ 2) (hq : q ≠ 2) (hpq : p ≠ q)
Goal: legendreSym q ↑p * legendreSym p ↑q = (-1) ^ (p / 2 * (q / 2))
-- legendreSym.quadratic_reciprocity'
theorem quadratic_reciprocity' (hp : p ≠ 2) (hq : q ≠ 2) :
    legendreSym q p = (-1) ^ (p / 2 * (q / 2)) * legendreSym p q 
Arguments: {p q : ℕ} [Fact (Nat.Prime p)] [Fact (Nat.Prime q)] (hp : p ≠ 2) (hq : q ≠ 2)
Goal: legendreSym q ↑p = (-1) ^ (p / 2 * (q / 2)) * legendreSym p ↑q
-- legendreSym.quadratic_reciprocity_one_mod_four
theorem quadratic_reciprocity_one_mod_four (hp : p % 4 = 1) (hq : q ≠ 2) :
    legendreSym q p = legendreSym p q 
Arguments: {p q : ℕ} [Fact (Nat.Prime p)] [Fact (Nat.Prime q)] (hp : p % 4 = 1) (hq : q ≠ 2)
Goal: legendreSym q ↑p = legendreSym p ↑q
-- legendreSym.quadratic_reciprocity_three_mod_four
theorem quadratic_reciprocity_three_mod_four (hp : p % 4 = 3) (hq : q % 4 = 3) :
    legendreSym q p = -legendreSym p q 
Arguments: {p q : ℕ} [Fact (Nat.Prime p)] [Fact (Nat.Prime q)] (hp : p % 4 = 3) (hq : q % 4 = 3)
Goal: legendreSym q ↑p = -legendreSym p ↑q
-- ZMod.exists_sq_eq_prime_iff_of_mod_four_eq_one
theorem exists_sq_eq_prime_iff_of_mod_four_eq_one (hp1 : p % 4 = 1) (hq1 : q ≠ 2) :
    IsSquare (q : ZMod p) ↔ IsSquare (p : ZMod q) 
Arguments: {p q : ℕ} [Fact (Nat.Prime p)] [Fact (Nat.Prime q)] (hp1 : p % 4 = 1) (hq1 : q ≠ 2)
Goal: IsSquare ↑q ↔ IsSquare ↑p
-- ZMod.exists_sq_eq_prime_iff_of_mod_four_eq_three
theorem exists_sq_eq_prime_iff_of_mod_four_eq_three (hp3 : p % 4 = 3) (hq3 : q % 4 = 3)
    (hpq : p ≠ q) : IsSquare (q : ZMod p) ↔ ¬IsSquare (p : ZMod q) 
Arguments: {p q : ℕ} [Fact (Nat.Prime p)] [Fact (Nat.Prime q)] (hp3 : p % 4 = 3) (hq3 : q % 4 = 3) (hpq : p ≠ q)
Goal: IsSquare ↑q ↔ ¬IsSquare ↑p
-- Liouville.irrational
protected theorem irrational {x : ℝ} (h : Liouville x) : Irrational x 
Arguments: {x : ℝ} (h : Liouville x)
Goal: Irrational x
-- Liouville.exists_one_le_pow_mul_dist
theorem exists_one_le_pow_mul_dist {Z N R : Type*} [PseudoMetricSpace R] {d : N → ℝ}
    {j : Z → N → R} {f : R → R} {α : R} {ε M : ℝ}
    -- denominators are positive
    (d0 : ∀ a : N, 1 ≤ d a)
    (e0 : 0 < ε)
    -- function is Lipschitz at α
    (B : ∀ ⦃y : R⦄, y ∈ closedBall α ε → dist (f α) (f y) ≤ dist α y * M)
    -- clear denominators
    (L : ∀ ⦃z : Z⦄, ∀ ⦃a : N⦄, j z a ∈ closedBall α ε → 1 ≤ d a * dist (f α) (f (j z a))) :
    ∃ A : ℝ, 0 < A ∧ ∀ z : Z, ∀ a : N, 1 ≤ d a * (dist α (j z a) * A) 
Arguments: {Z : Type u_1} {N : Type u_2} {R : Type u_3} [PseudoMetricSpace R] {d : N → ℝ} {j : Z → N → R} {f : R → R} {α : R} {ε M : ℝ} (d0 : ∀ (a : N), 1 ≤ d a) (e0 : 0 < ε) (B : ∀ ⦃y : R⦄, y ∈ Metric.closedBall α ε → dist (f α) (f y) ≤ dist α y * M) (L : ∀ ⦃z : Z⦄ ⦃a : N⦄, j z a ∈ Metric.closedBall α ε → 1 ≤ d a * dist (f α) (f (j z a)))
Goal: ∃ A, 0 < A ∧ ∀ (z : Z) (a : N), 1 ≤ d a * (dist α (j z a) * A)
-- Liouville.exists_pos_real_of_irrational_root
theorem exists_pos_real_of_irrational_root {α : ℝ} (ha : Irrational α) {f : ℤ[X]} (f0 : f ≠ 0)
    (fa : eval α (map (algebraMap ℤ ℝ) f) = 0) :
    ∃ A : ℝ, 0 < A ∧ ∀ a : ℤ, ∀ b : ℕ,
      (1 : ℝ) ≤ ((b : ℝ) + 1) ^ f.natDegree * (|α - a / (b + 1)| * A) 
Arguments: {α : ℝ} (ha : Irrational α) {f : Polynomial ℤ} (f0 : f ≠ 0) (fa : Polynomial.eval α (Polynomial.map (algebraMap ℤ ℝ) f) = 0)
Goal: ∃ A, 0 < A ∧ ∀ (a : ℤ) (b : ℕ), 1 ≤ (↑b + 1) ^ f.natDegree * (|α - ↑a / (↑b + 1)| * A)
-- Liouville.transcendental
protected theorem transcendental {x : ℝ} (lx : Liouville x) : Transcendental ℤ x 
Arguments: {x : ℝ} (lx : Liouville x)
Goal: Transcendental ℤ x
-- primorial_pos
theorem primorial_pos (n : ℕ) : 0 < n# 
Arguments: (n : ℕ)
Goal: 0 < n#
-- primorial_succ
theorem primorial_succ {n : ℕ} (hn1 : n ≠ 1) (hn : Odd n) : (n + 1)# = n# 
Arguments: {n : ℕ} (hn1 : n ≠ 1) (hn : Odd n)
Goal: (n + 1)# = n#
-- primorial_add
theorem primorial_add (m n : ℕ) :
    (m + n)# = m# * ∏ p ∈ filter Nat.Prime (Ico (m + 1) (m + n + 1)), p 
Arguments: (m n : ℕ)
Goal: (m + n)# = m# * ∏ p ∈ Finset.filter Nat.Prime (Finset.Ico (m + 1) (m + n + 1)), p
-- primorial_add_dvd
theorem primorial_add_dvd {m n : ℕ} (h : n ≤ m) : (m + n)# ∣ m# * choose (m + n) m 
Arguments: {m n : ℕ} (h : n ≤ m)
Goal: (m + n)# ∣ m# * (m + n).choose m
-- primorial_add_le
theorem primorial_add_le {m n : ℕ} (h : n ≤ m) : (m + n)# ≤ m# * choose (m + n) m 
Arguments: {m n : ℕ} (h : n ≤ m)
Goal: (m + n)# ≤ m# * (m + n).choose m
-- primorial_le_4_pow
theorem primorial_le_4_pow (n : ℕ) : n# ≤ 4 ^ n 
Arguments: (n : ℕ)
Goal: n# ≤ 4 ^ n
-- ZMod.χ₄_apply
@[simps]
def χ₄ : MulChar (ZMod 4) ℤ 
Arguments: (a : ZMod 4)
Goal: ZMod.χ₄ a =
  match a with
  | 0 => 0
  | 2 => 0
  | 1 => 1
  | 3 => -1
-- ZMod.isQuadratic_χ₄
theorem isQuadratic_χ₄ : χ₄.IsQuadratic 
Goal: ZMod.χ₄.IsQuadratic
-- ZMod.χ₄_nat_mod_four
theorem χ₄_nat_mod_four (n : ℕ) : χ₄ n = χ₄ (n % 4 : ℕ) 
Arguments: (n : ℕ)
Goal: ZMod.χ₄ ↑n = ZMod.χ₄ ↑(n % 4)
-- ZMod.χ₄_int_mod_four
theorem χ₄_int_mod_four (n : ℤ) : χ₄ n = χ₄ (n % 4 : ℤ) 
Arguments: (n : ℤ)
Goal: ZMod.χ₄ ↑n = ZMod.χ₄ ↑(n % 4)
-- ZMod.χ₄_int_eq_if_mod_four
theorem χ₄_int_eq_if_mod_four (n : ℤ) :
    χ₄ n = if n % 2 = 0 then 0 else if n % 4 = 1 then 1 else -1 
Arguments: (n : ℤ)
Goal: ZMod.χ₄ ↑n = if n % 2 = 0 then 0 else if n % 4 = 1 then 1 else -1
-- ZMod.χ₄_nat_eq_if_mod_four
theorem χ₄_nat_eq_if_mod_four (n : ℕ) :
    χ₄ n = if n % 2 = 0 then 0 else if n % 4 = 1 then 1 else -1 
Arguments: (n : ℕ)
Goal: ZMod.χ₄ ↑n = if n % 2 = 0 then 0 else if n % 4 = 1 then 1 else -1
-- ZMod.χ₄_eq_neg_one_pow
theorem χ₄_eq_neg_one_pow {n : ℕ} (hn : n % 2 = 1) : χ₄ n = (-1) ^ (n / 2) 
Arguments: {n : ℕ} (hn : n % 2 = 1)
Goal: ZMod.χ₄ ↑n = (-1) ^ (n / 2)
-- ZMod.χ₄_nat_one_mod_four
theorem χ₄_nat_one_mod_four {n : ℕ} (hn : n % 4 = 1) : χ₄ n = 1 
Arguments: {n : ℕ} (hn : n % 4 = 1)
Goal: ZMod.χ₄ ↑n = 1
-- ZMod.χ₄_nat_three_mod_four
theorem χ₄_nat_three_mod_four {n : ℕ} (hn : n % 4 = 3) : χ₄ n = -1 
Arguments: {n : ℕ} (hn : n % 4 = 3)
Goal: ZMod.χ₄ ↑n = -1
-- ZMod.χ₄_int_one_mod_four
theorem χ₄_int_one_mod_four {n : ℤ} (hn : n % 4 = 1) : χ₄ n = 1 
Arguments: {n : ℤ} (hn : n % 4 = 1)
Goal: ZMod.χ₄ ↑n = 1
-- ZMod.χ₄_int_three_mod_four
theorem χ₄_int_three_mod_four {n : ℤ} (hn : n % 4 = 3) : χ₄ n = -1 
Arguments: {n : ℤ} (hn : n % 4 = 3)
Goal: ZMod.χ₄ ↑n = -1
-- ZMod.neg_one_pow_div_two_of_one_mod_four
theorem neg_one_pow_div_two_of_one_mod_four {n : ℕ} (hn : n % 4 = 1) : (-1 : ℤ) ^ (n / 2) = 1 
Arguments: {n : ℕ} (hn : n % 4 = 1)
Goal: (-1) ^ (n / 2) = 1
-- ZMod.neg_one_pow_div_two_of_three_mod_four
theorem neg_one_pow_div_two_of_three_mod_four {n : ℕ} (hn : n % 4 = 3) : (-1 : ℤ) ^ (n / 2) = -1 
Arguments: {n : ℕ} (hn : n % 4 = 3)
Goal: (-1) ^ (n / 2) = -1
-- ZMod.χ₈_apply
@[simps]
def χ₈ : MulChar (ZMod 8) ℤ 
Arguments: (a : ZMod 8)
Goal: ZMod.χ₈ a =
  match a with
  | 0 => 0
  | 2 => 0
  | 4 => 0
  | 6 => 0
  | 1 => 1
  | 7 => 1
  | 3 => -1
  | 5 => -1
-- ZMod.isQuadratic_χ₈
theorem isQuadratic_χ₈ : χ₈.IsQuadratic 
Goal: ZMod.χ₈.IsQuadratic
-- ZMod.χ₈_nat_mod_eight
theorem χ₈_nat_mod_eight (n : ℕ) : χ₈ n = χ₈ (n % 8 : ℕ) 
Arguments: (n : ℕ)
Goal: ZMod.χ₈ ↑n = ZMod.χ₈ ↑(n % 8)
-- ZMod.χ₈_int_mod_eight
theorem χ₈_int_mod_eight (n : ℤ) : χ₈ n = χ₈ (n % 8 : ℤ) 
Arguments: (n : ℤ)
Goal: ZMod.χ₈ ↑n = ZMod.χ₈ ↑(n % 8)
-- ZMod.χ₈_int_eq_if_mod_eight
theorem χ₈_int_eq_if_mod_eight (n : ℤ) :
    χ₈ n = if n % 2 = 0 then 0 else if n % 8 = 1 ∨ n % 8 = 7 then 1 else -1 
Arguments: (n : ℤ)
Goal: ZMod.χ₈ ↑n = if n % 2 = 0 then 0 else if n % 8 = 1 ∨ n % 8 = 7 then 1 else -1
-- ZMod.χ₈_nat_eq_if_mod_eight
theorem χ₈_nat_eq_if_mod_eight (n : ℕ) :
    χ₈ n = if n % 2 = 0 then 0 else if n % 8 = 1 ∨ n % 8 = 7 then 1 else -1 
Arguments: (n : ℕ)
Goal: ZMod.χ₈ ↑n = if n % 2 = 0 then 0 else if n % 8 = 1 ∨ n % 8 = 7 then 1 else -1
-- ZMod.χ₈'_apply
@[simps]
def χ₈' : MulChar (ZMod 8) ℤ 
Arguments: (a : ZMod 8)
Goal: ZMod.χ₈' a =
  match a with
  | 0 => 0
  | 2 => 0
  | 4 => 0
  | 6 => 0
  | 1 => 1
  | 3 => 1
  | 5 => -1
  | 7 => -1
-- ZMod.isQuadratic_χ₈'
theorem isQuadratic_χ₈' : χ₈'.IsQuadratic 
Goal: ZMod.χ₈'.IsQuadratic
-- ZMod.χ₈'_int_eq_if_mod_eight
theorem χ₈'_int_eq_if_mod_eight (n : ℤ) :
    χ₈' n = if n % 2 = 0 then 0 else if n % 8 = 1 ∨ n % 8 = 3 then 1 else -1 
Arguments: (n : ℤ)
Goal: ZMod.χ₈' ↑n = if n % 2 = 0 then 0 else if n % 8 = 1 ∨ n % 8 = 3 then 1 else -1
-- ZMod.χ₈'_nat_eq_if_mod_eight
theorem χ₈'_nat_eq_if_mod_eight (n : ℕ) :
    χ₈' n = if n % 2 = 0 then 0 else if n % 8 = 1 ∨ n % 8 = 3 then 1 else -1 
Arguments: (n : ℕ)
Goal: ZMod.χ₈' ↑n = if n % 2 = 0 then 0 else if n % 8 = 1 ∨ n % 8 = 3 then 1 else -1
-- ZMod.χ₈'_eq_χ₄_mul_χ₈
theorem χ₈'_eq_χ₄_mul_χ₈ : ∀ a : ZMod 8, χ₈' a = χ₄ (cast a) * χ₈ a 
Arguments: (a : ZMod 8)
Goal: ZMod.χ₈' a = ZMod.χ₄ a.cast * ZMod.χ₈ a
-- ZMod.χ₈'_int_eq_χ₄_mul_χ₈
theorem χ₈'_int_eq_χ₄_mul_χ₈ (a : ℤ) : χ₈' a = χ₄ a * χ₈ a 
Arguments: (a : ℤ)
Goal: ZMod.χ₈' ↑a = ZMod.χ₄ ↑a * ZMod.χ₈ ↑a
-- quadraticCharFun_eq_zero_iff
theorem quadraticCharFun_eq_zero_iff {a : F} : quadraticCharFun F a = 0 ↔ a = 0 
Arguments: {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {a : F}
Goal: quadraticCharFun F a = 0 ↔ a = 0
-- quadraticCharFun_zero
@[simp]
theorem quadraticCharFun_zero : quadraticCharFun F 0 = 0 
Arguments: {F : Type u_1} [Field F] [Fintype F] [DecidableEq F]
Goal: quadraticCharFun F 0 = 0
-- quadraticCharFun_one
@[simp]
theorem quadraticCharFun_one : quadraticCharFun F 1 = 1 
Arguments: {F : Type u_1} [Field F] [Fintype F] [DecidableEq F]
Goal: quadraticCharFun F 1 = 1
-- quadraticCharFun_eq_one_of_char_two
theorem quadraticCharFun_eq_one_of_char_two (hF : ringChar F = 2) {a : F} (ha : a ≠ 0) :
    quadraticCharFun F a = 1 
Arguments: {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] (hF : ringChar F = 2) {a : F} (ha : a ≠ 0)
Goal: quadraticCharFun F a = 1
-- quadraticCharFun_eq_pow_of_char_ne_two
theorem quadraticCharFun_eq_pow_of_char_ne_two (hF : ringChar F ≠ 2) {a : F} (ha : a ≠ 0) :
    quadraticCharFun 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: quadraticCharFun F a = if a ^ (Fintype.card F / 2) = 1 then 1 else -1
-- quadraticCharFun_mul
theorem quadraticCharFun_mul (a b : F) :
    quadraticCharFun F (a * b) = quadraticCharFun F a * quadraticCharFun F b 
Arguments: {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] (a b : F)
Goal: quadraticCharFun F (a * b) = quadraticCharFun F a * quadraticCharFun F b
-- quadraticChar_apply
@[simps]
def quadraticChar : MulChar F ℤ 
Arguments: (F : Type u_1) [Field F] [Fintype F] [DecidableEq F] (a : F)
Goal: (quadraticChar F) a = quadraticCharFun F a
-- quadraticChar_eq_zero_iff
theorem quadraticChar_eq_zero_iff {a : F} : quadraticChar F a = 0 ↔ a = 0 
Arguments: {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {a : F}
Goal: (quadraticChar F) a = 0 ↔ a = 0