ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- LowerSet.prod_self_lt_prod_self
@[simp]
theorem prod_self_lt_prod_self : s₁ ×ˢ s₁ < s₂ ×ˢ s₂ ↔ s₁ < s₂ 
Arguments: {α : Type u_1} [Preorder α] {s₁ s₂ : LowerSet α}
Goal: s₁ ×ˢ s₁ < s₂ ×ˢ s₂ ↔ s₁ < s₂
-- LowerSet.prod_le_prod_iff
theorem prod_le_prod_iff : s₁ ×ˢ t₁ ≤ s₂ ×ˢ t₂ ↔ s₁ ≤ s₂ ∧ t₁ ≤ t₂ ∨ s₁ = ⊥ ∨ t₁ = ⊥ 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] {s₁ s₂ : LowerSet α} {t₁ t₂ : LowerSet β}
Goal: s₁ ×ˢ t₁ ≤ s₂ ×ˢ t₂ ↔ s₁ ≤ s₂ ∧ t₁ ≤ t₂ ∨ s₁ = ⊥ ∨ t₁ = ⊥
-- LowerSet.prod_eq_bot
@[simp]
theorem prod_eq_bot : s ×ˢ t = ⊥ ↔ s = ⊥ ∨ t = ⊥ 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] {s : LowerSet α} {t : LowerSet β}
Goal: s ×ˢ t = ⊥ ↔ s = ⊥ ∨ t = ⊥
-- LowerSet.disjoint_prod
@[simp]
theorem disjoint_prod : Disjoint (s₁ ×ˢ t₁) (s₂ ×ˢ t₂) ↔ Disjoint s₁ s₂ ∨ Disjoint t₁ t₂ 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] {s₁ s₂ : LowerSet α} {t₁ t₂ : LowerSet β}
Goal: Disjoint (s₁ ×ˢ t₁) (s₂ ×ˢ t₂) ↔ Disjoint s₁ s₂ ∨ Disjoint t₁ t₂
-- upperClosure_prod
@[simp]
theorem upperClosure_prod (s : Set α) (t : Set β) :
    upperClosure (s ×ˢ t) = upperClosure s ×ˢ upperClosure t 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] (s : Set α) (t : Set β)
Goal: upperClosure (s ×ˢ t) = upperClosure s ×ˢ upperClosure t
-- lowerClosure_prod
@[simp]
theorem lowerClosure_prod (s : Set α) (t : Set β) :
    lowerClosure (s ×ˢ t) = lowerClosure s ×ˢ lowerClosure t 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] (s : Set α) (t : Set β)
Goal: lowerClosure (s ×ˢ t) = lowerClosure s ×ˢ lowerClosure t
-- frobeniusNumber_pair
theorem frobeniusNumber_pair (cop : Coprime m n) (hm : 1 < m) (hn : 1 < n) :
    FrobeniusNumber (m * n - m - n) {m, n} 
Arguments: {m n : ℕ} (cop : m.Coprime n) (hm : 1 < m) (hn : 1 < n)
Goal: FrobeniusNumber (m * n - m - n) {m, n}
-- SlashInvariantForm.vAdd_width_periodic
theorem vAdd_width_periodic (N : ℕ) (k n : ℤ) (f : SlashInvariantForm (Gamma N) k) (z : ℍ) :
    f (((N * n) : ℝ) +ᵥ z) = f z 
Arguments: (N : ℕ) (k n : ℤ) (f : SlashInvariantForm (CongruenceSubgroup.Gamma N) k) (z : ℍ)
Goal: f (↑N * ↑n +ᵥ z) = f z
-- SlashInvariantForm.T_zpow_width_invariant
theorem T_zpow_width_invariant (N : ℕ) (k n : ℤ) (f : SlashInvariantForm (Gamma N) k) (z : ℍ) :
    f (((ModularGroup.T ^ (N * n))) • z) = f z 
Arguments: (N : ℕ) (k n : ℤ) (f : SlashInvariantForm (CongruenceSubgroup.Gamma N) k) (z : ℍ)
Goal: f (ModularGroup.T ^ (↑N * n) • z) = f z
-- mdifferentiable_jacobiTheta
theorem mdifferentiable_jacobiTheta : MDifferentiable 𝓘(ℂ) 𝓘(ℂ) (jacobiTheta ∘ (↑) : ℍ → ℂ) 
Goal: MDifferentiable 𝓘(ℂ, ℂ) 𝓘(ℂ, ℂ) (jacobiTheta ∘ UpperHalfPlane.coe)
-- setOf_liouville_eq_iInter_iUnion
theorem setOf_liouville_eq_iInter_iUnion :
    { x | Liouville x } =
      ⋂ n : ℕ, ⋃ (a : ℤ) (b : ℤ) (_ : 1 < b),
      ball ((a : ℝ) / b) (1 / (b : ℝ) ^ n) \ {(a : ℝ) / b} 
