On The Free and G-Saturated Weight Monoids of Smooth Affine Spherical Varieties For G=SL(n)

Transcription

1 City University of New York (CUNY) CUNY Academic Works Dissertations, Theses, and Capstone Projects Graduate Center On The Free and G-Saturated Weight Monoids of Smooth Affine Spherical Varieties For G=SL(n) Won Geun Kim The Graduate Center, City University of New York How does access to this work benefit you? Let us know! Follow this and additional works at: Part of the Algebraic Geometry Commons, Harmonic Analysis and Representation Commons, and the Number Theory Commons Recommended Citation Kim, Won Geun, "On The Free and G-Saturated Weight Monoids of Smooth Affine Spherical Varieties For G=SL(n)" (2016). CUNY Academic Works. This Dissertation is brought to you by CUNY Academic Works. It has been accepted for inclusion in All Dissertations, Theses, and Capstone Projects by an authorized administrator of CUNY Academic Works. For more information, please contact

2 ON THE FREE AND G-SATURATED WEIGHT MONOIDS OF SMOOTH AFFINE SPHERICAL VARIETIES FOR G = SL(n) by Won Geun Kim A dissertation submitted to the Graduate Faculty in Mathematics in partial fulfillment of the requirements for the degree of Doctor of Philosophy, The City University of New York. 2016

3 ii c 2016 Won Geun Kim All Rights Reserved

4 This manuscript has been read and accepted for the Graduate Faculty in Mathematics in satisfaction of the dissertation requirements for the degree of Doctor of Philosophy. Gautam Chinta iii Date Chair of Examining Committee Ara Basmajian Date Executive Officer Raymond Hoobler Benjamin Steinberg Bart Van Steirteghem : co-advisor Supervisory Committee THE CITY UNIVERSITY OF NEW YORK

5 iv Abstract ON THE FREE AND G-SATURATED WEIGHT MONOIDS OF SMOOTH AFFINE SPHERICAL VARIETIES FOR G = SL(n) by Won Geun Kim Advisor: Gautam Chinta and Bart Van Steirteghem Let X be an affine algebraic variety over C equipped with an action of a connected reductive group G. The weight monoid Γ(X) of X is the set of isomorphism classes of irreducible representations of G that occur in the coordinate ring C[X] of X. Losev has shown that if X is a smooth affine spherical variety, that is, if X is smooth and C[X] is multiplicityfree as a representation of G, then Γ(X) determines X up to equivariant automorphism. Pezzini and Van Steirteghem have recently obtained a combinatorial characterization of the weight monoids of smooth affine spherical varieties, using the combinatorial theory of spherical varieties and a smoothness criterion due to R. Camus. The first part of this thesis gives an implementation in Sage of a special case of this combinatorial characterization: given a free and G-saturated monoid Γ of dominant weights for G = SL(n), the algorithm decides whether there exists a smooth affine spherical G-variety X such that Γ(X) = Γ. In the second part of the thesis, we apply Pezzini and Van Steirteghem s characterization to determine which subsets of the set of fundamental weights of SL(n) generate a monoid that is the weight monoid of a smooth affine spherical G-variety.

6 Acknowledgments First and foremost, I would like to thank my advisors, Gautam Chinta and Bart Van Steirteghem. Extremely gifted teachers, they have been a constant source of inspiration. Their rigor, determination and kindness have kept this project on track. My special thanks go to Ray Hoobler, a real mentor. If I had not met him at the City College of New York it is very likely that I would not have studied mathematics. I am grateful to Benjamin Steinberg for his generosity of serving as a committee member and for useful discussions. Thanks to Guido Pezzini for suggesting the problem solved in Chapter 4 and for other helpful suggestions. Thanks to Sage Days 65 and GAeL XXIV for funding support. Last but not least, I would also like to thank my wife, Nina, and family in the US and Korea for their words of advice and their encouragement in my study and life. v

7 Contents Introduction 1 1 Preliminaries The Classification of Spherical Varieties Combinatorial Invariants of Affine Spherical Varieties The Weight Monoid N-Spherical Roots Algorithm and Implementation Combinatorial Invariants The Inputs Subalgorithm I Subalgorithm II Subalgorithm III Subalgorithm IV The Output Implementation of Algorithm Examples The Weight Monoid of SL(10)/Sp(10) The Weight Monoids of SL(7)/S(GL(4) GL(3)) and SL(8)/S(GL(4) GL(4)) Weight Monoids Generated by Sets of Fundamental Weights of G = SL(n + 1) Faces of the Dominant Cone of SL(n) Weight Monoids Generated by Fundamental Weights vi

8 CONTENTS vii Some facts about Σ N (Γ) Proof of Proposition 4.9.(1) and 4.9.(2) Proof of Proposition 4.9.(3) Smooth Weight Monoids of Full Rank for SL(n) Bibliography 112

9 Introduction Let G be a connected reductive algebraic group over C, in which we fix a Borel subgroup B and a closed subgroup H G. The homogeneous space G/H (or the subgroup H) is spherical if B acts on G/H with an open orbit. Examples include flag varieties (where H is parabolic in G) and symmetric spaces (where H is the fixed point set of an involutive automorphism of G). A large part of the interest in spherical subgroups comes from representation theory (Gel fand pairs, multiplicity-free spaces). Indeed, the homogeneous space G/H is spherical if and only if for any simple, rational G-module M, and for any multiplicative character χ of H, the χ-eigenspace of H in M is zero or a line. More generally, one defines a spherical variety as a normal algebraic variety with an action of G and a dense orbit of B. In the case where G is a torus (i.e. G = (C ) k for some k), this recovers the definition of a toric variety. The geometry of spherical varieties combines that of flag varieties (e.g. the Bruhat decomposition and the Borel-Weil-Bott theorem) and of symmetric spaces (e.g. the little Weyl group and its role in equivariant embeddings). For more background information on spherical varieties we refer to [Bri94] in the 1994 ICM proceedings, from which the above was adapted, and to [Tim11]. Before giving a brief overview of the thesis, we introduce some notation and provide some background information. The weight lattice of G is denoted by Λ. It is the character group of T and can be identified with the character group of B. The set of dominant weights of G with respect to B will be denoted by Λ +. It is a finitely generated submonoid of Λ. Highest weight theory says that the irreducible representations of G are classified by the elements of Λ +. We denote by V (λ) the irreducible G-module corresponding to λ Λ +. 1

