FUNCTION: SfDualBasis - addition of a new basis, dual to an existing one

CALLING SEQUENCE:

SfDualBasis(b, old)

SfDualBasis(b, old, scal)

SYMF[SfDualBasis](b, old)

SYMF[SfDualBasis](b, old, scal)

PARAMETERS:

b = any name

old = any name of a previously defined basis

scal = any procedure accepting a partition as input

SYNOPSIS:

• The function part -> scal(part) choosen by the user defines a scalar product <,> on symmetric functions for which power sums are orthogonal, and such that <p[part], p[part]> = scal(part). The usual scalar product SfScalar corresponds to scal(part)=SfZee(part) and is choosen by default.

• Given any existing linear basis old[part] of the space of symmetric functions, there exists a unique dual basis b[part] relative to <,>, i.e. such that <b[part],old[part2]> = 1 for part=part2, and 0 otherwise. The old basis can be of the type multiplicative (like 'h','e','p') or indexed (as 's', 'm', or any other new defined basis). For example, the monomial symmetric functions m[part] are dual (with respect to the standard scalar product) to the h-basis (products of complete symmetric functions).

• The new basis b is added to the list of bases and will be recognized in any expression; a new procedure Tob is available, with the same syntax as for instance Tom, Tos, and is devoted to express any symmetric function in the b-basis.

• It has also the effect to define a Isb function that tests whether an expression is an element of the b-basis.

• The result is the current set of known bases.

• An error is produced if 'b' is the name of a previously defined basis, or old is unknown.

• Whenever there is a conflict between the function name SfDualBasis and another name used in the same session, use the long form SYMF['SfDualBasis'].

EXAMPLES:

> with(SYMF):
> NewZee:=proc(part) SfZee(part, 0, t) end:  # Hall-Littlewood polynomials
> SfDualBasis(MS, 's', NewZee);        # basis of modified Schur functions
 
                             {p, s, e, h, m, c, MS}
 
> Tos(MS[3], 'collect');
 
                                  2                3    2
           (1 - t) s[3] + (- t + t ) s[2, 1] + (- t  + t ) s[1, 1, 1]
 
> Tos(SfTheta(s[3], t, 0), 'collect');
 
                                  2                3    2
           (1 - t) s[3] + (- t + t ) s[2, 1] + (- t  + t ) s[1, 1, 1]
 
> ToMS(MS[2]*s[2], 'collect');
 
                 MS[4]          (2 + t) MS[3, 1]     (t + 3) MS[2, 2]
          ------------------ + ------------------ + ------------------
                   2                    2                    2
          (- 1 + t)  (t + 1)   (- 1 + t)  (t + 1)   (- 1 + t)  (t + 1)
 
                 (4 + 3 t) MS[2, 1, 1]     MS[1, 1, 1, 1]
               + --------------------- + 6 --------------
                            2                         2
                   (- 1 + t)  (t + 1)        (- 1 + t)
 
> SfMat(4, 'MS', 'm');
 
                               [ 1  1  1  1  1 ]
                               [               ]
                               [ 0  1  1  2  3 ]
                               [               ]
                               [ 0  0  1  1  2 ]
                               [               ]
                               [ 0  0  0  1  3 ]
                               [               ]
                               [ 0  0  0  0  1 ]