schubmult 1.3.9__tar.gz → 1.4.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: schubmult
-Version: 1.3.9
+Version: 1.4.1
 Summary: Computing Littlewood-Richardson coefficients of Schubert polynomials
 Home-page: https://github.com/matthematics/schubmult
 Author: Matt Samuel
@@ -15,7 +15,7 @@ License-File: LICENSE
 
 ## Program and package for computing Littlewood-Richardson coefficients of Schubert polynomials
 
-This is a set of python scripts written by Matt Samuel for computing Littlewood-Richardson coefficients of (ordinary or double) Schubert polynomials. Since version 1.3.3, it also handles (double) quantum Schubert polynomials, if double then either in the same set or different sets of coefficient variables; that is to say it compute the (equivariant/mixed) Gromov-Witten invariants of the complete flag variety. It has the same command line syntax as the program "schubmult" in lrcalc by Anders Buch. Example:
+This is a set of python scripts written by Matt Samuel for computing (equivariant, Molev-Sagan) Littlewood-Richardson coefficients of (ordinary or double) Schubert polynomials. It also handles (double) quantum Schubert polynomials, if double then either in the same set or different sets of coefficient variables; that is to say it compute the (equivariant/mixed) Gromov-Witten invariants of the complete flag variety. It has the same command line syntax as the program "schubmult" in lrcalc by Anders Buch. Example:
 
 ```
 schubmult_py 1 2 4 9 11 6 8 12 3 5 7 10 - 6 8 1 2 3 4 7 10 12 14 5 9 11 13  
@@ -50,7 +50,7 @@ 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 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
 ```
@@ -59,7 +59,7 @@ Runtime will vary tremendously by case. The general problem is #P-hard. Though t
 
 schubmult_py is for multiplying ordinary Schubert polynomials. schubmult_yz is for multiplying double Schubert polynomials in different sets of coefficient variables (labeled y and z), and schubmult_double is for multiplying double Schubert polynomials in the same set of coefficient variables. Similarly, schubmult_q is for multiplying quantum Schubert polynomials, schubmult_q_double is for multiplying quantum double Schubert polynomials in the same set of coefficient variables, and schubmult_q_yz is for multiplying quantum double Schubert polynomials in different sets of coefficient variables, or in other words it computes the Gromov-Witten invariants, equivariant Gromov-Witten invariants, and (mixed?) equivariant Gromov-Witten invariants of the complete flag variety. All have the same command line syntax as schubmult, except when using the -code option. schubmult_double/schubmult_q_double display the result with nonnegative coefficients in terms of the negative simple roots (and the q variables), and schubmult_yz and schubmult_q_yz optionally display the result positively in terms of y_i-z_j (and q) with the --display-positive option.
 
-New in version 1.1.0, schubmult_xx -coprod allows you to split (double) Schubert polynomials along certain indices (not available for schubmult_q). It takes one permutation as an argument, followed by a dash -, then the set of indices you would like to split on. These coefficients are always nonnegative since they occur as product coefficients (this is actually how they are computed).
+schubmult_xx -coprod allows you to split (double) Schubert polynomials along certain indices (not available for quantum). It takes one permutation as an argument, followed by a dash -, then the set of indices you would like to split on. These coefficients are always nonnegative since they occur as product coefficients (this is actually how they are computed).
 
 When imported as a python package, the relevant packages are schubmult.perm_lib, which has various permutation manipulation functions, and three modules that have functions of the same name (function name is "schubmult"): schubmult.schubmult_py, schubmult.schubmult_yz, schubmult.schubmult_double. Function takes a permutation dictionary (keys are tuples of ints, which must be trimmed permutations, and values are either integers or symengine values, which can also be integers) as well as a permutation as its second argument, which is the (double) Schubert polynomial to multiply by. Returns a dictionary of the same form with the coefficients.
 
@@ -76,7 +76,7 @@ from schubmult.schubmult_py import schubmult
 coeff_dict = schubmult({(1,3,4,6,2,5): 1},(2,1,5,7,3,4,6))
 ```
 
-Version 1.0.18 adds the command line argument --display-positive to schubmult_yz (and version 1.3.3 adds --display-positive to schubmult_q_yz), which displays the result positively (if possible, this is still only always possible conjecturally). It will fail and print out the offending case if it finds a counterexample. This is highly processor intensive.
+The command line argument --display-positive is available in schubmult_yz and schubmult_q_yz, which displays the result positively (if possible, this is still only always possible conjecturally). It will fail and print out the offending case if it finds a counterexample. This is highly processor intensive.
 
 ![](https://raw.githubusercontent.com/matthematics/schubmult/main/positive_image.png)
 

{schubmult-1.3.9 → schubmult-1.4.1}/README.md

@@ -2,7 +2,7 @@
 
 ## Program and package for computing Littlewood-Richardson coefficients of Schubert polynomials
 
-This is a set of python scripts written by Matt Samuel for computing Littlewood-Richardson coefficients of (ordinary or double) Schubert polynomials. Since version 1.3.3, it also handles (double) quantum Schubert polynomials, if double then either in the same set or different sets of coefficient variables; that is to say it compute the (equivariant/mixed) Gromov-Witten invariants of the complete flag variety. It has the same command line syntax as the program "schubmult" in lrcalc by Anders Buch. Example:
+This is a set of python scripts written by Matt Samuel for computing (equivariant, Molev-Sagan) Littlewood-Richardson coefficients of (ordinary or double) Schubert polynomials. It also handles (double) quantum Schubert polynomials, if double then either in the same set or different sets of coefficient variables; that is to say it compute the (equivariant/mixed) Gromov-Witten invariants of the complete flag variety. It has the same command line syntax as the program "schubmult" in lrcalc by Anders Buch. Example:
 
 ```
 schubmult_py 1 2 4 9 11 6 8 12 3 5 7 10 - 6 8 1 2 3 4 7 10 12 14 5 9 11 13  
