schubmult 1.2.11__tar.gz → 1.3.0__tar.gz

{schubmult-1.2.11 → schubmult-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: schubmult
-Version: 1.2.11
+Version: 1.3.0
 Summary: Computing Littlewood-Richardson coefficients of Schubert polynomials
 Home-page: https://github.com/matthematics/schubmult
 Author: Matt Samuel
@@ -15,12 +15,13 @@ 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. 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 Littlewood-Richardson coefficients of (ordinary or double) Schubert polynomials. Since version 1.3.0, it also handles quantum Schubert polynomials. 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  
 schubmult_double 1 3 4 6 2 5 - 2 1 5 7 3 4 6  
 schubmult_yz 1 3 4 6 2 5 - 2 1 5 7 3 4 6
+schubmult_q 5 1 4 3 2 - 2 1 3 5 4
 ```
 
 The same execution with the Lehmer code:
@@ -29,6 +30,7 @@ The same execution with the Lehmer code:
 schubmult_py -code 0 0 1 5 6 2 3 4 - 5 6 0 0 0 0 1 2 3 4
 schubmult_double -code 0 1 1 2 - 1 0 2 3
 schubmult_yz -code 0 1 1 2 - 1 0 2 3
+schubmult_q -code 4 0 2 1 - 1 0 0 1
 ```
 
 For coproducts:
@@ -50,7 +52,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. Both have the same command line syntax as schubmult. schubmult_double displays the result with nonnegative coefficients in terms of the negative simple roots. Both are of course slower than schubmult_py, and expressing the result positively for schubmult_double slows it down even more.
 
-New in version 1.1.0, schubmult_py -coprod allows you to split Schubert polynomials along certain indices. 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).
+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).
 
 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.
 

{schubmult-1.2.11 → schubmult-1.3.0}/README.md

@@ -2,12 +2,13 @@
 
 ## 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. 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 Littlewood-Richardson coefficients of (ordinary or double) Schubert polynomials. Since version 1.3.0, it also handles quantum Schubert polynomials. 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  
 schubmult_double 1 3 4 6 2 5 - 2 1 5 7 3 4 6  
 schubmult_yz 1 3 4 6 2 5 - 2 1 5 7 3 4 6
+schubmult_q 5 1 4 3 2 - 2 1 3 5 4
 ```
 
 The same execution with the Lehmer code:
@@ -16,6 +17,7 @@ The same execution with the Lehmer code:
 schubmult_py -code 0 0 1 5 6 2 3 4 - 5 6 0 0 0 0 1 2 3 4
 schubmult_double -code 0 1 1 2 - 1 0 2 3
 schubmult_yz -code 0 1 1 2 - 1 0 2 3
+schubmult_q -code 4 0 2 1 - 1 0 0 1
 ```
 
 For coproducts:
@@ -37,7 +39,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. Both have the same command line syntax as schubmult. schubmult_double displays the result with nonnegative coefficients in terms of the negative simple roots. Both are of course slower than schubmult_py, and expressing the result positively for schubmult_double slows it down even more.
 
-New in version 1.1.0, schubmult_py -coprod allows you to split Schubert polynomials along certain indices. 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).
+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).
 
 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.
 

{schubmult-1.2.11 → schubmult-1.3.0}/schubmult/perm_lib.py

@@ -2,6 +2,11 @@ from symengine import *
 from functools import cache
 from itertools import chain
 from bisect import bisect_left
+import numpy as np
+
+n = 100
+
+q_var = symarray("q",n)
 
 def inv(perm):
 	L = len(perm)
@@ -86,6 +91,20 @@ def has_bruhat_descent(perm,i,j):
 			return False
 	return True
 