Goal: {x | Liouville x} = ⋂ n, ⋃ a, ⋃ b, ⋃ (_ : 1 < b), Metric.ball (↑a / ↑b) (1 / ↑b ^ n) \ {↑a / ↑b}
-- IsGδ.setOf_liouville
theorem IsGδ.setOf_liouville : IsGδ { x | Liouville x } 
Goal: IsGδ {x | Liouville x}
-- setOf_liouville_eq_irrational_inter_iInter_iUnion
theorem setOf_liouville_eq_irrational_inter_iInter_iUnion :
    { x | Liouville x } =
      { x | Irrational x } ∩ ⋂ n : ℕ, ⋃ (a : ℤ) (b : ℤ) (hb : 1 < b),
      ball (a / b) (1 / (b : ℝ) ^ n) 
Goal: {x | Liouville x} = {x | Irrational x} ∩ ⋂ n, ⋃ a, ⋃ b, ⋃ (_ : 1 < b), Metric.ball (↑a / ↑b) (1 / ↑b ^ n)
-- eventually_residual_liouville
theorem eventually_residual_liouville : ∀ᶠ x in residual ℝ, Liouville x 
Goal: ∀ᶠ (x : ℝ) in residual ℝ, Liouville x
-- dense_liouville
theorem dense_liouville : Dense { x | Liouville x } 
Goal: Dense {x | Liouville x}
-- Nat.roughNumbersUpTo_card_le'
-- This needs `Mathlib.Analysis.RCLike.Basic`, so we put it here
-- instead of in `Mathlib.NumberTheory.SmoothNumbers`.
lemma Nat.roughNumbersUpTo_card_le' (N k : ℕ) :
    (roughNumbersUpTo N k).card ≤
      N * (N.succ.primesBelow \ k.primesBelow).sum (fun p ↦ (1 : ℝ) / p) 
Arguments: (N k : ℕ)
Goal: ↑(N.roughNumbersUpTo k).card ≤ ↑N * ∑ p ∈ N.succ.primesBelow \ k.primesBelow, 1 / ↑p
-- one_half_le_sum_primes_ge_one_div
lemma one_half_le_sum_primes_ge_one_div (k : ℕ) :
    1 / 2 ≤ ∑ p ∈ (4 ^ (k.primesBelow.card + 1)).succ.primesBelow \ k.primesBelow,
      (1 / p : ℝ) 
Arguments: (k : ℕ)
Goal: 1 / 2 ≤ ∑ p ∈ (4 ^ (k.primesBelow.card + 1)).succ.primesBelow \ k.primesBelow, 1 / ↑p
-- not_summable_one_div_on_primes
theorem not_summable_one_div_on_primes :
    ¬ Summable (indicator {p | p.Prime} (fun n : ℕ ↦ (1 : ℝ) / n)) 
Goal: ¬Summable ({p | Nat.Prime p}.indicator fun n => 1 / ↑n)
-- Nat.Primes.not_summable_one_div
theorem Nat.Primes.not_summable_one_div : ¬ Summable (fun p : Nat.Primes ↦ (1 / p : ℝ)) 
Goal: ¬Summable fun p => 1 / ↑↑p
-- Nat.Primes.summable_rpow
theorem Nat.Primes.summable_rpow {r : ℝ} :
    Summable (fun p : Nat.Primes ↦ (p : ℝ) ^ r) ↔ r < -1 
Arguments: {r : ℝ}
Goal: (Summable fun p => ↑↑p ^ r) ↔ r < -1
-- gaussSum_aux_of_mulShift
lemma gaussSum_aux_of_mulShift (χ : DirichletCharacter R N) {d : ℕ}
    (hd : d ∣ N) (he : e.mulShift d = 1) {u : (ZMod N)ˣ} (hu : ZMod.unitsMap hd u = 1) :
    χ u * gaussSum χ e = gaussSum χ e 
Arguments: {N : ℕ} [NeZero N] {R : Type u_1} [CommRing R] (e : AddChar (ZMod N) R) (χ : DirichletCharacter R N) {d : ℕ} (hd : d ∣ N) (he : e.mulShift ↑d = 1) {u : (ZMod N)ˣ} (hu : (ZMod.unitsMap hd) u = 1)
Goal: χ ↑u * gaussSum χ e = gaussSum χ e
-- factorsThrough_of_gaussSum_ne_zero
lemma factorsThrough_of_gaussSum_ne_zero [IsDomain R] {χ : DirichletCharacter R N} {d : ℕ}
    (hd : d ∣ N) (he : e.mulShift d = 1) (h_ne : gaussSum χ e ≠ 0) :
    χ.FactorsThrough d 