10 INTRODUCTION 2 An affine G-variety X is spherical if and only if it is normal and the ring C[X] of regular functions on X is multiplicity-free as a representation of G. A combinatorial invariant of such a variety is its weight monoid Γ(X): it is the set of isomorphism classes of irreducible representations of G that occur in the coordinate ring C[X] of X. We identify Γ(X) with a finitely generated submonoid of the monoid Λ + of dominant weight: Γ(X) = {λ Λ + : Hom G (V (λ), C[X]) 0} It is possible for two non-isomorphic affine spherical varieties to have the same weight monoid, but the weight monoid is a complete invariant for smooth affine spherical varieties. Indeed, in the mid 1990s, F. Knop conjectured and in [Los09a] I. Losev proved the following result: Theorem. A smooth affine spherical G-variety X is uniquely determined (up to equivariant isomorphism) by its weight monoid Γ(X). One of the motivations to study smooth affine spherical G-varieties is an application to Hamiltonian K-manifolds where K G is a maximal compact subgroup. These are symplectic K-manifolds which are equipped with a moment map. Locally, a Hamiltonian K-manifold is isomorphic to a smooth affine G-variety [Sja98]. A Hamiltonian K-manifold is called multiplicity free if all symplectic reductions are zero-dimensional. Multiplicity free Hamiltonian K-manifolds have smooth affine spherical varieties as local models [Bri86]. In [Kno11], Knop proved the following two facts: (a) A multiplicity-free Hamiltonian manifold for a connected compact Lie Group is uniquely determined by its generic isotropy group and its moment polytope. (b) Locally, the moment polytope of a multiplicity-free Hamiltonian manifold looks like the weight monoid of a smooth affine spherical variety. Part (a) was known as Delzant s conjecture [Delzant90] and Knop used the theorem above to prove it. The image of the map X Γ(X) that sends a smooth affine spherical variety to its weight monoid is still somewhat mysterious. We call a submonoid Γ of Λ + smooth if it lies in the image of this map, that is, if there

11 INTRODUCTION 3 exists a smooth affine G-variety X such that C[X] = λ Γ V (λ) (1) as G-modules. Combining the combinatorial theory of spherical varieties [LV83, Lun01] and a smoothness criterion of R. Camus [Cam01], Pezzini and Van Steirteghem [PVS16] gave a combinatorial characterization of smooth submonoids of Λ +. In the first part of this thesis we give an implementation of Pezzini and Van Steirteghem s combinatorial characterization as an algorithm in Sage, under the assumption that G = SL(n) and that Γ is a free and G-saturated monoid: We say that Γ is free if there is a subset F of Λ + such that F generates Γ as a monoid and F is linearly independent in Λ. The submonoid Γ of Λ + is G-saturated if the following equality holds in Λ: ZΓ Λ + = Γ If Γ is a G-saturated submonoid of Λ +, then there exists a unique (up to G-equivariant isomorphism) affine spherical G-variety, denoted by X Γ, such that X Γ is the most generic affine spherical G-variety with weight monoid Γ [BCF08]. This is the only affine spherical G-variety of weight monoid Γ which can be smooth. The basic idea of the algorithm is to compute enough combinatorial invariants of X Γ from Γ to determine whether X Γ is smooth. To carry out the implementation of the algorithm we use Sage Math [Sage] by W. Stein. The algorithm determining whether a given weight monoid Γ is smooth or not will be explained in Chapter 2. Then Chapter 3 will be devoted to some examples of the implementation. The second part of this thesis applies the result in [PVS16] to certain families of weight monoids. In our main result, Theorem 4.1, we find all subsets of the set of fundamental weights of SL(n+1) that generate a smooth weight monoid Γ. Before proving it, we discovered this result by running our algorithm for all such subsets for SL(n + 1) with n 12. The algorithm also gave us hints towards the proof. In Theorem 4.42, we show that for SL(n) with n 3 the only smooth, free and G-saturated submonoids of Λ + that have the maximal rank n 1 are Λ + and 2Λ +.

12 Chapter 1 Preliminaries 1.1 The Classification of Spherical Varieties We continue to use the notations from the introduction. One of the most important results in the theory of spherical varieties is their complete (combinatorial) classification. It required two parts: (a) the classification of spherical embeddings G/H X for fixed G/H (b) the classification of spherical subgroups H G for fixed G. Part (a) was done by the Luna-Vust theory in [LV83], see also [Kno91]. Such embeddings are classified by so-called colored fans. The conjectural classification of spherical subgroups of a fixed connected reductive complex algebraic group G was proposed by Luna in [Lun01]: He attached a quadruples of combinatorial data, called spherical homogeneous data to every spherical subgroup H of G; he proposed a conjectural list of axioms explicitly describing (abstract) spherical homogeneous data, and he conjectured that his map {H G : H is a spherical subgroup}/conjugation { homogeous spherical data for G} (1.1) is a bijection. Luna proved his conjecture for groups of type A in [Lun01] and the injectivity of (1.1) was shown (for general G) by Losev in [Los09a]. The surjectivity turned out to be more difficult. In [BP16], Bravi and Pezzini 4

13 Preliminaries 5 completed the proof building on earlier results. There is another geometric proof proposed by Cupit-Foutou [CF14]. We refer to [Bri], [Lun01] and [Tim11] for basic facts about spherical varieties and more information about their combinatorial classification. The combinatorial characterization in [PVS16] of smooth weight monoids is obtained by combining the aforementioned classification of spherical varieties with a (combinatorial) smoothness criterion due to Camus [Cam01]. We give a bit more information about the basic idea behind the characterization. Let Γ be a finitely generated submonoid of Λ +. By [AB05] there exist finitely many affine spherical G-varieties X 1, X 2,..., X d with weight monoid Γ which can be smooth (if Γ is G-saturated, then d = 1). It is possible to determine the homogeneous spherical datum and the colored fan (which consists of just one colored cone ) for each of these varieties directly from Γ. Camus criterion then allows one to decide from this combinatorial information whether X i is smooth. The assumption that Γ is G-saturated, which we make in this thesis, considerably simplifies the required verifications (compare Theorem 4.2 to Theorem 1.12 in [PVS16]). 1.2 Combinatorial Invariants of Affine Spherical Varieties In this section, we briefly recall notions from the theory of affine spherical varieties that we will need in this thesis. As before, let G be a connected complex reductive algebraic group. We fix a Borel subgroup B of G and a maximal torus T contained in B. The set of simple roots of G determined by B and T is denoted by S. The weight lattice of G is denoted by Λ. The weight lattice Λ is the character group of T, and is identified with the character group of B. For α S, we denote the corresponding coroot by α. The set of dominant weights of G with respect to B will be denoted by Λ +. It is a finitely generated submonoid of Λ. Highest weight theory tells us that the elements of Λ + are in natural bijection with the isomorphism classes of irreducible representations of G. We denote by V (λ) the irreducible G- module corresponding to λ Λ +.

