File: Mathlib/NumberTheory/ModularForms/SlashActions.lean

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

full_name: _aux_Mathlib_NumberTheory_ModularForms_SlashActions___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_SlashActions___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_SlashActions___macroRules_termSL(_,_)_1»
code: local notation "SL(" n ", " R ")" => Matrix.SpecialLinearGroup (Fin n) R
goal: Lean.Macro

full_name: «_aux_Mathlib_NumberTheory_ModularForms_SlashActions___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_SlashActions___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: SlashAction
code: /-- A general version of the slash action of the space of modular forms. -/
class SlashAction (β G α γ : Type*) [Group G] [AddMonoid α] [SMul γ α] where
  map : β → G → α → α
  zero_slash : ∀ (k : β) (g : G), map k g 0 = 0
  slash_one : ∀ (k : β) (a : α), map k 1 a = a
  slash_mul : ∀ (k : β) (g h : G) (a : α), map k (g * h) a = map k h (map k g a)
  smul_slash : ∀ (k : β) (g : G) (a : α) (z : γ), map k g (z • a) = z • map k g a
  add_slash : ∀ (k : β) (g : G) (a b : α), map k g (a + b) = map k g a + map k g b
goal: Type (max (max u_1 u_2) u_3)

full_name: SlashAction.smul_slash
code: /-- A general version of the slash action of the space of modular forms. -/
class SlashAction (β G α γ : Type*) [Group G] [AddMonoid α] [SMul γ α] where
  map : β → G → α → α
  zero_slash : ∀ (k : β) (g : G), map k g 0 = 0
  slash_one : ∀ (k : β) (a : α), map k 1 a = a
  slash_mul : ∀ (k : β) (g h : G) (a : α), map k (g * h) a = map k h (map k g a)
  smul_slash : ∀ (k : β) (g : G) (a : α) (z : γ), map k g (z • a) = z • map k g a
  add_slash : ∀ (k : β) (g : G) (a b : α), map k g (a + b) = map k g a + map k g b
goal: (z • a) ∣[k;γ] g = z • a ∣[k;γ] g

full_name: SlashAction.zero_slash
code: /-- A general version of the slash action of the space of modular forms. -/
class SlashAction (β G α γ : Type*) [Group G] [AddMonoid α] [SMul γ α] where
  map : β → G → α → α
  zero_slash : ∀ (k : β) (g : G), map k g 0 = 0
  slash_one : ∀ (k : β) (a : α), map k 1 a = a
  slash_mul : ∀ (k : β) (g h : G) (a : α), map k (g * h) a = map k h (map k g a)
  smul_slash : ∀ (k : β) (g : G) (a : α) (z : γ), map k g (z • a) = z • map k g a
  add_slash : ∀ (k : β) (g : G) (a b : α), map k g (a + b) = map k g a + map k g b
goal: 0 ∣[k;γ] g = 0

full_name: SlashAction.slash_mul
code: /-- A general version of the slash action of the space of modular forms. -/
class SlashAction (β G α γ : Type*) [Group G] [AddMonoid α] [SMul γ α] where
  map : β → G → α → α
  zero_slash : ∀ (k : β) (g : G), map k g 0 = 0
  slash_one : ∀ (k : β) (a : α), map k 1 a = a
  slash_mul : ∀ (k : β) (g h : G) (a : α), map k (g * h) a = map k h (map k g a)
  smul_slash : ∀ (k : β) (g : G) (a : α) (z : γ), map k g (z • a) = z • map k g a
  add_slash : ∀ (k : β) (g : G) (a b : α), map k g (a + b) = map k g a + map k g b
goal: a ∣[k;γ] (g * h) = (a ∣[k;γ] g) ∣[k;γ] h