Arguments: {N : ℕ} [NeZero N] {R : Type u_1} [CommRing R] (e : AddChar (ZMod N) R) [IsDomain R] {χ : DirichletCharacter R N} {d : ℕ} (hd : d ∣ N) (he : e.mulShift ↑d = 1) (h_ne : gaussSum χ e ≠ 0)
Goal: χ.FactorsThrough d
-- gaussSum_eq_zero_of_isPrimitive_of_not_isPrimitive
lemma gaussSum_eq_zero_of_isPrimitive_of_not_isPrimitive [IsDomain R]
    {χ : DirichletCharacter R N} (hχ : IsPrimitive χ) (he : ¬IsPrimitive e) :
    gaussSum χ e = 0 
Arguments: {N : ℕ} [NeZero N] {R : Type u_1} [CommRing R] (e : AddChar (ZMod N) R) [IsDomain R] {χ : DirichletCharacter R N} (hχ : χ.IsPrimitive) (he : ¬e.IsPrimitive)
Goal: gaussSum χ e = 0
-- gaussSum_mulShift_of_isPrimitive
lemma gaussSum_mulShift_of_isPrimitive [IsDomain R] {χ : DirichletCharacter R N}
    (hχ : IsPrimitive χ) (a : ZMod N) :
    gaussSum χ (e.mulShift a) = χ⁻¹ a * gaussSum χ e 
Arguments: {N : ℕ} [NeZero N] {R : Type u_1} [CommRing R] (e : AddChar (ZMod N) R) [IsDomain R] {χ : DirichletCharacter R N} (hχ : χ.IsPrimitive) (a : ZMod N)
Goal: gaussSum χ (e.mulShift a) = χ⁻¹ a * gaussSum χ e
-- SlashInvariantForm.slash_action_eq'
structure SlashInvariantForm where
  toFun : ℍ → ℂ
  slash_action_eq' : ∀ γ : Γ, toFun ∣[k] γ = toFun
Arguments: {Γ : outParam (Subgroup SL(2, ℤ))} {k : outParam ℤ} (self : SlashInvariantForm Γ k) (γ : ↥Γ)
Goal: self.toFun ∣[k] γ = self.toFun
-- SlashInvariantFormClass.slash_action_eq
class SlashInvariantFormClass [FunLike F ℍ ℂ] : Prop where
  slash_action_eq : ∀ (f : F) (γ : Γ), (f : ℍ → ℂ) ∣[k] γ = f
