Documentation

Mathlib.LinearAlgebra.RootSystem.Basic

Root data and root systems #

This file contains basic definitions for root systems and root data.

Main definitions / results: #

Implementation details #

A root datum is sometimes defined as two subsets: roots and coroots, together with a bijection between them, subject to hypotheses. However the hypotheses ensure that the bijection is unique and so the question arises of whether this bijection should be part of the data of a root datum or whether one should merely assert its existence. For root systems, things are even more extreme: the coroots are uniquely determined by the roots. Furthermore a root system induces a canonical non-degenerate bilinear form on the ambient space and many informal accounts even include this form as part of the data.

We have opted for a design in which some of the uniquely-determined data is included: the bijection between roots and coroots is (implicitly) included and the coroots are included for root systems. Empirically this seems to be by far the most convenient design and by providing extensionality lemmas expressing the uniqueness we expect to get the best of both worlds.

A final point is that we require roots and coroots to be injections from a base indexing type ι rather than subsets of their codomains. This design was chosen to avoid the bijection between roots and coroots being a dependently-typed object. A third option would be to have the roots and coroots be subsets but to avoid having a dependently-typed bijection by defining it globally with junk value 0 outside of the roots and coroots. This would work but lacks the convenient symmetry that the chosen design enjoys: by introducing the indexing type ι, one does not have to pick a direction (roots → coroots or coroots → roots) for the forward direction of the bijection. Besides, providing the user with the additional definitional power to specify an indexing type ι is a benefit and the junk-value pattern is a cost.

structure RootPairing (ι : Type u_1) (R : Type u_2) (M : Type u_3) (N : Type u_4) [CommRing R] [AddCommGroup M] [Module R M] [AddCommGroup N] [Module R N] extends PerfectPairing :
Type (max (max (max u_1 u_2) u_3) u_4)

Given two perfectly-paired R-modules M and N, a root pairing with finite indexing set ι is the data of an ι-indexed subset of M ("the roots") and an ι-indexed subset of N ("the coroots") satisfying the axioms familiar from the traditional theory of root systems / data.

It exists to allow for a convenient unification of the theories of root systems and root data.

