schubmult 1.3.2__tar.gz → 1.3.4__tar.gz

{schubmult-1.3.2 → schubmult-1.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: schubmult
-Version: 1.3.2
+Version: 1.3.4
 Summary: Computing Littlewood-Richardson coefficients of Schubert polynomials
 Home-page: https://github.com/matthematics/schubmult
 Author: Matt Samuel
@@ -15,13 +15,15 @@ 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.0, it also handles quantum 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.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:
 
 ```
 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
+schubmult_yz 1 3 4 6 2 5 - 2 1 5 7 3 4 6 --display-positive
+schubmult_q 5 1 4 3 2 - 5 1 3 4 2
+schubmult_q_double 5 1 4 3 2 - 5 1 3 4 2
+schubmult_q_yz 5 1 4 3 2 - 2 5 1 3 4 --display-positive
 ```
 
 The same execution with the Lehmer code:
@@ -29,28 +31,30 @@ 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
+schubmult_yz -code 0 1 1 2 - 1 0 2 3 --display-positive
+schubmult_q -code 4 0 2 1 - 4 0 1 1
+schubmult_q_double -code 4 0 2 1 - 4 0 1 1
+schubmult_q_yz -code 4 0 2 1 - 1 3 --display-positive
 ```
 
 For coproducts:
 ```
 schubmult_py -coprod 1 3 5 7 2 4 6 - 2 4
 schubmult_double -coprod 1 3 5 7 2 4 6 - 2 4
-schubmult_yz -coprod 1 3 5 7 2 4 6 - 2 4
+schubmult_yz -coprod 1 3 5 7 2 4 6 - 2 4 --display-positive
 ```
 or
 ```
 schubmult_py -code -coprod 0 1 2 3 - 2 4
 schubmult_double -code -coprod 0 1 2 3 - 2 4
-schubmult_yz -code -coprod 0 1 2 3 - 2 4
+schubmult_yz -code -coprod 0 1 2 3 - 2 4 --display-positive
 ```
 
 
 
-Runtime will vary tremendously by case. The general problem is #P-hard. Though the result is always nonnegative and the problem is in GapP, it is not known to be in #P at this time.
+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_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.
+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).
 
@@ -69,9 +73,7 @@ from schubmult.schubmult_py import schubmult
 coeff_dict = schubmult({(1,3,4,6,2,5): 1},(2,1,5,7,3,4,6))
 ```
 
-Note versions 1.0.15 and prior had a bug that failed to upgrade the executable. The coefficients it computed were correct, but it was not using the updated version.
-
-Version 1.0.18 adds the command line argument --display-positive to schubmult_yz, which displays the result positively (if possible, this is still only always possible conjecturally). This is highly processor intensive.
+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.
 
 ![](https://raw.githubusercontent.com/matthematics/schubmult/main/positive_image.png)
 

{schubmult-1.3.2 → schubmult-1.3.4}/README.md

@@ -2,13 +2,15 @@
 
 ## 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.0, it also handles quantum 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.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:
 
 ```
 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
+schubmult_yz 1 3 4 6 2 5 - 2 1 5 7 3 4 6 --display-positive
+schubmult_q 5 1 4 3 2 - 5 1 3 4 2
+schubmult_q_double 5 1 4 3 2 - 5 1 3 4 2
+schubmult_q_yz 5 1 4 3 2 - 2 5 1 3 4 --display-positive
 ```
 
 The same execution with the Lehmer code:
@@ -16,28 +18,30 @@ 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
+schubmult_yz -code 0 1 1 2 - 1 0 2 3 --display-positive
+schubmult_q -code 4 0 2 1 - 4 0 1 1
+schubmult_q_double -code 4 0 2 1 - 4 0 1 1
+schubmult_q_yz -code 4 0 2 1 - 1 3 --display-positive
 ```
 
 For coproducts:
 ```
 schubmult_py -coprod 1 3 5 7 2 4 6 - 2 4
 schubmult_double -coprod 1 3 5 7 2 4 6 - 2 4
-schubmult_yz -coprod 1 3 5 7 2 4 6 - 2 4
+schubmult_yz -coprod 1 3 5 7 2 4 6 - 2 4 --display-positive
 ```
 or
 ```
 schubmult_py -code -coprod 0 1 2 3 - 2 4
 schubmult_double -code -coprod 0 1 2 3 - 2 4
-schubmult_yz -code -coprod 0 1 2 3 - 2 4
+schubmult_yz -code -coprod 0 1 2 3 - 2 4 --display-positive
 ```
 
 
 
-Runtime will vary tremendously by case. The general problem is #P-hard. Though the result is always nonnegative and the problem is in GapP, it is not known to be in #P at this time.
+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_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.
+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).
 
@@ -56,9 +60,7 @@ from schubmult.schubmult_py import schubmult
 coeff_dict = schubmult({(1,3,4,6,2,5): 1},(2,1,5,7,3,4,6))
 ```
 
-Note versions 1.0.15 and prior had a bug that failed to upgrade the executable. The coefficients it computed were correct, but it was not using the updated version.
-
-Version 1.0.18 adds the command line argument --display-positive to schubmult_yz, which displays the result positively (if possible, this is still only always possible conjecturally). This is highly processor intensive.
+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.
 
 ![](https://raw.githubusercontent.com/matthematics/schubmult/main/positive_image.png)
 

{schubmult-1.3.2 → schubmult-1.3.4}/schubmult/perm_lib.py

@@ -313,6 +313,28 @@ def elem_sym_func(k,i,u1,u2,v1,v2,udiff,vdiff,varl1,varl2):
 	zvars = [varl2[i] for i in call_zvars(v1,v2,k,i)]
 	return elem_sym_poly(newk-vdiff,newk,yvars,zvars)
 
+def elem_sym_func_q(k,i,u1,u2,v1,v2,udiff,vdiff,varl1,varl2):
+	global zero, one
+	newk = k - udiff
+	if newk < vdiff:
+		return zero
+	if newk == vdiff:
+		return one
+	yvars = []
+	mlen = max(len(u1),len(u2))
+	u1 = [*u1] + [a+1 for a in range(len(u1),mlen)]
+	u2 = [*u2] + [a+1 for a in range(len(u2),mlen)]
+	for j in range(min(len(u1),k)):
+		if u1[j]==u2[j]:
+			yvars += [varl1[u2[j]]]
+	for j in range(len(u1),min(k,len(u2))):
+		if u2[j]==j+1:
+			yvars += [varl1[u2[j]]]
+	for j in range(len(u2),k):
+		yvars += [varl1[j+1]]
+	zvars = [varl2[a] for a in call_zvars(v1,v2,k,i)]
+	return elem_sym_poly(newk-vdiff,newk,yvars,zvars)
+
 def trimcode(perm):
 	cd = code(perm)
 	while len(cd)>0 and cd[-1] == 0:

{schubmult-1.3.2 → schubmult-1.3.4}/schubmult/schubmult_double/schubmult_double.py

@@ -12,6 +12,8 @@ var2 = symarray('y',n)
 var3 = var2
 var_r = symarray('r',n)
 
+var_q = Symbol("q")
+
 subs_dict = {}
 
 for i in range(1,n):
@@ -20,6 +22,8 @@ for i in range(1,n):
 		sm += var_r[j]
 	subs_dict[var2[i]] = sm
 
+
+
 def main():
 	try:			
 		perms=[]
@@ -45,12 +49,15 @@ def main():
 					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("Alternative usage: schubmult_double <-code> -coprod perm - indexlist")
 			exit(1)
 		
 		perms += [curperm]
 		
+		
 		if coprod:
 			subs_dict_coprod = {}
 			if ascode:

{schubmult-1.3.2 → schubmult-1.3.4}/schubmult/schubmult_py/schubmult_py.py

@@ -76,6 +76,8 @@ def main():
 					continue
 				curperm += [int(s)]
 		except Exception:
+			print("**** schubmult_py ****")
+			print("Purpose: Compute products (and coproducts) of ordinary Schubert polynomials")
 			print("Usage: schubmult_py <-np|--no-print> <-code> perm1 - perm2 <- perm3...>")
 			print("Alternative usage: schubmult_py -coprod <-np> <perm> - <index list>")
 			exit(1)

schubmult-1.3.4/schubmult/schubmult_q/schubmult_q.py

@@ -0,0 +1,318 @@
+from symengine import *
+from functools import cache
+from itertools import chain
+from schubmult.perm_lib import *
+import schubmult.schubmult_yz as yz
+import sys
+
+var = symarray('x', n)
+var2 = symarray('y',n)
+var3 = var2
+var_r = symarray('r',n)
+
+var_q = Symbol("q")
+
+subs_dict = {}
+
+for i in range(1,n):
+	sm = var_r[0]
+	for j in range(1,i):
+		sm += var_r[j]
+	subs_dict[var2[i]] = sm
+
+def schubmult(perm_dict,v):
+	vn1 = inverse(v)
+	th = [len(v)-i for i in range(1,len(v)+1)]	
+	mu = permtrim(uncode(th))
+	vmu = permtrim(mulperm([*v],mu))
+	#print(f"{th=} {mu=} {vmu=}")
+	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 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
+
+var_q = Symbol("q")
+
+def grass_q_replace(perm,k,d,n):
+	if k-d<0:
+		return None
+	#print("Here")
+	ret = []
+	cd = code(perm)
+	for i in range(k-d,k):
+		if i>=len(cd) or cd[i]<d:
+			return None
+	grass_rep = [0 for i in range(n)]
+	perm2 = [*perm] + [i+1 for i in range(len(perm),n)]
+	for i in range(k,n):
+		grass_rep[perm2[i]-1] = 2
+	num_0 = 0
+	#print(f"{grass_rep=} {d=}")
+	for i in range(len(grass_rep)-1,-1,-1):
+		if num_0 == d:
+			break
+		if grass_rep[i] == 0:
+			grass_rep[i] = 1
+			num_0 += 1
+	num_2 = 0
+	for i in range(len(grass_rep)):
+		if num_2 == d:
+			break
+		if grass_rep[i] == 2:
+			grass_rep[i] = 1
+			num_2 += 1
+	#print(f"New {grass_rep=}")
+	k1 = k - d
+	k2 = k + d
+	pos_1 = 0
+	pos_2 = 0
+	pos_3 = 0
+	new_perm = [0 for i in range(n)]
+	for i in range(len(grass_rep)):
+		if grass_rep[i] == 0:
+			new_perm[pos_1] = i+1
+			pos_1 += 1
+		if grass_rep[i] == 1:
+			new_perm[k1+pos_2] = i+1
+			pos_2 += 1
+		if grass_rep[i] == 2:
+			new_perm[k2+pos_3] = i+1
+			pos_3 += 1
+	return tuple(permtrim(new_perm))
+
+def to_two_step(perm,k1,k2,n):
+	rep = [0 for i in range(n)]
+	perm2 = [*perm] + [i+1 for i in range(len(perm),n)]	
+	for i in range(n):
+		if i<k1:
+			rep[perm2[i]-1] = 0
+		elif i<k2:
+			rep[perm2[i]-1] = 1
+		else:
+			rep[perm2[i]-1] = 2
+	return rep
+
+def main():
+	try:			
+		perms=[]
+		curperm = []
+		
+		pr = True
+		ascode = False
+		grass = False
+		grass_q_n = 0
+		equiv = 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 == "-grass":
+					grass = None
+					continue
+				if s == "-equiv":
+					equiv = True
+					continue
+				if grass is None:
+					grass = True
+					grass_q_n = int(s)
+					continue
+				if s == "-":
+					perms += [curperm]
+					curperm = []
+					continue
+				curperm += [int(s)]
+		except Exception:
+			print("**** schubmult_q ****")
+			print("Purpose: Compute the structure constants of quantum Schubert polynomials")
+			print("Usage: schubmult_q <-np|--no-print> <-code> <-grass n> <-equiv> perm1 - perm2 < - perm 3 ... >")
+			print("For the -grass option, must use Grassmannian permutations. -equiv only works together with -grass.")
+			exit(1)
+		
+		perms += [curperm]
+		
+		
+		if grass:
+			perms_t = []
+			if ascode:
+				perms_t = [tuple(permtrim(uncode(perms[i]))) for i in range(len(perms))]
+			else:
+				perms_t = [tuple(permtrim(perms[i])) for i in range(len(perms))]
+			
+			k = -1
+			
+			for perm in perms_t:
+				desc = -1
+				for i in range(len(perm)-1):
+					if desc != -1 and perm[i]>perm[i+1]:
+						print("Error: permutations must have one descent")
+						exit(1)
+					elif desc == -1:
+						if perm[i]>perm[i+1]:
+							if k != -1 and k != i+1:
+								print("Error: permutations must all have the same descent")
+								exit(1)
+							k = i+1
+							desc = i+1
+			#perms1 = [perms_t[0]]
+			#perms2 = [perms_t[1]]
+			perms1 = []
+			perms2 = []
+			for d in range(100,-1,-1):
+				#print(f"{k=} {d=}")
+				grass_rep_1 = grass_q_replace(perms_t[0],k,d,grass_q_n)
+				grass_rep_2 = grass_q_replace(perms_t[1],k,d,grass_q_n)
+				#print(f"{grass_rep_1} {grass_rep_2}")
+				if grass_rep_1 is None or grass_rep_2 is None:
+					continue
+				perms1 += [grass_rep_1]
+				perms2 += [grass_rep_2]
+			for i in range(len(perms1)):
+				d = len(perms1) - i - 1
+				#print(f"{d=} {perms1[i]=} {perms2[i]=}")
+				if equiv:
+					coeff_dict = yz.schubmult({perms1[i]: 1},perms2[i],var2,var2)
+				else:
+					coeff_dict = yz.schubmult({perms1[i]: 1},perms2[i],[0 for i in range(100)],[0 for i in range(100)])
+				
+				#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()])
+				k1 = k - d
+				k2 = k + d
+				coeff_perms = list([key for key in coeff_dict.keys() if len(key)<=grass_q_n])
+				
+				coeff_perms.sort(key=lambda x: (inv(x),*x))
+				
+				coeff_perms2 = []
+				
+				for perm in coeff_perms:
+					two_step = to_two_step(perm,k1,k2,grass_q_n)					
+					num_1 = len([i for i in range(len(two_step)) if two_step[i] == 1])
+					if num_1 != 2*d:
+						coeff_perms2 += [None]
+						continue
+					one_step = [*two_step]
+					one_step.reverse()
+					two_step_r = [*two_step]
+					two_step_r.reverse()
+					for i in range(len(one_step)-1,-1,-1):
+						if one_step[i] == 0:
+							break
+						if one_step[i] == 1:
+							one_step[i] = 0
+					no_good = False
+					for i in range(len(one_step)):
+						if one_step[i] == 1:
+							one_step[i] = 2
+						elif one_step[i] == 2:
+							if len([j for j in range(len(one_step)) if one_step[j]==1]) != 0:
+								no_good = True
+								break
+					num_0 = len([i for i in range(len(one_step)) if one_step[i] == 0])
+					if num_0 != k or no_good:
+						#print(f"No good {one_step=} {two_step_r=} {no_good=}")
+						coeff_perms2 += [None]
+						continue
+					pos_0 = 0
+					pos_1 = 0
+					one_step.reverse()
+					#print(f"{two_step=}")
+					#print(f"{one_step=}")
+					grass_perm = [0 for i in range(len(one_step))]
+					for i in range(len(one_step)):
+						if one_step[i] == 0:
+							grass_perm[pos_0] = i+1
+							pos_0 += 1
+						else:
+							grass_perm[k+pos_1] = i+1
+							pos_1 += 1
+					coeff_perms2 += [tuple(permtrim(grass_perm))]
+				
+				try:
+					if ascode:
+						width = max([len(str(trimcode(perm))) for perm in coeff_perms2 if perm is not None])
+					else:
+						width = max([len(str(perm)) for perm in coeff_perms2 if perm is not None])
+				except ValueError:
+					continue
+				
+				for i in range(len(coeff_perms)):
+					if coeff_perms2[i] is None:
+						continue
+					perm = coeff_perms[i]
+					val = (var_q**d) * sympify(coeff_dict[perm]).subs(subs_dict).expand()
+					
+					if val != 0:
+						if ascode:					
+							print(f"{str(trimcode(coeff_perms2[i])):>{width}}  {str(val).replace('**','^').replace('*',' ')}")
+						else:
+							print(f"{str(coeff_perms2[i]):>{width}}  {str(val).replace('**','^').replace('*',' ')}")
+						#print(f"{str(two_step):>{width}}  {str(val).replace('**','^').replace('*',' ')}")
+						#else:
+						#	print(f"{str(perm):>{width}}  {str(val).replace('**','^').replace('*',' ')}")
+		else:		
+			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() 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))
+				
+				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.3.4/schubmult/schubmult_q_double/__init__.py

@@ -0,0 +1 @@
+from .schubmult_q_double import *

schubmult-1.3.4/schubmult/schubmult_q_double/__main__.py

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

schubmult-1.3.4/schubmult/schubmult_q_double/schubmult_q_double.py

@@ -0,0 +1,119 @@
+from schubmult.perm_lib import *
+from schubmult.schubmult_q_yz import schubmult
+from symengine import *
+import sys
+
+
+q_var = symarray("q",100)
+
+var2 = symarray("y",100)
+var3 = symarray("z",100)
+
+var3 = var2
+var_r = symarray('r',100)
+
+subs_dict = {}
+
+for i in range(1,100):
+	sm = var_r[0]
+	for j in range(1,i):
+		sm += var_r[j]
+	subs_dict[var2[i]] = sm
+	
+	
+
+def main():
+	global var2
+	try:
+		sys.setrecursionlimit(1000000)
+	
+		perms=[]
+		curperm = []
+		
+		pr = True
+		display_positive = False
+		ascode = False
+		coprod = False
+		check = True
+		msg = False
+		try:
+			for s in sys.argv[1:]:
+				if s == "-np" or s == "--no-print":
+					pr = False
+					continue
+				if s == "-nocheck":
+					check = False
+					continue
+				if s == "--display-positive":
+					display_positive = True
+					continue
+				if s == "--optimizer-message":
+					msg = 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_double ****")
+					print("Purpose: Compute equivariant Gromov-Witten invariants, structure constants of quantum double Schubert polynomials")
+					print("Usage: schubmult_q_double <-np|--no-print> <-code> <--display-positive> <--optimizer-message> perm1 - perm2 < - perm3 .. >")
+					#print("Alternative usage: schubmult_yz <-code> <--display-positive> -coprod perm - indexlist")
+					exit(0)
+				if s == "-":
+					perms += [curperm]
+					curperm = []
+					continue
+				curperm += [int(s)]
+		except Exception:
+			print("**** schubmult_q_double ****")
+			print("Purpose: Compute equivariant Gromov-Witten invariants, structure constants of quantum double Schubert polynomials")
+			print("Usage: schubmult_q_double <-np|--no-print> <-code> <--display-positive> <--optimizer-message> perm1 - perm2 < - perm3 .. >")
+			exit(1)
+				
+		perms += [curperm]
+		
+		
+		if ascode:
+			for i in range(len(perms)):
+				perms[i] = tuple(permtrim(uncode(perms[i])))
+		else:
+			for i in range(len(perms)):
+				perms[i] = tuple(permtrim([*perms[i]]))
+		
+		size = 0
+		L = len(perms)
+		
+		coeff_dict = {perms[0]: 1}
+		for perm in perms[1:]:
+			coeff_dict = schubmult(coeff_dict,perm,var2,var2)
+		
+		if pr:
+			if ascode:
+				width = max([len(str(trimcode(perm))) for perm in coeff_dict.keys() if expand(sympify(coeff_dict[perm]).subs(subs_dict))!=0])
+			else:
+				width = max([len(str(perm)) for perm in coeff_dict.keys() if expand(sympify(coeff_dict[perm]).subs(subs_dict))!=0])
+			
+			coeff_perms = list(coeff_dict.keys())
+			coeff_perms.sort(key=lambda x: (inv(x),*x))
+			
+			for perm in coeff_perms:
+				val = expand(sympify(coeff_dict[perm]).subs(subs_dict)).simplify()
+				if val != 0:
+					notint = False
+					try:
+						int(val)
+					except Exception:
+						notint = True
+					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.3.4/schubmult/schubmult_q_yz/__init__.py

@@ -0,0 +1 @@
+from .schubmult_q_yz import *

schubmult-1.3.4/schubmult/schubmult_q_yz/__main__.py

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

schubmult-1.3.4/schubmult/schubmult_q_yz/schubmult_q_yz.py

@@ -0,0 +1,206 @@
+from schubmult.perm_lib import *
+from schubmult.schubmult_yz import compute_positive_rep
+from symengine import *
+import sys
+
+
+#q_var = symarray("q",100)
+
+var2 = symarray("y",100)
+var3 = symarray("z",100)
+
+	
+
+	
+
+	
+def schubmult(perm_dict,v,var2=var2,var3=var3):
+	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:
+				inv_up = inv(up)
+				newperms = elem_sym_perms_q(up,mx_th,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]:
+							#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,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 factor_out_q(poly):
+	coeff_dict = expand(poly).as_coefficients_dict()
+	ret = {}
+	q_var2 = q_var.tolist()
+	for key in coeff_dict:
+		coeff = coeff_dict[key]
+		if coeff == 0:
+			continue
+		q_part = 1
+		yz_part = coeff
+		if isinstance(key,Mul):
+			for var_maybe_pow in key.args:
+				if isinstance(var_maybe_pow,Pow):
+					real_var = var_maybe_pow.args[0]
+					if real_var in q_var2:
+						q_part*=var_maybe_pow
+					else:
+						yz_part*=var_maybe_pow
+				else:
+					real_var = var_maybe_pow
+					if real_var in q_var2:
+						q_part*=var_maybe_pow
+					else:
+						yz_part*=var_maybe_pow
+		elif isinstance(key,Pow):
+			real_var = key.args[0]
+			if real_var in q_var2:
+				q_part*=key
+			else:
+				yz_part*=key
+		else:
+			if key in q_var2:
+				q_part *= key
+			else:
+				yz_part*=key
+			
+		ret[q_part] = ret.get(q_part,0) + yz_part
+	return ret
+def main():
+	global var2
+	try:
+		sys.setrecursionlimit(1000000)
+	
+		perms=[]
+		curperm = []
+		
+		pr = True
+		display_positive = False
+		ascode = False
+		coprod = False
+		check = True
+		msg = False
+		try:
+			for s in sys.argv[1:]:
+				if s == "-np" or s == "--no-print":
+					pr = False
+					continue
+				if s == "-nocheck":
+					check = False
+					continue
+				if s == "--display-positive":
+					display_positive = True
+					continue
+				if s == "--optimizer-message":
+					msg = 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 == "-":
+					perms += [curperm]
+					curperm = []
+					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 .. >")
+			exit(1)
+				
+		perms += [curperm]
+		
+		
+		if ascode:
+			for i in range(len(perms)):
+				perms[i] = tuple(permtrim(uncode(perms[i])))
+		else:
+			for i in range(len(perms)):
+				perms[i] = tuple(permtrim([*perms[i]]))
+		
+		size = 0
+		L = len(perms)
+		
+		coeff_dict = {perms[0]: 1}
+		for perm in perms[1:]:
+			coeff_dict = schubmult(coeff_dict,perm)
+		
+		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])
+			
+			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]).simplify()
+				if val != 0:
+					notint = False
+					try:
+						int(val)
+					except Exception:
+						notint = True
+						val2 = 0
+						if display_positive:
+							q_dict = factor_out_q(val)
+							for q_part in q_dict:
+								#print(f"{q_part=} {q_dict[q_part]=}")
+								try:
+									val2 += q_part*int(q_dict[q_part])
+								except Exception:
+									try:
+										val2 += q_part*compute_positive_rep(q_dict[q_part],var2,var3,msg,False)
+									except TypeError:
+										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 - val2)!=0:
+								print(f"error; write to schubmult@gmail.com with the case {perms=} {perm=} {val=} {check_coeff_dict.get(perm,0)=}")
+								exit(1)
+							val = val2
+					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.3.2 → schubmult-1.3.4}/schubmult/schubmult_yz/schubmult_yz.py

