schubmult 2.0.3__tar.gz → 2.0.4__tar.gz

schubmult-2.0.4/PKG-INFO

@@ -0,0 +1,542 @@
+Metadata-Version: 2.4
+Name: schubmult
+Version: 2.0.4
+Summary: Package for algebraic computation with single, double, and quantum Schubert polynomials
+Author-email: Matt Samuel <schubmult@gmail.com>
+Maintainer-email: Matt Samuel <schubmult@gmail.com>
+Project-URL: Homepage, http://schubmult.org
+Project-URL: Repository, https://github.com/matthematics/schubmult
+Keywords: Schubert,polynomial,double,algebra
+Classifier: Programming Language :: Python
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: PuLP>=2.7.0
+Requires-Dist: symengine>=0.14.0
+Requires-Dist: sympy>=1.12
+Requires-Dist: psutil
+Requires-Dist: cachetools
+Requires-Dist: sortedcontainers
+Requires-Dist: setuptools
+Provides-Extra: sage
+Requires-Dist: sagemath-standard; extra == "sage"
+Dynamic: license-file
+
+# schubmult
+
+## Program and package for rapid computation of Littlewood-Richardson coefficients of Schubert 
+polynomials, with optional Sage integration
+
+The main purpose of this python package is for executing scripts to compute coefficients of products of 
+various types of Schubert polynomials. Coproducts can also be computed, as well as substitution of 
+commuting difference operators for quantum double Schubert polynomials. Quantum multiplication also has 
+parabolic subgroup support, computed via the Peterson-Woodward comparison theorem. **Note that except 
+for quantum Schubert polynomial multiplication with the --basic-pieri option, the methodology for 
+quantum/quantum double Schubert polynomials is conjectural at this time.**
+
+
+[Docs to be hosted on Wiki](https://github.com/matthematics/schubmult/wiki/schubmult-home)
+
+
+## Basic script command lines, one-line notation
+
+### schubmult_py - ordinary Schubert polynmoials
+
+```
+usage: schubmult_py [-h] [-np] [--code] [--mult MULT [MULT ...]] [--coprod] [--display-mode 
+{basic,pretty,latex,raw}] 
+hyphen-separated list of perms [hyphen-separated list of perms ...]
+
+
+Compute products of ordinary Schubert polynomials
+
+positional arguments:
+  hyphen-separated list of perms
+                        Space-delimited permutations separated by hyphens, e. g. 3 4 1 2 - 5 1 2 4 3
+
+
+options:
+  -h, --help            show this help message and exit
+  -np, --no-print       Compute the result but do not print it
+
+  --code                Permutations represented by the Lehmer code
+
+  --mult MULT [MULT ...]
+                        Some additional terms in the ring to multiply by
+
+  --coprod              Compute the coproduct (different syntax: one permutation, then a hyphen, the 
+variable index 
+positions to split on)
+  --display-mode {basic,raw}
+                        Method of displaying the output. Default basic
+
+
+Example:
+        schubmult_py 5 1 7 3 2 6 4 - 2 1 6 3 5 4
+            or equivalently
+        schubmult_py --code 4 0 4 1 0 1 - 1 0 3 0 1
+            or alternatively
+        schubmult_py --coprod --code 2 0 3 0 1 - 2 4
+```
+
+
+<!-- ## Quantum commuting difference operators
+
+schubmult_q_double 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.
+```bash
+schubmult_q_double --nil-hecke 6 --code 2 2 --display-positive
+
+``` -->
+
+### schubmult_double - Double Schubert polynmoials
+
+```
+usage: schubmult_double [-h] [-np] [--code] [--mult MULT [MULT ...]] [--coprod] [--display-positive] [--
+optimizer-message] [--down] [-nc] 
+[--mixed-var] [--expand] [--display-mode {basic,pretty,latex,raw}]
+
+hyphen-separated list of perms [hyphen-separated list of perms ...]
+
+
+Compute coefficients of product of double Schubert polynomials in the same or different sets of 
+coefficient variables
+
+positional arguments:
+  hyphen-separated list of perms
+                        Space-delimited permutations separated by hyphens, e. g. 3 4 1 2 - 5 1 2 4 3
+
+
+options:
+  -h, --help            show this help message and exit
+  -np, --no-print       Compute the result but do not print it
+
+  --code                Permutations represented by the Lehmer code
+
+  --mult MULT [MULT ...]
+                        Some additional terms in the ring to multiply by
+
+  --coprod              Compute the coproduct (different syntax: one permutation, then a hyphen, the 
+variable index 
+  positions to split on)
+  --display-positive    Display the result in terms of the positive roots, or if mixed variable attempt 
+to display the 
+  result as a positive algebraic combination of terms of the form y_i - z_j
+
+  --optimizer-message   Display debug output during integer optimization for --display-positive
+
+  --down                Reverse multiplication
+  -nc, --no-check       Do not check if positive result matches the original
+
+  --mixed-var           Used mixed variables y and z
+  --expand              Expand the output rather than leaving it as originally computed (slow)
+
+  --display-mode {basic,pretty,latex,raw}
+                        Method of displaying the output. Default basic
+
+
+Example:
+        schubmult_double 5 1 7 3 2 6 4 - 2 1 6 3 5 4 [ --display-positive]
+
+            or equivalently
+        schubmult_double --code 4 0 4 1 0 1 - 1 0 3 0 1 [ --display-positive]
+
+            or alternatively
+        schubmult_double --coprod --code 2 0 3 0 1 - 2 4  [ --display-positive]
+
+```
+
+### schubmult_q - Quantum Schubert polynomials
+
+```
+usage: schubmult_q [-h] [-np] [--code] [--mult MULT [MULT ...]] [--parabolic PARABOLIC [PARABOLIC ...]] 
+[--basic-pieri] 
+[--display-mode {basic,pretty,latex,raw}]
+                   hyphen-separated list of perms [hyphen-separated list of perms ...]
+
+
+Compute products of quantum Schubert polynomials
+
+positional arguments:
+  hyphen-separated list of perms
+                        Space-delimited permutations separated by hyphens, e. g. 3 4 1 2 - 5 1 2 4 3
+
+
+options:
+  -h, --help            show this help message and exit
+  -np, --no-print       Compute the result but do not print it
+
+  --code                Permutations represented by the Lehmer code
+
+  --mult MULT [MULT ...]
+                        Some additional terms in the ring to multiply by
+
+  --parabolic PARABOLIC [PARABOLIC ...]
+                        Generators of the parabolic subgroup to compute quantum coeffs for
+
+  --basic-pieri         Do not apply conjectural computation optimization to quantum
+
+  --display-mode {basic,pretty,latex,raw}
+                        Method of displaying the output. Default basic
+
+
+Example:
+        schubmult_q 5 1 7 3 2 6 4 - 2 1 6 3 5 4
+            or equivalently
+        schubmult_q --code 4 0 4 1 0 1 - 1 0 3 0 1
+```
+
+### schubmult_q_double - Quantum double Schubert polynomials
+
+
+```
+usage: schubmult_q_double [-h] [-np] [--code] [--mult MULT [MULT ...]] [--display-positive] [--optimizer-
+message] [--down] 
+[-nc] [--mixed-var] [--expand] [--parabolic PARABOLIC [PARABOLIC ...]] [--basic-pieri]
+
+                          [--nil-hecke N] [--nil-hecke-apply N] [--display-mode 
+{basic,pretty,latex,raw}]
+                          hyphen-separated list of perms [hyphen-separated list of perms ...]
+
+
+Compute coefficients of products of quantum double Schubert polynomials in the same or different sets of 
+coefficient variables
+
+positional arguments:
+  hyphen-separated list of perms
+                        Space-delimited permutations separated by hyphens, e. g. 3 4 1 2 - 5 1 2 4 3
+
+
+options:
+  -h, --help            show this help message and exit
+  -np, --no-print       Compute the result but do not print it
+
+  --code                Permutations represented by the Lehmer code
+
+  --mult MULT [MULT ...]
+                        Some additional terms in the ring to multiply by
+
+  --display-positive    Display the result in terms of the positive roots, or if mixed variable attempt 
+to display the 
+result as a positive algebraic combination of terms of the form y_i - z_j
+
+  --optimizer-message   Display debug output during integer optimization for --display-positive
+
+  --down                Reverse multiplication
+  -nc, --no-check       Do not check if positive result matches the original
+
+  --mixed-var           Used mixed variables y and z
+  --expand              Expand the output rather than leaving it as originally computed (slow)
+
+  --parabolic PARABOLIC [PARABOLIC ...]
+                        Generators of the parabolic subgroup to compute quantum coeffs for
+
+  --basic-pieri         Do not apply conjectural computation optimization to quantum
+
+  --nil-hecke N         Substitute up to N of Fomin-Gelfand-Postnikov commuting difference operators
+
+  --nil-hecke-apply N   Substitute commuting difference operators for perm1, then apply to Schub indexed 
+by perm2
+  --display-mode {basic,pretty,latex,raw}
+                        Method of displaying the output. Default basic
+
+
+Example:
+        schubmult_q_double 5 1 7 3 2 6 4 - 2 1 6 3 5 4 [ --display-positive]
+
+            or equivalently
+        schubmult_q_double --code 4 0 4 1 0 1 - 1 0 3 0 1 [ --display-positive]
+
+```
+
+## Diplaying the result positively
+
+The command line argument `--display-positive `is available in schubmult_double and schubmult_q_double, 
+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.
+
+
+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_double is for multiplying 
+double Schubert polynomials in different sets of coefficient variables (`--mixed-var`) or in the same 
+set of coefficient variables (by default). Similarly, schubmult_q is for multiplying quantum Schubert 
+polynomials, schubmult_q_double is for multiplying quantum double Schubert polynomials (in different 
+sets of coefficient variables with the `--mixed-var` option, or the same set), 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 (and the q variables) with the `--display-positive` option (either in the 
+negative simple roots r_i, or in y_i - z_j for `--mixed-var`).
+
+
+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.
+
+# Sage integration (as of version 2.0.0)
+
+[SageMath](https://www.sagemath.org/) is a computer algebra system that, while wonderful, is monstrously 
+large and only works on posix-based operating systems (including WSL VMs, so it is still usable on 
+Windows). This is why Sage support is provided optionally in schubmult. The syntax to install the Sage 
+dependencies is
+
+```
+pip install schubmult[sage]
+```
+
+This will install the [sagemath-standard](https://pypi.org/project/sagemath-standard/) python package in 
+addition to the other dependencies. **Again, this only works on Linux, MacOS, or WSL.** To use with a 
+currently installed SageMath distribution, use sage's python interpreter to install the package (the 
+`[sage]` piece is not required in that case).
+
+## Basic sage example
+
+```python
+sage: from schubmult.sage_integration import FastSchubertPolynomialRing, 
+FastDoubleSchubertPolynomialRing,
+FastQuantumSchubertPolynomialRing, FastQuantumDoubleSchubertPolynomialRing
+
+sage: SingleRing = FastSchubertPolynomialRing(ZZ, 100, "x")
+sage: SingleRing([3,4,1,2])
+Sx([3, 4, 1, 2])
+sage: SingleRing([3,4,1,2]) * SingleRing([5,1,4,2,3])
+Sx([7, 3, 4, 1, 2, 5, 6]) + Sx([7, 4, 2, 1, 3, 5, 6]) + Sx([7, 5, 1, 2, 3, 4, 6])
+
+```
+
+## Mixed variable (Molev-Sagan) type products
+
+```python
+sage: DoubleRing = FastDoubleSchubertPolynomialRing(ZZ, 100, "x", ("y", "z"))
+sage: DoubleRing([3,4,1,2])*DoubleRing([1,4,2,3])
+(y1*y2-y1*y4-y2*y4+y4^2)*DSx([3, 4, 1, 2], 'y') + (-y1-y2+y4+y5)*DSx([3, 5, 1, 2, 4], 'y') + DSx([3, 6, 
+1, 2, 4, 5], 'y')
+sage: DoubleRing([3,4,1,2]) * DoubleRing([1,4,2,3],"z")
+(y3^2+y3*y4+y4^2-y3*z1-y4*z1-y3*z2-y4*z2+z1*z2-y3*z3-y4*z3+z1*z3+z2*z3)*DSx([3, 4, 1, 2], 'y') + (y3+y4+
+y5-z1-z2-z3)*DSx([3, 5, 1, 2, 4], 'y') + DSx([3, 6, 1, 2, 4, 5], 'y')
+```
+
+## expand()
+
+```python
+sage: SingleRingQ = FastQuantumSchubertPolynomialRing(ZZ, 100, "x")
+sage: SingleRingQ([2,3,1,4]).expand()
+x1*x2 + q_1
+```
+
+## Coercion
+
+Coercion was implemented as widely as possible.
+```python
+sage: DoubleRing([1,4,2,3],"z") * SingleRing([3,4,1,2])
+z1^2*z4^2*DSx([1, 4, 2, 3], 'z') + (z1^2*z4+z1^2*z5)*DSx([1, 5, 2, 3, 4], 'z') + z1^2*DSx([1, 6, 2, 3, 
+4, 5], 'z') + (z1*z4^2+z2*z4^2)*DSx([2, 4, 1, 3], 'z') + (z1*z4+z2*z4+z1*z5+z2*z5)*DSx([2, 5, 1, 3, 4], 
+'z') + (z1+z2)*DSx([2, 6, 1, 3, 4, 5], 'z') + z4^2*DSx([3, 4, 1, 2], 'z') + (z4+z5)*DSx([3, 5, 1, 2, 4], 
+'z') + DSx([3, 6, 1, 2, 4, 5], 'z')
+sage: SingleRingQ([2,3,1,4]) * SingleRing([4,1,3,2])
+(-2*q1^2*q2+q1*q2*q3)*QSx([1]) + q1*q2*QSx([1, 3, 4, 2]) + (-q1^2)*QSx([2, 3, 1]) + q1*QSx([2, 4, 3, 1]) 
++ (-q1*q2)*QSx([3, 1, 2]) + q1*QSx([3, 2, 4, 1]) + q1*QSx([3, 4, 1, 2]) + (-q1)*QSx([4, 2, 1, 3]) + 
+QSx([5, 2, 3, 1, 4]) + QSx([5, 3, 1, 2, 4])
+sage: R.<x1, x2> = PolynomialRing(ZZ, 2)
+sage: SingleRing([1,3,2]) - x1 - x2 == 0
+True
+```
+
+## Coproducts
+
+FastSchubertPolynomialRing and FastDoubleSchubertPolynomialRings are bialgebras and each element 
+implements the `coproduct()` member function. `set_coproduct_indices()` on the base ring will determine 
+the variables to partition on.
+```ada
+sage: DoubleRing.set_coproduct_indices((1,3))
+sage: DoubleRing([4,1,5,2,3], "z").coproduct()
+(y1^2-y1*z2-y1*z3+z2*z3)*DSx([4, 1, 2, 3], 'z') # DSx([1], 'y') + (y1+y2-z2-z3)*DSx([4, 1, 2, 3], 'z') # 
+DSx([2, 1], 'y') + DSx([4, 1, 2, 3], 'z') # DSx([3, 1, 2], 'y') + (y1-z3)*DSx([4, 2, 1, 3], 'z') # 
+DSx([1], 'y') + DSx([4, 2, 1, 3], 'z') # DSx([2, 1], 'y') + DSx([4, 3, 1, 2], 'z') # DSx([1], 'y')
+
+```
+
+## Demonstration of quantum double mixed products
+
+```python
+sage: QuantumDoubleRing = FastQuantumDoubleSchubertPolynomialRing(ZZ, 100, "x", ("y","z"))
+sage: QuantumDoubleRing([4,1,3,2])*QuantumDoubleRing([5,1,3,2,4], "z")
+(q1*q2*q3*y1^3+q1*q2*q3*y1^2*y4+q1*q2*q3*y1*y4^2+q1*q2*q3*y4^3-q1*q2*q3*y1^2*z1-q1*q2*q3*y1*y4*z1-
+q1*q2*q3*y4^2*z1-q1*q2*q3*y1^2*z2-q1*q2*q3*y1*y4*z2-q1*q2*q3*y4^2*z2+q1*q2*q3*y1*z1*z2+q1*q2*q3*y4*z1*z2-
+q1*q2*q3*y1^2*z3-q1*q2*q3*y1*y4*z3-q1*q2*q3*y4^2*z3+q1*q2*q3*y1*z1*z3+q1*q2*q3*y4*z1*z3+
+q1*q2*q3*y1*z2*z3+q1*q2*q3*y4*z2*z3-q1*q2*q3*z1*z2*z3-q1*q2*q3*y1^2*z4-q1*q2*q3*y1*y4*z4-
+q1*q2*q3*y4^2*z4+q1*q2*q3*y1*z1*z4+q1*q2*q3*y4*z1*z4+q1*q2*q3*y1*z2*z4+q1*q2*q3*y4*z2*z4-
+q1*q2*q3*z1*z2*z4+q1*q2*q3*y1*z3*z4+q1*q2*q3*y4*z3*z4-q1*q2*q3*z1*z3*z4-q1*q2*q3*z2*z3*z4)*QDSx([1], 
+'y') + (q1*q2*q3*y1^2+q1*q2*q3*y1*y4+q1*q2*q3*y4^2+q1*q2*q3*y1*y5+q1*q2*q3*y4*y5+q1*q2*q3*y5^2-
+q1*q2*q3*y1*z1-q1*q2*q3*y4*z1-q1*q2*q3*y5*z1-q1*q2*q3*y1*z2-q1*q2*q3*y4*z2-q1*q2*q3*y5*z2+q1*q2*q3*z1*z2-
+q1*q2*q3*y1*z3-q1*q2*q3*y4*z3-q1*q2*q3*y5*z3+q1*q2*q3*z1*z3+q1*q2*q3*z2*z3-q1*q2*q3*y1*z4-q1*q2*q3*y4*z4-
+q1*q2*q3*y5*z4+q1*q2*q3*z1*z4+q1*q2*q3*z2*z4+q1*q2*q3*z3*z4)*QDSx([1, 2, 3, 5, 4], 'y') + (q1*q2*q3*y1+
+q1*q2*q3*y4+q1*q2*q3*y5+q1*q2*q3*y6-q1*q2*q3*z1-q1*q2*q3*z2-q1*q2*q3*z3-q1*q2*q3*z4)*QDSx([1, 2, 3, 6, 
+4, 5], 'y') + q1*q2*q3*QDSx([1, 2, 3, 7, 4, 5, 6], 'y') + (q1*q3*y1^3+q1*q3*y1^2*y4+q1*q3*y1*y4^2+
+q1*q3*y4^3-q1*q3*y1^2*z1-q1*q3*y1*y4*z1-q1*q3*y4^2*z1-q1*q3*y1^2*z2-q1*q3*y1*y4*z2-q1*q3*y4^2*z2+
+q1*q3*y1*z1*z2+q1*q3*y4*z1*z2-q1*q3*y1^2*z3-q1*q3*y1*y4*z3-q1*q3*y4^2*z3+q1*q3*y1*z1*z3+q1*q3*y4*z1*z3+
+q1*q3*y1*z2*z3+q1*q3*y4*z2*z3-q1*q3*z1*z2*z3-q1*q3*y1^2*z4-q1*q3*y1*y4*z4-q1*q3*y4^2*z4+q1*q3*y1*z1*z4+
+q1*q3*y4*z1*z4+q1*q3*y1*z2*z4+q1*q3*y4*z2*z4-q1*q3*z1*z2*z4+q1*q3*y1*z3*z4+q1*q3*y4*z3*z4-q1*q3*z1*z3*z4-
+q1*q3*z2*z3*z4)*QDSx([1, 4, 2, 3], 'y') + (q1*y1^3*y3+q1*y1^3*y4+q1*y1^2*y3*y4+q1*y1^2*y4^2+
+q1*y1*y3*y4^2+q1*y1*y4^3+q1*y3*y4^3-q1*y1^3*z1-q1*y1^2*y3*z1-2*q1*y1^2*y4*z1-q1*y1*y3*y4*z1-
+2*q1*y1*y4^2*z1-q1*y3*y4^2*z1-q1*y4^3*z1+q1*y1^2*z1^2+q1*y1*y4*z1^2+q1*y4^2*z1^2-q1*y1^3*z2-
+q1*y1^2*y3*z2-2*q1*y1^2*y4*z2-q1*y1*y3*y4*z2-2*q1*y1*y4^2*z2-q1*y3*y4^2*z2-q1*y4^3*z2+2*q1*y1^2*z1*z2+
+q1*y1*y3*z1*z2+3*q1*y1*y4*z1*z2+q1*y3*y4*z1*z2+2*q1*y4^2*z1*z2-q1*y1*z1^2*z2-q1*y4*z1^2*z2+q1*y1^2*z2^2+
+q1*y1*y4*z2^2+q1*y4^2*z2^2-q1*y1*z1*z2^2-q1*y4*z1*z2^2-q1*y1^2*y3*z3-q1*y1^2*y4*z3-q1*y1*y3*y4*z3-
+q1*y1*y4^2*z3-q1*y3*y4^2*z3+q1*y1^2*z1*z3+q1*y1*y3*z1*z3+2*q1*y1*y4*z1*z3+q1*y3*y4*z1*z3+q1*y4^2*z1*z3-
+q1*y1*z1^2*z3-q1*y4*z1^2*z3+q1*y1^2*z2*z3+q1*y1*y3*z2*z3+2*q1*y1*y4*z2*z3+q1*y3*y4*z2*z3+q1*y4^2*z2*z3-
+2*q1*y1*z1*z2*z3-q1*y3*z1*z2*z3-2*q1*y4*z1*z2*z3+q1*z1^2*z2*z3-q1*y1*z2^2*z3-q1*y4*z2^2*z3+q1*z1*z2^2*z3-
+q1*y1^2*y3*z4-q1*y1^2*y4*z4-q1*y1*y3*y4*z4-q1*y1*y4^2*z4-q1*y3*y4^2*z4+q1*y1^2*z1*z4+q1*y1*y3*z1*z4+
+2*q1*y1*y4*z1*z4+q1*y3*y4*z1*z4+q1*y4^2*z1*z4-q1*y1*z1^2*z4-q1*y4*z1^2*z4+q1*y1^2*z2*z4+q1*y1*y3*z2*z4+
+2*q1*y1*y4*z2*z4+q1*y3*y4*z2*z4+q1*y4^2*z2*z4-2*q1*y1*z1*z2*z4-q1*y3*z1*z2*z4-2*q1*y4*z1*z2*z4+
+q1*z1^2*z2*z4-q1*y1*z2^2*z4-q1*y4*z2^2*z4+q1*z1*z2^2*z4+q1*y1*y3*z3*z4+q1*y1*y4*z3*z4+q1*y3*y4*z3*z4-
+q1*y1*z1*z3*z4-q1*y3*z1*z3*z4-q1*y4*z1*z3*z4+q1*z1^2*z3*z4-q1*y1*z2*z3*z4-q1*y3*z2*z3*z4-q1*y4*z2*z3*z4+
+q1*z1*z2*z3*z4+q1*z2^2*z3*z4)*QDSx([1, 4, 3, 2], 'y') + (q1*y1^3+q1*y1^2*y4+q1*y1*y4^2+q1*y4^3-
+q1*y1^2*z1-q1*y1*y4*z1-q1*y4^2*z1-q1*y1^2*z2-q1*y1*y4*z2-q1*y4^2*z2+q1*y1*z1*z2+q1*y4*z1*z2-q1*y1^2*z3-
+q1*y1*y4*z3-q1*y4^2*z3+q1*y1*z1*z3+q1*y4*z1*z3+q1*y1*z2*z3+q1*y4*z2*z3-q1*z1*z2*z3-q1*y1^2*z4-
+q1*y1*y4*z4-q1*y4^2*z4+q1*y1*z1*z4+q1*y4*z1*z4+q1*y1*z2*z4+q1*y4*z2*z4-q1*z1*z2*z4+q1*y1*z3*z4+
+q1*y4*z3*z4-q1*z1*z3*z4-q1*z2*z3*z4)*QDSx([1, 4, 5, 2, 3], 'y') + (q1*q3*y1^2+q1*q3*y1*y4+q1*q3*y4^2+
+q1*q3*y1*y5+q1*q3*y4*y5+q1*q3*y5^2-q1*q3*y1*z1-q1*q3*y4*z1-q1*q3*y5*z1-q1*q3*y1*z2-q1*q3*y4*z2-
+q1*q3*y5*z2+q1*q3*z1*z2-q1*q3*y1*z3-q1*q3*y4*z3-q1*q3*y5*z3+q1*q3*z1*z3+q1*q3*z2*z3-q1*q3*y1*z4-
+q1*q3*y4*z4-q1*q3*y5*z4+q1*q3*z1*z4+q1*q3*z2*z4+q1*q3*z3*z4)*QDSx([1, 5, 2, 3, 4], 'y') + (q1*y1^3+
+q1*y1^2*y3+q1*y1^2*y4+q1*y1*y3*y4+q1*y1*y4^2+q1*y3*y4^2+q1*y1^2*y5+q1*y1*y3*y5+q1*y1*y4*y5+q1*y3*y4*y5+
+q1*y1*y5^2+q1*y3*y5^2-2*q1*y1^2*z1-q1*y1*y3*z1-2*q1*y1*y4*z1-q1*y3*y4*z1-q1*y4^2*z1-2*q1*y1*y5*z1-
+q1*y3*y5*z1-q1*y4*y5*z1-q1*y5^2*z1+q1*y1*z1^2+q1*y4*z1^2+q1*y5*z1^2-2*q1*y1^2*z2-q1*y1*y3*z2-
+2*q1*y1*y4*z2-q1*y3*y4*z2-q1*y4^2*z2-2*q1*y1*y5*z2-q1*y3*y5*z2-q1*y4*y5*z2-q1*y5^2*z2+3*q1*y1*z1*z2+
+q1*y3*z1*z2+2*q1*y4*z1*z2+2*q1*y5*z1*z2-q1*z1^2*z2+q1*y1*z2^2+q1*y4*z2^2+q1*y5*z2^2-q1*z1*z2^2-
+q1*y1^2*z3-q1*y1*y3*z3-q1*y1*y4*z3-q1*y3*y4*z3-q1*y1*y5*z3-q1*y3*y5*z3+2*q1*y1*z1*z3+q1*y3*z1*z3+
+q1*y4*z1*z3+q1*y5*z1*z3-q1*z1^2*z3+2*q1*y1*z2*z3+q1*y3*z2*z3+q1*y4*z2*z3+q1*y5*z2*z3-2*q1*z1*z2*z3-
+q1*z2^2*z3-q1*y1^2*z4-q1*y1*y3*z4-q1*y1*y4*z4-q1*y3*y4*z4-q1*y1*y5*z4-q1*y3*y5*z4+2*q1*y1*z1*z4+
+q1*y3*z1*z4+q1*y4*z1*z4+q1*y5*z1*z4-q1*z1^2*z4+2*q1*y1*z2*z4+q1*y3*z2*z4+q1*y4*z2*z4+q1*y5*z2*z4-
+2*q1*z1*z2*z4-q1*z2^2*z4+q1*y1*z3*z4+q1*y3*z3*z4-q1*z1*z3*z4-q1*z2*z3*z4)*QDSx([1, 5, 3, 2, 4], 'y') + 
+(q1*y1^2+q1*y1*y4+q1*y4^2+q1*y1*y5+q1*y4*y5+q1*y5^2-q1*y1*z1-q1*y4*z1-q1*y5*z1-q1*y1*z2-q1*y4*z2-
+q1*y5*z2+q1*z1*z2-q1*y1*z3-q1*y4*z3-q1*y5*z3+q1*z1*z3+q1*z2*z3-q1*y1*z4-q1*y4*z4-q1*y5*z4+q1*z1*z4+
+q1*z2*z4+q1*z3*z4)*QDSx([1, 5, 4, 2, 3], 'y') + (q1*q3*y1+q1*q3*y4+q1*q3*y5+q1*q3*y6-q1*q3*z1-q1*q3*z2-
+q1*q3*z3-q1*q3*z4)*QDSx([1, 6, 2, 3, 4, 5], 'y') + (q1*y1^2+q1*y1*y3+q1*y1*y4+q1*y3*y4+q1*y1*y5+q1*y3*y5+
+q1*y1*y6+q1*y3*y6-2*q1*y1*z1-q1*y3*z1-q1*y4*z1-q1*y5*z1-q1*y6*z1+q1*z1^2-2*q1*y1*z2-q1*y3*z2-q1*y4*z2-
+q1*y5*z2-q1*y6*z2+2*q1*z1*z2+q1*z2^2-q1*y1*z3-q1*y3*z3+q1*z1*z3+q1*z2*z3-q1*y1*z4-q1*y3*z4+q1*z1*z4+
+q1*z2*z4)*QDSx([1, 6, 3, 2, 4, 5], 'y') + (q1*y1+q1*y4+q1*y5+q1*y6-q1*z1-q1*z2-q1*z3-q1*z4)*QDSx([1, 6, 
+4, 2, 3, 5], 'y') + q1*q3*QDSx([1, 7, 2, 3, 4, 5, 6], 'y') + (q1*y1+q1*y3-q1*z1-q1*z2)*QDSx([1, 7, 3, 2, 
+4, 5, 6], 'y') + q1*QDSx([1, 7, 4, 2, 3, 5, 6], 'y') + (q1*q2*q3*y1^2+q1*q2*q3*y1*y2+q1*q2*q3*y2^2+
+q1*q2*q3*y1*y4+q1*q2*q3*y2*y4+q1*q2*q3*y4^2-q1*q2*q3*y1*z1-q1*q2*q3*y2*z1-q1*q2*q3*y4*z1-q1*q2*q3*y1*z2-
+q1*q2*q3*y2*z2-q1*q2*q3*y4*z2+q1*q2*q3*z1*z2-q1*q2*q3*y1*z3-q1*q2*q3*y2*z3-q1*q2*q3*y4*z3+q1*q2*q3*z1*z3+
+q1*q2*q3*z2*z3-q1*q2*q3*y1*z4-q1*q2*q3*y2*z4-q1*q2*q3*y4*z4+q1*q2*q3*z1*z4+q1*q2*q3*z2*z4+
+q1*q2*q3*z3*z4)*QDSx([2, 1], 'y') + (q1*q2*q3*y1+q1*q2*q3*y2+q1*q2*q3*y4+q1*q2*q3*y5-q1*q2*q3*z1-
+q1*q2*q3*z2-q1*q2*q3*z3-q1*q2*q3*z4)*QDSx([2, 1, 3, 5, 4], 'y') + q1*q2*q3*QDSx([2, 1, 3, 6, 4, 5], 'y') 
++ (q1*q3*y1^2+q1*q3*y1*y2+q1*q3*y2^2+q1*q3*y1*y4+q1*q3*y2*y4+q1*q3*y4^2-q1*q3*y1*z1-q1*q3*y2*z1-
+q1*q3*y4*z1-q1*q3*y1*z2-q1*q3*y2*z2-q1*q3*y4*z2+q1*q3*z1*z2-q1*q3*y1*z3-q1*q3*y2*z3-q1*q3*y4*z3+
+q1*q3*z1*z3+q1*q3*z2*z3-q1*q3*y1*z4-q1*q3*y2*z4-q1*q3*y4*z4+q1*q3*z1*z4+q1*q3*z2*z4+
+q1*q3*z3*z4)*QDSx([2, 4, 1, 3], 'y') + (q1*y1^2*y3+q1*y1*y2*y3+q1*y2^2*y3+q1*y1^2*y4+q1*y1*y2*y4+
+q1*y2^2*y4+q1*y1*y3*y4+q1*y2*y3*y4+q1*y1*y4^2+q1*y2*y4^2+q1*y3*y4^2+q1*y4^3-q1*y1^2*z1-q1*y1*y2*z1-
+q1*y2^2*z1-q1*y1*y3*z1-q1*y2*y3*z1-2*q1*y1*y4*z1-2*q1*y2*y4*z1-q1*y3*y4*z1-2*q1*y4^2*z1+q1*y1*z1^2+
+q1*y2*z1^2+q1*y4*z1^2-q1*y1^2*z2-q1*y1*y2*z2-q1*y2^2*z2-q1*y1*y3*z2-q1*y2*y3*z2-2*q1*y1*y4*z2-
+2*q1*y2*y4*z2-q1*y3*y4*z2-2*q1*y4^2*z2+2*q1*y1*z1*z2+2*q1*y2*z1*z2+q1*y3*z1*z2+3*q1*y4*z1*z2-q1*z1^2*z2+
+q1*y1*z2^2+q1*y2*z2^2+q1*y4*z2^2-q1*z1*z2^2-q1*y1*y3*z3-q1*y2*y3*z3-q1*y1*y4*z3-q1*y2*y4*z3-q1*y3*y4*z3-
+q1*y4^2*z3+q1*y1*z1*z3+q1*y2*z1*z3+q1*y3*z1*z3+2*q1*y4*z1*z3-q1*z1^2*z3+q1*y1*z2*z3+q1*y2*z2*z3+
+q1*y3*z2*z3+2*q1*y4*z2*z3-2*q1*z1*z2*z3-q1*z2^2*z3-q1*y1*y3*z4-q1*y2*y3*z4-q1*y1*y4*z4-q1*y2*y4*z4-
+q1*y3*y4*z4-q1*y4^2*z4+q1*y1*z1*z4+q1*y2*z1*z4+q1*y3*z1*z4+2*q1*y4*z1*z4-q1*z1^2*z4+q1*y1*z2*z4+
+q1*y2*z2*z4+q1*y3*z2*z4+2*q1*y4*z2*z4-2*q1*z1*z2*z4-q1*z2^2*z4+q1*y3*z3*z4+q1*y4*z3*z4-q1*z1*z3*z4-
+q1*z2*z3*z4)*QDSx([2, 4, 3, 1], 'y') + (q1*y1^2+q1*y1*y2+q1*y2^2+q1*y1*y4+q1*y2*y4+q1*y4^2-q1*y1*z1-
+q1*y2*z1-q1*y4*z1-q1*y1*z2-q1*y2*z2-q1*y4*z2+q1*z1*z2-q1*y1*z3-q1*y2*z3-q1*y4*z3+q1*z1*z3+q1*z2*z3-
+q1*y1*z4-q1*y2*z4-q1*y4*z4+q1*z1*z4+q1*z2*z4+q1*z3*z4)*QDSx([2, 4, 5, 1, 3], 'y') + (q1*q3*y1+q1*q3*y2+
+q1*q3*y4+q1*q3*y5-q1*q3*z1-q1*q3*z2-q1*q3*z3-q1*q3*z4)*QDSx([2, 5, 1, 3, 4], 'y') + (q1*y1^2+q1*y1*y2+
+q1*y2^2+q1*y1*y3+q1*y2*y3+q1*y1*y4+q1*y2*y4+q1*y3*y4+q1*y4^2+q1*y1*y5+q1*y2*y5+q1*y3*y5+q1*y4*y5+q1*y5^2-
+2*q1*y1*z1-2*q1*y2*z1-q1*y3*z1-2*q1*y4*z1-2*q1*y5*z1+q1*z1^2-2*q1*y1*z2-2*q1*y2*z2-q1*y3*z2-2*q1*y4*z2-
+2*q1*y5*z2+3*q1*z1*z2+q1*z2^2-q1*y1*z3-q1*y2*z3-q1*y3*z3-q1*y4*z3-q1*y5*z3+2*q1*z1*z3+2*q1*z2*z3-
+q1*y1*z4-q1*y2*z4-q1*y3*z4-q1*y4*z4-q1*y5*z4+2*q1*z1*z4+2*q1*z2*z4+q1*z3*z4)*QDSx([2, 5, 3, 1, 4], 'y') +
+ (q1*y1+q1*y2+q1*y4+q1*y5-q1*z1-q1*z2-q1*z3-q1*z4)*QDSx([2, 5, 4, 1, 3], 'y') + q1*q3*QDSx([2, 6, 1, 3, 
+4, 5], 'y') + (q1*y1+q1*y2+q1*y3+q1*y4+q1*y5+q1*y6-2*q1*z1-2*q1*z2-q1*z3-q1*z4)*QDSx([2, 6, 3, 1, 4, 5], 
+'y') + q1*QDSx([2, 6, 4, 1, 3, 5], 'y') + q1*QDSx([2, 7, 3, 1, 4, 5, 6], 'y') + (q1*q2*q3*y1+q1*q2*q3*y2+
+q1*q2*q3*y3+q1*q2*q3*y4-q1*q2*q3*z1-q1*q2*q3*z2-q1*q2*q3*z3-q1*q2*q3*z4)*QDSx([3, 1, 2], 'y') + 
+q1*q2*q3*QDSx([3, 1, 2, 5, 4], 'y') + (q1*y1^2*y3+q1*y1*y3^2+q1*y1^2*y4+2*q1*y1*y3*y4+q1*y3^2*y4+
+q1*y1*y4^2+q1*y3*y4^2-q1*y1^2*z1-2*q1*y1*y3*z1-q1*y3^2*z1-2*q1*y1*y4*z1-2*q1*y3*y4*z1-q1*y4^2*z1+
+q1*y1*z1^2+q1*y3*z1^2+q1*y4*z1^2-q1*y1^2*z2-2*q1*y1*y3*z2-q1*y3^2*z2-2*q1*y1*y4*z2-2*q1*y3*y4*z2-
+q1*y4^2*z2+2*q1*y1*z1*z2+2*q1*y3*z1*z2+2*q1*y4*z1*z2-q1*z1^2*z2+q1*y1*z2^2+q1*y3*z2^2+q1*y4*z2^2-
+q1*z1*z2^2-q1*y1*y3*z3-q1*y1*y4*z3-q1*y3*y4*z3+q1*y1*z1*z3+q1*y3*z1*z3+q1*y4*z1*z3-q1*z1^2*z3+
+q1*y1*z2*z3+q1*y3*z2*z3+q1*y4*z2*z3-q1*z1*z2*z3-q1*z2^2*z3-q1*y1*y3*z4-q1*y1*y4*z4-q1*y3*y4*z4+
+q1*y1*z1*z4+q1*y3*z1*z4+q1*y4*z1*z4-q1*z1^2*z4+q1*y1*z2*z4+q1*y3*z2*z4+q1*y4*z2*z4-q1*z1*z2*z4-
+q1*z2^2*z4+q1*q3*y1+q1*q3*y2+q1*q3*y3+q1*q3*y4-q1*q3*z1-q1*q3*z2-q1*q3*z3-q1*q3*z4)*QDSx([3, 4, 1, 2], 
+'y') + (q1*y1*y3+q1*y2*y3+q1*y3^2+q1*y1*y4+q1*y2*y4+2*q1*y3*y4+q1*y4^2-q1*y1*z1-q1*y2*z1-2*q1*y3*z1-
+2*q1*y4*z1+q1*z1^2-q1*y1*z2-q1*y2*z2-2*q1*y3*z2-2*q1*y4*z2+2*q1*z1*z2+q1*z2^2-q1*y3*z3-q1*y4*z3+q1*z1*z3+
+q1*z2*z3-q1*y3*z4-q1*y4*z4+q1*z1*z4+q1*z2*z4)*QDSx([3, 4, 2, 1], 'y') + (q1*y1+q1*y2+q1*y3+q1*y4-q1*z1-
+q1*z2-q1*z3-q1*z4)*QDSx([3, 4, 5, 1, 2], 'y') + (q1*y1^2+2*q1*y1*y3+q1*y3^2+q1*y1*y4+q1*y3*y4+q1*y1*y5+
+q1*y3*y5-2*q1*y1*z1-2*q1*y3*z1-q1*y4*z1-q1*y5*z1+q1*z1^2-2*q1*y1*z2-2*q1*y3*z2-q1*y4*z2-q1*y5*z2+
+2*q1*z1*z2+q1*z2^2-q1*y1*z3-q1*y3*z3+q1*z1*z3+q1*z2*z3-q1*y1*z4-q1*y3*z4+q1*z1*z4+q1*z2*z4+
+q1*q3)*QDSx([3, 5, 1, 2, 4], 'y') + (q1*y1+q1*y2+2*q1*y3+q1*y4+q1*y5-2*q1*z1-2*q1*z2-q1*z3-
+q1*z4)*QDSx([3, 5, 2, 1, 4], 'y') + q1*QDSx([3, 5, 4, 1, 2], 'y') + (q1*y1+q1*y3-q1*z1-q1*z2)*QDSx([3, 
+6, 1, 2, 4, 5], 'y') + q1*QDSx([3, 6, 2, 1, 4, 5], 'y') + (q3*y4^4-q3*y4^3*z1-q3*y4^3*z2+q3*y4^2*z1*z2-
+q3*y4^3*z3+q3*y4^2*z1*z3+q3*y4^2*z2*z3-q3*y4*z1*z2*z3-q3*y4^3*z4+q3*y4^2*z1*z4+q3*y4^2*z2*z4-
+q3*y4*z1*z2*z4+q3*y4^2*z3*z4-q3*y4*z1*z3*z4-q3*y4*z2*z3*z4+q3*z1*z2*z3*z4)*QDSx([4, 1, 2, 3], 'y') + 
+(y1*y4^4+y3*y4^4-y1*y4^3*z1-y3*y4^3*z1-y4^4*z1+y4^3*z1^2-y1*y4^3*z2-y3*y4^3*z2-y4^4*z2+y1*y4^2*z1*z2+
+y3*y4^2*z1*z2+2*y4^3*z1*z2-y4^2*z1^2*z2+y4^3*z2^2-y4^2*z1*z2^2-y1*y4^3*z3-y3*y4^3*z3+y1*y4^2*z1*z3+
+y3*y4^2*z1*z3+y4^3*z1*z3-y4^2*z1^2*z3+y1*y4^2*z2*z3+y3*y4^2*z2*z3+y4^3*z2*z3-y1*y4*z1*z2*z3-
+y3*y4*z1*z2*z3-2*y4^2*z1*z2*z3+y4*z1^2*z2*z3-y4^2*z2^2*z3+y4*z1*z2^2*z3-y1*y4^3*z4-y3*y4^3*z4+
+y1*y4^2*z1*z4+y3*y4^2*z1*z4+y4^3*z1*z4-y4^2*z1^2*z4+y1*y4^2*z2*z4+y3*y4^2*z2*z4+y4^3*z2*z4-
+y1*y4*z1*z2*z4-y3*y4*z1*z2*z4-2*y4^2*z1*z2*z4+y4*z1^2*z2*z4-y4^2*z2^2*z4+y4*z1*z2^2*z4+y1*y4^2*z3*z4+
+y3*y4^2*z3*z4-y1*y4*z1*z3*z4-y3*y4*z1*z3*z4-y4^2*z1*z3*z4+y4*z1^2*z3*z4-y1*y4*z2*z3*z4-y3*y4*z2*z3*z4-
+y4^2*z2*z3*z4+y1*z1*z2*z3*z4+y3*z1*z2*z3*z4+2*y4*z1*z2*z3*z4-z1^2*z2*z3*z4+y4*z2^2*z3*z4-
+z1*z2^2*z3*z4)*QDSx([4, 1, 3, 2], 'y') + (y4^4-y4^3*z1-y4^3*z2+y4^2*z1*z2-y4^3*z3+y4^2*z1*z3+y4^2*z2*z3-
+y4*z1*z2*z3-y4^3*z4+y4^2*z1*z4+y4^2*z2*z4-y4*z1*z2*z4+y4^2*z3*z4-y4*z1*z3*z4-y4*z2*z3*z4+
+z1*z2*z3*z4)*QDSx([4, 1, 5, 2, 3], 'y') + (y4^4-y4^3*z1-y4^3*z2+y4^2*z1*z2-y4^3*z3+y4^2*z1*z3+y4^2*z2*z3-
+y4*z1*z2*z3-y4^3*z4+y4^2*z1*z4+y4^2*z2*z4-y4*z1*z2*z4+y4^2*z3*z4-y4*z1*z3*z4-y4*z2*z3*z4+
+z1*z2*z3*z4)*QDSx([4, 2, 3, 1], 'y') + (q1*y1+q1*y3+q1*y4+q1*y5-q1*z1-q1*z2-q1*z3-q1*z4)*QDSx([4, 5, 1, 
+2, 3], 'y') + q1*QDSx([4, 5, 2, 1, 3], 'y') + q1*QDSx([4, 6, 1, 2, 3, 5], 'y') + (q3*y4^3+q3*y4^2*y5+
+q3*y4*y5^2+q3*y5^3-q3*y4^2*z1-q3*y4*y5*z1-q3*y5^2*z1-q3*y4^2*z2-q3*y4*y5*z2-q3*y5^2*z2+q3*y4*z1*z2+
+q3*y5*z1*z2-q3*y4^2*z3-q3*y4*y5*z3-q3*y5^2*z3+q3*y4*z1*z3+q3*y5*z1*z3+q3*y4*z2*z3+q3*y5*z2*z3-
+q3*z1*z2*z3-q3*y4^2*z4-q3*y4*y5*z4-q3*y5^2*z4+q3*y4*z1*z4+q3*y5*z1*z4+q3*y4*z2*z4+q3*y5*z2*z4-
+q3*z1*z2*z4+q3*y4*z3*z4+q3*y5*z3*z4-q3*z1*z3*z4-q3*z2*z3*z4)*QDSx([5, 1, 2, 3, 4], 'y') + (y1*y4^3+
+y3*y4^3+y1*y4^2*y5+y3*y4^2*y5+y1*y4*y5^2+y3*y4*y5^2+y1*y5^3+y3*y5^3-y1*y4^2*z1-y3*y4^2*z1-y4^3*z1-
+y1*y4*y5*z1-y3*y4*y5*z1-y4^2*y5*z1-y1*y5^2*z1-y3*y5^2*z1-y4*y5^2*z1-y5^3*z1+y4^2*z1^2+y4*y5*z1^2+
+y5^2*z1^2-y1*y4^2*z2-y3*y4^2*z2-y4^3*z2-y1*y4*y5*z2-y3*y4*y5*z2-y4^2*y5*z2-y1*y5^2*z2-y3*y5^2*z2-
+y4*y5^2*z2-y5^3*z2+y1*y4*z1*z2+y3*y4*z1*z2+2*y4^2*z1*z2+y1*y5*z1*z2+y3*y5*z1*z2+2*y4*y5*z1*z2+
+2*y5^2*z1*z2-y4*z1^2*z2-y5*z1^2*z2+y4^2*z2^2+y4*y5*z2^2+y5^2*z2^2-y4*z1*z2^2-y5*z1*z2^2-y1*y4^2*z3-
+y3*y4^2*z3-y1*y4*y5*z3-y3*y4*y5*z3-y1*y5^2*z3-y3*y5^2*z3+y1*y4*z1*z3+y3*y4*z1*z3+y4^2*z1*z3+y1*y5*z1*z3+
+y3*y5*z1*z3+y4*y5*z1*z3+y5^2*z1*z3-y4*z1^2*z3-y5*z1^2*z3+y1*y4*z2*z3+y3*y4*z2*z3+y4^2*z2*z3+y1*y5*z2*z3+
+y3*y5*z2*z3+y4*y5*z2*z3+y5^2*z2*z3-y1*z1*z2*z3-y3*z1*z2*z3-2*y4*z1*z2*z3-2*y5*z1*z2*z3+z1^2*z2*z3-
+y4*z2^2*z3-y5*z2^2*z3+z1*z2^2*z3-y1*y4^2*z4-y3*y4^2*z4-y1*y4*y5*z4-y3*y4*y5*z4-y1*y5^2*z4-y3*y5^2*z4+
+y1*y4*z1*z4+y3*y4*z1*z4+y4^2*z1*z4+y1*y5*z1*z4+y3*y5*z1*z4+y4*y5*z1*z4+y5^2*z1*z4-y4*z1^2*z4-y5*z1^2*z4+
+y1*y4*z2*z4+y3*y4*z2*z4+y4^2*z2*z4+y1*y5*z2*z4+y3*y5*z2*z4+y4*y5*z2*z4+y5^2*z2*z4-y1*z1*z2*z4-
+y3*z1*z2*z4-2*y4*z1*z2*z4-2*y5*z1*z2*z4+z1^2*z2*z4-y4*z2^2*z4-y5*z2^2*z4+z1*z2^2*z4+y1*y4*z3*z4+
+y3*y4*z3*z4+y1*y5*z3*z4+y3*y5*z3*z4-y1*z1*z3*z4-y3*z1*z3*z4-y4*z1*z3*z4-y5*z1*z3*z4+z1^2*z3*z4-
+y1*z2*z3*z4-y3*z2*z3*z4-y4*z2*z3*z4-y5*z2*z3*z4+2*z1*z2*z3*z4+z2^2*z3*z4)*QDSx([5, 1, 3, 2, 4], 'y') + 
+(y4^3+y4^2*y5+y4*y5^2+y5^3-y4^2*z1-y4*y5*z1-y5^2*z1-y4^2*z2-y4*y5*z2-y5^2*z2+y4*z1*z2+y5*z1*z2-y4^2*z3-
+y4*y5*z3-y5^2*z3+y4*z1*z3+y5*z1*z3+y4*z2*z3+y5*z2*z3-z1*z2*z3-y4^2*z4-y4*y5*z4-y5^2*z4+y4*z1*z4+y5*z1*z4+
+y4*z2*z4+y5*z2*z4-z1*z2*z4+y4*z3*z4+y5*z3*z4-z1*z3*z4-z2*z3*z4)*QDSx([5, 1, 4, 2, 3], 'y') + (y4^3+
+y4^2*y5+y4*y5^2+y5^3-y4^2*z1-y4*y5*z1-y5^2*z1-y4^2*z2-y4*y5*z2-y5^2*z2+y4*z1*z2+y5*z1*z2-y4^2*z3-
+y4*y5*z3-y5^2*z3+y4*z1*z3+y5*z1*z3+y4*z2*z3+y5*z2*z3-z1*z2*z3-y4^2*z4-y4*y5*z4-y5^2*z4+y4*z1*z4+y5*z1*z4+
+y4*z2*z4+y5*z2*z4-z1*z2*z4+y4*z3*z4+y5*z3*z4-z1*z3*z4-z2*z3*z4)*QDSx([5, 2, 3, 1, 4], 'y') + (q3*y4^2+
+q3*y4*y5+q3*y5^2+q3*y4*y6+q3*y5*y6+q3*y6^2-q3*y4*z1-q3*y5*z1-q3*y6*z1-q3*y4*z2-q3*y5*z2-q3*y6*z2+
+q3*z1*z2-q3*y4*z3-q3*y5*z3-q3*y6*z3+q3*z1*z3+q3*z2*z3-q3*y4*z4-q3*y5*z4-q3*y6*z4+q3*z1*z4+q3*z2*z4+
+q3*z3*z4)*QDSx([6, 1, 2, 3, 4, 5], 'y') + (y1*y4^2+y3*y4^2+y1*y4*y5+y3*y4*y5+y1*y5^2+y3*y5^2+y1*y4*y6+
+y3*y4*y6+y1*y5*y6+y3*y5*y6+y1*y6^2+y3*y6^2-y1*y4*z1-y3*y4*z1-y4^2*z1-y1*y5*z1-y3*y5*z1-y4*y5*z1-y5^2*z1-
+y1*y6*z1-y3*y6*z1-y4*y6*z1-y5*y6*z1-y6^2*z1+y4*z1^2+y5*z1^2+y6*z1^2-y1*y4*z2-y3*y4*z2-y4^2*z2-y1*y5*z2-
+y3*y5*z2-y4*y5*z2-y5^2*z2-y1*y6*z2-y3*y6*z2-y4*y6*z2-y5*y6*z2-y6^2*z2+y1*z1*z2+y3*z1*z2+2*y4*z1*z2+
+2*y5*z1*z2+2*y6*z1*z2-z1^2*z2+y4*z2^2+y5*z2^2+y6*z2^2-z1*z2^2-y1*y4*z3-y3*y4*z3-y1*y5*z3-y3*y5*z3-
+y1*y6*z3-y3*y6*z3+y1*z1*z3+y3*z1*z3+y4*z1*z3+y5*z1*z3+y6*z1*z3-z1^2*z3+y1*z2*z3+y3*z2*z3+y4*z2*z3+
+y5*z2*z3+y6*z2*z3-2*z1*z2*z3-z2^2*z3-y1*y4*z4-y3*y4*z4-y1*y5*z4-y3*y5*z4-y1*y6*z4-y3*y6*z4+y1*z1*z4+
+y3*z1*z4+y4*z1*z4+y5*z1*z4+y6*z1*z4-z1^2*z4+y1*z2*z4+y3*z2*z4+y4*z2*z4+y5*z2*z4+y6*z2*z4-2*z1*z2*z4-
+z2^2*z4+y1*z3*z4+y3*z3*z4-z1*z3*z4-z2*z3*z4)*QDSx([6, 1, 3, 2, 4, 5], 'y') + (y4^2+y4*y5+y5^2+y4*y6+
+y5*y6+y6^2-y4*z1-y5*z1-y6*z1-y4*z2-y5*z2-y6*z2+z1*z2-y4*z3-y5*z3-y6*z3+z1*z3+z2*z3-y4*z4-y5*z4-y6*z4+
+z1*z4+z2*z4+z3*z4)*QDSx([6, 1, 4, 2, 3, 5], 'y') + (y4^2+y4*y5+y5^2+y4*y6+y5*y6+y6^2-y4*z1-y5*z1-y6*z1-
+y4*z2-y5*z2-y6*z2+z1*z2-y4*z3-y5*z3-y6*z3+z1*z3+z2*z3-y4*z4-y5*z4-y6*z4+z1*z4+z2*z4+z3*z4)*QDSx([6, 2, 
+3, 1, 4, 5], 'y') + (q3*y4+q3*y5+q3*y6+q3*y7-q3*z1-q3*z2-q3*z3-q3*z4)*QDSx([7, 1, 2, 3, 4, 5, 6], 'y') + 
+(y1*y4+y3*y4+y1*y5+y3*y5+y1*y6+y3*y6+y1*y7+y3*y7-y1*z1-y3*z1-y4*z1-y5*z1-y6*z1-y7*z1+z1^2-y1*z2-y3*z2-
+y4*z2-y5*z2-y6*z2-y7*z2+2*z1*z2+z2^2-y1*z3-y3*z3+z1*z3+z2*z3-y1*z4-y3*z4+z1*z4+z2*z4)*QDSx([7, 1, 3, 2, 
+4, 5, 6], 'y') + (y4+y5+y6+y7-z1-z2-z3-z4)*QDSx([7, 1, 4, 2, 3, 5, 6], 'y') + (y4+y5+y6+y7-z1-z2-z3-
+z4)*QDSx([7, 2, 3, 1, 4, 5, 6], 'y') + q3*QDSx([8, 1, 2, 3, 4, 5, 6, 7], 'y') + (y1+y3-z1-z2)*QDSx([8, 
+1, 3, 2, 4, 5, 6, 7], 'y') + QDSx([8, 1, 4, 2, 3, 5, 6, 7], 'y') + QDSx([8, 2, 3, 1, 4, 5, 6, 7], 
+'y')
+```
+This output of roughly 17,000 characters took about 2 seconds to compute on my laptop. **Again note that 
+quantum double computations are technically conjectural, but a proof is likely forthcoming.**
+
+
+[Homepage of schubmult](http://schubmult.org/)