schubmult 1.3.6__tar.gz → 1.3.8__tar.gz

{schubmult-1.3.6 → schubmult-1.3.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: schubmult
-Version: 1.3.6
+Version: 1.3.8
 Summary: Computing Littlewood-Richardson coefficients of Schubert polynomials
 Home-page: https://github.com/matthematics/schubmult
 Author: Matt Samuel
@@ -50,7 +50,10 @@ schubmult_double -code -coprod 0 1 2 3 - 2 4
 schubmult_yz -code -coprod 0 1 2 3 - 2 4 --display-positive
 ```
 
-
+Since version 1.3.7, schubmult_q_yz has a feature for displaying the coefficients of the divided difference operators in the evaluation of the quantum double Schubert polynomials on the commuting difference operators of Fomin, Gelfand, and Postnikov. It is necessary to cap the value of n in the group S_n we are working in because as n increases the expression does not stabilize.
+```
+schubmult_q_yz -nil-hecke 6 -code 2 2 --display-positive
+```
 
 Runtime will vary tremendously by case. The general problem is #P-hard. Though the result is always nonnegative (which at least is known for schubmult_py, schubmult_q, schubmult_double, and schubmult_q_double) and the problem is in GapP, it is not known to be in #P at this time.
 

{schubmult-1.3.6 → schubmult-1.3.8}/README.md

@@ -37,7 +37,10 @@ schubmult_double -code -coprod 0 1 2 3 - 2 4
 schubmult_yz -code -coprod 0 1 2 3 - 2 4 --display-positive
 ```
 
-
+Since version 1.3.7, schubmult_q_yz has a feature for displaying the coefficients of the divided difference operators in the evaluation of the quantum double Schubert polynomials on the commuting difference operators of Fomin, Gelfand, and Postnikov. It is necessary to cap the value of n in the group S_n we are working in because as n increases the expression does not stabilize.
+```
+schubmult_q_yz -nil-hecke 6 -code 2 2 --display-positive
+```
 
 Runtime will vary tremendously by case. The general problem is #P-hard. Though the result is always nonnegative (which at least is known for schubmult_py, schubmult_q, schubmult_double, and schubmult_q_double) and the problem is in GapP, it is not known to be in #P at this time.
 

{schubmult-1.3.6 → schubmult-1.3.8}/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
@@ -181,6 +203,32 @@ def elem_sym_perms_q(orig_perm,p,k):
 	#print(f"{total_list=}")
 	return total_list
 
+def elem_sym_perms_q_op(orig_perm,p,k,n):	
+	total_list = [(orig_perm,0,1)]
+	up_perm_list = [(orig_perm,1,k)]
+	for pp in range(p):
+		perm_list = []
+		for up_perm, val, last_j in up_perm_list:
+			up_perm2 = [*up_perm]
+			if len(up_perm) < n :
+				up_perm2 += [i+1 for i in range(len(up_perm2),n)]
+			pos_list = [i for i in range(k) if (i>=len(orig_perm) and up_perm2[i]==i+1) or (i<len(orig_perm) and up_perm2[i] == orig_perm[i])]
+			for j in range(last_j,n):
+				for i in pos_list:
+					ct = count_bruhat(up_perm2,i,j)
+					#print(f"{up_perm2=} {ct=} {i=} {j=} {k=} {pp=}")
+					if ct == -1 or ct == 2*(j-i)-1:
+						new_perm = [*up_perm2]
+						new_perm[i],new_perm[j] = new_perm[j],new_perm[i]
+						new_perm_add = tuple(permtrim(new_perm))
+						new_val = val
+						if ct>0:
+							new_val *= np.prod([q_var[index] for index in range(i+1,j+1)])
+						perm_list += [(new_perm_add,new_val,j)]
+						total_list+=[(new_perm_add,pp+1,new_val)]
+		up_perm_list = perm_list
+	return total_list
+
 
 # perms and inversion diff
 def kdown_perms(perm,monoperm,p,k):	

{schubmult-1.3.6 → schubmult-1.3.8}/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.6 → schubmult-1.3.8}/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.6 → schubmult-1.3.8}/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.6 → schubmult-1.3.8}/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.6 → schubmult-1.3.8}/schubmult/schubmult_q_yz/schubmult_q_yz.py

@@ -3,18 +3,106 @@ from schubmult.schubmult_yz import compute_positive_rep, posify
 from symengine import *
 import sys
 
-
-#q_var = symarray("q",100)
-
 var2 = symarray("y",100)
 var3 = symarray("z",100)
 
-	
+var_y = var2.tolist()
+var_z = var3.tolist()
+var_x = symarray("x",100).tolist()
+
+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))
+	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_q_op(up,mx_th,th[index],n)
+				for up2, udiff,mul_val in newperms:
+					if up2 not in newpathsums:
+						newpathsums[up2]={}
+					for v in vpathdicts[index]:
+						sumval = vpathsums[up].get(v,zero)*mul_val
+						if sumval == 0:
+							continue
+						for v2,vdiff,s in vpathdicts[index][v]:
+							#print(f"{code(up2)=} {elem_sym_func_q(th[index],index+1,up,up2,v,v2,udiff,vdiff,var2,var3)=} {mul_val=} {sumval=}")							
+							newpathsums[up2][v2] = newpathsums[up2].get(v2,zero)+s*sumval*elem_sym_func_q(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
 
-	
 
 	
 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))