14 Preliminaries 6 From Chapter 2 onwards we will take G = SL(n + 1) for some n 1. We can then take B to be the subgroup of upper triangular matrices of determinant 1, and T the subgroup of diagonal matrices of determinant 1. The weight lattice is n+1 Λ = Zε i /Z(ε 1 + ε ε n+1 ) (1.2) i=1 where ε i is the character of T given by ε i (t 1,..., t n+1 ) = t i. The fundamental weights of SL(n + 1) are ω i = ε 1 + ε ε i where i {1, 2,..., n}. Then Λ + = ω 1, ω 2,..., ω n N. The set of simple roots is S = {α 1, α 2,..., α n } where α k = ε k ε k+1 = ω k 1 + 2ω k ω k+1 (1.3) for k {1, 2,..., n}. Here we used the convention that ω 0 = ω n+1 = 0. The set S of simple roots of SL(n+1), or the root system they generate, is denoted by A n. Finally, we recall that the simple coroots α 1, α 2,..., α n Hom Z (Λ, Z) are uniquely determined by where i, j {1, 2,..., n} The Weight Monoid α i, ω j = δ ij. (1.4) Let X be an affine G-variety. Its ring of regular function becomes a G-module for the following action: (g f)(x) = f(g 1 x) for g G, f C[X] and x X. (1.5) Recall that such a variety is spherical if and only if it is normal and C[X] is multiplicity free as a representation of G. Given an affine spherical G-variety X we identify its weight monoid Γ(X) with a submonoid of Λ + : Γ(X) = {λ Λ + : Hom G (V (λ), C[X]) 0}. (1.6) In other words, Γ(X) tells us which irreducible representations of G occur in the coordinate ring C[X] of the variety X.

15 Preliminaries 7 Example 1.1. If G = SL(2) and X = G/T then Γ(X) = 2ω N, where ω is the fundamental weight of SL(2). Definition 1.2. We call a submonoid Γ of Λ + smooth if and only if there exists a smooth affine G-variety X such that C[X] = λ Γ V (λ) (1.7) as G modules, that is, if there exists a smooth affine spherical G-variety X with Γ(X) = Γ. Definition 1.3. Let Γ be a submonoid of the monoid Λ + of dominant weights of G. (a) We say that Γ is free if there is a subset F of Λ + such that F generates Γ as a monoid and F is linearly independent in Λ. (b) We say that Γ is G-saturated if the following equality holds in Λ: ZΓ Λ + = Γ. (1.8) The following lemma is a convenient way of characterizing G-saturated submonoids of Λ + among the free ones. Lemma 1.4 ([BCF08]). Let λ 1, λ 2,, λ k be linearly independent dominant weights. The following are equivalent: (a) the monoid λ 1, λ 2,, λ k N, is G-saturated (b) there exist k simple roots α t1, α t2,, α tk such that λ i, α tj 0 i = j Example 1.5. Let G = SL(4). Γ(X) = ω 1, ω 2 + ω 3, ω 3 N is free, but not G-saturated.

16 Preliminaries N-Spherical Roots In this subsection, X will be an affine spherical G-variety. A second invariant of X, besides Γ(X), is the (finite) set Σ N (Γ) of its N-spherical roots. Roughly speaking, this set measures to what extent the algebra C[X] fails to be graded by Γ(X) : Σ N (X) = C[X] is graded by Γ(X). Definition 1.6. The root monoid R(X) of X is the submonoid of Λ generated by {λ + µ ν : λ, µ, ν Λ + such that C[X] (ν) C[X] (λ) C[X] (µ) C } where for δ Λ + we used C[X] (δ) for the isotypic component of type δ in C[X]. By a theorem of F. Knop [Kno96], the saturation of R(X), i.e., the intersection of the cone and the lattice spanned by R(X), is a free submonoid of Λ. Definition 1.7. Denote by Σ N (X) the set of N-spherical roots of X, which is the basis of the saturation of R(X). Example 1.8. If G = SL(2) and X = G/T, then Σ N (X) = {2α} = {4ω}, where α is the simple root of SL(2). The following proposition is a consequence of results in [BCF08] and [AB05] Proposition 1.9. If Γ is a free and G-saturated submonoid of Λ + then there exists a unique (up to G-equivariant isomorphism) affine spherical G-variety X Γ such that (a) the weight monoid of X Γ is Γ; and (b) if X is an affine spherical G-variety with weight monoid Γ then Σ N (X) Σ N (X Γ ). Remark If Γ is free and G-saturated, then X Γ is the most generic affine spherical variety with weight monoid Γ. This is the only affine spherical variety of weight monoid Γ which can be smooth. Definition Let σ be an element of the root lattice Λ R of G and let σ = α S n α α

17 Preliminaries 9 be its unique expression as a linear combination of the simple roots. The support of σ is supp(σ) := {α S : n α 0}. The type of supp(σ) is the Dynkin type of the subroot system generated by supp(σ) in the root system of G. Definition The set Σ sc (SL(n + 1)) of spherically closed spherical roots of SL(n+1) is the subset of NS defined by: an element σ of NS belongs to Σ sc (SL(n + 1)) if after numbering the simple roots in supp(σ) as in (1.3), σ is listed in Table Table.1.12 Spherically closed spherical roots of type A Type of support σ Σ sc (G) A 1 α A 1 2α A 1 A 1 α + α A r, r 2 α 1 + α α r A 3 α 1 + 2α 2 + α 3 Example Σ sc (SL(4)) = {α 1, α 2, α 3 } {2α 1, 2α 2, 2α 3 } {α 1 + α 3 } {α 1 + α 2, α 2 + α 3, α 1 + α 2 + α 3 } {α 1 + 2α 3 + α 3 }

18 Chapter 2 Algorithm and Implementation In this chapter, we shall describe an algorithm that implements a special case of the combinatorial characterization of the weight monoids of smooth affine spherical varieties given in [PVS16]. Specifically, we implement Theorem 1.12 in [PVS16] (cf. Theorem 2.10 below) under the additional assumptions that G = SL(n + 1) and that the weight monoid Γ is free. We also describe the combinatorial invariants of spherical varieties used in our algorithm. For our implementation of the algorithm we used the mathematical software package SageMath [Sage] written by William Stein and collaborators. SageMath is an interpreter of the Python programming language [Pyth] and is equipped with many useful computational tools and mathematical packages. To explain the steps of the algorithm in the sections of this chapter, we divide the algorithm into four parts. We recall from [PVS16] that given a free and G-saturated monoid Γ of dominant weights there is a unique affine spherical G-variety X Γ with weight monoid Γ which can be smooth. The algorithm determining whether X Γ is smooth or not can be summarized as follows: INPUT. Subroutines in the input system produce the generators of the given weight monoid Γ as a linear combination of fundamental weights of the given group G = SL(n + 1). SUBALGRITHM I. The first part of the algorithm determines the set Σ sc (G) of the spherically closed spherical roots of type A as in Table SUBALGRITHM II. The second part of the algorithm computes some 10