Instances For
    @[inline, reducible]
    abbrev RootDatum (ι : Type u_1) (X₁ : Type u_5) (X₂ : Type u_6) [AddCommGroup X₁] [AddCommGroup X₂] :
    Type (max (max u_1 u_5) u_6)

    A root datum is a root pairing with coefficients in the integers and for which the root and coroot spaces are finitely-generated free Abelian groups.

    Note that the latter assumptions [Free ℤ X₁] [Finite ℤ X₁] [Free ℤ X₂] [Finite ℤ X₂] should be supplied as mixins.

    Equations
    Instances For
      structure RootSystem (ι : Type u_1) (R : Type u_2) (M : Type u_3) (N : Type u_4) [CommRing R] [AddCommGroup M] [Module R M] [AddCommGroup N] [Module R N] extends RootPairing :
      Type (max (max (max u_1 u_2) u_3) u_4)

      A root system is a root pairing for which the roots span their ambient module.

      Note that this is slightly more general than the usual definition in the sense that N is not required to be the dual of M.

      Instances For
        def RootPairing.IsCrystallographic {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [CommRing R] [AddCommGroup M] [Module R M] [AddCommGroup N] [Module R N] (P : RootPairing ι R M N) :

        A root pairing is said to be crystallographic if the pairing between a root and coroot is always an integer.

        Equations
        Instances For
          def RootPairing.IsReduced {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [CommRing R] [AddCommGroup M] [Module R M] [AddCommGroup N] [Module R N] (P : RootPairing ι R M N) :

          A root pairing is said to be reduced if it never contains the double of a root.

          Equations
          Instances For
            theorem RootPairing.ne_zero {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [CommRing R] [AddCommGroup M] [Module R M] [AddCommGroup N] [Module R N] (P : RootPairing ι R M N) (i : ι) [CharZero R] :
            P.root i 0
            theorem RootPairing.ne_zero' {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [CommRing R] [AddCommGroup M] [Module R M] [AddCommGroup N] [Module R N] (P : RootPairing ι R M N) (i : ι) [CharZero R] :
            P.coroot i 0
            theorem RootPairing.coroot_root_two {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [CommRing R] [AddCommGroup M] [Module R M] [AddCommGroup N] [Module R N] (P : RootPairing ι R M N) (i : ι) :
            ((LinearMap.flip P.toLin) (P.coroot i)) (P.root i) = 2
            def RootPairing.flip {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [CommRing R] [AddCommGroup M] [Module R M] [AddCommGroup N] [Module R N] (P : RootPairing ι R M N) :
            RootPairing ι R N M

            If we interchange the roles of M and N, we still have a root pairing.

            Equations
            • One or more equations did not get rendered due to their size.
            Instances For
              @[simp]
              theorem RootPairing.flip_flip {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [CommRing R] [AddCommGroup M] [Module R M] [AddCommGroup N] [Module R N] (P : RootPairing ι R M N) :
              def RootPairing.reflection {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [CommRing R] [AddCommGroup M] [Module R M] [AddCommGroup N] [Module R N] (P : RootPairing ι R M N) (i : ι) :

              The reflection associated to a root.

              Equations
              Instances For
                theorem RootPairing.reflection_apply {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [CommRing R] [AddCommGroup M] [Module R M] [AddCommGroup N] [Module R N] (P : RootPairing ι R M N) (i : ι) (x : M) :
                (RootPairing.reflection P i) x = x - (P.toLin x) (P.coroot i) P.root i
                @[simp]
                theorem RootPairing.reflection_apply_self {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [CommRing R] [AddCommGroup M] [Module R M] [AddCommGroup N] [Module R N] (P : RootPairing ι R M N) (i : ι) :
                (RootPairing.reflection P i) (P.root i) = -P.root i
                def RootPairing.coreflection {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [CommRing R] [AddCommGroup M] [Module R M] [AddCommGroup N] [Module R N] (P : RootPairing ι R M N) (i : ι) :

                The reflection associated to a coroot.

                Equations
                Instances For
                  theorem RootPairing.coreflection_apply {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [CommRing R] [AddCommGroup M] [Module R M] [AddCommGroup N] [Module R N] (P : RootPairing ι R M N) (i : ι) (f : N) :
                  (RootPairing.coreflection P i) f = f - (P.toLin (P.root i)) f P.coroot i
                  theorem RootPairing.bijOn_reflection_root {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [Finite ι] [CommRing R] [AddCommGroup M] [Module R M] [AddCommGroup N] [Module R N] (P : RootPairing ι R M N) (i : ι) :
                  Set.BijOn ((RootPairing.reflection P i)) (Set.range P.root) (Set.range P.root)
                  theorem RootPairing.bijOn_coreflection_coroot {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [Finite ι] [CommRing R] [AddCommGroup M] [Module R M] [AddCommGroup N] [Module R N] (P : RootPairing ι R M N) (i : ι) :
                  Set.BijOn ((RootPairing.coreflection P i)) (Set.range P.coroot) (Set.range P.coroot)
                  @[simp]
                  theorem RootPairing.reflection_image_eq {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [Finite ι] [CommRing R] [AddCommGroup M] [Module R M] [AddCommGroup N] [Module R N] (P : RootPairing ι R M N) (i : ι) :
                  (RootPairing.reflection P i) '' Set.range P.root = Set.range P.root
                  @[simp]
                  theorem RootPairing.coreflection_image_eq {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [Finite ι] [CommRing R] [AddCommGroup M] [Module R M] [AddCommGroup N] [Module R N] (P : RootPairing ι R M N) (i : ι) :
                  (RootPairing.coreflection P i) '' Set.range P.coroot = Set.range P.coroot
                  theorem RootPairing.reflection_dualMap_eq_coreflection {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [CommRing R] [AddCommGroup M] [Module R M] [AddCommGroup N] [Module R N] (P : RootPairing ι R M N) (i : ι) :
                  theorem RootPairing.eq_of_forall_coroot_root_eq {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [Finite ι] [CommRing R] [AddCommGroup M] [Module R M] [AddCommGroup N] [Module R N] (P : RootPairing ι R M N) [NoZeroSMulDivisors M] (i : ι) (j : ι) (h : ∀ (k : ι), (P.toLin (P.root k)) (P.coroot i) = (P.toLin (P.root k)) (P.coroot j)) :
                  i = j

                  Even though the roots may not span, coroots are distinguished by their pairing with the roots. The proof depends crucially on the fact that there are finitely-many roots.

                  Modulo trivial generalisations, this statement is exactly Lemma 1.1.4 on page 87 of SGA 3 XXI. See also RootPairing.injOn_dualMap_subtype_span_root_coroot for a more useful restatement.

                  theorem RootPairing.injOn_dualMap_subtype_span_root_coroot {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [Finite ι] [CommRing R] [AddCommGroup M] [Module R M] [AddCommGroup N] [Module R N] (P : RootPairing ι R M N) [NoZeroSMulDivisors M] :
                  Set.InjOn ((LinearMap.dualMap (Submodule.subtype (Submodule.span R (Set.range P.root))) ∘ₗ LinearMap.flip P.toLin)) (Set.range P.coroot)
                  theorem RootPairing.ext {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [Finite ι] [CommRing R] [AddCommGroup M] [Module R M] [AddCommGroup N] [Module R N] [CharZero R] [NoZeroSMulDivisors R M] {P₁ : RootPairing ι R M N} {P₂ : RootPairing ι R M N} (he : P₁.toLin = P₂.toLin) (hr : P₁.root = P₂.root) (hc : Set.range P₁.coroot = Set.range P₂.coroot) :
                  P₁ = P₂

                  In characteristic zero if there is no torsion, the correspondence between roots and coroots is unique.

                  Formally, the point is that the hypothesis hc depends only on the range of the coroot mappings.

                  theorem RootPairing.coroot_eq_coreflection_of_root_eq_of_span_eq_top' {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [Finite ι] [CommRing R] [AddCommGroup M] [Module R M] [AddCommGroup N] [Module R N] [CharZero R] [NoZeroSMulDivisors R M] (p : PerfectPairing R M N) (root : ι M) (coroot : ι N) (hp : ∀ (i : ι), (p.toLin (root i)) (coroot i) = 2) (hs : ∀ (i : ι), Set.MapsTo ((Module.preReflection (root i) ((LinearMap.flip p.toLin) (coroot i)))) (Set.range root) (Set.range root)) (hsp : Submodule.span R (Set.range root) = ) {i : ι} {j : ι} {k : ι} (hk : root k = (Module.preReflection (root i) ((LinearMap.flip p.toLin) (coroot i))) (root j)) :
                  coroot k = (Module.preReflection (coroot i) (p.toLin (root i))) (coroot j)

                  This lemma exists to support the definition RootSystem.mk' and usually should not be used directly. The lemma RootPairing.coroot_eq_coreflection_of_root_eq_of_span_eq_top or even RootSystem.coroot_eq_coreflection_of_root_eq will usually be more convenient.

                  theorem RootPairing.coroot_eq_coreflection_of_root_eq_of_span_eq_top {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [Finite ι] [CommRing R] [AddCommGroup M] [Module R M] [AddCommGroup N] [Module R N] (P : RootPairing ι R M N) [CharZero R] [NoZeroSMulDivisors R M] (hsp : Submodule.span R (Set.range P.root) = ) {i : ι} {j : ι} {k : ι} (hk : P.root k = (RootPairing.reflection P i) (P.root j)) :
                  P.coroot k = (RootPairing.coreflection P i) (P.coroot j)

                  In characteristic zero if there is no torsion and the roots span, if the ith reflection of the jth root is the kth root, then the corresponding relationship holds for coroots. See also RootSystem.coroot_eq_coreflection_of_root_eq.

                  theorem RootSystem.ext {ι : Type u_1} (R : Type u_2) (M : Type u_3) (N : Type u_4) [Finite ι] [CommRing R] [AddCommGroup M] [Module R M] [AddCommGroup N] [Module R N] [CharZero R] [NoZeroSMulDivisors R M] {P₁ : RootSystem ι R M N} {P₂ : RootSystem ι R M N} (he : P₁.toLin = P₂.toLin) (hr : P₁.root = P₂.root) :
                  P₁ = P₂

                  In characteristic zero if there is no torsion, a root system is determined entirely by its roots.

                  def RootSystem.mk' {ι : Type u_1} (R : Type u_2) (M : Type u_3) (N : Type u_4) [Finite ι] [CommRing R] [AddCommGroup M] [Module R M] [AddCommGroup N] [Module R N] [CharZero R] [NoZeroSMulDivisors R M] (p : PerfectPairing R M N) (root : ι M) (coroot : ι N) (hp : ∀ (i : ι), (p.toLin (root i)) (coroot i) = 2) (hs : ∀ (i : ι), Set.MapsTo ((Module.preReflection (root i) ((LinearMap.flip p.toLin) (coroot i)))) (Set.range root) (Set.range root)) (hsp : Submodule.span R (Set.range root) = ) :
                  RootSystem ι R M N

                  In characteristic zero if there is no torsion, to check that a family of roots form a root system, we do not need to check that the coroots are stable under reflections since this follows from the corresponding property for the roots.

                  Equations
                  • One or more equations did not get rendered due to their size.
                  Instances For
                    theorem RootSystem.coroot_eq_coreflection_of_root_eq {ι : Type u_1} (R : Type u_2) (M : Type u_3) (N : Type u_4) [Finite ι] [CommRing R] [AddCommGroup M] [Module R M] [AddCommGroup N] [Module R N] (P : RootSystem ι R M N) [CharZero R] [NoZeroSMulDivisors R M] {i : ι} {j : ι} {k : ι} (hk : P.root k = (RootPairing.reflection P.toRootPairing i) (P.root j)) :
                    P.coroot k = (RootPairing.coreflection P.toRootPairing i) (P.coroot j)

                    In characteristic zero if there is no torsion, if the ith reflection of the jth root is the kth root, then the corresponding relationship holds for coroots.