Merge branch 'u/mantepse/parent_of_plethysm' of https://github.com/sa…

…gemath/sagetrac-mirror into u/tscrim/parent_plethysm-27652

src/sage/combinat/sf/sfa.py

@@ -3043,21 +3043,21 @@ def plethysm(self, x, include=None, exclude=None):
  sage: Sym = SymmetricFunctions(QQ)
  sage: s = Sym.s()
  sage: h = Sym.h()
- sage: s ( h([3])( h([2]) ) )
+ sage: s(h[3](h[2]))
  s[2, 2, 2] + s[4, 2] + s[6]
  sage: p = Sym.p()
- sage: p([3])( s([2,1]) )
+ sage: p(p[3](s[2,1]))
  1/3*p[3, 3, 3] - 1/3*p[9]
  sage: e = Sym.e()
- sage: e([3])( e([2]) )
+ sage: e[3](e[2])
  e[3, 3] + e[4, 1, 1] - 2*e[4, 2] - e[5, 1] + e[6]
 
  ::
 
  sage: R.<t> = QQ[]
  sage: s = SymmetricFunctions(R).s()
  sage: a = s([3])
- sage: f = t*s([2])
+ sage: f = t * s([2])
  sage: a(f)
  t^3*s[2, 2, 2] + t^3*s[4, 2] + t^3*s[6]
  sage: f(a)
@@ -3142,39 +3142,40 @@ def plethysm(self, x, include=None, exclude=None):
  Check that we can compute the plethysm with a constant::
 
  sage: p[2,2,1](2)
- 8*p[]
+ 8
 
  sage: p[2,2,1](int(2))
- 8*p[]
+ 8
 
  sage: p[2,2,1](a1)
- a1^5*p[]
+ a1^5
 
  sage: X = algebras.Shuffle(QQ, 'ab')
  sage: Y = algebras.Shuffle(QQ, 'bc')
- sage: T = tensor([X,Y])
+ sage: T = tensor([X, Y])
  sage: s = SymmetricFunctions(T).s()
- sage: s(2*T.one())
- (2*B[]#B[])*s[]
+ sage: s[2](5)
+ 15*B[] # B[]
 
  .. TODO::
 
  The implementation of plethysm in
  :class:`sage.data_structures.stream.Stream_plethysm` seems
  to be faster. This should be investigated.
  """
- parent = self.parent()
+ from sage.structure.element import parent as get_parent
+ Px = get_parent(x)
  if not self:
- return self
+ return Px(0)
 
+ parent = self.parent()
  R = parent.base_ring()
  tHA = HopfAlgebrasWithBasis(R).TensorProducts()
- from sage.structure.element import parent as get_parent
- Px = get_parent(x)
  tensorflag = Px in tHA
  if not is_SymmetricFunction(x):
- if Px is R: # Handle stuff that is directly in the base ring
- x = parent(x)
+ if R.has_coerce_map_from(Px) or x in R:
+ x = R(x)
+ Px = R
  elif (not tensorflag or any(not isinstance(factor, SymmetricFunctionAlgebra_generic)
  for factor in Px._sets)):
  from sage.rings.lazy_series import LazySymmetricFunction
@@ -3198,13 +3199,15 @@ def plethysm(self, x, include=None, exclude=None):
 
  if tensorflag:
  tparents = Px._sets
- s = sum(d * prod(sum(_raise_variables(c, r, degree_one)
- * tensor([p[r].plethysm(base(la))
- for base, la in zip(tparents, trm)])
- for trm, c in x)
- for r in mu)
- for mu, d in p(self))
- return tensor([parent]*len(tparents))(s)
+ lincomb = Px.linear_combination
+ elt = lincomb((prod(lincomb((tensor([p[r].plethysm(base(la))
+ for base, la in zip(tparents, trm)]),
+ _raise_variables(c, r, degree_one))
+ for trm, c in x)
+ for r in mu),
+ d)
+ for mu, d in p(self))
+ return Px(elt)
 
  # Takes a symmetric function f, and an n and returns the
  # symmetric function with all of its basis partitions scaled
@@ -3218,7 +3221,11 @@ def pn_pleth(f, n):
  def f(part):
  return p.prod(pn_pleth(p_x.map_coefficients(lambda c: _raise_variables(c, i, degree_one)), i)
  for i in part)
- return parent(p._apply_module_morphism(p(self), f, codomain=p))
+ ret = p._apply_module_morphism(p(self), f, codomain=p)
+ if Px is R:
+ # special case for things in the base ring
+ return next(iter(ret._monomial_coefficients.values()))
+ return Px(ret)
 
  __call__ = plethysm
 
@@ -6202,21 +6209,20 @@ def _nonnegative_coefficients(x):
  return x >= 0
 
 def _variables_recursive(R, include=None, exclude=None):
- """
+ r"""
  Return all variables appearing in the ring ``R``.
 
  INPUT:
 
  - ``R`` -- a :class:`Ring`
- - ``include``, ``exclude`` (optional, default ``None``) --
- iterables of variables in ``R``
+ - ``include``, ``exclude`` -- (optional) iterables of variables in ``R``
 
  OUTPUT:
 
- - If ``include`` is specified, only these variables are returned
-  as elements of ``R``. Otherwise, all variables in ``R``
-  (recursively) with the exception of those in ``exclude`` are
-  returned.
+ If ``include`` is specified, only these variables are returned
+ as elements of ``R``. Otherwise, all variables in ``R``
+ (recursively) with the exception of those in ``exclude`` are
+ returned.
 
  EXAMPLES::
 
@@ -6251,15 +6257,15 @@ def _variables_recursive(R, include=None, exclude=None):
  except AttributeError:
  try:
  degree_one = R.gens()
- except NotImplementedError:
+ except (NotImplementedError, AttributeError):
  degree_one = []
  if exclude is not None:
  degree_one = [g for g in degree_one if g not in exclude]
 
  return [g for g in degree_one if g != R.one()]
 
 def _raise_variables(c, n, variables):
- """
+ r"""
  Replace the given variables in the ring element ``c`` with their
  ``n``-th power.
 
@@ -6276,6 +6282,9 @@ def _raise_variables(c, n, variables):
  sage: S.<t> = R[]
  sage: _raise_variables(2*a + 3*b*t, 2, [a, t])
  3*b*t^2 + 2*a^2
-
  """
- return c.subs(**{str(g): g ** n for g in variables})
+ try:
+ return c.subs(**{str(g): g ** n for g in variables})
+ except AttributeError:
+ return c
+