LeanBridge Blueprint

6.1. Dirichlet characters🔗

This section lists the LMFDB definitions in the category character. Each definition links back to its LMFDB knowl. It also lists the knowl about the LMFDB's data on this subject that has mathematical content, from the category portrait.

Definition6.1.1
uses 0
Used by 66
Reverse dependency previews
Preview
Definition 2.12
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Dirichlet character. (LMFDB)

A Dirichlet character is a function \chi: \Z\to \C together with a positive integer q called the modulus such that \chi is completely multiplicative, i.e. \chi(mn)=\chi(m)\chi(n) for all integers m and n, and \chi is periodic modulo q, i.e. \chi(n+q)=\chi(n) for all n. If (n,q)>1 then \chi(n)=0, whereas if (n,q)=1, then \chi(n) is a root of unity. The character \chi is primitive if its conductor is equal to its modulus.

Tau Ceti Review: DirichletCharacter, MulChar, DirichletCharacter.apply_eq_zero_iff.

Lean code for Definition6.1.1●4 declarations
  • abbrevdefined in Mathlib/NumberTheory/DirichletCharacter/Basic.lean
    complete
    abbrev DirichletCharacter.{u_1} (R : Type u_1) [CommMonoidWithZero R] (n : ℕ) :
      Type u_1
    abbrev DirichletCharacter.{u_1} (R : Type u_1)
      [CommMonoidWithZero R] (n : ℕ) :
      Type u_1
    The type of Dirichlet characters of level `n`. 
  • structure(extends 3, 4 fields)defined in Mathlib/NumberTheory/MulChar/Basic.lean
    complete
    structure MulChar.{u_1, u_2} (R : Type u_1) [CommMonoid R] (R' : Type u_2)
      [CommMonoidWithZero R'] : Type (max u_1 u_2)
    structure MulChar.{u_1, u_2} (R : Type u_1)
      [CommMonoid R] (R' : Type u_2)
      [CommMonoidWithZero R'] :
      Type (max u_1 u_2)
    Define a structure for multiplicative characters.
    A multiplicative character from a commutative monoid `R` to a commutative monoid with zero `R'`
    is a homomorphism of (multiplicative) monoids that sends non-units to zero. 
    • R →* R'
    toFun : R → R'
    Inherited from
    1. MonoidHom
    2. OneHom
    map_one' : (↑self.toMonoidHom).toFun 1 = 1
    Inherited from
    1. MonoidHom
    2. OneHom
    map_mul' : ∀ (x y : R), (↑self.toMonoidHom).toFun (x * y) = (↑self.toMonoidHom).toFun x * (↑self.toMonoidHom).toFun y
    Inherited from
    1. MonoidHom
    map_nonunit' : ∀ (a : R), ¬IsUnit a → (↑self.toMonoidHom).toFun a = 0
  • theoremdefined in Mathlib/NumberTheory/DirichletCharacter/Basic.lean
    complete
    theorem DirichletCharacter.apply_eq_zero_iff.{u_1} {R : Type u_1}
      [CommMonoidWithZero R] {n : ℕ} (χ : DirichletCharacter R n)
      [Nontrivial R] (a : ℤ) : χ ↑a = 0 ↔ ¬IsCoprime a ↑n
    theorem DirichletCharacter.apply_eq_zero_iff.{u_1}
      {R : Type u_1} [CommMonoidWithZero R]
      {n : ℕ} (χ : DirichletCharacter R n)
      [Nontrivial R] (a : ℤ) :
      χ ↑a = 0 ↔ ¬IsCoprime a ↑n
  • theoremdefined in Mathlib/NumberTheory/MulChar/Lemmas.lean
    complete
    theorem MulChar.apply_mem_rootsOfUnity.{u_1, u_2} {R : Type u_1} {R' : Type u_2}
      [CommRing R] [CommRing R'] [Fintype Rˣ] (a : Rˣ) {χ : MulChar R R'} :
      (MulChar.equivToUnitHom χ) a ∈ rootsOfUnity (Fintype.card Rˣ) R'
    theorem MulChar.apply_mem_rootsOfUnity.{u_1, u_2}
      {R : Type u_1} {R' : Type u_2}
      [CommRing R] [CommRing R'] [Fintype Rˣ]
      (a : Rˣ) {χ : MulChar R R'} :
      (MulChar.equivToUnitHom χ) a ∈
        rootsOfUnity (Fintype.card Rˣ) R'
    The values of a multiplicative character on `R` are `n`th roots of unity, where `n = #Rˣ`. 
Definition6.1.2
uses 1
Used by 8
Reverse dependency previews
Preview
Definition 2.17
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Conductor of a Dirichlet character. (LMFDB)

The conductor of a Dirichlet character \chi modulo q is the least positive integer q_1 dividing q for which \chi(n+kq_1)=\chi(n) for all n and n+kq_1 coprime to q.

Tau Ceti Review: DirichletCharacter.conductor.

Depends on: Definition 6.1.1

Lean code for Definition6.1.2●1 definition
  • defdefined in Mathlib/NumberTheory/DirichletCharacter/Basic.lean
    complete
    def DirichletCharacter.conductor.{u_1} {R : Type u_1} [CommMonoidWithZero R]
      {n : ℕ} (χ : DirichletCharacter R n) : ℕ
    def DirichletCharacter.conductor.{u_1}
      {R : Type u_1} [CommMonoidWithZero R]
      {n : ℕ} (χ : DirichletCharacter R n) : ℕ
    The minimum natural number level `n` through which `χ` factors. 
Definition6.1.3
Statement uses 7
Statement dependency previews
Preview
Definition 6.1.1
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 2
Reverse dependency previews
Preview
Definition 2.44
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
XL∃∀N

Conrey label of Dirichlet characters. (LMFDB)

We use the notation \chi_{q}(n,\cdot) to identify Dirichlet characters \Z\to \C, where q is the modulus, and n is the index, a positive integer coprime to q that identifies a Dirichlet character of modulus q as described below. The LMFDB label \texttt{q.n}, with 1\le n < \max(q,2) uniquely identifies \chi_{q}(n,\cdot).

Introduced by Brian Conrey, this labeling system is based on an explicit isomorphism between the multiplicative group (\Z/q\Z)^\times and the group of Dirichlet characters of modulus q that makes it easy to recover the order, the conductor, and the parity of a Dirichlet character from its label, or to induce characters.

As an example, \chi_q(1, \cdot) is always trivial, \chi_q(m,\cdot) is real if m^2=1\bmod q, and for all m,n coprime to q we have \chi_q(m,n)=\chi_q(n,m).

For prime powers q=p^e we define \chi_q(n,\cdot) as follows:

  • For each odd prime p we choose the least positive integer g_p which

    is a primitive root for all p^e, and then for n \equiv g_p^a mod p^{e} and m \equiv g_p^{b} mod p^{e} coprime to p we define

\chi_{p^e}(n, m) = \exp\left(2\pi i \frac{a b}{\phi(p^{e})} \right).

  • \chi_2(1, \cdot) is trivial, \chi_4(3, \cdot) is the

    unique nontrivial character of modulus 4, and for larger powers of 2 we choose -1 and 5 as generators of the multiplicative group. For e > 2, if

n \equiv \epsilon_a 5^a \pmod{2^e}

and

m \equiv \epsilon_b 5^b \pmod{2^e}

with \epsilon_a, \epsilon_b \in \{\pm 1\}, then

\chi_{2^e}(n, m) = \exp\left(2 \pi i \left(\frac{(1 - \epsilon_a)(1 - \epsilon_b)}{8} + \frac{ab}{2^{e-2}}\right)\right).

For general q, the function \chi_q(n, m) is defined multiplicatively: \chi_{q_1 q_2}(n, m) := \chi_{q_1}(n, m)\chi_{q_2}(n, m) for all coprime positive integers q_1 and q_2. The Chinese remainder theorem implies that this definition is well founded and that every Dirichlet character can be defined in this way. In particular, every Dirichlet character \chi of modulus q can be written uniquely as a product of Dirichlet characters of prime power modulus.

Depends on: Definition 6.1.1 Definition 6.1.4 Definition 6.1.5 Definition 6.1.8 Definition 6.1.9 Definition 6.1.16 Definition 6.1.20

Definition6.1.4
Statement uses 2
Statement dependency previews
Preview
Definition 6.1.1
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 1XL∃∀N

Conductor of a Dirichlet character from its Conrey label. (LMFDB)

Let \chi_q(n,\cdot)=\prod_{p|q}\chi_{p^e}(n,\cdot) be the unique factorization of the Dirichlet character \chi_q(n,\cdot) into characters of prime power modulus p^e under the Conrey labeling system. The conductor of \chi_q(n,\cdot) is the product of the conductors of the \chi_{p^e}(n,\cdot).

For odd primes p and 1\leq f\leq e, the isomorphism between (\Z/p^f\Z)^\times and the image of x\mapsto x^{p^{e-f}} in (\Z/p^e\Z)^\times is compatible with the Conrey labeling system.

Thus for odd primes p, the conductor of \chi_{p^e}(n,\cdot) is

  • 1 if n\equiv 1\bmod p^e;

  • p^f if n^{p-1} has order p^{f-1} modulo p^e.

For p=2 the conductor of \chi_{p^e}(n,\cdot) is

  • 1 if n\equiv 1\bmod 2^e;

  • 4 if e=2 and n\equiv 3\bmod 4;

  • 2^{f+2} if e\geq3 and \varepsilon n has order 2^f modulo 2^e, where \varepsilon\in\{-1,1\} satisfies n\equiv \epsilon\bmod 4.

Depends on: Definition 6.1.1 Definition 6.1.2

Definition6.1.5
Statement uses 2
Statement dependency previews
Preview
Definition 6.1.1
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 1XL∃∀N

Conrey index of a Dirichlet character. (LMFDB)

The Conrey index (or index) of a Dirichlet character \chi of modulus q is the unique positive integer n < \max(q,2) for which \chi = \chi_q(n,\cdot) in the Conrey labeling system.

Depends on: Definition 6.1.1 Definition 6.1.27

Definition6.1.6
Statement uses 2
Statement dependency previews
Preview
Definition 6.1.1
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0✓L∃∀N

Labels for Galois orbits of Dirichlet Characters. (LMFDB)

A Galois orbit of Dirichlet characters is labelled as \texttt{q.A}, where \texttt{q} is the modulus of the characters in the orbit, and \texttt{A} is a lower-case letter which corresponds to the lexicographic ordering of the Galois-invariant vector \left( \textup{Order}(\chi), \mathrm{Tr}(\chi(2)), \cdots, \mathrm{Tr}(\chi(\texttt{q} - 1) \right), for \chi any Dirichlet character in the orbit. See Section 3.3 of for more details.

Depends on: Definition 6.1.1 Definition 6.1.12

Lean code for Definition6.1.6●10 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/GaloisOrbitLabel.lean
    complete
    def DirichletCharacter.galoisOrbitLabel {q : ℕ}
      (χ : DirichletCharacter ℂ q) : String
    def DirichletCharacter.galoisOrbitLabel
      {q : ℕ} (χ : DirichletCharacter ℂ q) :
      String
    The **label** of the Galois orbit of a Dirichlet character `χ` of modulus `q` (LMFDB
    `character.dirichlet.galois_orbit_label`): `q.a`, where `a` is the letter code of the orbit index
    of `χ` minus one, so that the orbit indices `1, 2, 27` are written `a, b, ba`. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/OrbitLabelVector.lean
    complete
    def DirichletCharacter.orbitLabelVector {q : ℕ}
      (χ : DirichletCharacter ℂ q) : List ℚ
    def DirichletCharacter.orbitLabelVector
      {q : ℕ} (χ : DirichletCharacter ℂ q) :
      List ℚ
    The **Galois-invariant vector** `(ord χ, Tr χ(2), …, Tr χ(q - 1))` of a Dirichlet character `χ`
    of modulus `q` (LMFDB `character.dirichlet.conrey.orbit_label`), whose lexicographic order labels
    the Galois orbits: the order of `χ` followed by the traces of `χ i` from the field of values of `χ`
    to `ℚ` for `i = 2, …, q - 1`. It is the trace vector `DirichletCharacter.galoisOrbitTraceVector`
    without its entry `Tr χ(1)` (`DirichletCharacter.eraseIdx_galoisOrbitTraceVector`). 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/GaloisOrbitLabel.lean
    complete
    def DirichletCharacter.letterCode (n : ℕ) : String
    def DirichletCharacter.letterCode (n : ℕ) :
      String
    The **letter code** of a natural number `n`: its base-`26` expansion with the digits written
    `a, b, …, z`, so that `0, 1, …, 25, 26` are written `a, b, …, z, ba`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/OrbitLabelVector.lean
    complete
    theorem DirichletCharacter.galoisOrbitLabel_eq {q : ℕ}
      (χ : DirichletCharacter ℂ q) :
      χ.galoisOrbitLabel =
        toString q ++ "." ++
          DirichletCharacter.letterCode
            {t |
                t ∈ Set.range DirichletCharacter.orbitLabelVector ∧
                  t < χ.orbitLabelVector}.ncard
    theorem DirichletCharacter.galoisOrbitLabel_eq
      {q : ℕ} (χ : DirichletCharacter ℂ q) :
      χ.galoisOrbitLabel =
        toString q ++ "." ++
          DirichletCharacter.letterCode
            {t |
                t ∈
                    Set.range
                      DirichletCharacter.orbitLabelVector ∧
                  t <
                    χ.orbitLabelVector}.ncard
    **The label of a Galois orbit is the knowl's** (LMFDB `character.dirichlet.conrey.orbit_label`):
    the label of the orbit of `χ` is `q.A`, where `A` is the letter code of the number of vectors
    `(ord ψ, Tr ψ(2), …, Tr ψ(q - 1))` of the characters `ψ` of modulus `q` that are lexicographically
    smaller than that of `χ`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/OrbitLabelVector.lean
    complete
    theorem DirichletCharacter.galoisOrbitIndex_eq_ncard_orbitLabelVector {q : ℕ}
      (χ : DirichletCharacter ℂ q) :
      χ.galoisOrbitIndex =
        {t |
              t ∈ Set.range DirichletCharacter.orbitLabelVector ∧
                t < χ.orbitLabelVector}.ncard +
          1
    theorem DirichletCharacter.galoisOrbitIndex_eq_ncard_orbitLabelVector
      {q : ℕ} (χ : DirichletCharacter ℂ q) :
      χ.galoisOrbitIndex =
        {t |
              t ∈
                  Set.range
                    DirichletCharacter.orbitLabelVector ∧
                t <
                  χ.orbitLabelVector}.ncard +
          1
    **The orbit index is the position of the knowl's vector** (LMFDB
    `character.dirichlet.conrey.orbit_label`): it is one more than the number of vectors
    `(ord ψ, Tr ψ(2), …, Tr ψ(q - 1))` of the characters `ψ` of modulus `q` that are lexicographically
    smaller than that of `χ`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/OrbitLabelVector.lean
    complete
    theorem DirichletCharacter.orbitLabelVector_lt_orbitLabelVector_iff {q : ℕ}
      {χ ψ : DirichletCharacter ℂ q} :
      ψ.orbitLabelVector < χ.orbitLabelVector ↔
        ψ.galoisOrbitTraceVector < χ.galoisOrbitTraceVector
    theorem DirichletCharacter.orbitLabelVector_lt_orbitLabelVector_iff
      {q : ℕ} {χ ψ : DirichletCharacter ℂ q} :
      ψ.orbitLabelVector <
          χ.orbitLabelVector ↔
        ψ.galoisOrbitTraceVector <
          χ.galoisOrbitTraceVector
    **The knowl's vectors are ordered as the trace vectors**: the extra entry `Tr χ(1) = φ(ord χ)`
    of the trace vector is a function of its first entry `ord χ`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/OrbitLabelVector.lean
    complete
    theorem DirichletCharacter.orbitLabelVector_eq_iff {q : ℕ}
      {χ ψ : DirichletCharacter ℂ q} [NeZero q] :
      ψ.orbitLabelVector = χ.orbitLabelVector ↔ ψ ∈ MulChar.galoisOrbit χ
    theorem DirichletCharacter.orbitLabelVector_eq_iff
      {q : ℕ} {χ ψ : DirichletCharacter ℂ q}
      [NeZero q] :
      ψ.orbitLabelVector =
          χ.orbitLabelVector ↔
        ψ ∈ MulChar.galoisOrbit χ
    **The knowl's vector depends only on the Galois orbit and determines it**: two Dirichlet
    characters of nonzero modulus have the same vector `(ord χ, Tr χ(2), …, Tr χ(q - 1))` exactly when
    they lie in one Galois orbit. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/OrbitLabelVector.lean
    complete
    theorem DirichletCharacter.valueTrace_one {q : ℕ} (χ : DirichletCharacter ℂ q) :
      χ.valueTrace 1 = ↑(orderOf χ).totient
    theorem DirichletCharacter.valueTrace_one {q : ℕ}
      (χ : DirichletCharacter ℂ q) :
      χ.valueTrace 1 = ↑(orderOf χ).totient
    **The trace of `χ 1` is the degree `φ(ord χ)` of the field of values.** 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/GaloisOrbitLabel.lean
    complete
    def DirichletCharacter.galoisOrbitIndex {q : ℕ}
      (χ : DirichletCharacter ℂ q) : ℕ
    def DirichletCharacter.galoisOrbitIndex
      {q : ℕ} (χ : DirichletCharacter ℂ q) : ℕ
    The **orbit index** of a Dirichlet character `χ` of modulus `q` (LMFDB
    `character.dirichlet.galois_orbit_index`): the position, counted from `1`, of the trace vector of
    `χ` in the lexicographic order on the trace vectors of the Dirichlet characters of modulus `q`. It
    depends only on the Galois orbit of `χ` and determines it (`galoisOrbitIndex_eq_iff`). 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/GaloisOrbitLabel.lean
    complete
    def DirichletCharacter.galoisOrbitTraceVector {q : ℕ}
      (χ : DirichletCharacter ℂ q) : List ℚ
    def DirichletCharacter.galoisOrbitTraceVector
      {q : ℕ} (χ : DirichletCharacter ℂ q) :
      List ℚ
    The **trace vector** `t([χ]) = (n, t₁, …, t_{q-1})` of a Dirichlet character `χ` of modulus
    `q`: its order `n` followed by the traces `tᵢ = tr_{ℚ(χ)/ℚ}(χ i)` for `i = 1, …, q - 1`. The `tᵢ`
    are rational integers; we keep them in `ℚ`, whose order agrees with that of `ℤ`. 
Definition6.1.7
Statement uses 3
Statement dependency previews
Preview
Definition 6.1.1
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0XL∃∀N

Order of a Dirichlet character from its label. (LMFDB)

Since \chi_q(m^r,n)=\chi_q(m,n)^r, a Dirichlet character of Conrey index m has order r, where r is the multiplicative order of m in (\Z/q\Z)^\times.

Depends on: Definition 6.1.1 Definition 6.1.3 Definition 6.1.28

Definition6.1.8
Statement uses 2
Statement dependency previews
Preview
Definition 6.1.1
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 1XL∃∀N

Parity of a Dirichlet character from its Conrey label. (LMFDB)

Let \chi_q(n,\cdot)=\prod_{p|q}\chi_{p^e}(n,\cdot) be the unique factorization of the Dirichlet character \chi_q(n,\cdot) into characters of prime power modulus p^e under the Conrey labeling system. The parity of \chi_q(n,\cdot) is the sum of the parities of the Dirichlet characters \chi_{p^e}(n,\cdot), which can be computed as follows:

  • for p>2, the character \chi_{p^e}(n,\cdot) is even if and only if n is a square modulo p;

  • for p=2 and e>1 the character \chi_{p^e}(n,\cdot) is even if and only if n is a square modulo 4.

  • for p=2 and e=1 the character \chi_{p^e}(n,\cdot)=\chi_2(1,\cdot) is even.

Depends on: Definition 6.1.1 Definition 6.1.29

Definition6.1.9
uses 0used by 1XL∃∀N

Conrey primitive generator modulo p. (LMFDB)

For an odd prime p and an exponent e\geq1, the group (\Z/p^e\Z)^\times is cyclic. It happens that any integer a which generates (\Z/p^2\Z)^\times will also be a generator of (\Z/p^e\Z)^\times for all e\geq 1. We call the least such a the Conrey (primitive) generator modulo p.

Interestingly, the Conrey generator is also the smallest generator of (\Z/p\Z)^\times for all primes p<10^{12} except two cases:

  • for p=40487, the Conrey generator is 10 instead of 5.

  • for p=6692367337, the Conrey generator is 7 instead of 5.

Definition6.1.10
Statement uses 3
Statement dependency previews
Preview
Definition 5.1.14
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0✓L∃∀N

Degree of a Dirichlet character. (LMFDB)

The degree of a Dirichlet character \chi is the degree of its field of values \Q(\chi(\Z)).

If \chi has order n then its degree is \phi(n):=\#(\Z/n\Z)^\times.

Tau Ceti Review: Nat.totient, ZMod.card_units_eq_totient.

Depends on: Definition 6.1.28 Definition 6.1.34 Definition 5.1.14

Lean code for Definition6.1.10●4 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/MulChar/FieldOfValues.lean
    complete
    def MulChar.degree.{u_1, u_2} {M : Type u_1} {K : Type u_2} [CommMonoid M]
      [Field K] [CharZero K] (χ : MulChar M K) : ℕ
    def MulChar.degree.{u_1, u_2} {M : Type u_1}
      {K : Type u_2} [CommMonoid M] [Field K]
      [CharZero K] (χ : MulChar M K) : ℕ
    The **degree** (LMFDB `character.dirichlet.degree`) of a character `χ` with values in a field of
    characteristic zero, such as a Dirichlet character: the degree over `ℚ` of its field of values
    `ℚ(χ)`, the subfield generated by its values. A character of order `n` on a monoid with finitely
    many units has degree `φ(n)` (`MulChar.degree_eq_totient`). 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/MulChar/FieldOfValues.lean
    complete
    theorem MulChar.degree_eq_totient.{u_1, u_2} {M : Type u_1} {K : Type u_2}
      [CommMonoid M] [Field K] [CharZero K] (χ : MulChar M K) [Finite Mˣ] :
      χ.degree = (orderOf χ).totient
    theorem MulChar.degree_eq_totient.{u_1, u_2}
      {M : Type u_1} {K : Type u_2}
      [CommMonoid M] [Field K] [CharZero K]
      (χ : MulChar M K) [Finite Mˣ] :
      χ.degree = (orderOf χ).totient
    **A character of order `n` has degree `φ(n)`.** 
  • defdefined in Mathlib/Data/Nat/Totient.lean
    complete
    def Nat.totient (n : ℕ) : ℕ
    def Nat.totient (n : ℕ) : ℕ
    Euler's totient function. This counts the number of naturals strictly less than `n` which are
    coprime with `n`. 
  • theoremdefined in Mathlib/Data/Nat/Totient.lean
    complete
    theorem ZMod.card_units_eq_totient (n : ℕ) [NeZero n] [Fintype (ZMod n)ˣ] :
      Fintype.card (ZMod n)ˣ = n.totient
    theorem ZMod.card_units_eq_totient (n : ℕ)
      [NeZero n] [Fintype (ZMod n)ˣ] :
      Fintype.card (ZMod n)ˣ = n.totient
    Note this takes an explicit `Fintype ((ZMod n)ˣ)` argument to avoid trouble with instance
    diamonds. 
Definition6.1.11
Statement uses 2
Statement dependency previews
Preview
Definition 6.1.1
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 1✓L∃∀N

Fixed field of a Dirichlet character. (LMFDB)

Let \chi:\mathbb{Z}\to \mathbb{C} be a Dirichlet character with modulus q. The fixed field of \chi is \mathbb{Q}(\zeta_q)^{\ker(\chi)}. By definition, this is the subfield of elements fixed under Galois morphisms \zeta_q\mapsto \zeta_q^k for all k such that \chi(k)=1.

In fact \chi determines a homomorphism \chi:(\mathbb{Z}/q\mathbb{Z})^\times\to \mathbb{C}^\times. Identifying (\mathbb{Z}/q\mathbb{Z})^\times with \textrm{Gal}(\mathbb{Q}(\zeta_q)/\mathbb{Q}) by a\mapsto \sigma_a with \sigma_a(\zeta_q)=\zeta_q^a, we then identify \ker(\chi) with a subgroup of \textrm{Gal}(\mathbb{Q}(\zeta_q)/\mathbb{Q}). By the Galois correspondence, the fixed field \mathbb{Q}(\zeta_q)^{\ker(\chi)} of this subgroup is a subfield of \mathbb{Q}(\zeta_q) whose Galois group is isomorphic to \textrm{Im}(\chi), which is cyclic of order n where n is the order of \chi.

Tau Ceti Review: IsCyclotomicExtension.Rat.galEquivZMod.

Depends on: Definition 6.1.1 Definition 6.1.28

Lean code for Definition6.1.11●6 declarations
  • abbrevdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/FixedField.lean
    complete
    abbrev DirichletCharacter.fixedField.{u_1} {q : ℕ} [NeZero q] (K : Type u_1)
      [Field K] [NumberField K] [IsCyclotomicExtension {q} ℚ K]
      (χ : DirichletCharacter ℂ q) : IntermediateField ℚ K
    abbrev DirichletCharacter.fixedField.{u_1}
      {q : ℕ} [NeZero q] (K : Type u_1)
      [Field K] [NumberField K]
      [IsCyclotomicExtension {q} ℚ K]
      (χ : DirichletCharacter ℂ q) :
      IntermediateField ℚ K
    The **fixed field** (LMFDB `character.dirichlet.field_cut_out`) of a complex Dirichlet character
    `χ` of modulus `q`: the subfield `ℚ(ζ_q)^{ker χ}` of a `q`-th cyclotomic field `K = ℚ(ζ_q)`, for
    instance the subfield `adjoin ℚ {b : ℂ | b ^ q = 1}` of `ℂ`, fixed by the subgroup of `Gal(K/ℚ)`
    that corresponds to the kernel of `χ` on `(ℤ/qℤ)ˣ` under Mathlib's
    `IsCyclotomicExtension.Rat.galEquivZMod`, the isomorphism `Gal(K/ℚ) ≃* (ℤ/qℤ)ˣ` sending
    `σ_a : ζ_q ↦ ζ_q ^ a` to `a`. Its elements are those fixed by the automorphisms `ζ_q ↦ ζ_q ^ k`
    with `χ(k) = 1` (`DirichletCharacter.mem_fixedField_iff`). 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/FixedField.lean
    complete
    theorem DirichletCharacter.mem_fixedField_iff.{u_1} {q : ℕ} [NeZero q]
      {K : Type u_1} [Field K] [NumberField K]
      [IsCyclotomicExtension {q} ℚ K] (χ : DirichletCharacter ℂ q) {x : K} :
      x ∈ DirichletCharacter.fixedField K χ ↔
        ∀ (k : ℕ) (σ : Gal(K/ℚ)),
          σ (IsCyclotomicExtension.zeta q ℚ K) =
              IsCyclotomicExtension.zeta q ℚ K ^ k →
            χ ↑k = 1 → σ x = x
    theorem DirichletCharacter.mem_fixedField_iff.{u_1}
      {q : ℕ} [NeZero q] {K : Type u_1}
      [Field K] [NumberField K]
      [IsCyclotomicExtension {q} ℚ K]
      (χ : DirichletCharacter ℂ q) {x : K} :
      x ∈ DirichletCharacter.fixedField K χ ↔
        ∀ (k : ℕ) (σ : Gal(K/ℚ)),
          σ
                (IsCyclotomicExtension.zeta q
                  ℚ K) =
              IsCyclotomicExtension.zeta q ℚ
                  K ^
                k →
            χ ↑k = 1 → σ x = x
    **The fixed field of `χ` consists of the elements fixed by the automorphisms `ζ_q ↦ ζ_q ^ k`
    with `χ(k) = 1`**, `ζ_q` being the primitive `q`-th root of unity `IsCyclotomicExtension.zeta`. 
  • abbrevdefined in Mathlib/NumberTheory/NumberField/Cyclotomic/Galois.lean
    complete
    abbrev IsCyclotomicExtension.Rat.galEquivZMod.{u_1} (n : ℕ) [NeZero n]
      (K : Type u_1) [Field K] [NumberField K]
      [hK : IsCyclotomicExtension {n} ℚ K] : Gal(K/ℚ) ≃* (ZMod n)ˣ
    abbrev IsCyclotomicExtension.Rat.galEquivZMod.{u_1}
      (n : ℕ) [NeZero n] (K : Type u_1)
      [Field K] [NumberField K]
      [hK : IsCyclotomicExtension {n} ℚ K] :
      Gal(K/ℚ) ≃* (ZMod n)ˣ
    The isomorphism between `Gal(ℚ(ζₙ)/ℚ)` and `(ℤ/nℤ)ˣ` that sends `σ` to the class `a` such that
    `σ (ζₙ) = ζₙ ^ a`.
    
  • defdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/FixedField.lean
    complete
    def DirichletCharacter.galEquivRange.{u_1} {q : ℕ} [NeZero q] (K : Type u_1)
      [Field K] [NumberField K] [IsCyclotomicExtension {q} ℚ K]
      (χ : DirichletCharacter ℂ q) :
      Gal(↥(DirichletCharacter.fixedField K χ)/ℚ) ≃*
        ↥(MulChar.toUnitHom χ).range
    def DirichletCharacter.galEquivRange.{u_1}
      {q : ℕ} [NeZero q] (K : Type u_1)
      [Field K] [NumberField K]
      [IsCyclotomicExtension {q} ℚ K]
      (χ : DirichletCharacter ℂ q) :
      Gal(↥(DirichletCharacter.fixedField K
              χ)/ℚ) ≃*
        ↥(MulChar.toUnitHom χ).range
    The isomorphism (LMFDB `character.dirichlet.field_cut_out`) of the Galois group of the fixed
    field `ℚ(ζ_q)^{ker χ}` of a Dirichlet character `χ` with the image `Im(χ)` of `χ` on units, given by
    the Galois correspondence: `Gal(ℚ(ζ_q)^{ker χ}/ℚ) ≅ Gal(ℚ(ζ_q)/ℚ)/ker(χ ∘ σ) ≅ Im(χ)`. It sends the
    restriction of `σ_a` to `χ(a)` (`DirichletCharacter.galEquivRange_restrictNormalHom`). The image
    `Im(χ)` is the cyclic group of `n`-th roots of unity, `n` being the order of `χ`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/MulChar/Order.lean
    complete
    theorem MulChar.isCyclic_range_toUnitHom.{u_1, u_2} {M : Type u_1}
      {R : Type u_2} [CommMonoid M] [CommRing R] (χ : MulChar M R)
      [Finite Mˣ] [IsDomain R] : IsCyclic ↥χ.toUnitHom.range
    theorem MulChar.isCyclic_range_toUnitHom.{u_1,
        u_2}
      {M : Type u_1} {R : Type u_2}
      [CommMonoid M] [CommRing R]
      (χ : MulChar M R) [Finite Mˣ]
      [IsDomain R] :
      IsCyclic ↥χ.toUnitHom.range
    **The image of a character on units is cyclic.** 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/MulChar/Order.lean
    complete
    theorem MulChar.card_range_toUnitHom.{u_1, u_2} {M : Type u_1} {R : Type u_2}
      [CommMonoid M] [CommRing R] (χ : MulChar M R) [Finite Mˣ]
      [IsDomain R] : Nat.card ↥χ.toUnitHom.range = orderOf χ
    theorem MulChar.card_range_toUnitHom.{u_1, u_2}
      {M : Type u_1} {R : Type u_2}
      [CommMonoid M] [CommRing R]
      (χ : MulChar M R) [Finite Mˣ]
      [IsDomain R] :
      Nat.card ↥χ.toUnitHom.range = orderOf χ
    **The image of a character on units has the order of the character.** 
Definition6.1.12
Statement uses 5
Statement dependency previews
Preview
Definition 5.1.23
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 12
Reverse dependency previews
Preview
Definition 3.1.18
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Galois orbit of a Dirichlet character. (LMFDB)

The Galois orbit of a Dirichlet character \chi of modulus q and order n is the set [\chi]:=\{\sigma(\chi): \sigma\in \Gal(\Q(\zeta_n)/\Q)\}, where \sigma(\chi) denotes the Dirichlet character of modulus q defined by k \mapsto \sigma(\chi(k)). The map \chi\to \sigma(\chi) defines a faithful action of the Galois group \Gal(\Q(\zeta_n)/\Q) on the set of Dirichlet characters of modulus q and order n, each of which has \Q(\zeta_n) as its field of values.

Tau Ceti Review: MulChar.galoisOrbit, IsPrimitiveRoot.isCyclotomicExtension_adjoin_nth_roots.

Depends on: Definition 6.1.1 Definition 6.1.27 Definition 6.1.28 Definition 6.1.34 Definition 5.1.23

Lean code for Definition6.1.12●6 declarations
  • defdefined in TauCeti/NumberTheory/MulChar/GaloisOrbit.lean
    complete
    def MulChar.galoisOrbit.{u_1, u_2} {M : Type u_1} [CommMonoid M]
      {R : Type u_2} [CommMonoidWithZero R] (χ : MulChar M R) :
      Set (MulChar M R)
    def MulChar.galoisOrbit.{u_1, u_2}
      {M : Type u_1} [CommMonoid M]
      {R : Type u_2} [CommMonoidWithZero R]
      (χ : MulChar M R) : Set (MulChar M R)
    The Galois orbit of a multiplicative character `χ`: the characters generating the same cyclic
    subgroup of characters as `χ`. When `χ` has finite order these are the powers `χ ^ a` with `a`
    prime to its order (`MulChar.mem_galoisOrbit_iff_exists_pow`). When moreover the monoid has
    finitely many units and the values lie in a field of characteristic zero, they are the conjugates
    `σ ∘ χ` under the embeddings `σ` of the field generated by the values of `χ`
    (`MulChar.mem_galoisOrbit_iff_exists_algHom`). 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/MulChar/GaloisAction.lean
    complete
    def MulChar.galoisConj.{u_1} {M : Type u_1} [CommMonoid M] {n : ℕ}
      (σ : Gal(↥(IntermediateField.adjoin ℚ {b | b ^ n = 1})/ℚ))
      {χ : MulChar M ℂ} (hχ : χ ^ n = 1) : MulChar M ℂ
    def MulChar.galoisConj.{u_1} {M : Type u_1}
      [CommMonoid M] {n : ℕ}
      (σ :
        Gal(↥(IntermediateField.adjoin ℚ
              {b | b ^ n = 1})/ℚ))
      {χ : MulChar M ℂ} (hχ : χ ^ n = 1) :
      MulChar M ℂ
    The **Galois conjugate** (LMFDB `character.dirichlet.galois_orbit`) `σ(χ) : x ↦ σ(χ x)` of a
    complex character `χ` with `χ ^ n = 1`, such as a Dirichlet character of modulus `q` and order `n`,
    by an automorphism `σ` of the subfield `ℚ(ζ_n)` of `ℂ` generated by the `n`-th roots of unity, which
    contains the values of `χ`. On the characters of order `n` it is an action of `Gal(ℚ(ζ_n)/ℚ)`
    whose orbits are the Galois orbits (`MulChar.image_val_orbit`). 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/MulChar/GaloisAction.lean
    complete
    theorem MulChar.image_val_orbit.{u_1} {M : Type u_1} [CommMonoid M]
      (χ : MulChar M ℂ) [Finite Mˣ] :
      Subtype.val ''
          MulAction.orbit
            Gal(↥(IntermediateField.adjoin ℚ {b | b ^ orderOf χ = 1})/ℚ)
            ⟨χ, ⋯⟩ =
        χ.galoisOrbit
    theorem MulChar.image_val_orbit.{u_1}
      {M : Type u_1} [CommMonoid M]
      (χ : MulChar M ℂ) [Finite Mˣ] :
      Subtype.val ''
          MulAction.orbit
            Gal(↥(IntermediateField.adjoin ℚ
                  {b | b ^ orderOf χ = 1})/ℚ)
            ⟨χ, ⋯⟩ =
        χ.galoisOrbit
    **The orbit of a character `χ` of order `n` under `Gal(ℚ(ζ_n)/ℚ)` is its Galois orbit**, the
    set `{σ(χ) : σ ∈ Gal(ℚ(ζ_n)/ℚ)}`: the automorphism `σ_a` raising the `n`-th roots of unity to the
    power `a` prime to `n` sends `χ` to `χ ^ a`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/MulChar/GaloisAction.lean
    complete
    theorem MulChar.faithfulSMul_galois.{u_1} {M : Type u_1} [CommMonoid M]
      (χ : MulChar M ℂ) [Finite Mˣ] :
      FaithfulSMul
        Gal(↥(IntermediateField.adjoin ℚ {b | b ^ orderOf χ = 1})/ℚ)
        { ψ // orderOf ψ = orderOf χ }
    theorem MulChar.faithfulSMul_galois.{u_1}
      {M : Type u_1} [CommMonoid M]
      (χ : MulChar M ℂ) [Finite Mˣ] :
      FaithfulSMul
        Gal(↥(IntermediateField.adjoin ℚ
              {b | b ^ orderOf χ = 1})/ℚ)
        { ψ // orderOf ψ = orderOf χ }
    **The action of `Gal(ℚ(ζ_n)/ℚ)` on the characters of order `n` is faithful**, `n` being the
    order of a character `χ`, so that there are characters of order `n`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/MulChar/FieldOfValues.lean
    complete
    theorem MulChar.adjoin_range_eq_adjoin_nth_roots.{u_1, u_2} {M : Type u_1}
      {K : Type u_2} [CommMonoid M] [Field K] [CharZero K] (χ : MulChar M K)
      [Finite Mˣ] :
      IntermediateField.adjoin ℚ (Set.range ⇑χ) =
        IntermediateField.adjoin ℚ {b | b ^ orderOf χ = 1}
    theorem MulChar.adjoin_range_eq_adjoin_nth_roots.{u_1,
        u_2}
      {M : Type u_1} {K : Type u_2}
      [CommMonoid M] [Field K] [CharZero K]
      (χ : MulChar M K) [Finite Mˣ] :
      IntermediateField.adjoin ℚ
          (Set.range ⇑χ) =
        IntermediateField.adjoin ℚ
          {b | b ^ orderOf χ = 1}
    **The field of values of a character of order `n` is the field `ℚ(μ_n)`** generated by the
    `n`-th roots of unity, an `n`-th cyclotomic field (Tau Ceti's
    `IsPrimitiveRoot.isCyclotomicExtension_adjoin_nth_roots`). 
  • theoremdefined in TauCeti/NumberTheory/Cyclotomic/Adjoin.lean
    complete
    theorem IsPrimitiveRoot.isCyclotomicExtension_adjoin_nth_roots.{u_1, u_2}
      {K : Type u_1} {M : Type u_2} [Field K] [Field M] [Algebra K M]
      {m : ℕ} [NeZero m] {ζ : M} (hζ : IsPrimitiveRoot ζ m) :
      IsCyclotomicExtension {m} K
        ↥(IntermediateField.adjoin K {b | b ^ m = 1})
    theorem IsPrimitiveRoot.isCyclotomicExtension_adjoin_nth_roots.{u_1,
        u_2}
      {K : Type u_1} {M : Type u_2} [Field K]
      [Field M] [Algebra K M] {m : ℕ}
      [NeZero m] {ζ : M}
      (hζ : IsPrimitiveRoot ζ m) :
      IsCyclotomicExtension {m} K
        ↥(IntermediateField.adjoin K
            {b | b ^ m = 1})
    **`K(μ_m)` is an `m`-th cyclotomic extension of `K`** inside any extension of `K` containing a
    primitive `m`-th root of unity. 
Definition6.1.13
Statement uses 6
Statement dependency previews
Preview
Definition 6.1.1
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 1✓L∃∀N

Orbit index of a Dirichlet character. (LMFDB)

The Galois orbits of Dirichlet characters of modulus q are ordered as follows. Let \chi be any character in the Galois orbit [\chi] and define the N-tuple of integers

t([\chi]) := (n,t_1,t_2,\ldots,t_{q-1}) \in \Z^q,

where n is the order of \chi and t_i:=\mathrm{tr}_{\Q(\chi)/\Q}(\chi(i)) is the trace of \chi(i) from the field of values of \chi to \Q. The q-tuple t([\chi]) is independent of the choice of representative \chi and uniquely identifies the Galois orbit [\chi].

The orbit index of \chi is the index of t([\chi]) in the lexicographic ordering of all such tuples arising for Dirichlet characters of modulus q; indexing begins at 1, which is always the index of the Galois orbit of the principal character of modulus 1.

Depends on: Definition 6.1.1 Definition 6.1.12 Definition 6.1.27 Definition 6.1.28 Definition 6.1.31 Definition 6.1.34

Lean code for Definition6.1.13●10 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/GaloisOrbitLabel.lean
    complete
    def DirichletCharacter.galoisOrbitIndex {q : ℕ}
      (χ : DirichletCharacter ℂ q) : ℕ
    def DirichletCharacter.galoisOrbitIndex
      {q : ℕ} (χ : DirichletCharacter ℂ q) : ℕ
    The **orbit index** of a Dirichlet character `χ` of modulus `q` (LMFDB
    `character.dirichlet.galois_orbit_index`): the position, counted from `1`, of the trace vector of
    `χ` in the lexicographic order on the trace vectors of the Dirichlet characters of modulus `q`. It
    depends only on the Galois orbit of `χ` and determines it (`galoisOrbitIndex_eq_iff`). 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/TraceVectorIntegral.lean
    complete
    def DirichletCharacter.intTraceVector {q : ℕ} (χ : DirichletCharacter ℂ q) :
      List ℤ
    def DirichletCharacter.intTraceVector {q : ℕ}
      (χ : DirichletCharacter ℂ q) : List ℤ
    The **trace vector** `t([χ]) = (n, t₁, …, t_{q-1}) ∈ ℤ^q` of a Dirichlet character `χ` of
    modulus `q` (LMFDB `character.dirichlet.galois_orbit_index`): the order `n` of `χ` followed by the
    traces `tᵢ = tr_{ℚ(χ)/ℚ}(χ i)` for `i = 1, …, q - 1`, which are rational integers
    (`DirichletCharacter.intCast_num_valueTrace`), here written as their numerators. In `ℚ` it is
    `DirichletCharacter.galoisOrbitTraceVector` (`DirichletCharacter.map_intCast_intTraceVector`). 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/GaloisOrbitLabel.lean
    complete
    def DirichletCharacter.galoisOrbitTraceVector {q : ℕ}
      (χ : DirichletCharacter ℂ q) : List ℚ
    def DirichletCharacter.galoisOrbitTraceVector
      {q : ℕ} (χ : DirichletCharacter ℂ q) :
      List ℚ
    The **trace vector** `t([χ]) = (n, t₁, …, t_{q-1})` of a Dirichlet character `χ` of modulus
    `q`: its order `n` followed by the traces `tᵢ = tr_{ℚ(χ)/ℚ}(χ i)` for `i = 1, …, q - 1`. The `tᵢ`
    are rational integers; we keep them in `ℚ`, whose order agrees with that of `ℤ`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/TraceVectorIntegral.lean
    complete
    theorem DirichletCharacter.intCast_num_valueTrace {q : ℕ}
      (χ : DirichletCharacter ℂ q) (x : ZMod q) :
      ↑(χ.valueTrace x).num = χ.valueTrace x
    theorem DirichletCharacter.intCast_num_valueTrace
      {q : ℕ} (χ : DirichletCharacter ℂ q)
      (x : ZMod q) :
      ↑(χ.valueTrace x).num = χ.valueTrace x
    **The traces `tᵢ` are rational integers** (LMFDB `character.dirichlet.galois_orbit_index`):
    the trace of `χ x` from the field of values of `χ` to `ℚ` is the integer given by its numerator, as
    `χ x` is an algebraic integer. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/TraceVectorIntegral.lean
    complete
    theorem DirichletCharacter.length_intTraceVector {q : ℕ}
      (χ : DirichletCharacter ℂ q) [NeZero q] : χ.intTraceVector.length = q
    theorem DirichletCharacter.length_intTraceVector
      {q : ℕ} (χ : DirichletCharacter ℂ q)
      [NeZero q] : χ.intTraceVector.length = q
    **The trace vector has `q` entries**, the order and the traces `t₁, …, t_{q-1}`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/TraceVectorIntegral.lean
    complete
    theorem DirichletCharacter.intTraceVector_eq_iff {q : ℕ}
      {χ ψ : DirichletCharacter ℂ q} [NeZero q] :
      ψ.intTraceVector = χ.intTraceVector ↔ ψ ∈ MulChar.galoisOrbit χ
    theorem DirichletCharacter.intTraceVector_eq_iff
      {q : ℕ} {χ ψ : DirichletCharacter ℂ q}
      [NeZero q] :
      ψ.intTraceVector = χ.intTraceVector ↔
        ψ ∈ MulChar.galoisOrbit χ
    **The trace vector in `ℤ^q` depends only on the Galois orbit and determines it**: two Dirichlet
    characters of nonzero modulus have the same trace vector exactly when they lie in one Galois
    orbit. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/TraceVectorIntegral.lean
    complete
    theorem DirichletCharacter.galoisOrbitIndex_eq_ncard_intTraceVector {q : ℕ}
      (χ : DirichletCharacter ℂ q) :
      χ.galoisOrbitIndex =
        {t |
              t ∈ Set.range DirichletCharacter.intTraceVector ∧
                t < χ.intTraceVector}.ncard +
          1
    theorem DirichletCharacter.galoisOrbitIndex_eq_ncard_intTraceVector
      {q : ℕ} (χ : DirichletCharacter ℂ q) :
      χ.galoisOrbitIndex =
        {t |
              t ∈
                  Set.range
                    DirichletCharacter.intTraceVector ∧
                t < χ.intTraceVector}.ncard +
          1
    **The orbit index is the position of the trace vector in `ℤ^q`** (LMFDB
    `character.dirichlet.galois_orbit_index`): it is one more than the number of trace vectors in
    `ℤ^q` of the characters of modulus `q` that are lexicographically smaller than that of `χ`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/GaloisOrbitLabel.lean
    complete
    theorem DirichletCharacter.galoisOrbitIndex_one {q : ℕ} :
      DirichletCharacter.galoisOrbitIndex 1 = 1
    theorem DirichletCharacter.galoisOrbitIndex_one
      {q : ℕ} :
      DirichletCharacter.galoisOrbitIndex 1 =
        1
    The Galois orbit of the principal character has orbit index `1`, since every other character
    has a larger order. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/GaloisOrbitLabel.lean
    complete
    theorem DirichletCharacter.galoisOrbitIndex_eq_iff {q : ℕ}
      {χ ψ : DirichletCharacter ℂ q} [NeZero q] :
      ψ.galoisOrbitIndex = χ.galoisOrbitIndex ↔ ψ ∈ MulChar.galoisOrbit χ
    theorem DirichletCharacter.galoisOrbitIndex_eq_iff
      {q : ℕ} {χ ψ : DirichletCharacter ℂ q}
      [NeZero q] :
      ψ.galoisOrbitIndex =
          χ.galoisOrbitIndex ↔
        ψ ∈ MulChar.galoisOrbit χ
    Two Dirichlet characters of nonzero modulus have the same orbit index exactly when they lie in
    one Galois orbit. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/GaloisOrbitLabel.lean
    complete
    theorem DirichletCharacter.galoisOrbitTraceVector_eq_iff {q : ℕ}
      {χ ψ : DirichletCharacter ℂ q} [NeZero q] :
      ψ.galoisOrbitTraceVector = χ.galoisOrbitTraceVector ↔
        ψ ∈ MulChar.galoisOrbit χ
    theorem DirichletCharacter.galoisOrbitTraceVector_eq_iff
      {q : ℕ} {χ ψ : DirichletCharacter ℂ q}
      [NeZero q] :
      ψ.galoisOrbitTraceVector =
          χ.galoisOrbitTraceVector ↔
        ψ ∈ MulChar.galoisOrbit χ
    Two Dirichlet characters of nonzero modulus have the same trace vector exactly when they lie
    in one Galois orbit. 
Definition6.1.14
Statement uses 3
Statement dependency previews
Preview
Definition 6.1.1
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 6
Reverse dependency previews
Preview
Definition 3.1.30
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Label of a Galois orbit of a Dirichlet character. (LMFDB)

The label of a Galois orbit of a Dirichlet character \chi of modulus N takes the form N.a, where a is a letter or string of letters representing the index of the Galois orbit. The index 1 is written as a, the index 2 is written as b, the index 27 is written as ba, and so on.

Depends on: Definition 6.1.1 Definition 6.1.12 Definition 6.1.13

Lean code for Definition6.1.14●5 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/GaloisOrbitLabel.lean
    complete
    def DirichletCharacter.galoisOrbitLabel {q : ℕ}
      (χ : DirichletCharacter ℂ q) : String
    def DirichletCharacter.galoisOrbitLabel
      {q : ℕ} (χ : DirichletCharacter ℂ q) :
      String
    The **label** of the Galois orbit of a Dirichlet character `χ` of modulus `q` (LMFDB
    `character.dirichlet.galois_orbit_label`): `q.a`, where `a` is the letter code of the orbit index
    of `χ` minus one, so that the orbit indices `1, 2, 27` are written `a, b, ba`. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/GaloisOrbitLabel.lean
    complete
    def DirichletCharacter.letterCode (n : ℕ) : String
    def DirichletCharacter.letterCode (n : ℕ) :
      String
    The **letter code** of a natural number `n`: its base-`26` expansion with the digits written
    `a, b, …, z`, so that `0, 1, …, 25, 26` are written `a, b, …, z, ba`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/GaloisOrbitLabel.lean
    complete
    theorem DirichletCharacter.letterCode_zero :
      DirichletCharacter.letterCode 0 = "a"
    theorem DirichletCharacter.letterCode_zero :
      DirichletCharacter.letterCode 0 = "a"
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/GaloisOrbitLabel.lean
    complete
    theorem DirichletCharacter.letterCode_one :
      DirichletCharacter.letterCode 1 = "b"
    theorem DirichletCharacter.letterCode_one :
      DirichletCharacter.letterCode 1 = "b"
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/GaloisOrbitLabel.lean
    complete
    theorem DirichletCharacter.letterCode_twentySix :
      DirichletCharacter.letterCode 26 = "ba"
    theorem DirichletCharacter.letterCode_twentySix :
      DirichletCharacter.letterCode 26 = "ba"
Definition6.1.15
uses 1
Used by 2
Reverse dependency previews
Preview
Definition 6.1.23
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Gauss sum. (LMFDB)

Let \chi be a Dirichlet character with modulus q. For a \in \mathbb{Z}, the Gauss sum associated to \chi and a is given by

\large \tau_{a}(\chi) = \sum_{r \,\in\, \mathbb{Z}/q\mathbb{Z}} \chi(r)\, e^{2\pi iar/q}.

The Gauss sum \tau_1(\chi) is often called "the Gauss sum" of \chi.

Tau Ceti Review: gaussSum, ZMod.stdAddChar, AddChar.mulShift.

Depends on: Definition 6.1.1

Lean code for Definition6.1.15●3 definitions
  • defdefined in Mathlib/NumberTheory/GaussSum.lean
    complete
    def gaussSum.{u, v} {R : Type u} [CommRing R] [Fintype R] {R' : Type v}
      [CommRing R'] (χ : MulChar R R') (ψ : AddChar R R') : R'
    def gaussSum.{u, v} {R : Type u} [CommRing R]
      [Fintype R] {R' : Type v} [CommRing R']
      (χ : MulChar R R') (ψ : AddChar R R') :
      R'
    Definition of the Gauss sum associated to a multiplicative and an additive character. 
  • defdefined in Mathlib/Analysis/SpecialFunctions/Complex/CircleAddChar.lean
    complete
    def ZMod.stdAddChar {N : ℕ} [NeZero N] : AddChar (ZMod N) ℂ
    def ZMod.stdAddChar {N : ℕ} [NeZero N] :
      AddChar (ZMod N) ℂ
    The additive character from `ZMod N` to `ℂ`, sending `j mod N` to `exp (2 * π * I * j / N)`. 
  • defdefined in Mathlib/Algebra/Group/AddChar.lean
    complete
    def AddChar.mulShift.{u_1, u_2} {R : Type u_1} {M : Type u_2} [Ring R]
      [CommMonoid M] (ψ : AddChar R M) (r : R) : AddChar R M
    def AddChar.mulShift.{u_1, u_2} {R : Type u_1}
      {M : Type u_2} [Ring R] [CommMonoid M]
      (ψ : AddChar R M) (r : R) : AddChar R M
    Define the multiplicative shift of an additive character.
    This satisfies `mulShift ψ a x = ψ (a * x)`. 
Definition6.1.16
Statement uses 2
Statement dependency previews
Preview
Definition 6.1.1
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 1✓L∃∀N

Dirichlet character group. (LMFDB)

The Dirichlet characters \chi\colon\Z\to\C of modulus q form a group under pointwise multiplication.

In the Conrey labeling system we simply have \chi_q(n_1,\cdot)\chi_q(n_2,\cdot) = \chi_q(n_1n_2,\cdot).

This group is (non-canonically) isomorphic to the multiplicative group (\Z/q\Z)^\times.

Tau Ceti Review: MulChar.commGroup, MulChar.coeToFun_mul.

Depends on: Definition 6.1.1 Definition 6.1.27

Lean code for Definition6.1.16●3 declarations
  • defdefined in Mathlib/NumberTheory/MulChar/Basic.lean
    complete
    def MulChar.commGroup.{u_1, u_2} {R : Type u_1} [CommMonoid R]
      {R' : Type u_2} [CommMonoidWithZero R'] : CommGroup (MulChar R R')
    def MulChar.commGroup.{u_1, u_2}
      {R : Type u_1} [CommMonoid R]
      {R' : Type u_2}
      [CommMonoidWithZero R'] :
      CommGroup (MulChar R R')
    The commutative group structure on `MulChar R R'`. 
  • theoremdefined in Mathlib/NumberTheory/MulChar/Basic.lean
    complete
    theorem MulChar.coeToFun_mul.{u_1, u_2} {R : Type u_1} [CommMonoid R]
      {R' : Type u_2} [CommMonoidWithZero R'] (χ χ' : MulChar R R') :
      ⇑(χ * χ') = ⇑χ * ⇑χ'
    theorem MulChar.coeToFun_mul.{u_1, u_2}
      {R : Type u_1} [CommMonoid R]
      {R' : Type u_2} [CommMonoidWithZero R']
      (χ χ' : MulChar R R') :
      ⇑(χ * χ') = ⇑χ * ⇑χ'
  • theoremdefined in Mathlib/NumberTheory/DirichletCharacter/Orthogonality.lean
    complete
    theorem DirichletCharacter.mulEquiv_units.{u_1} (R : Type u_1) [CommRing R]
      (n : ℕ) [NeZero n]
      [HasEnoughRootsOfUnity R (Monoid.exponent (ZMod n)ˣ)] :
      Nonempty (DirichletCharacter R n ≃* (ZMod n)ˣ)
    theorem DirichletCharacter.mulEquiv_units.{u_1}
      (R : Type u_1) [CommRing R] (n : ℕ)
      [NeZero n]
      [HasEnoughRootsOfUnity R
          (Monoid.exponent (ZMod n)ˣ)] :
      Nonempty
        (DirichletCharacter R n ≃* (ZMod n)ˣ)
    The group of Dirichlet characters mod `n` with values in a ring `R` that has enough
    roots of unity is (noncanonically) isomorphic to `(ZMod n)ˣ`. 
Definition6.1.17
Statement uses 2
Statement dependency previews
Preview
Definition 6.1.1
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0✓L∃∀N

Generators of a Dirichlet character group. (LMFDB)

A set of generators of the Dirichlet character group G of modulus q is a set of Dirichlet characters \chi_q(n_i,\cdot) that generate G under multiplication. These may be chosen so that G is the direct product of the cyclic groups generated by each of the \chi_q(n_i,\cdot).

Tau Ceti Review: Subgroup.closure, Subgroup.zpowers.

Depends on: Definition 6.1.1 Definition 6.1.27

Lean code for Definition6.1.17●5 declarations
  • defdefined in Mathlib/Algebra/Group/Subgroup/Lattice.lean
    complete
    def Subgroup.closure.{u_1} {G : Type u_1} [Group G] (k : Set G) : Subgroup G
    def Subgroup.closure.{u_1} {G : Type u_1}
      [Group G] (k : Set G) : Subgroup G
    The `Subgroup` generated by a set. 
  • defdefined in Mathlib/Algebra/Group/Subgroup/ZPowers/Basic.lean
    complete
    def Subgroup.zpowers.{u_1} {G : Type u_1} [Group G] (g : G) : Subgroup G
    def Subgroup.zpowers.{u_1} {G : Type u_1}
      [Group G] (g : G) : Subgroup G
    The subgroup generated by an element. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/Generators.lean
    complete
    theorem DirichletCharacter.exists_generators_bijective_prod_zpowers (q : ℕ) :
      ∃ ι x χ,
        Subgroup.closure (Set.range χ) = ⊤ ∧
          Function.Bijective fun x_1 => ∏ i, ↑(x_1 i)
    theorem DirichletCharacter.exists_generators_bijective_prod_zpowers
      (q : ℕ) :
      ∃ ι x χ,
        Subgroup.closure (Set.range χ) = ⊤ ∧
          Function.Bijective fun x_1 =>
            ∏ i, ↑(x_1 i)
    **The group of Dirichlet characters of modulus `q` has generators `χ_i` such that it is the
    direct product of the cyclic subgroups `⟨χ_i⟩`**: the `χ_i` generate it under multiplication, and
    the map `∏ᵢ ⟨χ_i⟩ → G`, `(x_i) ↦ ∏ᵢ x_i`, is bijective. 
  • theoremdefined in LeanBridge/ForMathlib/GroupTheory/FiniteAbelian/ProdZPowers.lean
    complete
    theorem CommGroup.exists_bijective_prod_zpowers.{u_1} (G : Type u_1)
      [CommGroup G] [Finite G] :
      ∃ ι x g, Function.Bijective fun x_1 => ∏ i, ↑(x_1 i)
    theorem CommGroup.exists_bijective_prod_zpowers.{u_1}
      (G : Type u_1) [CommGroup G]
      [Finite G] :
      ∃ ι x g,
        Function.Bijective fun x_1 =>
          ∏ i, ↑(x_1 i)
    **A finite commutative group is the internal direct product of the cyclic subgroups generated by
    suitable elements `g_i`**: the map `∏ᵢ ⟨g_i⟩ → G`, `(x_i) ↦ ∏ᵢ x_i`, is bijective. 
  • theoremdefined in LeanBridge/ForMathlib/GroupTheory/FiniteAbelian/ProdZPowers.lean
    complete
    theorem CommGroup.closure_range_eq_top_of_surjective_prod_zpowers.{u_1, u_2}
      {G : Type u_1} [CommGroup G] {ι : Type u_2} [Fintype ι] {g : ι → G}
      (h : Function.Surjective fun x => ∏ i, ↑(x i)) :
      Subgroup.closure (Set.range g) = ⊤
    theorem CommGroup.closure_range_eq_top_of_surjective_prod_zpowers.{u_1,
        u_2}
      {G : Type u_1} [CommGroup G]
      {ι : Type u_2} [Fintype ι] {g : ι → G}
      (h :
        Function.Surjective fun x =>
          ∏ i, ↑(x i)) :
      Subgroup.closure (Set.range g) = ⊤
    **Elements `g_i` such that `G` is the product of the cyclic subgroups `⟨g_i⟩` generate `G`.** 
Definition6.1.18
Statement uses 2
Statement dependency previews
Preview
Definition 6.1.1
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0✓L∃∀N

Order of a Dirichlet character group. (LMFDB)

The set of Dirichlet characters \chi\colon\Z\to\C of modulus q form a group isomorphic (though not canonically) to (\Z/q\Z)^\times, which has order \varphi(q), where \varphi is the Euler function.

Tau Ceti Review: DirichletCharacter.card_eq_totient_of_hasEnoughRootsOfUnity.

Depends on: Definition 6.1.1 Definition 6.1.27

Lean code for Definition6.1.18●2 theorems
  • theoremdefined in Mathlib/NumberTheory/DirichletCharacter/Orthogonality.lean
    complete
    theorem DirichletCharacter.card_eq_totient_of_hasEnoughRootsOfUnity.{u_1}
      (R : Type u_1) [CommRing R] (n : ℕ) [NeZero n]
      [HasEnoughRootsOfUnity R (Monoid.exponent (ZMod n)ˣ)] :
      Nat.card (DirichletCharacter R n) = n.totient
    theorem DirichletCharacter.card_eq_totient_of_hasEnoughRootsOfUnity.{u_1}
      (R : Type u_1) [CommRing R] (n : ℕ)
      [NeZero n]
      [HasEnoughRootsOfUnity R
          (Monoid.exponent (ZMod n)ˣ)] :
      Nat.card (DirichletCharacter R n) =
        n.totient
    There are `n.totient` Dirichlet characters mod `n` with values in a ring that has enough
    roots of unity. 
  • theoremdefined in Mathlib/NumberTheory/DirichletCharacter/Orthogonality.lean
    complete
    theorem DirichletCharacter.mulEquiv_units.{u_1} (R : Type u_1) [CommRing R]
      (n : ℕ) [NeZero n]
      [HasEnoughRootsOfUnity R (Monoid.exponent (ZMod n)ˣ)] :
      Nonempty (DirichletCharacter R n ≃* (ZMod n)ˣ)
    theorem DirichletCharacter.mulEquiv_units.{u_1}
      (R : Type u_1) [CommRing R] (n : ℕ)
      [NeZero n]
      [HasEnoughRootsOfUnity R
          (Monoid.exponent (ZMod n)ˣ)] :
      Nonempty
        (DirichletCharacter R n ≃* (ZMod n)ˣ)
    The group of Dirichlet characters mod `n` with values in a ring `R` that has enough
    roots of unity is (noncanonically) isomorphic to `(ZMod n)ˣ`. 
Definition6.1.19
uses 1used by 1✓L∃∀N

Structure of a Dirichlet group. (LMFDB)

The structure of a Dirichlet character group of Dirichlet characters of modulus q refers to its isomorphism type as a finite abelian group, which can be uniquely expressed as a product of cyclic groups C_{n_1}\times C_{n_2}\cdots\times C_{n_r} with n_1|n_2|\cdots |n_r. This is the same as the structure of the group (\Z/q\Z)^\times.

Depends on: Definition 6.1.27

Lean code for Definition6.1.19●4 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/GroupStructure.lean
    complete
    def DirichletCharacter.groupStructure (q : ℕ) : List ℕ
    def DirichletCharacter.groupStructure
      (q : ℕ) : List ℕ
    The **structure** (LMFDB `character.dirichlet.group.structure`) of the group of Dirichlet
    characters of modulus `q`: its invariant factors `[n₁, …, n_r]`, the unique list with
    `1 < n₁ ∣ n₂ ∣ ⋯ ∣ n_r` such that the group is isomorphic to `C_{n₁} × ⋯ × C_{n_r}`
    (`groupStructure_eq_iff`). It is also the structure of `(ℤ/qℤ)ˣ` (`groupStructure_eq`). The LMFDB
    does not state `1 < n₁`, without which the list is not unique; for `q ≤ 2` the group is trivial
    and the list is empty. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/GroupStructure.lean
    complete
    theorem DirichletCharacter.groupStructure_eq_iff {q : ℕ} {L : List ℕ} :
      DirichletCharacter.groupStructure q = L ↔
        (∀ m ∈ L, 1 < m) ∧
          List.IsChain (fun x1 x2 => x1 ∣ x2) L ∧
            Nonempty
              (DirichletCharacter ℂ q ≃*
                ((i : Fin L.length) → Multiplicative (ZMod L[i])))
    theorem DirichletCharacter.groupStructure_eq_iff
      {q : ℕ} {L : List ℕ} :
      DirichletCharacter.groupStructure q =
          L ↔
        (∀ m ∈ L, 1 < m) ∧
          List.IsChain (fun x1 x2 => x1 ∣ x2)
              L ∧
            Nonempty
              (DirichletCharacter ℂ q ≃*
                ((i : Fin L.length) →
                  Multiplicative (ZMod L[i])))
    The structure of the group of Dirichlet characters of modulus `q` is the unique list
    `[n₁, …, n_r]` with `1 < n₁ ∣ n₂ ∣ ⋯ ∣ n_r` such that the group is isomorphic to
    `C_{n₁} × ⋯ × C_{n_r}`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/GroupStructure.lean
    complete
    theorem DirichletCharacter.groupStructure_eq (q : ℕ) [NeZero q] :
      DirichletCharacter.groupStructure q =
        AddCommGroup.smithAbelianInvariants (Additive (ZMod q)ˣ)
    theorem DirichletCharacter.groupStructure_eq
      (q : ℕ) [NeZero q] :
      DirichletCharacter.groupStructure q =
        AddCommGroup.smithAbelianInvariants
          (Additive (ZMod q)ˣ)
    The structure of the group of Dirichlet characters of modulus `q` is the structure of
    `(ℤ/qℤ)ˣ`. 
  • defdefined in LeanBridge/ForMathlib/GroupTheory/FiniteAbelian/AbelianInvariants.lean
    complete
    def AddCommGroup.smithAbelianInvariants.{u_1} (G : Type u_1)
      [AddCommGroup G] [Finite G] : List ℕ
    def AddCommGroup.smithAbelianInvariants.{u_1}
      (G : Type u_1) [AddCommGroup G]
      [Finite G] : List ℕ
    The **Smith abelian invariants** of a finite abelian group `A` (LMFDB
    `group.abelian_invariants`), or its invariant factors: the unique list `[m₁, …, mₖ]` of integers
    larger than `1` such that `mᵢ ∣ mᵢ₊₁` for all `i` and `A ≃ C_{m₁} × ⋯ × C_{mₖ}`
    (`AddCommGroup.smithAbelianInvariants_eq_iff`). Here `C_m` is `ZMod m`; the invariants of a
    multiplicative group `G` are those of `Additive G`
    (`CommGroup.smithAbelianInvariants_additive_eq_iff`). 
Definition6.1.20
Statement uses 2
Statement dependency previews
Preview
Definition 6.1.1
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 8
Reverse dependency previews
Preview
Definition 2.44
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Induced Dirichlet character. (LMFDB)

A Dirichlet character \chi_1 of modulus q_1 is said to be induced by a Dirichlet character \chi_2 of modulus q_2 dividing q_1 if \chi_1(m)=\chi_2(m) for all m coprime to q_1.

A Dirichlet character is primitive if it is not induced by any character other than itself; every Dirichlet character is induced by a uniquely determined primitive Dirichlet character.

Tau Ceti Review: DirichletCharacter.changeLevel, DirichletCharacter.primitiveCharacter.

Depends on: Definition 6.1.1 Definition 6.1.27

Lean code for Definition6.1.20●6 declarations
  • defdefined in Mathlib/NumberTheory/DirichletCharacter/Basic.lean
    complete
    def DirichletCharacter.changeLevel.{u_1} {R : Type u_1}
      [CommMonoidWithZero R] {n m : ℕ} (hm : n ∣ m) :
      DirichletCharacter R n →* DirichletCharacter R m
    def DirichletCharacter.changeLevel.{u_1}
      {R : Type u_1} [CommMonoidWithZero R]
      {n m : ℕ} (hm : n ∣ m) :
      DirichletCharacter R n →*
        DirichletCharacter R m
    A function that modifies the level of a Dirichlet character to some multiple
    of its original level. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/Induced.lean
    complete
    def DirichletCharacter.IsInducedBy.{u_1} {R : Type u_1}
      [CommMonoidWithZero R] {q d : ℕ} (χ : DirichletCharacter R q)
      (ψ : DirichletCharacter R d) : Prop
    def DirichletCharacter.IsInducedBy.{u_1}
      {R : Type u_1} [CommMonoidWithZero R]
      {q d : ℕ} (χ : DirichletCharacter R q)
      (ψ : DirichletCharacter R d) : Prop
    A Dirichlet character `χ` of modulus `q` is **induced** (LMFDB `character.dirichlet.induce`) by
    a Dirichlet character `ψ` of modulus `d` if `d` divides `q` and `χ(m) = ψ(m)` for every integer `m`
    prime to `q`. Equivalently, `χ` is Mathlib's `changeLevel` of `ψ`
    (`DirichletCharacter.isInducedBy_iff`). 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/Induced.lean
    complete
    theorem DirichletCharacter.isInducedBy_iff.{u_1} {R : Type u_1}
      [CommMonoidWithZero R] {q d : ℕ} (χ : DirichletCharacter R q)
      (ψ : DirichletCharacter R d) [NeZero q] :
      χ.IsInducedBy ψ ↔
        ∃ (h : d ∣ q), (DirichletCharacter.changeLevel h) ψ = χ
    theorem DirichletCharacter.isInducedBy_iff.{u_1}
      {R : Type u_1} [CommMonoidWithZero R]
      {q d : ℕ} (χ : DirichletCharacter R q)
      (ψ : DirichletCharacter R d)
      [NeZero q] :
      χ.IsInducedBy ψ ↔
        ∃ (h : d ∣ q),
          (DirichletCharacter.changeLevel h)
              ψ =
            χ
    **A character is induced by `ψ` if and only if it is `changeLevel` of `ψ`.** 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/Induced.lean
    complete
    theorem DirichletCharacter.isPrimitive_iff_forall_isInducedBy.{u_1}
      {R : Type u_1} [CommMonoidWithZero R] {q : ℕ}
      (χ : DirichletCharacter R q) [NeZero q] :
      χ.IsPrimitive ↔
        ∀ (x : (d : ℕ) × DirichletCharacter R d),
          χ.IsInducedBy x.snd → x = ⟨q, χ⟩
    theorem DirichletCharacter.isPrimitive_iff_forall_isInducedBy.{u_1}
      {R : Type u_1} [CommMonoidWithZero R]
      {q : ℕ} (χ : DirichletCharacter R q)
      [NeZero q] :
      χ.IsPrimitive ↔
        ∀
          (x :
            (d : ℕ) × DirichletCharacter R d),
          χ.IsInducedBy x.snd → x = ⟨q, χ⟩
    **A Dirichlet character of modulus `q ≥ 1` is primitive if and only if it is induced by no
    character other than itself.** 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/Induced.lean
    complete
    theorem DirichletCharacter.isPrimitive_and_isInducedBy_iff.{u_1} {R : Type u_1}
      [CommMonoidWithZero R] {q : ℕ} (χ : DirichletCharacter R q) [NeZero q]
      (x : (d : ℕ) × DirichletCharacter R d) :
      x.snd.IsPrimitive ∧ χ.IsInducedBy x.snd ↔
        x = ⟨χ.conductor, χ.primitiveCharacter⟩
    theorem DirichletCharacter.isPrimitive_and_isInducedBy_iff.{u_1}
      {R : Type u_1} [CommMonoidWithZero R]
      {q : ℕ} (χ : DirichletCharacter R q)
      [NeZero q]
      (x : (d : ℕ) × DirichletCharacter R d) :
      x.snd.IsPrimitive ∧
          χ.IsInducedBy x.snd ↔
        x =
          ⟨χ.conductor, χ.primitiveCharacter⟩
    **Every Dirichlet character of modulus `q ≥ 1` is induced by a unique primitive character**,
    the primitive character `χ.primitiveCharacter` of modulus the conductor of `χ`. 
  • defdefined in Mathlib/NumberTheory/DirichletCharacter/Basic.lean
    complete
    def DirichletCharacter.primitiveCharacter.{u_1} {R : Type u_1}
      [CommMonoidWithZero R] {n : ℕ} (χ : DirichletCharacter R n) :
      DirichletCharacter R χ.conductor
    def DirichletCharacter.primitiveCharacter.{u_1}
      {R : Type u_1} [CommMonoidWithZero R]
      {n : ℕ} (χ : DirichletCharacter R n) :
      DirichletCharacter R χ.conductor
    The primitive character associated to a Dirichlet character. 
Definition6.1.21
uses 1used by 0✓L∃∀N

Jacobi sum. (LMFDB)

Given two Dirichlet characters \chi and \psi modulo q, the Jacobi sum associated to these characters is given by J(\chi,\psi) = \sum_{r \,\in\, \mathbb{Z}/q\mathbb{Z}} \chi(r)\, \psi(1-r).

Tau Ceti Review: jacobiSum.

Depends on: Definition 6.1.1

Lean code for Definition6.1.21●1 definition
  • defdefined in Mathlib/NumberTheory/JacobiSum/Basic.lean
    complete
    def jacobiSum.{u_1, u_2} {R : Type u_1} {R' : Type u_2} [CommRing R]
      [Fintype R] [CommRing R'] (χ ψ : MulChar R R') : R'
    def jacobiSum.{u_1, u_2} {R : Type u_1}
      {R' : Type u_2} [CommRing R] [Fintype R]
      [CommRing R'] (χ ψ : MulChar R R') : R'
    The *Jacobi sum* of two multiplicative characters on a finite commutative ring. 
Definition6.1.22
uses 1used by 1✓L∃∀N

Jacobi symbol. (LMFDB)

The Jacobi symbol \displaystyle\left(\frac{a}{b}\right) is an extension of the Legendre symbol to all positive odd integers b as follows.

We set \displaystyle\left(\frac{a}{1}\right) =1 for all a.

If b>1, then it has a decomposition into distinct *odd* primes of the form b = p_1^{e_1} p_2^{e_2}\cdots p_r^{e_r} and the Jacobi symbol is defined as the product of Legendre symbols

\displaystyle\left(\frac{a}{b}\right) = \left(\frac{a}{p_1}\right)^{e_1} \left(\frac{a}{p_2}\right)^{e_2}\cdots \left(\frac{a}{p_r}\right)^{e_r}.

The Jacobi symbol is multiplicative in the sense that \displaystyle\left(\frac{a_1 a_2}{b}\right) = \displaystyle\left(\frac{a_1}{b}\right)\displaystyle\left(\frac{a_2}{b}\right) and \displaystyle\left(\frac{a}{b_1b_2}\right) = \displaystyle\left(\frac{a}{b_1}\right)\displaystyle\left(\frac{a}{b_2}\right) for all integers a, a_1, a_2 and all positive odd integers b, b_1, b_2.

It has the same special formulas for a=-1 and a = 2 as the Legendre symbol, namely

\left(\displaystyle \frac{-1}{b}\right)= (-1)^{\frac{b-1}{2}} = \left\{ \begin{array}{cl} 1 & \text{if } b \equiv 1 \bmod 4 \\ -1 & \text{if } b \equiv -1 \bmod 4 \end{array} \right. and \left(\displaystyle \frac{2}{b}\right) = (-1)^{\frac{b^2-1}{8}}=\left\{ \begin{array}{cl} 1 & \text{if } b \equiv \pm1 \bmod 8 \\ -1 & \text{if } b \equiv \pm3 \bmod 8 \end{array} \right..

The law of quadratic reciprocity states that for m,n odd positive coprime integers we have

\left(\displaystyle\frac{n}{m}\right) = (-1)^{\frac{m-1}2 \frac{n-1}2} \left(\displaystyle \frac{m}{n}\right).

Tau Ceti Review: jacobiSym, jacobiSym.quadratic_reciprocity, jacobiSym.at_neg_one, jacobiSym.at_two.

Depends on: Definition 6.1.25

Lean code for Definition6.1.22●4 declarations
  • defdefined in Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean
    complete
    def jacobiSym (a : ℤ) (b : ℕ) : ℤ
    def jacobiSym (a : ℤ) (b : ℕ) : ℤ
    The Jacobi symbol of `a` and `b` 
  • theoremdefined in Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean
    complete
    theorem jacobiSym.quadratic_reciprocity {a b : ℕ} (ha : Odd a) (hb : Odd b) :
      jacobiSym (↑a) b = (-1) ^ (a / 2 * (b / 2)) * jacobiSym (↑b) a
    theorem jacobiSym.quadratic_reciprocity {a b : ℕ}
      (ha : Odd a) (hb : Odd b) :
      jacobiSym (↑a) b =
        (-1) ^ (a / 2 * (b / 2)) *
          jacobiSym (↑b) a
    The Law of Quadratic Reciprocity for the Jacobi symbol 
  • theoremdefined in Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean
    complete
    theorem jacobiSym.at_neg_one {b : ℕ} (hb : Odd b) :
      jacobiSym (-1) b = ZMod.χ₄ ↑b
    theorem jacobiSym.at_neg_one {b : ℕ}
      (hb : Odd b) :
      jacobiSym (-1) b = ZMod.χ₄ ↑b
    If `b` is odd, then `J(-1 | b)` is given by `χ₄ b`. 
  • theoremdefined in Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean
    complete
    theorem jacobiSym.at_two {b : ℕ} (hb : Odd b) : jacobiSym 2 b = ZMod.χ₈ ↑b
    theorem jacobiSym.at_two {b : ℕ} (hb : Odd b) :
      jacobiSym 2 b = ZMod.χ₈ ↑b
    If `b` is odd, then `J(2 | b)` is given by `χ₈ b`. 
Definition6.1.23
Statement uses 2
Statement dependency previews
Preview
Definition 6.1.1
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0✓L∃∀N

Kloosterman sum. (LMFDB)

Let \chi be a Dirichlet character with modulus q. The Kloosterman sum K(a,b,\chi) is defined by

K(a,b,\chi) = \sum_{r \in (\mathbb{Z}/q\mathbb{Z})^\times} \chi(r)\zeta^{ar+br^{-1}},

where \zeta = e^{2\pi i/q}. This reduces to the Gauss sum if b=0.

Tau Ceti Review: ZMod.stdAddChar, gaussSum.

Depends on: Definition 6.1.1 Definition 6.1.15

Lean code for Definition6.1.23●5 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/KloostermanSum.lean
    complete
    def kloostermanSum.{u_1, u_2} {R : Type u_1} {R' : Type u_2} [CommRing R]
      [Fintype R] [DecidableEq R] [CommRing R'] (χ : MulChar R R')
      (ψ : AddChar R R') (a b : R) : R'
    def kloostermanSum.{u_1, u_2} {R : Type u_1}
      {R' : Type u_2} [CommRing R] [Fintype R]
      [DecidableEq R] [CommRing R']
      (χ : MulChar R R') (ψ : AddChar R R')
      (a b : R) : R'
    The **Kloosterman sum** `∑_{r ∈ Rˣ} χ(r) ψ(a r + b r⁻¹)` of a multiplicative character `χ` and
    an additive character `ψ` of a finite commutative ring `R` at `a, b ∈ R`. For a Dirichlet character
    `χ` of modulus `q` and the standard additive character `ZMod.stdAddChar` of `ZMod q`, it is the
    **Kloosterman sum** `K(a, b, χ) = ∑_{r ∈ (ℤ/qℤ)ˣ} χ(r) ζ ^ (a r + b r⁻¹)` (LMFDB
    `character.dirichlet.kloosterman_sum`), where `ζ = exp (2 π i / q)`
    (`DirichletCharacter.kloostermanSum_stdAddChar`). The LMFDB takes `a` and `b` in `ℤ`; the sum only
    depends on their residues modulo `q`, which are its arguments here. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/KloostermanSum.lean
    complete
    theorem DirichletCharacter.kloostermanSum_stdAddChar {q : ℕ} [NeZero q]
      (χ : DirichletCharacter ℂ q) (a b : ZMod q) :
      kloostermanSum χ ZMod.stdAddChar a b =
        ∑ r,
          χ ↑r *
            Complex.exp (2 * ↑Real.pi * Complex.I / ↑q) ^
              (a * ↑r + b * ↑r⁻¹).val
    theorem DirichletCharacter.kloostermanSum_stdAddChar
      {q : ℕ} [NeZero q]
      (χ : DirichletCharacter ℂ q)
      (a b : ZMod q) :
      kloostermanSum χ ZMod.stdAddChar a b =
        ∑ r,
          χ ↑r *
            Complex.exp
                (2 * ↑Real.pi * Complex.I /
                  ↑q) ^
              (a * ↑r + b * ↑r⁻¹).val
    For a Dirichlet character `χ` of modulus `q`, the Kloosterman sum with the standard additive
    character is `K(a, b, χ) = ∑_{r ∈ (ℤ/qℤ)ˣ} χ(r) ζ ^ (a r + b r⁻¹)`, where `ζ = exp (2 π i / q)` and
    the exponent is the residue `a r + b r⁻¹` modulo `q`, represented in `[0, q)`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/KloostermanSum.lean
    complete
    theorem kloostermanSum_zero_right.{u_1, u_2} {R : Type u_1} {R' : Type u_2}
      [CommRing R] [Fintype R] [DecidableEq R] [CommRing R']
      (χ : MulChar R R') (ψ : AddChar R R') (a : R) :
      kloostermanSum χ ψ a 0 = gaussSum χ (ψ.mulShift a)
    theorem kloostermanSum_zero_right.{u_1, u_2}
      {R : Type u_1} {R' : Type u_2}
      [CommRing R] [Fintype R] [DecidableEq R]
      [CommRing R'] (χ : MulChar R R')
      (ψ : AddChar R R') (a : R) :
      kloostermanSum χ ψ a 0 =
        gaussSum χ (ψ.mulShift a)
    The Kloosterman sum at `b = 0` is the Gauss sum of `χ` and `ψ.mulShift a`. 
  • defdefined in Mathlib/Analysis/SpecialFunctions/Complex/CircleAddChar.lean
    complete
    def ZMod.stdAddChar {N : ℕ} [NeZero N] : AddChar (ZMod N) ℂ
    def ZMod.stdAddChar {N : ℕ} [NeZero N] :
      AddChar (ZMod N) ℂ
    The additive character from `ZMod N` to `ℂ`, sending `j mod N` to `exp (2 * π * I * j / N)`. 
  • defdefined in Mathlib/NumberTheory/GaussSum.lean
    complete
    def gaussSum.{u, v} {R : Type u} [CommRing R] [Fintype R] {R' : Type v}
      [CommRing R'] (χ : MulChar R R') (ψ : AddChar R R') : R'
    def gaussSum.{u, v} {R : Type u} [CommRing R]
      [Fintype R] {R' : Type v} [CommRing R']
      (χ : MulChar R R') (ψ : AddChar R R') :
      R'
    Definition of the Gauss sum associated to a multiplicative and an additive character. 
Definition6.1.24
Statement uses 3
Statement dependency previews
Preview
Definition 6.1.22
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 1XL∃∀N

Kronecker symbol. (LMFDB)

The Kronecker symbol \displaystyle\left(\frac{a}{n}\right) is the multiplicative extension of the Jacobi symbol \displaystyle\left(\frac{a}{m}\right), which is defined on all positive odd integers m, to all integers n\in\mathbb{Z} as follows.

We set

\displaystyle\left(\frac{a}{-1}\right) = \left\{ \begin{array}{cl} 1 & \text{if } a\geq 0\\ -1 & \text{if } a < 0; \end{array} \right.

\displaystyle\left(\frac{a}{2}\right) = \left\{ \begin{array}{cl} 0 & \text{if } a\equiv 0 \bmod 2\\ 1 & \text{if } a\equiv \pm 1 \bmod 8\\ -1 & \text{if } a \equiv \pm 3 \bmod 8; \end{array} \right.

and

\displaystyle\left(\frac{a}{0}\right) = \left\{ \begin{array}{cl} 1 & \text{if } a= \pm 1\\ 0 & \text{otherwise }. \end{array} \right.

Then for each nonzero integer n = \sgn(n) p_1^{e_1} p_2^{e_2} \cdots p_r^{e_r} the Kronecker symbol is defined as the product of symbols above and the Legendre symbols for odd primes

\displaystyle\left(\frac{a}{n}\right) = \displaystyle\left(\frac{a}{\sgn(n)}\right) \displaystyle\left(\frac{a}{p_1}\right)^{e_1} \displaystyle\left(\frac{a}{p_2}\right)^{e_2}\cdots \displaystyle\left(\frac{a}{p_r}\right)^{e_r}.

A Dirichlet character can be written as a Kronecker symbol \displaystyle\left(\frac{a}{\cdot}\right) if and only if it is real.

Depends on: Definition 6.1.22 Definition 6.1.25 Definition 6.1.32

Definition6.1.25
uses 1
Used by 2
Reverse dependency previews
Preview
Definition 6.1.22
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Legendre symbol. (LMFDB)

Let x be an integer and p be an odd prime. The Legendre symbol \displaystyle\left(\frac{x}{p}\right) is defined to be

\left( \frac{x}{p} \right) = \left\{ \begin{array}{cl} 0 & \text{if } p \mid x, \\ 1 & \text{if } x \bmod p \text{ is a non-zero square in } \Z/p\Z, \\ -1 & \text{if } x \bmod p \text{ is not a square in } \Z/p\Z. \end{array} \right.

It can be computed efficiently by using the following formulae inductively:

  • (Multiplicativity) \left(\frac{ab}{p}\right) = \left(\frac{a}{p}\right) \left(\frac{b}{p}\right).

  • (Special cases) \left(\frac{-1}{p}\right)= \left\{ \begin{array}{cl} 1 & \text{if } p \equiv 1 \bmod 4 \\ -1 & \text{if } p \equiv -1 \bmod 4 \end{array} \right. and \left(\frac{2}{p}\right)=\left\{ \begin{array}{cl} 1 & \text{if } p \equiv \pm1 \bmod 8 \\ -1 & \text{if } p \equiv \pm3 \bmod 8 \end{array} \right..

  • (Quadratic reciprocity) If p and q are distinct odd primes, then \left(\frac{q}{p}\right) = (-1)^{\frac{p-1}2 \frac{q-1}2} \left(\frac{p}{q}\right).

In particular, for a fixed odd prime p, x \mapsto \left(\frac{x}{p}\right) is a Dirichlet character modulo p.

Tau Ceti Review: legendreSym, quadraticChar, legendreSym.at_neg_one, legendreSym.at_two.

Depends on: Definition 6.1.1

Lean code for Definition6.1.25●5 declarations
  • defdefined in Mathlib/NumberTheory/LegendreSymbol/Basic.lean
    complete
    def legendreSym (p : ℕ) [Fact (Nat.Prime p)] (a : ℤ) : ℤ
    def legendreSym (p : ℕ) [Fact (Nat.Prime p)]
      (a : ℤ) : ℤ
    The Legendre symbol of `a : ℤ` and a prime `p`, `legendreSym p a`,
    is an integer defined as
    
    * `0` if `a` is `0` modulo `p`;
    * `1` if `a` is a nonzero square modulo `p`
    * `-1` otherwise.
    
    Note the order of the arguments! The advantage of the order chosen here is
    that `legendreSym p` is a multiplicative function `ℤ → ℤ`.
    
  • defdefined in Mathlib/NumberTheory/LegendreSymbol/QuadraticChar/Basic.lean
    complete
    def quadraticChar.{u_1} (F : Type u_1) [Field F] [Fintype F]
      [DecidableEq F] : MulChar F ℤ
    def quadraticChar.{u_1} (F : Type u_1)
      [Field F] [Fintype F] [DecidableEq F] :
      MulChar F ℤ
    The quadratic character as a multiplicative character. 
  • theoremdefined in Mathlib/NumberTheory/LegendreSymbol/QuadraticReciprocity.lean
    complete
    theorem legendreSym.quadratic_reciprocity {p q : ℕ} [Fact (Nat.Prime p)]
      [Fact (Nat.Prime q)] (hp : p ≠ 2) (hq : q ≠ 2) (hpq : p ≠ q) :
      legendreSym q ↑p * legendreSym p ↑q = (-1) ^ (p / 2 * (q / 2))
    theorem legendreSym.quadratic_reciprocity
      {p q : ℕ} [Fact (Nat.Prime p)]
      [Fact (Nat.Prime q)] (hp : p ≠ 2)
      (hq : q ≠ 2) (hpq : p ≠ q) :
      legendreSym q ↑p * legendreSym p ↑q =
        (-1) ^ (p / 2 * (q / 2))
    **The Law of Quadratic Reciprocity**: if `p` and `q` are distinct odd primes, then
    `(q / p) * (p / q) = (-1)^((p-1)(q-1)/4)`. 
  • theoremdefined in Mathlib/NumberTheory/LegendreSymbol/Basic.lean
    complete
    theorem legendreSym.at_neg_one {p : ℕ} [Fact (Nat.Prime p)] (hp : p ≠ 2) :
      legendreSym p (-1) = ZMod.χ₄ ↑p
    theorem legendreSym.at_neg_one {p : ℕ}
      [Fact (Nat.Prime p)] (hp : p ≠ 2) :
      legendreSym p (-1) = ZMod.χ₄ ↑p
    `legendreSym p (-1)` is given by `χ₄ p`. 
  • theoremdefined in Mathlib/NumberTheory/LegendreSymbol/QuadraticReciprocity.lean
    complete
    theorem legendreSym.at_two {p : ℕ} [Fact (Nat.Prime p)] (hp : p ≠ 2) :
      legendreSym p 2 = ZMod.χ₈ ↑p
    theorem legendreSym.at_two {p : ℕ}
      [Fact (Nat.Prime p)] (hp : p ≠ 2) :
      legendreSym p 2 = ZMod.χ₈ ↑p
    `legendreSym p 2` is given by `χ₈ p`. 
Definition6.1.26
Statement uses 6
Statement dependency previews
Preview
Definition 6.1.1
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 2
Reverse dependency previews
Preview
Definition 3.1.61
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Minimal Dirichlet character. (LMFDB)

A Dirichlet character \chi of prime power modulus N is minimal if the following conditions both hold:

  1. The conductor of \chi does not lie in the open interval (\sqrt{N},N), and if N is a square divisible by 16 then {\rm cond}(\chi)\in \{\sqrt{N},N\}.

  2. Both the order and conductor of \chi are minimal among the set of all Dirichlet character \chi\psi^2 for which {\rm cond}(\psi){\rm cond}(\chi\psi) | N.

This includes all primitive Dirichlet characters of prime power modulus, but not every minimal Dirichlet character of prime power modulus is primitive.

For a composite modulus N with prime power factorization N=p_1^{e_1}\cdots p_n^{e_n}, a Dirichlet character \chi of modulus N is minimal if and only if every character in its unique factorization into Dirichlet characters of modulus p_1^{e_1},\cdots,p_n^{e_n} is minimal. The trivial Dirichlet character is minimal.

Tau Ceti Review: TauCeti.Nat.IsExactDivisor.eq_mul_comp_unitsMap.

Depends on: Definition 6.1.1 Definition 6.1.2 Definition 6.1.27 Definition 6.1.28 Definition 6.1.30 Definition 6.1.31

Lean code for Definition6.1.26●8 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/Minimal.lean
    complete
    def DirichletCharacter.IsMinimalOfPrimePowerModulus {N : ℕ}
      (χ : DirichletCharacter ℂ N) : Prop
    def DirichletCharacter.IsMinimalOfPrimePowerModulus
      {N : ℕ} (χ : DirichletCharacter ℂ N) :
      Prop
    A complex Dirichlet character `χ` of prime power modulus `N` is **minimal** (LMFDB
    `character.dirichlet.minimal`) if
    1. its conductor does not lie in the open interval `(√N, N)`, and if `N` is a square divisible by
       `16` then its conductor is `√N` or `N`;
    2. both its order and its conductor are minimal among the characters `χψ²`, for `ψ` running over
       the characters modulo `N` with `cond(ψ) cond(χψ) ∣ N`.
    
    We read the second condition as saying that neither the order nor the conductor of `χ` exceeds
    that of such a `χψ²` (`χ` itself is one of them, for `ψ = 1`). The conditions are stated for every
    modulus `N`; the LMFDB uses them for prime powers. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/Minimal.lean
    complete
    def DirichletCharacter.IsMinimal {N : ℕ} (χ : DirichletCharacter ℂ N) : Prop
    def DirichletCharacter.IsMinimal {N : ℕ}
      (χ : DirichletCharacter ℂ N) : Prop
    A complex Dirichlet character `χ` modulo `N` is **minimal** (LMFDB
    `character.dirichlet.minimal`) if every character in its factorization into characters of prime
    power moduli `p ^ v_p(N)`, its `p`-parts for the primes `p ∣ N`, is minimal. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/Minimal.lean
    complete
    def DirichletCharacter.primePowerPart.{u_1} {R : Type u_1}
      [CommMonoidWithZero R] {N : ℕ} (p : ℕ) (ψ : DirichletCharacter R N) :
      DirichletCharacter R (p ^ N.factorization p)
    def DirichletCharacter.primePowerPart.{u_1}
      {R : Type u_1} [CommMonoidWithZero R]
      {N : ℕ} (p : ℕ)
      (ψ : DirichletCharacter R N) :
      DirichletCharacter R
        (p ^ N.factorization p)
    The **`p`-part** of a Dirichlet character `ψ` modulo `N`: the character modulo the exact prime
    power divisor `p ^ v_p(N)` of `N` that sends `u` to `ψ û`, where `û ≡ u` modulo `p ^ v_p(N)` and
    `û ≡ 1` modulo `N / p ^ v_p(N)`. The `p`-parts of `ψ`, for `p` dividing `N`, are the characters of
    prime power modulus into which `ψ` factors uniquely
    (`TauCeti.Nat.IsExactDivisor.eq_mul_comp_unitsMap`). 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/Minimal.lean
    complete
    theorem DirichletCharacter.IsPrimitive.isMinimalOfPrimePowerModulus {N : ℕ}
      {χ : DirichletCharacter ℂ N} (hN : IsPrimePow N)
      (hχ : χ.IsPrimitive) : χ.IsMinimalOfPrimePowerModulus
    theorem DirichletCharacter.IsPrimitive.isMinimalOfPrimePowerModulus
      {N : ℕ} {χ : DirichletCharacter ℂ N}
      (hN : IsPrimePow N)
      (hχ : χ.IsPrimitive) :
      χ.IsMinimalOfPrimePowerModulus
    A primitive Dirichlet character of prime power modulus is minimal. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/MinimalTrivial.lean
    complete
    theorem DirichletCharacter.not_forall_isPrimitive_of_isMinimalOfPrimePowerModulus :
      ¬∀ (N : ℕ),
          IsPrimePow N →
            ∀ (χ : DirichletCharacter ℂ N),
              χ.IsMinimalOfPrimePowerModulus → χ.IsPrimitive
    theorem DirichletCharacter.not_forall_isPrimitive_of_isMinimalOfPrimePowerModulus :
      ¬∀ (N : ℕ),
          IsPrimePow N →
            ∀ (χ : DirichletCharacter ℂ N),
              χ.IsMinimalOfPrimePowerModulus →
                χ.IsPrimitive
    **Not every minimal Dirichlet character of prime power modulus is primitive** (LMFDB
    `character.dirichlet.minimal`): the trivial character modulo `3` is minimal, `3` not being a square
    divisible by `16` (`DirichletCharacter.isMinimalOfPrimePowerModulus_one_iff`), but its conductor is
    `1`, not `3`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/MinimalTrivial.lean
    complete
    theorem DirichletCharacter.isMinimal_one_iff {N : ℕ} :
      DirichletCharacter.IsMinimal 1 ↔
        ¬(2 ∣ N.factorization 2 ∧ 4 ≤ N.factorization 2)
    theorem DirichletCharacter.isMinimal_one_iff
      {N : ℕ} :
      DirichletCharacter.IsMinimal 1 ↔
        ¬(2 ∣ N.factorization 2 ∧
            4 ≤ N.factorization 2)
    **The trivial character modulo `N` is minimal exactly when `2 ^ e ∥ N` with `e` odd or
    `e < 4`** (LMFDB `character.dirichlet.minimal`). The knowl's claim that the trivial character is
    minimal fails for the `N` whose largest power of `2` dividing it is `2 ^ e` with `e ≥ 4` even, such
    as `N = 16`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/Minimal.lean
    complete
    theorem DirichletCharacter.isMinimalOfPrimePowerModulus_one_iff {N : ℕ}
      [NeZero N] :
      DirichletCharacter.IsMinimalOfPrimePowerModulus 1 ↔
        ¬(IsSquare N ∧ 16 ∣ N)
    theorem DirichletCharacter.isMinimalOfPrimePowerModulus_one_iff
      {N : ℕ} [NeZero N] :
      DirichletCharacter.IsMinimalOfPrimePowerModulus
          1 ↔
        ¬(IsSquare N ∧ 16 ∣ N)
    The trivial character modulo `N` satisfies the conditions for minimality of a character of prime
    power modulus exactly when `N` is not a square divisible by `16`: the LMFDB's claim that the
    trivial character is minimal fails for the moduli `2 ^ e` with `e ≥ 4` even. 
  • theoremdefined in TauCeti/Data/ZMod/ExactDivisor.lean
    complete
    theorem TauCeti.Nat.IsExactDivisor.eq_mul_comp_unitsMap.{u_1} {N Q : ℕ}
      {G : Type u_1} [CommMonoid G] (h : TauCeti.Nat.IsExactDivisor Q N)
      (χ : (ZMod N)ˣ →* G) :
      χ =
        ((χ.comp h.unitsEquivProd.symm.toMonoidHom).comp
                (MonoidHom.inl (ZMod Q)ˣ (ZMod (N / Q))ˣ)).comp
            (ZMod.unitsMap ⋯) *
          ((χ.comp h.unitsEquivProd.symm.toMonoidHom).comp
                (MonoidHom.inr (ZMod Q)ˣ (ZMod (N / Q))ˣ)).comp
            (ZMod.unitsMap ⋯)
    theorem TauCeti.Nat.IsExactDivisor.eq_mul_comp_unitsMap.{u_1}
      {N Q : ℕ} {G : Type u_1} [CommMonoid G]
      (h : TauCeti.Nat.IsExactDivisor Q N)
      (χ : (ZMod N)ˣ →* G) :
      χ =
        ((χ.comp
                    h.unitsEquivProd.symm.toMonoidHom).comp
                (MonoidHom.inl (ZMod Q)ˣ
                  (ZMod (N / Q))ˣ)).comp
            (ZMod.unitsMap ⋯) *
          ((χ.comp
                    h.unitsEquivProd.symm.toMonoidHom).comp
                (MonoidHom.inr (ZMod Q)ˣ
                  (ZMod (N / Q))ˣ)).comp
            (ZMod.unitsMap ⋯)
    A character modulo `N` splits as the product of its restrictions to the Chinese
    remainder factors modulo `Q` and `N / Q`. 
Definition6.1.27
uses 0
Used by 20
Reverse dependency previews
Preview
Definition 3.1.32
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Modulus of a Dirichlet character. (LMFDB)

A Dirichlet character is a function \chi: \mathbb{Z}\to \mathbb{C} together with a positive integer q, called the modulus of the character, such that \chi is completely multiplicative, i.e. \chi(mn)=\chi(m)\chi(n) for all integers m and n, and \chi is periodic modulo q, i.e. \chi(n+q)=\chi(n) for all n. If (n,q)>1 then \chi(n)=0, whereas if (n,q)=1, then \chi(n) is a root of unity.

Tau Ceti Review: DirichletCharacter, MulChar, DirichletCharacter.apply_eq_zero_iff.

Lean code for Definition6.1.27●4 declarations
  • abbrevdefined in Mathlib/NumberTheory/DirichletCharacter/Basic.lean
    complete
    abbrev DirichletCharacter.{u_1} (R : Type u_1) [CommMonoidWithZero R] (n : ℕ) :
      Type u_1
    abbrev DirichletCharacter.{u_1} (R : Type u_1)
      [CommMonoidWithZero R] (n : ℕ) :
      Type u_1
    The type of Dirichlet characters of level `n`. 
  • structure(extends 3, 4 fields)defined in Mathlib/NumberTheory/MulChar/Basic.lean
    complete
    structure MulChar.{u_1, u_2} (R : Type u_1) [CommMonoid R] (R' : Type u_2)
      [CommMonoidWithZero R'] : Type (max u_1 u_2)
    structure MulChar.{u_1, u_2} (R : Type u_1)
      [CommMonoid R] (R' : Type u_2)
      [CommMonoidWithZero R'] :
      Type (max u_1 u_2)
    Define a structure for multiplicative characters.
    A multiplicative character from a commutative monoid `R` to a commutative monoid with zero `R'`
    is a homomorphism of (multiplicative) monoids that sends non-units to zero. 
    • R →* R'
    toFun : R → R'
    Inherited from
    1. MonoidHom
    2. OneHom
    map_one' : (↑self.toMonoidHom).toFun 1 = 1
    Inherited from
    1. MonoidHom
    2. OneHom
    map_mul' : ∀ (x y : R), (↑self.toMonoidHom).toFun (x * y) = (↑self.toMonoidHom).toFun x * (↑self.toMonoidHom).toFun y
    Inherited from
    1. MonoidHom
    map_nonunit' : ∀ (a : R), ¬IsUnit a → (↑self.toMonoidHom).toFun a = 0
  • theoremdefined in Mathlib/NumberTheory/DirichletCharacter/Basic.lean
    complete
    theorem DirichletCharacter.apply_eq_zero_iff.{u_1} {R : Type u_1}
      [CommMonoidWithZero R] {n : ℕ} (χ : DirichletCharacter R n)
      [Nontrivial R] (a : ℤ) : χ ↑a = 0 ↔ ¬IsCoprime a ↑n
    theorem DirichletCharacter.apply_eq_zero_iff.{u_1}
      {R : Type u_1} [CommMonoidWithZero R]
      {n : ℕ} (χ : DirichletCharacter R n)
      [Nontrivial R] (a : ℤ) :
      χ ↑a = 0 ↔ ¬IsCoprime a ↑n
  • theoremdefined in Mathlib/NumberTheory/MulChar/Lemmas.lean
    complete
    theorem MulChar.apply_mem_rootsOfUnity.{u_1, u_2} {R : Type u_1} {R' : Type u_2}
      [CommRing R] [CommRing R'] [Fintype Rˣ] (a : Rˣ) {χ : MulChar R R'} :
      (MulChar.equivToUnitHom χ) a ∈ rootsOfUnity (Fintype.card Rˣ) R'
    theorem MulChar.apply_mem_rootsOfUnity.{u_1, u_2}
      {R : Type u_1} {R' : Type u_2}
      [CommRing R] [CommRing R'] [Fintype Rˣ]
      (a : Rˣ) {χ : MulChar R R'} :
      (MulChar.equivToUnitHom χ) a ∈
        rootsOfUnity (Fintype.card Rˣ) R'
    The values of a multiplicative character on `R` are `n`th roots of unity, where `n = #Rˣ`. 
Definition6.1.28
Statement uses 3
Statement dependency previews
Preview
Definition 6.1.1
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 10
Reverse dependency previews
Preview
Definition 3.1.84
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Order of a Dirichlet character. (LMFDB)

The order of a Dirichlet character \chi is the least positive integer n such that \chi^n is the trivial character of the same modulus as \chi. Equivalently, it is the order n of the image of \chi in \mathbb{C}^\times, the group of nth roots of unity.

Tau Ceti Review: orderOf, MulChar.toUnitHom, rootsOfUnity.

Depends on: Definition 6.1.1 Definition 6.1.27 Definition 6.1.31

Lean code for Definition6.1.28●6 declarations
  • defdefined in Mathlib/GroupTheory/OrderOfElement.lean
    complete
    def orderOf.{u_1} {G : Type u_1} [Monoid G] (x : G) : ℕ
    def orderOf.{u_1} {G : Type u_1} [Monoid G]
      (x : G) : ℕ
    `orderOf x` is the order of the element `x`, i.e. the `n ≥ 1`, s.t. `x ^ n = 1` if it exists.
    Otherwise, i.e. if `x` is of infinite order, then `orderOf x` is `0` by convention. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/MulChar/Order.lean
    complete
    theorem MulChar.isLeast_orderOf.{u_1, u_2} {M : Type u_1} {R : Type u_2}
      [CommMonoid M] [CommRing R] (χ : MulChar M R) [Finite Mˣ] :
      IsLeast {n | 0 < n ∧ χ ^ n = 1} (orderOf χ)
    theorem MulChar.isLeast_orderOf.{u_1, u_2}
      {M : Type u_1} {R : Type u_2}
      [CommMonoid M] [CommRing R]
      (χ : MulChar M R) [Finite Mˣ] :
      IsLeast {n | 0 < n ∧ χ ^ n = 1}
        (orderOf χ)
    **The order of a character is the least positive integer `n` such that `χ ^ n` is the trivial
    character.** 
  • defdefined in Mathlib/NumberTheory/MulChar/Basic.lean
    complete
    def MulChar.toUnitHom.{u_1, u_2} {R : Type u_1} [CommMonoid R]
      {R' : Type u_2} [CommMonoidWithZero R'] (χ : MulChar R R') : Rˣ →* R'ˣ
    def MulChar.toUnitHom.{u_1, u_2}
      {R : Type u_1} [CommMonoid R]
      {R' : Type u_2} [CommMonoidWithZero R']
      (χ : MulChar R R') : Rˣ →* R'ˣ
    Turn a `MulChar` into a homomorphism between the unit groups. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/MulChar/Order.lean
    complete
    theorem MulChar.range_toUnitHom_eq_rootsOfUnity.{u_1, u_2} {M : Type u_1}
      {R : Type u_2} [CommMonoid M] [CommRing R] (χ : MulChar M R)
      [Finite Mˣ] [IsDomain R] :
      χ.toUnitHom.range = rootsOfUnity (orderOf χ) R
    theorem MulChar.range_toUnitHom_eq_rootsOfUnity.{u_1,
        u_2}
      {M : Type u_1} {R : Type u_2}
      [CommMonoid M] [CommRing R]
      (χ : MulChar M R) [Finite Mˣ]
      [IsDomain R] :
      χ.toUnitHom.range =
        rootsOfUnity (orderOf χ) R
    **The image of a character on units is the group of `n`-th roots of unity**, `n` being the
    order of the character. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/MulChar/Order.lean
    complete
    theorem MulChar.card_range_toUnitHom.{u_1, u_2} {M : Type u_1} {R : Type u_2}
      [CommMonoid M] [CommRing R] (χ : MulChar M R) [Finite Mˣ]
      [IsDomain R] : Nat.card ↥χ.toUnitHom.range = orderOf χ
    theorem MulChar.card_range_toUnitHom.{u_1, u_2}
      {M : Type u_1} {R : Type u_2}
      [CommMonoid M] [CommRing R]
      (χ : MulChar M R) [Finite Mˣ]
      [IsDomain R] :
      Nat.card ↥χ.toUnitHom.range = orderOf χ
    **The image of a character on units has the order of the character.** 
  • defdefined in Mathlib/RingTheory/RootsOfUnity/Basic.lean
    complete
    def rootsOfUnity.{u_7} (k : ℕ) (M : Type u_7) [CommMonoid M] : Subgroup Mˣ
    def rootsOfUnity.{u_7} (k : ℕ) (M : Type u_7)
      [CommMonoid M] : Subgroup Mˣ
    `rootsOfUnity k M` is the subgroup of elements `m : Mˣ` that satisfy `m ^ k = 1`. 
Definition6.1.29
uses 1used by 1✓L∃∀N

Parity of a Dirichlet character. (LMFDB)

A character has odd/even parity if it is odd/even as a function. A Dirichlet character \chi\colon\Z\to\C is odd if \chi(-1) = -1 and even if \chi(-1)=1.

Tau Ceti Review: DirichletCharacter.Even, DirichletCharacter.Odd, DirichletCharacter.even_or_odd.

Depends on: Definition 6.1.1

Lean code for Definition6.1.29●3 declarations
  • defdefined in Mathlib/NumberTheory/DirichletCharacter/Basic.lean
    complete
    def DirichletCharacter.Even.{u_2} {S : Type u_2} [CommRing S] {m : ℕ}
      (ψ : DirichletCharacter S m) : Prop
    def DirichletCharacter.Even.{u_2}
      {S : Type u_2} [CommRing S] {m : ℕ}
      (ψ : DirichletCharacter S m) : Prop
    A Dirichlet character is even if its value at -1 is 1. 
  • defdefined in Mathlib/NumberTheory/DirichletCharacter/Basic.lean
    complete
    def DirichletCharacter.Odd.{u_2} {S : Type u_2} [CommRing S] {m : ℕ}
      (ψ : DirichletCharacter S m) : Prop
    def DirichletCharacter.Odd.{u_2}
      {S : Type u_2} [CommRing S] {m : ℕ}
      (ψ : DirichletCharacter S m) : Prop
    A Dirichlet character is odd if its value at -1 is -1. 
  • theoremdefined in Mathlib/NumberTheory/DirichletCharacter/Basic.lean
    complete
    theorem DirichletCharacter.even_or_odd.{u_2} {S : Type u_2} [CommRing S] {m : ℕ}
      (ψ : DirichletCharacter S m) [NoZeroDivisors S] : ψ.Even ∨ ψ.Odd
    theorem DirichletCharacter.even_or_odd.{u_2}
      {S : Type u_2} [CommRing S] {m : ℕ}
      (ψ : DirichletCharacter S m)
      [NoZeroDivisors S] : ψ.Even ∨ ψ.Odd
Definition6.1.30
Statement uses 4
Statement dependency previews
Preview
Definition 6.1.1
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 13
Reverse dependency previews
Preview
Definition 2.44
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Primitive Dirichlet character. (LMFDB)

A Dirichlet character \chi is primitive if its conductor is equal to its modulus; equivalently, \chi is not induced by a Dirichlet character of smaller modulus.

Tau Ceti Review: DirichletCharacter.IsPrimitive.

Depends on: Definition 6.1.1 Definition 6.1.2 Definition 6.1.20 Definition 6.1.27

Lean code for Definition6.1.30●1 definition
  • defdefined in Mathlib/NumberTheory/DirichletCharacter/Basic.lean
    complete
    def DirichletCharacter.IsPrimitive.{u_1} {R : Type u_1}
      [CommMonoidWithZero R] {n : ℕ} (χ : DirichletCharacter R n) : Prop
    def DirichletCharacter.IsPrimitive.{u_1}
      {R : Type u_1} [CommMonoidWithZero R]
      {n : ℕ} (χ : DirichletCharacter R n) :
      Prop
    A character is primitive if its level is equal to its conductor. 
Definition6.1.31
Statement uses 3
Statement dependency previews
Preview
Definition 6.1.1
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 6
Reverse dependency previews
Preview
Definition 3.1.85
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Principal Dirichlet character. (LMFDB)

A Dirichlet character is principal (or trivial) if it has order 1, equivalently, if it is induced by the unique Dirichlet character of modulus 1.

The value of the principal Dirichlet character of modulus q at an integer n is 1 if n is coprime to q and 0 otherwise.

Depends on: Definition 6.1.1 Definition 6.1.20 Definition 6.1.27

Lean code for Definition6.1.31●3 declarations
  • defdefined in Mathlib/NumberTheory/MulChar/Basic.lean
    complete
    def MulChar.trivial.{u_1, u_2} (R : Type u_1) [CommMonoid R] (R' : Type u_2)
      [CommMonoidWithZero R'] : MulChar R R'
    def MulChar.trivial.{u_1, u_2} (R : Type u_1)
      [CommMonoid R] (R' : Type u_2)
      [CommMonoidWithZero R'] : MulChar R R'
    The trivial multiplicative character. It takes the value `0` on non-units and
    the value `1` on units. 
  • theoremdefined in Mathlib/NumberTheory/MulChar/Basic.lean
    complete
    theorem MulChar.trivial_apply.{u_1, u_2} (R : Type u_1) [CommMonoid R]
      (R' : Type u_2) [CommMonoidWithZero R'] (x : R) :
      (MulChar.trivial R R') x = if IsUnit x then 1 else 0
    theorem MulChar.trivial_apply.{u_1, u_2}
      (R : Type u_1) [CommMonoid R]
      (R' : Type u_2) [CommMonoidWithZero R']
      (x : R) :
      (MulChar.trivial R R') x =
        if IsUnit x then 1 else 0
  • theoremdefined in Mathlib/NumberTheory/DirichletCharacter/Basic.lean
    complete
    theorem DirichletCharacter.factorsThrough_one_iff.{u_1} {R : Type u_1}
      [CommMonoidWithZero R] {n : ℕ} (χ : DirichletCharacter R n) :
      χ.FactorsThrough 1 ↔ χ = 1
    theorem DirichletCharacter.factorsThrough_one_iff.{u_1}
      {R : Type u_1} [CommMonoidWithZero R]
      {n : ℕ} (χ : DirichletCharacter R n) :
      χ.FactorsThrough 1 ↔ χ = 1
Definition6.1.32
uses 0used by 1✓L∃∀N

Real Dirichlet character. (LMFDB)

A character is real if its image is contained in \mathbb{R}.

Tau Ceti Review: MulChar.IsQuadratic, Complex.conj_eq_iff_real.

Lean code for Definition6.1.32●2 declarations
  • defdefined in Mathlib/NumberTheory/MulChar/Basic.lean
    complete
    def MulChar.IsQuadratic.{u_1, u_2} {R : Type u_1} [CommMonoid R]
      {R' : Type u_2} [CommRing R'] (χ : MulChar R R') : Prop
    def MulChar.IsQuadratic.{u_1, u_2}
      {R : Type u_1} [CommMonoid R]
      {R' : Type u_2} [CommRing R']
      (χ : MulChar R R') : Prop
    A multiplicative character is *quadratic* if it takes only the values `0`, `1`, `-1`. 
  • theoremdefined in Mathlib/Basic/Complex/Basic.lean
    complete
    theorem Complex.conj_eq_iff_real {z : ℂ} : (starRingEnd ℂ) z = z ↔ ∃ r, z = ↑r
    theorem Complex.conj_eq_iff_real {z : ℂ} :
      (starRingEnd ℂ) z = z ↔ ∃ r, z = ↑r
Lean code for Definition6.1.33●4 definitions
  • defdefined in TauCeti/NumberTheory/ModularForms/Newforms/Fields.lean
    complete
    def TauCeti.CharacterField {N : ℕ} (χ : (ZMod N)ˣ →* ℂˣ) :
      IntermediateField ℚ ℂ
    def TauCeti.CharacterField {N : ℕ}
      (χ : (ZMod N)ˣ →* ℂˣ) :
      IntermediateField ℚ ℂ
    The subfield of `ℂ` generated over `ℚ` by the values of a nebentypus character. 
  • defdefined in Mathlib/FieldTheory/Galois/Basic.lean
    complete
    def IntermediateField.fixedField.{u_1, u_2} {F : Type u_1} [Field F]
      {E : Type u_2} [Field E] [Algebra F E] (H : Subgroup Gal(E/F)) :
      IntermediateField F E
    def IntermediateField.fixedField.{u_1, u_2}
      {F : Type u_1} [Field F] {E : Type u_2}
      [Field E] [Algebra F E]
      (H : Subgroup Gal(E/F)) :
      IntermediateField F E
    The intermediate field fixed by a subgroup. 
  • defdefined in Mathlib/NumberTheory/NumberField/Cyclotomic/Galois.lean
    complete
    def IsCyclotomicExtension.Rat.intermediateFieldEquivSubgroupChar.{u_1, u_2}
      (n : ℕ) [NeZero n] (K : Type u_1) [Field K] [NumberField K]
      [hK : IsCyclotomicExtension {n} ℚ K] (R : Type u_2) [CommRing R]
      [HasEnoughRootsOfUnity R (Monoid.exponent (ZMod n)ˣ)]
      [IsAbelianGalois ℚ K] :
      IntermediateField ℚ K ≃o Subgroup (DirichletCharacter R n)
    def IsCyclotomicExtension.Rat.intermediateFieldEquivSubgroupChar.{u_1,
        u_2}
      (n : ℕ) [NeZero n] (K : Type u_1)
      [Field K] [NumberField K]
      [hK : IsCyclotomicExtension {n} ℚ K]
      (R : Type u_2) [CommRing R]
      [HasEnoughRootsOfUnity R
          (Monoid.exponent (ZMod n)ˣ)]
      [IsAbelianGalois ℚ K] :
      IntermediateField ℚ K ≃o
        Subgroup (DirichletCharacter R n)
    The bijection between the intermediate fields of `ℚ(ζₙ)/ℚ` and the subgroups of the group
    of Dirichlet characters of level `n`.
    
  • defdefined in Mathlib/FieldTheory/IntermediateField/Adjoin/Defs.lean
    complete
    def IntermediateField.adjoin.{u_1, u_2} (F : Type u_1) [Field F]
      {E : Type u_2} [Field E] [Algebra F E] (S : Set E) :
      IntermediateField F E
    def IntermediateField.adjoin.{u_1, u_2}
      (F : Type u_1) [Field F] {E : Type u_2}
      [Field E] [Algebra F E] (S : Set E) :
      IntermediateField F E
    `adjoin F S` extends a field `F` by adjoining a set `S ⊆ E`. 
Definition6.1.34
uses 1
Used by 5
Reverse dependency previews
Preview
Definition 3.1.34
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Field of values of a Dirichlet character. (LMFDB)

The field of values of a Dirichlet character \chi\colon\Z\to\C is the field \Q(\chi(\Z)) generated by its values; it is equal to the cyclotomic field \Q(\zeta_n), where n is the order of \chi.

Tau Ceti Review: TauCeti.CharacterField, IntermediateField.adjoin.

Depends on: Definition 6.1.28

Lean code for Definition6.1.34●3 declarations
  • defdefined in TauCeti/NumberTheory/ModularForms/Newforms/Fields.lean
    complete
    def TauCeti.CharacterField {N : ℕ} (χ : (ZMod N)ˣ →* ℂˣ) :
      IntermediateField ℚ ℂ
    def TauCeti.CharacterField {N : ℕ}
      (χ : (ZMod N)ˣ →* ℂˣ) :
      IntermediateField ℚ ℂ
    The subfield of `ℂ` generated over `ℚ` by the values of a nebentypus character. 
  • defdefined in Mathlib/FieldTheory/IntermediateField/Adjoin/Defs.lean
    complete
    def IntermediateField.adjoin.{u_1, u_2} (F : Type u_1) [Field F]
      {E : Type u_2} [Field E] [Algebra F E] (S : Set E) :
      IntermediateField F E
    def IntermediateField.adjoin.{u_1, u_2}
      (F : Type u_1) [Field F] {E : Type u_2}
      [Field E] [Algebra F E] (S : Set E) :
      IntermediateField F E
    `adjoin F S` extends a field `F` by adjoining a set `S ⊆ E`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/MulChar/FieldOfValues.lean
    complete
    theorem MulChar.adjoin_range_eq_adjoin_nth_roots.{u_1, u_2} {M : Type u_1}
      {K : Type u_2} [CommMonoid M] [Field K] [CharZero K] (χ : MulChar M K)
      [Finite Mˣ] :
      IntermediateField.adjoin ℚ (Set.range ⇑χ) =
        IntermediateField.adjoin ℚ {b | b ^ orderOf χ = 1}
    theorem MulChar.adjoin_range_eq_adjoin_nth_roots.{u_1,
        u_2}
      {M : Type u_1} {K : Type u_2}
      [CommMonoid M] [Field K] [CharZero K]
      (χ : MulChar M K) [Finite Mˣ] :
      IntermediateField.adjoin ℚ
          (Set.range ⇑χ) =
        IntermediateField.adjoin ℚ
          {b | b ^ orderOf χ = 1}
    **The field of values of a character of order `n` is the field `ℚ(μ_n)`** generated by the
    `n`-th roots of unity, an `n`-th cyclotomic field (Tau Ceti's
    `IsPrimitiveRoot.isCyclotomicExtension_adjoin_nth_roots`). 
Definition6.1.35
Statement uses 2
Statement dependency previews
Preview
Definition 6.1.1
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0✓L∃∀N

Values of a Dirichlet character. (LMFDB)

Complete information about a Dirichlet character \chi\colon \Z\to\C of modulus q > 1 is contained in the list of values (\chi(1)=1,\ \chi(2),\ \chi(3),\ \dots,\ \chi(q-1),\ \chi(q)=0), each of which is a root of unity e(r) := \exp({2 \pi i r}), for some rational number r.

Tau Ceti Review: DirichletCharacter, MulChar.map_one, MulChar.map_nonunit.

Depends on: Definition 6.1.1 Definition 6.1.27

Lean code for Definition6.1.35●7 declarations
  • abbrevdefined in Mathlib/NumberTheory/DirichletCharacter/Basic.lean
    complete
    abbrev DirichletCharacter.{u_1} (R : Type u_1) [CommMonoidWithZero R] (n : ℕ) :
      Type u_1
    abbrev DirichletCharacter.{u_1} (R : Type u_1)
      [CommMonoidWithZero R] (n : ℕ) :
      Type u_1
    The type of Dirichlet characters of level `n`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/ValueList.lean
    complete
    theorem DirichletCharacter.eq_iff_forall_mem_Icc {q : ℕ}
      (χ ψ : DirichletCharacter ℂ q) [NeZero q] :
      χ = ψ ↔ ∀ n ∈ Finset.Icc 1 q, χ ↑n = ψ ↑n
    theorem DirichletCharacter.eq_iff_forall_mem_Icc
      {q : ℕ} (χ ψ : DirichletCharacter ℂ q)
      [NeZero q] :
      χ = ψ ↔
        ∀ n ∈ Finset.Icc 1 q, χ ↑n = ψ ↑n
    **A Dirichlet character of modulus `q` is determined by its list of values
    `χ(1), …, χ(q)`**, as every residue class modulo `q` has a representative in `[1, q]`. 
  • theoremdefined in Mathlib/NumberTheory/MulChar/Basic.lean
    complete
    theorem MulChar.map_one.{u_1, u_2} {R : Type u_1} [CommMonoid R] {R' : Type u_2}
      [CommMonoidWithZero R'] (χ : MulChar R R') : χ 1 = 1
    theorem MulChar.map_one.{u_1, u_2} {R : Type u_1}
      [CommMonoid R] {R' : Type u_2}
      [CommMonoidWithZero R']
      (χ : MulChar R R') : χ 1 = 1
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/ValueList.lean
    complete
    theorem DirichletCharacter.apply_modulus {q : ℕ} (χ : DirichletCharacter ℂ q)
      (hq : q ≠ 1) : χ ↑q = 0
    theorem DirichletCharacter.apply_modulus {q : ℕ}
      (χ : DirichletCharacter ℂ q)
      (hq : q ≠ 1) : χ ↑q = 0
    **The value of a Dirichlet character at its modulus `q ≠ 1` is `0`.** 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/ValueList.lean
    complete
    theorem DirichletCharacter.apply_eq_zero_or_exists_rat_apply_eq_exp {q : ℕ}
      (χ : DirichletCharacter ℂ q) [NeZero q] (a : ZMod q) :
      χ a = 0 ∨ ∃ r, χ a = Complex.exp (2 * ↑Real.pi * Complex.I * ↑r)
    theorem DirichletCharacter.apply_eq_zero_or_exists_rat_apply_eq_exp
      {q : ℕ} (χ : DirichletCharacter ℂ q)
      [NeZero q] (a : ZMod q) :
      χ a = 0 ∨
        ∃ r,
          χ a =
            Complex.exp
              (2 * ↑Real.pi * Complex.I * ↑r)
    **Every value of a Dirichlet character is `0` or a root of unity `e(r) = exp(2πir)` for a
    rational number `r`.** It is `0` exactly at the residues that are not units. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/ValueList.lean
    complete
    theorem DirichletCharacter.exists_rat_apply_eq_exp {q : ℕ}
      (χ : DirichletCharacter ℂ q) [NeZero q] (u : (ZMod q)ˣ) :
      ∃ r, χ ↑u = Complex.exp (2 * ↑Real.pi * Complex.I * ↑r)
    theorem DirichletCharacter.exists_rat_apply_eq_exp
      {q : ℕ} (χ : DirichletCharacter ℂ q)
      [NeZero q] (u : (ZMod q)ˣ) :
      ∃ r,
        χ ↑u =
          Complex.exp
            (2 * ↑Real.pi * Complex.I * ↑r)
    **The value of a Dirichlet character at a unit is a root of unity `e(r) = exp(2πir)` for a
    rational number `r`.** 
  • theoremdefined in Mathlib/NumberTheory/MulChar/Basic.lean
    complete
    theorem MulChar.map_nonunit.{u_1, u_2} {R : Type u_1} [CommMonoid R]
      {R' : Type u_2} [CommMonoidWithZero R'] (χ : MulChar R R') {a : R}
      (ha : ¬IsUnit a) : χ a = 0
    theorem MulChar.map_nonunit.{u_1, u_2}
      {R : Type u_1} [CommMonoid R]
      {R' : Type u_2} [CommMonoidWithZero R']
      (χ : MulChar R R') {a : R}
      (ha : ¬IsUnit a) : χ a = 0
Definition6.1.36
Statement uses 3
Statement dependency previews
Preview
Definition 6.1.1
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0✓L∃∀N

Values of a Dirichlet character on generators. (LMFDB)

A Dirichlet character \chi\colon \Z\to \C of modulus q is determined (via multiplicativity) by the values \chi(g_1), \ldots, \chi(g_r) it takes on any list of generators g_1,\ldots,g_r for the group (\mathbb{Z}/q\mathbb{Z})^\times. The generators g_i can each be specified as integers in the interval [1,q-1], and the values \chi(g_i) are roots of unity e(r):=\exp(2\pi i r), where r is a rational number.

Tau Ceti Review: DirichletCharacter, ZMod.natCast_zmod_val.

Depends on: Definition 6.1.1 Definition 6.1.19 Definition 6.1.27

Lean code for Definition6.1.36●6 declarations
  • abbrevdefined in Mathlib/NumberTheory/DirichletCharacter/Basic.lean
    complete
    abbrev DirichletCharacter.{u_1} (R : Type u_1) [CommMonoidWithZero R] (n : ℕ) :
      Type u_1
    abbrev DirichletCharacter.{u_1} (R : Type u_1)
      [CommMonoidWithZero R] (n : ℕ) :
      Type u_1
    The type of Dirichlet characters of level `n`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/ValueList.lean
    complete
    theorem DirichletCharacter.eq_iff_forall_apply_eq_of_closure_eq_top.{u_1}
      {q : ℕ} (χ ψ : DirichletCharacter ℂ q) {ι : Type u_1}
      {g : ι → (ZMod q)ˣ} (hg : Subgroup.closure (Set.range g) = ⊤) :
      χ = ψ ↔ ∀ (i : ι), χ ↑(g i) = ψ ↑(g i)
    theorem DirichletCharacter.eq_iff_forall_apply_eq_of_closure_eq_top.{u_1}
      {q : ℕ} (χ ψ : DirichletCharacter ℂ q)
      {ι : Type u_1} {g : ι → (ZMod q)ˣ}
      (hg :
        Subgroup.closure (Set.range g) = ⊤) :
      χ = ψ ↔ ∀ (i : ι), χ ↑(g i) = ψ ↑(g i)
    **A Dirichlet character is determined by its values on generators of `(ℤ/qℤ)ˣ`**: if the
    units `g i` generate `(ℤ/qℤ)ˣ`, then two characters that agree at every `g i` are equal. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/ValueList.lean
    complete
    theorem DirichletCharacter.exists_rat_apply_eq_exp {q : ℕ}
      (χ : DirichletCharacter ℂ q) [NeZero q] (u : (ZMod q)ˣ) :
      ∃ r, χ ↑u = Complex.exp (2 * ↑Real.pi * Complex.I * ↑r)
    theorem DirichletCharacter.exists_rat_apply_eq_exp
      {q : ℕ} (χ : DirichletCharacter ℂ q)
      [NeZero q] (u : (ZMod q)ˣ) :
      ∃ r,
        χ ↑u =
          Complex.exp
            (2 * ↑Real.pi * Complex.I * ↑r)
    **The value of a Dirichlet character at a unit is a root of unity `e(r) = exp(2πir)` for a
    rational number `r`.** 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/ValueList.lean
    complete
    theorem ZMod.val_mem_Icc_of_isUnit {q : ℕ} (hq : 1 < q) {a : ZMod q}
      (ha : IsUnit a) : a.val ∈ Finset.Icc 1 (q - 1)
    theorem ZMod.val_mem_Icc_of_isUnit {q : ℕ}
      (hq : 1 < q) {a : ZMod q}
      (ha : IsUnit a) :
      a.val ∈ Finset.Icc 1 (q - 1)
    **For `q > 1`, the least nonnegative representative of a unit modulo `q` lies in
    `[1, q - 1]`**, so every element of `(ℤ/qℤ)ˣ` is the class of an integer in `[1, q - 1]`. 
  • theoremdefined in Mathlib/Data/ZMod/Basic.lean
    complete
    theorem ZMod.natCast_zmod_val {n : ℕ} [NeZero n] (a : ZMod n) : ↑a.val = a
    theorem ZMod.natCast_zmod_val {n : ℕ} [NeZero n]
      (a : ZMod n) : ↑a.val = a
    So-named because the coercion is `Nat.cast` into `ZMod`. For `Nat.cast` into an arbitrary ring,
    see `ZMod.natCast_val`. 
  • theoremdefined in Mathlib/NumberTheory/MulChar/Lemmas.lean
    complete
    theorem MulChar.apply_mem_rootsOfUnity.{u_1, u_2} {R : Type u_1} {R' : Type u_2}
      [CommRing R] [CommRing R'] [Fintype Rˣ] (a : Rˣ) {χ : MulChar R R'} :
      (MulChar.equivToUnitHom χ) a ∈ rootsOfUnity (Fintype.card Rˣ) R'
    theorem MulChar.apply_mem_rootsOfUnity.{u_1, u_2}
      {R : Type u_1} {R' : Type u_2}
      [CommRing R] [CommRing R'] [Fintype Rˣ]
      (a : Rˣ) {χ : MulChar R R'} :
      (MulChar.equivToUnitHom χ) a ∈
        rootsOfUnity (Fintype.card Rˣ) R'
    The values of a multiplicative character on `R` are `n`th roots of unity, where `n = #Rˣ`. 
Definition6.1.37
Statement uses 4
Statement dependency previews
Preview
Definition 1.1.33
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 4
Reverse dependency previews
Preview
Definition 2.32
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Hecke character. (LMFDB)

Let K be a number field with ring of integers \Z_K and let \mathfrak{m} be an integral ideal of \Z_K. Let I(\mathfrak{m}) be the group of fractional ideals of \Z_K coprime to \mathfrak{m}. A Hecke character modulo \mathfrak{m} is a group homomorphism \chi:I(\mathfrak{m})\to\mathbb{C}^\times with the property there exists another group homomorphism \chi_{\infty}:K^\times/\mathbb{Q}^\times\to\mathbb{C}^\times such that

\chi(\alpha\mathbb{Z}_K)=\chi_{\infty}(\alpha) \text{ for all }\alpha\in K^\times\text{ such that }\alpha\equiv1 \mod ^*\mathfrak{m},

where by \alpha\equiv1\mod^*{\mathfrak{m}} we mean that v_{\mathfrak{p}}((\alpha-1))\geq v_{\mathfrak{p}}(\mathfrak{m}) for all prime ideals \mathfrak{p}\mid\mathfrak{m}.

Tau Ceti Review: TauCeti.GlobalNumberFields.HeckeCharacter.

Depends on: Definition 5.1.1 Definition 5.1.74 Definition 1.1.33 Definition 1.1.34

Lean code for Definition6.1.37●6 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/NumberField/HeckeIdealCharacter.lean
    complete
    def TauCeti.GlobalNumberFields.IsIdealHeckeCharacter.{u_1} {K : Type u_1}
      [Field K] [NumberField K] (𝔪 : TauCeti.GlobalNumberFields.Modulus K)
      (χ : ↥(TauCeti.GlobalNumberFields.idealsPrimeTo 𝔪) →* ℂˣ) : Prop
    def TauCeti.GlobalNumberFields.IsIdealHeckeCharacter.{u_1}
      {K : Type u_1} [Field K] [NumberField K]
      (𝔪 :
        TauCeti.GlobalNumberFields.Modulus K)
      (χ :
        ↥(TauCeti.GlobalNumberFields.idealsPrimeTo
              𝔪) →*
          ℂˣ) :
      Prop
    A homomorphism `χ : I(𝔪) → ℂˣ` from the fractional ideals of `K` prime to a modulus `𝔪` is a
    **Hecke character** modulo `𝔪` (LMFDB `character.hecke`) if there are continuous characters
    `χ_w : K_wˣ → ℂˣ` of the completions at the infinite places such that `χ((α)) = ∏_w χ_w(α)` for
    every `α ∈ Kˣ` with `α ≡ 1 mod* 𝔪`. The LMFDB's modulus is an integral ideal, the modulus with no
    infinite part, for which `α ≡ 1 mod* 𝔪` is the condition `v_𝔭(α - 1) ≥ v_𝔭(𝔪)` at the primes
    `𝔭 ∣ 𝔪`; a general modulus also imposes positivity at the real places it contains.
    
    The knowl asks for a homomorphism `χ_∞ : Kˣ/ℚˣ → ℂˣ` with no further condition, which does not give
    the intended notion: an arbitrary homomorphism imposes no condition at all on the restriction of
    `χ` to the principal ideals generated by elements `≡ 1 mod* 𝔪` that are independent modulo `ℚˣ`,
    and triviality on `ℚˣ` is not part of the classical definition. The standard requirement, made
    here, is that `χ_∞` be the restriction to `Kˣ` of a continuous character of
    `(K ⊗ ℝ)ˣ = ∏_w K_wˣ`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/NumberField/HeckeIdealCharacterIdelic.lean
    complete
    theorem TauCeti.GlobalNumberFields.isIdealHeckeCharacter_iff.{u_1}
      {K : Type u_1} [Field K] [NumberField K]
      {𝔪 : TauCeti.GlobalNumberFields.Modulus K}
      {χ : ↥(TauCeti.GlobalNumberFields.idealsPrimeTo 𝔪) →* ℂˣ} :
      TauCeti.GlobalNumberFields.IsIdealHeckeCharacter 𝔪 χ ↔
        ∃ ψ,
          ∃ (h :
            { finitePart := ψ.finiteConductor, finitePart_ne_bot := ⋯,
                  infinitePart := ∅ }.support ⊆
              𝔪.support),
            (∀
                (v :
                  IsDedekindDomain.HeightOneSpectrum
                    (NumberField.RingOfIntegers K)),
                ψ.conductorExponent v ≤ 𝔪.exponent v) ∧
              ψ.idealCharacter.comp
                  (TauCeti.NumberFieldArithmetic.idealsAwayInclusion K h) =
                χ
    theorem TauCeti.GlobalNumberFields.isIdealHeckeCharacter_iff.{u_1}
      {K : Type u_1} [Field K] [NumberField K]
      {𝔪 :
        TauCeti.GlobalNumberFields.Modulus K}
      {χ :
        ↥(TauCeti.GlobalNumberFields.idealsPrimeTo
              𝔪) →*
          ℂˣ} :
      TauCeti.GlobalNumberFields.IsIdealHeckeCharacter
          𝔪 χ ↔
        ∃ ψ,
          ∃ (h :
            { finitePart := ψ.finiteConductor,
                  finitePart_ne_bot := ⋯,
                  infinitePart :=
                    ∅ }.support ⊆
              𝔪.support),
            (∀
                (v :
                  IsDedekindDomain.HeightOneSpectrum
                    (NumberField.RingOfIntegers
                      K)),
                ψ.conductorExponent v ≤
                  𝔪.exponent v) ∧
              ψ.idealCharacter.comp
                  (TauCeti.NumberFieldArithmetic.idealsAwayInclusion
                    K h) =
                χ
    **Ideal-theoretic Hecke characters are the ideal characters of idelic Hecke characters**
    (LMFDB `character.hecke`): a character `χ` of the group `I(𝔪)` of fractional ideals prime to a
    modulus `𝔪` is a Hecke character modulo `𝔪` in the ideal-theoretic sense exactly when there is a
    Hecke character `ψ` of the idele class group whose conductor divides `𝔪` (its conductor exponents
    are at most those of `𝔪`) and whose ideal character, restricted to `I(𝔪)`, is `χ`. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/NumberField/HeckeIdealCharacterIdelic.lean
    complete
    def TauCeti.GlobalNumberFields.IsIdealHeckeCharacter.heckeCharacter.{u_1}
      {K : Type u_1} [Field K] [NumberField K]
      {𝔪 : TauCeti.GlobalNumberFields.Modulus K}
      {χ : ↥(TauCeti.GlobalNumberFields.idealsPrimeTo 𝔪) →* ℂˣ}
      (hχ : TauCeti.GlobalNumberFields.IsIdealHeckeCharacter 𝔪 χ) :
      TauCeti.GlobalNumberFields.HeckeCharacter K
    def TauCeti.GlobalNumberFields.IsIdealHeckeCharacter.heckeCharacter.{u_1}
      {K : Type u_1} [Field K] [NumberField K]
      {𝔪 :
        TauCeti.GlobalNumberFields.Modulus K}
      {χ :
        ↥(TauCeti.GlobalNumberFields.idealsPrimeTo
              𝔪) →*
          ℂˣ}
      (hχ :
        TauCeti.GlobalNumberFields.IsIdealHeckeCharacter
          𝔪 χ) :
      TauCeti.GlobalNumberFields.HeckeCharacter
        K
    The **idelic Hecke character of an ideal-theoretic Hecke character** `χ` modulo `𝔪`, with
    characters `φ_w` at the infinite places: the character of the idele class group whose value at the
    class of an idele `x` congruent to one modulo `𝔪` is `χ(ideal of x) ∏_w φ_w(x_w)⁻¹`. Every idele
    class has such a representative, and the value does not depend on it since
    `χ((α)) = ∏_w φ_w(α)` for `α ≡ 1 mod* 𝔪`. Its ideal character is `χ`
    (`TauCeti.GlobalNumberFields.IsIdealHeckeCharacter.idealCharacter_comp_heckeCharacter`). 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/NumberField/HeckeIdealCharacterIdelic.lean
    complete
    theorem TauCeti.GlobalNumberFields.IsIdealHeckeCharacter.idealCharacter_comp_heckeCharacter.{u_1}
      {K : Type u_1} [Field K] [NumberField K]
      {𝔪 : TauCeti.GlobalNumberFields.Modulus K}
      {χ : ↥(TauCeti.GlobalNumberFields.idealsPrimeTo 𝔪) →* ℂˣ}
      (hχ : TauCeti.GlobalNumberFields.IsIdealHeckeCharacter 𝔪 χ) :
      hχ.heckeCharacter.idealCharacter.comp
          (TauCeti.NumberFieldArithmetic.idealsAwayInclusion K ⋯) =
        χ
    theorem TauCeti.GlobalNumberFields.IsIdealHeckeCharacter.idealCharacter_comp_heckeCharacter.{u_1}
      {K : Type u_1} [Field K] [NumberField K]
      {𝔪 :
        TauCeti.GlobalNumberFields.Modulus K}
      {χ :
        ↥(TauCeti.GlobalNumberFields.idealsPrimeTo
              𝔪) →*
          ℂˣ}
      (hχ :
        TauCeti.GlobalNumberFields.IsIdealHeckeCharacter
          𝔪 χ) :
      hχ.heckeCharacter.idealCharacter.comp
          (TauCeti.NumberFieldArithmetic.idealsAwayInclusion
            K ⋯) =
        χ
    **The ideal character of the idelic Hecke character of `χ` is `χ`**: on an ideal `I` prime to
    `𝔪`, represented by an idele congruent to one modulo `𝔪` with trivial infinite components, both
    are `χ(I)`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/NumberField/HeckeIdealCharacter.lean
    complete
    theorem TauCeti.GlobalNumberFields.HeckeCharacter.isIdealHeckeCharacter_idealCharacter.{u_1}
      {K : Type u_1} [Field K] [NumberField K]
      (χ : TauCeti.GlobalNumberFields.HeckeCharacter K) :
      TauCeti.GlobalNumberFields.IsIdealHeckeCharacter
        { finitePart := χ.finiteConductor, finitePart_ne_bot := ⋯,
          infinitePart := ∅ }
        χ.idealCharacter
    theorem TauCeti.GlobalNumberFields.HeckeCharacter.isIdealHeckeCharacter_idealCharacter.{u_1}
      {K : Type u_1} [Field K] [NumberField K]
      (χ :
        TauCeti.GlobalNumberFields.HeckeCharacter
          K) :
      TauCeti.GlobalNumberFields.IsIdealHeckeCharacter
        { finitePart := χ.finiteConductor,
          finitePart_ne_bot := ⋯,
          infinitePart := ∅ }
        χ.idealCharacter
    **The ideal character of an idelic Hecke character is a Hecke character** modulo its finite
    conductor, with the inverses of the infinite components as characters at the infinite places. 
  • abbrevdefined in TauCeti/NumberTheory/NumberField/Global/HeckeCharacter/Basic.lean
    complete
    abbrev TauCeti.GlobalNumberFields.HeckeCharacter.{u_1} (K : Type u_1) [Field K]
      [NumberField K] : Type u_1
    abbrev TauCeti.GlobalNumberFields.HeckeCharacter.{u_1}
      (K : Type u_1) [Field K]
      [NumberField K] : Type u_1
    A **Hecke character** of `K`: a continuous homomorphism from the idele class group of `K` to
    the complex units.  Hecke characters form a commutative group under pointwise multiplication. 
Definition6.1.38
Statement uses 2
Statement dependency previews
Preview
Definition 6.1.1
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0✓L∃∀N

Underlying unit group for a Dirichlet character. (LMFDB)

A Dirichlet character \chi: \Z\to \C has a modulus n such that \chi is induced from a function \chi:\Z/n\Z\to \C. It gives a homomorphism (\Z/n\Z)^\times\to \C^\times. The underlying unit group is (\Z/n\Z)^\times, the group of units of the ring \Z/n\Z.

Tau Ceti Review: Units, ZMod, MulChar.equivToUnitHom.

Depends on: Definition 6.1.1 Definition 6.1.27

Lean code for Definition6.1.38●3 definitions
  • structure(4 fields)defined in Mathlib/Algebra/Group/Units/Defs.lean
    complete
    structure Units.{u} (α : Type u) [Monoid α] : Type u
    structure Units.{u} (α : Type u) [Monoid α] : Type u
    Units of a `Monoid`, bundled version. Notation: `αˣ`.
    
    An element of a `Monoid` is a unit if it has a two-sided inverse.
    This version bundles the inverse element so that it can be computed.
    For a predicate see `IsUnit`. 
    val : α
    The underlying value in the base `Monoid`. 
    inv : α
    The inverse value of `val` in the base `Monoid`. 
    val_inv : ↑self * self.inv = 1
    `inv` is the right inverse of `val` in the base `Monoid`. 
    inv_val : self.inv * ↑self = 1
    `inv` is the left inverse of `val` in the base `Monoid`. 
  • defdefined in Mathlib/Data/ZMod/Defs.lean
    complete
    def ZMod : ℕ → Type
    def ZMod : ℕ → Type
    The integers modulo `n : ℕ`. 
  • defdefined in Mathlib/NumberTheory/MulChar/Basic.lean
    complete
    def MulChar.equivToUnitHom.{u_1, u_2} {R : Type u_1} [CommMonoid R]
      {R' : Type u_2} [CommMonoidWithZero R'] : MulChar R R' ≃ (Rˣ →* R'ˣ)
    def MulChar.equivToUnitHom.{u_1, u_2}
      {R : Type u_1} [CommMonoid R]
      {R' : Type u_2}
      [CommMonoidWithZero R'] :
      MulChar R R' ≃ (Rˣ →* R'ˣ)
    The equivalence between multiplicative characters and homomorphisms of unit groups. 
Definition6.1.39
Statement uses 6
Statement dependency previews
Preview
Definition 6.1.1
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0✓L∃∀N

Pictures for Dirichlet characters. (LMFDB)

For each Dirichlet character \chi of modulus N and each residue a modulo N, we draw the partial Gauss sums

S_a(k) = \sum_{n = 1}^{k} \chi(n) e^{2\pi i a n/N}

as segments from the origin of the complex plane to S_a(k). All the segments belonging to a given a share a hue, running through the spectrum from red at a = 0 to violet at a = N-1; within one hue the segments for small k are darkened and those for large k are drawn at full brightness, so the eye can follow the partial sums as they accumulate. A large dot marks the last of them, the complete Gauss sum \tau_a(\chi) = S_a(N-1).

Only the stages k coprime to N are drawn: \chi(n) = 0 whenever \gcd(n, N) > 1, so each omitted stage would simply repeat the segment before it.

The grey circle has radius \sqrt N. If \chi is primitive, then |\tau_a(\chi)| = \sqrt N for every a coprime to N, and \tau_a(\chi) = 0 for every other a: the picture of a primitive character is \phi(N) dots on the circle together with a cluster of dots at the origin, and a character is primitive exactly when its coprime dots reach the circle.

Several other properties of \chi can be read off the picture.

  • Since \tau_a(\chi) = \overline{\chi(a)}\,\tau_1(\chi) for primitive \chi and a coprime to N, the dots on the circle are the vertices of a regular n-gon, where n is the order of \chi.

  • S_{N-a}(k) = \overline{S_a(k)} when \chi is real, so the picture of a real character is symmetric about the real axis.

  • The principal character shows a single long red spike along the positive real axis, of length \phi(N), since then S_0(k) just counts the units up to k.

The pictures are drawn when the page is requested rather than stored in the database, so they are only shown when there is little work to do: the number of segments is N\phi(N), and we draw the picture only when that is at most 25000. This is why a character of modulus 300 has a picture while one of modulus 293 does not.

The design follows Alex Best's demo.

Depends on: Definition 6.1.1 Definition 6.1.15 Definition 6.1.27 Definition 6.1.28 Definition 6.1.30 Definition 6.1.31

Lean code for Definition6.1.39●8 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/GaussSumPortrait.lean
    complete
    def DirichletCharacter.partialGaussSum {N : ℕ} [NeZero N]
      (χ : DirichletCharacter ℂ N) (a : ZMod N) (k : ℕ) : ℂ
    def DirichletCharacter.partialGaussSum {N : ℕ}
      [NeZero N] (χ : DirichletCharacter ℂ N)
      (a : ZMod N) (k : ℕ) : ℂ
    The **partial Gauss sum** `S_a(k) = ∑_{n = 1}^{k} χ(n) e^{2πian/N}` (LMFDB
    `portrait.character.dirichlet`) of a Dirichlet character `χ` of modulus `N`, at a residue `a`
    modulo `N`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/GaussSumPortrait.lean
    complete
    theorem DirichletCharacter.partialGaussSum_modulus_sub_one {N : ℕ} [NeZero N]
      (χ : DirichletCharacter ℂ N) (a : ZMod N) (hN : 1 < N) :
      χ.partialGaussSum a (N - 1) = gaussSum χ (ZMod.stdAddChar.mulShift a)
    theorem DirichletCharacter.partialGaussSum_modulus_sub_one
      {N : ℕ} [NeZero N]
      (χ : DirichletCharacter ℂ N)
      (a : ZMod N) (hN : 1 < N) :
      χ.partialGaussSum a (N - 1) =
        gaussSum χ
          (ZMod.stdAddChar.mulShift a)
    **For `N > 1`, the complete Gauss sum is the partial Gauss sum at `N - 1`**:
    `S_a(N - 1) = τ_a(χ)`, as `χ(N) = 0`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/GaussSumPortrait.lean
    complete
    theorem DirichletCharacter.partialGaussSum_succ_of_not_coprime {N : ℕ}
      [NeZero N] (χ : DirichletCharacter ℂ N) (a : ZMod N) {k : ℕ}
      (hk : ¬(k + 1).Coprime N) :
      χ.partialGaussSum a (k + 1) = χ.partialGaussSum a k
    theorem DirichletCharacter.partialGaussSum_succ_of_not_coprime
      {N : ℕ} [NeZero N]
      (χ : DirichletCharacter ℂ N)
      (a : ZMod N) {k : ℕ}
      (hk : ¬(k + 1).Coprime N) :
      χ.partialGaussSum a (k + 1) =
        χ.partialGaussSum a k
    **A stage `k + 1` not coprime to `N` repeats the previous one**: `χ(k + 1) = 0`, so
    `S_a(k + 1) = S_a(k)`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/GaussSumPortrait.lean
    complete
    theorem DirichletCharacter.norm_gaussSum_mulShift_of_isPrimitive {N : ℕ}
      [NeZero N] (χ : DirichletCharacter ℂ N) {a : ZMod N}
      (hχ : χ.IsPrimitive) (ha : IsUnit a) :
      ‖gaussSum χ (ZMod.stdAddChar.mulShift a)‖ = √↑N
    theorem DirichletCharacter.norm_gaussSum_mulShift_of_isPrimitive
      {N : ℕ} [NeZero N]
      (χ : DirichletCharacter ℂ N)
      {a : ZMod N} (hχ : χ.IsPrimitive)
      (ha : IsUnit a) :
      ‖gaussSum χ
            (ZMod.stdAddChar.mulShift a)‖ =
        √↑N
    **If `χ` is primitive, then `|τ_a(χ)| = √N` for every `a` coprime to `N`.** 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/GaussSumPortrait.lean
    complete
    theorem DirichletCharacter.isPrimitive_iff_forall_norm_gaussSum_mulShift_eq_sqrt
      {N : ℕ} [NeZero N] (χ : DirichletCharacter ℂ N) :
      χ.IsPrimitive ↔
        ∀ (a : ZMod N),
          IsUnit a → ‖gaussSum χ (ZMod.stdAddChar.mulShift a)‖ = √↑N
    theorem DirichletCharacter.isPrimitive_iff_forall_norm_gaussSum_mulShift_eq_sqrt
      {N : ℕ} [NeZero N]
      (χ : DirichletCharacter ℂ N) :
      χ.IsPrimitive ↔
        ∀ (a : ZMod N),
          IsUnit a →
            ‖gaussSum χ
                  (ZMod.stdAddChar.mulShift
                    a)‖ =
              √↑N
    **A Dirichlet character is primitive exactly when its coprime dots reach the circle**: `χ` is
    primitive if and only if `|τ_a(χ)| = √N` for every `a` coprime to `N`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/GaussSumPortrait.lean
    complete
    theorem DirichletCharacter.image_setOf_norm_gaussSum_mulShift_eq_sqrt_of_isPrimitive
      {N : ℕ} [NeZero N] (χ : DirichletCharacter ℂ N) (hχ : χ.IsPrimitive) :
      (fun a => gaussSum χ (ZMod.stdAddChar.mulShift a)) ''
          {a | ‖gaussSum χ (ZMod.stdAddChar.mulShift a)‖ = √↑N} =
        (fun k =>
            gaussSum χ ZMod.stdAddChar *
              Complex.exp
                (2 * ↑Real.pi * Complex.I * (↑k / ↑(orderOf χ)))) ''
          Set.Iio (orderOf χ)
    theorem DirichletCharacter.image_setOf_norm_gaussSum_mulShift_eq_sqrt_of_isPrimitive
      {N : ℕ} [NeZero N]
      (χ : DirichletCharacter ℂ N)
      (hχ : χ.IsPrimitive) :
      (fun a =>
            gaussSum χ
              (ZMod.stdAddChar.mulShift a)) ''
          {a |
            ‖gaussSum χ
                  (ZMod.stdAddChar.mulShift
                    a)‖ =
              √↑N} =
        (fun k =>
            gaussSum χ ZMod.stdAddChar *
              Complex.exp
                (2 * ↑Real.pi * Complex.I *
                  (↑k / ↑(orderOf χ)))) ''
          Set.Iio (orderOf χ)
    **The dots on the circle of a primitive character are the vertices of a regular `n`-gon**, `n`
    the order of `χ`: the complete Gauss sums `τ_a(χ)` of absolute value `√N` are the points
    `τ_1(χ) e^{2πik/n}`, `0 ≤ k < n`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/GaussSumPortrait.lean
    complete
    theorem DirichletCharacter.partialGaussSum_neg {N : ℕ} [NeZero N]
      (χ : DirichletCharacter ℂ N) (a : ZMod N) (k : ℕ)
      (hχ : ∀ (x : ZMod N), (starRingEnd ℂ) (χ x) = χ x) :
      χ.partialGaussSum (-a) k = (starRingEnd ℂ) (χ.partialGaussSum a k)
    theorem DirichletCharacter.partialGaussSum_neg
      {N : ℕ} [NeZero N]
      (χ : DirichletCharacter ℂ N)
      (a : ZMod N) (k : ℕ)
      (hχ :
        ∀ (x : ZMod N),
          (starRingEnd ℂ) (χ x) = χ x) :
      χ.partialGaussSum (-a) k =
        (starRingEnd ℂ)
          (χ.partialGaussSum a k)
    **The partial Gauss sums of a real character at `-a` are the complex conjugates of those at
    `a`**: `S_{-a}(k) = conj (S_a(k))` if the values of `χ` are real. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/DirichletCharacter/GaussSumPortrait.lean
    complete
    theorem DirichletCharacter.partialGaussSum_one_zero {N : ℕ} [NeZero N] (k : ℕ) :
      DirichletCharacter.partialGaussSum 1 0 k =
        ↑{n ∈ Finset.Icc 1 k | n.Coprime N}.card
    theorem DirichletCharacter.partialGaussSum_one_zero
      {N : ℕ} [NeZero N] (k : ℕ) :
      DirichletCharacter.partialGaussSum 1 0
          k =
        ↑{n ∈ Finset.Icc 1 k |
              n.Coprime N}.card
    **For the principal character, `S_0(k)` counts the integers in `[1, k]` coprime to `N`.**