@@ -37,7 +37,7 @@ 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 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
 ```
@@ -46,7 +46,7 @@ Runtime will vary tremendously by case. The general problem is #P-hard. Though t
 
 schubmult_py is for multiplying ordinary Schubert polynomials. schubmult_yz is for multiplying double Schubert polynomials in different sets of coefficient variables (labeled y and z), and schubmult_double is for multiplying double Schubert polynomials in the same set of coefficient variables. Similarly, schubmult_q is for multiplying quantum Schubert polynomials, schubmult_q_double is for multiplying quantum double Schubert polynomials in the same set of coefficient variables, and schubmult_q_yz is for multiplying quantum double Schubert polynomials in different sets of coefficient variables, or in other words it computes the Gromov-Witten invariants, equivariant Gromov-Witten invariants, and (mixed?) equivariant Gromov-Witten invariants of the complete flag variety. All have the same command line syntax as schubmult, except when using the -code option. schubmult_double/schubmult_q_double display the result with nonnegative coefficients in terms of the negative simple roots (and the q variables), and schubmult_yz and schubmult_q_yz optionally display the result positively in terms of y_i-z_j (and q) with the --display-positive option.
 
-New in version 1.1.0, schubmult_xx -coprod allows you to split (double) Schubert polynomials along certain indices (not available for schubmult_q). It takes one permutation as an argument, followed by a dash -, then the set of indices you would like to split on. These coefficients are always nonnegative since they occur as product coefficients (this is actually how they are computed).
+schubmult_xx -coprod allows you to split (double) Schubert polynomials along certain indices (not available for quantum). It takes one permutation as an argument, followed by a dash -, then the set of indices you would like to split on. These coefficients are always nonnegative since they occur as product coefficients (this is actually how they are computed).
 
 When imported as a python package, the relevant packages are schubmult.perm_lib, which has various permutation manipulation functions, and three modules that have functions of the same name (function name is "schubmult"): schubmult.schubmult_py, schubmult.schubmult_yz, schubmult.schubmult_double. Function takes a permutation dictionary (keys are tuples of ints, which must be trimmed permutations, and values are either integers or symengine values, which can also be integers) as well as a permutation as its second argument, which is the (double) Schubert polynomial to multiply by. Returns a dictionary of the same form with the coefficients.
 
@@ -63,7 +63,7 @@ from schubmult.schubmult_py import schubmult
 coeff_dict = schubmult({(1,3,4,6,2,5): 1},(2,1,5,7,3,4,6))
 ```
 
-Version 1.0.18 adds the command line argument --display-positive to schubmult_yz (and version 1.3.3 adds --display-positive to schubmult_q_yz), which displays the result positively (if possible, this is still only always possible conjecturally). It will fail and print out the offending case if it finds a counterexample. This is highly processor intensive.
+The command line argument --display-positive is available in schubmult_yz and schubmult_q_yz, which displays the result positively (if possible, this is still only always possible conjecturally). It will fail and print out the offending case if it finds a counterexample. This is highly processor intensive.
 
 ![](https://raw.githubusercontent.com/matthematics/schubmult/main/positive_image.png)
 

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

@@ -8,6 +8,11 @@ n = 100
 
 q_var = symarray("q",n)
 
+def getpermval(perm,index):
+	if index<len(perm):
+		return perm[index]
+	return index+1
+
 def inv(perm):
 	L = len(perm)
 	v = [i for i in range(1,L+1)]
@@ -148,7 +153,7 @@ def elem_sym_perms_op(orig_perm,p,k):
 			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]]
+			pos_list = [i for i in range(k) if getpermval(up_perm2,i) == getpermval(orig_perm,i)]
 			for j in range(last,len(up_perm2)):				
 				for i in pos_list:								
 					if has_bruhat_descent(up_perm2,i,j):
@@ -229,7 +234,81 @@ def elem_sym_perms_q_op(orig_perm,p,k,n):
 		up_perm_list = perm_list
 	return total_list
 
+qvar_list = q_var.tolist()
 