Arguments: {F : Type u_1} {Γ : outParam (Subgroup SL(2, ℤ))} {k : outParam ℤ} [FunLike F ℍ ℂ] [self : SlashInvariantFormClass F Γ k] (f : F) (γ : ↥Γ)
Goal: ⇑f ∣[k] γ = ⇑f
-- SlashInvariantForm.toFun_eq_coe
@[simp]
theorem SlashInvariantForm.toFun_eq_coe {f : SlashInvariantForm Γ k} : f.toFun = (f : ℍ → ℂ) 
Arguments: {Γ : outParam (Subgroup SL(2, ℤ))} {k : outParam ℤ} {f : SlashInvariantForm Γ k}
Goal: f.toFun = ⇑f
-- SlashInvariantForm.coe_mk
@[simp]
theorem SlashInvariantForm.coe_mk (f : ℍ → ℂ) (hf : ∀ γ : Γ, f ∣[k] γ = f) : ⇑(mk f hf) = f 
Arguments: {Γ : outParam (Subgroup SL(2, ℤ))} {k : outParam ℤ} (f : ℍ → ℂ) (hf : ∀ (γ : ↥Γ), f ∣[k] γ = f)
Goal: ⇑{ toFun := f, slash_action_eq' := hf } = f
-- SlashInvariantForm.ext
@[ext]
theorem SlashInvariantForm.ext {f g : SlashInvariantForm Γ k} (h : ∀ x, f x = g x) : f = g 
Arguments: {Γ : outParam (Subgroup SL(2, ℤ))} {k : outParam ℤ} {f g : SlashInvariantForm Γ k} (h : ∀ (x : ℍ), f x = g x)
Goal: f = g
-- SlashInvariantForm.slash_action_eqn
theorem slash_action_eqn [SlashInvariantFormClass F Γ k] (f : F) (γ : Γ) :
    ↑f ∣[k] γ = ⇑f 
Arguments: {F : Type u_1} {Γ : Subgroup SL(2, ℤ)} {k : ℤ} [FunLike F ℍ ℂ] [SlashInvariantFormClass F Γ k] (f : F) (γ : ↥Γ)
Goal: ⇑f ∣[k] γ = ⇑f
-- SlashInvariantForm.slash_action_eqn'
theorem slash_action_eqn' (k : ℤ) (Γ : Subgroup SL(2, ℤ)) [SlashInvariantFormClass F Γ k] (f : F)
    (γ : Γ) (z : ℍ) : f (γ • z) = ((↑ₘ[ℤ] γ 1 0 : ℂ) * z + (↑ₘ[ℤ] γ 1 1 : ℂ)) ^ k * f z 
Arguments: {F : Type u_1} [FunLike F ℍ ℂ] (k : ℤ) (Γ : Subgroup SL(2, ℤ)) [SlashInvariantFormClass F Γ k] (f : F) (γ : ↥Γ) (z : ℍ)
Goal: f (γ • z) = (↑(↑↑↑γ 1 0) * ↑z + ↑(↑↑↑γ 1 1)) ^ k * f z
-- SlashInvariantForm.SlashInvariantFormClass.coe_coe
@[simp]
theorem SlashInvariantFormClass.coe_coe [SlashInvariantFormClass F Γ k] (f : F) :
    ((f : SlashInvariantForm Γ k) : ℍ → ℂ) = f 
Arguments: {F : Type u_1} {Γ : Subgroup SL(2, ℤ)} {k : ℤ} [FunLike F ℍ ℂ] [SlashInvariantFormClass F Γ k] (f : F)
Goal: ⇑{ toFun := ⇑f, slash_action_eq' := ⋯ } = ⇑f
-- SlashInvariantForm.coe_add
@[simp]
theorem coe_add (f g : SlashInvariantForm Γ k) : ⇑(f + g) = f + g 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} (f g : SlashInvariantForm Γ k)
Goal: ⇑(f + g) = ⇑f + ⇑g
-- SlashInvariantForm.add_apply
@[simp]
theorem add_apply (f g : SlashInvariantForm Γ k) (z : ℍ) : (f + g) z = f z + g z 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} (f g : SlashInvariantForm Γ k) (z : ℍ)
Goal: (f + g) z = f z + g z
-- SlashInvariantForm.coe_zero
@[simp]
theorem coe_zero : ⇑(0 : SlashInvariantForm Γ k) = (0 : ℍ → ℂ) 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ}
Goal: ⇑0 = 0
-- SlashInvariantForm.coe_smul
@[simp]
theorem coe_smul (f : SlashInvariantForm Γ k) (n : α) : ⇑(n • f) = n • ⇑f 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} {α : Type u_2} [SMul α ℂ] [IsScalarTower α ℂ ℂ] (f : SlashInvariantForm Γ k) (n : α)
Goal: ⇑(n • f) = n • ⇑f
-- SlashInvariantForm.smul_apply
@[simp]
theorem smul_apply (f : SlashInvariantForm Γ k) (n : α) (z : ℍ) : (n • f) z = n • f z 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} {α : Type u_2} [SMul α ℂ] [IsScalarTower α ℂ ℂ] (f : SlashInvariantForm Γ k) (n : α) (z : ℍ)
Goal: (n • f) z = n • f z
-- SlashInvariantForm.coe_neg
@[simp]
theorem coe_neg (f : SlashInvariantForm Γ k) : ⇑(-f) = -f 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} (f : SlashInvariantForm Γ k)
Goal: ⇑(-f) = -⇑f
-- SlashInvariantForm.neg_apply
@[simp]
theorem neg_apply (f : SlashInvariantForm Γ k) (z : ℍ) : (-f) z = -f z 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} (f : SlashInvariantForm Γ k) (z : ℍ)
Goal: (-f) z = -f z
-- SlashInvariantForm.coe_sub
@[simp]
theorem coe_sub (f g : SlashInvariantForm Γ k) : ⇑(f - g) = f - g 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} (f g : SlashInvariantForm Γ k)
Goal: ⇑(f - g) = ⇑f - ⇑g
-- SlashInvariantForm.sub_apply
@[simp]
theorem sub_apply (f g : SlashInvariantForm Γ k) (z : ℍ) : (f - g) z = f z - g z 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ} (f g : SlashInvariantForm Γ k) (z : ℍ)
Goal: (f - g) z = f z - g z
-- SlashInvariantForm.coeHom_injective
theorem coeHom_injective : Function.Injective (@coeHom Γ k) 
Arguments: {Γ : Subgroup SL(2, ℤ)} {k : ℤ}
Goal: Function.Injective ⇑SlashInvariantForm.coeHom
-- SlashInvariantForm.const_toFun
@[simps (config := .asFn)]
def const (x : ℂ) : SlashInvariantForm Γ 0 
Arguments: {Γ : Subgroup SL(2, ℤ)} (x : ℂ)
Goal: ⇑(SlashInvariantForm.const x) = Function.const ℍ x
-- SlashInvariantForm.one_coe_eq_one
@[simp]
theorem one_coe_eq_one : ((1 : SlashInvariantForm Γ 0) : ℍ → ℂ) = 1 
Arguments: {Γ : Subgroup SL(2, ℤ)}
Goal: ⇑1 = 1
-- SlashInvariantForm.coe_mul
@[simp]
theorem coe_mul {k₁ k₂ : ℤ} {Γ : Subgroup SL(2, ℤ)} (f : SlashInvariantForm Γ k₁)
    (g : SlashInvariantForm Γ k₂) : ⇑(f.mul g) = ⇑f * ⇑g 
