File: Mathlib/Algebra/Module/CharacterModule.lean

full_name: CharacterModule
code: /--
The character module of an abelian group `A` in the unit rational circle is `A⋆ := Hom_ℤ(A, ℚ ⧸ ℤ)`.
-/
def CharacterModule : Type uA 
goal: Type uA

full_name: CharacterModule.instFunLikeAddCircleRatOfNat
code: instance : FunLike (CharacterModule A) A (AddCircle (1 : ℚ)) 
goal: FunLike (CharacterModule A) A (AddCircle 1)

full_name: CharacterModule.instLinearMapClassIntAddCircleRatOfNat
code: instance : LinearMapClass (CharacterModule A) ℤ A (AddCircle (1 : ℚ)) 
goal: LinearMapClass (CharacterModule A) ℤ A (AddCircle 1)

full_name: CharacterModule.instAddCommGroup
code: instance : AddCommGroup (CharacterModule A) 
goal: AddCommGroup (CharacterModule A)

full_name: CharacterModule.ext
code: @[ext] theorem ext {c c' : CharacterModule A} (h : ∀ x, c x = c' x) : c = c' 
goal: c = c'

full_name: CharacterModule.instModule
code: instance : Module R (CharacterModule A) 
goal: Module R (CharacterModule A)

full_name: CharacterModule.smul_apply
code: @[simp] lemma smul_apply (c : CharacterModule A) (r : R) (a : A) : (r • c) a = c (r • a) 
goal: (r • c) a = c (r • a)

full_name: CharacterModule.dual_apply
code: /--
Given an abelian group homomorphism `f : A → B`, `f⋆(L) := L ∘ f` defines a linear map
from `B⋆` to `A⋆`.
-/
@[simps] def dual (f : A →ₗ[R] B) : CharacterModule B →ₗ[R] CharacterModule A 
goal: (CharacterModule.dual f) L = AddMonoidHom.comp L f.toAddMonoidHom

full_name: CharacterModule.dual
code: /--
Given an abelian group homomorphism `f : A → B`, `f⋆(L) := L ∘ f` defines a linear map
from `B⋆` to `A⋆`.
-/
@[simps] def dual (f : A →ₗ[R] B) : CharacterModule B →ₗ[R] CharacterModule A 
goal: CharacterModule B →ₗ[R] CharacterModule A

full_name: CharacterModule.dual_surjective_of_injective
code: lemma dual_surjective_of_injective (f : A →ₗ[R] B) (hf : Function.Injective f) :
    Function.Surjective (dual f) 
goal: Function.Surjective ⇑(CharacterModule.dual f)

full_name: CharacterModule.congr
code: /--
Two isomorphic modules have isomorphic character modules.
-/
def congr (e : A ≃ₗ[R] B) : CharacterModule A ≃ₗ[R] CharacterModule B 
goal: CharacterModule A ≃ₗ[R] CharacterModule B

full_name: CharacterModule.uncurry_apply
code: /--
Any linear map `L : A → B⋆` induces a character in `(A ⊗ B)⋆` by `a ⊗ b ↦ L a b`.
-/
@[simps] noncomputable def uncurry :
    (A →ₗ[R] CharacterModule B) →ₗ[R] CharacterModule (A ⊗[R] B) 
goal: CharacterModule.uncurry c = TensorProduct.liftAddHom c.toAddMonoidHom ⋯

full_name: CharacterModule.uncurry
code: /--
Any linear map `L : A → B⋆` induces a character in `(A ⊗ B)⋆` by `a ⊗ b ↦ L a b`.
-/
@[simps] noncomputable def uncurry :
    (A →ₗ[R] CharacterModule B) →ₗ[R] CharacterModule (A ⊗[R] B) 
goal: (A →ₗ[R] CharacterModule B) →ₗ[R] CharacterModule (TensorProduct R A B)

full_name: CharacterModule.curry
code: /--
Any character `c` in `(A ⊗ B)⋆` induces a linear map `A → B⋆` by `a ↦ b ↦ c (a ⊗ b)`.
-/
@[simps] noncomputable def curry :
    CharacterModule (A ⊗[R] B) →ₗ[R] (A →ₗ[R] CharacterModule B) 
goal: CharacterModule (TensorProduct R A B) →ₗ[R] A →ₗ[R] CharacterModule B

