File: Mathlib/NumberTheory/ModularForms/SlashInvariantForms.lean

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

full_name: _aux_Mathlib_NumberTheory_ModularForms_SlashInvariantForms___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_SlashInvariantForms___unexpand_Matrix_SpecialLinearGroup_1
code: local notation "SL(" n ", " R ")" => Matrix.SpecialLinearGroup (Fin n) R
goal: Lean.PrettyPrinter.Unexpander

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

full_name: «_aux_Mathlib_NumberTheory_ModularForms_SlashInvariantForms___macroRules_term↑ₘ__1»
code: local notation:1024 "↑ₘ" A:1024 =>
  (((A : GL(2, ℝ)⁺) : GL (Fin 2) ℝ) : Matrix (Fin 2) (Fin 2) _)
goal: Lean.Macro

full_name: «_aux_Mathlib_NumberTheory_ModularForms_SlashInvariantForms___macroRules_term↑ₘ[_]__1»
code: local notation:1024 "↑ₘ[" R "]" A:1024 =>
  ((A : GL (Fin 2) R) : Matrix (Fin 2) (Fin 2) R)
goal: Lean.Macro

full_name: SlashInvariantForm
code: /-- Functions `ℍ → ℂ` that are invariant under the `SlashAction`. -/
structure SlashInvariantForm where
  toFun : ℍ → ℂ
  slash_action_eq' : ∀ γ : Γ, toFun ∣[k] γ = toFun
goal: Type

full_name: SlashInvariantForm.slash_action_eq'
code: /-- Functions `ℍ → ℂ` that are invariant under the `SlashAction`. -/
structure SlashInvariantForm where
  toFun : ℍ → ℂ
  slash_action_eq' : ∀ γ : Γ, toFun ∣[k] γ = toFun
goal: self.toFun ∣[k] γ = self.toFun

full_name: SlashInvariantForm.toFun
code: /-- Functions `ℍ → ℂ` that are invariant under the `SlashAction`. -/
structure SlashInvariantForm where
  toFun : ℍ → ℂ
  slash_action_eq' : ∀ γ : Γ, toFun ∣[k] γ = toFun
goal: ℍ → ℂ

full_name: SlashInvariantFormClass
code: /-- `SlashInvariantFormClass F Γ k` asserts `F` is a type of bundled functions that are invariant
under the `SlashAction`. -/
class SlashInvariantFormClass [FunLike F ℍ ℂ] : Prop where
  slash_action_eq : ∀ (f : F) (γ : Γ), (f : ℍ → ℂ) ∣[k] γ = f
goal: Prop

full_name: SlashInvariantFormClass.slash_action_eq
code: /-- `SlashInvariantFormClass F Γ k` asserts `F` is a type of bundled functions that are invariant
under the `SlashAction`. -/
class SlashInvariantFormClass [FunLike F ℍ ℂ] : Prop where
  slash_action_eq : ∀ (f : F) (γ : Γ), (f : ℍ → ℂ) ∣[k] γ = f
goal: ⇑f ∣[k] γ = ⇑f

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

full_name: SlashInvariantFormClass.slashInvariantForm
code: instance (priority := 100) SlashInvariantFormClass.slashInvariantForm :
    SlashInvariantFormClass (SlashInvariantForm Γ k) Γ k 
goal: SlashInvariantFormClass (SlashInvariantForm Γ k) Γ k

full_name: SlashInvariantForm.toFun_eq_coe
code: @[simp]
theorem SlashInvariantForm.toFun_eq_coe {f : SlashInvariantForm Γ k} : f.toFun = (f : ℍ → ℂ) 
goal: f.toFun = ⇑f

