\h2SSKJr SSKJr "SS\5rg)) CartanType)AtomcH\rSrSrSrSrSrSrSrSr Sr S r S r S r g ) RootSystemaRepresent the root system of a simple Lie algebra Every simple Lie algebra has a unique root system. To find the root system, we first consider the Cartan subalgebra of g, which is the maximal abelian subalgebra, and consider the adjoint action of g on this subalgebra. There is a root system associated with this action. Now, a root system over a vector space V is a set of finite vectors Phi (called roots), which satisfy: 1. The roots span V 2. The only scalar multiples of x in Phi are x and -x 3. For every x in Phi, the set Phi is closed under reflection through the hyperplane perpendicular to x. 4. If x and y are roots in Phi, then the projection of y onto the line through x is a half-integral multiple of x. Now, there is a subset of Phi, which we will call Delta, such that: 1. Delta is a basis of V 2. Each root x in Phi can be written x = sum k_y y for y in Delta The elements of Delta are called the simple roots. Therefore, we see that the simple roots span the root space of a given simple Lie algebra. References ========== .. [1] https://en.wikipedia.org/wiki/Root_system .. [2] Lie Algebras and Representation Theory - Humphreys cR[R"U5n[U5UlU$)aeCreate a new RootSystem object This method assigns an attribute called cartan_type to each instance of a RootSystem object. When an instance of RootSystem is called, it needs an argument, which should be an instance of a simple Lie algebra. We then take the CartanType of this argument and set it as the cartan_type attribute of the RootSystem instance. )r__new__r cartan_type)cls cartantypeobjs U/var/www/auris/envauris/lib/python3.13/site-packages/sympy/liealgebras/root_system.pyr RootSystem.__new__%s#ll3$Z0 cURR5n[SUS-5Vs0sHo"URRU5_M nnU$s snf)aGenerate the simple roots of the Lie algebra The rank of the Lie algebra determines the number of simple roots that it has. This method obtains the rank of the Lie algebra, and then uses the simple_root method from the Lie algebra classes to generate all the simple roots. Examples ======== >>> from sympy.liealgebras.root_system import RootSystem >>> c = RootSystem("A3") >>> roots = c.simple_roots() >>> roots {1: [1, -1, 0, 0], 2: [0, 1, -1, 0], 3: [0, 0, 1, -1]} r)r rankrange simple_root)selfnirootss r simple_rootsRootSystem.simple_roots3sU$    ! ! #=B1ac]K]D$$0033]K Ls%AcURR5n[UR55n[ U5nUH"nUS- nXnUVs/sHof*PM nnXqU'M$ U$s snf)aWGenerate all the roots of a given root system The result is a dictionary where the keys are integer numbers. It generates the roots by getting the dictionary of all positive roots from the bases classes, and then taking each root, and multiplying it by -1 and adding it to the dictionary. In this way all the negative roots are generated. r)r positive_rootslistkeysmax)ralpharkvalrootxnewroots r all_rootsRootSystem.all_rootsJsr  //1EJJL! IC FA:D#'(4ar4G(!H   )s A)cURR5nSRS[SUS-555nU$)aReturn the span of the simple roots The root space is the vector space spanned by the simple roots, i.e. it is a vector space with a distinguished basis, the simple roots. This method returns a string that represents the root space as the span of the simple roots, alpha[1],...., alpha[n]. Examples ======== >>> from sympy.liealgebras.root_system import RootSystem >>> c = RootSystem("A3") >>> c.root_space() 'alpha[1] + alpha[2] + alpha[3]' z + c3D# UHnS[U5-S-v M g7f)zalpha[]N)str).0rs r (RootSystem.root_space..psDmQ,ms r)r rjoinr)rrrss r root_spaceRootSystem.root_space^s;"    ! ! # ZZDeAqsmD D rcUR5nU[U5:dU[U5:a [S5eX1nX2n[XE5VVs/sH upgXg-PM nnnU$s snnf)aAdd two simple roots together The function takes as input two integers, root1 and root2. It then uses these integers as keys in the dictionary of simple roots, and gets the corresponding simple roots, and then adds them together. Examples ======== >>> from sympy.liealgebras.root_system import RootSystem >>> c = RootSystem("A3") >>> newroot = c.add_simple_roots(1, 2) >>> newroot [1, 0, -1, 0] z&You've used a root that doesn't exist!)rlen ValueErrorzip) rroot1root2r!a1a2_a1_a2r&s radd_simple_rootsRootSystem.add_simple_rootsssi$!!# 3u: U!3EF F \ \-0[9[39[9:sA%cUR5n[X5VVs/sH upEXE-PM nnnXcR5;aU$gs snnf)a+Add two roots together if and only if their sum is also a root It takes as input two vectors which should be roots. It then computes their sum and checks if it is in the list of all possible roots. If it is, it returns the sum. Otherwise it returns a string saying that the sum is not a root. Examples ======== >>> from sympy.liealgebras.root_system import RootSystem >>> c = RootSystem("A3") >>> c.add_as_roots([1, 0, -1, 0], [0, 0, 1, -1]) [1, 0, 0, -1] >>> c.add_as_roots([1, -1, 0, 0], [0, 0, -1, 1]) 'The sum of these two roots is not a root' z(The sum of these two roots is not a root)r'r7values)rr8r9r!r1r2r&s r add_as_rootsRootSystem.add_as_rootssH& ),U):;):vr27):; lln $N= >> from sympy.liealgebras.root_system import RootSystem >>> c = RootSystem("A3") >>> c.cartan_matrix() Matrix([ [ 2, -1, 0], [-1, 2, -1], [ 0, -1, 2]]) )r cartan_matrixrs rrGRootSystem.cartan_matrixs--//rc6URR5$)zDynkin diagram of the Lie algebra associated with this root system Examples ======== >>> from sympy.liealgebras.root_system import RootSystem >>> c = RootSystem("A3") >>> print(c.dynkin_diagram()) 0---0---0 1 2 3 )r dynkin_diagramrHs rrKRootSystem.dynkin_diagrams..00rN)__name__ __module__ __qualname____firstlineno____doc__r rr'r2r>rDrGrK__static_attributes__rMrrrrs0@ .(*4>60 1rrN)r rsympy.core.basicrrrMrrrUs#!@1@1r