+def q_vector(q_exp):
+	ret = []
+	
+	if q_exp == 1:
+		return ret
+	if q_exp in q_var:
+		i = qvar_list.index(q_exp)
+		ret = [0 for j in range(i-1)] + [1]
+		return ret
+	if isinstance(q_exp, Pow):
+		qv = q_exp.args[0]
+		expon = int(q_exp.args[1])
+		i = qvar_list.index(qv)
+		ret = [0 for j in range(i-1)] + [expon]
+		return ret
+	if isinstance(q_exp, Mul):	
+		for a in q_exp.args:
+			v1 = q_vector(a)
+			v1 += [0 for i in range(len(v1),len(ret))]
+			ret += [0 for i in range(len(ret),len(v1))]
+			ret = [ret[i] + v1[i] for i in range(len(ret))]
+		return ret
+		
+	return None
+
+def omega(i,qv):
+	i = i - 1
+	if len(qv) == 0 or i > len(qv):
+		return 0
+	if i == 0:
+		if len(qv) == 1:
+			return 2*qv[0]
+		return 2*qv[0] - qv[1]
+	if i == len(qv):
+		return -qv[-1]
+	if i == len(qv) - 1:
+		return 2*qv[-1] - qv[-2]
+	return 2*qv[i] - qv[i-1] - qv[i+1]
+
+def sg(i,w):
+	if i>=len(w) - 1 or w[i]<w[i+1]:
+		return 0
+	return 1
+
+def reduce_q_coeff(u, v, w, qv):
+	for i in range(len(qv)):
+		if (i<len(u)-1 and u[i]>u[i+1] and (i>=len(v)-1 or v[i]<v[i+1]) and (i>=len(w)-1 or w[i]<w[i+1]) and sg(i,w) + omega(i+1,qv) == 1):
+			ret_u = [*u]
+			ret_u[i], ret_u[i+1] = ret_u[i+1], ret_u[i]
+			ret_w = [*w] + [j+1 for j in range(len(w),i+2)]
+			ret_w[i], ret_w[i+1] = ret_w[i+1], ret_w[i]
+			qv_ret = [*qv]
+			qv_ret[i] -= 1
+			return tuple(permtrim(ret_u)), v, tuple(permtrim(ret_w)), qv_ret, True
+		elif (i<len(v)-1 and v[i]>v[i+1] and (i>=len(u)-1 or u[i]<u[i+1]) and (i>=len(w)-1 or w[i]<w[i+1]) and sg(i,w) + omega(i+1,qv) == 1):
+			ret_v = [*v]
+			ret_v[i], ret_v[i+1] = ret_v[i+1], ret_v[i]
+			ret_w = [*w] + [j+1 for j in range(len(w),i+2)]
+			ret_w[i], ret_w[i+1] = ret_w[i+1], ret_w[i]
+			qv_ret = [*qv]
+			qv_ret[i] -= 1
+			return u, tuple(permtrim(ret_v)), tuple(permtrim(ret_w)), qv_ret, True
+		elif (i<len(u)-1 and u[i]>u[i+1] and i<len(v)-1 and v[i]>v[i+1] and sg(i,w)+omega(i+1,qv)  == 2):
+			ret_u = [*u]
+			ret_u[i], ret_u[i+1] = ret_u[i+1], ret_u[i]
+			ret_w = [*w] + [j+1 for j in range(len(w),i+2)]
+			ret_w[i], ret_w[i+1] = ret_w[i+1], ret_w[i]
+			qv_ret = [*qv]
+			if i>=len(w)-1 or w[i]<w[i+1]:
+				qv_ret[i] -= 1
+			return tuple(permtrim(ret_u)), v, tuple(permtrim(ret_w)), qv_ret, True
+	return u, v, w, qv, False
+		
 # perms and inversion diff
 def kdown_perms(perm,monoperm,p,k):	
 	inv_m = inv(monoperm)
@@ -663,4 +742,80 @@ def pull_out_var(vnum,v):
 			vpm2.pop(vnum-1)
 			vp = permtrim(vpm2)
 			ret_list += [[[v[i] for i in range(vnum,len(v)) if ((i>len(vp) and v[i]==i) or (i<=len(vp) and v[i]==vp[i-1]))],vp]]