Arguments: {k₁ k₂ : ℤ} {Γ : Subgroup SL(2, ℤ)} (f : SlashInvariantForm Γ k₁) (g : SlashInvariantForm Γ k₂)
Goal: ⇑(f.mul g) = ⇑f * ⇑g
-- SlashInvariantForm.coe_natCast
@[simp, norm_cast]
theorem coe_natCast (n : ℕ) : ⇑(n : SlashInvariantForm Γ 0) = n 
Arguments: {Γ : Subgroup SL(2, ℤ)} (n : ℕ)
Goal: ⇑↑n = ↑n
-- SlashInvariantForm.coe_intCast
@[simp, norm_cast]
theorem coe_intCast (z : ℤ) : ⇑(z : SlashInvariantForm Γ 0) = z 
Arguments: {Γ : Subgroup SL(2, ℤ)} (z : ℤ)
Goal: ⇑↑z = ↑z
-- LiouvilleNumber.summable
protected theorem summable {m : ℝ} (hm : 1 < m) : Summable fun i : ℕ => 1 / m ^ i ! 
Arguments: {m : ℝ} (hm : 1 < m)
Goal: Summable fun i => 1 / m ^ i !
-- LiouvilleNumber.remainder_summable
theorem remainder_summable {m : ℝ} (hm : 1 < m) (k : ℕ) :
    Summable fun i : ℕ => 1 / m ^ (i + (k + 1))! 
Arguments: {m : ℝ} (hm : 1 < m) (k : ℕ)
Goal: Summable fun i => 1 / m ^ (i + (k + 1))!
-- LiouvilleNumber.remainder_pos
theorem remainder_pos {m : ℝ} (hm : 1 < m) (k : ℕ) : 0 < remainder m k 
Arguments: {m : ℝ} (hm : 1 < m) (k : ℕ)
Goal: 0 < LiouvilleNumber.remainder m k
-- LiouvilleNumber.partialSum_succ
theorem partialSum_succ (m : ℝ) (n : ℕ) :
    partialSum m (n + 1) = partialSum m n + 1 / m ^ (n + 1)! 
Arguments: (m : ℝ) (n : ℕ)
Goal: LiouvilleNumber.partialSum m (n + 1) = LiouvilleNumber.partialSum m n + 1 / m ^ (n + 1)!
-- LiouvilleNumber.partialSum_add_remainder
theorem partialSum_add_remainder {m : ℝ} (hm : 1 < m) (k : ℕ) :
    partialSum m k + remainder m k = liouvilleNumber m 
Arguments: {m : ℝ} (hm : 1 < m) (k : ℕ)
Goal: LiouvilleNumber.partialSum m k + LiouvilleNumber.remainder m k = liouvilleNumber m
-- LiouvilleNumber.remainder_lt'
theorem remainder_lt' (n : ℕ) {m : ℝ} (m1 : 1 < m) :
    remainder m n < (1 - 1 / m)⁻¹ * (1 / m ^ (n + 1)!) 
Arguments: (n : ℕ) {m : ℝ} (m1 : 1 < m)
Goal: LiouvilleNumber.remainder m n < (1 - 1 / m)⁻¹ * (1 / m ^ (n + 1)!)
-- LiouvilleNumber.aux_calc
theorem aux_calc (n : ℕ) {m : ℝ} (hm : 2 ≤ m) :
    (1 - 1 / m)⁻¹ * (1 / m ^ (n + 1)!) ≤ 1 / (m ^ n !) ^ n 
