File: Mathlib/NumberTheory/ModularForms/Basic.lean

full_name: «_aux_Mathlib_NumberTheory_ModularForms_Basic___macroRules_termGL(_,_)⁺_1»
code: local notation "GL(" n ", " R ")" "⁺" => Matrix.GLPos (Fin n) R
goal: Lean.Macro

full_name: _aux_Mathlib_NumberTheory_ModularForms_Basic___unexpand_Matrix_GLPos_1
code: local notation "GL(" n ", " R ")" "⁺" => Matrix.GLPos (Fin n) R
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_NumberTheory_ModularForms_Basic___macroRules_termSL(_,_)_1»
code: local notation "SL(" n ", " R ")" => Matrix.SpecialLinearGroup (Fin n) R
goal: Lean.Macro

full_name: _aux_Mathlib_NumberTheory_ModularForms_Basic___unexpand_Matrix_SpecialLinearGroup_1
code: local notation "SL(" n ", " R ")" => Matrix.SpecialLinearGroup (Fin n) R
goal: Lean.PrettyPrinter.Unexpander

full_name: ModularForm.holo'
code: /-- These are `SlashInvariantForm`'s that are holomorphic and bounded at infinity. -/
structure ModularForm extends SlashInvariantForm Γ k where
  holo' : MDifferentiable 𝓘(ℂ) 𝓘(ℂ) (toSlashInvariantForm : ℍ → ℂ)
  bdd_at_infty' : ∀ A : SL(2, ℤ), IsBoundedAtImInfty (toSlashInvariantForm ∣[k] A)
goal: MDifferentiable 𝓘(ℂ, ℂ) 𝓘(ℂ, ℂ) ⇑self.toSlashInvariantForm

full_name: ModularForm.bdd_at_infty'
code: /-- These are `SlashInvariantForm`'s that are holomorphic and bounded at infinity. -/
structure ModularForm extends SlashInvariantForm Γ k where
  holo' : MDifferentiable 𝓘(ℂ) 𝓘(ℂ) (toSlashInvariantForm : ℍ → ℂ)
  bdd_at_infty' : ∀ A : SL(2, ℤ), IsBoundedAtImInfty (toSlashInvariantForm ∣[k] A)
goal: UpperHalfPlane.IsBoundedAtImInfty (SlashAction.map ℂ k A ⇑self.toSlashInvariantForm)

full_name: ModularForm
code: /-- These are `SlashInvariantForm`'s that are holomorphic and bounded at infinity. -/
structure ModularForm extends SlashInvariantForm Γ k where
  holo' : MDifferentiable 𝓘(ℂ) 𝓘(ℂ) (toSlashInvariantForm : ℍ → ℂ)
  bdd_at_infty' : ∀ A : SL(2, ℤ), IsBoundedAtImInfty (toSlashInvariantForm ∣[k] A)
goal: Type

full_name: CuspForm.holo'
code: /-- These are `SlashInvariantForm`s that are holomorphic and zero at infinity. -/
structure CuspForm extends SlashInvariantForm Γ k where
  holo' : MDifferentiable 𝓘(ℂ) 𝓘(ℂ) (toSlashInvariantForm : ℍ → ℂ)
  zero_at_infty' : ∀ A : SL(2, ℤ), IsZeroAtImInfty (toSlashInvariantForm ∣[k] A)
goal: MDifferentiable 𝓘(ℂ, ℂ) 𝓘(ℂ, ℂ) ⇑self.toSlashInvariantForm

full_name: CuspForm.zero_at_infty'
code: /-- These are `SlashInvariantForm`s that are holomorphic and zero at infinity. -/
structure CuspForm extends SlashInvariantForm Γ k where
  holo' : MDifferentiable 𝓘(ℂ) 𝓘(ℂ) (toSlashInvariantForm : ℍ → ℂ)
  zero_at_infty' : ∀ A : SL(2, ℤ), IsZeroAtImInfty (toSlashInvariantForm ∣[k] A)
goal: UpperHalfPlane.IsZeroAtImInfty (SlashAction.map ℂ k A ⇑self.toSlashInvariantForm)

full_name: CuspForm
code: /-- These are `SlashInvariantForm`s that are holomorphic and zero at infinity. -/
structure CuspForm extends SlashInvariantForm Γ k where
  holo' : MDifferentiable 𝓘(ℂ) 𝓘(ℂ) (toSlashInvariantForm : ℍ → ℂ)
  zero_at_infty' : ∀ A : SL(2, ℤ), IsZeroAtImInfty (toSlashInvariantForm ∣[k] A)