+def count_bruhat(perm,i,j):
+	up_amount = 0
+	if perm[i]<perm[j]:
+		up_amount = 1
+	else:
+		up_amount = -1
+	for k in range(i+1,j):
+		if perm[i]<perm[k] and perm[j]>perm[k]:
+			up_amount+=1
+		elif perm[i]>perm[k] and perm[j]<perm[k]:
+			up_amount-=1
+	return up_amount
+
+
 def has_bruhat_ascent(perm,i,j):
 	if perm[i]>perm[j]:
 		return False
@@ -120,6 +139,33 @@ def elem_sym_perms(orig_perm,p,k):
 		up_perm_list = perm_list
 	return total_list
 
+
+def elem_sym_perms_q(orig_perm,p,k):	
+	total_list = [(orig_perm,0,1)]
+	up_perm_list = [(orig_perm,1,1000)]
+	for pp in range(p):
+		perm_list = []
+		for up_perm, last, last_j in up_perm_list:	
+			up_perm2 = [*up_perm,len(up_perm)+1]
+			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 i>=len(orig_perm) or up_perm2[i] == orig_perm[i]]
+			for j in range(min(last_j,len(up_perm2)-1),k-1,-1):
+				for i in pos_list:
+					ct = count_bruhat(up_perm2,i,j)
+					if ct == 1 or ct == 2*(i-j)+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_last = last
+						if ct<0:
+							new_last *= np.prod([q_var[index] for index in range(i+1,j+1)])
+						perm_list += [(new_perm_add,new_last,j)]
+						total_list+=[(new_perm_add,pp+1,new_last)]
+		up_perm_list = perm_list
+	return total_list
+
+
 # perms and inversion diff
 def kdown_perms(perm,monoperm,p,k):	
 	inv_m = inv(monoperm)

schubmult-1.3.0/schubmult/schubmult_q/__init__.py

@@ -0,0 +1,2 @@
+from .schubmult_q import schubmult
+

schubmult-1.3.0/schubmult/schubmult_q/__main__.py

@@ -0,0 +1,5 @@
+import sys
+from .schubmult_q import main
+
+if __name__ == "__main__":
+	sys.exit(main())

schubmult-1.3.0/schubmult/schubmult_q/schubmult_q.py

