Program Manual

Maxima Program

SimpleLieAlgebra.mac (v2.11)

  • Version note

    • Main changes from version 2.00:

    • A serious bug of the function SubGrdm is fixed.
    • The dict embM, which a comprehensive list of the embedding matrices for the maximal subgroups of low rank simple Lie groups, is renamed to _embMlib.
    • Some private library functions are moved to separate files:

      mylib_list_v1_00_pub.mac, mylib_matrix_v1_10_pub.mac, mylib_dict_v1_00_pub.mac

      These files should be put in the same directory as the main file.

    Note that in the version 2.00 and later, the internal definition of the data type "dict" is changed. The new "dict" has the following structure:

    • dict = [[ item, ...]]
    • item = ( [tag]=data )
    Here, data must have the structure of list. It can be a dict-type again. Because it is a list in reality, each data corresponding to a tag cannot be referred to as "dict[tag]" like the table or hashed array. Instead, dict can be handled by some special functions as
    • getdict( dict, [tag]) ⇒ data
    • adddict( dict, item ) ⇒ addition of item
    • repldict( dict, item) ⇒ replacement of the data for the tag of the item.
    • remdict(dict, item) ⇒ remove item from dict.
    • dicttaglist( dict) ⇒ the list of tag in dict.
    • showdict (dict) ⇒ display dict in the form [ [tag]=data, ...]

  • Common abbreviation

  • dt = Dynkin type (e.g. A4, E6)
  • wv = a weight vector in the simple root basis (e.g. [2/5,4/5,11/5,8/5])
  • rv = a root vector in the simple root basis (e.g. [1,1,0,0])
  • dw = Dynkin label for the weight (e.g. [0,-1,2,-1] for A4)
  • hdw = the highest Dynkin label for an irrep (e.g. [1,0,0,1] for A4)
  • basis = "S" or "D": "S"= the simple root basis and "D"= the dynkin basis

  • Metric

  • Kmetric( dt ) ⇒ Killing metric matrix in the simple root basis
  • Cmatrix( dt ) ⇒ Cartan matrix
  • Gmetric( dt ) ⇒ Killing metric matrix in the Dynkin basis

  • Inner products

  • IPDB( dw1, dw2, dt ) ⇒ Inner product of Dynkin weights
  • RIP( wv1, wv2, dt ) ⇒ Inner product of weights in the simple root basis
  • RCP( wv, rv, dt ) ⇒ Cartan product ❬sw,rv❭

  • Basis change

  • DBtoSRB( dw, dt ) ⇒ the coordinate trf of a weight: Dynkin basis to the Simple root basis
  • SRBtoDB( wv, dt ) ⇒ the coordinate trf of a weight: Simple root basis to the Dynkin basis

  • Root system

  • HighestRoot( dt ) ⇒ the highest root in the simple root basis
  • Rlevel( wv ) ⇒ the level of a root wv
  • RootSystem( dt[, basis, sw] ) ⇒ the root system in the specified basis.
  • sw=1 ⇒ with an output display, sw=0 ⇒ no output display
  • returned value = dict[ ["type"]= [dt], ["dim"]=[the algebra dim], ["hl"]=[highest level], roots]
  • roots = ( [level] = rootlist, ....)
  • e.g.
  • RootSystem output

  • Structure constant

  • StrConstWB( dt ) ⇒ NNdict describing the Weyl Basic CCR coefficients.
  • NNdict = dict[ ["StrConst"] = NNval, ["type"]=[Xn], ...]
  • NNval = dict[ [w1,w2]=[N[w1,w2]], ...]
  • [ E_w1, E_w2] = N[w1,w2] E_(w1+w2) (w1+w2 #0); N[w1,w2] is a number.
  • [ E_w, E_(-w)] = H_w (= K.w) ; N[w,-w]= K.w is a vector.
  • printStrConst( NNdict[, sw] ) ⇒ shows the list of non-vanishing structure constants
  • sw=1 ⇒ display the nonvanishing CCR, sw=0 ⇒ no display
  • e.g., for SO(5)
  • printStrConst output

  • Weight system

  • WeightSystem( dt, hdw, [, basis, sw] ) ⇒ WS: the weight system in the Dynkin basis (basis="D")/the simple root basis (basis="S")
  • sw=0 ⇒ output=WS. No monitor output.
  • sw=1 ⇒ output=WS. Display the weight system.
  • sw=2 ⇒ output= the flat weight list.
  • e.g., for SO(10)
  • WeightSystem output
  • printWS( WS/DWS ) ⇒ shows a formated display of a weight system.
  • findHighestWeight( dw, dt ) ⇒ hdw: the highest weight of the irrep to which a given weight dw belongs to in Dynkin basis.

  • Weyl transformation

  • WeylTrf( dt, rv[, basis] ) ⇒ Weyl trf matrix in the basis wrt the root vector rv in the simple root basis

  • Irr. decomposition of a product of irreps

  • ProductOfRep( dt, hdw1, hdw2[, sw, basis] ) ⇒ the irreps list
  • sw=0 (default) ⇒ output = Irreps list only
  • sw=1 ⇒ output = Irreps list with a formated display
  • sw=2 ⇒ output = Irreps list with display of the composite weight system in the Simple Root Basis (basis="S") or the Dynkin Basis(basis="D",default)
  • e.g., for E6
  • ProductOfRep output

  • Maximal quasi-semisimple subalgebras

    (quasi-semisimple = semisimple+U(1) factors)
  • MaxSubGlist( dt ) ⇒ [[the list of regular subalgs],[the list of special subalgs]]
  • MaxSubGlist0( dt ) ⇒ [ the flat list of all maximal subalgs].
  • e.g., for E6
  • subalgebra list

  • Irr. decomposition of an irrep of a simple algebra L wrt a subalgebra H

  • SubGrdm( dt, hwd, dts, embMD[,sw] ) ⇒ DWS/WL
  • dts = a list of Dynkin types representing a subalgebra H: e.g. SU4xSO9xU1 ⇒ [A3,B4, U1]
  • embMD = a projection matrix of the Dynkin labels; Dynkin weight for L, dw ⇒ Dynkin weights for H, dw'=embMD dw.
  • Projection matrices for the maximal quasi-semisimple subalgebras of low-rank simple algebra are preregistered in this program (see the procedure embMlist below), but for the other cases, you have to construct the projection matrices by yourself when you use the procedure SubGrdm.
  • sw=0 ⇒ output=Irrep list. No monitor output
  • sw=1 ⇒ output=Irrep list with monitor display
  • sw=2 ⇒ output=Irrep list with monitor display of the projected Dynkin weight system
  • sw=3 ⇒ output=Irrep list + monitor display of the projeced Dynkin weight system together with the original weight system
  • e.g., for SU(3)xSU(2)xU(1) ⊂ SU(5)
  • SubGrdm output list
  • In the output of SubGrdm, each list in the derived irreps has the structure

    [[U(1) charges], highest level] = [[hdw's], [dims], multiplicity ]

  • Embedding of algebras

  • MaySubG( dts1, dts0 ) ⇒ maplist : [dts0[1]=[dts1[1],..], dts0[2]=[dts1[3],..]]
  • dts0 = a target list of simple algebras: e.g. [B3,A1]
  • dts1 = a list of may be subalgebras: e.g. [A2, A1]
  • return = the list of all possible embeddings of the algebra dts1 to the algebra dts0
  • e.g. for dts1=[ A2, A1] and dts0 = [B3, A1]
  • MaySubG output list
  • embMlist( dt ) ⇒ the list of dict keys [Y, Z] for the embedding/projection matrices operating on Dynkin type dt preregisted in this program. The corresponding matrices are obtained by
  • e.g. embMD : getdict(getdict(embM, [Y, Z]),[D])[1]
  • embMlist output list
  • mkRSembM( dt, nodepos, type ) ⇒ dict[ ["subalgebra"]=dts, ["embM"]=embMdict ]
  • dts= the list of the Dynkin types of the resulting subalgebra. e.g. [A4,U1] for D5
  • embMdict = dict[[D]=embMD, [S]=embMS, [H]=embMH ]
  • embMD = projection matrix for Dynkin labels,
  • embMS = matrix specifying the pull back of simple roots,
  • embMH = matrix specifying the embedding of the Cartan subalgebra
  • nodepos= a node position to remove from the (extended) Dynkin diagram
  • type=1 => remove one node from the Dynkin diagram and add U1
  • type=2 => use the extended Dynkin diagram
  • e.g. for E6,
  • mkRSembM usage example
  • mkSOSLembM( dim ) ⇒table[embM[H],embM[S],embM[D]]

    Constructing an embedding matrix for the canonical embedding SO(dim) → SL(dim)

  • e.g. for SO(10) ⊂ SU(10)
  • mkSOSLembM usage example

  • GUT Symmetry breaking chain list

  • SBpattern( dt, dts[, sw] ) ⇒ the SB chain list: [ [[SBlist,[[],Unbrknlist],...]
  • dt = the Dynkin type of the initial algebra
  • dts = a list of Dynkin types for the final algebra
  • sw=0 ⇒ output = the SB chain list, no display,
  • sw=1 ⇒ output = the SB chain list + its monitor display.
  • e.g. for SO(10) ⇒ SU(3)xSU(2)xU(1)
  • SBpattern output list