goal: Type

full_name: ModularFormClass
code: /-- `ModularFormClass F Γ k` says that `F` is a type of bundled functions that extend
`SlashInvariantFormClass` by requiring that the functions be holomorphic and bounded
at infinity. -/
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)
goal: Prop

full_name: ModularFormClass.holo
code: /-- `ModularFormClass F Γ k` says that `F` is a type of bundled functions that extend
`SlashInvariantFormClass` by requiring that the functions be holomorphic and bounded
at infinity. -/
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)
goal: MDifferentiable 𝓘(ℂ, ℂ) 𝓘(ℂ, ℂ) ⇑f

full_name: ModularFormClass.bdd_at_infty
code: /-- `ModularFormClass F Γ k` says that `F` is a type of bundled functions that extend
`SlashInvariantFormClass` by requiring that the functions be holomorphic and bounded
at infinity. -/
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)
goal: UpperHalfPlane.IsBoundedAtImInfty (SlashAction.map ℂ k A ⇑f)

full_name: CuspFormClass.zero_at_infty
code: /-- `CuspFormClass F Γ k` says that `F` is a type of bundled functions that extend
`SlashInvariantFormClass` by requiring that the functions be holomorphic and zero
at infinity. -/
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)
goal: UpperHalfPlane.IsZeroAtImInfty (SlashAction.map ℂ k A ⇑f)

full_name: CuspFormClass
code: /-- `CuspFormClass F Γ k` says that `F` is a type of bundled functions that extend
`SlashInvariantFormClass` by requiring that the functions be holomorphic and zero
at infinity. -/
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)
goal: Prop

full_name: CuspFormClass.holo
code: /-- `CuspFormClass F Γ k` says that `F` is a type of bundled functions that extend
`SlashInvariantFormClass` by requiring that the functions be holomorphic and zero
at infinity. -/
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)
goal: MDifferentiable 𝓘(ℂ, ℂ) 𝓘(ℂ, ℂ) ⇑f

full_name: ModularForm.funLike
code: instance (priority := 100) ModularForm.funLike :
    FunLike (ModularForm Γ k) ℍ ℂ 
goal: FunLike (ModularForm Γ k) ℍ ℂ

full_name: ModularFormClass.modularForm
code: instance (priority := 100) ModularFormClass.modularForm :
    ModularFormClass (ModularForm Γ k) Γ k 
goal: ModularFormClass (ModularForm Γ k) Γ k

full_name: CuspForm.funLike
code: instance (priority := 100) CuspForm.funLike : FunLike (CuspForm Γ k) ℍ ℂ 
goal: FunLike (CuspForm Γ k) ℍ ℂ

full_name: CuspFormClass.cuspForm
code: instance (priority := 100) CuspFormClass.cuspForm : CuspFormClass (CuspForm Γ k) Γ k 
goal: CuspFormClass (CuspForm Γ k) Γ k

full_name: ModularForm.toFun_eq_coe
code: theorem ModularForm.toFun_eq_coe (f : ModularForm Γ k) : f.toFun = (f : ℍ → ℂ) 
goal: f.toFun = ⇑f

full_name: ModularForm.toSlashInvariantForm_coe
code: @[simp]
theorem ModularForm.toSlashInvariantForm_coe (f : ModularForm Γ k) : ⇑f.1 = f 
goal: ⇑f.toSlashInvariantForm = ⇑f

full_name: CuspForm.toFun_eq_coe
code: theorem CuspForm.toFun_eq_coe {f : CuspForm Γ k} : f.toFun = (f : ℍ → ℂ) 
goal: f.toFun = ⇑f

full_name: CuspForm.toSlashInvariantForm_coe
code: @[simp]
theorem CuspForm.toSlashInvariantForm_coe (f : CuspForm Γ k) : ⇑f.1 = f 
goal: ⇑f.toSlashInvariantForm = ⇑f

full_name: ModularForm.ext
code: @[ext]
theorem ModularForm.ext {f g : ModularForm Γ k} (h : ∀ x, f x = g x) : f = g 
goal: f = g

full_name: CuspForm.ext
code: @[ext]
theorem CuspForm.ext {f g : CuspForm Γ k} (h : ∀ x, f x = g x) : f = g 
goal: f = g

full_name: ModularForm.copy
code: /-- Copy of a `ModularForm` with a new `toFun` equal to the old one. Useful to fix
definitional equalities. -/
protected def ModularForm.copy (f : ModularForm Γ k) (f' : ℍ → ℂ) (h : f' = ⇑f) :
    ModularForm Γ k 