@@ -150,6 +238,14 @@ def factor_out_q(poly):
 var2_t = tuple(var2.tolist())
 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 .. > <-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")
+
 def main():
 	global var2
 	try:
@@ -162,13 +258,31 @@ def main():
 		display_positive = False
 		ascode = False
 		coprod = False
+		nilhecke = False
 		check = True
 		msg = False
+		just_nil = False
+		mult = False
+		
+		nil_N = 0
+		
+		mulstring = ""
+		
 		try:
 			for s in sys.argv[1:]:
+				if just_nil:
+					just_nil = False
+					nil_N = int(s)
+					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
@@ -178,26 +292,26 @@ def main():
 				if s == "--optimizer-message":
 					msg = True
 					continue
+				if s == "-nil-hecke":
+					nilhecke = True
+					just_nil = True
+					continue
 				if s == "--version":
 					print(f"Python version {sys.version}")
 					exit(0)
 				if s == "-code":
 					ascode = True
 					continue
-				if s == "--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 .. >")
-					exit(0)
+				if s == "--usage" or s == "--help":
+					print_usage()
+					exit(0)				
 				if s == "-":
 					perms += [curperm]
 					curperm = []
-					continue
+					continue				
 				curperm += [int(s)]
 		except Exception:
-			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()
 			exit(1)
 				
 		perms += [curperm]
@@ -213,9 +327,18 @@ def main():
 		size = 0
 		L = len(perms)
 		
-		coeff_dict = {perms[0]: 1}
-		for perm in perms[1:]:
-			coeff_dict = schubmult(coeff_dict,perm)
+		if nilhecke:
+			coeff_dict = nil_hecke({(1,2): 1},perms[0],nil_N)			
+			rep = ("y","x")		
+		else:
+			coeff_dict = {perms[0]: 1}
+			for perm in perms[1:]:
+				coeff_dict = schubmult(coeff_dict,perm)
+			if mult:
+				mul_exp = sympify(mulstring)
+				coeff_dict = mult_poly(coeff_dict,mul_exp)
+			rep = ("","")
+			rep = ("","")
 		
 		if pr:
 			if ascode:
@@ -243,11 +366,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]])											
@@ -260,18 +383,26 @@ 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 val!=0:
 						if ascode:
-							print(f"{str(trimcode(perm)):>{width}}  {str(val).replace('**','^').replace('*',' ')}")	
+							print(f"{str(trimcode(perm)):>{width}}  {str(val).replace('**','^').replace('*',' ').replace(*rep)}")	
 						else:
-							print(f"{str(perm):>{width}}  {str(val).replace('**','^').replace('*',' ')}")	
+							print(f"{str(perm):>{width}}  {str(val).replace('**','^').replace('*',' ').replace(*rep)}")	
 	except BrokenPipeError:
 		pass
 		

{schubmult-1.3.6 → schubmult-1.3.8}/schubmult/schubmult_yz/schubmult_yz.py

@@ -27,6 +27,99 @@ var = tuple(symarray('x',n).tolist())
 var2 = tuple(symarray('y',n).tolist())
 var3 = tuple(symarray('z',n).tolist())
 
+var_x = symarray("x",100).tolist()
+
+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 +253,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 +1430,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 +1467,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 == "-":
@@ -1462,9 +1611,22 @@ 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 down:
+				for perm in orig_perms[1:]:
+					check_coeff_dict = schubmult_down(check_coeff_dict,perm)
+				if mult:
+					mul_exp = sympify(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 = sympify(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 +1639,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 +1675,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.6 → schubmult-1.3.8}/schubmult.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: schubmult
-Version: 1.3.6
+Version: 1.3.8
 Summary: Computing Littlewood-Richardson coefficients of Schubert polynomials
 Home-page: https://github.com/matthematics/schubmult
 Author: Matt Samuel
@@ -50,7 +50,10 @@ schubmult_double -code -coprod 0 1 2 3 - 2 4
 schubmult_yz -code -coprod 0 1 2 3 - 2 4 --display-positive
 ```
 
-
+Since version 1.3.7, schubmult_q_yz has a feature for displaying the coefficients of the divided difference operators in the evaluation of the quantum double Schubert polynomials on the commuting difference operators of Fomin, Gelfand, and Postnikov. It is necessary to cap the value of n in the group S_n we are working in because as n increases the expression does not stabilize.
+```
+schubmult_q_yz -nil-hecke 6 -code 2 2 --display-positive
+```
 
 Runtime will vary tremendously by case. The general problem is #P-hard. Though the result is always nonnegative (which at least is known for schubmult_py, schubmult_q, schubmult_double, and schubmult_q_double) and the problem is in GapP, it is not known to be in #P at this time.
 

{schubmult-1.3.6 → schubmult-1.3.8}/setup.py

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