full_name: SlashAction.slash_one
code: /-- A general version of the slash action of the space of modular forms. -/
class SlashAction (β G α γ : Type*) [Group G] [AddMonoid α] [SMul γ α] where
  map : β → G → α → α
  zero_slash : ∀ (k : β) (g : G), map k g 0 = 0
  slash_one : ∀ (k : β) (a : α), map k 1 a = a
  slash_mul : ∀ (k : β) (g h : G) (a : α), map k (g * h) a = map k h (map k g a)
  smul_slash : ∀ (k : β) (g : G) (a : α) (z : γ), map k g (z • a) = z • map k g a
  add_slash : ∀ (k : β) (g : G) (a b : α), map k g (a + b) = map k g a + map k g b
goal: a ∣[k;γ] 1 = a

full_name: SlashAction.map
code: /-- A general version of the slash action of the space of modular forms. -/
class SlashAction (β G α γ : Type*) [Group G] [AddMonoid α] [SMul γ α] where
  map : β → G → α → α
  zero_slash : ∀ (k : β) (g : G), map k g 0 = 0
  slash_one : ∀ (k : β) (a : α), map k 1 a = a
  slash_mul : ∀ (k : β) (g h : G) (a : α), map k (g * h) a = map k h (map k g a)
  smul_slash : ∀ (k : β) (g : G) (a : α) (z : γ), map k g (z • a) = z • map k g a
  add_slash : ∀ (k : β) (g : G) (a b : α), map k g (a + b) = map k g a + map k g b
goal: β → G → α → α

full_name: SlashAction.add_slash
code: /-- A general version of the slash action of the space of modular forms. -/
class SlashAction (β G α γ : Type*) [Group G] [AddMonoid α] [SMul γ α] where
  map : β → G → α → α
  zero_slash : ∀ (k : β) (g : G), map k g 0 = 0
  slash_one : ∀ (k : β) (a : α), map k 1 a = a
  slash_mul : ∀ (k : β) (g h : G) (a : α), map k (g * h) a = map k h (map k g a)
  smul_slash : ∀ (k : β) (g : G) (a : α) (z : γ), map k g (z • a) = z • map k g a
  add_slash : ∀ (k : β) (g : G) (a b : α), map k g (a + b) = map k g a + map k g b
goal: (a + b) ∣[k;γ] g = a ∣[k;γ] g + b ∣[k;γ] g

full_name: ModularForm.«_aux_Mathlib_NumberTheory_ModularForms_SlashActions___macroRules_ModularForm_term_∣[_;_]__1»
code: scoped[ModularForm] notation:100 f " ∣[" k ";" γ "] " a:100 => SlashAction.map γ k a f
goal: Lean.Macro

full_name: ModularForm._aux_Mathlib_NumberTheory_ModularForms_SlashActions___unexpand_SlashAction_map_1
code: scoped[ModularForm] notation:100 f " ∣[" k ";" γ "] " a:100 => SlashAction.map γ k a f
goal: Lean.PrettyPrinter.Unexpander

full_name: ModularForm.«_aux_Mathlib_NumberTheory_ModularForms_SlashActions___macroRules_ModularForm_term_∣[_]__1»
code: scoped[ModularForm] notation:100 f " ∣[" k "] " a:100 => SlashAction.map ℂ k a f
goal: Lean.Macro

full_name: ModularForm._aux_Mathlib_NumberTheory_ModularForms_SlashActions___unexpand_SlashAction_map_2
code: scoped[ModularForm] notation:100 f " ∣[" k "] " a:100 => SlashAction.map ℂ k a f
goal: Lean.PrettyPrinter.Unexpander

full_name: SlashAction.neg_slash
code: @[simp]
theorem SlashAction.neg_slash {β G α γ : Type*} [Group G] [AddGroup α] [SMul γ α]
    [SlashAction β G α γ] (k : β) (g : G) (a : α) : (-a) ∣[k;γ] g = -a ∣[k;γ] g 
goal: (-a) ∣[k;γ] g = -a ∣[k;γ] g

full_name: SlashAction.smul_slash_of_tower
code: @[simp]
theorem SlashAction.smul_slash_of_tower {R β G α : Type*} (γ : Type*) [Group G] [AddGroup α]
    [Monoid γ] [MulAction γ α] [SMul R γ] [SMul R α] [IsScalarTower R γ α] [SlashAction β G α γ]
    (k : β) (g : G) (a : α) (r : R) : (r • a) ∣[k;γ] g = r • a ∣[k;γ] g 
