schubmult 1.3.7__tar.gz → 1.3.9__tar.gz

{schubmult-1.3.7 → schubmult-1.3.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: schubmult
-Version: 1.3.7
+Version: 1.3.9
 Summary: Computing Littlewood-Richardson coefficients of Schubert polynomials
 Home-page: https://github.com/matthematics/schubmult
 Author: Matt Samuel

{schubmult-1.3.7 → schubmult-1.3.9}/schubmult/perm_lib.py

@@ -139,6 +139,28 @@ def elem_sym_perms(orig_perm,p,k):
 		up_perm_list = perm_list
 	return total_list
 
+def elem_sym_perms_op(orig_perm,p,k):	
+	total_list = [(orig_perm,0)]
+	up_perm_list = [(orig_perm,k)]
+	for pp in range(p):
+		perm_list = []
+		for up_perm, last in up_perm_list:	
+			up_perm2 = [*up_perm]
+			if len(up_perm2) < k + 1:
+				up_perm2 += [i+1 for i in range(len(up_perm2),k+2)]
+			pos_list = [i for i in range(k) if up_perm2[i] == orig_perm[i]]
+			for j in range(last,len(up_perm2)):				
+				for i in pos_list:								
+					if has_bruhat_descent(up_perm2,i,j):
+						new_perm = [*up_perm2]
+						new_perm[i],new_perm[j] = new_perm[j],new_perm[i]
+						new_perm_add = tuple(permtrim(new_perm))
+						perm_list += [(new_perm_add,j)]
+						total_list+=[(new_perm_add,pp+1)]
+		up_perm_list = perm_list
+	return total_list
+
+
 def strict_theta(u):
 	ret = [*trimcode(u)]
 	did_one = True
@@ -300,6 +322,13 @@ def add_perm_dict(d1,d2):
 zero = sympify(0)
 one = sympify(1)
 
+def elem_sym_poly_q(p,k,varl1,varl2):
+	if p == 0 and k>=0:
+		return one
+	if p<0 or p>k:
+		return zero
+	return (varl1[k-1] - varl2[k-p])*elem_sym_poly_q(p-1,k-1,varl1,varl2)+elem_sym_poly_q(p,k-1,varl1,varl2)+q_var[k-1]*elem_sym_poly_q(p-2,k-2,varl1,varl2)
+
 def elem_sym_poly(p,k,varl1,varl2,xstart=0,ystart=0):
 	global zero, one
 	if p>k:

{schubmult-1.3.7 → schubmult-1.3.9}/schubmult/schubmult_double/schubmult_double.py

@@ -2,7 +2,7 @@ from symengine import *
 from functools import cache
 from itertools import chain
 from schubmult.perm_lib import *
-from schubmult.schubmult_yz import schubmult
+from schubmult.schubmult_yz import schubmult, mult_poly
 import sys
 
 n = 100
@@ -17,7 +17,7 @@ var_q = Symbol("q")
 subs_dict = {}
 
 for i in range(1,n):
-	sm = var_r[0]
+	sm = var2[1]
 	for j in range(1,i):
 		sm += var_r[j]
 	subs_dict[var2[i]] = sm
@@ -32,11 +32,16 @@ def main():
 		pr = True
 		ascode = False
 		coprod = False
+		mult = False
+		mulstring = ""
 		try:
 			for s in sys.argv[1:]:
 				if s == "-np" or s == "--no-print":
 					pr = False
 					continue
+				if mult:
+					mulstring+=s
+					continue
 				if s == "-code":
 					ascode = True
 					continue
@@ -47,11 +52,14 @@ def main():
 					perms += [curperm]
 					curperm = []
 					continue
+				if s == "-mult":
+					mult = True
+					continue
 				curperm += [int(s)]
 		except Exception:
 			print("**** schubmult_double ****")
 			print("Purpose: Compute products (and coproducts) of double Schubert polynomials in the same set of variables")
-			print("Usage: schubmult_double <-np|--no-print> <-code> perm1 - perm2 < - perm 3 ... >")
+			print("Usage: schubmult_double <-np|--no-print> <-code> perm1 - perm2 < - perm 3 ... > <-mult poly>")
 			print("Alternative usage: schubmult_double <-code> -coprod perm - indexlist")
 			exit(1)
 		
@@ -145,7 +153,10 @@ def main():
 			
 			for perm in perms[1:]:
 				coeff_dict = schubmult(coeff_dict,tuple(permtrim([*perm])),var2,var2)
-				
+			if mult:
+				mul_exp = sympify(mulstring)
+				coeff_dict = mult_poly(coeff_dict,mul_exp)
+			
 			if pr:
 				if ascode:
 					width = max([len(str(trimcode(perm))) for perm in coeff_dict.keys()])

{schubmult-1.3.7 → schubmult-1.3.9}/schubmult/schubmult_py/schubmult_py.py

@@ -2,6 +2,50 @@ import sys
 from functools import cache
 from itertools import chain
 from schubmult.perm_lib import *
+from symengine import *
+
+var_x = symarray("x",100).tolist()
+
+def single_variable(coeff_dict,varnum):
+	ret = {}
+	for u in coeff_dict:
+		new_perms_k = elem_sym_perms(u,1,varnum)
+		new_perms_km1 = []
+		if varnum > 1:
+			new_perms_km1 = elem_sym_perms(u,1,varnum-1)
+		for perm, udiff in new_perms_k:
+			if udiff == 1:
+				ret[perm] = ret.get(perm,0) + coeff_dict[u]
+		for perm, udiff in new_perms_km1:
+			if udiff == 1:
+				ret[perm] = ret.get(perm,0) - coeff_dict[u]
+	return ret
+
+def mult_poly(coeff_dict,poly):
+	if poly in var_x:
+		return single_variable(coeff_dict,var_x.index(poly))
+	elif isinstance(poly,Mul):
+		ret = coeff_dict
+		for a in poly.args:
+			ret = mult_poly(ret,a)
+		return ret
+	elif isinstance(poly,Pow):
+		base = poly.args[0]
+		exponent = int(poly.args[1])
+		ret = coeff_dict
+		for i in range(int(exponent)):
+			ret = mult_poly(ret,base)
+		return ret
+	elif isinstance(poly,Add):
+		ret = {}
+		for a in poly.args:
+			ret = add_perm_dict(ret,mult_poly(coeff_dict,a))
+		return ret
+	else:
+		ret = {}
+		for perm in coeff_dict:
+			ret[perm] = poly*coeff_dict[perm]
+		return ret
 
 def schubmult(perm_dict,v):
 	vn1 = inverse(v)
@@ -58,9 +102,17 @@ def main():
 		pr = True
 		coprod = False
 		ascode = False
+		mult = False
+		mulstring = ""
 		
 		try:
 			for s in sys.argv[1:]:
+				if mult:
+					mulstring += s
+					continue
+				if s == "-mult":
+					mult = True
+					continue
 				if s == "-np" or s == "--no-print":
 					pr = False
 					continue
@@ -73,8 +125,9 @@ def main():
 				if s == "-":
 					perms += [tuple(curperm)]
 					curperm = []
-					continue
-				curperm += [int(s)]
+					continue				
+				else:
+					curperm += [int(s)]
 		except Exception:
 			print("**** schubmult_py ****")
 			print("Purpose: Compute products (and coproducts) of ordinary Schubert polynomials")
@@ -138,11 +191,14 @@ def main():
 		
 		
 			perms.sort(reverse=True,key=lambda x: sum(theta(inverse(x)))-inv(x))
-			
+					
 			coeff_dict = {tuple(permtrim([*perms[0]])): 1}
-			
+					
 			for perm in perms[1:]:
 				coeff_dict = schubmult(coeff_dict,tuple(permtrim([*perm])))
+			if mult:
+				mul_exp = sympify(mulstring)
+				coeff_dict = mult_poly(coeff_dict,mul_exp)
 				
 			if pr:
 				for perm, val in coeff_dict.items():

{schubmult-1.3.7 → schubmult-1.3.9}/schubmult/schubmult_q/schubmult_q.py

@@ -14,6 +14,49 @@ var_q = Symbol("q")
 
 subs_dict = {}
 
+var_x = symarray("x",100).tolist()
+
+def single_variable(coeff_dict,varnum):
+	ret = {}
+	for u in coeff_dict:
+		new_perms_k = elem_sym_perms_q(u,1,varnum)
+		new_perms_km1 = []
+		if varnum > 1:
+			new_perms_km1 = elem_sym_perms_q(u,1,varnum-1)
+		for perm, udiff, mul_val in new_perms_k:
+			if udiff == 1:
+				ret[perm] = ret.get(perm,0) + coeff_dict[u]*mul_val
+		for perm, udiff, mul_val in new_perms_km1:
+			if udiff == 1:
+				ret[perm] = ret.get(perm,0) - coeff_dict[u]*mul_val
+	return ret
+
+def mult_poly(coeff_dict,poly):
+	if poly in var_x:
+		return single_variable(coeff_dict,var_x.index(poly))
+	elif isinstance(poly,Mul):
+		ret = coeff_dict
+		for a in poly.args:
+			ret = mult_poly(ret,a)
+		return ret
+	elif isinstance(poly,Pow):
+		base = poly.args[0]
+		exponent = int(poly.args[1])
+		ret = coeff_dict
+		for i in range(int(exponent)):
+			ret = mult_poly(ret,base)
+		return ret
+	elif isinstance(poly,Add):
+		ret = {}
+		for a in poly.args:
+			ret = add_perm_dict(ret,mult_poly(coeff_dict,a))
+		return ret
+	else:
+		ret = {}
+		for perm in coeff_dict:
+			ret[perm] = poly*coeff_dict[perm]
+		return ret
+
 for i in range(1,n):
 	sm = var_r[0]
 	for j in range(1,i):
@@ -132,11 +175,17 @@ def main():
 		grass = False
 		grass_q_n = 0
 		equiv = False
+		mult = False
+		mulstring = ""
+		
 		try:
 			for s in sys.argv[1:]:
 				if s == "-np" or s == "--no-print":
 					pr = False
 					continue
+				if mult:
+					mulstring += s
+					continue
 				if s == "-code":
 					ascode = True
 					continue
@@ -150,6 +199,9 @@ def main():
 					grass = True
 					grass_q_n = int(s)
 					continue
+				if s == "-mult":
+					mult = True
+					continue
 				if s == "-":
 					perms += [curperm]
 					curperm = []
@@ -294,6 +346,10 @@ def main():
 			
 			for perm in perms[1:]:
 				coeff_dict = schubmult(coeff_dict,tuple(permtrim([*perm])))
+			
+			if mult:
+				mul_exp = sympify(mulstring)
+				coeff_dict = mult_poly(coeff_dict,mul_exp)
 				
 			if pr:
 				if ascode:

{schubmult-1.3.7 → schubmult-1.3.9}/schubmult/schubmult_q_double/schubmult_q_double.py

@@ -1,5 +1,5 @@
 from schubmult.perm_lib import *
-from schubmult.schubmult_q_yz import schubmult
+from schubmult.schubmult_q_yz import schubmult, mult_poly
 from symengine import *
 import sys
 
@@ -15,7 +15,7 @@ var_r = symarray('r',100)
 subs_dict = {}
 
 for i in range(1,100):
-	sm = var_r[0]
+	sm = var2[1]
 	for j in range(1,i):
 		sm += var_r[j]
 	subs_dict[var2[i]] = sm
@@ -36,11 +36,19 @@ def main():
 		coprod = False
 		check = True
 		msg = False
+		mult = False
+		mulstring = ""
 		try:
 			for s in sys.argv[1:]:
 				if s == "-np" or s == "--no-print":
 					pr = False
 					continue
+				if mult:
+					mulstring += s
+					continue
+				if s == "-mult":
+					mult = True
+					continue
 				if s == "-nocheck":
 					check = False
 					continue
@@ -89,6 +97,9 @@ def main():
 		coeff_dict = {perms[0]: 1}
 		for perm in perms[1:]:
 			coeff_dict = schubmult(coeff_dict,perm,var2,var2)
+		if mult:
+			mul_exp = sympify(mulstring)
+			coeff_dict = mult_poly(coeff_dict,mul_exp)
 		
 		if pr:
 			if ascode:

{schubmult-1.3.7 → schubmult-1.3.9}/schubmult/schubmult_q_yz/schubmult_q_yz.py

@@ -6,9 +6,66 @@ import sys
 var2 = symarray("y",100)
 var3 = symarray("z",100)
 
-var_x = symarray("x",100)
+var_y = var2.tolist()
+var_z = var3.tolist()
+var_x = symarray("x",100).tolist()
+
+x = var_x
+y = var_y
+z = var_z
+
+def E(p,k,varl=var_y[1:]):
+	return elem_sym_poly_q(p,k,var_x[1:],varl)
+
+def single_variable(coeff_dict,varnum):
+	ret = {}
+	for u in coeff_dict:
+		if varnum -1 < len(u):
+			ret[u] = ret.get(u,0) + var2[u[varnum-1]]*coeff_dict[u]
+		else:
+			ret[u] = ret.get(u,0) + var2[varnum]*coeff_dict[u]
+		new_perms_k = elem_sym_perms_q(u,1,varnum)
+		new_perms_km1 = []
+		if varnum > 1:
+			new_perms_km1 = elem_sym_perms_q(u,1,varnum-1)
+		for perm, udiff, mul_val in new_perms_k:
+			if udiff == 1:
+				ret[perm] = ret.get(perm,0) + coeff_dict[u]*mul_val
+		for perm, udiff, mul_val in new_perms_km1:
+			if udiff == 1:
+				ret[perm] = ret.get(perm,0) - coeff_dict[u]*mul_val
+	return ret
+
+def mult_poly(coeff_dict,poly):
+	if poly in var_x:
+		return single_variable(coeff_dict,var_x.index(poly))
+	elif isinstance(poly,Mul):
+		ret = coeff_dict
+		for a in poly.args:
+			ret = mult_poly(ret,a)
+		return ret
+	elif isinstance(poly,Pow):
+		base = poly.args[0]
+		exponent = int(poly.args[1])
+		ret = coeff_dict
+		for i in range(int(exponent)):
+			ret = mult_poly(ret,base)
+		return ret
+	elif isinstance(poly,Add):
+		ret = {}
+		for a in poly.args:
+			ret = add_perm_dict(ret,mult_poly(coeff_dict,a))
+		return ret
+	else:
+		ret = {}
+		for perm in coeff_dict:
+			ret[perm] = poly*coeff_dict[perm]
+		return ret
+		
 
 def nil_hecke(perm_dict,v,n,var2=var2,var3=var3):
+	if v == (1,2):
+		return perm_dict
 	th = strict_theta(inverse(v))
 	mu = permtrim(uncode(th))
 	vmu = permtrim(mulperm([*v],mu))
@@ -51,6 +108,8 @@ def nil_hecke(perm_dict,v,n,var2=var2,var3=var3):
 
 	
 def schubmult(perm_dict,v,var2=var2,var3=var3):
+	if v == (1,2):
+		return perm_dict
 	th = strict_theta(inverse(v))
 	mu = permtrim(uncode(th))
 	vmu = permtrim(mulperm([*v],mu))
@@ -189,7 +248,7 @@ var3_t = tuple(var3.tolist())
 def print_usage():
 	print("**** schubmult_q_yz ****")
 	print("Purpose: Compute Molev-Sagan coefficients of quantum double Schubert polynomials")
-	print("Usage: schubmult_q_yz <-np|--no-print> <-code> <--display-positive> <--optimizer-message> perm1 - perm2 < - perm3 .. >")
+	print("Usage: schubmult_q_yz <-np|--no-print> <-code> <--display-positive> <--optimizer-message> perm1 - perm2 < - perm3 .. > <-mult poly_expression>")
 	print("       *** Computes products")
 	print("Alternative usage: schubmult_q_yz -nil-hecke n <-code> <--display-positive> perm")
 	print("       *** Computes nil-Hecke representation of quantum double Schubert polynomial, limiting to the group S_n")
@@ -210,18 +269,35 @@ def main():
 		check = True
 		msg = False
 		just_nil = False
+		mult = False
 		
 		nil_N = 0
 		
+		mulstring = ""
+		norep = False
+		expa = False
+		
 		try:
 			for s in sys.argv[1:]:
 				if just_nil:
 					just_nil = False
 					nil_N = int(s)
 					continue
+				if s == "--norep":
+					norep = True
+					continue
+				if s == "--expand":
+					expa = True
+					continue
 				if s == "-np" or s == "--no-print":
 					pr = False
 					continue
+				if mult:
+					mulstring += s
+					continue					
+				if s == "-mult":
+					mult = True
+					continue
 				if s == "-nocheck":
 					check = False
 					continue
@@ -243,11 +319,11 @@ def main():
 					continue
 				if s == "--usage" or s == "--help":
 					print_usage()
-					exit(0)
+					exit(0)				
 				if s == "-":
 					perms += [curperm]
 					curperm = []
-					continue
+					continue				
 				curperm += [int(s)]
 		except Exception:
 			print_usage()
@@ -261,6 +337,8 @@ def main():
 				perms[i] = tuple(permtrim(uncode(perms[i])))
 		else:
 			for i in range(len(perms)):
+				if len(perms[i])<2 and (len(perms[i])==0 or perms[i][0]==1):
+					perms[i] = (1,2)
 				perms[i] = tuple(permtrim([*perms[i]]))
 		
 		size = 0
@@ -268,12 +346,21 @@ def main():
 		
 		if nilhecke:
 			coeff_dict = nil_hecke({(1,2): 1},perms[0],nil_N)			
-			rep = ("y","x")
+			rep = ("y","x")		
 		else:
 			coeff_dict = {perms[0]: 1}
 			for perm in perms[1:]:
 				coeff_dict = schubmult(coeff_dict,perm)
-			rep = ("","")
+			if mult:
+				for v in var2:
+					globals()[str(v)] = v
+				for v in var3:
+					globals()[str(v)] = v	
+				for v in var_x:
+					globals()[str(v)] = v	
+				mul_exp = eval(mulstring)
+				coeff_dict = mult_poly(coeff_dict,mul_exp)
+			rep = ("","")			
 		
 		if pr:
 			if ascode:
@@ -301,11 +388,11 @@ def main():
 									val2 += q_part*int(q_dict[q_part])
 								except Exception:
 									try:
-										if len(perms) == 2 and q_part == 1:
+										if len(perms) == 2 and q_part == 1 and not mult:
 											u = permtrim([*perms[0]])
 											v = permtrim([*perms[1]])
 											val2 += posify(q_dict[q_part],tuple(u),tuple(v),perm,var2_t,var3_t,msg,False)
-										elif len(perms) == 2 and q_part in q_var2:
+										elif len(perms) == 2 and q_part in q_var2 and not mult:
 											i = q_var2.index(q_part)
 											u = permtrim([*perms[0]])
 											v = permtrim([*perms[1]])											
@@ -318,18 +405,34 @@ def main():
 										else:
 											val2 += q_part*compute_positive_rep(q_dict[q_part],var2_t,var3_t,msg,False)
 									except Exception as e:
-										print(f"error; write to schubmult@gmail.com with the case {perms=} {perm=} {val=} {coeff_dict.get(perm,0)=}")
-										print(f"Exception: {e}")
-										exit(1)
+										if mult:
+											print("warning; --display-positive is on but result is not positive",file=sys.stderr)
+											val2 = val
+											break
+										else:
+											print(f"error; write to schubmult@gmail.com with the case {perms=} {perm=} {val=} {coeff_dict.get(perm,0)=}")
+											print(f"Exception: {e}")
+											exit(1)
 							if check and expand(val - val2)!=0:
-								print(f"error: value not equal; write to schubmult@gmail.com with the case {perms=} {perm=} {val=} {coeff_dict.get(perm,0)=}")
-								exit(1)
+								if mult:
+									val2 = val
+								else:
+									print(f"error: value not equal; write to schubmult@gmail.com with the case {perms=} {perm=} {val=} {coeff_dict.get(perm,0)=}")
+									exit(1)
 							val = val2
+					if expa:
+						val = expand(val)
 					if val!=0:
 						if ascode:
-							print(f"{str(trimcode(perm)):>{width}}  {str(val).replace('**','^').replace('*',' ').replace(*rep)}")	
+							if norep:
+								print(f"{str(trimcode(perm)):>{width}}  {str(val).replace(*rep)}")	
+							else:
+								print(f"{str(trimcode(perm)):>{width}}  {str(val).replace('**','^').replace('*',' ').replace(*rep)}")	
 						else:
-							print(f"{str(perm):>{width}}  {str(val).replace('**','^').replace('*',' ').replace(*rep)}")	
+							if norep:
+								print(f"{str(perm):>{width}}  {str(val).replace(*rep)}")	
+							else:
+								print(f"{str(perm):>{width}}  {str(val).replace('**','^').replace('*',' ').replace(*rep)}")	
 	except BrokenPipeError:
 		pass
 		

{schubmult-1.3.7 → schubmult-1.3.9}/schubmult/schubmult_yz/schubmult_yz.py

@@ -27,6 +27,108 @@ var = tuple(symarray('x',n).tolist())
 var2 = tuple(symarray('y',n).tolist())
 var3 = tuple(symarray('z',n).tolist())
 
+var_x = symarray("x",100).tolist()
+var_y = var2
+var_z = var3
+
+x = var_x
+y = var_y
+z = var_z
+
+def E(p,k,varl=var_y[1:]):
+	return elem_sym_poly(p,k,var_x[1:],varl)
+
+def single_variable(coeff_dict,varnum):
+	ret = {}
+	for u in coeff_dict:
+		if varnum -1 < len(u):
+			ret[u] = ret.get(u,0) + var2[u[varnum-1]]*coeff_dict[u]
+		else:
+			ret[u] = ret.get(u,0) + var2[varnum]*coeff_dict[u]
+		new_perms_k = elem_sym_perms(u,1,varnum)
+		new_perms_km1 = []
+		if varnum > 1:
+			new_perms_km1 = elem_sym_perms(u,1,varnum-1)
+		for perm, udiff in new_perms_k:
+			if udiff == 1:
+				ret[perm] = ret.get(perm,0) + coeff_dict[u]
+		for perm, udiff in new_perms_km1:
+			if udiff == 1:
+				ret[perm] = ret.get(perm,0) - coeff_dict[u]
+	return ret
+
+def single_variable_down(coeff_dict,varnum):
+	ret = {}
+	for u in coeff_dict:
+		if varnum -1 < len(u):
+			ret[u] = ret.get(u,0) + var2[u[varnum-1]]*coeff_dict[u]
+		else:
+			ret[u] = ret.get(u,0) + var2[varnum]*coeff_dict[u]
+		new_perms_k = elem_sym_perms_op(u,1,varnum)
+		new_perms_km1 = []
+		if varnum > 1:
+			new_perms_km1 = elem_sym_perms_op(u,1,varnum-1)
+		for perm, udiff in new_perms_k:
+			if udiff == 1:
+				ret[perm] = ret.get(perm,0) + coeff_dict[u]
+		for perm, udiff in new_perms_km1:
+			if udiff == 1:
+				ret[perm] = ret.get(perm,0) - coeff_dict[u]
+	return ret
+
+
+def mult_poly(coeff_dict,poly):
+	if poly in var_x:
+		return single_variable(coeff_dict,var_x.index(poly))
+	elif isinstance(poly,Mul):
+		ret = coeff_dict
+		for a in poly.args:
+			ret = mult_poly(ret,a)
+		return ret
+	elif isinstance(poly,Pow):
+		base = poly.args[0]
+		exponent = int(poly.args[1])
+		ret = coeff_dict
+		for i in range(int(exponent)):
+			ret = mult_poly(ret,base)
+		return ret
+	elif isinstance(poly,Add):
+		ret = {}
+		for a in poly.args:
+			ret = add_perm_dict(ret,mult_poly(coeff_dict,a))
+		return ret
+	else:
+		ret = {}
+		for perm in coeff_dict:
+			ret[perm] = poly*coeff_dict[perm]
+		return ret
+
+def mult_poly_down(coeff_dict,poly):
+	if poly in var_x:
+		return single_variable_down(coeff_dict,var_x.index(poly))
+	elif isinstance(poly,Mul):
+		ret = coeff_dict
+		for a in poly.args:
+			ret = mult_poly_down(ret,a)
+		return ret
+	elif isinstance(poly,Pow):
+		base = poly.args[0]
+		exponent = int(poly.args[1])
+		ret = coeff_dict
+		for i in range(int(exponent)):
+			ret = mult_poly_down(ret,base)
+		return ret
+	elif isinstance(poly,Add):
+		ret = {}
+		for a in poly.args:
+			ret = add_perm_dict(ret,mult_poly_down(coeff_dict,a))
+		return ret
+	else:
+		ret = {}
+		for perm in coeff_dict:
+			ret[perm] = poly*coeff_dict[perm]
+		return ret
+
 
 def forwardcoeff(u,v,perm,var2=var2,var3=var3):
 	th = theta(v)
@@ -160,6 +262,49 @@ def schubmult(perm_dict,v,var2=var2,var3=var3):
 		ret_dict = add_perm_dict({ep: vpathsums[ep].get(toget,0) for ep in vpathsums},ret_dict)
 	return ret_dict
 
+def schubmult_down(perm_dict,v,var2=var2,var3=var3):
+	vn1 = inverse(v)
+	th = theta(vn1)
+	if th[0]==0:
+		return perm_dict		
+	mu = permtrim(uncode(th))
+	vmu = permtrim(mulperm([*v],mu))
+	inv_vmu = inv(vmu)
+	inv_mu = inv(mu)
+	ret_dict = {}
+	vpaths = [([(vmu,0)],1)]
+	while th[-1] == 0:
+		th.pop()
+	thL = len(th)
+	vpathdicts = compute_vpathdicts(th,vmu,True)
+	for u,val in perm_dict.items():
+		inv_u = inv(u)
+		vpathsums = {u: {(1,2): val}}
+		for index in range(thL):			
+			mx_th = 0
+			for vp in vpathdicts[index]:
+				for v2,vdiff,s in vpathdicts[index][vp]:
+					if th[index]-vdiff > mx_th:
+						mx_th = th[index] - vdiff					
+			newpathsums = {}
+			for up in vpathsums:
+				inv_up = inv(up)
+				newperms = elem_sym_perms_op(up,mx_th,th[index])
+				for up2, udiff in newperms:
+					if up2 not in newpathsums:
+						newpathsums[up2]={}
+					for v in vpathdicts[index]:
+						sumval = vpathsums[up].get(v,zero)
+						if sumval == 0:
+							continue
+						for v2,vdiff,s in vpathdicts[index][v]:
+							newpathsums[up2][v2] = newpathsums[up2].get(v2,zero)+s*sumval*elem_sym_func(th[index],index+1,up2,up,v,v2,udiff,vdiff,var2,var3)
+			vpathsums = newpathsums
+		toget = tuple(vmu)
+		ret_dict = add_perm_dict({ep: vpathsums[ep].get(toget,0) for ep in vpathsums},ret_dict)
+	return ret_dict
+
+
 fvar = 0
 
 def poly_to_vec(poly,vec0=None):	
@@ -1294,11 +1439,24 @@ def main():
 		coprod = False
 		check = True
 		msg = False
+		mult = False
+		mulstring = ""
+		down = False
+		
 		try:
 			for s in sys.argv[1:]:
 				if s == "-np" or s == "--no-print":
 					pr = False
 					continue
+				if mult:
+					mulstring += s
+					continue
+				if s == "-mult":
+					mult = True
+					continue
+				if s == "-down":
+					down = True
+					continue
 				if s == "-coprod":
 					coprod = True
 					continue
@@ -1318,7 +1476,7 @@ def main():
 					ascode = True
 					continue
 				if s == "--usage":
-					print("Usage: schubmult_yz <-np|--no-print> <-code> <--display-positive> <--optimizer-message> perm1 - perm2 < - perm3 .. >")
+					print("Usage: schubmult_yz <-np|--no-print> <-code> <--display-positive> <--optimizer-message> perm1 - perm2 < - perm3 .. > <-mult poly_expression>")					
 					print("Alternative usage: schubmult_yz <-code> <--display-positive> -coprod perm - indexlist")
 					exit(0)
 				if s == "-":
@@ -1451,6 +1609,8 @@ def main():
 					perms[i] = tuple(permtrim(uncode(perms[i])))
 			else:
 				for i in range(len(perms)):
+					if len(perms[i])<2 and (len(perms[i])==0 or perms[i][0]==1):
+						perms[i] = (1,2)
 					perms[i] = tuple(permtrim([*perms[i]]))
 			
 			size = 0
@@ -1462,9 +1622,30 @@ def main():
 			
 			coeff_dict = {perms[0]: 1}
 			check_coeff_dict = {perms[0]: 1}
-			for perm in orig_perms[1:]:
-				check_coeff_dict = schubmult(check_coeff_dict,perm)
-			if display_positive and len(perms)==2 and will_formula_work(perms[0],perms[1]):
+			
+			if mult:
+				for v in var2:
+					globals()[str(v)] = v
+				for v in var3:
+					globals()[str(v)] = v	
+				for v in var_x:
+					globals()[str(v)] = v	
+			
+			if down:
+				for perm in orig_perms[1:]:
+					check_coeff_dict = schubmult_down(check_coeff_dict,perm)
+				if mult:
+					mul_exp = eval(mulstring)
+					check_coeff_dict = mult_poly_down(check_coeff_dict,mul_exp)				
+			else:
+				for perm in orig_perms[1:]:
+					check_coeff_dict = schubmult(check_coeff_dict,perm)
+				if mult:
+					mul_exp = eval(mulstring)
+					check_coeff_dict = mult_poly(check_coeff_dict,mul_exp)
+			
+			
+			if display_positive and len(perms)==2 and will_formula_work(perms[0],perms[1]) and not mult and not down:
 				coeff_dict = {}
 				th = theta(perms[1])
 				muv = uncode(th)
@@ -1477,7 +1658,7 @@ def main():
 						coeff_dict[tuple(permtrim(w))] = val
 				posified = True
 				
-			if display_positive and len(perms)>2:
+			if display_positive and len(perms)>2 and not mult:
 				coeff_dict2 = dict(coeff_dict)
 				for perm in perms[1:]:					
 					coeff_dict3 = {}
@@ -1513,13 +1694,21 @@ def main():
 						if notint and display_positive:
 							valu = val
 							try:
-								if len(perms) == 2 and not posified:
-									val = posify(val,perms[0],perms[1],perm,var2,var3,msg)							
-								elif not posified:								
+								if len(perms) == 2 and not posified and not mult:
+									if not down:
+										val = posify(val,perms[0],perms[1],perm,var2,var3,msg)							
+									else:
+										val = posify(val,perm,perms[1],perms[0],var2,var3,msg)
+								elif not posified and not mult:			
 									val = compute_positive_rep(val,var2,var3,msg)
-							except TypeError:
-								print(f"error; write to schubmult@gmail.com with the case {perms=} {perm=} {val=} {check_coeff_dict.get(perm,0)=}")
-								exit(1)
+								elif not posified:
+									val = compute_positive_rep(val,var2,var3,msg,do_pos_neg=False)
+							except Exception:
+								if mult:
+									print(f"warning; --display-positive is on but result is not positive",file=sys.stderr)
+								else:
+									print(f"error; write to schubmult@gmail.com with the case {perms=} {perm=} {val=} {check_coeff_dict.get(perm,0)=}")
+									exit(1)
 							if check and expand(val - check_coeff_dict.get(perm,0))!=0:
 								print(f"error; write to schubmult@gmail.com with the case {perms=} {perm=} {val=} {check_coeff_dict.get(perm,0)=}")
 								exit(1)

{schubmult-1.3.7 → schubmult-1.3.9}/schubmult.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: schubmult
-Version: 1.3.7
+Version: 1.3.9
 Summary: Computing Littlewood-Richardson coefficients of Schubert polynomials
 Home-page: https://github.com/matthematics/schubmult
 Author: Matt Samuel

{schubmult-1.3.7 → schubmult-1.3.9}/setup.py

@@ -6,7 +6,7 @@ long_description = (this_directory / "README.md").read_text()
 
 setup(
     name="schubmult",
-    version="1.3.7",
+    version="1.3.9",
     description="Computing Littlewood-Richardson coefficients of Schubert polynomials",
 	long_description=long_description,
 	long_description_content_type='text/markdown',