More Schubert polynomial shenanigans

[darijgr]

Title stolen from Stanley, but this is, alas, a bug, not a determinant conjecture:

sage: X = SchubertPolynomialRing(ZZ)
sage: X([]).expand()
1
sage: X([1]).expand()
1
sage: X([]) == X([1])
False

Normally, X(perm) reduces the permutation perm by removing all fixed points attached to its right end (i.e., if a permutation in S_n sends n to n, then it reduces it to a permutation in S_{n-1} and so on, until this reduction is no longer possible). And rightfully so, since the Schubert basis is indexed by reduced permutations.

sage: X = SchubertPolynomialRing(ZZ)
sage: X([1])
X[1]
sage: X([1,2])
X[1]
sage: X([1,2,3])
X[1]

However, it fails to reduce [1] to [] due to the behavior of Permutation.remove_extra_fixed_points.

Can we just fix it, or does symmetrica break on contact with the empty list? In the latter case, should we reduce [] to [1] instead?

Related: #23403.

CC: @tscrim @sagetrac-sage-combinat @anneschilling @VivianePons

Component: combinatorics

Keywords: schubert, polynomials, divided differences

Author: Darij Grinberg

Branch/Commit: 94d9d75

Reviewer: Travis Scrimshaw

Issue created by migration from https://trac.sagemath.org/ticket/23443

[tscrim]

comment:2

I've updated the ticket description to better describe where the error is coming from (rather than the symptom).

There does seem to be some issue with symmetrica and empty lists:

sage: X([]) * X([1])
function: copy code: 4294967295 
python: : Numerical argument out of domain
sage: X([]) * X([])
function: copy code: 4294967295 
python: : Numerical argument out of domain

More shenanigans:

sage: it = iter(X.basis())
sage: [it.next() for _ in range(10)]
[X[],
 X[1],
 X[1, 2],
 X[2, 1],
 X[1, 2, 3],
 X[1, 3, 2],
 X[2, 1, 3],
 X[2, 3, 1],
 X[3, 1, 2],
 X[3, 2, 1]]

So one of the definite problems is that the indexing set could be considered too big. However, we could also consider X as a tower of polynomial rings, so it would make sense to distinguish X[1, 2] from X[1], etc. by considering each within a homogeneous component with a fixed number of variables.

[tscrim]

Description changed:

--- 
+++ 
@@ -10,7 +10,18 @@
 False
 ```
 
-Normally, `X(perm)` reduces the permutation `perm` by removing all fixed points attached to its right end (i.e., if a permutation in `S_n` sends `n` to `n`, then it reduces it to a permutation in `S_{n-1}` and so on, until this reduction is no longer possible). And rightfully so, since the Schubert basis is indexed by reduced permutations. However, it fails to reduce `[1]` to `[]`.
+Normally, `X(perm)` reduces the permutation `perm` by removing all fixed points attached to its right end (i.e., if a permutation in `S_n` sends `n` to `n`, then it reduces it to a permutation in `S_{n-1}` and so on, until this reduction is no longer possible). And rightfully so, since the Schubert basis is indexed by reduced permutations.
+
+```
+sage: X = SchubertPolynomialRing(ZZ)
+sage: X([1])
+X[1]
+sage: X([1,2])
+X[1]
+sage: X([1,2,3])
+X[1]
+```
+However, it fails to reduce `[1]` to `[]` due to the behavior of `Permutation.remove_extra_fixed_points`.
 
 Can we just fix it, or does symmetrica break on contact with the empty list? In the latter case, should we reduce `[]` to `[1]` instead?
 

[darijgr]

comment:3

The way I understand Schubert polynomials, you either deal with them in a fixed number of indeterminates (in which case the basis is indexed by S_n), or in infinitely many indeterminates (in which case the basis is indexed by S_0 \cup S_1 \cup S_2 \cup ..., and this is an increasing union, not a disjoint union -- i.e., we identify permutations that only differ in trailing fixed points). I have never seen a situation where Schubert polynomials have a basis indexed by the disjoint union S_0 \sqcup S_1 \sqcup S_2 \sqcup ...; they are not the Malvenuto-Reutenauer Hopf algebra. So I think the basis method is wrong here.

[tscrim]

comment:4

By doing the tower approach, you can get a little bit of both worlds: you are considering a fixed number of variables that you can arbitrarily move between different rings (i.e., you do not have to deal with coercions between different parents). I do not have any preference on what approach is taken; I am just stating how I understand the code.

However, there are some large inconsistencies between the code parts (and possibly the doc). Those do need to be fixed. We might just be better off changing the entire class to perhaps do some slight adjustments to the permutations when sending them back and forth with symmetrica.

[darijgr]

Attachment: schubert-1.diff.gz

Fixing X([]) misbehaving and X([1]).expand() not properly coercing

[darijgr]

comment:5

The attached schubert-1.diff file (I can't push for some stupid security reasons) fixes two basic bugs: the X([]) shenanigans (it's X([1]) now) and the problems stemming from X([1]).expand() landing in Z[x] instead of Z[x0] (which led to the product X([1]).expand() * X([1,2]).expand() being undefined).

The basis() method still needs to be fixed.

[tscrim]

Branch: public/combinat/schubert_shenanigans-23443

[tscrim]

Reviewer: Travis Scrimshaw

[tscrim]

comment:6

Is there anything else that is needed for this ticket? If not, then you can set a positive review if I have applied your patch correctly.

---

New commits:

379fc13

Applying Darij's patch to better normalize permutations for Schubert polynomials.

[tscrim]

Commit: 379fc13

[tscrim]

Author: Darij Grinberg