-	return ret_list			
+	return ret_list			
+	
+def get_cycles(perm):
+	cycle_set = []
+	done_vals = set()
+	for i in range(len(perm)):
+		p = i + 1
+		if perm[i] == p:
+			continue
+		if p in done_vals:
+			continue
+		cycle = []
+		m = -1
+		max_index = -1
+		while p not in done_vals:
+			cycle += [p]
+			done_vals.add(p)
+			if p>m:
+				m = p
+				max_index = len(cycle) - 1
+			p = perm[p-1]
+		cycle = tuple(cycle[max_index+1:] + cycle[:max_index+1])
+		cycle_set += [cycle]
+	return cycle_set
+	
+def double_elem_sym_q(u,p1,p2,k):
+	ret_list = {}
+	perms1 = elem_sym_perms_q(u,p1,k)
+	iu = inverse(u)
+	for perm1, udiff1, mul_val1 in perms1:
+		perms2 = elem_sym_perms_q(perm1,p2,k)
+		cycles1 = get_cycles(tuple(permtrim(mulperm(iu,[*perm1]))))
+		cycles1_dict = {}
+		for c in cycles1:
+			if c[-1] not in cycles1_dict:
+				cycles1_dict[c[-1]] = []
+			cycles1_dict[c[-1]]+= [set(c)]
+		ip1 = inverse(perm1)
+		for perm2, udiff2, mul_val2 in perms2:
+			cycles2 = get_cycles(tuple(permtrim(mulperm(ip1,[*perm2]))))
+			good = True
+			for i in range(len(cycles2)):
+				c2 = cycles2[i]
+				if c2[-1] not in cycles1_dict:
+					continue
+				for c1_s in cycles1_dict[c2[-1]]:
+					for a in range(len(c2)-2,-1,-1):
+						if c2[a] in c1_s:
+							good = False
+							break
+					if not good:
+						break														
+				if not good:
+					break
+			
+			if good:				
+				if (perm1,udiff1,mul_val1) not in ret_list:
+					ret_list[(perm1,udiff1,mul_val1)] = []
+				ret_list[(perm1,udiff1,mul_val1)] += [(perm2,udiff2,mul_val2)]
+	return ret_list
+
+def medium_theta(perm):
+	cd = code(perm)
+	found_one = True
+	while found_one:
+		found_one = False
+		for i in range(len(cd)-1):
+			if cd[i]<cd[i+1]: 
+				found_one = True
+				cd[i], cd[i+1] = cd[i+1]+1, cd[i]
+				break
+			if cd[i]==cd[i+1] and cd[i]!=0 and i>0 and cd[i-1]<=cd[i]+1:
+			#if cd[i]==cd[i+1] and i>0 and cd[i-1]<=cd[i]+1:
+				cd[i]+=1
+				found_one = True
+				break
+	return cd

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

@@ -63,6 +63,92 @@ for i in range(1,n):
 		sm += var_r[j]
 	subs_dict[var2[i]] = sm
 
+def schubmult_db(perm_dict,v,var2=var2,var3=var3):
+	if v == (1,2):
+		return perm_dict
+	th = medium_theta(inverse(v))
+	#print(f"{th=}")
+	while th[-1] == 0:
+		th.pop()
+	#if len(set(th))!=len(th):
+	#	print(f"medium theta {th=}")
+	mu = permtrim(uncode(th))
+	vmu = permtrim(mulperm([*v],mu))
+	inv_vmu = inv(vmu)
+	inv_mu = inv(mu)
+	ret_dict = {}
+	vpaths = [([(vmu,0)],1)]
+	
+	thL = len(th)
+	#if thL!=2 and len(set(thL))!=1:
+	#	raise ValueError("Not what I can do")
+	vpathdicts = compute_vpathdicts(th,vmu,True)
+	#print(f"{vpathdicts=}")
+	for u,val in perm_dict.items():
+		inv_u = inv(u)
+		vpathsums = {u: {(1,2): val}}
+		for index in range(thL):
+			if index>0 and th[index-1] == th[index]:
+				continue				
+			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
+			if index<len(th)-1 and th[index] == th[index+1]:
+				mx_th1 = 0
+				for vp in vpathdicts[index+1]:
+					for v2,vdiff,s in vpathdicts[index+1][vp]:
+						if th[index+1]-vdiff > mx_th1:
+							mx_th1 = th[index+1] - vdiff				
+				newpathsums = {}
+				for up in vpathsums:
+					newpathsums0 = {}
+					inv_up = inv(up)
+					newperms = double_elem_sym_q(up,mx_th,mx_th1,th[index])
+					for v in vpathdicts[index]:
+						sumval = vpathsums[up].get(v,zero)
+						if sumval == 0:
+							continue
+						for v2,vdiff2,s2 in vpathdicts[index][v]:
+							for up1, udiff1, mul_val1 in newperms:
+								if (up1,udiff1,mul_val1) not in newpathsums0:
+									newpathsums0[(up1,udiff1,mul_val1)] = {}
+								if udiff1 + vdiff2 == th[index]:
+									newpathsums0[(up1,udiff1,mul_val1)][v2] = newpathsums0[(up1,udiff1,mul_val1)].get(v2,zero)+s2*sumval*mul_val1
+					
+					for up1, udiff1, mul_val1 in newpathsums0:
+						for v in vpathdicts[index+1]:
+							sumval = newpathsums0[(up1,udiff1,mul_val1)].get(v,zero)
+							if sumval == 0:
+								continue
+							for v2,vdiff2,s2 in vpathdicts[index+1][v]:
+								for up2, udiff2, mul_val2 in newperms[(up1,udiff1,mul_val1)]:
+									if up2 not in newpathsums:
+										newpathsums[up2]={}
+									if udiff2 + vdiff2 == th[index+1]:
+										newpathsums[up2][v2] = newpathsums[up2].get(v2,zero)+s2*sumval*mul_val2
+			else:
+				newpathsums = {}
+				for up in vpathsums:
+					inv_up = inv(up)
+					newperms = elem_sym_perms_q(up,min(mx_th,(inv_mu-(inv_up-inv_u))-inv_vmu),th[index])
+					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)
+							if sumval == 0:
+								continue
+							for v2,vdiff,s in vpathdicts[index][v]:
+								if udiff+vdiff==th[index]:
+									newpathsums[up2][v2] = newpathsums[up2].get(v2,zero)+s*sumval*mul_val
+			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):
 	th = strict_theta(inverse(v))
 	mu = permtrim(uncode(th))
