Documentation

TauCeti.LinearAlgebra.RootSystem.DynkinType

Dynkin types #

The Cartan-Killing classification says that an irreducible reduced crystallographic finite root system is described by one of a short list of combinatorial types. This file introduces those types as a plain enumeration TauCeti.DynkinType, equips it with a rank, a validity predicate carving out the rank ranges in which the types are pairwise distinct and irreducible, and attaches to each type its standard integer Cartan matrix, taken from Mathlib's CartanMatrix family and numbered by Bourbaki's node labels, with node i at index i - 1. The predicate TauCeti.HasCartanType then says that the Cartan matrix of a base agrees with the standard matrix of a given type under a single simultaneous relabelling of rows and columns.

The enumeration is deliberately plain: the rank ranges A n (1 ≤ n), B n (2 ≤ n), C n (3 ≤ n), D n (4 ≤ n) are carried by TauCeti.DynkinType.Valid rather than baked into the constructors. Those bounds remove two different kinds of redundancy. The rank-zero types A 0, B 0, C 0, D 0 have empty Cartan matrices, and D 2 has the reducible matrix of A₁ × A₁, so none of these names an irreducible root system at all. The other excluded types are low-rank coincidences: B 1, C 1 and D 1 are A 1, C 2 is B 2, and D 3 is A 3, so each of them does name an irreducible root system, but one the list already carries under a valid name. What the bounds secure is therefore uniqueness of the type, not the existence of a root system realizing it. Note in particular that Valid is not preserved by exchanging B n and C n: B 2 is valid while C 2 is not, precisely because they name the same root system.

The matching in TauCeti.HasCartanType is oriented, using one relabelling e on both indices rather than allowing the matrix to be transposed. This is what keeps Bₙ and Cₙ apart from rank 3 on, where they are different root systems whose standard Cartan matrices are transposes of one another (CartanMatrix.B_transpose) and an unoriented match would identify them. At rank at most 2 the orientation carries no information about these matrices: relabelling by the swap of two indices transposes the off-diagonal entries but exchanges the diagonal ones as well, and every diagonal entry of a standard Cartan matrix is 2, so here transposition is itself a simultaneous relabelling. Hence B 2 and C 2 match exactly the same bases, in keeping with their naming the same root system; Valid keeps only B 2 of those two names.

Main definitions #

Main results #

References #

This file implements the DynkinType enumeration of Layer 5 of TauCetiRoadmap/RepresentationTheory/RootSystems/README.md, following the target signatures in TauCetiRoadmap/RepresentationTheory/RootSystems/Suggested.lean. See Bourbaki, Lie Groups and Lie Algebras, Chapters 4-6, plates I-IX, and Humphreys, Introduction to Lie Algebras and Representation Theory, Chapter 11, for the standard Cartan matrices.

The Dynkin types: the four classical families Aₙ, Bₙ, Cₙ, Dₙ, whose constructors accept every natural number, together with the five exceptional types. The rank ranges on which these are the types occurring in the Cartan-Killing classification are carried by TauCeti.DynkinType.Valid, not by the constructors.