19 Algorithm and Implementation 11 of the Luna invariants of X Γ from Γ: Given Γ and Σ sc (G) (as inputs) the subroutines in this subalgorithm derives a triple of combinatorial data. SUBALGRITHM III. The third part of the algorithm determines whether the computed triple in Subalgorithm II is admissible or not by comparing it to the primitive admissible triples of List 2.8. SUBALGRITHM IV. In this part, the subroutines check the two remaining conditions in Theorem 1.12 of [PVS16]. OUTPUT. Subroutines in the output system of the algorithm produce the main computational result: the given weight monoid Γ is smooth or not. Rather then giving scripts in pseudo code, we have chosen to use a actual computer programming language (Python/SageMath) to illustrate our implementation. Because the primary implementation language of SageMath is Python, our code is written in Python Combinatorial Invariants The Inputs Implementation 2.1. Before inputting the weight monoid Γ, we realize the fundamental weights and simple roots as elements of the weight lattice Λ in Sage. To this end, in Subroutine below we use the built-in Sage Class called RootSystem() which takes the type and rank of the root system as inputs and bring out the root system together with various methods (functions). All the outputs of this subroutine become the global variables of the program throughout the code. Subroutine INPUT: the rank of the root system, the type of the root system OUTPUT: the root system, root lattice, the weight lattice, the set of simple roots and coroots, and set of indexes

20 Algorithm and Implementation 12 rank=input("enter the rank:") Type=input("Enter the type(only type A currently):") R=RootSystem([type,rank]) LR=R.root_lattice() L=R.weight_lattice() alpha=lr.simple_roots() alphacheck=lr.simple_coroots() Lambda=L.fundamental_weights() indexes = L.index_set() If Γ is generated by λ 1, λ 2,, λ k and λ i = α S m i,αω α is the unique expression of λ i as a linear combination of the fundamental weights, then Subroutine takes the input file in which the k n matrix (m i,α ) is stored by the user. The outputs of subroutine generated by Methods of Class RootSystem() are used in Subroutine as inputs. The output of Subroutine is the set of generators of the weight monoid Γ as linear combinations of the fundamental weights of G. Subroutine INPUT: the fundamental weights, file containing the matrix whose rows are coefficients of the generators Γ OUTPUT: the free (G-saturated) weight monoid Γ Λ + def ZGamma(): inputfile=raw_input("enter the file name of the monoid:") infile=open(inputfile, rt ) lambdas=list(lambda) GAMMA=[] while True: line=infile.readline() if not line: break coefficients=[int(p) for p in line.split(, )] weights=[coefficients[i]*lambdas[i] for i in range(len(lambdas))]

21 Algorithm and Implementation 13 if sum(weights)!=0: GAMMA.append(sum(weights)) infile.close() return GAMMA Subalgorithm I This subalgorithm determines the set Σ sc (G) of the spherically closed spherical roots of G = SL(n + 1). Implementation 2.2. Subroutines in this part produce the subsets of Σ sc (G) corresponding to the different types of spherical roots in the Table The input of each subroutine below is the set of simple roots S from Subroutine Subroutine generates the subset of Σ sc (G) consisting of the doubles of simple roots of G: {2α 1, 2α 2,, 2α n } Σ sc (G). Subroutine INPUT: the set of simple roots S OUTPUT: the set {2α : α S} Σ sc (G). def double_roots(alphas): return [2*x for x in alphas] Subroutine generates the subset of Σ sc (G) of spherical roots of G with type of support A 1 A 1 : {α 1 + α 3, α 1 + α 4,, α 1 + α n, α 2 + α 4, α 2 + α 5,, α 2 + α n,, α n 2 + α n } Σ sc (G). Subroutine INPUT: the rank n of the group G, the set of simple roots S OUTPUT: spherically closed spherical roots of G with type of support A 1 A 1 def roots2(n, alphas): ranges = [] for x in range(n): for y in range(x+2, n):

22 Algorithm and Implementation 14 ranges.append((x,y)) ROOTS2 = [] for x,y in ranges: ROOTS2.append(alphas[x] + alphas[y]) return ROOTS2 Subroutine generates the subset of spherical roots of G with type of supports A 2, A 3,, A n : {α 1 + α 2, α 2 + α 3,, α n 1 + α n } {α 1 + α 2 + α 3, α 3 + α 4 + α 5,, α n 2 + α n 1 + α n } {α 1 + α 2 + α 3 + α 4 + α 5 + α α n 2 + α n 1 + α n } Σ sc (G). Subroutine INPUT: the rank n of the group G, the set of simple roots S OUTPUT: the spherically closed spherical roots of G with type of supports A 2, A 3,, A n def plus_roots(n, alphas): size = range(2, n+1) #NOTE: discarding the simple roots ROOTS=[] for root_size in size: l = [] indexes = range(n-root_size+1) for i in indexes: terms = alphas[i:i+root_size] expr = sum(terms) l.append(expr) for k in range(len(l)): ROOTS.append(l[k]) return ROOTS Subroutine generates the subset of spherical roots of G with type of supports A 3 : {α 1 +2α 2 +α 3, α 3 +2α 4 +α 5,, α n 2 +2α n 1 +α n } Σ sc (G).

23 Algorithm and Implementation 15 Subroutine INPUT: the rank n of the group G, the set of simple roots S OUTPUT: spherically closed spherical roots of G with type of support A 3 def roots3(n, alphas): root_size = 3 ROOTS3 = [] for i in range(n - root_size + 1): ROOTS3.append(alphas[i] + 2*alphas[i+1] + alphas[i+2]) return ROOTS Subalgorithm II Given Γ and Σ sc (G) (as inputs) the subroutine in this subalgorithm II derives some of the combinatorial invariants of the spherical variety X Γ. The first combinatorial invariant is S p (Γ), the set of simple roots orthogonal to Γ. It is computed in Subroutine of Implementation 2.3. Definition 2.1. The set of simple roots orthogonal to Γ is Implementation S p (Γ) = {α S : λ, α = 0, λ Γ}. Subroutine produces the matrix form m1 of the free weight monoid Γ Λ + given by the natural pairing λ i, α j between N Q and M Q with i, j {1, 2,, n} the index set of the simple roots of G. To generate the matrix m1 Subroutine uses Methods matrix(), scalar() in Class Matrix() and the data type called double list comprehension in Sage. Subroutine INPUT: the simple coroots S, the index set of the weight lattice Λ, and the generators λ = α S m αω of the weight monoid Γ. OUTPUT: the matrix m1 of the free weight monoid Γ Λ +