@@ -0,0 +1,105 @@
+from symengine import *
+from functools import cache
+from itertools import chain
+from schubmult.perm_lib import *
+import sys
+
+def schubmult(perm_dict,v):
+	vn1 = inverse(v)
+	th = [len(v)-i for i in range(1,len(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:
+				newperms = elem_sym_perms_q(up,mx_th,th[index])
+				for vp in vpathsums[up]:
+					sumval = vpathsums[up][vp]
+					if sumval == 0:
+						continue
+					for v2,vdiff,s in vpathdicts[index][vp]:
+						addsumval = s*sumval
+						for up2, udiff, mul_val in newperms:					
+							if vdiff + udiff == th[index]:								
+								if up2 not in newpathsums:
+									newpathsums[up2]={}
+								newpathsums[up2][v2] = newpathsums[up2].get(v2,0)+mul_val*addsumval
+			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 main():
+	try:			
+		perms=[]
+		curperm = []
+		
+		pr = True
+		ascode = False
+		try:
+			for s in sys.argv[1:]:
+				if s == "-np" or s == "--no-print":
+					pr = False
+					continue
+				if s == "-code":
+					ascode = True
+					continue
+				if s == "-":
+					perms += [curperm]
+					curperm = []
+					continue
+				curperm += [int(s)]
+		except Exception:
+			print("Usage: schubmult_q <-np|--no-print> <-code> perm1 - perm2 < - perm 3 ... >")
+			exit(1)
+		
+		perms += [curperm]
+		
+		
+		if ascode:
+			for i in range(len(perms)):
+				perms[i] = uncode(perms[i])
+		
+		coeff_dict = {tuple(permtrim([*perms[0]])): 1}
+		
+		for perm in perms[1:]:
+			coeff_dict = schubmult(coeff_dict,tuple(permtrim([*perm])))
+			
+		if pr:
+			if ascode:
+				width = max([len(str(trimcode(perm))) for perm in coeff_dict.keys()])
+			else:
+				width = max([len(str(perm)) for perm in coeff_dict.keys()])
+			
+			coeff_perms = list(coeff_dict.keys())
+			coeff_perms.sort(key=lambda x: (inv(x),*x))
+			
+			for perm in coeff_perms:
+				val = sympify(coeff_dict[perm]).expand()
+				if val != 0:
+					if ascode:					
+						print(f"{str(trimcode(perm)):>{width}}  {str(val).replace('**','^').replace('*',' ')}")
+					else:
+						print(f"{str(perm):>{width}}  {str(val).replace('**','^').replace('*',' ')}")
+	except BrokenPipeError:
+		pass
+			
+if __name__ == "__main__":
+	main()

{schubmult-1.2.11 → schubmult-1.3.0}/schubmult/schubmult_yz/schubmult_yz.py

@@ -736,16 +736,43 @@ def is_hook(cd):
 		return True
 	return False
 
-@cached(cache={}, key=lambda val, u2,v2,w2,var2=var2,var3=var3,msg=False,do_pos_neg=True: hashkey(u2,v2,w2,var2,var3,msg,do_pos_neg))
-def posify(val,u2,v2,w2,var2=var2,var3=var3,msg=False,do_pos_neg=True):
-	if inv(u2)+inv(v2) - inv(w2)<=1:
-		return expand(val)
+def div_diff(i,poly):
+	return sympify(sympy.div(sympy.sympify(poly - permy(poly,i)),sympy.sympify(var2[i]-var2[i+1]))[0])
+
+def skew_div_diff(u,w,poly):
+	d = -1
+	for i in range(len(w)-1):
+		if w[i]>w[i+1]:
+			d = i
+			break
+	d2 = -1
+	for i in range(len(u)-1):
+		if u[i]>u[i+1]:
+			d2 = i
+			break
+	if d == -1:
+		if d2 == -1:
+			return poly
+		return 0
+	w2 = [*w]
+	w2[d], w2[d+1] = w2[d+1], w2[d]
+	if d<len(u)-1 and u[d]>u[d+1]:		
+		u2 = [*u]		
+		u2[d], u2[d+1] = u2[d+1], u2[d]
+		return skew_div_diff(u2,w2,permy(poly,d+1))
+	else:
+		return skew_div_diff(u,w2,div_diff(d+1,poly))
+
+@cached(cache={}, key=lambda val, u2,v2,w2,var2=var2,var3=var3,msg=False,do_pos_neg=True,sign_only=False: hashkey(u2,v2,w2,var2,var3,msg,do_pos_neg,sign_only))
+def posify(val,u2,v2,w2,var2=var2,var3=var3,msg=False,do_pos_neg=True,sign_only=False):
+	if inv(u2)+inv(v2) - inv(w2) == 0:
+		return val
 	cdv = code(v2)	
 	if set(cdv) == set([0,1]) and do_pos_neg:	
 		return val
 	#if is_hook(cdv):
 	#	print(f"Could've {cdv}")
-	if expand(val) == 0:
+	if not sign_only and expand(val) == 0:
 		return 0
 	
 	u, v, w = try_reduce_v(u2, v2, w2)
@@ -767,6 +794,9 @@ def posify(val,u2,v2,w2,var2=var2,var3=var3,msg=False,do_pos_neg=True):
 	u = tuple(u)
 	v = tuple(v)	
 	w = tuple(w)
+	
+	if w != w2 and sign_only:
+		return 0
 			
 	if is_coeff_irreducible(u,v,w):
 		u3, v3, w3 = try_reduce_v(u, v, w)
@@ -777,8 +807,10 @@ def posify(val,u2,v2,w2,var2=var2,var3=var3,msg=False,do_pos_neg=True):
 			if not is_coeff_irreducible(u3,v3,w3):
 				u, v, w = u3, v3, w3
 	split_two_b, split_two = is_split_two(u,v,w)
-
+	
 	if len([i for i in code(v) if i !=0]) == 1:
+		if sign_only:
+			return 0
 		cv = code(v)
 		for i in range(len(cv)):
 			if cv[i]!=0:
@@ -792,8 +824,12 @@ def posify(val,u2,v2,w2,var2=var2,var3=var3,msg=False,do_pos_neg=True):
 		hvarset = [w2[i] for i in range(min(len(w2),k))]+[i+1 for i in range(len(w2),k)] + [w2[b] for b in range(k,len(u)) if u[b]!=w2[b]]+[w2[b] for b in range(len(u),len(w2))]
 		val = elem_sym_poly(p-r,k+p-1,[-var3[i] for i in range(1,n)],[-var2[i] for i in hvarset])	
 	elif (will_formula_work(v,u) or dominates(u,w)):
+		if sign_only:
+			return 0
 		val = dualcoeff(u,v,w,var2,var3)
 	elif inv(w) - inv(u) == 1:	
+		if sign_only:
+			return 0
 		a, b = -1, -1
 		for i in range(len(w)):
 			if a == -1 and u[i] != w[i]:
@@ -847,6 +883,8 @@ def posify(val,u2,v2,w2,var2=var2,var3=var3,msg=False,do_pos_neg=True):
 			toadd *= schubpoly(v3,[0,var2[w[a]],var2[w[b]]],var3)
 			val += toadd
 	elif split_two_b:
+		if sign_only:
+			return 0
 		cycles = split_two
 		a1, b1 = cycles[0]
 		a2, b2 = cycles[1]
@@ -1000,7 +1038,53 @@ def posify(val,u2,v2,w2,var2=var2,var3=var3,msg=False,do_pos_neg=True):
 				toadd*=tomul.subs(subs_dict3)
 			val += toadd
 	elif will_formula_work(u,v):
+		if sign_only:
+			return 0
 		val = forwardcoeff(u,v,w,var2,var3)
+	#elif inv(w) - inv(u) == 2:
+	#	indices = []
+	#	for i in range(len(w)):
+	#		if i>=len(u) or u[i]!=w[i]:
+	#			indices += [i+1]
+	#	arr = [[[],v]]
+	#	d = -1
+	#	for i in range(len(v)-1):
+	#		if v[i]>v[i+1]:
+	#			d = i + 1
+	#	for i in range(d):
+	#		arr2 = []
+	#					
+	#		if i+1 in indices:
+	#			continue
+	#		i2 = 1
+	#		i2 += len([aa for aa in indices if i+1>aa])
+	#		for vr, v2 in arr:
+	#			dpret = pull_out_var(i2,[*v2])
+	#			for v3r, v3 in dpret:
+	#				arr2 += [[vr + [(v3r,i+1)],v3]]
+	#		arr = arr2
+	#	val = 0
+	#	
+	#	for L in arr:
+	#		v3 = [*L[-1]]
+	#		tomul = 1
+	#		pooly = skew_div_diff(u,w,schubpoly(v3,[0,*[var2[a] for a in indices]],var3))
+	#		coeff = compute_positive_rep(pooly,var2,var3,msg,False)
+	#		if coeff == -1:
+	#			return -1
+	#		tomul = sympify(coeff)
+	#		toadd = 1
+	#		for i in range(len(L[0])):
+	#			var_index = L[0][i][1]
+	#			oaf = L[0][i][0]
+	#			if var_index-1>=len(w):
+	#				yv = var_index
+	#			else:
+	#				yv = w[var_index-1]
+	#			for j in range(len(oaf)):				
+	#				toadd*= var2[yv] - var3[oaf[j]]
+	#		toadd*=tomul#.subs(subs_dict3)
+	#		val += toadd		
 	else:
 		c01 = code(u)
 		c02 = code(w)
@@ -1010,6 +1094,8 @@ def posify(val,u2,v2,w2,var2=var2,var3=var3,msg=False,do_pos_neg=True):
 		c2 = code(inverse(w))
 		
 		if one_dominates(u,w):
+			if sign_only:
+				return 0
 			while c1[0] != c2[0]:				
 				w = [*w]
 				v = [*v]
@@ -1024,6 +1110,8 @@ def posify(val,u2,v2,w2,var2=var2,var3=var3,msg=False,do_pos_neg=True):
 				
 		
 		if is_reducible(v):
+			if sign_only:
+				return 0
 			newc = []
 			elemc = []
 			for i in range(len(c03)):
@@ -1041,6 +1129,8 @@ def posify(val,u2,v2,w2,var2=var2,var3=var3,msg=False,do_pos_neg=True):
 				newval = posify(newval,new_w,tuple(permtrim(uncode(newc))),w,var2,var3,msg,do_pos_neg)
 				val += tomul*shiftsubz(newval)
 		elif c01[0] == c02[0] and c01[0] != 0:
+			if sign_only:
+				return 0
 			varl = c01[0]
 			u3 = uncode([0] + c01[1:])
 			w3 = uncode([0] + c02[1:])
@@ -1050,6 +1140,8 @@ def posify(val,u2,v2,w2,var2=var2,var3=var3,msg=False,do_pos_neg=True):
 			for i in range(varl):
 				val = permy(val,i+1)			
 		elif c1[0] == c2[0]:
+			if sign_only:
+				return 0
 			vp = pull_out_var(c1[0]+1,[*v])
 			u3 = tuple(permtrim(phi1(u)))
 			w3 = tuple(permtrim(phi1(w)))
@@ -1064,10 +1156,74 @@ def posify(val,u2,v2,w2,var2=var2,var3=var3,msg=False,do_pos_neg=True):
 				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:
+			indices = []
+			for i in range(len(w)):
+				if i>=len(u) or u[i]!=w[i]:
+					indices += [i+1]
+			arr = [[[],v]]
+			d = -1
+			for i in range(len(v)-1):
+				if v[i]>v[i+1]:
+					d = i + 1
+			for i in range(d):
+				arr2 = []
+							
+				if i+1 in indices:
+					continue
+				i2 = 1
+				i2 += len([aa for aa in indices if i+1>aa])
+				for vr, v2 in arr:
+					dpret = pull_out_var(i2,[*v2])
+					for v3r, v3 in dpret:
+						arr2 += [[vr + [(v3r,i+1)],v3]]
+				arr = arr2
+			val = 0
+			
+			for L in arr:
+				v3 = [*L[-1]]
+				tomul = 1						
+				toadd = 1
+				for i in range(len(L[0])):
+					var_index = L[0][i][1]
+					oaf = L[0][i][0]
+					if var_index-1>=len(w):
+						yv = var_index
+					else:
+						yv = w[var_index-1]
+					for j in range(len(oaf)):				
+						toadd*= var2[yv] - var3[oaf[j]]
+				pooly = skew_div_diff(u,w,schubpoly(v3,[0,*[var2[a] for a in indices]],var3))
+				if toadd == 0:
+					continue
+				if pooly !=0:
+					coeff = compute_positive_rep(pooly,var2,var3,msg,False)
+				else:
+					coeff = 0
+				if coeff == -1:
+					return -1
+				tomul = sympify(coeff)
+				toadd*=tomul#.subs(subs_dict3)
+				val += toadd						
 		else:
-			val2 = compute_positive_rep(val,var2,var3,msg,do_pos_neg)
-			if val2 is not None:
-				val = val2
+			if not sign_only:
+				if inv(u)+inv(v)-inv(w)==1:
+					val2 = compute_positive_rep(val,var2,var3,msg,False)
+				else:
+					val2 = compute_positive_rep(val,var2,var3,msg,do_pos_neg)					
+				if val2 is not None:				
+					val = val2							
+			else:
+				#st = str(expand(val))
+				#if st.find("-")!=-1:
+				#	return -1
+				#else:
+				#	return val
+				d = expand(val).as_coefficients_dict()
+				for v in d.values():
+					if v<0:
+						return -1
+				return 1
 	return val
 
 def split_perms(perms):

{schubmult-1.2.11 → schubmult-1.3.0}/schubmult.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: schubmult
-Version: 1.2.11
+Version: 1.3.0
 Summary: Computing Littlewood-Richardson coefficients of Schubert polynomials
 Home-page: https://github.com/matthematics/schubmult
 Author: Matt Samuel
@@ -15,12 +15,13 @@ 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. 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 Littlewood-Richardson coefficients of (ordinary or double) Schubert polynomials. Since version 1.3.0, it also handles quantum Schubert polynomials. 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  
 schubmult_double 1 3 4 6 2 5 - 2 1 5 7 3 4 6  
 schubmult_yz 1 3 4 6 2 5 - 2 1 5 7 3 4 6
+schubmult_q 5 1 4 3 2 - 2 1 3 5 4
 ```
 
 The same execution with the Lehmer code:
@@ -29,6 +30,7 @@ The same execution with the Lehmer code:
 schubmult_py -code 0 0 1 5 6 2 3 4 - 5 6 0 0 0 0 1 2 3 4
 schubmult_double -code 0 1 1 2 - 1 0 2 3
 schubmult_yz -code 0 1 1 2 - 1 0 2 3
+schubmult_q -code 4 0 2 1 - 1 0 0 1
 ```
 
 For coproducts:
@@ -50,7 +52,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. Both have the same command line syntax as schubmult. schubmult_double displays the result with nonnegative coefficients in terms of the negative simple roots. Both are of course slower than schubmult_py, and expressing the result positively for schubmult_double slows it down even more.
 
-New in version 1.1.0, schubmult_py -coprod allows you to split Schubert polynomials along certain indices. 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).
+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).
 
 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.
 

{schubmult-1.2.11 → schubmult-1.3.0}/schubmult.egg-info/SOURCES.txt

@@ -16,6 +16,9 @@ schubmult/schubmult_double/schubmult_double.py
 schubmult/schubmult_py/__init__.py
 schubmult/schubmult_py/__main__.py
 schubmult/schubmult_py/schubmult_py.py
+schubmult/schubmult_q/__init__.py
+schubmult/schubmult_q/__main__.py
+schubmult/schubmult_q/schubmult_q.py
 schubmult/schubmult_yz/__init__.py
 schubmult/schubmult_yz/__main__.py
 schubmult/schubmult_yz/schubmult_yz.py

{schubmult-1.2.11 → schubmult-1.3.0}/schubmult.egg-info/entry_points.txt

@@ -1,5 +1,6 @@
 [console_scripts]
 schubmult_double = schubmult.schubmult_double.__main__:main
 schubmult_py = schubmult.schubmult_py.__main__:main
+schubmult_q = schubmult.schubmult_q.__main__:main
 schubmult_yz = schubmult.schubmult_yz.__main__:main
 

{schubmult-1.2.11 → schubmult-1.3.0}/setup.py

@@ -6,7 +6,7 @@ long_description = (this_directory / "README.md").read_text()
 
 setup(
     name="schubmult",
-    version="1.2.11",
+    version="1.3.0",
     description="Computing Littlewood-Richardson coefficients of Schubert polynomials",
 	long_description=long_description,
 	long_description_content_type='text/markdown',
@@ -30,6 +30,7 @@ setup(
     ],
     entry_points={"console_scripts": ["schubmult_py=schubmult.schubmult_py.__main__:main",
 	"schubmult_double=schubmult.schubmult_double.__main__:main",
-	"schubmult_yz=schubmult.schubmult_yz.__main__:main"
+	"schubmult_yz=schubmult.schubmult_yz.__main__:main",
+	"schubmult_q=schubmult.schubmult_q.__main__:main"
 	]},
 )