@@ -1327,6 +1327,8 @@ def main():
 					continue
 				curperm += [int(s)]
 		except Exception:
+			print("**** schubmult_yz ****")
+			print("Purpose: Compute products (and coproducts) of double Schubert polynomials in different sets of variables")
 			print("Usage: schubmult_yz <-np|--no-print> <-code> <--display-positive> <--optimizer-message> perm1 - perm2 < - perm3 .. >")
 			print("Alternative usage: schubmult_yz <-code> <--display-positive> <--optimizer-message> -coprod perm - indexlist")
 			exit(1)
@@ -1510,10 +1512,14 @@ def main():
 							notint = True
 						if notint and display_positive:
 							valu = val
-							if len(perms) == 2 and not posified:
-								val = posify(val,perms[0],perms[1],perm,var2,var3,msg)							
-							elif not posified:								
-								val = compute_positive_rep(val,var2,var3,msg)								
+							try:
+								if len(perms) == 2 and not posified:
+									val = posify(val,perms[0],perms[1],perm,var2,var3,msg)							
+								elif not posified:								
+									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)
 							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.2 → schubmult-1.3.4}/schubmult.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: schubmult
-Version: 1.3.2
+Version: 1.3.4
 Summary: Computing Littlewood-Richardson coefficients of Schubert polynomials
 Home-page: https://github.com/matthematics/schubmult
 Author: Matt Samuel