goal: ModularForm Γ k

full_name: CuspForm.copy
code: /-- Copy of a `CuspForm` with a new `toFun` equal to the old one. Useful to fix
definitional equalities. -/
protected def CuspForm.copy (f : CuspForm Γ k) (f' : ℍ → ℂ) (h : f' = ⇑f) : CuspForm Γ k 
goal: CuspForm Γ k

full_name: ModularForm.add
code: instance add : Add (ModularForm Γ k) 
goal: Add (ModularForm Γ k)

full_name: ModularForm.coe_add
code: @[simp]
theorem coe_add (f g : ModularForm Γ k) : ⇑(f + g) = f + g 
goal: ⇑(f + g) = ⇑f + ⇑g

full_name: ModularForm.add_apply
code: @[simp]
theorem add_apply (f g : ModularForm Γ k) (z : ℍ) : (f + g) z = f z + g z 
goal: (f + g) z = f z + g z

full_name: ModularForm.instZero
code: instance instZero : Zero (ModularForm Γ k) 
goal: Zero (ModularForm Γ k)

full_name: ModularForm.coe_zero
code: @[simp]
theorem coe_zero : ⇑(0 : ModularForm Γ k) = (0 : ℍ → ℂ) 
goal: ⇑0 = 0

full_name: ModularForm.zero_apply
code: @[simp]
theorem zero_apply (z : ℍ) : (0 : ModularForm Γ k) z = 0 
goal: 0 z = 0

full_name: ModularForm.instSMul
code: instance instSMul : SMul α (ModularForm Γ k) 
goal: SMul α (ModularForm Γ k)

full_name: ModularForm.coe_smul
code: @[simp]
theorem coe_smul (f : ModularForm Γ k) (n : α) : ⇑(n • f) = n • ⇑f 
goal: ⇑(n • f) = n • ⇑f

full_name: ModularForm.smul_apply
code: @[simp]
theorem smul_apply (f : ModularForm Γ k) (n : α) (z : ℍ) : (n • f) z = n • f z 
goal: (n • f) z = n • f z

full_name: ModularForm.instNeg
code: instance instNeg : Neg (ModularForm Γ k) 
goal: Neg (ModularForm Γ k)

full_name: ModularForm.coe_neg
code: @[simp]
theorem coe_neg (f : ModularForm Γ k) : ⇑(-f) = -f 
goal: ⇑(-f) = -⇑f

full_name: ModularForm.neg_apply
code: @[simp]
theorem neg_apply (f : ModularForm Γ k) (z : ℍ) : (-f) z = -f z 
goal: (-f) z = -f z

full_name: ModularForm.instSub
code: instance instSub : Sub (ModularForm Γ k) 
goal: Sub (ModularForm Γ k)

full_name: ModularForm.coe_sub
code: @[simp]
theorem coe_sub (f g : ModularForm Γ k) : ⇑(f - g) = f - g 
goal: ⇑(f - g) = ⇑f - ⇑g

full_name: ModularForm.sub_apply
code: @[simp]
theorem sub_apply (f g : ModularForm Γ k) (z : ℍ) : (f - g) z = f z - g z 
goal: (f - g) z = f z - g z

full_name: ModularForm.instAddCommGroup
code: instance : AddCommGroup (ModularForm Γ k) 
goal: AddCommGroup (ModularForm Γ k)

full_name: ModularForm.coeHom_apply
code: /-- Additive coercion from `ModularForm` to `ℍ → ℂ`. -/
@[simps]
def coeHom : ModularForm Γ k →+ ℍ → ℂ 
goal: ModularForm.coeHom f a = f a

full_name: ModularForm.coeHom
code: /-- Additive coercion from `ModularForm` to `ℍ → ℂ`. -/
@[simps]
def coeHom : ModularForm Γ k →+ ℍ → ℂ 
goal: ModularForm Γ k →+ ℍ → ℂ

full_name: ModularForm.instModuleComplex
code: instance : Module ℂ (ModularForm Γ k) 
goal: Module ℂ (ModularForm Γ k)

full_name: ModularForm.instInhabited
code: instance : Inhabited (ModularForm Γ k) 
goal: Inhabited (ModularForm Γ k)

full_name: ModularForm.mul
code: /-- The modular form of weight `k_1 + k_2` given by the product of two modular forms of weights
`k_1` and `k_2`. -/
def mul {k_1 k_2 : ℤ} {Γ : Subgroup SL(2, ℤ)} (f : ModularForm Γ k_1) (g : ModularForm Γ k_2) :
    ModularForm Γ (k_1 + k_2) 