full_name: SlashInvariantForm.coe_mk
code: @[simp]
theorem SlashInvariantForm.coe_mk (f : ℍ → ℂ) (hf : ∀ γ : Γ, f ∣[k] γ = f) : ⇑(mk f hf) = f 
goal: ⇑{ toFun := f, slash_action_eq' := hf } = f

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

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

full_name: SlashInvariantForm.slash_action_eqn
code: theorem slash_action_eqn [SlashInvariantFormClass F Γ k] (f : F) (γ : Γ) :
    ↑f ∣[k] γ = ⇑f 
goal: ⇑f ∣[k] γ = ⇑f

full_name: SlashInvariantForm.slash_action_eqn'
code: theorem slash_action_eqn' (k : ℤ) (Γ : Subgroup SL(2, ℤ)) [SlashInvariantFormClass F Γ k] (f : F)
    (γ : Γ) (z : ℍ) : f (γ • z) = ((↑ₘ[ℤ] γ 1 0 : ℂ) * z + (↑ₘ[ℤ] γ 1 1 : ℂ)) ^ k * f z 
goal: f (γ • z) = (↑(↑↑↑γ 1 0) * ↑z + ↑(↑↑↑γ 1 1)) ^ k * f z

full_name: SlashInvariantForm.instCoeTCOfSlashInvariantFormClass
code: instance [SlashInvariantFormClass F Γ k] : CoeTC F (SlashInvariantForm Γ k) 
goal: CoeTC F (SlashInvariantForm Γ k)

full_name: SlashInvariantForm.SlashInvariantFormClass.coe_coe
code: @[simp]
theorem SlashInvariantFormClass.coe_coe [SlashInvariantFormClass F Γ k] (f : F) :
    ((f : SlashInvariantForm Γ k) : ℍ → ℂ) = f 
goal: ⇑{ toFun := ⇑f, slash_action_eq' := ⋯ } = ⇑f

full_name: SlashInvariantForm.instAdd
code: instance instAdd : Add (SlashInvariantForm Γ k) 
goal: Add (SlashInvariantForm Γ k)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

full_name: SlashInvariantForm.coeHom
code: /-- Additive coercion from `SlashInvariantForm` to `ℍ → ℂ`. -/
def coeHom : SlashInvariantForm Γ k →+ ℍ → ℂ 
goal: SlashInvariantForm Γ k →+ ℍ → ℂ

full_name: SlashInvariantForm.coeHom_injective
code: theorem coeHom_injective : Function.Injective (@coeHom Γ k) 
goal: Function.Injective ⇑SlashInvariantForm.coeHom

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

full_name: SlashInvariantForm.const_toFun
code: /-- The `SlashInvariantForm` corresponding to `Function.const _ x`. -/
@[simps (config := .asFn)]
def const (x : ℂ) : SlashInvariantForm Γ 0 
goal: ⇑(SlashInvariantForm.const x) = Function.const ℍ x

full_name: SlashInvariantForm.const
code: /-- The `SlashInvariantForm` corresponding to `Function.const _ x`. -/
@[simps (config := .asFn)]
def const (x : ℂ) : SlashInvariantForm Γ 0 
goal: SlashInvariantForm Γ 0

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

full_name: SlashInvariantForm.one_coe_eq_one
code: @[simp]
theorem one_coe_eq_one : ((1 : SlashInvariantForm Γ 0) : ℍ → ℂ) = 1 
goal: ⇑1 = 1

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

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

full_name: SlashInvariantForm.coe_mul
code: @[simp]
theorem coe_mul {k₁ k₂ : ℤ} {Γ : Subgroup SL(2, ℤ)} (f : SlashInvariantForm Γ k₁)
    (g : SlashInvariantForm Γ k₂) : ⇑(f.mul g) = ⇑f * ⇑g 
goal: ⇑(f.mul g) = ⇑f * ⇑g

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

full_name: SlashInvariantForm.coe_natCast
code: @[simp, norm_cast]
theorem coe_natCast (n : ℕ) : ⇑(n : SlashInvariantForm Γ 0) = n 
goal: ⇑↑n = ↑n

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

full_name: SlashInvariantForm.coe_intCast
code: @[simp, norm_cast]
theorem coe_intCast (z : ℤ) : ⇑(z : SlashInvariantForm Γ 0) = z 
goal: ⇑↑z = ↑z