goal: (r • a) ∣[k;γ] g = r • a ∣[k;γ] g

full_name: monoidHomSlashAction
code: /-- Slash_action induced by a monoid homomorphism. -/
def monoidHomSlashAction {β G H α γ : Type*} [Group G] [AddMonoid α] [SMul γ α] [Group H]
    [SlashAction β G α γ] (h : H →* G) : SlashAction β H α γ 
goal: SlashAction β H α γ

full_name: ModularForm.slash
code: /-- The weight `k` action of `GL(2, ℝ)⁺` on functions `f : ℍ → ℂ`. -/
def slash (k : ℤ) (γ : GL(2, ℝ)⁺) (f : ℍ → ℂ) (x : ℍ) : ℂ 
goal: ℂ

full_name: ModularForm.«_aux_Mathlib_NumberTheory_ModularForms_SlashActions___macroRules_ModularForm_term_∣[_]__1_1»
code: local notation:100 f " ∣[" k "]" γ:100 => ModularForm.slash k γ f
goal: Lean.Macro

full_name: ModularForm._aux_Mathlib_NumberTheory_ModularForms_SlashActions___unexpand_ModularForm_slash_1
code: local notation:100 f " ∣[" k "]" γ:100 => ModularForm.slash k γ f
goal: Lean.PrettyPrinter.Unexpander

full_name: _private.Mathlib.NumberTheory.ModularForms.SlashActions.0.ModularForm.slash_mul
code: private theorem slash_mul (k : ℤ) (A B : GL(2, ℝ)⁺) (f : ℍ → ℂ) :
    f ∣[k](A * B) = (f ∣[k]A) ∣[k]B 
goal: ModularForm.slash k (A * B) f = ModularForm.slash k B (ModularForm.slash k A f)

full_name: _private.Mathlib.NumberTheory.ModularForms.SlashActions.0.ModularForm.add_slash
code: private theorem add_slash (k : ℤ) (A : GL(2, ℝ)⁺) (f g : ℍ → ℂ) :
    (f + g) ∣[k]A = f ∣[k]A + g ∣[k]A 
goal: ModularForm.slash k A (f + g) = ModularForm.slash k A f + ModularForm.slash k A g

full_name: _private.Mathlib.NumberTheory.ModularForms.SlashActions.0.ModularForm.slash_one
code: private theorem slash_one (k : ℤ) (f : ℍ → ℂ) : f ∣[k]1 = f 
goal: ModularForm.slash k 1 f = f

full_name: _private.Mathlib.NumberTheory.ModularForms.SlashActions.0.ModularForm.smul_slash
code: private theorem smul_slash (k : ℤ) (A : GL(2, ℝ)⁺) (f : ℍ → ℂ) (c : α) :
    (c • f) ∣[k]A = c • f ∣[k]A 
goal: ModularForm.slash k A (c • f) = c • ModularForm.slash k A f

full_name: _private.Mathlib.NumberTheory.ModularForms.SlashActions.0.ModularForm.zero_slash
code: private theorem zero_slash (k : ℤ) (A : GL(2, ℝ)⁺) : (0 : ℍ → ℂ) ∣[k]A = 0 
goal: ModularForm.slash k A 0 = 0

full_name: ModularForm.instSlashActionIntSubtypeGeneralLinearGroupFinOfNatNatRealMemSubgroupGLPosForallUpperHalfPlaneComplex
code: instance : SlashAction ℤ GL(2, ℝ)⁺ (ℍ → ℂ) ℂ 
goal: SlashAction ℤ (↥GL(2, ℝ)⁺) (ℍ → ℂ) ℂ

full_name: ModularForm.slash_def
code: theorem slash_def (A : GL(2, ℝ)⁺) : f ∣[k] A = slash k A f 
goal: f ∣[k] A = ModularForm.slash k A f

full_name: ModularForm.subgroupAction
code: instance subgroupAction (Γ : Subgroup SL(2, ℤ)) : SlashAction ℤ Γ (ℍ → ℂ) ℂ 
goal: SlashAction ℤ (↥Γ) (ℍ → ℂ) ℂ