@@ -177,12 +263,16 @@ def main():
 		equiv = False
 		mult = False
 		mulstring = ""
+		slow = False
 		
 		try:
 			for s in sys.argv[1:]:
 				if s == "-np" or s == "--no-print":
 					pr = False
 					continue
+				if s == "--slow":
+					slow = True
+					continue
 				if mult:
 					mulstring += s
 					continue
@@ -344,8 +434,12 @@ def main():
 		
 			coeff_dict = {tuple(permtrim([*perms[0]])): 1}
 			
-			for perm in perms[1:]:
-				coeff_dict = schubmult(coeff_dict,tuple(permtrim([*perm])))
+			if not slow:
+				for perm in perms[1:]:
+					coeff_dict = schubmult_db(coeff_dict,tuple(permtrim([*perm])))
+			else:
+				for perm in perms[1:]:
+					coeff_dict = schubmult(coeff_dict,tuple(permtrim([*perm])))
 			
 			if mult:
 				mul_exp = sympify(mulstring)

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

@@ -1,5 +1,5 @@
 from schubmult.perm_lib import *
-from schubmult.schubmult_q_yz import schubmult, mult_poly
+from schubmult.schubmult_q_yz import schubmult, schubmult_db, mult_poly
 from symengine import *
 import sys
 
@@ -37,12 +37,16 @@ def main():
 		check = True
 		msg = False
 		mult = False
+		slow = False
 		mulstring = ""
 		try:
 			for s in sys.argv[1:]:
 				if s == "-np" or s == "--no-print":
 					pr = False
 					continue
+				if s == "--slow":
+					slow = True
+					continue
 				if mult:
 					mulstring += s
 					continue
@@ -96,7 +100,10 @@ def main():
 		
 		coeff_dict = {perms[0]: 1}
 		for perm in perms[1:]:
-			coeff_dict = schubmult(coeff_dict,perm,var2,var2)
+			if slow:
+				coeff_dict = schubmult(coeff_dict,perm,var2,var2)
+			else:
+				coeff_dict = schubmult_db(coeff_dict,perm,var2,var2)
 		if mult:
 			mul_exp = sympify(mulstring)
 			coeff_dict = mult_poly(coeff_dict,mul_exp)

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

@@ -1,5 +1,6 @@
 from schubmult.perm_lib import *
 from schubmult.schubmult_yz import compute_positive_rep, posify
+import schubmult.schubmult_yz as norm_yz
 from symengine import *
 import sys
 