24 Algorithm and Implementation 16 def ZGmatrix(ZG): m1=matrix([[zg[i].scalar(alphacheck[j]) \ for j in L.index_set()] for i in range(len(zg))]) return m1 Subroutine takes the matrix m1 and returns a free module ZΓ over the ring of integers Z using Method span() in Class Matrix(). Subroutine INPUT: the matrix m1 of the weight monoid Γ Λ + OUTPUT: the free module ZΓ of rank r with basis λ 1, λ 2,, λ r N def ZGspan(m1): ZGammaSpan=span(m1,ZZ) return ZGammaSpan Subroutine computes the subset S p (Γ) of simple roots S that are orthogonal to the weight monoid Γ using the columns of matrix m1= λ i, α j of the weight monoid Γ. Note that Method is zero() in Class Matrix() is used to determine the orthogonality λ i, α j = 0. Subroutine INPUT: the matrix m1= λ i, α j of the weight monoid Γ Λ +, the set of simple roots S OUTPUT: the set S p (Γ) = {α S : λ, α = 0, λ Γ} def SpGamma(m1): Sp_=[m1.column(k).is_zero() for k in range(len(m1.columns()))] Sp_Gamma=[] for i in range(len(sp_)): if Sp_[i]==True: Sp_Gamma.append(alpha[i+1]) return Sp_Gamma The subroutines in Implementation 2.4 determine the set Σ N (Γ) of N- spherical roots of X Γ. In computing the set of N-spherical roots of X Γ Implementation 2.4 uses Proposition 2.3 below:

25 Algorithm and Implementation 17 Definition 2.2. Let σ Σ sc (G). We define S p (σ) = {α S : σ, α = 0, σ Σ N (Γ)}; S pp (σ) = supp(σ) S p (σ). Proposition 2.3 ([BVS15]). Let Γ be G-saturated monoid of dominant weight and let σ Σ sc (G). Then σ is N-adapted to Γ the following conditions are all satisfied: (i) σ / S. (ii) σ ZΓ. (iii) σ is compatible with S p (Γ),i.e., S pp (σ) S p (Γ) S p (σ), (iv) If σ = 2α, then α, γ 2Z, γ ZΓ. (v) If σ = α + β and α β, then α, γ = β, γ, γ ZΓ. Implementation 2.4. Subroutines in this part of Sub-algorithm II implements the conditions in Proposition 2.3. Later in the algorithm we combine the subroutines to obtain the set Σ N (Γ) of N-spherical roots of X Γ from Γ and the set Σ sc (G) of spherical roots of the given group G. Note that the first item(i) in the proposition 2.3 above is already taken care of in Subroutine 2.2.3: that subroutine generates Σ sc (G) \ S. To implement each statement in Proposition 2.3 we reduce the given problem to the problems of linear algebra (free module over PID) and utilize Class Matrix() with Methods in Sage. The weight monoid Γ has been expressed in terms of a matrix over Z in Subroutine and as a free submodule over the ring Z in Subroutine Subroutine checks the condition (ii) in Proposition 2.3,i.e.,it returns the set of spherical roots σ that are in ZΓ. First, each spherical root σ is expressed in the linear combination of fundamental weights ω. Second, a module is obtained as a span of the spherical root σ in the weight lattice Λ. Method scalar() is used to produce the generator of the submodule by picking the coefficients of the spherical roots σ. Finally, Method is submodule() determines whether the module is a submodule of ZΓ for each σ. Subroutine

26 Algorithm and Implementation 18 INPUT: the lattice of weight monoid ZΓ, the set of spherical roots Σ sc (G) OUTPUT: the set of spherical roots Σ sc (G) of G that satisfy the condition (ii) in proposition 2.3 def is_sigma_in_zgamma(sigmas,zgamma): SIGMA_GAMM=[] for i in range(len(sigmas)): sigma1=l(sigmas[i]) Spa=[sigma1.scalar(alphacheck[j]) for j in L.index_set()] Sigma1=span([Spa],ZZ) if Sigma1.is_submodule(ZGamma)==True: SIGMA_GAMM.append(sigmas[i]) return SIGMA_GAMM Subroutine computes for each spherical root σ in Σ sc (G) the set S p (σ) of the simple roots that are orthogonal to σ. First, each spherical root σ is expressed in the linear combination of fundamental weights ω. Then, using the dual pairing σ, α j with j {1, 2,, n} the subroutine checks the orthogonality for each α in S. Subroutine INPUT: σ Σ sc (G) OUTPUT: S p (σ) = {α S : σ, α = 0} def SpSigma(sigma): #(iii) sigma1=l(sigma) Sp=[sigma1.scalar(alphacheck[j]) for j in L.index_set()] Sp_sigma=[] for i in range(len(sp)): if Sp[i]==0: Sp_sigma.append(alpha[i+1]) return Sp_sigma Subroutine computes for each spherical root σ in Σ sc (G) the set supp(σ) of the support of σ. For each spherical root σ Subroutine 2.4.3

27 Algorithm and Implementation 19 checks whether each term of σ = j S n jα is zero or not. If it is not zero, n j 0, j {1, 2,, n}, then the subroutine returns corresponding simple roots α j. Subroutine INPUT: σ = α j S n jα j Σ sc (G) OUTPUT: supp(σ)= {α j S : n j 0}. def suppsigma(sigma): #(iii) n_alpha=[sigma[j] for j in L.index_set()] Supp_sigma=[] for i in range(len(n_alpha)): if n_alpha[i]!=0: Supp_sigma.append(alpha[i+1]) return Supp_sigma Subroutine checks condition(iii) in Proposition 2.3: S pp (σ) S p (Γ) S p (σ) Notice that the second subset relation S p (Γ) S p (σ) in the condition(iii) is always true because σ ZΓ. Thus, Subroutine checks only the first subset relation S pp (σ) S p (Γ) in the condition(iii). For each spherical root σ in Σ sc (G), Subroutine calls Subroutine to compute S p (Γ), Subroutine to compute S p (σ), and Subroutine to compute supp(σ), and then S pp (σ) = supp(σ) S p (σ) is computed using Methods Set() and intersection() in Class Set() in Sage. Finally, the subset relation S pp (σ) S p (Γ) is determined using Method issubset() in Class Set() in Sage. Subroutine INPUT: the set of spherical roots σ Σ sc (G), the matrix m1 of Γ OUTPUT: the set of spherical roots σ that satisfy condition(iii) in Proposition 2.3. def compatibility(sigmas,m1): #(iii) SIGMA_GAMMA=[] for i in range(len(sigmas)): Sp_sigma=SpSigma(sigmas[i])