full_name: ModularForm.subgroup_slash
code: @[simp]
theorem subgroup_slash (Γ : Subgroup SL(2, ℤ)) (γ : Γ) : f ∣[k] γ = f ∣[k] (γ : GL(2, ℝ)⁺) 
goal: f ∣[k] γ = f ∣[k] ↑↑γ

full_name: ModularForm.SLAction
code: instance SLAction : SlashAction ℤ SL(2, ℤ) (ℍ → ℂ) ℂ 
goal: SlashAction ℤ SL(2, ℤ) (ℍ → ℂ) ℂ

full_name: ModularForm.SL_slash
code: @[simp]
theorem SL_slash (γ : SL(2, ℤ)) : f ∣[k] γ = f ∣[k] (γ : GL(2, ℝ)⁺) 
goal: f ∣[k] γ = f ∣[k] ↑γ

full_name: ModularForm.is_invariant_const
code: theorem is_invariant_const (A : SL(2, ℤ)) (x : ℂ) :
    Function.const ℍ x ∣[(0 : ℤ)] A = Function.const ℍ x 
goal: Function.const ℍ x ∣[0] A = Function.const ℍ x

full_name: ModularForm.is_invariant_one
code: /-- The constant function 1 is invariant under any element of `SL(2, ℤ)`. -/
-- @[simp] -- Porting note: simpNF says LHS simplifies to something more complex
theorem is_invariant_one (A : SL(2, ℤ)) : (1 : ℍ → ℂ) ∣[(0 : ℤ)] A = (1 : ℍ → ℂ) 
goal: 1 ∣[0] A = 1

full_name: ModularForm.slash_action_eq'_iff
code: /-- A function `f : ℍ → ℂ` is slash-invariant, of weight `k ∈ ℤ` and level `Γ`,
  if for every matrix `γ ∈ Γ` we have `f(γ • z)= (c*z+d)^k f(z)` where `γ= ![![a, b], ![c, d]]`,
  and it acts on `ℍ` via Möbius transformations. -/
theorem slash_action_eq'_iff (k : ℤ) (Γ : Subgroup SL(2, ℤ)) (f : ℍ → ℂ) (γ : Γ) (z : ℍ) :
    (f ∣[k] γ) z = f z ↔ f (γ • z) = ((↑ₘ[ℤ] γ 1 0 : ℂ) * z + (↑ₘ[ℤ] γ 1 1 : ℂ)) ^ k * f z 
goal: (f ∣[k] γ) z = f z ↔ f (γ • z) = (↑(↑↑↑γ 1 0) * ↑z + ↑(↑↑↑γ 1 1)) ^ k * f z

full_name: ModularForm.mul_slash
code: theorem mul_slash (k1 k2 : ℤ) (A : GL(2, ℝ)⁺) (f g : ℍ → ℂ) :
    (f * g) ∣[k1 + k2] A = ((↑ₘA).det : ℝ) • f ∣[k1] A * g ∣[k2] A 
goal: (f * g) ∣[k1 + k2] A = (↑↑A).det • f ∣[k1] A * g ∣[k2] A

full_name: ModularForm.mul_slash_SL2
code: theorem mul_slash_SL2 (k1 k2 : ℤ) (A : SL(2, ℤ)) (f g : ℍ → ℂ) :
    (f * g) ∣[k1 + k2] A = f ∣[k1] A * g ∣[k2] A 
goal: (f * g) ∣[k1 + k2] A = f ∣[k1] A * g ∣[k2] A

full_name: ModularForm.mul_slash_subgroup
code: theorem mul_slash_subgroup (k1 k2 : ℤ) (Γ : Subgroup SL(2, ℤ)) (A : Γ) (f g : ℍ → ℂ) :
    (f * g) ∣[k1 + k2] A = f ∣[k1] A * g ∣[k2] A 
goal: (f * g) ∣[k1 + k2] A = f ∣[k1] A * g ∣[k2] A