goal: ModularForm Γ (k_1 + k_2)

full_name: ModularForm.mul_coe
code: @[simp]
theorem mul_coe {k_1 k_2 : ℤ} {Γ : Subgroup SL(2, ℤ)} (f : ModularForm Γ k_1)
    (g : ModularForm Γ k_2) : (f.mul g : ℍ → ℂ) = f * g 
goal: ⇑(f.mul g) = ⇑f * ⇑g

full_name: ModularForm.const_toFun
code: /-- The constant function with value `x : ℂ` as a modular form of weight 0 and any level. -/
@[simps! (config := .asFn) toFun toSlashInvariantForm]
def const (x : ℂ) : ModularForm Γ 0 
goal: ⇑(ModularForm.const x) = Function.const ℍ x

full_name: ModularForm.const
code: /-- The constant function with value `x : ℂ` as a modular form of weight 0 and any level. -/
@[simps! (config := .asFn) toFun toSlashInvariantForm]
def const (x : ℂ) : ModularForm Γ 0 
goal: ModularForm Γ 0

full_name: ModularForm.const_toSlashInvariantForm
code: /-- The constant function with value `x : ℂ` as a modular form of weight 0 and any level. -/
@[simps! (config := .asFn) toFun toSlashInvariantForm]
def const (x : ℂ) : ModularForm Γ 0 
goal: (ModularForm.const x).toSlashInvariantForm = SlashInvariantForm.const x

full_name: ModularForm.instOneOfNatInt
code: instance : One (ModularForm Γ 0) 
goal: One (ModularForm Γ 0)

full_name: ModularForm.one_coe_eq_one
code: @[simp]
theorem one_coe_eq_one : ⇑(1 : ModularForm Γ 0) = 1 
goal: ⇑1 = 1

full_name: ModularForm.instNatCastOfNatInt
code: instance (Γ : Subgroup SL(2, ℤ)) : NatCast (ModularForm Γ 0) 
goal: NatCast (ModularForm Γ 0)

full_name: ModularForm.coe_natCast
code: @[simp, norm_cast]
lemma coe_natCast (Γ : Subgroup SL(2, ℤ)) (n : ℕ) :
    ⇑(n : ModularForm Γ 0) = n 
goal: ⇑↑n = ↑n

full_name: ModularForm.toSlashInvariantForm_natCast
code: lemma toSlashInvariantForm_natCast (Γ : Subgroup SL(2, ℤ)) (n : ℕ) :
    (n : ModularForm Γ 0).toSlashInvariantForm = n 
goal: (↑n).toSlashInvariantForm = ↑n

full_name: ModularForm.instIntCastOfNatInt
code: instance (Γ : Subgroup SL(2, ℤ)) : IntCast (ModularForm Γ 0) 
goal: IntCast (ModularForm Γ 0)

full_name: ModularForm.coe_intCast
code: @[simp, norm_cast]
lemma coe_intCast (Γ : Subgroup SL(2, ℤ)) (z : ℤ) :
    ⇑(z : ModularForm Γ 0) = z 
goal: ⇑↑z = ↑z

full_name: ModularForm.toSlashInvariantForm_intCast
code: lemma toSlashInvariantForm_intCast (Γ : Subgroup SL(2, ℤ)) (z : ℤ) :
    (z : ModularForm Γ 0).toSlashInvariantForm = z 
goal: (↑z).toSlashInvariantForm = ↑z

full_name: CuspForm.hasAdd
code: instance hasAdd : Add (CuspForm Γ k) 
goal: Add (CuspForm Γ k)

full_name: CuspForm.coe_add
code: @[simp]
theorem coe_add (f g : CuspForm Γ k) : ⇑(f + g) = f + g 
goal: ⇑(f + g) = ⇑f + ⇑g

full_name: CuspForm.add_apply
code: @[simp]
theorem add_apply (f g : CuspForm Γ k) (z : ℍ) : (f + g) z = f z + g z 
goal: (f + g) z = f z + g z

full_name: CuspForm.instZero
code: instance instZero : Zero (CuspForm Γ k) 
goal: Zero (CuspForm Γ k)

full_name: CuspForm.coe_zero
code: @[simp]
theorem coe_zero : ⇑(0 : CuspForm Γ k) = (0 : ℍ → ℂ) 
goal: ⇑0 = 0