28 Algorithm and Implementation 20 Supp_sigma=suppSigma(sigmas[i]) Sp_Gamma=SpGamma(m1) Supp_SpSigma=Set(Supp_sigma).intersection(Set(Sp_sigma)) if Supp_SpSigma.issubset(Set(Sp_Gamma))==True: SIGMA_GAMMA.append(sigmas[i]) return SIGMA_GAMMA Subroutine checks condition (iv) in Proposition 2.3: using the columns of the matrix m1= λ i, α j of the weight monoid Γ. If all the entries in a column of m1 are divisible by 2, then subroutine returns the double of the corresponding simple roots α. Subroutine INPUT: the matrix m1= λ i, α j of Γ, the set of simple roots S OUTPUT: the set of spherical roots of type A 1 i.e., σ = 2α such that α, γ 2Z, γ ZΓ def two_times_alpha(m1): #(iv) Sigma_Gamma=[] for k in range(len(m1.columns())): if m1.column(k) % 2 == 0: Sigma_Gamma.append(2*alpha[k+1]) return Sigma_Gamma Subroutine checks the last condition (v) in Proposition 2.3: It checks: first, the condition α i α j using the dual pairing α i, αj with coroots; second, the condition αi, γ = αj, γ, γ ZΓ using the columns of matrix m1= λ i, αj of the weight monoid Γ. Subroutine returns the set of spherical roots σ = α i + α j of type A 1 A 1 that satisfy condition(v) in Proposition 2.3. Subroutine INPUT: the matrix m1= λ i, α j of Γ, the set of simple roots S and coroots S of G

29 Algorithm and Implementation 21 OUTPUT: the set of spherical roots of type A 1 A 1,i.e., σ = α i + α j with α i α j such that α i, γ = α j, γ, γ ZΓ def alpha_beta(m1): #(v) Sigma_Gamma=[] for i in L.index_set(): for j in L.index_set(): if alpha[i].scalar(alphacheck[j])==0 \ and m1.column(i-1)==m1.column(j-1) \ and alpha[i]+alpha[j] not in Sigma_Gamma: Sigma_Gamma.append(alpha[i]+alpha[j]) return Sigma_Gamma The last part of Subalgorithm II determines a third combinatorial invariant S Γ which we briefly describe now. The affine spherical G-variety X Γ has an open G-orbit. Let H(Γ) be the stabilizer of a point in this orbit, which can be identified with G/H(Γ). The Luna-Vust theory of spherical embeddings [LV83],[Kno91] implies that the equivariant embedding G/H(Γ) X Γ is determined by a certain strictly convex cone in the vector space N Q = Hom Z (ZΓ, Q). Under the assumption that Γ is G-saturated, this cone is spanned by certain simple co-roots of G. Proposition 2.4 determines the corresponding simple roots: Proposition 2.4 ([PVS16]). Let Γ be G-saturated submonoid of Λ +. Among all the subsets F of S such that the relative interior of the cone spanned by {α ZΓ : α F } in Hom Z (ZΓ, Q) intersects V(Γ) there is a unique one, denoted S Γ, that contains all the others. Proposition 2.4 could be implemented using the Fourier-Motzkin elimination algorithm. We have decided to use some existing package in toric geometry instead. We need some more notation to explain our implementation of Proposition 2.4. Let M = ZΓ and N = Hom Z (M, Z) be its dual with the canonical pairing, : M N Z. Denote by N Q = Q Z N and M Q = Q Z M their scalar extensions to Q and by, : M Q N Q Q. Define the cone C Γ = Q 0 {α i ZΓ : α i S \ S p (Γ)} N Q. The so-called the valuation cone of X Γ is

30 Algorithm and Implementation 22 V(Γ) = {v N Q : v, σ 0, σ Σ N (Γ)}. Proposition 2.5. Denote by IC the cone C Γ V(Γ) in N Q. If F min is the minimal face of the cone C Γ containing IC and F max is the maximal face of the cone C Γ whose relative interior meets V(Γ), then F min is equal to F max. In particular, S Γ := S p (Γ) E where E = {α S : α ZΓ F min }. Proof. If F is a face of a cone, we will use F for its relative interior and F for its boundary. In particular, F = F \ F. Proposition 2.5 follows from the following two claims. Claim 1. F max contains IC, which implies F min F max. Proof of Claim.1. Let v IC. Then v C Γ and v V(Γ). Since v C Γ, there exists a face F 1 of C Γ such that v F 1. (a) If v F 1, then v F max because F 1 F max, by the definition of F max, and we are done. (b) If v / F 1, then v F 1. Since F 1 is a union of faces of C Γ whose dimentions are strictly smaller than dim F 1 (See [Ewald]4.4 Lemma(p.15)) there exists a face F 2 of C Γ with dim F 2 < dim F 1 such that v F 2. i. If v F 2, then v F max because F 2 F max and we are done. ii. If v / F 2, then there exists a face F 3 of C Γ with dim F 3 < dim F 2 such v F 3. Since dim C Γ is finite, this process ends with a face F k of C Γ for some k such that v F k, hence, F k F max. This proves Claim.1. Claim 2. There is no face F of C Γ with F F max such that F contains IC. Proof of Claim.2. Suppose that F is a face of C Γ such that F F max and F contains IC. Then IC = C Γ V(Γ) F F max = F max \ F max.

31 Algorithm and Implementation 23 By the definition of F max, we have F max V(Γ). Therefore V(Γ) C Γ (since F max C Γ ). Thus, the fact that IC F max \ F max F max IC which contradicts F max. This proves Claim.2. Remark 2.6. Note that S p (Γ) S Γ since α ZΓ = 0 for all α S p (Γ). The subroutines in Implementation 2.5 implements Proposition 2.5. Implementation 2.5. Subroutines in this part of subalgorithm II implement Proposition 2.5 to obtain S Γ, using the combinatorics of cones in convex geometry. We carry out the computation of S Γ using the Sage Class Cone(), and its Methods ToricLattice() and dual(). Subroutine determines the cone C Γ =:C1 spanned by the coroots α ZΓ restricted to ZΓ such that corresponding simple root α is not in S p (Γ). First, the lattice N = Z r where r is the rank of the free module ZΓ is generated by Method ToricLattice(). Then, the non-zero columns of the matrix m1= λ i, α j of Γ are used to generate the convex rational polyhedral cone C Γ in the vector space N Q. Subroutine INPUT: the matrix m1= λ i, α j of Γ, ZΓ OUTPUT: C1= C Γ = Q 0 {α i ZΓ : α i S \ S p (Γ)} def cones(zg,m1): N=ToricLattice(len(ZG)) Sp_=[m1.column(k).is_zero() for k in range(len(m1.columns()))] Columns=[] for i in range(len(sp_)): if Sp_[i]==False: Columns.append(m1.columns()[i]) C1=Cone(Columns,N) return C1 Recall that the variety X Γ has valuation cone V(Γ) = {v N Q : v, σ 0, σ Σ N (Γ)}.