@@ -149,6 +150,104 @@ 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_db(perm_dict,v,var2=var2,var3=var3):
+	if v == (1,2):
+		return perm_dict
+	th = medium_theta(inverse(v))
+	#print(f"{th=}")
+	while th[-1] == 0:
+		th.pop()
+	#if len(set(th))!=len(th):
+	#	print(f"medium theta {th=}")
+	mu = permtrim(uncode(th))
+	vmu = permtrim(mulperm([*v],mu))
+	inv_vmu = inv(vmu)
+	inv_mu = inv(mu)
+	ret_dict = {}
+	vpaths = [([(vmu,0)],1)]
+	
+	thL = len(th)
+	#if thL!=2 and len(set(thL))!=1:
+	#	raise ValueError("Not what I can do")
+	vpathdicts = compute_vpathdicts(th,vmu,True)
+	#print(f"{vpathdicts=}")
+	for u,val in perm_dict.items():
+		inv_u = inv(u)
+		vpathsums = {u: {(1,2): val}}
+		for index in range(thL):
+			if index>0 and th[index-1] == th[index]:
+				continue				
+			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
+			if index<len(th)-1 and th[index] == th[index+1]:
+				mx_th1 = 0
+				for vp in vpathdicts[index+1]:
+					for v2,vdiff,s in vpathdicts[index+1][vp]:
+						if th[index+1]-vdiff > mx_th1:
+							mx_th1 = th[index+1] - vdiff				
+				newpathsums = {}
+				for up in vpathsums:
+					newpathsums0 = {}
+					inv_up = inv(up)
+					newperms = double_elem_sym_q(up,mx_th,mx_th1,th[index])
+					#for up1, up2, udiff1,udiff2,mul_val1,mul_val2 in newperms:
+					for v in vpathdicts[index]:
+						sumval = vpathsums[up].get(v,zero)
+						if sumval == 0:
+							continue
+						for v2,vdiff2,s2 in vpathdicts[index][v]:
+							for up1, udiff1, mul_val1 in newperms:
+								esim1 = elem_sym_func_q(th[index],index+1,up,up1,v,v2,udiff1,vdiff2,var2,var3)*mul_val1*s2
+								mulfac = sumval*esim1
+								if (up1,udiff1,mul_val1) not in newpathsums0:
+									newpathsums0[(up1,udiff1,mul_val1)] = {}
+								#newpathsums0[(up1, udiff1, mul_val1
+								newpathsums0[(up1,udiff1,mul_val1)][v2] = newpathsums0[(up1,udiff1,mul_val1)].get(v2,0) + mulfac
+					
+					for up1, udiff1, mul_val1 in newpathsums0:
+						for v in vpathdicts[index+1]:
+							sumval = newpathsums0[(up1,udiff1,mul_val1)].get(v,zero)
+							if sumval == 0:
+								continue
+							for v2,vdiff2,s2 in vpathdicts[index+1][v]:
+								for up2, udiff2, mul_val2 in newperms[(up1,udiff1,mul_val1)]:
+									esim1 = elem_sym_func_q(th[index+1],index+2,up1,up2,v,v2,udiff2,vdiff2,var2,var3)*mul_val2*s2
+									mulfac = sumval*esim1
+									if up2 not in newpathsums:
+										newpathsums[up2] = {}
+									newpathsums[up2][v2] = newpathsums[up2].get(v2,0) + mulfac
+											#for up2, udiff2, mul_val2 in newperms[(up1,udiff1,mul_val1)]:
+											#	if up2 not in newpathsums:
+											#		newpathsums[up2]={}
+											#	for v3,vdiff3,s3 in vpathdicts[index+1][v2]:
+											#			newpathsums[up2][v3] = newpathsums[up2].get(v3,zero)+s3*mul_val2*mulfac*elem_sym_func_q(th[index+1],index+2,up1,up2,v2,v3,udiff2,vdiff3,var2,var3)
+			else:
+				newpathsums = {}
+				for up in vpathsums:
+					inv_up = inv(up)
+					newperms = elem_sym_perms_q(up,min(mx_th,(inv_mu-(inv_up-inv_u))-inv_vmu),th[index])
+					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]:
+								newpathsums[up2][v2] = newpathsums[up2].get(v2,zero)+s*sumval*elem_sym_func_q(th[index],index+1,up,up2,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 div_diff(v,w,var2=var2,var3=var3):
+	coeff_dict = {v: 1}
+	coeff_dict = norm_yz.schubmult_down(coeff_dict,w,var2,var3)
+	return coeff_dict.get((1,2),0)
+
 q_var2 = q_var.tolist()
 
 def sum_q_dict(q_dict1,q_dict2):
@@ -266,10 +365,12 @@ def main():
 		ascode = False
 		coprod = False
 		nilhecke = False
+		nilhecke_apply = False
 		check = True
 		msg = False
 		just_nil = False
 		mult = False
+		slow = False
 		
 		nil_N = 0
 		
@@ -283,6 +384,9 @@ def main():
 					just_nil = False
 					nil_N = int(s)
 					continue
+				if s == "--slow":
+					slow = True
+					continue
 				if s == "--norep":
 					norep = True
 					continue
@@ -311,6 +415,10 @@ def main():
 					nilhecke = True
 					just_nil = True
 					continue
+				if s == "-nil-hecke-apply":
+					nilhecke_apply = True
+					just_nil = True
+					continue
 				if s == "--version":
 					print(f"Python version {sys.version}")
 					exit(0)
@@ -346,11 +454,20 @@ def main():
 		
 		if nilhecke:
 			coeff_dict = nil_hecke({(1,2): 1},perms[0],nil_N)			
-			rep = ("y","x")		
+			rep = ("y","x")
+		elif nilhecke_apply:
+			coeff_dict0 = nil_hecke({(1,2): 1},perms[0],nil_N,var2,var2)
+			coeff_dict = {(1,2): 0}
+			for v in coeff_dict0:
+				coeff_dict[(1,2)] += coeff_dict0[v]*div_diff(v,perms[1],var2,var3)
+			rep = ("y","x")			
 		else:
 			coeff_dict = {perms[0]: 1}
 			for perm in perms[1:]:
-				coeff_dict = schubmult(coeff_dict,perm)
+				if not slow:
+					coeff_dict = schubmult_db(coeff_dict,perm)
+				else:
+					coeff_dict = schubmult(coeff_dict,perm)
 			if mult:
 				for v in var2:
 					globals()[str(v)] = v
@@ -358,15 +475,18 @@ def main():
 					globals()[str(v)] = v	
 				for v in var_x:
 					globals()[str(v)] = v	
+				for v in q_var:
+					globals()[str(v)] = v
+				q = q_var
 				mul_exp = eval(mulstring)
 				coeff_dict = mult_poly(coeff_dict,mul_exp)
 			rep = ("","")			
 		
 		if pr:
-			if ascode:
-				width = max([len(str(trimcode(perm))) for perm in coeff_dict.keys() if expand(coeff_dict[perm])!=0])
-			else:
-				width = max([len(str(perm)) for perm in coeff_dict.keys() if expand(coeff_dict[perm])!=0])
+			#if ascode:
+			#	width = max([len(str(trimcode(perm))) for perm in coeff_dict.keys() if expand(coeff_dict[perm])!=0])
+			#else:
+			#	width = max([len(str(perm)) for perm in coeff_dict.keys() if expand(coeff_dict[perm])!=0])
 			
 			coeff_perms = list(coeff_dict.keys())
 			coeff_perms.sort(key=lambda x: (inv(x),*x))
@@ -388,22 +508,28 @@ def main():
 									val2 += q_part*int(q_dict[q_part])
 								except Exception:
 									try:
-										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 and not mult:
-											i = q_var2.index(q_part)
-											u = permtrim([*perms[0]])
-											v = permtrim([*perms[1]])											
-											#print(f"{u=} {v=} {q_part=} {q_dict[q_part]=}")
-											if i<len(u) and i<len(v) and u[i-1]>u[i] and v[i-1]>v[i]:
-												u[i], u[i-1] = u[i-1], u[i]
-												v[i], v[i-1] = v[i-1], v[i]
-												#print(f"new {u=} {v=}")
-												val2 += q_part*posify(q_dict[q_part],tuple(permtrim(u)),tuple(permtrim(v)),perm,var2_t,var3_t,msg,False)
+										if len(perms) == 2:
+											u = tuple(permtrim([*perms[0]]))
+											v = tuple(permtrim([*perms[1]]))
+										if len(perms) == 2 and code(inverse(perms[1])) == medium_theta(inverse(perms[1])) and not mult and not slow and not nilhecke_apply:
+											val2 += q_part*q_dict[q_part]
 										else:
-											val2 += q_part*compute_positive_rep(q_dict[q_part],var2_t,var3_t,msg,False)
+											q_part2 = q_part
+											if not mult and not nilhecke_apply and len(perms) == 2:
+												qv = q_vector(q_part)
+												u2, v2, w2 = u, v, perm
+												u2, v2, w2, qv, did_one = reduce_q_coeff(u2, v2, w2, qv)
+												while did_one:
+													u2, v2, w2, qv, did_one = reduce_q_coeff(u2, v2, w2, qv)
+												q_part2 = np.prod([q_var[i+1]**qv[i] for i in range(len(qv))])
+												if q_part2 == 1:												
+													#if q_part != q_part2:
+													#	print("Posified q part")
+													val2 += q_part*posify(q_dict[q_part],u2,v2,w2,var2_t,var3_t,msg,False)
+												else:
+													val2 += q_part*compute_positive_rep(q_dict[q_part],var2_t,var3_t,msg,False)
+											else:
+												val2 += q_part*compute_positive_rep(q_dict[q_part],var2_t,var3_t,msg,False)
 									except Exception as e:
 										if mult:
 											print("warning; --display-positive is on but result is not positive",file=sys.stderr)
@@ -412,12 +538,14 @@ def main():
 										else:
 											print(f"error; write to schubmult@gmail.com with the case {perms=} {perm=} {val=} {coeff_dict.get(perm,0)=}")
 											print(f"Exception: {e}")
+											import traceback
+											traceback.print_exc()
 											exit(1)
 							if check and expand(val - val2)!=0:
 								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)=}")