Arguments: (n : ℕ) {m : ℝ} (hm : 2 ≤ m)
Goal: (1 - 1 / m)⁻¹ * (1 / m ^ (n + 1)!) ≤ 1 / (m ^ n !) ^ n
-- LiouvilleNumber.remainder_lt
theorem remainder_lt (n : ℕ) {m : ℝ} (m2 : 2 ≤ m) : remainder m n < 1 / (m ^ n !) ^ n 
Arguments: (n : ℕ) {m : ℝ} (m2 : 2 ≤ m)
Goal: LiouvilleNumber.remainder m n < 1 / (m ^ n !) ^ n
-- LiouvilleNumber.partialSum_eq_rat
theorem partialSum_eq_rat {m : ℕ} (hm : 0 < m) (k : ℕ) :
    ∃ p : ℕ, partialSum m k = p / ((m ^ k ! :) : ℝ) 
Arguments: {m : ℕ} (hm : 0 < m) (k : ℕ)
Goal: ∃ p, LiouvilleNumber.partialSum (↑m) k = ↑p / ↑(m ^ k !)
-- liouville_liouvilleNumber
theorem liouville_liouvilleNumber {m : ℕ} (hm : 2 ≤ m) : Liouville (liouvilleNumber m) 
Arguments: {m : ℕ} (hm : 2 ≤ m)
Goal: Liouville (liouvilleNumber ↑m)
-- transcendental_liouvilleNumber
theorem transcendental_liouvilleNumber {m : ℕ} (hm : 2 ≤ m) :
    Transcendental ℤ (liouvilleNumber m) 
Arguments: {m : ℕ} (hm : 2 ≤ m)
Goal: Transcendental ℤ (liouvilleNumber ↑m)
-- EisensteinSeries.summable_norm_eisSummand
lemma summable_norm_eisSummand {k : ℤ} (hk : 3 ≤ k) (z : ℍ) :
    Summable fun (x : Fin 2 → ℤ) ↦ ‖(eisSummand k x z)‖ 
Arguments: {k : ℤ} (hk : 3 ≤ k) (z : ℍ)
Goal: Summable fun x => ‖EisensteinSeries.eisSummand k x z‖
-- EisensteinSeries.abs_le_tsum_abs
lemma abs_le_tsum_abs (N : ℕ) (a : Fin 2 → ZMod N) (k : ℤ) (hk : 3 ≤ k) (z : ℍ) :
    Complex.abs (eisensteinSeries a k z) ≤ ∑' (x : Fin 2 → ℤ), Complex.abs (eisSummand k x z) 
Arguments: (N : ℕ) (a : Fin 2 → ZMod N) (k : ℤ) (hk : 3 ≤ k) (z : ℍ)
Goal: Complex.abs (eisensteinSeries a k z) ≤ ∑' (x : Fin 2 → ℤ), Complex.abs (EisensteinSeries.eisSummand k x z)
-- EisensteinSeries.isBoundedAtImInfty_eisensteinSeries_SIF
theorem isBoundedAtImInfty_eisensteinSeries_SIF {N : ℕ+} (a : Fin 2 → ZMod N) {k : ℤ} (hk : 3 ≤ k)
    (A : SL(2, ℤ)) : IsBoundedAtImInfty ((eisensteinSeries_SIF a k).toFun ∣[k] A) 
Arguments: {N : ℕ+} (a : Fin 2 → ZMod ↑N) {k : ℤ} (hk : 3 ≤ k) (A : SL(2, ℤ))
Goal: UpperHalfPlane.IsBoundedAtImInfty ((EisensteinSeries.eisensteinSeries_SIF a k).toFun ∣[k] A)
-- DirichletCharacter.toUnitHom_eq_char'
lemma toUnitHom_eq_char' {a : ZMod n} (ha : IsUnit a) : χ a = χ.toUnitHom ha.unit 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n : ℕ} (χ : DirichletCharacter R n) {a : ZMod n} (ha : IsUnit a)
Goal: χ a = ↑((MulChar.toUnitHom χ) ha.unit)
-- DirichletCharacter.toUnitHom_eq_iff
lemma toUnitHom_eq_iff (ψ : DirichletCharacter R n) : toUnitHom χ = toUnitHom ψ ↔ χ = ψ 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n : ℕ} (χ ψ : DirichletCharacter R n)
Goal: MulChar.toUnitHom χ = MulChar.toUnitHom ψ ↔ χ = ψ
-- DirichletCharacter.eval_modulus_sub
lemma eval_modulus_sub (x : ZMod n) : χ (n - x) = χ (-x) 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n : ℕ} (χ : DirichletCharacter R n) (x : ZMod n)
Goal: χ (↑n - x) = χ (-x)
-- DirichletCharacter.changeLevel_def
lemma changeLevel_def {m : ℕ} (hm : n ∣ m) :
    changeLevel hm χ = MulChar.ofUnitHom (χ.toUnitHom.comp (ZMod.unitsMap hm)) 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n : ℕ} (χ : DirichletCharacter R n) {m : ℕ} (hm : n ∣ m)