@@ -15,13 +15,15 @@ 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.0, it also handles quantum 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.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:
 
 ```
 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
+schubmult_yz 1 3 4 6 2 5 - 2 1 5 7 3 4 6 --display-positive
+schubmult_q 5 1 4 3 2 - 5 1 3 4 2
+schubmult_q_double 5 1 4 3 2 - 5 1 3 4 2
+schubmult_q_yz 5 1 4 3 2 - 2 5 1 3 4 --display-positive
 ```
 
 The same execution with the Lehmer code:
@@ -29,28 +31,30 @@ 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
+schubmult_yz -code 0 1 1 2 - 1 0 2 3 --display-positive
+schubmult_q -code 4 0 2 1 - 4 0 1 1
+schubmult_q_double -code 4 0 2 1 - 4 0 1 1
+schubmult_q_yz -code 4 0 2 1 - 1 3 --display-positive
 ```
 
 For coproducts:
 ```
 schubmult_py -coprod 1 3 5 7 2 4 6 - 2 4
 schubmult_double -coprod 1 3 5 7 2 4 6 - 2 4
-schubmult_yz -coprod 1 3 5 7 2 4 6 - 2 4
+schubmult_yz -coprod 1 3 5 7 2 4 6 - 2 4 --display-positive
 ```
 or
 ```
 schubmult_py -code -coprod 0 1 2 3 - 2 4
 schubmult_double -code -coprod 0 1 2 3 - 2 4