+									print(f"error: value not equal; write to schubmult@gmail.com with the case {perms=} {perm=} {val2=} {coeff_dict.get(perm,0)=}")
 									exit(1)
 							val = val2
 					if expa:
@@ -425,14 +553,14 @@ def main():
 					if val!=0:
 						if ascode:
 							if norep:
-								print(f"{str(trimcode(perm)):>{width}}  {str(val).replace(*rep)}")	
+								print(f"{str(trimcode(perm))}  {str(val).replace(*rep)}")	
 							else:
-								print(f"{str(trimcode(perm)):>{width}}  {str(val).replace('**','^').replace('*',' ').replace(*rep)}")	
+								print(f"{str(trimcode(perm))}  {str(val).replace('**','^').replace('*',' ').replace(*rep)}")	
 						else:
 							if norep:
-								print(f"{str(perm):>{width}}  {str(val).replace(*rep)}")	
+								print(f"{str(perm)}  {str(val).replace(*rep)}")	
 							else:
-								print(f"{str(perm):>{width}}  {str(val).replace('**','^').replace('*',' ').replace(*rep)}")	
+								print(f"{str(perm)}  {str(val).replace('**','^').replace('*',' ').replace(*rep)}")	
 	except BrokenPipeError:
 		pass
 		

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

@@ -129,7 +129,21 @@ def mult_poly_down(coeff_dict,poly):
 			ret[perm] = poly*coeff_dict[perm]
 		return ret
 
-
+def nilhecke_mult(coeff_dict1,coeff_dict2):
+	ret = {}
+	for w in coeff_dict2:
+		w1 = [*w]
+		inv_w1 = inv(w1)
+		poly = coeff_dict2[w]
+		did_mul = mult_poly_down(coeff_dict1,poly)
+		for v in did_mul:
+			v1 = [*v1]
+			addperm = mulperm(v1,w1)
+			if inv(addperm) == inv(v1) + inv_w1:
+				toadd = tuple(permtrim(addperm))
+				ret[toadd] = ret.get(toadd,0) + did_mul[v]
+	return ret
+	
 def forwardcoeff(u,v,perm,var2=var2,var3=var3):
 	th = theta(v)
 	muv = uncode(th)