full_name: CharacterModule.curry_apply_apply
code: /--
Any character `c` in `(A ⊗ B)⋆` induces a linear map `A → B⋆` by `a ↦ b ↦ c (a ⊗ b)`.
-/
@[simps] noncomputable def curry :
    CharacterModule (A ⊗[R] B) →ₗ[R] (A →ₗ[R] CharacterModule B) 
goal: ∀ (x : A), (CharacterModule.curry c) x = AddMonoidHom.comp c ↑((TensorProduct.mk R A B) x)

full_name: CharacterModule.homEquiv_apply_apply
code: /--
Linear maps into a character module are exactly characters of the tensor product.
-/
@[simps!] noncomputable def homEquiv :
    (A →ₗ[R] CharacterModule B) ≃ₗ[R] CharacterModule (A ⊗[R] B) 
goal: (CharacterModule.homEquiv c) x = AddCon.liftOn x ⇑(FreeAddMonoid.lift fun mn => (c.toAddMonoidHom mn.1) mn.2) ⋯

full_name: CharacterModule.homEquiv
code: /--
Linear maps into a character module are exactly characters of the tensor product.
-/
@[simps!] noncomputable def homEquiv :
    (A →ₗ[R] CharacterModule B) ≃ₗ[R] CharacterModule (A ⊗[R] B) 
goal: (A →ₗ[R] CharacterModule B) ≃ₗ[R] CharacterModule (TensorProduct R A B)

full_name: CharacterModule.homEquiv_symm_apply_apply_apply
code: /--
Linear maps into a character module are exactly characters of the tensor product.
-/
@[simps!] noncomputable def homEquiv :
    (A →ₗ[R] CharacterModule B) ≃ₗ[R] CharacterModule (A ⊗[R] B) 
goal: ∀ (x : A) (a_1 : B), ((CharacterModule.homEquiv.symm a) x) a_1 = a (x ⊗ₜ[R] a_1)