Goal: (DirichletCharacter.changeLevel hm) χ = MulChar.ofUnitHom ((MulChar.toUnitHom χ).comp (ZMod.unitsMap hm))
-- DirichletCharacter.changeLevel_toUnitHom
lemma changeLevel_toUnitHom {m : ℕ} (hm : n ∣ m) :
    (changeLevel hm χ).toUnitHom = χ.toUnitHom.comp (ZMod.unitsMap hm) 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n : ℕ} (χ : DirichletCharacter R n) {m : ℕ} (hm : n ∣ m)
Goal: MulChar.toUnitHom ((DirichletCharacter.changeLevel hm) χ) = (MulChar.toUnitHom χ).comp (ZMod.unitsMap hm)
-- DirichletCharacter.changeLevel_injective
lemma changeLevel_injective {m : ℕ} [NeZero m] (hm : n ∣ m) :
    Function.Injective (changeLevel (R := R) hm) 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n m : ℕ} [NeZero m] (hm : n ∣ m)
Goal: Function.Injective ⇑(DirichletCharacter.changeLevel hm)
-- DirichletCharacter.changeLevel_eq_one_iff
@[simp]
lemma changeLevel_eq_one_iff {m : ℕ} {χ : DirichletCharacter R n} (hm : n ∣ m) [NeZero m] :
    changeLevel hm χ = 1 ↔ χ = 1 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n m : ℕ} {χ : DirichletCharacter R n} (hm : n ∣ m) [NeZero m]
Goal: (DirichletCharacter.changeLevel hm) χ = 1 ↔ χ = 1
-- DirichletCharacter.changeLevel_self
@[simp]
lemma changeLevel_self : changeLevel (dvd_refl n) χ = χ 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n : ℕ} (χ : DirichletCharacter R n)
Goal: (DirichletCharacter.changeLevel ⋯) χ = χ
-- DirichletCharacter.changeLevel_self_toUnitHom
lemma changeLevel_self_toUnitHom : (changeLevel (dvd_refl n) χ).toUnitHom = χ.toUnitHom 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n : ℕ} (χ : DirichletCharacter R n)
Goal: MulChar.toUnitHom ((DirichletCharacter.changeLevel ⋯) χ) = MulChar.toUnitHom χ
-- DirichletCharacter.changeLevel_trans
lemma changeLevel_trans {m d : ℕ} (hm : n ∣ m) (hd : m ∣ d) :
    changeLevel (dvd_trans hm hd) χ = changeLevel hd (changeLevel hm χ) 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n : ℕ} (χ : DirichletCharacter R n) {m d : ℕ} (hm : n ∣ m) (hd : m ∣ d)
Goal: (DirichletCharacter.changeLevel ⋯) χ = (DirichletCharacter.changeLevel hd) ((DirichletCharacter.changeLevel hm) χ)
-- DirichletCharacter.changeLevel_eq_cast_of_dvd
lemma changeLevel_eq_cast_of_dvd {m : ℕ} (hm : n ∣ m) (a : Units (ZMod m)) :
    (changeLevel hm χ) a = χ (ZMod.cast (a : ZMod m)) 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n : ℕ} (χ : DirichletCharacter R n) {m : ℕ} (hm : n ∣ m) (a : (ZMod m)ˣ)
Goal: ((DirichletCharacter.changeLevel hm) χ) ↑a = χ (↑a).cast
-- DirichletCharacter.changeLevel_factorsThrough
lemma changeLevel_factorsThrough {m : ℕ} (hm : n ∣ m) : FactorsThrough (changeLevel hm χ) n 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n : ℕ} (χ : DirichletCharacter R n) {m : ℕ} (hm : n ∣ m)
Goal: ((DirichletCharacter.changeLevel hm) χ).FactorsThrough n
-- DirichletCharacter.FactorsThrough.dvd
lemma dvd {d : ℕ} (h : FactorsThrough χ d) : d ∣ n 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n : ℕ} {χ : DirichletCharacter R n} {d : ℕ} (h : χ.FactorsThrough d)
Goal: d ∣ n
-- DirichletCharacter.FactorsThrough.eq_changeLevel
lemma eq_changeLevel {d : ℕ} (h : FactorsThrough χ d) : χ = changeLevel h.dvd h.χ₀ 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n : ℕ} {χ : DirichletCharacter R n} {d : ℕ} (h : χ.FactorsThrough d)
Goal: χ = (DirichletCharacter.changeLevel ⋯) h.χ₀
-- DirichletCharacter.FactorsThrough.existsUnique
lemma existsUnique {d : ℕ} [NeZero n] (h : FactorsThrough χ d) :
    ∃! χ' : DirichletCharacter R d, χ = changeLevel h.dvd χ' 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n : ℕ} {χ : DirichletCharacter R n} {d : ℕ} [NeZero n] (h : χ.FactorsThrough d)