@@ -1301,7 +1315,7 @@ def posify(val,u2,v2,w2,var2=var2,var3=var3,msg=False,do_pos_neg=True,sign_only=
 				val2 = schubmult_one(tuple(permtrim(u3)),tuple(permtrim(v3)),var2,var3).get(tuple(permtrim(w3)),0)
 				val2 = posify(val2,u3,tuple(permtrim(v3)),w3,var2,var3,msg,do_pos_neg)
 				val += tomul*shiftsub(val2)
-		elif inv(w)-inv(u)==2:
+		elif inv(w)-inv(u)==2 and len(trimcode(u)) == len(trimcode(w)):
 			indices = []
 			for i in range(len(w)):
 				if i>=len(u) or u[i]!=w[i]:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: schubmult
-Version: 1.3.9
+Version: 1.4.1
 Summary: Computing Littlewood-Richardson coefficients of Schubert polynomials
 Home-page: https://github.com/matthematics/schubmult
 Author: Matt Samuel
@@ -15,7 +15,7 @@ License-File: LICENSE
 
 ## Program and package for computing Littlewood-Richardson coefficients of Schubert polynomials
 
-This is a set of python scripts written by Matt Samuel for computing Littlewood-Richardson coefficients of (ordinary or double) Schubert polynomials. Since version 1.3.3, it also handles (double) quantum Schubert polynomials, if double then either in the same set or different sets of coefficient variables; that is to say it compute the (equivariant/mixed) Gromov-Witten invariants of the complete flag variety. It has the same command line syntax as the program "schubmult" in lrcalc by Anders Buch. Example:
+This is a set of python scripts written by Matt Samuel for computing (equivariant, Molev-Sagan) Littlewood-Richardson coefficients of (ordinary or double) Schubert polynomials. It also handles (double) quantum Schubert polynomials, if double then either in the same set or different sets of coefficient variables; that is to say it compute the (equivariant/mixed) Gromov-Witten invariants of the complete flag variety. It has the same command line syntax as the program "schubmult" in lrcalc by Anders Buch. Example:
 
 ```
 schubmult_py 1 2 4 9 11 6 8 12 3 5 7 10 - 6 8 1 2 3 4 7 10 12 14 5 9 11 13  
@@ -50,7 +50,7 @@ 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 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
 ```
@@ -59,7 +59,7 @@ Runtime will vary tremendously by case. The general problem is #P-hard. Though t
 
 schubmult_py is for multiplying ordinary Schubert polynomials. schubmult_yz is for multiplying double Schubert polynomials in different sets of coefficient variables (labeled y and z), and schubmult_double is for multiplying double Schubert polynomials in the same set of coefficient variables. Similarly, schubmult_q is for multiplying quantum Schubert polynomials, schubmult_q_double is for multiplying quantum double Schubert polynomials in the same set of coefficient variables, and schubmult_q_yz is for multiplying quantum double Schubert polynomials in different sets of coefficient variables, or in other words it computes the Gromov-Witten invariants, equivariant Gromov-Witten invariants, and (mixed?) equivariant Gromov-Witten invariants of the complete flag variety. All have the same command line syntax as schubmult, except when using the -code option. schubmult_double/schubmult_q_double display the result with nonnegative coefficients in terms of the negative simple roots (and the q variables), and schubmult_yz and schubmult_q_yz optionally display the result positively in terms of y_i-z_j (and q) with the --display-positive option.
 
-New in version 1.1.0, schubmult_xx -coprod allows you to split (double) Schubert polynomials along certain indices (not available for schubmult_q). It takes one permutation as an argument, followed by a dash -, then the set of indices you would like to split on. These coefficients are always nonnegative since they occur as product coefficients (this is actually how they are computed).
+schubmult_xx -coprod allows you to split (double) Schubert polynomials along certain indices (not available for quantum). It takes one permutation as an argument, followed by a dash -, then the set of indices you would like to split on. These coefficients are always nonnegative since they occur as product coefficients (this is actually how they are computed).
 
 When imported as a python package, the relevant packages are schubmult.perm_lib, which has various permutation manipulation functions, and three modules that have functions of the same name (function name is "schubmult"): schubmult.schubmult_py, schubmult.schubmult_yz, schubmult.schubmult_double. Function takes a permutation dictionary (keys are tuples of ints, which must be trimmed permutations, and values are either integers or symengine values, which can also be integers) as well as a permutation as its second argument, which is the (double) Schubert polynomial to multiply by. Returns a dictionary of the same form with the coefficients.
 
@@ -76,7 +76,7 @@ from schubmult.schubmult_py import schubmult
 coeff_dict = schubmult({(1,3,4,6,2,5): 1},(2,1,5,7,3,4,6))
 ```
 
-Version 1.0.18 adds the command line argument --display-positive to schubmult_yz (and version 1.3.3 adds --display-positive to schubmult_q_yz), which displays the result positively (if possible, this is still only always possible conjecturally). It will fail and print out the offending case if it finds a counterexample. This is highly processor intensive.
+The command line argument --display-positive is available in schubmult_yz and schubmult_q_yz, which displays the result positively (if possible, this is still only always possible conjecturally). It will fail and print out the offending case if it finds a counterexample. This is highly processor intensive.
 
 ![](https://raw.githubusercontent.com/matthematics/schubmult/main/positive_image.png)
 

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

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