full_name: CharacterModule.dual_rTensor_conj_homEquiv
code: theorem dual_rTensor_conj_homEquiv (f : A →ₗ[R] A') :
    homEquiv.symm.toLinearMap ∘ₗ dual (f.rTensor B) ∘ₗ homEquiv.toLinearMap = f.lcomp R _ 
goal: ↑CharacterModule.homEquiv.symm ∘ₗ CharacterModule.dual (LinearMap.rTensor B f) ∘ₗ ↑CharacterModule.homEquiv =
  LinearMap.lcomp R (CharacterModule B) f

full_name: CharacterModule.int
code: /--
`ℤ⋆`, the character module of `ℤ` in the unit rational circle.
-/
protected abbrev int : Type 
goal: Type

full_name: CharacterModule.int.divByNat
code: /-- Given `n : ℕ`, the map `m ↦ m / n`. -/
protected abbrev int.divByNat (n : ℕ) : CharacterModule.int 
goal: CharacterModule.int

full_name: CharacterModule.int.divByNat_self
code: protected lemma int.divByNat_self (n : ℕ) :
    int.divByNat n n = 0 
goal: (CharacterModule.int.divByNat n) ↑n = 0

full_name: CharacterModule.intSpanEquivQuotAddOrderOf
code: /-- The `ℤ`-submodule spanned by a single element `a` is isomorphic to the quotient of `ℤ`
by the ideal generated by the order of `a`. -/
@[simps!] noncomputable def intSpanEquivQuotAddOrderOf (a : A) :
    (ℤ ∙ a) ≃ₗ[ℤ] ℤ ⧸ Ideal.span {(addOrderOf a : ℤ)} 
goal: ↥(Submodule.span ℤ {a}) ≃ₗ[ℤ] ℤ ⧸ Ideal.span {↑(addOrderOf a)}

full_name: CharacterModule.intSpanEquivQuotAddOrderOf_symm_apply_coe
code: /-- The `ℤ`-submodule spanned by a single element `a` is isomorphic to the quotient of `ℤ`
by the ideal generated by the order of `a`. -/
@[simps!] noncomputable def intSpanEquivQuotAddOrderOf (a : A) :
    (ℤ ∙ a) ≃ₗ[ℤ] ℤ ⧸ Ideal.span {(addOrderOf a : ℤ)} 
goal: ∀ (a_1 : ℤ ⧸ Ideal.span {↑(addOrderOf a)}),
  ↑((CharacterModule.intSpanEquivQuotAddOrderOf a).symm a_1) =
    ↑((LinearMap.toSpanSingleton ℤ A a).quotKerEquivRange
        (((LinearMap.ker (LinearMap.toSpanSingleton ℤ A a)).quotEquivOfEq (Ideal.span {↑(addOrderOf a)}) ⋯).symm a_1))

full_name: CharacterModule.intSpanEquivQuotAddOrderOf_apply
code: /-- The `ℤ`-submodule spanned by a single element `a` is isomorphic to the quotient of `ℤ`
by the ideal generated by the order of `a`. -/
@[simps!] noncomputable def intSpanEquivQuotAddOrderOf (a : A) :
    (ℤ ∙ a) ≃ₗ[ℤ] ℤ ⧸ Ideal.span {(addOrderOf a : ℤ)} 
goal: ∀ (a_1 : ↥(Submodule.span ℤ {a})),
  (CharacterModule.intSpanEquivQuotAddOrderOf a) a_1 =
    ((LinearMap.ker (LinearMap.toSpanSingleton ℤ A a)).quotEquivOfEq (Ideal.span {↑(addOrderOf a)}) ⋯)
      ((LinearMap.toSpanSingleton ℤ A a).quotKerEquivRange.symm
        ((LinearEquiv.ofEq (Submodule.span ℤ {a}) (LinearMap.range (LinearMap.toSpanSingleton ℤ A a)) ⋯) a_1))

full_name: CharacterModule.intSpanEquivQuotAddOrderOf_apply_self
code: lemma intSpanEquivQuotAddOrderOf_apply_self (a : A) :
    intSpanEquivQuotAddOrderOf a ⟨a, Submodule.mem_span_singleton_self a⟩ =
    Submodule.Quotient.mk 1 
goal: (CharacterModule.intSpanEquivQuotAddOrderOf a) ⟨a, ⋯⟩ = Submodule.Quotient.mk 1

full_name: CharacterModule.ofSpanSingleton
code: /--
For an abelian group `A` and an element `a ∈ A`, there is a character `c : ℤ ∙ a → ℚ ⧸ ℤ` given by
`m • a ↦ m / n` where `n` is the smallest positive integer such that `n • a = 0` and when such `n`
does not exist, `c` is defined by `m • a ↦ m / 2`.
-/
noncomputable def ofSpanSingleton (a : A) : CharacterModule (ℤ ∙ a) 
goal: CharacterModule ↥(Submodule.span ℤ {a})

full_name: CharacterModule.eq_zero_of_ofSpanSingleton_apply_self
code: lemma eq_zero_of_ofSpanSingleton_apply_self (a : A)
    (h : ofSpanSingleton a ⟨a, Submodule.mem_span_singleton_self a⟩ = 0) : a = 0 
goal: a = 0

full_name: CharacterModule.exists_character_apply_ne_zero_of_ne_zero
code: lemma exists_character_apply_ne_zero_of_ne_zero {a : A} (ne_zero : a ≠ 0) :
    ∃ (c : CharacterModule A), c a ≠ 0 
goal: ∃ c, c a ≠ 0

full_name: CharacterModule.eq_zero_of_character_apply
code: lemma eq_zero_of_character_apply {a : A} (h : ∀ c : CharacterModule A, c a = 0) : a = 0 
goal: a = 0

full_name: CharacterModule.dual_surjective_iff_injective
code: lemma dual_surjective_iff_injective {f : A →ₗ[R] A'} :
    Function.Surjective (dual f) ↔ Function.Injective f 
goal: Function.Surjective ⇑(CharacterModule.dual f) ↔ Function.Injective ⇑f

full_name: rTensor_injective_iff_lcomp_surjective
code: theorem _root_.rTensor_injective_iff_lcomp_surjective {f : A →ₗ[R] A'} :
    Function.Injective (f.rTensor B) ↔ Function.Surjective (f.lcomp R <| CharacterModule B) 
goal: Function.Injective ⇑(LinearMap.rTensor B f) ↔ Function.Surjective ⇑(LinearMap.lcomp R (CharacterModule B) f)