full_name: CuspForm.zero_apply
code: @[simp]
theorem zero_apply (z : ℍ) : (0 : CuspForm Γ k) z = 0 
goal: 0 z = 0

full_name: CuspForm.instSMul
code: instance instSMul : SMul α (CuspForm Γ k) 
goal: SMul α (CuspForm Γ k)

full_name: CuspForm.coe_smul
code: @[simp]
theorem coe_smul (f : CuspForm Γ k) (n : α) : ⇑(n • f) = n • ⇑f 
goal: ⇑(n • f) = n • ⇑f

full_name: CuspForm.smul_apply
code: @[simp]
theorem smul_apply (f : CuspForm Γ k) (n : α) {z : ℍ} : (n • f) z = n • f z 
goal: (n • f) z = n • f z

full_name: CuspForm.instNeg
code: instance instNeg : Neg (CuspForm Γ k) 
goal: Neg (CuspForm Γ k)

full_name: CuspForm.coe_neg
code: @[simp]
theorem coe_neg (f : CuspForm Γ k) : ⇑(-f) = -f 
goal: ⇑(-f) = -⇑f

full_name: CuspForm.neg_apply
code: @[simp]
theorem neg_apply (f : CuspForm Γ k) (z : ℍ) : (-f) z = -f z 
goal: (-f) z = -f z

full_name: CuspForm.instSub
code: instance instSub : Sub (CuspForm Γ k) 
goal: Sub (CuspForm Γ k)

full_name: CuspForm.coe_sub
code: @[simp]
theorem coe_sub (f g : CuspForm Γ k) : ⇑(f - g) = f - g 
goal: ⇑(f - g) = ⇑f - ⇑g

full_name: CuspForm.sub_apply
code: @[simp]
theorem sub_apply (f g : CuspForm Γ k) (z : ℍ) : (f - g) z = f z - g z 
goal: (f - g) z = f z - g z

full_name: CuspForm.instAddCommGroup
code: instance : AddCommGroup (CuspForm Γ k) 
goal: AddCommGroup (CuspForm Γ k)

full_name: CuspForm.coeHom_apply
code: /-- Additive coercion from `CuspForm` to `ℍ → ℂ`. -/
@[simps]
def coeHom : CuspForm Γ k →+ ℍ → ℂ 
goal: CuspForm.coeHom f a = f a

full_name: CuspForm.coeHom
code: /-- Additive coercion from `CuspForm` to `ℍ → ℂ`. -/
@[simps]
def coeHom : CuspForm Γ k →+ ℍ → ℂ 
goal: CuspForm Γ k →+ ℍ → ℂ

full_name: CuspForm.instModuleComplex
code: instance : Module ℂ (CuspForm Γ k) 
goal: Module ℂ (CuspForm Γ k)

full_name: CuspForm.instInhabited
code: instance : Inhabited (CuspForm Γ k) 
goal: Inhabited (CuspForm Γ k)

full_name: CuspForm.instModularFormClassOfCuspFormClass
code: instance (priority := 99) [FunLike F ℍ ℂ] [CuspFormClass F Γ k] : ModularFormClass F Γ k 
goal: ModularFormClass F Γ k

full_name: ModularForm.mcast
code: /-- Cast for modular forms, which is useful for avoiding `Heq`s. -/
def mcast {a b : ℤ} {Γ : Subgroup SL(2, ℤ)} (h : a = b) (f : ModularForm Γ a) :
    ModularForm Γ b 
goal: ModularForm Γ b

full_name: ModularForm.gradedMonoid_eq_of_cast
code: @[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 
goal: a = b

full_name: ModularForm.instGOneInt
code: instance (Γ : Subgroup SL(2, ℤ)) : GradedMonoid.GOne (ModularForm Γ) 
goal: GradedMonoid.GOne (ModularForm Γ)

full_name: ModularForm.instGMulInt
code: instance (Γ : Subgroup SL(2, ℤ)) : GradedMonoid.GMul (ModularForm Γ) 
goal: GradedMonoid.GMul (ModularForm Γ)

full_name: ModularForm.instGCommRing
code: instance instGCommRing (Γ : Subgroup SL(2, ℤ)) : DirectSum.GCommRing (ModularForm Γ) 
goal: DirectSum.GCommRing (ModularForm Γ)

full_name: ModularForm.instGAlgebra
code: instance instGAlgebra (Γ : Subgroup SL(2, ℤ)) : DirectSum.GAlgebra ℂ (ModularForm Γ) 
goal: DirectSum.GAlgebra ℂ (ModularForm Γ)