32 Algorithm and Implementation 24 Thus, the valuation cone V(Γ) can be realized as the opposite of the dual cone to the cone generated by the spherical roots of X Γ in M Q : V(Γ) = (Q 0 Σ N (Γ)) N Q (Γ). Given ZΓ and Σ N (Γ) as inputs Subroutine determines the valuation cone V(Γ) of X Γ. To do this, we first find the coordinates of each σ Σ N (Γ) in the basis {λ 1, λ 2,..., λ r } of ZΓ. Recall that since σ ZΓ, there exists integers b k such that r σ = b k λ k. k=1 Because Γ is free this expression is unique. The first part of Subroutine uses some linear algebra to compute the b k. For i {1,..., r} and j {1,..., n}, let a ij := λ i, αj. Then λ i = n a ij ω j = j=1 n λi, αj j=1 ωj for every i {1,..., r}. We denote the matrix (a ij ) by m1 in Subroutine Let σ i Σ N (Γ) and for every j {1,..., n} let c ij Z such that n σ i = c ij ω j In Subroutine 2.5.2, (m2) ij = c ij = σ i, α j. Solving the linear system j=1 n c ij ω j = j=1 r b k k=1 j=1 n a kj ω j. in the variables b k for every i with 1 i Σ N (Γ), gives us the generators of the convex polyhedral cone C 2 = (Q 0 Σ N (Γ)) in the vector space ZΓ Q = M Q. That is, the i-th column of sigma lambda in Subroutine consists of the coefficients of σ i in terms of the basis {λ 1, λ 2,..., λ r } of ZΓ and C 2 is the cone in M Q generated by the columns of sigma lambda. Using Method dual() in Class Cone() in Sage, Subroutine then determines the convex polyhedral cone C 2 = (Q 0 Σ N (Γ)) in the vector space N Q. Then V(Γ) = C 2. Notice that if Σ N (Γ) =, then V(Γ) = N Q (Γ).

33 Algorithm and Implementation 25 Subroutine INPUT: ZΓ, Σ N (Γ), the set of simple coroots S of G OUTPUT: V(Γ) = {v N Q : v, σ 0, σ Σ N (Γ)} def valuationcone(zg,sigma_gamma): N=ToricLattice(len(ZG)) M=N.dual() if Sigma_Gamma!=[]: m1=matrix([[zg[i].scalar(alphacheck[j]) for j in L.index_set()] for i in range(len(zg))]) m2=matrix([[sigma_gamma[i].scalar(alphacheck[j]) for j in L.index_set()] for i in range(len(sigma_gamma))]) m1t=m1.transpose() m2t=m2.transpose() sigma_lambda=m1t.solve_right(m2t) C2=Cone(sigma_lambda.columns(),M) D=C2.dual() minus_d=-1*d.rays() V=Cone(minus_D.transpose()) else: V=Cone([M(0)]).dual() #if Sigma_Gamma is empty, V=N return V Subroutine of Implementation 2.5 determines the intersection cone IC which is the intersection of C Γ with the valuation cone V(Γ) in the vector space N Q (Γ) associated with coweight lattice Λ using Method intersection() in Class Cone() in Sage. Subroutine INPUT: C Γ,V(Γ) OUTPUT: IC := C Γ V(Γ) def intersectioncone(c1,v): IC=C1.intersection(V) return IC

34 Algorithm and Implementation 26 Given C Γ and IC Subroutine of implementation 2.5 computes the minimal face F min of the cone C Γ that contains all the rays of the intersection cone IC := C Γ V(Γ) using Method intersection() in Class Cone() in Sage. Subroutine INPUT: C Γ, IC OUTPUT: the face F min of the cone C Γ that contains all the rays of the intersection cone IC := C Γ V(Γ) def facescone(c1,ic): Face=[] for j in range(ic.dim(),c1.dim()+1): for k in range(len(c1.faces(j))): Fmin=[C1.faces(j)[k].contains(IC.rays()[l]) for l in range(len(ic.rays()))] if Fmin==[True for i in range(len(fmin))]: Face.append(C1.faces(j)[k]) break if Face!=[]:break return Face Subroutine determines the set S Γ = {α S : α ZΓ F min } S p (Γ) using the matrix m1= λ i, α j of ZΓ and the minimal face F min of the cone C Γ containing all the rays of IC. Notice that if the set {α S : α ZΓ C Γ } turns out to be empty Subroutine will assign the set S P (Γ) as S Γ. Subroutine INPUT: the matrix m1= λ i, α j of Γ, the minimal face F min of the cone C Γ containing IC, the set of simple roots S of G OUTPUT: S Γ = {α S : α ZΓ F min } S p (Γ) def S_Gamma(m1,Face): S_GAMMA=[] for i in range(len(face)): for j in range(len(m1.columns())): if Face[i].contains(m1.column(j)): S_GAMMA.append(alpha[j+1]) return S_GAMMA

35 Algorithm and Implementation Subalgorithm III This part of the algorithm implements condition (c) of Theorem 2.10 below which is [PVS16, Theorem 1.12]. The main part, Implementation 2.6, of Subalgorithm III implements the statement (c) of Theorem That is, the subroutines of Implementation 2.6 determine whether the triples computed in Subalgorithm II are admissible or not using the primitive admissible triples in List 2.8. The following Definition 2.7 and List 2.8 tell us how to determine if given triples are admissible triples. We also need them to state Theorem Definition 2.7. Let S be the set of simple roots of a root system. Let S p be a subset of S. Let Σ N be a subset of NS. We say that the triple (S, S p, Σ N ) is admissible if there exists a finite index set I and for every i I a triple (S i, S p i, ΣN i ) from List 2.8 below and an automorphism f i of the Dynkin diagram of S i such that the Dynkin diagram of S is the union over i I of the Dynkin diagrams of the S i, that S p = i f i (S p i ) and that ΣN = i f i (Σ N i ). List 2.8. Primitive Admissible Triples of Type A (1) (S, S, ) where S is the set of simple roots of an irreducible root system of type A. (2) (A n, {α 2, α 3,..., α n }, ) for n 1. (3) (A n, {α 1, α 3, α 5,..., α n 1 }, {α 1 + 2α 2 + α 3, α 3 + 2α 4 + α 5,..., α n 3 + 2α n 2 + α n 1 }) for n 4, n even. (4) (A n A k, {α k+2, α k+3,..., α n }, {α 1 + α 1, α 2 + α 2..., α k + α k }) for n > k 2. Remark 2.9. We allow I = in Definition 2.7. So, the triple (,, ) is admissible.