Instances For
    Equations
    Instances For

      The rank of a Dynkin type: the number of simple roots, equivalently the size of its Cartan matrix. This is exposed because it appears in the type of TauCeti.DynkinType.cartanMatrix, so even the statement (A n).cartanMatrix = CartanMatrix.A n needs Fin (A n).rank to reduce to Fin n.

      Equations
      Instances For
        @[simp]
        theorem TauCeti.DynkinType.rank_A (n : ) :
        (A n).rank = n
        @[simp]
        theorem TauCeti.DynkinType.rank_B (n : ) :
        (B n).rank = n
        @[simp]
        theorem TauCeti.DynkinType.rank_C (n : ) :
        (C n).rank = n
        @[simp]
        theorem TauCeti.DynkinType.rank_D (n : ) :
        (D n).rank = n

        The rank ranges on which the Dynkin types are pairwise distinct and irreducible. Outside them the standard Cartan matrices are degenerate or coincide: B 1 = C 1 = A 1, C 2 is B 2 transposed, D 2 is A 1 × A 1 and D 3 is A 3 relabelled.

        Equations
        Instances For
          @[simp]
          theorem TauCeti.DynkinType.valid_A {n : } :
          (A n).Valid 1 n
          @[simp]
          theorem TauCeti.DynkinType.valid_B {n : } :
          (B n).Valid 2 n
          @[simp]
          theorem TauCeti.DynkinType.valid_C {n : } :
          (C n).Valid 3 n
          @[simp]
          theorem TauCeti.DynkinType.valid_D {n : } :
          (D n).Valid 4 n
          theorem TauCeti.DynkinType.rank_pos {t : DynkinType} (ht : t.Valid) :
          0 < t.rank

          A valid Dynkin type has at least one simple root.

          The standard integer Cartan matrix of a Dynkin type, indexed by Fin t.rank in the Bourbaki node numbering, so that cartanMatrix t i j = ⟨αᵢ, αⱼ^∨⟩ for Bourbaki node i + 1 at index i. The classical families and the exceptional matrices are Mathlib's CartanMatrix.A, .B, .C, .D, .E₆, .E₇, .E₈ and .F₄, whose conventions agree with Bourbaki's plates.

          Type G₂ is the one place where they do not. Mathlib's CartanMatrix.G₂ is documented as the transpose of Bourbaki's plate IX matrix, so the Bourbaki numbering — node 1 short, node 2 long, giving !![2, -1; -3, 2] — is CartanMatrix.G₂ᵀ. The transpose of a Cartan matrix is again one, of the same diagram with the arrow reversed, and here it is the Bourbaki-numbered representative that this enumeration pins.

          Equations
          Instances For

            The two rank-two standard Cartan matrices differ only by the node numbering: exchanging Bourbaki nodes 1 and 2 carries the matrix of B 2 to the matrix of C 2. This is the low-rank coincidence that TauCeti.DynkinType.Valid records by keeping only the name B 2 of the two. From rank three on there is no such relabelling, Bₙ and Cₙ being different root systems whose matrices are transposes; at rank two transposition is itself a relabelling because both diagonal entries are 2.

            @[simp]

            Every diagonal entry of a standard Cartan matrix is 2.

            Every off-diagonal entry of a standard Cartan matrix is nonpositive.

            The zero pattern of a standard Cartan matrix is symmetric: two simple roots are orthogonal in one order exactly when they are in the other. With cartanMatrix_apply_same and cartanMatrix_apply_le_zero_of_ne this says each standard matrix is a generalized Cartan matrix. This is the DynkinType analogue of RootPairing.Base.cartanMatrix_apply_eq_zero_iff_symm.

            A standard Cartan matrix is simply laced exactly when its type is, or the type has rank at most one. The second alternative is not redundant. Rank at most one holds for A 0, A 1, D 0 and D 1 as well, but those types are simply laced anyway, so the types it adds to the first alternative are precisely B 0, B 1, C 0 and C 1, whose matrices have no off-diagonal entries at all and so are vacuously simply laced even though the types are not. Excluding those four is all that isSimplyLaced_cartanMatrix_iff_of_valid needs.

            Among valid Dynkin types the simply-laced Cartan matrices are exactly those of types A, D and E. Validity is what rules out B 1 = A 1, whose matrix is simply laced.

            A standard Cartan matrix that is simply laced is symmetric: its off-diagonal entries are 0 or -1, and by cartanMatrix_apply_eq_zero_iff_symm which of the two an entry is depends only on the unordered pair of indices. By isSimplyLaced_cartanMatrix_iff the hypothesis holds for every simply-laced type, and for the degenerate B 0, B 1, C 0, C 1 besides.

            def TauCeti.HasCartanType {ι : 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) [P.IsCrystallographic] (b : P.Base) (t : DynkinType) :

            A base of a crystallographic root pairing has Cartan type t when its Cartan matrix agrees with the standard Cartan matrix of t after a single simultaneous relabelling of rows and columns. Matching without transposing is deliberate: from rank 3 on, Bₙ and Cₙ are different root systems with transposed Cartan matrices (CartanMatrix.B_transpose), so an unoriented match would identify them. It does not separate B 2 from C 2, which are the same root system; TauCeti.DynkinType.Valid excludes C 2.

            Equations
            Instances For
              theorem TauCeti.hasCartanType_iff {ι : 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} [P.IsCrystallographic] (b : P.Base) (t : DynkinType) :
              HasCartanType P b t ∃ (e : b.support Fin t.rank), ∀ (i j : b.support), b.cartanMatrix i j = t.cartanMatrix (e i) (e j)

              Having Cartan type t, unfolded to the relabelling it asserts to exist. The body of TauCeti.HasCartanType is deliberately not exposed, so this is the interface through which consumers in other modules build and destructure it.

              theorem TauCeti.HasCartanType.exists_supportEquiv_cartanMatrix_eq {ι : 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} [P.IsCrystallographic] {ι₂ : Type u_5} {M₂ : Type u_6} {N₂ : Type u_7} [AddCommGroup M₂] [Module R M₂] [AddCommGroup N₂] [Module R N₂] {P₂ : RootPairing ι₂ R M₂ N₂} [P₂.IsCrystallographic] {b : P.Base} {b₂ : P₂.Base} {t : DynkinType} (h : HasCartanType P b t) (h₂ : HasCartanType P₂ b₂ t) :
              ∃ (e : b.support b₂.support), ∀ (i j : b.support), b₂.cartanMatrix (e i) (e j) = b.cartanMatrix i j

              Two bases of the same Cartan type are related by a relabelling matching their Cartan matrices. Each of the two bases comes with a labelling of its support by the nodes of t, and composing one with the inverse of the other identifies the supports; the two Cartan matrices then agree because each agrees with the standard matrix of t.

              This is the hypothesis of Mathlib's RootPairing.Base.equivOfCartanMatrixEq, and is pure bookkeeping about the labellings: it needs neither finiteness nor reducedness of the two root pairings, with the root-system content left to that theorem.

              theorem TauCeti.hasCartanType_iff_reindex {ι : 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} [P.IsCrystallographic] (b : P.Base) (t : DynkinType) :

              Having Cartan type t, expressed as a reindexing of matrices rather than entrywise.

              theorem TauCeti.HasCartanType.card_support {ι : 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} [P.IsCrystallographic] {b : P.Base} {t : DynkinType} (h : HasCartanType P b t) :

              The rank of the Cartan type of a base is its number of simple roots.

              theorem TauCeti.HasCartanType.isSimplyLaced_iff {ι : 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} [P.IsCrystallographic] {b : P.Base} {t : DynkinType} (h : HasCartanType P b t) :

              A base of Cartan type t is simply laced exactly when t is, or t has rank at most one. The second alternative adds only the degenerate types B 0, B 1, C 0 and C 1: the remaining types of rank at most one, namely A 0, A 1, D 0 and D 1, are simply laced already.

              theorem TauCeti.HasCartanType.isSimplyLaced_iff_of_valid {ι : 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} [P.IsCrystallographic] {b : P.Base} {t : DynkinType} (h : HasCartanType P b t) (ht : t.Valid) :

              A base of valid Cartan type t is simply laced exactly when t is, that is, exactly when t is one of A, D, E₆, E₇, E₈.