-schubmult_yz -code -coprod 0 1 2 3 - 2 4
+schubmult_yz -code -coprod 0 1 2 3 - 2 4 --display-positive
 ```
 
 
 
-Runtime will vary tremendously by case. The general problem is #P-hard. Though the result is always nonnegative and the problem is in GapP, it is not known to be in #P at this time.
+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_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.
+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).
 
@@ -69,9 +73,7 @@ from schubmult.schubmult_py import schubmult
 coeff_dict = schubmult({(1,3,4,6,2,5): 1},(2,1,5,7,3,4,6))
 ```
 
-Note versions 1.0.15 and prior had a bug that failed to upgrade the executable. The coefficients it computed were correct, but it was not using the updated version.
-
-Version 1.0.18 adds the command line argument --display-positive to schubmult_yz, which displays the result positively (if possible, this is still only always possible conjecturally). This is highly processor intensive.
+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.
 
 ![](https://raw.githubusercontent.com/matthematics/schubmult/main/positive_image.png)
 

{schubmult-1.3.2 → schubmult-1.3.4}/schubmult.egg-info/SOURCES.txt

@@ -19,6 +19,12 @@ schubmult/schubmult_py/schubmult_py.py
 schubmult/schubmult_q/__init__.py
 schubmult/schubmult_q/__main__.py
 schubmult/schubmult_q/schubmult_q.py
+schubmult/schubmult_q_double/__init__.py
+schubmult/schubmult_q_double/__main__.py
+schubmult/schubmult_q_double/schubmult_q_double.py
+schubmult/schubmult_q_yz/__init__.py
+schubmult/schubmult_q_yz/__main__.py
+schubmult/schubmult_q_yz/schubmult_q_yz.py
 schubmult/schubmult_yz/__init__.py
 schubmult/schubmult_yz/__main__.py
 schubmult/schubmult_yz/schubmult_yz.py

{schubmult-1.3.2 → schubmult-1.3.4}/schubmult.egg-info/entry_points.txt

@@ -2,5 +2,7 @@
 schubmult_double = schubmult.schubmult_double.__main__:main
 schubmult_py = schubmult.schubmult_py.__main__:main
 schubmult_q = schubmult.schubmult_q.__main__:main
+schubmult_q_double = schubmult.schubmult_q_double.__main__:main
+schubmult_q_yz = schubmult.schubmult_q_yz.__main__:main
 schubmult_yz = schubmult.schubmult_yz.__main__:main
 

{schubmult-1.3.2 → schubmult-1.3.4}/setup.py

@@ -6,7 +6,7 @@ long_description = (this_directory / "README.md").read_text()
 
 setup(
     name="schubmult",
-    version="1.3.2",
+    version="1.3.4",
     description="Computing Littlewood-Richardson coefficients of Schubert polynomials",
 	long_description=long_description,
 	long_description_content_type='text/markdown',
@@ -31,6 +31,8 @@ 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_q=schubmult.schubmult_q.__main__:main"
+	"schubmult_q=schubmult.schubmult_q.__main__:main",
+	"schubmult_q_double=schubmult.schubmult_q_double.__main__:main",
+	"schubmult_q_yz=schubmult.schubmult_q_yz.__main__:main"
 	]},
 )

schubmult-1.3.2/schubmult/schubmult_q/schubmult_q.py

@@ -1,105 +0,0 @@
-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)+1)]	
-	mu = permtrim(uncode(th))
-	vmu = permtrim(mulperm([*v],mu))
-	#print(f"{th=} {mu=} {vmu=}")
-	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 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 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()