36 Algorithm and Implementation 28 Theorem 2.10 ([PVS16], Theorem 1.12). Let Γ be a G-saturated monoid of dominant weights of G. Then Γ is the weight monoid of a smooth affine spherical G-variety if and only if (a) The set {α ZΓ : α S Γ \ S p (Γ)} is a subset of a basis of ZΓ ; and (b) for all α, β S Γ \ S p (Γ) such that α β and α ZΓ = β ZΓ we have α + β ZΓ; and (c) The triple (S Γ, S p (Γ), Σ N (Γ) ZS Γ ) is admissible. Implementation 2.6. With the combinatorial invariants S p (Γ), Σ N (Γ), and S Γ obtained by the previous subalgorithms and the primitive admissible triples of type A in List 2.8, the following Subroutines 2.6.1, 2.6.2, 2.6.3, 2.6.4, 2.6.5, 2.6.6, 2.6.7, 2.6.8, and implement part (c) of the theorem 2.10: In the first part, Subroutine 2.6.1, given S Γ and Σ N (Γ) as inputs, the intersection of the lattice ZS Γ with Σ N (Γ) is computed. In the next part, given the set of simple roots S and S Γ as the inputs, Subroutine determines as the output the set of connected components of (the Dynkin diagram of) S Γ,i.e., {S i S Γ : S i is a connected component of S Γ } Given a subset S i of simple roots S of the root system R, Subroutine implements the non-trivial automorphism f i of the Dynkin diagram of S i S. Recall that a Dynkin diagram of type A has exactly one non-trivial automorphism. Subroutine and Subroutine implement the intersections and the unions of multiple sets, respectively. Subroutine computes for each connected component S i of S Γ the set T i := {σ ZS Γ Σ N (Γ) : supp(σ) S i }. (2.1)

37 Algorithm and Implementation 29 Subroutine computes for each pair S i and S j of connected components of S Γ the set T ij := {σ ZS Γ Σ N (Γ) : supp(σ) (S i S j ) }. (2.2) Given the set T i from Subroutine 2.6.6, Subroutine computes the union σ T i supp(σ) of supports of each spherical roots σ in T i. The heart of Subalgorithm III is Subroutine It decides whether the triple (S Γ, S p (Γ), Σ N (Γ) ZS Γ ) is admissible by looping through the connected components of S Γ. For each connected component S i, it computes the set T i of (2.1). Then two cases are considered: (i) if σ T i supp(σ) S i, then the subroutine checks whether (S i, S p (Γ) S i, T i ) or (f i (S i ), f i (S p (Γ) S i ), f i (T i )) is one of the triples (1),(2), or (3) in List 2.8, where f i is the non-trivial automorphism of S i. (ii) if σ T i supp(σ) S i, then the subroutine checks whether there exists a component S j of S Γ such that S i > S j and σ T i supp(σ) S i S j. If such a component exists, then the subroutine checks whether (τ(s i S j ), τ(s p (Γ) (S i S j )), τ(t i T j )) is the triple (4) in List 2.8, where τ is one of the four automorphisms of S i S j. If neither of the case (i) and (ii) occurs, then the triple (S Γ, S p (Γ), Σ N (Γ) ZS Γ ) is not admissible. We now give the Sage/Python code for Subroutine through Subroutine 2.6.9, with some additional explanations. Given S Γ and Σ N (Γ), Subroutine computes the intersection ZS Γ Σ N (Γ) that adapted to Γ. It does this by collecting the spherical roots σ Σ N (Γ) such that σ Z ZS Γ.

38 Algorithm and Implementation 30 In Subroutine 2.6.1, the rows of the matrix m2= σ i, αj and m3= αi, αj represent the coefficients of each σ Σ N (Γ) and α S Γ, respectively, in the basis {ω 1,..., ω n } of Λ. Method span() in Class FreeModule() in Sage determines the free Z-modules σ i Z with rank 1 for each i {1,..., Σ N (Γ) } and the free Z-module S Γ Z with rank = S Γ. Method is submodule() determines the submodule relation σ i Z ZS Γ for each i {1,..., Σ N (Γ) }. Subroutine INPUT: S Γ, Σ N (Γ) OUTPUT: ZS Γ Σ N (Γ) def Sigma_Gamma_intersection_ZS_Gamma(S_Gamma,Sigma_Gamma): m2=matrix([[sigma_gamma[i].scalar(alphacheck[j]) \ for j in L.index_set()] for i in range(len(sigma_gamma))]) m3=matrix([[s_gamma[i].scalar(alphacheck[j]) \ for j in L.index_set()] for i in range(len(s_gamma))]) ZSigma_Gamma=[span([m2.rows()[i]],ZZ) for i in range(len(m2.rows()))] ZS_Gamma=span(m3,ZZ) Sigma_Gamma_intersection_ZS_Gamma=[] for i in range(len(zsigma_gamma)): if ZSigma_Gamma[i].is_submodule(ZS_Gamma)==True: Sigma_Gamma_intersection_ZS_Gamma.append(Sigma_Gamma[i]) return Sigma_Gamma_intersection_ZS_Gamma In Subroutine 2.6.2, to compute the connected components of S Γ we first determines the set of indices of simple roots α S that are not in S Γ, {i : α i / S Γ, 1 i S }. The second loop then determines the connected components of S Γ by slicing the list of simple roots S with respect to the set of missing indexes miss index. Subroutine INPUT: S and S Γ OUTPUT: {S i S Γ : S i is a connected component of S Γ } def Connected_Components(S_gamma): A=list(alpha) #Simple roots from dictionary type alpha

39 Algorithm and Implementation 31 miss_index=[0] #Set by i=0 the first missing index for i in R.index_set(): if alpha[i] not in S_gamma: miss_index.append(i) miss_index.append(rank+1) #Set the last missing index=rank(g)+1 S_CC=[] #slicing the list A into connected components for i in range(len(miss_index)): if i+1 in range(len(miss_index)): S_CC.append(A[miss_index[i]:miss_index[i+1]-1]) return S_CC Given a connected subset S i of the simple roots S of the (Dynkin diagram) of root system A n, Subroutine implements the non-trivial automorphism f i of the Dynkin diagram of S i S, using the anonymous function lambda and function map in Python. Recall that if S i = {α 1, α 2,..., α N }, then for each k {1, 2,..., N} Subroutine INPUT: S i S OUTPUT: f i (S i ) S f i (α k ) = α N k+1. def AUTO(LIST): N =len(list) auto=[] for k in map(lambda i: N-i+1, range(1,n+1)): auto.append(list[k-1]) return auto Given any multiple sets A i where i I for some index set I Subroutine implements the intersections of the sets. Subroutine INPUT: sets A 1, A 2,..., A r OUTPUT: i I A i