{VERSION 6 0 "IBM INTEL NT" "6.0" } {USTYLETAB {CSTYLE "Maple Input" -1 0 "Courier" 0 1 255 0 0 1 0 1 0 0 1 0 0 0 0 1 }{CSTYLE "2D Math" -1 2 "Times" 0 1 0 0 0 0 0 0 2 0 0 0 0 0 0 1 }{CSTYLE "2D Output" 2 20 "" 0 1 0 0 255 1 0 0 0 0 0 0 0 0 0 1 } {CSTYLE "" -1 256 "" 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 }{PSTYLE "Normal " -1 0 1 {CSTYLE "" -1 -1 "Times" 1 12 0 0 0 1 2 2 2 2 2 2 1 1 1 1 }1 1 0 0 0 0 1 0 1 0 2 2 0 1 }{PSTYLE "Maple Output" -1 11 1 {CSTYLE "" -1 -1 "Times" 1 12 0 0 0 1 2 2 2 2 2 2 1 1 1 1 }3 3 0 0 0 0 1 0 1 0 2 2 0 1 }{PSTYLE "Maple Output" -1 12 1 {CSTYLE "" -1 -1 "Times" 1 12 0 0 0 1 2 2 2 2 2 2 1 1 1 1 }1 3 0 0 0 0 1 0 1 0 2 2 0 1 }} {SECT 0 {EXCHG {PARA 0 "" 0 "" {TEXT -1 85 "This is package SymGroupAl gebra ver. 3 for the group algebra of a symmetric group. \n\n" }{TEXT 256 33 "File SymGroupAlgebra_03_M12.mws\n\n" }{TEXT -1 972 "This is a \+ preliminary attempt to write a small package for computation with grou p algebra of the symmetric group S[n]. This package relies on Maple's \+ \"group\"package which allows for computation in the symmetric group S [n] but not in a group algebra of S[n]. In particular, this package [f or now, a list of procedures] uses the following commands from the \"g roup\" package:\n\n- mulperms - for multiplying permutations written i n disjoint cycle notation, e.g., [[1,2],[3,4,5]], [] (identity element )\n- invperm - for finding inverse of a permutation written in disjoi nt cycle notation\n- parity - for finding parity of a permutation in d isjoint cycle notation\n\nSince Maple uses a list of lists to write a \+ permutation, one needs to create a new way to represent symmetric grou p elements in its group algebra: Remember that Maple automatically add s lists!\n\nNote: This version uses LinearAlgebra package instead of t he old and defunct linalg package.\n\nCookeville, January 6, 2009\n" } }}{EXCHG {PARA 0 "> " 0 "" {MPLTEXT 1 0 0 "" }}}{EXCHG {PARA 0 "> " 0 "" {MPLTEXT 1 0 2020 "restart:\n\nSymGroupAlgebra:=module()\n######### ##########################\nexport SGAversion,split,disjcycform,pmul,p inv,conjugation,PermGroup,sgn,pcollect,pbasis,ActionOnTabloid,\n \+ tableautranspose,fdim,makepartitions,shape_of,content_of,ActionOnGene ralizedTableau,transversal,\n rowdescent,Hminus,Hplus,GroupProdu ct,RowStabilizer,ColumnStabilizer,kappa,kappa_action,is_partition_of, \n ActionOnTableau,associated_polytabloid,make_standard_fill,siz e,YoungSubgroup, \nModuleLoad, ModuleUnload; \n##################### ##############\noption package, load=ModuleLoad , unload=ModuleUnload; \n#################################################################### #################\nSGAversion:= proc()\noptions `Copyright (c) 2008-20 09 by Rafal Ablamowicz and Bertfried Fauser. All rights reserved.`;\nd escription `Revised: January 6, 2009`;\n############################## ###################################################################\np rint(`+++++++++++++++++++++++++++++++++++++++++++`);\nprint(`SymGroupA lgebra - A Maple 12 Small Package for Group Algebra of Symmetric Group `); \nprint(`Last revised: January 6, 2009 (Source file: SymGroupAlgeb ra_03_M12.mws)`);\nprint(`Copyright 2008-2009 by Rafal Ablamowicz(*) a nd Bertfried Fauser(**)`);\nprint(``);\nprint(`(*) Department of Math ematics, Box 5054`);\nprint(` Tennessee Technological University, \+ Cookeville, TN 38505`);\nprint(` tel: USA (931) 372-3622, fax: USA (931) 372-6353`);\nprint(` rablamowicz@tntech.edu`);\nprint(` \+ http://math.tntech.edu/rafal/`);\nprint(`(**) University of Konstanz` );\nprint(` Fachbereich Physik, Fach M678`);\nprint(` Universi t\344tsstrasse 10, D-78457 Konstanz, Germany`);\nprint(` Phone: +4 9 (0)7531 693491`);\nprint(` E-mail: Bertfried.Fauser@uni-konstanz .de`);\nprint(` http://clifford.physik.uni-konstanz.de/~fauser/`); \nprint(``);\nprint(`+++++This is SymGroupAlgebra Package (SGA) ver. 0 3 for Maple 12+++++`);\nend proc:\n################################### ##################################################\n" }}{PARA 0 "" 0 " " {TEXT -1 591 "1. Procedure split will be an internal procedure to th e multiplication procedure pmul later. It takes an element of type cyc basmon, cycmon, or cycpolynom and returns two lists: the first list is a list of the monomial coefficients whereas the second list is a list of monomials of type cycbasmon. There is a 1-to-1 correspondence betw een the entries of these two lists. \n\nThis procedure also can split \+ tabloids, tabloidmons, and polytabloids the same way.\n\nThis procedur e also can split generalized tableaux, generalized tableaux monomials, and generalized tableaux polynomials the same way." }}{PARA 0 "" 0 " " {TEXT -1 0 "" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 1604 "split:=proc(x) \+ local Lxc,Lx,m,aa,bb,L;\noptions `Copyright (c) 2008-2009 by Rafal Abl amowicz and Bertfried Fauser. All rights reserved.`;\n################ ###################################################################### ###########\nLxc,Lx:=[],[]:\nif type(x,cycbasmon) then\n Lxc:=[1]:\n Lx:=[x]:\nelif type(x,cycmon) then\n patmatch(x,a::Algebraic*b::c ycbasmon,'lax');\n Lxc:=subs(lax,[a]):\n Lx:=subs(lax,[b]);\nelif \+ type(x,cycpolynom) then\n L:=[op(expand(x))];\n for m in L do\n \+ patmatch(m,a::Algebraic*b::cycbasmon,'lax');\n Lxc:=[op(Lxc) ,op(subs(lax,[a]))];\n Lx:=[op(Lx),op(subs(lax,[b]))];\n end d o;\nelif type(x,tabloid) then\n Lxc:=[1]:\n Lx:=[x]:\nelif type(x, tabloidmon) then\n patmatch(x,a::Algebraic*b::tabloid,'lax');\n Lx c:=subs(lax,[a]):\n Lx:=subs(lax,[b]);\nelif type(x,polytabloid) the n\n L:=[op(expand(x))];\n for m in L do\n patmatch(m,a::Alge braic*b::tabloid,'lax');\n Lxc:=[op(Lxc),op(subs(lax,[a]))];\n \+ Lx:=[op(Lx),op(subs(lax,[b]))];\n end do;\nelif type(x,generali zedtableau) then\n Lxc:=[1]:\n Lx:=[x]:\nelif type(x,generalizedta bleaumon) then\n patmatch(x,a::Algebraic*b::generalizedtableau,'lax' );\n Lxc:=subs(lax,[a]):\n Lx:=subs(lax,[b]);\nelif type(x,polygen eralizedtableau) then\n L:=[op(expand(x))];\n for m in L do\n \+ patmatch(m,a::Algebraic*b::generalizedtableau,'lax');\n Lxc:=[ op(Lxc),op(subs(lax,[a]))];\n Lx:=[op(Lx),op(subs(lax,[b]))];\n \+ end do;\nelse error `wrong type in split`\nend if:\nreturn Lxc,Lx;\n end proc: \n######################################################### ############################\n" }}{PARA 0 "" 0 "" {TEXT -1 533 "2. Pro cedure 'disjcycform' forces each permutation of type cycbasmon to be w ritten in Maple's standard form in disjoint cycle notation. This proce dure is used by 'pmul' and other procedures, like PermGroup to assure \+ a certain standard way in which permutations are written. For, example permutation p([[6,2]]) is the same as p([[2,6]]) yet form Maple they \+ are different. Thus, in order to assure automatic simplification, the \+ first permutation will be converted to the latter. That is,\n\ndisjcyc form(p([[6,2]]))\n\nreturns p([[2,6]]). \n" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 494 "disjcycform:=proc(pp::\{cycbasmon,listbasmon\}) loca l p3,m:\noptions `Copyright (c) 2008-2009 by Rafal Ablamowicz and Bert fried Fauser. All rights reserved.`;\n################################ #################################################################\np3: =op(1,pp);\nif evalb(p3=[]) then return p([]) end if:\nif type(pp,cycb asmon) then\n m:=max(op(map(op,p3)));\n p3:=convert(p3,'permlist', m);\n p3:=convert(p3,'disjcyc');\nelse\n p3:=convert(p3,'disjcyc') ;\nend if:\nreturn p(p3);\nend proc:\n" }}{PARA 0 "" 0 "" {TEXT -1 197 "3. Procedure 'pmul' gives a product in the group algebra of the s ymmetric group S[n]. It can accpet now two or more inputs, each of one of the basis three types: cycbasmon, cycmon, or cycpolynom. \n" }} {PARA 0 "> " 0 "" {MPLTEXT 1 0 802 "pmul:=proc(p1::\{cycbasmon,cycmon, cycpolynom\},p2::\{cycbasmon,cycmon,cycpolynom\}) local L1,L2,Lc1,Lc2, out,i,j:\noptions `Copyright (c) 2008-2009 by Rafal Ablamowicz and Ber tfried Fauser. All rights reserved.`;\n############################### ##################################################################\nif nargs>=3 then return procname(procname(args[1],args[2]),args[3..nargs ]) end if; \n######################################################### ########################################\nLc1,L1:=SymGroupAlgebra:-spl it(p1):\nLc2,L2:=SymGroupAlgebra:-split(p2):\nout:=add(add(Lc1[j]*Lc2[ i]*SymGroupAlgebra:-disjcycform(p(group:-mulperms(op(1,L2[i]),op(1,L1[ j])))),i=1..nops(Lc2)),j=1..nops(Lc1));\nreturn out; \nend proc:\n#### ###################################################################### ###########\n" }}{PARA 0 "" 0 "" {TEXT -1 201 "4. Procedure 'pinv' tak es inverse of an element of type cycbasmon and cycmon in the group alg ebra. It uses procedure 'invperm' to find the inverse of a permutation written in disjoint cycle notation. \n" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 461 "pinv:=proc(x::\{cycbasmon,cycmon\}) local co,m:\noptions `Cop yright (c) 2008-2009 by Rafal Ablamowicz and Bertfried Fauser. All rig hts reserved.`;\n##################################################### ############################################\nco,m:=SymGroupAlgebra:-s plit(x):\nco:=op(co):\nm:=group:-invperm(op(1,op(m)));\n(co)^(-1)*SymG roupAlgebra:-disjcycform(p(m));\nend proc:\n########################## ###########################################################\n" }} {PARA 0 "" 0 "" {TEXT -1 256 "5. Procedure conjugation performs conjug ation of a permutation or any element in the group algebra p by a perm utation g, that is, it computes the product g p g^\{-1\}. It can also \+ be applied to lists of elements of the type cycbasmon, cycmon, or cycp olynom.\n" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 609 "conjugation:=proc(p:: \{cycbasmon,cycmon,cycpolynom,list(\{cycbasmon,cycmon,cycpolynom\})\}) local g:\noptions `Copyright (c) 2008-2009 by Rafal Ablamowicz and Be rtfried Fauser. All rights reserved.`;\n############################## ###################################################################\ng :=op(procname);\nif type(p,list) then return map(procname[g],p) end if ;\nif not type(g,\{cycbasmon,cycmon\}) then error `parameter in conjug ation must be of type cycbasmon or cycmon` end if:\nreturn pmul(pmul(g ,p),pinv(g));\nend proc:\n############################################ #########################################\n" }}{PARA 0 "" 0 "" {TEXT -1 430 "6. Procedure PermGroup returns elements of the permutation gro up S[n] in disjoint cycle notation. Its argument can be a positive int eger n, in which case it returns elements of the symmetric group on \{ 1,2,...,n\} in disjoint cycle notation; a nonempty list or a nonempty \+ set of distinct positive integers in which case it returns elements of the symmetric group of the elements of the list or the set in disjoi nt cycle notation. \n" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 1354 "PermGrou p:=proc(nL::\{posint,list(posint),set(posint)\}) local L,f,i,Lp,N,m;\n options `Copyright (c) 2008-2009 by Rafal Ablamowicz and Bertfried Fau ser. All rights reserved.`;\n######################################### ########################################################\nif type(nL,p osint) then return map(p,map(convert,combinat:-permute(nL),'disjcyc')) end if;\n############################################################ ##############################\nif type(nL,list(posint)) then\n if e valb(nops(nL)=0) then error `argument list, when used, must not be emp ty: it must contain distinct positive integers` end if:\n if not eva lb(nops(nL)=nops(convert(nL,set))) then error `argument list, when use d, must contain distinct positive integers` end if:\n L:=convert(nL, list)\nelse\n if evalb(nops(nL)=0) then error `argument set, when us ed, must not be empty: it must contain distinct positive integers` end if:\n L:=convert(nL,list)\nend if:\n############################### ###########################################################\nf:=i->L[i ];\nLp:=[seq(i,i=1..nops(L))];\nLp:=map(convert,combinat:-permute(Lp), 'disjcyc');\nN:=[]:\nfor m in Lp do\nif m=[] then N:=[op(N),p([])] els e N:=[op(N),SymGroupAlgebra:-disjcycform(p(map(f,m)))] end if;\nend do ;\nreturn N;\nend proc:\n############################################# ########################################\n" }}{PARA 0 "" 0 "" {TEXT -1 140 "7. Procedure sgn returns +1 if a permutation of type cycbasmon or cycmon is even and -1 if it is odd. It is based on group:-parity f unction\n" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 324 "sgn:=proc(x::\{cycbas mon,cycmon\}) local co,m:\noptions `Copyright (c) 2008-2009 by Rafal A blamowicz and Bertfried Fauser. All rights reserved.`;\n############## ###################################################################### #############\nco,m:=SymGroupAlgebra:-split(x):\nco:=op(co):\ngroup:-p arity(op(1,op(m)));\nend proc:\n" }}{PARA 0 "" 0 "" {TEXT -1 89 "8. Pr ocedure pcollect collects and simplifies polynomials/expressions in a \+ group algebra\n" }{MPLTEXT 1 0 0 "" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 446 "pcollect:=proc(x::\{cycbasmon,cycmon,cycpolynom\}) local s,co,m,s s:\noptions `Copyright (c) 2008-2009 by Rafal Ablamowicz and Bertfried Fauser. All rights reserved.`;\n##################################### ############################################################\ns:=simpl ify(expand(x)):\nif type(s,\{cycbasmon,cycmon\}) then return s end if: \nco,m:=SymGroupAlgebra:-split(s);\nss:=select(type,convert(m,set),cyc basmon);\nreturn collect(s,ss);\nend proc:\n" }}{PARA 0 "" 0 "" {TEXT -1 78 "9. Procedure pbasis returns a list or a set of linearly indepen dent elements.\n" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 1543 "pbasis:=proc( x::\{set(\{cycbasmon,cycmon,cycpolynom\}),list(\{cycbasmon,cycmon,cycp olynom\})\}) local pivotcolumns,listflag,s,ss,M,L,i,bb:\noptions `Copy right (c) 2008-2009 by Rafal Ablamowicz and Bertfried Fauser. All righ ts reserved.`;\n###################################################### ###########################################\npivotcolumns:=proc(M::\{M atrix,matrix,symbol\}) local leftmostnonzero,MM,r,L:\n################ #############################\nleftmostnonzero:=proc(L::list) local fl ag,i;\nflag:=false:\nfor i from 1 to nops(L) while not flag do\n fl ag:=evalb(L[i]<>0);\nend do;\nif flag then return i-1 else return 0 en d if;\nend proc:\n#############################################\nif ty pe(M,matrix) then MM:=convert(M,Matrix) else MM:=M end if:\nr:=LinearA lgebra:-Rank(MM):\nMM:=LinearAlgebra:-GaussianElimination(MM):\nL:=map (convert,[LinearAlgebra:-Row(MM,1..r)],list);\nmap(leftmostnonzero,L); \nend proc:\n######################################################### ########################################\nlistflag:=true:\nif type(x,s et(\{cycbasmon,cycmon,cycpolynom\})) then\n listflag:=false:\n s :=convert(x,list);\nelse\n s:=x:\nend if:\nss:=map(expand,convert(s ,set)):\nss:=map(SymGroupAlgebra:-split,ss);\nss:=select(type,ss,list( \{\{cycbasmon,cycmon,cycpolynom\}\}));\nss:=convert(map(op,ss),list); \nif ss=[] then error `list in pbasis is empty` end if:\nM:=LinearAlge bra:-GenerateMatrix(s,ss)[1];\nM:=LinearAlgebra:-Transpose(M);\nL:=piv otcolumns(M);\nbb:=[seq(s[i],i=L)]:\nif listflag then return bb else r eturn convert(bb,set) end if;\nend proc:\n\n" }}{PARA 0 "" 0 "" {TEXT -1 157 "10. Procedure ActionOnTabloid can apply any element of a group algebra of type cycbasmon, cycmon, or cycpolynom to a tabloid, tabloi dmon, or a polytabloid, \n" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 982 "Acti onOnTabloid:=proc(ta::\{tabloid,tabloidmon,polytabloid\}) local d,perm ,L,f,i,r,coes,ms,coest,mst;\noptions `Copyright (c) 2008-2009 by Rafal Ablamowicz and Bertfried Fauser. All rights reserved.`;\n############ ###################################################################### ###############\nif type(ta,polytabloid) or type(ta,tabloidmon) then d o\n coest,mst:=SymGroupAlgebra:-split(ta);\n mst:=map(procname,mst); \n return add(coest[i]*mst[i],i=1..nops(coest));\n end do:\nend if: \n###############################################\nperm:=op(procname); \nif type(perm,\{cycmon,cycpolynom\}) then do \n coes,ms:=SymGroupAl gebra:-split(perm);\n ms:=[seq(procname[m](ta),m=ms)];\n return ad d(coes[i]*ms[i],i=1..nops(coes));\nend do;\nend if:\nif not type(perm, cycbasmon) then error `cycbasmon expected as parameter` end if:\nd:=ma x(op(map(op,op(1,ta))));\nperm:=op(1,perm);\nif perm=[] then return ta end if:\nL:=convert(perm,'permlist',d);\nf:=i->L[i];\nt([seq(map(f,r) ,r=op(1,ta))]);\nend proc:\n" }}{PARA 0 "" 0 "" {TEXT -1 88 "11. Proce dure tableautranspose takes a transpose of a tableau or a generalized \+ tableau.\n" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 584 "tableautranspose:=pr oc(x::\{tableau,generalizedtableau\}) local L,inrows,mn,m,Lp,M,flag:\n options `Copyright (c) 2008-2009 by Rafal Ablamowicz and Bertfried Fau ser. All rights reserved.`;\n######################################### ########################################################\nL:=op(1,x); \nflag:=type(x,tableau):\ninrows:=map(nops,L);\nmn:=inrows[1];\nLp:=[s eq([op(m),0$(mn-nops(m))],m=L)];\nM:=LinearAlgebra:-Transpose(Matrix(L p));\nLp:=map(convert,[LinearAlgebra:-Row(M,1..mn)],list);\nL:=[seq(re move(member,m,[0]),m=Lp)];\nif flag then return t(L) else return T(L) \+ end if;\nend proc:\n" }}{PARA 0 "" 0 "" {TEXT -1 174 "12. Procedure fd im takes a partition lambda |- n and returns the number of standard la mbda-tableaux. It is based on Determinantal Formula (Theorem 3.1.1 in \+ Sagan, page 132).\n" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 431 "fdim:=proc( lambda::partition) local i,j,l,n,M:\noptions `Copyright (c) 2008-2009 \+ by Rafal Ablamowicz and Bertfried Fauser. All rights reserved.`;\n#### ###################################################################### #######################\nn:=add(i,i=lambda):\nl:=nops(lambda):\nM:=Mat rix(l,l,(i,j)->if (lambda[i]-i+j)<0 then 0 else 1/factorial(lambda[i]- i+j) end if);\nreturn factorial(n)*LinearAlgebra:-Determinant(M);\nend proc:\n" }}{PARA 0 "" 0 "" {TEXT -1 95 "13. Procedure makepartitions \+ takes a positive integer n and returns a list of partitions of n.\n" } }{PARA 0 "> " 0 "" {MPLTEXT 1 0 292 "makepartitions:=proc(n::posint) l ocal s:\noptions `Copyright (c) 2008-2009 by Rafal Ablamowicz and Bert fried Fauser. All rights reserved.`;\n################################ #################################################################\nret urn map(sort,combinat:-partition(n),`>`);\nend proc:\n" }}{PARA 0 "" 0 "" {TEXT -1 118 "14. Procedure shape_of returns shape of a tableau, \+ generalizedtableau, generalizedtableaumon, tabloid, or tabloidmon.\n" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 512 "shape_of:=proc(t::\{tableau,gene ralizedtableau,generalizedtableaumon,tabloid,tabloidmon\}) local s:\no ptions `Copyright (c) 2008-2009 by Rafal Ablamowicz and Bertfried Faus er. All rights reserved.`;\n########################################## #######################################################\nif type(t,\{t ableau,generalizedtableau,tabloid\}) then return map(nops,op(t)) \neli f type(t,\{tabloidmon,generalizedtableaumon\}) then\n s:=op(SymGro upAlgebra:-split(t)[2]):\n return map(nops,op(s))\nend if:\nend pr oc:\n" }}{PARA 0 "" 0 "" {TEXT -1 314 "15. Procedure content_of return a composition mu = (mu[1], mu[2], ... , mu[m]) of a tableau, a genera lizedtableau, generalized tableau mon, a tabloid, or a tabloidmon wher e m is the largest integer appearing in the array whereas mu[i] equals the number of times integer i appears in the array, where 1 <= i <= m . \n" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 564 "content_of:=proc(t::\{tabl eau,generalizedtableau,generalizedtableaumon,tabloid,tabloidmon\}) loc al s,L,m,i:\noptions `Copyright (c) 2008-2009 by Rafal Ablamowicz and \+ Bertfried Fauser. All rights reserved.`;\n############################ ##################################################################### \nif type(t,\{tableau,generalizedtableau,tabloid\}) then L:=op(t) \ne lif type(t,\{tabloidmon,generalizedtableaumon\}) then\n s:=op(SymG roupAlgebra:-split(t)[2]):\n L:=op(s)\nend if:\nL:=map(op,L);\nm:= max(op(L));\n[seq(nops(select(member,L,[i])),i=1..m)];\nend proc:\n" } }{PARA 0 "" 0 "" {TEXT -1 216 "16. Procedure make_standard_fill takes \+ a partition s and returns a tableau of shape s that has been filled in the standard way, that is, 1,2,3,..., d row-wise and then column-wise , where d = size of the partition s.\n" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 390 "make_standard_fill:=proc(s::partition) local d,i,j,k,L,Lp:\no ptions `Copyright (c) 2008-2009 by Rafal Ablamowicz and Bertfried Faus er. All rights reserved.`;\n########################################## #######################################################\nd:=add(i,i=s) ;\nL:=[seq(i,i=1..d)];\nreturn 't'([seq([seq(L[i],i=(1+add(s[k],k=1..( j-1)))..add(s[k],k=1..j))],j=1..nops(s))]);\nend proc:\n" }}{PARA 0 " " 0 "" {TEXT -1 327 "17. Procedure ActionOnGeneralizedTableau applies \+ action of elements from the group algebra C[S_n] to a generalized tabl eau, generalized tableaumon, polygeneralizedtableau, or to a tableau a ccording to the inverse action defined in Sagan page 79, line 3 from t he bottom, i.e.,\n\n(pi T)(i) = T(pi^\{-1\}i);\n(pi t)(i) = t(pi^\{-1 \}i);\n" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 1615 "ActionOnGeneralizedTab leau:=proc(ta::\{tableau,generalizedtableau,generalizedtableaumon,poly generalizedtableau\}) \n local d,perm,L,f, i,r,coes,ms,coest,mst,TT,perminv,LL,sh,flag;\noptions `Copyright (c) 2 008-2009 by Rafal Ablamowicz and Bertfried Fauser. All rights reserved .`;\n################################################################# ################################\nif type(ta,polygeneralizedtableau) o r type(ta,generalizedtableaumon) then do\n coest,mst:=SymGroupAlgebra :-split(ta);\n mst:=map(procname,mst);\n return add(coest[i]*mst[i], i=1..nops(coest));\n end do:\nend if:\n############################## #########################\nperm:=op(procname);\nif type(perm,\{cycmon, cycpolynom\}) then do \n coes,ms:=SymGroupAlgebra:-split(perm);\n \+ ms:=[seq(procname[m](ta),m=ms)];\n return add(coes[i]*ms[i],i=1..nop s(coes));\nend do;\nend if:\n######################################### ########################################################\nif not type( perm,cycbasmon) then error `cycbasmon expected as parameter` end if:\n L:=op(1,ta);\nL:=map(op,L);\nTT:=i->L[i];\nd:=nops(L);\nperminv:=SymGr oupAlgebra:-pinv(perm):\nperminv:=op(1,perminv);\nif perminv=[] then r eturn ta end if:\nLL:=convert(perminv,'permlist',d);\nf:=i->LL[i];\nsh :=SymGroupAlgebra:-shape_of(ta):\n#################################### #############################################################\nflag:=t ype(ta,tableau):\nif not flag then return T([seq(map(TT@f,r),r=op(1,Sy mGroupAlgebra:-make_standard_fill(sh)))]) else\n retur n t([seq(map(TT@f,r),r=op(1,SymGroupAlgebra:-make_standard_fill(sh)))] )\nend if:\nend proc:\n" }}{PARA 0 "" 0 "" {TEXT -1 379 "18. Procedure 'transversal' finds a transversal set of permutations pi such that \n \nS_A_union_B = disjoint union pi (S_A_times_S_B)\n\nwhere A and B are disjoint lists of positive integers, S_A_union_B denotes the permutat ion group of [op(A),op(B)], S_A is the permutation group of the list A , and S_B is the permutation group of the list B. See Definition 2.6. 1 page 70 in Sagan.\n" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 1827 "transver sal:=proc(A::list(posint),B::list(posint)) local AunionB,AunionBp,i,f, Ap,Bp,S_A,S_B,p1,p2,S_A_times_S_B,S_A_union_B,m,N,k,pi:\noptions `Copy right (c) 2008-2009 by Rafal Ablamowicz and Bertfried Fauser. All righ ts reserved.`;\n###################################################### ###########################################\nif not evalb(`intersect`( convert(A,set),convert(B,set))=\{\}) then error `lists of positive int egers must be disjoint` end if:\nAunionB:=[op(A),op(B)]:\nAunionBp:=[s eq(i,i=1..nops(AunionB))];\n########################################## ############\n##Function f maps [1,2,3,...] to [op(A),op(B)]\n##and it is used later to correctly show permutations.\n##This is because conv ersion to 'disjcyc' requires\n##integers 1,2,3,... only.\n############ ##########################################\nf:=i->AunionB[i]:\n####### ###############################################\nS_A:=SymGroupAlgebra: -PermGroup(A);\nS_B:=SymGroupAlgebra:-PermGroup(B);\nS_A_times_S_B:=[s eq(seq(SymGroupAlgebra:-pmul(p1,p2),p1=S_A),p2=S_B)];\nS_A_union_B:=Sy mGroupAlgebra:-PermGroup(AunionB);\n################################## #####################\n##Make pairs Ap and Bp such that |Ap|=|A| and | Bp|=|B|\n#######################################################\nAp:= combinat:-choose(AunionBp,nops(A));\nBp:=[seq(remove(member,AunionBp,m ),m=Ap)];\n########################################################### #########\n##Compute number of cosets such that\n## S_A_union_B = di sjoint union pi(S_A_times_S_B),\n##where the pi's are the transversal \+ \n#################################################################### \nN:=factorial(nops(AunionB))/(factorial(nops(A))*factorial(nops(B))); \nfor k from 1 to N do\n pi||k:= p(map(f,convert([op(Ap[k]),op(Bp[k ])],'disjcyc'))); \nend do;\nreturn map(SymGroupAlgebra:-disjcycform ,[seq(pi||k,k=1..N)]);\nend proc:\n" }}{PARA 0 "" 0 "" {TEXT -1 769 "1 9. Procedure rowdescent acts on a tableau t. It returns an empty list \+ if the tableau t is standard, that is, there are not row descents. If \+ there is a row descent, then it returns a list containing three lists: \n\n[[rowi,columnj], A, B]\n\nwhere [rowi, columnj] are the row/column indices (i,j) of the element t_\{i,j\} in a tableau t where the desce nt occurs, that is, t_\{i,j\} > t_\{i,j+1\}. Then, A is a list of entr ies t_\{i,j\} from the j-th column of the tableau below and including \+ the entry in row rowi, that is, i >= rowi. Furthermore, B is a list of entries t_\{i,j\} from the (j+1)-st column above and including the en try in row rowi, that is, 1 <= i <= row.\n\nFor example, if ta = t([[1 ,2,3,4],[5,7,6],[8,9],[10]]) then rowdescent(ta) returns\n\n[[2,2], \{ 7,9\}, \{3,6\}]\n " }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 1579 "rowdesce nt:=proc(t::tableau) local L,m,n,flag,i,j,rowi,columnj,Lm,M,A,B,Ls;\no ptions `Copyright (c) 2008-2009 by Rafal Ablamowicz and Bertfried Faus er. All rights reserved.`;\n########################################## #######################################################\nif type(t,sta ndardtableau) then return [] end if;\n################################ ##########################\nL:=op(1,t);\nm:=nops(L): #number of row s\nn:=nops(L[1]): #number of columns\n################################ ##########################\nflag:=false:\nfor i from 1 to m while not \+ flag and evalb(nops(L[i])>1) do\n for j from 1 to nops(L[i])-1 w hile not flag do\n flag:=evalb(L[i][j]>L[i][j+1]);\nend do:\n end do:\nif not flag then return [] else \n rowi:=i-1;\n columnj:= j-1;\nend if:\n####################################################### ###\n#Ls:=map(sort,L,`<`);\n#flag:=false: #find row rowi where the fir st descent occurs\n#for i from 1 to m while not flag do\n# flag:= evalb(L[i]<>Ls[i]);\n#end do:\n#if not flag then return [] else \n# \+ rowi:=i-1;\n#end if:\n################################################ ################\n#flag:=false: #find column columnj where the first d escent occurs\n#for j from 1 to nops(L[rowi]) while not flag do\n# \+ flag:=evalb(L[rowi][j]<>Ls[rowi][j]);\n#end do;\n#columnj:=j-1;\n### #############################################################\nLm:=[se q([op(L[i]),0$(n-nops(L[i]))],i=1..m)];\nM:=matrix(m,n,Lm):\nA:=remove (member,[seq(M[i,columnj],i=rowi..m)],[0]):\nB:=remove(member,[seq(M[i ,columnj+1],i=1..rowi)],[0]):\nreturn [[rowi,columnj],A,B];\nend proc: \n" }}{PARA 0 "" 0 "" {TEXT -1 248 "20. Procedures Hplus and Hminus de fine the following elements of a symmetric group algebra for any set H or a list H of permutations pi in S_n:\n\n(a) Hplus(H) = add(pi, pi=H )\n(b) Hminus(H) = add(sgn(pi)*pi,pi=H)\n\nper definition on page 60 i n Sagan.\n" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 285 "Hplus:=proc(pe::\{li st(cycbasmon),set(cycbasmon)\}) local p:\noptions `Copyright (c) 2008- 2009 by Rafal Ablamowicz and Bertfried Fauser. All rights reserved.`; \n#################################################################### #############################\nreturn add(p,p=pe);\nend proc:\n" }} {PARA 0 "> " 0 "" {MPLTEXT 1 0 310 "Hminus:=proc(pe::\{list(cycbasmon) ,set(cycbasmon)\}) local p:\noptions `Copyright (c) 2008-2009 by Rafal Ablamowicz and Bertfried Fauser. All rights reserved.`;\n############ ###################################################################### ###############\nreturn add(SymGroupAlgebra:-sgn(p)*p,p=pe);\nend proc :\n" }}{PARA 0 "" 0 "" {TEXT -1 462 "21. Procedure GroupProduct comput es an external product of two or more permutation groups acting on dis joint sets. Note that it does not check whether the sets on which thes e permutation groups act are disjoint. Thus, GroupProduct(G1, G2,..., \+ Gn) returns a list of products of the form pmul(p1,p2,...,pn) where p1 belongs to G1, p2 belongs to G2, ..., pn belongs to Gn.\n\nNote that \+ each group Gi cen be entered as a list or set of elements of the type \+ cycbasmon.\n" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 556 "GroupProduct:=proc (G::\{list(cycbasmon),set(cycbasmon)\},H::\{list(cycbasmon),set(cycbas mon)\}) local p1,p2:\noptions `Copyright (c) 2008-2009 by Rafal Ablamo wicz and Bertfried Fauser. All rights reserved.`;\n################### ###################################################################### ########\nif nargs=1 then error `at least two groups are needed to com pute external product` end if:\nif nargs>=3 then return procname(procn ame(args[1],args[2]),args[3..nargs]) end if;\nreturn [seq(seq(SymGroup Algebra:-pmul(p1,p2),p1=args[1]),p2=args[2])];\nend proc:\n" }}{PARA 0 "" 0 "" {TEXT -1 163 "22. Procedures RowStabilizer and ColumnStabili zer return a list of elements in the row and column stabilizer of a ta bleau ta per definition in Sagan on page 60. \n" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 503 "RowStabilizer:=proc(ta::tableau) local M,m,n,R:\nopt ions `Copyright (c) 2008-2009 by Rafal Ablamowicz and Bertfried Fauser . All rights reserved.`;\n############################################ #####################################################\nM:=convert(ta,t _to_matrix);\n#M:=convert(M,Matrix);\nm,n:=LinearAlgebra:-Dimension(M) ;\nR:=map(convert,[LinearAlgebra:-Row(M,1..m)],list);\nR:=[seq(remove( member,m,[0]),m=R)];\nreturn SymGroupAlgebra:-GroupProduct(op(map(SymG roupAlgebra:-PermGroup,R)));\nend proc:\n" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 509 "ColumnStabilizer:=proc(ta::tableau) local M,m,n,C:\n options `Copyright (c) 2008-2009 by Rafal Ablamowicz and Bertfried Fau ser. All rights reserved.`;\n######################################### ########################################################\nM:=convert(t a,t_to_matrix);\n#M:=convert(M,Matrix);\nm,n:=LinearAlgebra:-Dimension (M);\nC:=map(convert,[LinearAlgebra:-Column(M,1..n)],list);\nC:=[seq(r emove(member,m,[0]),m=C)];\nreturn SymGroupAlgebra:-GroupProduct(op(ma p(SymGroupAlgebra:-PermGroup,C)));\nend proc:\n" }}{PARA 0 "" 0 "" {TEXT -1 258 "23. Procedure kappa returns C_t^\{-\} for the given tabl eau ta. Thus, kappa is defined as in Sagan on page 61. Recall that kap pa is needed to compute a polytabloid that is associated to the given \+ tableau t. This is accomplished with the procedure kappa_action\n" }} {PARA 0 "> " 0 "" {MPLTEXT 1 0 317 "kappa:=proc(ta::tableau) local H: \noptions `Copyright (c) 2008-2009 by Rafal Ablamowicz and Bertfried F auser. All rights reserved.`;\n####################################### ##########################################################\nH:=SymGrou pAlgebra:-ColumnStabilizer(ta):\nreturn SymGroupAlgebra:-Hminus(H);\ne nd proc:\n" }}{PARA 0 "" 0 "" {TEXT -1 234 "24. Procedure kappa_action takes kappa of a tableau t as an argument and then it computes the ac tion of kappa on the tabloid tb obtained from the tableau ta. Thus, it can compute a polytabloid that is associated with the tableau ta. \n " }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 347 "kappa_action:=proc(ta::tableau ) local k,tb:\noptions `Copyright (c) 2008-2009 by Rafal Ablamowicz an d Bertfried Fauser. All rights reserved.`;\n########################## ###################################################################### #\nk:=op(1,procname);\ntb:=convert(ta,t_to_tabloid):\nreturn SymGroupA lgebra:-ActionOnTabloid[k](tb);\nend proc:\n" }}{PARA 0 "" 0 "" {TEXT -1 458 "25. Procedure is_partition_of checks of the given list of posi tive integers, entered as a first argument, is a partition of a positi ve integer n entered as the second argument. Thus, this procedure retu rns true of \\lambda |- n and false otherwise. Recall that \\lambda |- n if \\lambda is a non increasing sequence of positive integers, i.e. , \\lambda is of type partition and the size of \\lambda is n, that is , the sum of entries in the list \\lambda equals n.\n" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 357 "is_partition_of:=proc(L::list(posint),n::posint ) local nn,m:\noptions `Copyright (c) 2008-2009 by Rafal Ablamowicz an d Bertfried Fauser. All rights reserved.`;\n########################## ###################################################################### #\nif not evalb(sort(L,`>`)=L) then return false end if;\nnn:=add(m,m= L):\nreturn evalb(nn=n);\nend proc:\n" }}{PARA 0 "" 0 "" {TEXT -1 123 "26. Procedure size gives the size of a partition lambda |-n, that is, it returns n = lambda_1 + lambda_2 + ... + lambda_l.\n" }}{PARA 0 "> \+ " 0 "" {MPLTEXT 1 0 274 "size:=proc(p::\{partition,list(posint)\}) loc al i:\noptions `Copyright (c) 2008-2009 by Rafal Ablamowicz and Bertfr ied Fauser. All rights reserved.`;\n################################## ###############################################################\nretur n add(i,i=p);\nend proc:\n" }}{PARA 0 "" 0 "" {TEXT -1 232 "27. Proced ure ActionOnTableau applies a permutation pi from S_n to a tableau t o f shape \\lambda |- n so that pi(t) = (pi(t_\{i,j\})) per definition i n Sagan on page 55. This action is then extended to tabloids \{t\} by \+ ActionOnTabloid.\n" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 1182 "ActionOnTab leau:=proc(ta::\{tableau\}) local d,perm,L,f,i,r,coes,ms,coest,mst,n,s h;\noptions `Copyright (c) 2008-2009 by Rafal Ablamowicz and Bertfried Fauser. All rights reserved.`;\n##################################### ############################################################\nperm:=op (procname);\nif type(perm,\{cycmon,cycpolynom\}) then do \n coes,ms: =SymGroupAlgebra:-split(perm);\n ms:=[seq(procname[m](ta),m=ms)];\n \+ return add(coes[i]*ms[i],i=1..nops(coes));\nend do;\nend if:\n###### #######################################\nif not type(perm,cycbasmon) t hen error `cycbasmon expected as parameter` end if:\nd:=max(op(map(op, op(1,ta)))); #max positive integer d appearing in tableau needs to be \+ <= the largest positive integer in perm\nperm:=op(1,perm);\nif perm=[] then return ta end if:\nn:=max(op(map(op,perm)));\nif not evalb(d>=n) then error `the largest positive integer appearing in tableau needs t o be >= the largest positive integer in the applied permutation` end i f:\nsh:=SymGroupAlgebra:-shape_of(ta);\nif not type(sh,partition) then error `the shape of tableau must be a partition` end if; \nL:=convert (perm,'permlist',d);\nf:=i->L[i];\nt([seq(map(f,r),r=op(1,ta))]);\nend proc:\n" }}{PARA 0 "" 0 "" {TEXT -1 304 "27. Procedure associated_pol ytabloid returns the polytabloid e_t associated to the given tableau t per Definition 2.3.2 in Sagan on page 61. That is, e_t = kappa_t \{t \}. This polytabloid can also be computed using kappa_action[kappa(t)] (t). That is,\n\nassociated_polytabloid(t) = kappa_action[kappa(t)](t) \n" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 369 "associated_polytabloid:=proc (ta::tableau) local k,tb:\noptions `Copyright (c) 2008-2009 by Rafal A blamowicz and Bertfried Fauser. All rights reserved.`;\n############## ###################################################################### #############\nk:=SymGroupAlgebra:-kappa(ta):\ntb:=convert(ta,t_to_tab loid);\nreturn SymGroupAlgebra:-ActionOnTabloid[k](tb);\nend proc:\n" }}{PARA 0 "" 0 "" {TEXT -1 377 "28. Procedure 'YoungSubgroup' for a p artition lambda |- n returns the Young subgroup S_lambda of S_n that i s equal to the product of permutation groups:\n\nS_lambda = S_\{1,... ,lambda_1\} x S_\{lambda_1+1,...,lambda_1+lambda_2\} x S_\{lambda_1+la mbda_2+1,...,lambda_1+lambda_2+lambda_3\} x ... x S_\{n - lambda_l+1,n - lambda_l+2,..., n\}\n\nper Definition 2.1.2 in Sagan on page 54. \+ \n" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 574 "YoungSubgroup:=proc(L::parti tion) local S,n,l,i,j,m:\noptions `Copyright (c) 2008-2009 by Rafal Ab lamowicz and Bertfried Fauser. All rights reserved.`;\n############### ###################################################################### ############\nl:=nops(L):\nn:=SymGroupAlgebra:-size(L):\nif l=1 then r eturn SymGroupAlgebra:-PermGroup(n) end if:\nm[1]:=0:\nfor i from 1 to l do\n if i>1 then m[i]:=add(L[j],j=1..(i-1)) end if:;\n S[ i]:=SymGroupAlgebra:-PermGroup([seq(j,j=m[i]+1..m[i]+L[i])])\nend do: \nreturn SymGroupAlgebra:-GroupProduct(seq(S[i],i=1..l));\nend proc:\n " }}{PARA 0 "" 0 "" {TEXT -1 2526 "Procedure ModuleLoad defines types \+ and any additional useful functions, like conversion `convert/tabloid` that converts a tableau to a tabloid.\n\nHere is a list of types:\n\n - Algebraic - anything of Maple type algebraic which is not of type c ycbasmon or tabloid,\n- cycbasmon - any permutation written in disjoi nt cycle notation as, for example, p([[1,2,3],[5,6],[7]]) where the na me holder p is protected. That is, the argument [[1,2,3],[5,6],[7]] is of Maple type disjcyc from the package 'group',\n- cycmon - any prod uct a*perm where a is of type Algebraic and perm is of type cycbasmon, \n- cycpolynom - a sum or difference of elements of type cycmon, that is, this would be the most general element in a group algebra,\n- ta bleau - tableaux are written as t([[6,3,2],[5,4],[1]]) where t is the name holder preventing Maple from evaluating lists,\n- standardtablea u - a tableau in which rows and columns are increasing,\n- generalized tableau - an array of shape lambda of some partition lambda |- n obta ined by replacing the nodes of lambda with positive integers, repetiti ons allowed. Thus, any tableau is a generalized tableau.\n- generalize dtableaumon - any product a*gt where a is of type Algebraic and gt is of type generalizedtableau,\n- polygeneralizedtableau - a sum or diff erence of elements of type generalizedtableaumon, that is, this would \+ be the most general element in a vector space of generalized tableaux, \n- semistandardtableau - a generalized tableau with weakly increasing rows and strictly increasing columns\n- tabloid - a tabloid is writt en as t([\{6,3,2\},\{5,4\},\{1\}]) where t is the name holder preventi ng Maple from evaluating lists. Procedure `convert/tabloid` converts a tableau t to a tabloid \{t\} [Sagan's notation]\n- tabloidmon - any \+ product a*tb where a is of type Algebraic and tb is of type tabloid, \n- polytabloid - a sum or difference of elements of type tabloidmon, that is, this would be the most general element in a permutation modu le,\n- partition - a list of positive integers arranged in nonincreasi ng order, e.g., [3,2,1], or [2,2], \n\n\nConversions:\n\n- `convert/t _to_tabloid` - converts a tableau t to a tabloid \{t\}\n- `convert/t_t o_generalizedtableau` - converts a tableau t to a generalized tableau, for example, t([[1,2,3],[4,5]]]) converts to T([[1,2,3],[4,5]]])\n- ` convert/t_to_matrix` - converts a tableau to a matrix. Extra cells are filled with 0's.\n- `convert/m_to_tableau` - converts a matrix with n onnegative integer entries to a tableau. Extra 0's, if any, are elimin ated. \n" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 8851 "ModuleLoad:=proc() lo cal i,n,K; \nglobal `type/Algebraic`,`type/listbasmon`,`type/cycbasmon `,`type/cycmon`,`type/cycpolynom`,\n `type/tabl oid`,`type/tabloidmon`,`type/polytabloid`,`type/tableau`,\n \+ `type/standardtableau`,`type/generalizedtableau`,`type/ge neralizedtableaumon`,\n `type/polygeneralizedta bleau`,`type/semistandardtableau`,\n `type/part ition`, \n `convert/t_to_tabloid`,`convert/t_to _generalizedtableau`,`convert/t_to_matrix`,`convert/m_to_tableau`,\n \+ `convert/cycbasmon_to_listbasmon`,`convert/listb asmon_to_cycbasmon`,\n _known_types,_known_con versions;\noptions `Copyright (c) 2008-2009 by Rafal Ablamowicz and Be rtfried Fauser. All rights reserved.`;\n############################## ###################################################################### #########\n_known_types:=[Algebraic,listbasmon,cycbasmon,cycmon,cycpol ynom,tabloid,tabloidmon,polytabloid,tableau,standardtableau,\n \+ generalizedtableau,generalizedtableaumon,polygeneralizedtableau ,semistandardtableau,partition]:\nprint('_known_types'=_known_types); \n#################################################################### #########################################\n_known_conversions:=[`conve rt/t_to_tabloid`,`convert/t_to_generalizedtableau`,\n`convert/t_to_mat rix`,`convert/m_to_tableau`,`convert/cycbasmon_to_listbasmon`,`convert /listbasmon_to_cycbasmon`];\nprint('_known_conversions'=_known_convers ions);\n###############################################\n`type/Algebra ic`:=proc(x) local p:\nif type(x,algebraic) and not type(x,\{cycbasmon ,listbasmon,tabloid,tableau,generalizedtableau,semistandardtableau\}) \+ then return true else return false end if:\nend proc:\n############### ################################\n`type/cycbasmon`:=proc(x):\nif evalb (x=p([])) then return true end if;\nif not type(x,function) then retur n false end if:\nif not evalb(op(0,x)='p') then return false end if;\n if not type(op(1,x),disjcyc) then return false else return true end if ;\nend proc:\n###############################################\n`type/l istbasmon`:=proc(x) local L1,L2,i:\nif evalb(x=p([])) then return true end if;\nif not type(x,function) then return false end if:\nif not ev alb(op(0,x)='p') then return false end if;\nif not type(op(1,x),list(p osint)) then return false end if:\nL1:=op(1,x):\nL2:=[seq(i,i=1..max(o p(L1)))];\nreturn evalb(sort(L1,`<`)=L2);\nend proc:\n################ ###############################\n`type/cycmon`:=proc(x) local a,b:\nif type(x,cycbasmon) then return false end if;\npatmatch(x,a::Algebraic* b::cycbasmon);\nend proc:\n########################################### ####\n`type/cycpolynom`:=proc(x) local xx,L:\nxx:=expand(x):\nif not t ype(xx,`+`) then return false end if;\nL:=\{op(xx)\};\nL:=map(type,L, \{cycmon,cycbasmon\}):\nif L=\{true\} then return true else return fal se end if:\nend proc:\n############################################### \n`type/tabloid`:=proc(x) \nif not type(x,function) then return false \+ end if:\nif not evalb(op(0,x)='t') then return false end if;\nreturn e valb(type(op(1,x),list(set))); \nend proc:\n########################## #####################\n`type/tabloidmon`:=proc(x) local a,b:\nif type( x,tabloid) then return false end if;\npatmatch(x,a::Algebraic*b::tablo id);\nend proc:\n###############################################\n`typ e/polytabloid`:=proc(x) local xx,L:\nxx:=expand(x):\nif not type(xx,`+ `) then return false end if;\nL:=\{op(xx)\};\nL:=map(type,L,\{tabloid, tabloidmon\}):\nif L=\{true\} then return true else return false end i f:\nend proc:\n###############################################\n`type/ tableau`:=proc(x) local L,inrows,n,i;\nif not type(x,function) then re turn false end if:\nif not evalb(op(0,x)='t') then return false end if ;\nif not evalb(type(op(1,x),list(list))) then return false end if;\nL :=op(1,x);\ninrows:=map(nops,L);\nif not type(inrows,partition) then r eturn false end if:\nn:=add(i,i=inrows);\nif not evalb(sort(map(op,L)) =[seq(i,i=1..n)]) then return false end if;\nreturn true;\nend proc:\n ###############################################\n`type/standardtableau `:=proc(x) local L,inrows,n,i,Ls,xt,incols;\nif not type(x,tableau) th en return false end if;\n############################################# ##\n##Checking if entries in rows are increasing\nL:=op(1,x);\ninrows: =map(nops,L);\nLs:=map(sort,L,`<`);\nif not evalb(L=Ls) then return fa lse end if: #entries in rows are not increasing\n##################### ##########################\n##Checking if entries in columns are incre asing\nxt:=SymGroupAlgebra:-tableautranspose(x);\nL:=op(1,xt);\nincols :=map(nops,L);\nLs:=map(sort,L,`<`);\nif not evalb(L=Ls) then return f alse end if: #entries in columns are not increasing\n################# ###############################################################\nretur n true; #entries in rows and columns are increasing\nend proc:\n###### #########################################\n`type/generalizedtableau`:= proc(x) local L;\nif not type(x,function) then return false end if:\ni f not evalb(op(0,x)='T') then return false end if;\nL:=op(1,x);\nretur n type(L,list(list(posint)));\nend proc:\n############################ ###################\n`type/generalizedtableaumon`:=proc(x) local a,b: \nif type(x,generalizedtableau) then return false end if;\npatmatch(x, a::Algebraic*b::generalizedtableau);\nend proc:\n##################### ##########################\n`type/polygeneralizedtableau`:=proc(x) loc al xx,L:\nxx:=expand(x):\nif not type(xx,`+`) then return false end if ;\nL:=\{op(xx)\};\nL:=map(type,L,\{generalizedtableau,generalizedtable aumon\}):\nif L=\{true\} then return true else return false end if:\ne nd proc:\n###############################################\n`type/semis tandardtableau`:=proc(x) local L,inrows,n,i,Ls,xt,incols;\nif not type (x,generalizedtableau) then return false end if;\n#################### ###########################\n##Checking if entries in rows are weakly \+ increasing\nL:=op(1,x);\ninrows:=map(nops,L);\nLs:=map(sort,L,`<=`);\n if not evalb(L=Ls) then return false end if: #entries in rows are not \+ weakly increasing\n###############################################\n## Checking if entries in columns are strictly increasing\nxt:=SymGroupAl gebra:-tableautranspose(x);\nL:=op(1,xt);\nincols:=map(nops,L);\nLs:=m ap(sort,L,`<`);\nif not evalb(L=Ls) then return false end if: #entries in columns are not strictly increasing\n############################# ###############################################################\nretur n true; #entries in rows and columns are increasing\nend proc:\n###### #########################################\n`convert/cycbasmon_to_listb asmon`:=proc(p1::cycbasmon) local n,s:\ns:=0:\n#n:=max(map(op,op(1,p1) ));\nn:=max(op(map(op,op(1,p1)))); ##to make it compatible with Maple \+ 11\nif nargs=2 then \n if not type(args[2],posint) then erro r `second optional argument, when used, must be a positive integer` el se s:=args[2] end if:\nend if: \nreturn p(convert(op(1,p1),'permlist', max(n,s)));\nend proc:\n############################################## #\n`convert/listbasmon_to_cycbasmon`:=proc(p1::listbasmon)\nreturn p(c onvert(op(1,p1),'disjcyc'));\nend proc:\n############################# ##################\n`convert/t_to_tabloid`:=proc(x::tableau) local s: \ns:=op(1,x);\nt(map(convert,s,set));\nend proc:\n#################### ###########################\n`convert/t_to_generalizedtableau`:=proc(x ::tableau) local s:\ns:=op(1,x);\nT(s);\nend proc:\n################## #############################\n#`convert/t_to_matrix`:=proc(t::tableau ) local i,j,m,n,L,Lm,M:\n#L:=op(1,t);\n#m:=nops(L): #number of rows\n# n:=nops(L[1]): #number of columns\n#Lm:=[seq([op(L[i]),0$(n-nops(L[i]) )],i=1..m)];\n#M:=matrix(m,n,Lm):\n#end proc:\n####################### ########################\n#`convert/m_to_tableau`:=proc(M::'matrix'(no nnegint)) local L,m:\n#m:=linalg:-rowdim(M):\n#return t(map2(remove,me mber,map(convert,[linalg:-row(M,1..m)],list),[0])):\n#end proc:\n##### ##########################################\n`convert/t_to_matrix`:=pro c(t::tableau) local i,m,n,L:\nL:=op(1,t);\nm:=nops(L): #number of rows \nn:=nops(L[1]): #number of columns\nreturn Matrix(m,n,[seq([op(L[i]), 0$(n-nops(L[i]))],i=1..m)]):\nend proc:\n############################# ##################\n`convert/m_to_tableau`:=proc(Mm::\{'Matrix'(nonneg int),'matrix'(nonnegint)\}) local L,m,M:\nif type(Mm,'matrix'(nonnegin t)) then M:=convert(Mm,Matrix) else M:=Mm end if:\nm:=LinearAlgebra:-R owDimension(M):\nreturn t(map2(remove,member,map(convert,[LinearAlgebr a:-Row(M,1..m)],list),[0])):\nend proc:\n############################# ##################\n`type/partition`:=proc(L::list(posint)) local s:\n evalb(sort(L,`>`)=L);\nend proc:\n#################################### ###########\nprotect(p,T,t):\n######################################## #######\nalias(epsilon=p([])):\n###################################### #########\nreturn NULL;\nend proc:\n################################## ###########################\n" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 236 "M oduleUnload:=proc() local s:\noptions `Copyright (c) 2008-2009 by Rafa l Ablamowicz and Bertfried Fauser. All rights reserved.`;\n########### ############################################################\nreturn N ULL;\nend proc:\n\nend module:\n" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 12 "savelibname;" }}{PARA 0 "" 0 "" {TEXT -1 125 "Note: If you have not c reated yet your library archive with march command before, unremark th is next command and execute it.\n" }}{PARA 11 "" 1 "" {XPPMATH 20 "6#/ %-_known_typesG71%*AlgebraicG%+listbasmonG%*cycbasmonG%'cycmonG%+cycpo lynomG%(tabloidG%+tabloidmonG%,polytabloidG%(tableauG%0standardtableau G%3generalizedtableauG%6generalizedtableaumonG%7polygeneralizedtableau G%4semistandardtableauG%*partitionG" }}{PARA 11 "" 1 "" {XPPMATH 20 "6 #/%3_known_conversionsG7(%5convert/t_to_tabloidG%@convert/t_to_general izedtableauG%4convert/t_to_matrixG%5convert/m_to_tableauG%@convert/cyc basmon_to_listbasmonG%@convert/listbasmon_to_cycbasmonG" }}{PARA 11 " " 1 "" {XPPMATH 20 "6#Q7C:\\Maple12/Cliffordlib6\"" }}}{EXCHG {PARA 0 "> " 0 "" {MPLTEXT 1 0 19 "with(LibraryTools);" }}{PARA 11 "" 1 "" {XPPMATH 20 "6#72%1ActivationModuleG%1AddFromDirectoryG%'AuthorG%'Brow seG%3BuildFromDirectoryG%/ConvertVersionG%'CreateG%'DeleteG%,FindLibra ryG%,PrefixMatchG%)PriorityG%%SaveG%-ShowContentsG%*TimestampG%4Update FromDirectoryG%*WriteModeG" }}}{EXCHG {PARA 0 "> " 0 "" {MPLTEXT 1 0 25 "ShowContents(libname[1]);" }}{PARA 12 "" 1 "" {XPPMATH 20 "6#7;7&Q *Bigebra.m6\"7(\"%3?\"#7\"#?\"#;\"#=\"#D\"'X&3$\"%_77&Q+Clifford.mF&7( F(F)F*\"#<\"#8\"#V\"&7$>\"%IC7&Q*Cliplus.mF&7(F(F)F*F+F4\"#\\\"'^NX\"$ l$7&Q)Define.mF&7(F(F)F*F+\"#:F,\"'$p%>\"$*[7&Q>P.mF&7(F(F)F*F+\"#K \"#c\"'X\"Q$\"$!G7&Q&GfG.mF&7(F(F)F*F,\"\"'\"#C\"'\"G;(\"%187&Q+matcom pL.mF&7(F(F)F*F+\"#5\"#L\"'e\"=(\"&=X(7&Q+matquatR.mF&FT\"'D1p\"&I?#7& Q+matrealR.mF&FT\"':+Z\"'Wj67&Q+Octonion.mF&7(F(F)F*F+\"#Q\"#P\"'-\\z \"$O%7&Q,RJgrobner.mF&7(F(F)\"#@Feo\"\"$\"#f\"'caj\"%j57&Q5SINGULARPLU RALlink.mF&7(F(F)F*F*\"\"#FH\"'9;?\"$&H7&Q+SchurFkt.mF&7(F(F)F*\"#>\"# N\"#d\"'E$\\%\"%DU7&Q2SymGroupAlgebra.mF&7(\"%4?\"\"\"\"\"%\"\"*\"#E\" \")\"'Bi()\"%a77&Q>_AlternatingGroup_rem_table.mF&7(F(F)F*F*FcpFeo\"%G u\"%Y77&Q:_FiniteGroups_rem_table.mF&Feq\"'!RP%\"%]C7&Q6_Reynolds_rem_ table.mF&Feq\"'W&f#\"&7X#7&Q<_SymmetricGroup_rem_table.mF&Feq\"'`6:\"% LB7&QA_generateGinvariants_rem_table.mF&Feq\"'!oG%\"%Cl7&Q<_implicitbe zierpolynomial.mF&7(F(F)FeoFeoF]qFfo\"'e;J\"&S7\"7&Q/code_support.mF&7 (F(F)F*F3\"#_\"#a\"'R/f\"$v%7&Q+matcompR.mF&FT\"'O&\\$\"&^M(7&Q+matqua tL.mF&FT\"'JkG\"&9@#7&Q+matrealL.mF&FT\"&&\\A\"'9k67&Q%SP.mF&7(F(F)F*F *F4Feo\"'JQU\"%76" }}}{EXCHG {PARA 0 "" 0 "" {TEXT -1 178 "\nOnce you \+ have executed the above command, either you get a message that archive already exists, or, no error message is returned. In either case, rem ark back the above command.\n" }}}{EXCHG {PARA 0 "" 0 "" {TEXT -1 85 " Do not execute the next command unless \"savelibname\" above returns \+ \".../Cliffordlib\"\n" }}}{EXCHG {PARA 0 "> " 0 "" {MPLTEXT 1 0 12 "sa velibname;" }}{PARA 11 "" 1 "" {XPPMATH 20 "6#Q7C:\\Maple12/Cliffordli b6\"" }}}{EXCHG {PARA 0 "> " 0 "" {MPLTEXT 1 0 27 "savelib('SymGroupAl gebra');" }}}{EXCHG {PARA 0 "> " 0 "" {MPLTEXT 1 0 25 "ShowContents(li bname[1]);" }}{PARA 12 "" 1 "" {XPPMATH 20 "6#7;7&Q*Bigebra.m6\"7(\"%3 ?\"#7\"#?\"#;\"#=\"#D\"'X&3$\"%_77&Q+Clifford.mF&7(F(F)F*\"#<\"#8\"#V \"&7$>\"%IC7&Q*Cliplus.mF&7(F(F)F*F+F4\"#\\\"'^NX\"$l$7&Q)Define.mF&7( F(F)F*F+\"#:F,\"'$p%>\"$*[7&Q>P.mF&7(F(F)F*F+\"#K\"#c\"'X\"Q$\"$!G7& Q&GfG.mF&7(F(F)F*F,\"\"'\"#C\"'\"G;(\"%187&Q+matcompL.mF&7(F(F)F*F+\"# 5\"#L\"'e\"=(\"&=X(7&Q+matquatR.mF&FT\"'D1p\"&I?#7&Q+matrealR.mF&FT\"' :+Z\"'Wj67&Q+Octonion.mF&7(F(F)F*F+\"#Q\"#P\"'-\\z\"$O%7&Q,RJgrobner.m F&7(F(F)\"#@Feo\"\"$\"#f\"'caj\"%j57&Q5SINGULARPLURALlink.mF&7(F(F)F*F *\"\"#FH\"'9;?\"$&H7&Q+SchurFkt.mF&7(F(F)F*\"#>\"#N\"#d\"'E$\\%\"%DU7& Q2SymGroupAlgebra.mF&7(\"%4?\"\"\"FN\"\"*F,\"#M\"'.u*)\"%a77&Q>_Altern atingGroup_rem_table.mF&7(F(F)F*F*FcpFeo\"%Gu\"%Y77&Q:_FiniteGroups_re m_table.mF&Fcq\"'!RP%\"%]C7&Q6_Reynolds_rem_table.mF&Fcq\"'W&f#\"&7X#7 &Q<_SymmetricGroup_rem_table.mF&Fcq\"'`6:\"%LB7&QA_generateGinvariants _rem_table.mF&Fcq\"'!oG%\"%Cl7&Q<_implicitbezierpolynomial.mF&7(F(F)Fe oFeo\"\"%Ffo\"'e;J\"&S7\"7&Q/code_support.mF&7(F(F)F*F3\"#_\"#a\"'R/f \"$v%7&Q+matcompR.mF&FT\"'O&\\$\"&^M(7&Q+matquatL.mF&FT\"'JkG\"&9@#7&Q +matrealL.mF&FT\"&&\\A\"'9k67&Q%SP.mF&7(F(F)F*F*F4Feo\"'JQU\"%76" }}} {EXCHG {PARA 0 "> " 0 "" {MPLTEXT 1 0 38 "#Delete('SYmGroupAlgebra',li bname[1]);" }}}{EXCHG {PARA 0 "> " 0 "" {MPLTEXT 1 0 41 "code_support: -NamesInLibrary(libname[1]);" }}{PARA 11 "" 1 "" {XPPMATH 20 "6#%!G" } }{PARA 11 "" 1 "" {XPPMATH 20 "6#%inModule~code_cupport~ver.~1.03~for~ CLIFFORD~et~al.~for~Maple~12G" }}{PARA 11 "" 1 "" {XPPMATH 20 "6#%apCo pyright~(c)~2002-2009~by~Rafal~Ablamowicz~and~Bertfried~Fauser.~All~ri ghts~reserved.G" }}{PARA 11 "" 1 "" {XPPMATH 20 "6#%@Last~revised:~Dec ember~20,~2008G" }}{PARA 11 "" 1 "" {XPPMATH 20 "6#%!G" }}{PARA 11 "" 1 "" {XPPMATH 20 "6#Q+matrealL.m6\"" }}{PARA 11 "" 1 "" {XPPMATH 20 "6 #Q+Clifford.m6\"" }}{PARA 11 "" 1 "" {XPPMATH 20 "6#Q>_AlternatingGrou p_rem_table.m6\"" }}{PARA 11 "" 1 "" {XPPMATH 20 "6#Q<_SymmetricGroup_ rem_table.m6\"" }}{PARA 11 "" 1 "" {XPPMATH 20 "6#Q5SINGULARPLURALlink .m6\"" }}{PARA 11 "" 1 "" {XPPMATH 20 "6#Q)Define.m6\"" }}{PARA 11 "" 1 "" {XPPMATH 20 "6#Q>P.m6\"" }}{PARA 11 "" 1 "" {XPPMATH 20 "6#Q<_i mplicitbezierpolynomial.m6\"" }}{PARA 11 "" 1 "" {XPPMATH 20 "6#Q*Bige bra.m6\"" }}{PARA 11 "" 1 "" {XPPMATH 20 "6#Q+matquatL.m6\"" }}{PARA 11 "" 1 "" {XPPMATH 20 "6#Q6_Reynolds_rem_table.m6\"" }}{PARA 11 "" 1 "" {XPPMATH 20 "6#Q*Cliplus.m6\"" }}{PARA 11 "" 1 "" {XPPMATH 20 "6#Q+ SchurFkt.m6\"" }}{PARA 11 "" 1 "" {XPPMATH 20 "6#Q:_FiniteGroups_rem_t able.m6\"" }}{PARA 11 "" 1 "" {XPPMATH 20 "6#QA_generateGinvariants_re m_table.m6\"" }}{PARA 11 "" 1 "" {XPPMATH 20 "6#Q%SP.m6\"" }}{PARA 11 "" 1 "" {XPPMATH 20 "6#Q+matcompR.m6\"" }}{PARA 11 "" 1 "" {XPPMATH 20 "6#Q/code_support.m6\"" }}{PARA 11 "" 1 "" {XPPMATH 20 "6#Q+matreal R.m6\"" }}{PARA 11 "" 1 "" {XPPMATH 20 "6#Q2SymGroupAlgebra.m6\"" }} {PARA 11 "" 1 "" {XPPMATH 20 "6#Q,RJgrobner.m6\"" }}{PARA 11 "" 1 "" {XPPMATH 20 "6#Q+Octonion.m6\"" }}{PARA 11 "" 1 "" {XPPMATH 20 "6#Q+ma tcompL.m6\"" }}{PARA 11 "" 1 "" {XPPMATH 20 "6#Q&GfG.m6\"" }}{PARA 11 "" 1 "" {XPPMATH 20 "6#Q+matquatR.m6\"" }}}{EXCHG {PARA 0 "> " 0 "" {MPLTEXT 1 0 0 "" }}}{EXCHG {PARA 0 "> " 0 "" {MPLTEXT 1 0 0 "" }}} {EXCHG {PARA 0 "" 0 "" {TEXT -1 27 "Cookeville, January 6, 2009" }}}} {MARK "12 0 0" 0 }{VIEWOPTS 1 1 0 1 1 1803 1 1 1 1 }{PAGENUMBERS 0 1 2 33 1 1 }