Goal: ∃! χ', χ = (DirichletCharacter.changeLevel ⋯) χ'
-- DirichletCharacter.FactorsThrough.same_level
lemma same_level : FactorsThrough χ n 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n : ℕ} (χ : DirichletCharacter R n)
Goal: χ.FactorsThrough n
-- DirichletCharacter.factorsThrough_iff_ker_unitsMap
lemma factorsThrough_iff_ker_unitsMap {d : ℕ} [NeZero n] (hd : d ∣ n) :
    FactorsThrough χ d ↔ (ZMod.unitsMap hd).ker ≤ χ.toUnitHom.ker 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n : ℕ} {χ : DirichletCharacter R n} {d : ℕ} [NeZero n] (hd : d ∣ n)
Goal: χ.FactorsThrough d ↔ (ZMod.unitsMap hd).ker ≤ (MulChar.toUnitHom χ).ker
-- DirichletCharacter.level_one
lemma level_one (χ : DirichletCharacter R 1) : χ = 1 
Arguments: {R : Type u_1} [CommMonoidWithZero R] (χ : DirichletCharacter R 1)
Goal: χ = 1
-- DirichletCharacter.level_one'
lemma level_one' (hn : n = 1) : χ = 1 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n : ℕ} (χ : DirichletCharacter R n) (hn : n = 1)
Goal: χ = 1
-- DirichletCharacter.changeLevel_one
lemma changeLevel_one {d : ℕ} (h : d ∣ n) :
    changeLevel h (1 : DirichletCharacter R d) = 1 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n d : ℕ} (h : d ∣ n)
Goal: (DirichletCharacter.changeLevel h) 1 = 1
-- DirichletCharacter.factorsThrough_one_iff
lemma factorsThrough_one_iff : FactorsThrough χ 1 ↔ χ = 1 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n : ℕ} (χ : DirichletCharacter R n)
Goal: χ.FactorsThrough 1 ↔ χ = 1
-- DirichletCharacter.mem_conductorSet_iff
lemma mem_conductorSet_iff {x : ℕ} : x ∈ conductorSet χ ↔ FactorsThrough χ x 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n : ℕ} (χ : DirichletCharacter R n) {x : ℕ}
Goal: x ∈ χ.conductorSet ↔ χ.FactorsThrough x
-- DirichletCharacter.level_mem_conductorSet
lemma level_mem_conductorSet : n ∈ conductorSet χ 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n : ℕ} (χ : DirichletCharacter R n)
Goal: n ∈ χ.conductorSet
-- DirichletCharacter.mem_conductorSet_dvd
lemma mem_conductorSet_dvd {x : ℕ} (hx : x ∈ conductorSet χ) : x ∣ n 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n : ℕ} (χ : DirichletCharacter R n) {x : ℕ} (hx : x ∈ χ.conductorSet)
Goal: x ∣ n
-- DirichletCharacter.conductor_mem_conductorSet
lemma conductor_mem_conductorSet : conductor χ ∈ conductorSet χ 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n : ℕ} (χ : DirichletCharacter R n)
Goal: χ.conductor ∈ χ.conductorSet
-- DirichletCharacter.conductor_dvd_level
lemma conductor_dvd_level : conductor χ ∣ n 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n : ℕ} (χ : DirichletCharacter R n)
Goal: χ.conductor ∣ n
-- DirichletCharacter.factorsThrough_conductor
lemma factorsThrough_conductor : FactorsThrough χ (conductor χ) 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n : ℕ} (χ : DirichletCharacter R n)
Goal: χ.FactorsThrough χ.conductor
-- DirichletCharacter.conductor_ne_zero
lemma conductor_ne_zero (hn : n ≠ 0) : conductor χ ≠ 0 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n : ℕ} (χ : DirichletCharacter R n) (hn : n ≠ 0)
Goal: χ.conductor ≠ 0
-- DirichletCharacter.conductor_one
lemma conductor_one (hn : n ≠ 0) : conductor (1 : DirichletCharacter R n) = 1 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n : ℕ} (hn : n ≠ 0)
Goal: DirichletCharacter.conductor 1 = 1
-- DirichletCharacter.eq_one_iff_conductor_eq_one
lemma eq_one_iff_conductor_eq_one (hn : n ≠ 0) : χ = 1 ↔ conductor χ = 1 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n : ℕ} {χ : DirichletCharacter R n} (hn : n ≠ 0)
Goal: χ = 1 ↔ χ.conductor = 1