##对称函数包：SF版本2.4，普通版。#此版本/版本已于测试#枫树V R3、R4、R5、枫树6、枫树7、枫树9和枫树9.5。##这不是Maple工作表。##在Maple会话期间加载此文件后#可以使用调用序列访问包##平方英尺[]().##为了使用缩写形式的包函数##(),##加载此文件后运行命令“withSF（）”。如果有#这些函数之一的名称与另一个名称之间的冲突#在同一会话中，会打印警告。##为了使用中的程序子集的缩写形式#包，运行命令##带SF(,,...).##有关介绍，请参见# http://www.math.lsa.umich.edu/~jrs/software/SF.ps#有关各个函数的文档，请参阅# http://www.math.lsa.umich.edu/~jrs/software/SFhelp.html##版权所有（c）2005 John R.Stembridge###########################################################################SF:=表格（）：e： ='e'：p:='p'：h:='h'：s：='s'：cl:='cl'：`SF/基数`：={e，h，p，s[]}：##指定短名称，如果发生冲突，则打印警告。#使用SF:=proc（）本地安装，f；install:=进程（x）如果未分配（SF[x]），则错误（cat（x，`不是SF`中的顶级函数）elif eval（x）<>eval（SF[x]），然后如果x=“scalar”或x=“conjugate”，则取消保护（x）fi；如果分配了（x），则printf（`警告：%a\n`，x）fi的新定义；分配（x，SF[x]）fi；x个结束；如果nargs>0，则映射（安装，[args]）elsef： =proc（）映射（op，[args]）结束；#砍掉那些没有完整评估的名字！地图（安装，f（指数（SF））fi（菲涅耳）结束：###定义一个相对于某个内部正交的新基b#乘积ip和三角w.r.t共轭lex-order单项式。#提供可选的分区过程作为参数[3]，以指定#每个b的领先系数[mu]（默认值=1）。#如果最后一个参数（args[3]或args[4]）不是过程，请设置#标志表明该基是三角w.r.t优势序。##注：`SF/iprod`、`SF/lcoffef`和`SF/nondom`都是颠覆性的全球概念。#`SF/add_basis`：=proc（b，ip）local a，n，flag，lc；如果类型（b，‘索引’），则a:=op（0，b），否则a:=b-fi；如果成员（a[]，`SF/Bases`）或成员（a，`SF/Bases`），则错误（cat（`base`，a，`已在使用中`）fi；n： =鼻孔；标志：=类型（args[n]，'procedure'）；如果未标记，则n：=n-1 fi；如果n>2，则lc:=args[3]，否则lc:=1fi；assign（[evaln（`SF/Bases`）={op（`SF/Bases`），a[]}，`SF/iprod`[a]=ip，`SF/lcoeff`[a]=lc，`SF/nondom`[a=flag]）；assign（cat（`to`，b）=proc（）local c，f，d，b，i，v，vars，kill，nr，res，mu，nu；B： =子字符串（进程名，3..长度（进程名））；f： =SF['toe']（参数）；分辨率：=0；nr:=`SF/getrows`（args）；d： =SF['stdeg']（f，'e'）；如果nr=0，则nr:=d，否则nr:=min（nr，d）fi；杀死：=[seq（猫（'e'，i）=0，i=nr+1..d）]；变量：=[seq（cat（'e'，-i），i=-nr.-1）]；而f<>0会c： =tcoeff（f，vars，'v'）；nu:=`SF/shape`（v，'e'，nr）；mu:=SF['conjugate']（nu）；c： =正常（c/`SF/lcoeff`[B]（mu））；res:=c*B[op（mu）]+res；f： =f-c*subs（kill，`SF/added`（B，nu））；f： =`SF/正常`（f，vars，v）；od；物件结束）；“好的”；结束：##假设b是由“add_basis”创建的基，并且sp是#分区或单个分区的列表。#用三个参数替换f0中出现的所有b[mu]#sp中的所有mu及其相应的e展开式。#使用两个参数，假设sp是单个分区，#并返回b[共轭（sp）]的e展开式。#`SF/添加`：=proc（b，sp，f0）local f，mu；如果nargs>2，则f： =子（{seq（b[op（mu）]=`SF/添加/gs`（b，SF['共轭']（mu））[2]，mu=sp）}，f0）其他的f： =`SF/added/gs`（b，sp）[2]fi；sub（映射（x->`SF/added/etable`（x）[1]，SF['varset']（f，e[]）），f）结束：##给定用户添加的基数b，计算并记住电子单项式#b的展开式[mu']（注意：这是共轭（mu），而不是mu）#通过Gram-Schmidt算法。初始订购依据为#电子单项式集合，按字典顺序排列，如“Par”中所示。#结果以[N，f]的形式返回，其中N是平方范数#b[mu’]和f是b[mu'作为集合线性的表达式#术语e[…]的组合，其中（例如）e[3,3,2,1]表示#单项式e3^2*e2*e1。#如果`SF/nondom`[b]为false，则假定基b#相对于支配顺序是三角形的。#未来：收集/归一化系数的最佳频率可能#需要根据接地环和Maple版本进行进一步调整。#`SF/added/gs`：=proc（b，mu）局部g，lc，f，f0，sc，nu，N，c；选项记忆；lc:=`SF/lcoeff`[b]（SF['conjugate']（mu））；f： =lc*e[op（mu）]；g： =`SF/added/etable`（mu）[2]；sc:=[]；nu:=子项（0=NULL，[convert（mu，`+`）]）；N： =lc^2*SF[“标尺”]（g，g，0,0，`SF/iprod`[b]）；而nu<>mu do如果`SF/nondom`[b]或SF['dominate']（nu，mu），则c： =`SF/added/etable`（nu）[2]；c： =正常（SF[‘标尺’]（g，c，0,0，`SF/iprod`[b]）；sc:=[op（sc），e[op（nu）]=c]；f0:=`SF/added/gs`（b，nu）；c： =正常（（lc/f0[1]）*子（sc，f0[2]））；f： =f-c*f0[2]；如果长度（f）>20000，则#见未来f： =集合（f，map（x->op（1，x），sc），‘distributed’，normal）fi；N： =N-c^2*f0[1]；如果长度（N）>1000，则N:=正常（N）fi#参见未来fi；nu:=SF['nextPar']（nu）od；[因子（N），集合（f，map（x->op（1，x），sc），‘distributed’，normal）]；结束：##记住每个电子单项式的两件事：# 1. 替换虚拟变量e[mu]的替换#SF/添加了/gs和实际的电子单项式，以及# 2. “标量”使用的格式中的e单项式的p展开式。#`SF/addd/etable`：=proc（mu）局部v，g，tf，vars，j，d；选项记忆；v： =转换（[seq（cat（'e'，j），j=mu）]，`*`）；d： =op（1，[op（mu），0]）；变量：=[seq（cat（'p'，j），j=1..d）]；g： =系数（SF['top']（v，'e'），vars，'tf'）；[e[op（mu）]=v，[[g]，[tf]，d]]结束：##char2sf（chi）将特征映射应用于类函数chi，#生成一个对称函数作为输出。类功能必须是#表示为特征函数cl[mu]的线性组合#对于不同的分区mu。默认情况下，输出将是一个p多项式。#使用char2sf（chi，b）要求以b为基数的输出。#`SF/char2sf`：=proc（chi，b）局部res，mu；res:=SF['varset']（chi，'cl[]'）；res:=转换（[seq（系数（chi，cl[op（mu）]）*转换（map（x->cat（'p'，x），mu），`*`）/SF['zee']（mu），mu=res）]，`+`）；如果nargs>1，则`SF/apply`（b，res，'p'）else res-fi；结束时间：##共轭（mu）返回分区mu的共轭。#mu必须是一个降序列表。#`SF/共轭`：=proc（mu）局部i，l；l： =nops（mu）；如果l=0，则[]else[l$mu[l]，seq（（-i）$（mu[-i]-mu[1-i]），i=1-l.-1）]fi（菲涅耳）结束：##支配（mu）按支配顺序列出所有分区<=mu#支配（mu，n）的作用相同，但仅适用于行数小于等于n的分区#支配（mu，nu）按支配顺序返回真iff mu>=nu#`SF/discent`：=proc（mu）local n，nu，res，sat，i，j，m，nu0，lam；n： =转换（mu，`+`）；如果nargs>1，则如果类型（args[2]，'list'），则nu:=zip（（x，y）->x-y，mu，args[2]，0）；m： =0；对于nu-do m中的i：=m+i；如果m<0，则返回（假）fiod；返回（true）否则n：=最小值（n，args[2]）fifi；如果nnu0[i+1]+1然后j:=i+1否则j从i+2到m，而nu0[j-1]=nu0[j]做od；fi；如果j>min（n，m+1），则接下来elif j<=m，则lam：=底土（i=nu[i]-1，j=nu[j]+1，nu）else lam:=[op（底土（i=nu[i]-1，nu）），1]fi；如果不是成员（lam，res），则res:=[op（res）、lam]fi；日od；物件结束：##定义一个新的基数b1，该基数与某些现有基数b2是双重的。#提供可选标量产品作为参数[3]（默认值=zee）。##“SF/Bases”、“SF/doual”和“SF/iprod”都是颠覆性的全球性#`SF/dual_base`：=proc（b1，b2）局部a，ip；如果类型（b1，‘索引’），则a:=op（0，b1），否则a:=b1-fi；如果成员（a[]，`SF/Bases`）或成员（a，`SF/Bases`），则错误（cat（`base`，a，`已在使用中`）fi；如果nargs>2，则ip:=args[3]else ip:=SF['zee']fi；assign（[`SF/doual`[a]=`SF/verify`（b2），`SF/iprod`[a]=ip，evaln（`SF/Bases'）={op（`SF/Bases'），a[]}]）；assign（cat（`to`，a）=proc（）局部f，B，B；B： =子字符串（进程名，3..长度（进程名））；b： =`SF/双`[b]；f： =SF['top']（参数）；如果类型（args[nargs]，'list'），则`SF/dial_basis/to`（[f，0]，B，B，args[nargs]）其他的f： =`SF/homog_cmps`（f，'p'）；转换（映射（`SF/dial_basis/to`，f，B，B），`+`）fi（菲涅耳）结束）；“好的”；结束时间：##将p-多项式f0=[f，d]转换为B[mu]的线性组合。#如果有第四个参数，它应该是分区列表#包含f的B支撑。否则，我们不做任何假设#关于B-支撑，除了f是同质度d。#`SF/dial_basis/to`：=proc（f0，B，B）局部f，sp，res，mu，v，j，d；如果nargs>3，则sp:=args[4]，否则sp:=SF['Par']（f0[2]）fi；d： =SF[“变量集”]（f0[1]，'p'）；f： =[系数（f0[1]，[seq（cat（'p'，j），j=1..d）]，'v'）]；f： =[f，[v]，d]；分辨率：=0；对于sp-do中的mu如果类型为（b，'indexed'），则v:=op（0，b）[op（mu）]else v：=转换（map（（x，y）->cat（y，x），mu，b），`*`）fi；v： =SF[‘标尺’]（f，v，0，b，`SF/iprod`[b]）；res:=res+正常（v）*B[op（mu）]；od；物件结束：##假设“a”是通过dual_basis定义的基础。#对于sp中列出的每个分区mu，替换[mu]的所有实例#在对称函数f中具有相应的p多项式。##这需要对每个a-变量进行昂贵的计算，因此我们#通过对每个均质度只执行一次此操作来节约成本#发生在由sp索引的a-变量中。#`SF/dualize`：=proc（a，sp）局部cmps，v，vars，t，f，g，b，pr；b： =`SF/双`[a]；f： =参数[3]；如果nops（sp）=0，则返回（f）fi；cmps:=转换（[seq（a[op（v）]*t^convert（v，`+`），v=sp）]，`+'）；cmps：=映射（indets，[系数（cmps，t）]）；对于cmps do中的vars如果度（f，vars）=1，则f： =集合（f，vars）；#仅适用于Maple V.3pr:=（x，y）->正常（x/y）；f： =`SF/dialize/hg`（f，vars，a，b，pr）其他的g： =转换（[seq（v*t[op（v）]，v=vars）]，`+`）；pr:=proc（x，y）如果类型为（x，`+`），则贴图（（X，Y）->法线（X/Y），X，Y）其他法线（X/Y）结束；g： =`SF/dialize/hg`（g，vars，a，b，pr）；g： =集合（g，[seq（t[op（v）]，v=vars）]）；#Maple V.3所需f： =子（{seq（v=系数（g，t[op（v）]），v=变量）}，f）；fi（菲涅耳）od；（f）结束：##给定一组非空的齐次a-变量，a的对偶基b，#以及在这些a-变量中是线性的对称函数f，#用p-多项式代替f中这些a-变量的出现。#未来：也许值得记住bv。#`SF/dialize/hg`：=proc（f，vars，a，b，pr）局部mu，g，v，sp，i，bv，scp，d；d： =转换（vars[1]，`+`）；如果类型为（b，“索引”），则sp:=映射（（x，y）->[x，y[op（x）]]，vars，op（0，b））；scp:=`SF/dialize/id`；其他的sp:=[seq（[v，convert（map（（（x，y）->cat（y，x），[op（v）]，b），`*`）]，v=vars）]；sp:=sp，[seq（cat（b，i），i=1..d）]；scp:=`SF/dialize/mult`；fi；mu:=子项（0=NULL，[d]）；g： =子（{seq（v=0，v=vars）}，f）；而mu<>NULL dov： =转换（map（x->cat（'p'，x），mu），`*`）；bv:=`SF/apply`（b，v，'p'）；g： =g+pr（scp（f，bv，sp），`SF/iprod`[a]（mu））*v；mu:=SF['nextPar']（亩）od；克结束：##计算f与b表达式bv的标量乘积，给定#f中的a变量和bv中的b变量在sp中成对列出。##b是索引类型的基名称，。。。#`SF/dialize/ind`：=proc（f，bv，sp）局部u；转换（[seq（系数（f，u[1]）*系数（bv，u[2]），u=sp）]，`+`）结束：## ...或b是乘法基名称。#`SF/dualize/mult`：=proc（f，bv，sp，bvars）局部u，g，tms，res，j；g： =[系数（bv，bvars，'tms'）]；tms:=[tms]；分辨率：=0；对于sp-do中的u如果成员（u[2]，tms，'j'），则res:=res+系数（f，u[1]）*g[j]fi；od；物件结束：##evalsf（f，a）在a处生成f的完整性评估。#让一个表示用x=x^j和p.i=p（i*j）代替#a的p展开式中的每个变量x和每个幂和p.i。#然后将p.j=a代入evalsf（f，a）在权力范围内#对于j=1,2,3，…，f的和展开式，。。。#收集并规范输出。#`SF/evalsf`：=proc（）局部f，df，a，da，expr，j，i；f： =SF['top']（参数[1]）；a： =SF['top']（参数[2]）；df:=SF['varset']（f，'p'）；da:=SF['varset']（a，'p'）；expr:=指数（a）减去{seq（cat（'p'，i），i=1..da）}；expr:=子（{seq（i=i^j，i=expr），seq（cat（'p'，i）='cat'（'p`，i*j），i=1..da）}，a）；表达式：=子（{seq（cat（'p'，j）=eval（expr），j=1..df）}，f）；collect（expr，[seq（cat（'p'，i），i=1.da*df）]，'已分配'，正常）结束：##homogcmps（f）将对称函数f分解为齐次函数#组件并返回列表[[f1，d1]，[f2，d2]，…]，其中f1、f2为#分量和d1、d2，。。。是他们的学位（未分类）。#homog_cmps（f，b）的作用是相同的，假设f在基数b中。#`SF/homog_cmps`：=proc（）局部t，sp，i，f，x，b，mu，bases；如果nargs>1，则bases:={args[2]}else bases:=`SF/bases`fi；f： =参数[1]；sp:=SF[变量集]（f，碱基）；对于基数为x的do如果类型（x，“索引”），则b： =op（0，x）；f： =sub（{seq（b[op（mu）]=t^转换（mu，`+`）*b[op，mu）]，mu=sp[b]）}，f）其他的f： =子（{seq（cat（x，i）=t^i*cat（x，i），i=1..sp[x]）}，f）fi（菲涅耳）od；f： =[系数（collect（f，t），t，'sp'）]；拉链（（x，y）->[x，度（y）]，f，[sp]）结束：##hooks（lambda）是lambda中的钩子长度列表。#钩子（lambda，a）是杰克钩子产品。#hooks（lambda，q，t）是双变量hook多项式。#`SF/hooks`：=proc（mu，z，w）局部nu，i，j，q，t；nu:=SF[共轭]（mu）；如果nargs=1，则nu:=[seq（seq（mu[i]-i+nu[j]-j+1，j=1..mu[i]），i=1..nops（mu））]；排序（nu，（x，y）->evalb（x>y））elif nargs=2，则nu:=[seq（seq（z*（mu[i]-j）+nu[j]-i+1，j=1..mu[i]），i=1..nops（mu））]；转换（nu，`*`）其他的nu:=[seq（seq（（1-q^（mu[i]-j）*t^（nu[j]-i+1），j=1..mu[i]）），i=1..nops（mu））]；sub（q=z，t=w，convert（nu，`*`））#Maple在0^0左右还不成熟fi（菲涅耳）结束：##itensor（f，g）计算内部张量积#对称函数f和g的Kronecker积）。#itensor（f，g，b1，b2）的作用与假设f位于基b1中，g位于b2中相同。#itensor（f，g，b）也这样做，但将输出转换为基数b。#（默认基数为“p”）。#itensor（f，g，b1，b2，b）组合了这两个选项。#`SF/itensor`：=proc（）局部b，d，j，f，g，tf，u，c，res，vars；如果nargs>3，则b:=[args[3..4]]，否则b[1]：=NULL；b[2]：=空fi；f： =[seq（SF['top']（args[j]，b[j]），j=1..2）]；d： =SF['varset']（f，'p'）；分辨率：=0；变量：=[seq（cat（'p'，j），j=1..d）]；f： =[[系数（f[1]，vars，'tf'）]，[tf]，[coeff（f[2]，vars、'tf'；如果nops（f[2]）<=nops（f[4]），则g： =zip（（x，y）->[x，y]，f[1]，f[2]）；tf:=f[4]；f： =f[3]其他的g： =zip（（x，y）->[x，y]，f[3]，f[4]）；tf:=f[2]；f： =f[1]fi；对于u in g do如果成员（u[2]，tf，'j'），则c： =SF['zee']（'SF/形状'（u[2]，'p'，d））；res：=res+正常（c*u[1]*f[j]）*u[2]fi；od；如果modp（nargs，2）=1，则`SF/apply`（args[nargs]，res，'p'）else res-fi；结束：##当nrows=0时，计算s[mu]作为Jacobi-Trudi的行列式#e或h的矩阵，以行数较少的版本为准。#提供可选的第三个参数b='e'或b='h'以覆盖选择。#当nrows>0时，n>nrows的所有矩阵变量b.n为#在计算行列式之前终止。#`SF/jt_det`：=proc（mu，nrows）局部b，nu；如果mu=[]，则返回（1）fi；如果nargs>2，则b:=args[3]elif nops（mu）>mu[1]，然后b:='e'其他b:=“h”fi；如果b='e'，则nu:=SF['conjugate']（mu）else nu:=mu-fi；如果nrows>0，则b:=b，nrows-fi；展开（linalg['det']（SF['jt_matrix']（nu，[]，b））；结束时间：##jt_matrix（lambda）生成Jacobi-Trudi矩阵，对应于#隔板λ。#jtmatrix（lambda，mu）的作用相同，但对于由#隔板对lambda，mu（mu=内部形状）。#jtmatrix（lambda，mu，b）的作用相同，但使用b作为#矩阵的条目。#jtmatrix（lambda，mu，b，m）的作用相同，但会杀死所有矩阵#表b.k中的条目表示k>m。#注意，如果lambda=mu=[]，那么结果应该是0x0矩阵。#但Maple（错误地）不允许这样做，所以我们生成了一个1x1矩阵。#`SF/jt_matrix`：=proc（）局部b，n，i，j，mu，nu；mu:=参数[1]；如果nargs>1，则nu:=args[2]，否则nu:=[]fi；如果nargs>2，则b:=args[3..nargs]否则b:='h'fi；n： =最大值（1，nops（mu），nobs（nu））；μ：=[操作（μ），0$n]；nu:=[op（nu），0$n]；数组（[seq（[seq`（`SF/jt_matrix/ent`（mu[i]-i+j-nu[j]，b），j=1..n）]，i=1..n结束：#`SF/jt_matrix/ent`：=进程（k，b）如果k<0，则为0elif k=0，然后为1elif-nargs>2和k>args[3]然后为0else猫（b，k）fi（菲涅耳）结束：##按照字典顺序在mu之后生成下一个分区。#如果mu是最后一个分区（即mu=[1,1，…，1]），则返回NULL。#请注意，这将以与Par（n）相同的顺序生成分区，#但对于较大的n而言，速度明显更快，空间效率更高。##示例：mu:=[9]；而mu<>NULL do; mu:=nextPar（mu）od；#`SF/nextPar`：=proc（mu）局部i，k，m，r；如果成员（1，mu，'i'），则i:=i-1，否则i:=nops（mu）fi；如果i=0，则其他为NULLk： =μ[i]-1；m： =iquo（nops（mu）-i+mu[i]，k，'r'）；如果r=0，则r:=NULL fi；[op（1..i-1，mu），k$m，r]fi（菲涅耳）结束：##ω（f）将ω自同构应用于对称函数f。#ω（f，b1）相同，但假设f以基b1表示。#ω（f，b1，b2）相同，但将输出转换为b2基。##如果没有指定输出基准，结果可能会涉及任何方便的#各种基础功能的组合。#`SF/omega`：=proc（）局部f，sp，j，b，a，b0，mu，b1，bases；f： =参数[1]；b0:={'p'，'h'，'e'，'s[]'}；基数：=`SF/bases`；如果nargs>1，则b1:=`SF/verify`（args[2]）；碱基：={b1}-fi；基数：=基数减去b0；sp:=SF['varset']（f，基数）；对于基数do中的ba： =op（0，b）；如果sp[a]=[]，则下一个fi；如果被赋值（“SF/对偶”[a]），则f： =`SF/对偶`（a，sp[a]，f）；b1:=“p”其他的f： =`SF/added`（a，sp[a]，f）；b1:=“e”fi；如果nargs>1，则f:=`SF/apply`（b1，f，b1）fi；od；b1:=subs（{'e'='h'，'h'='e'}，b1）；sp:=SF['varset']（f，b0）；f： =子（{seq（cat（'e'，j）=猫（'h'，j，j=1..sp['e']）），seq（cat（'h'，j）=猫（'e'，j，seq（cat（'p'，j）=（-1）^（j-1）*cat（‘p'，j），j=1..sp['p']），seq（s[op（mu）]=s[op；如果nargs>2，则`SF/apply`（args[3]，f，b1）else f fi；结束：##Par（n）返回n的所有分区的列表。#Par（n，l）返回长度<=l的n的分区。#Par（n，k，l）返回n的分区，其中部分<=k，长度<=l。##注意：分区列表首先按最大部分进行lex-sorted，#然后是第二大部分等。这种一致性对于#basis-涉及Gram-Schmidt的转换例程。#`SF/Par`：=进程（n）如果nargs=1，则`SF/Par/sub`（n，n，n）elif nargs=2，然后`SF/Par/sub`（n，n，args[2]）else `SF/Par/sub`（参数）fi（菲涅耳）结束：#`SF/Par/sub`：=进程（n，行，列）局部i；如果n=0，则[[]]elif col=0，然后[]其他[seq（op（映射（（x，y）->[y，op（x）]，`SF/Par/sub`（n+i，-i，col-1），-i）），i=-min（行，n）-iquo（n+col-1，col））]fi（菲涅耳）结束：##完整性（f，g）计算对称函数f，g的完整性f[g]。#假设f位于基础b1中，g位于b2中，则完整性（f，g，b1，b2）的作用相同。#plethysm（f，g，b）也这样做，但将输出转换为基数b。#多功能性（f，g，b1，b2，b）两者兼有。默认输出为基本“p”。#`SF/plethysm`：=proc（）局部d，i，f，b；如果nargs>3，则b:=[args[3..4]]其他b[1]：=NULL；b[2]：=空fi；f： =[seq（SF['top']（args[i]，b[i]），i=1..2）]；d： =映射（SF[变量集]，f，'p'）；f： =子（映射（`SF/plethysm/one`，[1..d[1]，d[2]，f[2]），f[1]）；f： =集合（f，[seq（cat（'p'，i），i=1..d[1]*d[2]）]，'分布'，正常）；如果modp（nargs，2）=1，则`SF/apply`（args[nargs]，f，'p'）else f fi；结束：##计算特殊完整性f[g]，其中f=p.r，g具有dg度，#并返回结果作为f的替换。#`SF/体积描记图/one`：=proc（r，dg，g）局部i；cat（'p'，r）=子（{seq（cat（'p'，i）=cat（‘p'，r*i），i=1..dg）}，g）结束：##标量（f，g）计算对称函数f的标量积#和g关于幂和正交的形式#和=泽（亩）。#标量（f，g，b1，b2）的作用是相同的，假设f位于基b1中，g位于b2中。#相对于#幂和正交的形式=Z（亩）。#`SF/标量`：=proc（）局部f，g，tf，ip，b，d，u，mu，j，res；如果nargs=3或nargs=5，则ip:=args[nargs]else ip:=SF['zee']fi；如果nargs>3，则b:=[args[3..4]]其他b[1]：=NULL；b[2]：=空fi；f： =[seq（`SF/scalar/parse`（args[j]，b[j]），j=1..2）]；分辨率：=0；d： =最小值（f[1][3]，f[2][3]）；如果nops（f[1][2]）<=nops（f[2]），则g： =zip（（x，y）->[x，y]，f[1]，f[1][2]）；tf:=f[2][2]；f： =f[2][1]其他的g： =zip（（x，y）->[x，y]，f[2]，f[2]）；tf:=f[1][2]；f： =f[1]fi；对于u in g do如果成员（u[2]，tf，'j'），则mu:=`SF/shape`（u[2]，'p'，d）；res:=res+ip（mu）*u[1]*f[j]；fi（菲涅耳）od；物件结束：##分析由f和基/标志b指定的数据：#如果b=0，假设f=[系数，项，d]代表系数，#项，以及某些p-多项式中出现的最大p.d。返回f。#否则，假设f是以b为基的对称函数（或未知#如果b=NULL，则返回表单）。将f转换为基数p并返回[coeffs，terms，d]。#`SF/scalarl/parse`：=proc（f，b）局部g，i，d，tms；如果nargs>1且b=0，则返回（f）fi；g： =SF['top']（参数）；d： =SF[变量集]（g，'p'）；[[系数（g，[seq（cat（'p'，i），i=1..d）]，'tms'）]，[tms]，d]结束：##sf2char（f）将逆特征映射应用于sym-funf。#结果表示为特征的线性组合#函数cl[mu]用于分区mu。#sf2char（f，b）的作用是相同的，假设f在基数b中。#`SF/sf2char`：=proc（）局部f，i，d，res，cfs，term，mu；f： =SF['top']（参数）；d： =SF['varset']（f，'p'）；cfs:=[系数（f，[seq（cat（'p'，i），i=1..d）]，'term'）]；术语：=[术语]；分辨率：=0；对于i到nops（cfs）domu:=`SF/shape`（术语[i]，'p'，d）；res:=res+SF['zee']（μ）*cfs[i]*cl[op（μ）]；od；物件结束：##skew（f，g）将线性变换f^*应用于g，#其中f^*表示f乘法的伴随。#相对于内积ip，skew（f，g，ip）的作用是相同的。#skew（f，g，b1，b2）的作用是相同的，假设f在基b1中，g在b2中。#skew（f、g、b1、b2、ip）结合了这两种选项。# `SF/skew`：=proc（）局部f，ip，b，vars，i，g；如果modp（nargs，2）=0，则ip:=SF['zee']else ip:=args[nargs]fi；如果nargs>3，则b:=[args[3..4]]，否则b[1]：=NULL；b[2]：=空fi；f： =[seq（SF['top']（args[i]，b[i]），i=1..2）]；f： =映射（（x，y）->映射（`SF/skew/parse`，`SF/homog_cmps`（x，y）），f，'p'）；f： =转换（[seq（op（map（`SF/skew/hg`，f[1]，g，ip）），g=f[2]）]，`+`）；变量：=[seq（cat（'p'，i），i=1.SF[‘varset’]（f，'p'））]；集合（f，vars，‘distributed’，normal）；结束：##给定f=[poly，d]，其中poly是齐次p-多项式#对于度d，返回三元组[系数，项，d]。#`SF/skew/parse `：=进程（f）局部i，tf；[[coeffs（f[1]，[seq（cat（'p'，i），i=1..f[2]）]，'tf'）]，[tf]，f[2]结束：##将f^*应用于g，假设f和g是齐次p-多项式#由skew/parse的输出构成。#`SF/skew/hg`：=proc（f，g，ip）局部d，c，mu，v，res；d： =克[3]-夫[3]；如果d<0，则返回（0）fi；μ：=子（0=NULL，[d]）；分辨率：=0；而mu<>NULL dov： =转换（map（x->cat（'p'，x），mu），`*`）；c： =[f[1]，映射（（x，y）->x*y，f[2]，v），g[3]；c： =SF[“标尺”]（g，c，0,0，ip）；res：=res+正常（c/ip（mu））*v；mu:=SF['nextPar']（mu）；od；物件结束：##stdeg（f）确定了fw.r.t.的等级标准。#stdeg（f，b）也这样做，但假设f在基数b中。#`SF/stdeg`：=proc（）局部f，bases，b，b，i，sp，t；如果nargs>1，则bases:={args[2]}else bases:=`SF/bases`fi；f： =参数[1]；sp:=SF['varset']（f，基数）；对于基数do中的b如果类型（b，‘索引’），则b:=op（0，b）；f： =sub（{seq（B[op（i）]=t^转换（i，`+`）*B[op[i）]，i=sp[B]）}，f）其他的f： =子（{seq（cat（b，i）=t^i*猫（b，i），i=1..sp[b]）}，f）fi（菲涅耳）od；度（f，t）结束：##subPar（mu）返回适合mu图的所有分区。#subPar（mu，n）的作用相同，仅限于n的分区集。#`SF/subPar`：=proc（mu，n）局部m，i，l，nu，j；l： =nops（μ）；如果nargs=1，则如果mu=[]，则返回（[[]]）fi；对于i到l-1，而mu[i]=mu[i+1]做od；如果mu[i]>1，则j:=mu[i]-1，否则j:=NULL fi；[seq（[mu[1]$i，op（nu）]，nu=`SF/subPar`（[op（i+1..l，mu）]），op（`SF/subPar`（底土（i=j，mu））]其他的m： =转换（mu，`+`）；如果n>m或n<0，则返回（[]）elif n=m，然后返回（[mu]）fi；对于i到l-1，而mu[i]=mu[i+1]做od；如果mu[i]>1，则j:=mu[i]-1，否则j:=NULL fi；[seq（[mu[1]$i，op（nu）]，nu=`SF/subPar`（[op（i+1..l，mu）]、n-i*mu[1]）），op（`SF/subPar`（底土（i=j，mu），n））]fi（菲涅耳）结束：##θ（f，a）将自同构p.j->a*p.j应用于f。#θ（f，q，t）将自同构p.j->（1-q^j）/（1-t^j）*p.j应用于f。#`SF/theta`：=过程（g，q，t）局部f，d，j，vars；f： =SF【顶部】（g）；d： =SF['varset']（f，'p'）；变量：=[seq（cat（'p'，j），j=1..d）]；如果nargs=2，则f： =子（{seq（vars[j]=q*vars[j]，j=1..d）}，f）elif nargs=3那么f： =子（{seq（变量[j]=（1-q^j）/（1-t^j）*vars[j]，j=1..d）}，f）其他的错误（`参数数量错误`）fi；集合（f，vars，‘distributed’，normal）；结束：##toe（f）将对称函数f转换为e多项式。#假设f仅以b为基础表示，则toe（f，b）的作用相同。#收集关于e1、e2、e3…的最终结果，。。。#如果b不是预定义的基，则f在b[..]中必须是*线性*。#`SF/toe`：=proc（）局部f，bases，sp，i，mu，d，b，c，nrows；nrows:=`SF/getrows`（args）；f： =参数[1]；bases:=`SF/getbase`（args）减去{'e'}；sp:=SF['varset']（f，碱基减去{'p'，'h'}）；对于基数为负{'h'，'p'，'s[]'}do的bc： =op（0，b）；如果sp[c]=[]，则下一个fi；如果分配（`SF/双`[c]），则f： =“SF/二元化”（c，sp[c]，f）；基数：={op（基数），'p'}其他的f： =`SF/添加的`（c，sp[c]，f）fi（菲涅耳）od；如果成员（'s[]'，基数），则b:='e'；如果nops（sp['s']）>1且nrows=0，则b:=NULL；碱基：={op（碱基），'h'}-fi；f： =子（{seq（s[op（mu）]=`SF/jt_det`（mu，nrows，b），mu=sp[s']）}，f）；fi；如果nrows>0，则d： =SF['varset']（f，'e'）；f： =子（{seq（cat（'e'，i）=0，i=nrows+1..d）}，f）fi；如果成员（'p'，碱基），则f:=`SF/to_ehp'（'p'，'e'，f，nrows）fi；如果成员（'h'，基数），则f:=`SF/to_ehp`（'h]，'e'，f，nrows）fi；d： =SF['varset']（f，'e'）；集合（f，[seq（cat（'e'，i），i=1..d）]，‘已分配’，正常）；结束时间：##假设b1和b2是{e，h，p}的（不同的）成员。#to_ehp（b1，b2，f）取所有出现的变量b1.i，i=1,2，。。。在里面#f并替换变量b2.i，i=1,2，…中的等价表达式，。。。#重新设计为v2.4：我们现在使用卷积恒等式。似乎是这样#更快速、更节省空间的高度数。#此外，它的扩展速度更快，空间效率略高#当地面场为Q时，一次一个变量，但最好#在一个有理函数域上立即收集整个数据。#`SF/to_ehp`：=进程（b1，b2）局部i，f，d，g，sp，vars；f： =参数[3]；d： =SF['varset']（f，{b1，b2}）；如果d[b1]=0，则返回（f）fi；g： =`SF/to_ehp/subs`（b1，b2，d[b1]，args[4..nargs]）；sp:=[seq（cat（b1，i），i=1..d[b1]）]；变量：=[op（sp），seq（cat（b2，i），i=1..d[b2]）]；如果类型（f，‘polynom’（‘rational’，vars）），则vars:=指数（f）相交{op（sp）}；对于i到d[b1]do如果成员（sp[i]，vars），则f:=展开（sub（sp[i]=g[i]、f））fiod；（f）其他的sub（{seq（sp[i]=g[i]，i=1..d[b1]）}，f）fi（菲涅耳）结束：##创建一个数组，其第i项是b1.i，i=1..d的b2-展开。#`SF/to_ehp/subs`：=进程（b1，b2，d）本地dr，i，k，vars，g，sig；如果nargs>3且args[4]>0，则dr:=min（d，args[4]），否则dr:=d-fi；如果b1=‘e’或b2=‘e变量：=[seq（（-1）^（i-1）*cat（b2，i），i=1..dr），0$（d-dr）]其他的变量：=[seq（cat（b2，i），i=1..dr），0$（d-dr）]fi；g： =数组（0..d，[0=1]）；如果b2=“p”，则对于k到d dog[k]：=展开（转换（[seq（g[k-i]*vars[i]，i=1..k）]，`+`））/kod；elif b1='p'则如果b2='h'，则vars:=map（x->-x，vars）；sig:=-1其他sig:=1 fi；对于k到d dog[0]：=sig*k；g[k]：=展开（转换（[seq（g[k-i]*vars[i]，i=1..k）]，`+`））od；其他的对于k到d dog[k]：=展开（转换（[seq（g[k-i]*vars[i]，i=1..k）]，`+`））od；fi；op（g）结束：##toh（f）将对称函数f转换为h多项式。#toh（f，b）也这样做，假设f仅以b为基础表示。#收集关于h1、h2、h3…的最终结果，。。。#如果b不是预定义的基，则f在b[..]中必须是*线性*。#`SF/toh`：=proc（）局部f，bases，sp，i，mu，d，b，c；f： =参数[1]；bases:=`SF/getbase`（args）减去{'h'}；sp:=SF['varset']（f，基数减去{'p'，'e'}）；对于基数为负{'e'，'p'，'s[]'}的b doc： =op（0，b）；如果sp[c]=[]，则下一个fi；如果分配（`SF/双`[c]），则f： =`SF/对偶`（c，sp[c]，f）；基数：={op（基数），'p'}其他的f： =`SF/added`（c，sp[c]，f）；基数：={op（基数），'e'}fi（菲涅耳）od；如果成员（'s[]'，基数），则b:='h'；如果nops（sp['s']）>1，则b:=NULL；碱基：={op（碱基），'e'}-fi；f： =子（{seq（s[op（mu）]=`SF/jt_det`（mu，0，b），mu=sp[s']）}，f）；fi；如果成员（'p'，bases），则f:=`SF/to_ehp`（'p`，'h'，f）fi；如果成员（‘e’，基数），则f:=`SF/to_ehp`（‘e'，‘h’，f）fi；d： =SF[变量集]（f，'h'）；收集（f，[seq（cat（'h'，i），i=1..d）]，'分配'，正常）；结束时间：###多处需要的各种内部工具##解析nrows形式的方程的参数列表='.#如果找到，请返回第一个这样的方程。#否则，返回0作为默认值。#`SF/getrows`：=proc（）局部u；[args]do中的u如果type（u，`=`）和op（1，u）='rows'，则RETURN（op（2，u））fiod；0结束：##分析参数列表（参数[1]除外）中的名称。#验证找到的第一个并将其作为单个集返回。#如果找不到名称，则返回“SF/bases”作为默认值。#`SF/getbase`：=proc（）局部i；对于我来说，从2到nargs是这样的如果类型（args[i]，'name'），则RETURN（{`SF/verive'（args[i]）}）fiod`SF/基础`结束：##假设b.d是最高的，得到b单项式f的形状#f中可能出现的度变量。#`SF/shape`：=进程（f，b，d）局部k；[seq（（-k）$度（f，cat（b，-k）），k=-d..-1）]结束：##报告分配的字节数。#我们需要这样来解决枫叶强加的特征断裂问题。#如果`+`（0）=0，则#我们使用的是Maple V.4或更高版本`SF/字节`：=proc（）内核点（字节分配）结束其他的`SF/字节`：=proc（）4*状态[2]结束图1：##将sym函数f转换为针对地面场优化的标准形式：#*如果系数合理，则不采取任何措施。#*如果系数是Q上的多项式，则展开f。这可能会浪费a#内存很大，但速度的提高是惊人的。#*否则，收集术语并对系数应用法线。#*如果系数不是ratpoly，则浮点运算，#涉及激进分子或其他猥亵内容。在这种情况下，请确保#前导项v已被删除（防止无限循环）。#`SF/normal`：=proc（f，vars，v）局部g；如果类型（f，“polynom”（“national”，vars）），则返回（f）elif类型（f，‘polynom（rational）’），然后返回（expand（f））fi；g： =集合（f，vars，'distributed'，normal）；如果类型为（g，‘atpoly（rational）’），则为gelif类型（g，`+`）然后映射（`SF/normal/zap`，g，vars，v）else `SF/normal/zap`（g，vars，v）fi（菲涅耳）结束：##如果f的单项式部分与m匹配，则删除它。#否则，请安全通过。#`SF/normal/zap`：=proc（f，vars，m）局部u；对于vars do中的u如果度数（f，u）<>度数（m，u），则返回（f）fiod；0结束：##top（f）将对称函数f转换为p-多项式。#top（f，b）也这样做，假设f仅以b为基础表示。#收集关于p1、p2、p3…的最终结果，。。。#如果b不是预定义的基，则f在b[..]中必须是*线性*。#`SF/top`：=proc（）局部f，bases，sp，i，mu，b，d，a；f： =参数[1]；bases:=`SF/getbase`（args）减去{'p'}；sp:=SF['varset']（f，基数减去{'h'，'e'}）；对于基数为负{'h'，'e'，'s[]'}do的ba： =op（0，b）；如果sp[a]=[]，则下一个fi；如果分配（`SF/双`[a]），则f： =`SF/对偶`（a，sp[a]，f）其他的f： =`SF/added`（a，sp[a]，f）；基：=基并集{'e'}fi（菲涅耳）od；如果成员（'s[]'，基数），则f： =子（{seq（s[op（mu）]=`SF/jt_det`（mu，0），mu=sp[s']）}，f）；基数：={op（基数），'h'，'e'}fi；如果成员（'h'，bases），则f:=`SF/to_ehp`（'h]，'p'，f）fi；如果成员（‘e’，基数），则f:=`SF/to_ehp`（‘e'，‘p’，f）fi；d： =SF['varset']（f，'p'）；集合（f，[seq（cat（'p'，i），i=1..d）]，‘已分配’，正常）；结束时间：##tos（f，)将f转换为Schur函数的和。#可选参数可以按任意顺序给出：#（1）方程nrows='，其中是正整数#指定所有计算都应在环中进行#由Schur函数跨越，最多排。#（2）基名称，表示f以该基表示。#（3）支持f的Schur展开的分区列表。#2.4新增：我们忽略（3）。新代码确定了Schur支持#f动态，所以这个选项毫无意义。##设置infolevel[tos]：=2以查看有关#舒尔函数系数。#`SF/tos`：=proc（）局部b，c，d，j，f，den，nrows，vars，mu，res，v；nrows:=`SF/getrows`（args）；如果nrows>0，则f： =SF['toe']（参数）；b： =‘e’；d： =最小值（nrows，SF['stdeg']（f，b））；其他的f： =SF[‘toh’]（参数）；b： =“h”；d： =SF['stdeg']（f，b）；nrows：=空；fi；变量：=[seq（cat（b，-j），j=-d..-1）]；分辨率：=0；f： =`SF/tos/numer`（f，vars，'den'）；而f<>0会c： =tcoeff（f，vars，'v'）；mu:=`SF/shape`（v，b，d）；f： =f-c*展开（linalg['det']（SF['jt_matrix']（mu，[]，b，nrows））；f： =`SF/正常`（f，vars，v）；如果b='e'，则mu:=SF['conjugate']（mu）fi；res:=正常（c/den）*s[op（mu）]+res；用户信息（2，tos，c，mu，nops（f））；od；物件结束：##如果f是具有ratpoly系数的sym poly，则提取一个最不常见的#系数的分母，将其分配给args[3]，以及#返回按该因子重新缩放（和规范化）f的结果。#与“primpart”类似，但“方式”更节省空间。#如果系数不是ratpoly，则不执行任何操作（使用1作为分母）。#`SF/tos/numer`：=proc（f，vars）local cfs，tms，den；如果类型（f，‘polynom’（‘rational’，vars）），则den:=denom（f）；赋值（args[3]，den）；密度*felif类型（f，‘atpoly（rational）’）则cfs:=[系数（f，vars，'tms'）]；den：=lcm（op（map（denom，cfs）））；赋值（args[3]，den）；cfs:=映射（（x，y）->正常（y*x），cfs，den）；转换（zip（（x，y）->x*y，cfs，[tms]），`+`）其他的分配（参数[3]，1）；（f）fi（菲涅耳）结束：##varset（f，)将返回一个表，该表的条目描述#变量集来自发生在对称函数f中。##可以是字符串名称和索引名称的列表或集合。对于#索引名称，如's[]'，将有一个索引表条目#由表示支持的分区列表组成#对于字符串名，例如“p”，将有一个#由“p”索引的表项等于最大n s.t.p.n出现在f中。##我们假设基的字符串名称是单个字符。##如果是一个名称（不是列表或集合），然后是上面的条目#返回与该名称对应的表，而不是表本身。#如果省略第二个参数，默认值为=`SF/Bases`。#`SF/varset`：=proc（f）局部inds，strs，one_base，b，v，res，i，digits；索引：={}；字符串：={}；res:=表格（）；one_base:=假；如果nargs=1，则b:=`SF/Bases`其他b:=args[2]fi；如果类型为（b，'name'），则one_base:=true；b： ={b}fi；对于bdo中的v如果类型（v，“索引”），则inds:={op（inds），op（0，v）}；res[op（0，v）]：=空else字符串：={op（strs），v}；res[v]：=0fi（菲涅耳）od；如果nops（strs）>0，则数字：=表（[seq（cat（i）=i，i=0..9）]）fi；对于indets中的v（f，‘name’）do如果类型（v，‘索引’），则b:=op（0，v）；如果成员（b，inds），则res[b]：=res[b'，[op（v）]fi否则b:=子串（v，1..1）；如果成员（b，strs），则res[b]：=最大值（res[b]，`SF/varset/deg`（v，数字））fifi（菲涅耳）od；对于inds中的b，执行res[b]：=[res[b]]od；如果是one_base，则res[op（strs），op（inds）]else op（res）fi；结束：##如果删除字符串v的第一个字符会得到一个正数#整数n然后返回n；否则，返回0。#`SF/varset/deg`：=进程（v，数字）局部i，j，n；n： =0；对于i从2到长度（v）doj： =子字符串（v，i..i）；如果未赋值（数字[j]），则返回（0）fi；n： =10*n+数字[j]od；n个结束时间：##检查b或b[]是否为已知基础。#`SF/verify`：=进程（b）如果成员（b，`SF/Bases`），则为belif成员（b[]，`SF/Bases`），然后b[]else ERROR（cat（b，`不是已知基`））fi（菲涅耳）结束：##`SF/apply`（b，f，…）验证`to`.b的存在，然后#将其应用于f，。。。#`SF/apply`：=proc（）局部b，pr；b： =`SF/verify`（参数[1]）；如果类型（b，‘索引’），则b:=op（0，b）fi；pr:=猫（`to`，b）；如果类型为（pr，'procedure'），则为pr（args[2..nargs]）else SF[pr]（args[2..nargs]）fi；结束：# #zee（lambda）=#循环型λ；即1^（m1）*m1*2平方米*平方米！*。。。##zee（λ，a）=zee（lambda）*a^nops（lambda）#zee（lambda，q，t）=zee（lambda）*产品（（1-q^（lambda_i））/（1-t^（lambda_i））#`SF/zee`：=proc（mu）局部res，m，i；m： =1；res:=转换（mu，`*`）；如果nargs=2，则res:=res*args[2]^nops（mu）elif nargs=3那么res:=res*转换（[seq（（1-args[2]^i）/（1-args[3]^i），i=mu）]，`*`）fi；对于我来说，从2到nops（mu）do如果mu[i]assign（SF[x]，cat（‘SF/’，x）），['（'Par'）'，'（'add_basis'）'、'（'char2sf'）'和'（'conjugate'）'，'（'dominate'）'，'（'dual_basis'）'、'（'valsf'）'和'（'hooks'）''，'（'张量'）'，'（'jt_matrix'）'、'（'extPar'）'和'（'omega'）'，'（'plethysm'）'，'（'scalar'，“（‘subPar’）”、“（‘eta’）”，“（‘toe’）’，”（‘toh’）“，”（“top”）“，'（'tos'）'，'（'varset'）'，'（'zee'）']）：#printf（`SF 2.4v loaded.Run'withSF（）'使用缩写名称。\n’）；