tutorial-symmetric-functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\def\\CC{\\bf C}\n",
    "\\def\\QQ{\\bf Q}\n",
    "\\def\\RR{\\bf R}\n",
    "\\def\\ZZ{\\bf Z}\n",
    "\\def\\NN{\\bf N}\n",
    "$$\n",
    "# Symmetric Functions Tutorial\n",
    "\n",
    "The aim of this tutorial is to present what it is possible to do in Sage on symmetric functions. We suppose that the reader knows the basics about symmetric functions.\n",
    "\n",
    "**Caveat:** in this tutorial, the term symmetric \"functions\" will mostly stand for \"abstract\" symmetric polynomials, in which variables are not made explicit. Indeed for most practical calculations variables need not appear. Moreover, one may show that this does not cause any trouble in the calculations. $\\def\\QQ{mathbb{QQ}}$\n",
    "\n",
    "*Outputs printed in latex mode*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%display latex           # not tested"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## For the impatient\n",
    "\n",
    "Before going into details with symmetric functions in sage, here is a quick example of what we can do in sage.\n",
    "\n",
    "We recall that the **complete homogeneous** symmetric functions $h_d$ are defined in terms of the **power sum** symmetric functions $p_{\\mu}$ by the formula :\n",
    "\n",
    "$$h_d = \\sum \\limits_{\\mu \\vdash d} \\dfrac{1}{z_{\\mu}} p_{\\mu}$$\n",
    "\n",
    "where $z_\\mu$ is the number of \"automorphisms\" of a permutation having cycle structure $\\mu$.\n",
    "\n",
    "Here is how to obtain both sides of this equality in the ring of symmetric function \"$\\mathrm{Sym}$\" over $\\mathbb{Q}$ :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Defining e as shorthand for Symmetric Functions over Rational Field in the elementary basis\n",
       "Defining f as shorthand for Symmetric Functions over Rational Field in the forgotten basis\n",
       "Defining h as shorthand for Symmetric Functions over Rational Field in the homogeneous basis\n",
       "Defining m as shorthand for Symmetric Functions over Rational Field in the monomial basis\n",
       "Defining p as shorthand for Symmetric Functions over Rational Field in the powersum basis\n",
       "Defining s as shorthand for Symmetric Functions over Rational Field in the Schur basis"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Sym = SymmetricFunctions(QQ)\n",
    "Sym.inject_shorthands()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1/720*p[1, 1, 1, 1, 1, 1] + 1/48*p[2, 1, 1, 1, 1] + 1/16*p[2, 2, 1, 1] + 1/48*p[2, 2, 2] + 1/18*p[3, 1, 1, 1] + 1/6*p[3, 2, 1] + 1/18*p[3, 3] + 1/8*p[4, 1, 1] + 1/8*p[4, 2] + 1/5*p[5, 1] + 1/6*p[6]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p(h[6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1/720*p[1, 1, 1, 1, 1, 1] + 1/48*p[2, 1, 1, 1, 1] + 1/16*p[2, 2, 1, 1] + 1/48*p[2, 2, 2] + 1/18*p[3, 1, 1, 1] + 1/6*p[3, 2, 1] + 1/18*p[3, 3] + 1/8*p[4, 1, 1] + 1/8*p[4, 2] + 1/5*p[5, 1] + 1/6*p[6]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum((1/Partition(i).aut())*p(i) for i in Partitions(6).list())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Abstract symmetric functions\n",
    "\n",
    "We first describe how to manipulate \"variable free\" symmetric functions (with coefficients in the ring of rational coefficient fractions in $q$ and $t$). Such functions are linear combinations of one of the six classical bases of symmetric functions; all indexed by interger partitions $\\mu=\\mu_1\\mu_2\\cdots \\mu_k$.\n",
    "\n",
    "-   The **power sum** symmetric functions $p_\\mu=p_{\\mu_1}p_{\\mu_2}\\cdots p_{\\mu_2}$\n",
    "-   The **(complete) homogeneous** symmetric functions $h_\\mu=h_{\\mu_1}h_{\\mu_2}\\cdots h_{\\mu_2}$\n",
    "-   The **elementary** symmetric functions $e_\\mu=e_{\\mu_1}e_{\\mu_2}\\cdots e_{\\mu_2}$\n",
    "-   The **monomial** functions $m_{\\mu}$\n",
    "-   The **Schur** functions $s{\\mu}$\n",
    "-   The **forgotten** symmetric functions $f_{\\mu}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sage.combinat.q_analogues import *\n",
    "from sage.combinat.sf.sfa import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Defining q, t"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "F = QQ['q','t'].fraction_field()\n",
    "F.inject_variables()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Symqt = SymmetricFunctions(F)\n",
    "Symqt.inject_shorthands(verbose=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ":\n",
    "\n",
    "Another often used coefficient ring is $\\mathbb{Q}(q,t)$. Thus, declaring first this ring (and \"injecting\" variables $q$ and $t$ to make them available), one may introduce the ring of symmetric functions over $\\mathbb{Q}(q,t)$ as follows. The `Symqt.inject_shorthands()` command makes the \"usual\" short names (as in Macdonald book) available (with Sage &lt; 8.0, it will display a warning message you can ignore.). The keyword $verbose$ allows you to make the injection quiet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(h[2, 1], p[2, 1])"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h[2,1],p[2,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(q+t)*s[2, 1, 1]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(q+t)*s[2,1,1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have acces to all the bases we need, we can start to manipulate them. Symmetric functions are indexed by partitions $\\mu$, with integers considered as partitions having size one (don't forget the brackets!):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "s[101, 14, 13, 11]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[101,14,13,11]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "e[3, 2, 1]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e[3,2,1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The ring structure\n",
    "\n",
    "Note that for the multiplicative bases (ie: $e$, $h$ and $p$), products are replaced by the corresponding partition indexed expression:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p([2,1,1])*p([5,2])==p([5,2,2,1,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the non-multiplicative bases, such as the Schur functions, multiplication are expanded as linear combinations in the same (linear) basis:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "s[5, 5, 1, 1, 1] + s[6, 4, 1, 1, 1] + 2*s[6, 5, 1, 1] + s[6, 6, 1] + s[7, 3, 1, 1, 1] + 2*s[7, 4, 1, 1] + s[7, 5, 1] + s[8, 2, 1, 1, 1] + 2*s[8, 3, 1, 1] + s[8, 4, 1] + s[9, 1, 1, 1, 1] + 2*s[9, 2, 1, 1] + s[9, 3, 1] + 2*s[10, 1, 1, 1] + s[10, 2, 1] + s[11, 1, 1]\n"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s([5])^2*s([1,1,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "m[3, 2, 2, 1] + 2*m[3, 3, 2] + m[5, 2, 1] + m[5, 3]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m([3,1])*m([2,2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These calculations are relatively fast as illustrated in the following, showing only the length of the output rather than printing it out in all its glory:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2986"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(s[10,5,5,3]*s[12,5,2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we mix different bases, the result will be expressed in one of the bases, usually the first basis encountered in the expression:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "s[1, 1, 1, 1] - s[2, 1, 1] + s[2, 1, 1, 1] + 2*s[2, 2] + s[2, 2, 1] - s[3, 1] + s[3, 1, 1] + s[3, 2] + s[4]\n"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s([2,1])*m([1,1])+p([2,2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20*m[1, 1, 1, 1, 1] + 9*m[2, 1, 1, 1] + 2*m[2, 2] + 4*m[2, 2, 1] + 2*m[3, 1, 1] + m[3, 2] + m[4]\n"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m([1,1])*s([2,1])+p([2,2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1/6*p[1, 1, 1, 1, 1] - 1/6*p[2, 1, 1, 1] + p[2, 2] - 1/6*p[3, 1, 1] + 1/6*p[3, 2]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p([2,2])+m([1,1])*s([2,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Concrete symmetric functions\n",
    "\n",
    "Our above abstract symmetric functions represent (possibly very large) concrete multivariate polynomials that are invariant upon any permutation of their variables. Simple examples include\n",
    "\n",
    "$$p_k(x_1,x_2,\\ldots, x_n)= x_1^k+x_2^k+\\ldots +x_n^k,\\ (\\hbox{for any } k\\in\\mathbb{N}),\\ {\\rm or}$$\n",
    "\n",
    "$$e_n(x_1,x_2,\\ldots, x_n) = x_1x_2\\cdots x_n.$$\n",
    "\n",
    "To expand a symmetric function into a concrete polynomial in the set of variables $x_0, x_1, \\dots, x_{n-1}$, one proceeds as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "x0^3 + x1^3 + x2^3"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p[3].expand(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "x0^3 + x0^2*x1 + x0*x1^2 + x1^3 + x0^2*x2 + x0*x1*x2 + x1^2*x2 + x0*x2^2 + x1*x2^2 + x2^3"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h[3].expand(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "x0*x1*x2"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e[3].expand(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "x0^3*x1*x2 + x0^2*x1^2*x2 + x0*x1^3*x2 + x0^2*x1*x2^2 + x0*x1^2*x2^2 + x0*x1*x2^3 + x0^3*x1*x3 + x0^2*x1^2*x3 + x0*x1^3*x3 + x0^3*x2*x3 + 3*x0^2*x1*x2*x3 + 3*x0*x1^2*x2*x3 + x1^3*x2*x3 + x0^2*x2^2*x3 + 3*x0*x1*x2^2*x3 + x1^2*x2^2*x3 + x0*x2^3*x3 + x1*x2^3*x3 + x0^2*x1*x3^2 + x0*x1^2*x3^2 + x0^2*x2*x3^2 + 3*x0*x1*x2*x3^2 + x1^2*x2*x3^2 + x0*x2^2*x3^2 + x1*x2^2*x3^2 + x0*x1*x3^3 + x0*x2*x3^3 + x1*x2*x3^3"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[3,1,1].expand(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "x0^3*x1*x2 + x0*x1^3*x2 + x0*x1*x2^3 + x0^3*x1*x3 + x0*x1^3*x3 + x0^3*x2*x3 + x1^3*x2*x3 + x0*x2^3*x3 + x1*x2^3*x3 + x0*x1*x3^3 + x0*x2*x3^3 + x1*x2*x3^3"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m[3,1,1].expand(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3*x0^5 + 2*x0^4*x1 + x0^3*x1^2 + x0^2*x1^3 + 2*x0*x1^4 + 3*x1^5 + 2*x0^4*x2 + x0^3*x1*x2 + x0*x1^3*x2 + 2*x1^4*x2 + x0^3*x2^2 + x1^3*x2^2 + x0^2*x2^3 + x0*x1*x2^3 + x1^2*x2^3 + 2*x0*x2^4 + 2*x1*x2^4 + 3*x2^5 + 2*x0^4*x3 + x0^3*x1*x3 + x0*x1^3*x3 + 2*x1^4*x3 + x0^3*x2*x3 + x1^3*x2*x3 + x0*x2^3*x3 + x1*x2^3*x3 + 2*x2^4*x3 + x0^3*x3^2 + x1^3*x3^2 + x2^3*x3^2 + x0^2*x3^3 + x0*x1*x3^3 + x1^2*x3^3 + x0*x2*x3^3 + x1*x2*x3^3 + x2^2*x3^3 + 2*x0*x3^4 + 2*x1*x3^4 + 2*x2*x3^4 + 3*x3^5"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f[3,1,1].expand(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For sure, one may use any other set of variables via the optional \"alphabet\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "x^2*y + x*y^2 + x^2*z + 2*x*y*z + y^2*z + x*z^2 + y*z^2"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g = s[2,1]\n",
    "g.expand(3, alphabet =['x','y','z'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise**\n",
    "\n",
    "Let $e_k(n) = e_k(x_0,x_1, \\dots , x_{n-1})$ and similarly for the homogeneous functions. Then we have the following recursion relations for $n \\geq 1$ :\n",
    "\n",
    "$$e_k(n) = e_k(n-1) + x_ne_{k-1}(n-1), \\\\\n",
    "h_k(n) = h_k(n-1) + x_nh_{k-1}(n), \\\\\n",
    "e_k(0)=h_k(0) = \\delta_{k,0},$$\n",
    "\n",
    "where $\\delta_{k,0}$ is the Kronecker delta.\n",
    "\n",
    "Check these relations for $k=3$ and $2 \\leq n \\leq 5$.\n",
    "\n",
    "**Solution**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Defining x0, x1, x2, x3, x4"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k=3\n",
    "R = PolynomialRing(QQ,'x',5)\n",
    "R.inject_variables()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0\n",
       "0\n",
       "x0^3 + x0^2*x1 + x0*x1^2 + x1^3\n",
       "x0^3 + x0^2*x1 + x0*x1^2 + x1^3\n",
       "x0*x1*x2\n",
       "x0*x1*x2\n",
       "x0^3 + x0^2*x1 + x0*x1^2 + x1^3 + x0^2*x2 + x0*x1*x2 + x1^2*x2 + x0*x2^2 + x1*x2^2 + x2^3\n",
       "x0^3 + x0^2*x1 + x0*x1^2 + x1^3 + x0^2*x2 + x0*x1*x2 + x1^2*x2 + x0*x2^2 + x1*x2^2 + x2^3\n",
       "x0*x1*x2 + x0*x1*x3 + x0*x2*x3 + x1*x2*x3\n",
       "x0*x1*x2 + x0*x1*x3 + x0*x2*x3 + x1*x2*x3\n",
       "x0^3 + x0^2*x1 + x0*x1^2 + x1^3 + x0^2*x2 + x0*x1*x2 + x1^2*x2 + x0*x2^2 + x1*x2^2 + x2^3 + x0^2*x3 + x0*x1*x3 + x1^2*x3 + x0*x2*x3 + x1*x2*x3 + x2^2*x3 + x0*x3^2 + x1*x3^2 + x2*x3^2 + x3^3\n",
       "x0^3 + x0^2*x1 + x0*x1^2 + x1^3 + x0^2*x2 + x0*x1*x2 + x1^2*x2 + x0*x2^2 + x1*x2^2 + x2^3 + x0^2*x3 + x0*x1*x3 + x1^2*x3 + x0*x2*x3 + x1*x2*x3 + x2^2*x3 + x0*x3^2 + x1*x3^2 + x2*x3^2 + x3^3\n",
       "x0*x1*x2 + x0*x1*x3 + x0*x2*x3 + x1*x2*x3 + x0*x1*x4 + x0*x2*x4 + x1*x2*x4 + x0*x3*x4 + x1*x3*x4 + x2*x3*x4\n",
       "x0*x1*x2 + x0*x1*x3 + x0*x2*x3 + x1*x2*x3 + x0*x1*x4 + x0*x2*x4 + x1*x2*x4 + x0*x3*x4 + x1*x3*x4 + x2*x3*x4\n",
       "x0^3 + x0^2*x1 + x0*x1^2 + x1^3 + x0^2*x2 + x0*x1*x2 + x1^2*x2 + x0*x2^2 + x1*x2^2 + x2^3 + x0^2*x3 + x0*x1*x3 + x1^2*x3 + x0*x2*x3 + x1*x2*x3 + x2^2*x3 + x0*x3^2 + x1*x3^2 + x2*x3^2 + x3^3 + x0^2*x4 + x0*x1*x4 + x1^2*x4 + x0*x2*x4 + x1*x2*x4 + x2^2*x4 + x0*x3*x4 + x1*x3*x4 + x2*x3*x4 + x3^2*x4 + x0*x4^2 + x1*x4^2 + x2*x4^2 + x3*x4^2 + x4^3\n",
       "x0^3 + x0^2*x1 + x0*x1^2 + x1^3 + x0^2*x2 + x0*x1*x2 + x1^2*x2 + x0*x2^2 + x1*x2^2 + x2^3 + x0^2*x3 + x0*x1*x3 + x1^2*x3 + x0*x2*x3 + x1*x2*x3 + x2^2*x3 + x0*x3^2 + x1*x3^2 + x2*x3^2 + x3^3 + x0^2*x4 + x0*x1*x4 + x1^2*x4 + x0*x2*x4 + x1*x2*x4 + x2^2*x4 + x0*x3*x4 + x1*x3*x4 + x2*x3*x4 + x3^2*x4 + x0*x4^2 + x1*x4^2 + x2*x4^2 + x3*x4^2 + x4^3"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = list(R.gens())\n",
    "for xn, n in zip(l[1:], range(2,6)):\n",
    "    f1 = e([k]).expand(n)\n",
    "    print(f1)\n",
    "    f2 = e([k]).expand(n-1,l[:n-1])+xn*(e([k-1]).expand(n-1,l[:n-1]))\n",
    "    print(f2)\n",
    "    g1 = h([k]).expand(n)\n",
    "    print(g1)\n",
    "    g2 = h([k]).expand(n-1,l[:n-1])+xn*(h([k-1]).expand(n,l[:n]))\n",
    "    print(g2)     "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Convert a concrete symmetric polynomial into an abstract symmetric function\n",
    "\n",
    "Conversely, a \"concrete\" symmetric polynomial, i.e.: explicitly expressed in the variables, maybe written as a formal symmetric function in any chosen basis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "x0^2*x1 + x0*x1^2 + x0^2*x2 + 3*x0*x1*x2 + x1^2*x2 + x0*x2^2 + x1*x2^2 + x0^2 + x1^2 + x2^2"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pol1 = (p([2])+e([2,1])).expand(3)\n",
    "pol1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Defining x0, x1, x2"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = 3\n",
    "R = PolynomialRing(FractionField(QQ['q','t']),'x',n)\n",
    "X=R.gens()\n",
    "R.inject_variables()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "x0^4*x1^2 + (-2)*x0^3*x1^3 + x0^2*x1^4 + (-2)*x0^4*x1*x2 + 2*x0^3*x1^2*x2 + 2*x0^2*x1^3*x2 + (-2)*x0*x1^4*x2 + x0^4*x2^2 + 2*x0^3*x1*x2^2 + (-6)*x0^2*x1^2*x2^2 + 2*x0*x1^3*x2^2 + x1^4*x2^2 + (-2)*x0^3*x2^3 + 2*x0^2*x1*x2^3 + 2*x0*x1^2*x2^3 + (-2)*x1^3*x2^3 + x0^2*x2^4 + (-2)*x0*x1*x2^4 + x1^2*x2^4"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Discr=mul(mul((X[k]-X[j])^2 for j in range(k)) for k in range(1,n))\n",
    "Discr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "e[2, 2, 1, 1] - 4*e[2, 2, 2] - 4*e[3, 1, 1, 1] + 18*e[3, 2, 1] - 27*e[3, 3] - 8*e[4, 1, 1] + 24*e[4, 2]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e.from_polynomial(Discr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `pol` input of the function `from_polynomial(pol)` is assumed to lie in a polynomial ring over the same base field as that used for the symmetric functions, which thus has to be delared beforehand."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Defining y0, y1, y2"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = 3\n",
    "R = PolynomialRing(FractionField(QQ['q','t']),'y',n)\n",
    "R.inject_variables()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we will work with three variables ($y_0, y_1$ and $y_2$). Finally, we can declare our polynomial and convert it into a symmetric function in the monomial basis for example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2*m[1, 1, 1] + m[2, 1]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pol2 = y0^2*y1 + y0*y1^2 + y0^2*y2 + 2*y0*y1*y2 + y1^2*y2 + y0*y2^2 + y1*y2^2\n",
    "m.from_polynomial(pol2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the preceeding example, the base ring of polynomials is the same as the base  \n",
    "ring of symmetric polynomials considered, as checked by the following."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(s.base_ring())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(pol2.base_ring())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Thus a concrete symmetric polynomial over $\\mathbb{Q}(q,t)$ may be transformed into an abstract symmetric function in any basis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Defining y0, y1, y2"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "R = PolynomialRing(QQ['q','t'],'y',3)\n",
    "R.inject_variables()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "s[] + (q+t)*s[1, 1] + q*t*s[1, 1, 1]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pol2 = 1+(y0*y1+y0*y2+y1*y2)*(q+t)+(y0*y1*y2)*(q*t)\n",
    "s.from_polynomial(pol2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Changes of bases\n",
    "\n",
    "Many calculations on symmetric functions involve a change of (linear) basis.\n",
    "\n",
    "For example, here we compute $p_{22}+m_{11}s_{21}$ in the elementary basis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "e[1, 1, 1, 1] - 4*e[2, 1, 1] + 4*e[2, 2] + e[2, 2, 1] - e[3, 2]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e(p([2,2])+m([1,1])*s([2,1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise**\n",
    "\n",
    "Print all the Schur functions on partitions of size 5 and convert them into the elementary basis.\n",
    "\n",
    "**Solution**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "s[5]\n",
       "e[1, 1, 1, 1, 1] - 4*e[2, 1, 1, 1] + 3*e[2, 2, 1] + 3*e[3, 1, 1] - 2*e[3, 2] - 2*e[4, 1] + e[5]\n",
       "s[4, 1]\n",
       "e[2, 1, 1, 1] - 2*e[2, 2, 1] - e[3, 1, 1] + 2*e[3, 2] + e[4, 1] - e[5]\n",
       "s[3, 2]\n",
       "e[2, 2, 1] - e[3, 1, 1] - e[3, 2] + e[4, 1]\n",
       "s[3, 1, 1]\n",
       "e[3, 1, 1] - e[3, 2] - e[4, 1] + e[5]\n",
       "s[2, 2, 1]\n",
       "e[3, 2] - e[4, 1]\n",
       "s[2, 1, 1, 1]\n",
       "e[4, 1] - e[5]\n",
       "s[1, 1, 1, 1, 1]\n",
       "e[5]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for mu in Partitions(5):\n",
    "    print(s(mu))\n",
    "    print(e(s(mu)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise**\n",
    "\n",
    "Compute the sum of the homogeneous functions on partitions of size 4 in the power sum basis.\n",
    "\n",
    "**Solution**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "47/24*p[1, 1, 1, 1] + 7/4*p[2, 1, 1] + 3/8*p[2, 2] + 2/3*p[3, 1] + 1/4*p[4]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p(sum(h(mu) for mu in Partitions(4)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise**\n",
    "\n",
    "It is well konwn that $h_n(X) = \\sum \\limits_{\\mu \\vdash n} \\dfrac{p_{\\mu}(x)}{z_{\\mu}}$. Verify this result for $n \\in \\{1,2,3,4\\}$\n",
    "\n",
    "Note that there exists a function `zee()` which takes a partition $\\mu$ and gives back the value of $z_{\\mu}$. To use this function, you should import it from\\* `sage.combinat.sf.sfa`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "64"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sage.combinat.sf.sfa import *\n",
    "zee([4,4,2,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Solution**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True\n",
       "True\n",
       "True\n",
       "True"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for n in range (1,5) :\n",
    "    print(p(h([n])) == sum(p(mu)/zee(mu) for mu in Partitions(n)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ":\n",
    "\n",
    "### Other well-known bases\n",
    "\n",
    "Other important bases are implemented in SAGE.\n",
    "\n",
    "-   The forgotten symmetric functions\n",
    "-   The Hall-littlewood basis\n",
    "-   The Jack basis\n",
    "-   The orthogonal basis\n",
    "-   The symplectic basis\n",
    "-   The Witt basis\n",
    "-   The zonal basis\n",
    "\n",
    "The well known Macdonald symmetric functions are also implemented in sage. For more details, you can consult the following sage reference : <http://doc.sagemath.org/html/en/reference/combinat/sage/combinat/sf/macdonald.html>\n",
    "\n",
    "Here are some examples involving the \"combinatorial\" Macdonald symmetric functions. These are eigenfunctions of the operator $\\nabla$. (See below for more informations about $\\nabla$.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "H = Symqt.macdonald().Ht()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "q*t*s[1, 1, 1] + (q+t)*s[2, 1] + s[3]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s(H([2,1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((-q)/(-q*t^2+t^3+q^2-q*t))*McdHt[1, 1, 1] + ((q^2+q*t+t^2)/(-q^2*t^2+q^3+t^3-q*t))*McdHt[2, 1] + (t/(-q^3+q^2*t+q*t-t^2))*McdHt[3]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H(s[2,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[q^6*McdHt[4],\n",
       " q^3*t*McdHt[3, 1],\n",
       " q^2*t^2*McdHt[2, 2],\n",
       " q*t^3*McdHt[2, 1, 1],\n",
       " t^6*McdHt[1, 1, 1, 1]]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[H(mu).nabla() for mu in Partitions(4)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More basic commands on symmetric functions\n",
    "\n",
    "We can see that the terms of a calculation are always given in a precise order on the partitions. This order can be changed.\n",
    "\n",
    "First, the function `get_print_style()` applied to a basis gives us the order used on the partitions for this basis. Then, with `set_print_style()` we can set another printing order. The possible orders are :\n",
    "\n",
    "-   `lex` : lexicographic order.\n",
    "-   `length` : by length of the partitions, and for partitions of same length by lexicographic order.\n",
    "-   `maximal_part` : by the value of the biggest part of the partition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'lex'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.get_print_style()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-s[1, 1, 1, 1, 1, 1] - s[2, 1, 1, 1, 1] + s[2, 2, 1, 1] + s[2, 2, 2] - s[3, 3] - s[4, 2] + s[5, 1] + s[6]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.set_print_style('lex')\n",
    "s(p[4,1,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "s[6] - s[3, 3] - s[4, 2] + s[5, 1] + s[2, 2, 2] + s[2, 2, 1, 1] - s[2, 1, 1, 1, 1] - s[1, 1, 1, 1, 1, 1]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.set_print_style('length')\n",
    "s(p[4,1,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'length'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.get_print_style()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-s[1, 1, 1, 1, 1, 1] + s[2, 2, 2] - s[2, 1, 1, 1, 1] + s[2, 2, 1, 1] - s[3, 3] - s[4, 2] + s[5, 1] + s[6]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.set_print_style('maximal_part')\n",
    "s(p[4,1,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function `coefficient()` returns the coefficient associated to a given partition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "e[4, 3, 1, 1, 1] - 2*e[4, 3, 2, 1] + e[4, 3, 3] - e[4, 4, 1, 1] + e[4, 4, 2] - e[5, 2, 1, 1, 1] + 2*e[5, 2, 2, 1] - e[5, 3, 2] + e[5, 4, 1] + e[6, 2, 1, 1] - e[6, 2, 2] - e[6, 4] - e[7, 2, 1] + e[8, 2]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = s[5,2,2,1]\n",
    "e(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-2"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e(f).coefficient([4,3,2,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function `degree()` gives the degree of a symmetric function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.degree()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, the function `support()` returns the list of partitions that appear in a given symmetric function. The result will depend on the basis of the function. In the following example, we also use the function `sorted()` to get an ordered list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[5, 2, 2, 1]]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(f.support())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[5, 2, 2, 1], [5, 3, 1, 1], [5, 3, 2], [5, 4, 1], [6, 2, 1, 1], [6, 3, 1], [6, 4], [7, 1, 1, 1], [7, 2, 1], [8, 1, 1], [8, 2]]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(sorted(h(f).support()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The omega involution\n",
    "\n",
    "The $\\omega$ involution is the linear extension of the map which sends $e_\\lambda$ to $h_{\\lambda}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "s[2, 2] + s[3, 1] + s[4]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = s[2]^2; f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "h[2, 2]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "e[2, 2]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e(f.omega())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(s[5], s[1, 1, 1, 1, 1]),\n",
       " (s[4, 1], s[2, 1, 1, 1]),\n",
       " (s[3, 2], s[2, 2, 1]),\n",
       " (s[3, 1, 1], s[3, 1, 1]),\n",
       " (s[2, 2, 1], s[3, 2]),\n",
       " (s[2, 1, 1, 1], s[4, 1]),\n",
       " (s[1, 1, 1, 1, 1], s[5])]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[(s(mu),s(mu).omega()) for mu in Partitions(5)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ":\n",
    "\n",
    "## Scalar Products\n",
    "\n",
    "The Hall scalar product is the standard scalar product on the algebra of symmetric functions. It makes the Schur functions into an orthonormal basis. The value of the scalar product between $p_{\\mu}$ and $p_{\\lambda}$ is given by $z_{\\mu}$ if $\\mu = \\lambda$ or zero otherwise. In formula,\n",
    "\n",
    "$$\\langle p_\\mu,p_\\lambda\\rangle = z_\\mu\\,\\delta_{\\mu,\\lambda}$$\n",
    "\n",
    "Or, yet again, we have\n",
    "\n",
    "$$\\left(\\langle p_\\mu,p_\\lambda/z_\\lambda\\rangle\\right)_{\\mu,\\lambda}= {\\rm Id}_{n\\times n}$$\n",
    "\n",
    "Thus, we get"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p([2,2,1]).scalar(p([2,2,1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1 0 0 0 0 0 0]\n",
       "[0 1 0 0 0 0 0]\n",
       "[0 0 1 0 0 0 0]\n",
       "[0 0 0 1 0 0 0]\n",
       "[0 0 0 0 1 0 0]\n",
       "[0 0 0 0 0 1 0]\n",
       "[0 0 0 0 0 0 1]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Matrix([[p(mu).scalar(p(nu)/zee(mu)) for nu in Partitions(5)] for mu in Partitions(5)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Other scalar products, such as the $q,t$-scalar product\n",
    "\n",
    "One may specify an optional argument which is a function on partitions giving the value for the scalar product between $p_{\\mu}$ and $p_{\\mu}$. Power sums remain orthogonal for the resulting scalar product. By default, this value is $z_{\\mu}$, but other interesting cases include:\n",
    "\n",
    "$$\\langle p_{\\mu},p_{\\mu}\\rangle_{q,t} = z_\\mu\\,\\prod_i\\frac{1-q^{\\mu_i}}{1-t^{\\mu_i}}.$$\n",
    "\n",
    "This is already refined as $scalar_qt()$ :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[                            (-q^3 + 1)/(-t^3 + 1)                                                 0                                                 0]\n",
       "[                                                0           (q^3 - q^2 - q + 1)/(t^3 - t^2 - t + 1)                                                 0]\n",
       "[                                                0                                                 0 (-q^3 + 3*q^2 - 3*q + 1)/(-t^3 + 3*t^2 - 3*t + 1)]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Matrix([[p(mu).scalar_qt(p(nu)/zee(mu)) for nu in Partitions(3)] for mu in Partitions(3)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Schur Positivity\n",
    "\n",
    "When computing with symmetric functions, one often wants to check a given symmetric function is Schur positive or not. In our current setup, this means that coefficients polynomials in $\\mathbb{N}[q,t]$. The following function returns `True` if the given symmetric function is Schur positive and `False` if not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = s([4,1])+s([3,2])\n",
    "print(f.is_schur_positive())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g = s([4,1])-s([3,2])\n",
    "print(g.is_schur_positive())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example, we can verify the well-known Schur positivity of product of Schur  \n",
    "functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "The product of  s[2]  and  s[3]  is Schur positive.\n",
       "The product of  s[2]  and  s[2, 1]  is Schur positive.\n",
       "The product of  s[2]  and  s[1, 1, 1]  is Schur positive.\n",
       "The product of  s[1, 1]  and  s[3]  is Schur positive.\n",
       "The product of  s[1, 1]  and  s[2, 1]  is Schur positive.\n",
       "The product of  s[1, 1]  and  s[1, 1, 1]  is Schur positive."
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for mu in Partitions(2) :\n",
    "    for nu in Partitions(3) :\n",
    "        if (s(mu)*s(nu)).is_schur_positive() :\n",
    "            print('The product of ', s(mu),' and ',s(nu),' is Schur positive.')\n",
    "        else :\n",
    "            print('The product of ', s(mu),' and ',s(nu),'is not Schur positive.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise**\n",
    "\n",
    "Its representation theoretic signification implies that $\\nabla (e_n)$ is Schur positive. Verify this for $1 \\leq n \\leq 6$.\n",
    "\n",
    "**Solution**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True\n",
       "True\n",
       "True\n",
       "True\n",
       "True\n",
       "True"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for n in range(1,7) :\n",
    "    print(e([n]).nabla().is_schur_positive())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Schur positivity is a rare phenomena in general, but symmetric functions that come from representation theory are Schur positive. One can show that the probability that a degree $n$ monomial positive is Schur positive is equal to\n",
    "\n",
    "$$\\prod_{\\mu\\vdash n}\\frac{1}{k_\\mu},\\qquad {\\rm where}\\qquad k_\\mu:=\\sum_{\\nu\\vdash n} K_{\\mu,\\nu},$$\n",
    "\n",
    "with $K_{\\mu,\\nu}$ the **Kostka numbers**. Recall that these occur in the expansion of the Schur functions in terms of the monomial functions:\n",
    "\n",
    "$$s_\\mu=\\sum_\\nu K_{\\mu,\\nu}\\, m_\\nu.$$\n",
    "\n",
    "For instance, we have"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5*m[1, 1, 1, 1, 1] + 3*m[2, 1, 1, 1] + 2*m[2, 2, 1] + m[3, 1, 1] + m[3, 2]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m(s[3,2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "hence defining"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def K(mu,nu):\n",
    "    return s(mu).scalar(h(nu))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "so that the above expression is indeed seen to be"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5*m[1, 1, 1, 1, 1] + 3*m[2, 1, 1, 1] + 2*m[2, 2, 1] + m[3, 1, 1] + m[3, 2]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add(K([3,2],nu)*m(nu) for nu in Partitions(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def k(mu):\n",
    "    n=add(j for j in mu)\n",
    "    return add(K(mu,nu) for nu in Partitions(n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "so that the above probability is calculated by the function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prob_Schur_positive(n): return 1/mul(k(mu) for mu in Partitions(n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One can then illustrate how very rare Schur-positivity is, as a function of the degree:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1/2, 1/9, 1/560, 1/480480, 1/1027458432000, 1/2465474364698304960000]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[prob_Schur_positive(n) for n in range(1,8)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plethysm\n",
    "\n",
    "As its name strongly suggests, the `plethysm()` function computes the **plethysm** $f\\circ g$, of two symmetric functions $f$ and $g$. Recall that this is the operation characterized by the properties - $(f_1+f_2)\\circ g =(f_1\\circ g)+(f_2\\circ g)$, - $(f_1\\cdot f_2)\\circ g =(f_1\\circ g)\\cdot (f_2\\circ g)$, - $p_k\\circ(g_1+g_2) =(p_k\\circ g_1)+(p_k\\circ g_2)$, - $p_k\\circ (g_1\\cdot g_2) =(p_k\\circ g_1)+(p_k\\circ g_2)$, - $p_k\\circ p_n =p_{kn}$, - $p_k\\circ x =x^k$, if $x$ is a **variable** - $p_k\\circ c =c$, if $c$ is a **constant**\n",
    "\n",
    "One may specify a list of SAGE-variables to be treated as **variables** in a plethysm, using the option `include=[x1,x2,...,xk]`, and/or a list of SAGE-variables to be considered as **constants**, using the option `exclude=[c1,c2,...,ck]`. Here are some examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1/36*p[3, 3, 3, 3, 2, 2, 2, 2] + 1/12*p[4, 3, 3, 3, 3, 2, 2] + 1/12*p[6, 3, 3, 2, 2, 2, 2] + 1/18*p[6, 3, 3, 3, 3, 2] + 1/4*p[6, 4, 3, 3, 2, 2] + 1/6*p[6, 6, 3, 3, 2] + 1/18*p[9, 3, 2, 2, 2, 2] + 1/6*p[9, 4, 3, 2, 2] + 1/9*p[9, 6, 3, 2]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p([3,2]).plethysm(h([3,1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "p[2] + 1/3*t^2*p[2, 2, 2] + (-1/3*t^2)*p[6]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g = p([1]) + t*s([2,1])\n",
    "p([2]).plethysm(g,include=[t])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "p[2] + 1/3*t*p[2, 2, 2] + (-1/3*t)*p[6]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p([2]).plethysm(g,exclude=[t])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is costumary to also write $f[g]$ for $f\\circ g$ in mathematical texts, but SAGE uses the shorthand notation $f(g)$ for better compatibility with python. For instance, the plethysm $s_4\\circ s_2$, may also be computed as"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "s[2, 2, 2, 2] + s[4, 2, 2] + s[4, 4] + s[6, 2] + s[8]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[4](s[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To have nice expressions for plethystic substitutions, one may set aliases for the symmetric function on the empty partition (i.e. $s_0, m_0, \\dots$, all equal to the constant 1), and the symmetric function (unique up to a scalar) of degree 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "One = s([])\n",
    "X = s[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(q^12+q^11+2*q^10+3*q^9+4*q^8+4*q^7+5*q^6+4*q^5+4*q^4+3*q^3+2*q^2+q+1)*s[]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[3](s[4](One*(1+q)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One should compare this with"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "q^12 + q^11 + 2*q^10 + 3*q^9 + 4*q^8 + 4*q^7 + 5*q^6 + 4*q^5 + 4*q^4 + 3*q^3 + 2*q^2 + q + 1"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q_binomial(7,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "q^2*s[2, 2] + (q^3+q^2+q)*s[3, 1] + (q^4+q^3+q^2+q+1)*s[4]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[4](X*(1+q))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((q-1)^-4*(q+1)^-2*q^6*(q^2+1)^-1*(q^2+q+1)^-1)*s[1, 1, 1, 1] + ((q-1)^-4*(q+1)^-2*q^2*(q^2+q+1)^-1)*s[2, 2] + ((q-1)^-4*(q+1)^-2*q^3*(q^2+1)^-1)*s[2, 1, 1] + ((q-1)^-4*(q+1)^-2*q*(q^2+1)^-1)*s[3, 1] + ((q-1)^-4*(q+1)^-2*(q^2+1)^-1*(q^2+q+1)^-1)*s[4]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[4](X/(1-q)).map_coefficients(factor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "s[4, 4, 4] + s[6, 4, 2] + s[7, 4, 1] + s[8, 2, 2] + s[9, 3]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[3](s[4])-s[2](s[6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suggests that we have the following positive coefficient polynomial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "q^9 + q^8 + q^7 + q^6 + q^5 + q^4 + q^3"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q_binomial(7,3)-q_binomial(8,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Some interesting operators on symmetric functions\n",
    "\n",
    "Operators on symmetric functions may be found in SAGE. Among these, the **nabla operator** is characterized as having the combinatorial Macdonald symmetric functions $H_{\\mu}=H_{\\mu}(\\mathbf{x};q,t)$ as eigenfunctions:\n",
    "\n",
    "$$\\nabla H_{\\mu} = t^{n(\\mu)} q^{n(\\mu')} H_{\\mu},$$\n",
    "\n",
    "where $\\mu$ is a partition, $\\mu'$ its conjugate, and $n(\\mu)$ is set to be equal to $\\sum_i (i-1)\\mu_i$. This operator $\\nabla$ is thus defined over symmetric functions with coefficients in the fraction field $\\mathbb{Q}[q,t]$, as is declared above.\n",
    "\n",
    "It has been shown by Haiman that $\\nabla(e_n)$ is the Frobenius transform of the bigraded character of the $\\mathbb{S}_n$-module of diagonal harmonic polynomials. Recall that the Frobernius transform encodes irreducible as Schur functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(q^3+q^2*t+q*t^2+t^3+q*t)*s[1, 1, 1] + (q^2+q*t+t^2+q+t)*s[2, 1] + s[3]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s(e[3].nabla())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The global dimension of this module is $(n+1)^{n-1}$, and the dimension of its alternating component (see exercise below) is the Catalan number $C_n=\\frac{1}{n+1}\\binom{2n}{n}$. And there are many other interesting properties of the bigraded version."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "q^3 + q^2*t + q*t^2 + t^3 + 2*q^2 + 3*q*t + 2*t^2 + 2*q + 2*t + 1"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Hilb_qt=s(e[3].nabla()).scalar(p[1]^3); Hilb_qt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Hilb_qt.substitute({q:1,t:1})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are also interesting conjectures on the effect of $\\nabla$ on Schur functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(q^6*t^3+q^5*t^4+q^4*t^5+q^3*t^6)*s[1, 1, 1, 1, 1] + (q^5*t^2+2*q^4*t^3+2*q^3*t^4+q^2*t^5)*s[2, 2, 1] + (q^6*t^2+2*q^5*t^3+2*q^4*t^4+2*q^3*t^5+q^2*t^6+q^4*t^3+q^3*t^4)*s[2, 1, 1, 1] + (q^4*t^2+q^3*t^3+q^2*t^4)*s[3, 2] + (q^5*t^2+q^4*t^3+q^3*t^4+q^2*t^5+q^4*t^2+2*q^3*t^3+q^2*t^4)*s[3, 1, 1] + (q^3*t^2+q^2*t^3)*s[4, 1]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(-s([2,2,1])).nabla()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise**\n",
    "\n",
    "We have the following relation between $\\nabla (e_n)$ and the q,t-Catalan numbers :\n",
    "\n",
    "$$C_n(q,t) = \\langle \\nabla e_n , e_n \\rangle.$$\n",
    "\n",
    "Check this relation for $1 \\leq n \\leq 5$\n",
    "\n",
    "*Note that the n-th q,t-Catalan number can be computed by using the command `qt_catalan_number(n)` which has to be imported from* `sage.combinat.q_analogues` if it hasn't already been done\\*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 1)\n",
       "(2, q + t)\n",
       "(3, q^3 + q^2*t + q*t^2 + t^3 + q*t)\n",
       "(4, q^6 + q^5*t + q^4*t^2 + q^3*t^3 + q^2*t^4 + q*t^5 + t^6 + q^4*t + q^3*t^2 + q^2*t^3 + q*t^4 + q^3*t + q^2*t^2 + q*t^3)\n",
       "(5, q^10 + q^9*t + q^8*t^2 + q^7*t^3 + q^6*t^4 + q^5*t^5 + q^4*t^6 + q^3*t^7 + q^2*t^8 + q*t^9 + t^10 + q^8*t + q^7*t^2 + q^6*t^3 + q^5*t^4 + q^4*t^5 + q^3*t^6 + q^2*t^7 + q*t^8 + q^7*t + 2*q^6*t^2 + 2*q^5*t^3 + 2*q^4*t^4 + 2*q^3*t^5 + 2*q^2*t^6 + q*t^7 + q^6*t + q^5*t^2 + 2*q^4*t^3 + 2*q^3*t^4 + q^2*t^5 + q*t^6 + q^4*t^2 + q^3*t^3 + q^2*t^4)"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sage.combinat.q_analogues import *\n",
    "for n in range (1,6) :\n",
    "    print((n,qt_catalan_number(n)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 1)\n",
       "(2, 2)\n",
       "(3, 5)\n",
       "(4, 14)\n",
       "(5, 42)"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for n in range (1,6) :\n",
    "    print((n,e([n]).nabla().scalar(e([n])).substitute({q:1,t:1})))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 1)\n",
       "(2, q^-1 * (q^2 + 1))\n",
       "(3, q^-3 * (q^2 - q + 1) * (q^4 + q^3 + q^2 + q + 1))\n",
       "(4, q^-6 * (q^2 - q + 1) * (q^4 + 1) * (q^6 + q^5 + q^4 + q^3 + q^2 + q + 1))\n",
       "(5, q^-10 * (q^4 + 1) * (q^4 - q^3 + q^2 - q + 1) * (q^6 + q^3 + 1) * (q^6 + q^5 + q^4 + q^3 + q^2 + q + 1))"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for n in range (1,6) :\n",
    "    print((n,factor(e([n]).nabla().scalar(e([n])).substitute({t:1/q}))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Solution**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True\n",
       "True\n",
       "True\n",
       "True\n",
       "True"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for n in range (1,6) :\n",
    "    print(e([n]).nabla().scalar(e([n])) == qt_catalan_number(n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## $k$-Schur functions\n",
    "\n",
    "The $k$-Schur functions live in the $k$-bounded subspace of the ring of symmetric functions. It is possible to compute in the $k$-bounded subspace directly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ks3[2, 2, 1, 1] + ks3[2, 2, 2] + ks3[3, 1, 1, 1]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Sym = SymmetricFunctions(QQ)\n",
    "ks = Sym.kschur(3,1)\n",
    "f = ks[2,1]*ks[2,1] \n",
    "print(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or to lift to the ring of symmetric functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "s[2, 2, 1, 1] + s[2, 2, 2] + s[3, 1, 1, 1] + 2*s[3, 2, 1] + s[3, 3] + s[4, 1, 1] + s[4, 2]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.lift()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, it is not always possible to convert a symmetric function to the $k$-bounded subspace:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ks3[2, 1]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = Sym.schur()\n",
    "ks(s[2,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The $k$-Schur functions are more generally defined with a parameter $t$ and they are a basis of the subspace spanned by the Hall-Littlewood $Qp$ symmetric functions indexed by partitions whose first part is less than or equal to $k$ :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ks3[2, 1, 1, 1] + (t^2+t)*ks3[2, 2, 1] + (t^3+t^2)*ks3[3, 1, 1] + t^4*ks3[3, 2]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Sym = SymmetricFunctions(QQ['t'].fraction_field())\n",
    "SymS3 = Sym.kBoundedSubspace(3) # default t='t'\n",
    "ks = SymS3.kschur()\n",
    "Qp = Sym.hall_littlewood().Qp()\n",
    "print(ks(Qp[2,1,1,1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The subspace spanned by the $k$-Schur functions with a parameter $t$ are not known to form a natural algebra. However it is known that the product of a $k$-Schur function and an $\\ell$-Schur function is in the linear span of the $k+\\ell$-Schur functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "s[2, 1, 1, 1] + s[2, 2, 1] + s[3, 1, 1] + s[3, 2]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ks(ks[2,1]*ks[1,1]) # not tested\n",
    "ks[2,1]*ks[1,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ks6[3, 3, 1, 1] + ks6[4, 2, 1, 1] + (t+1)*ks6[4, 3, 1] + t*ks6[4, 4]\n",
       "+ ks6[5, 1, 1, 1] + ks6[5, 2, 1] + t*ks6[5, 3] + ks6[6, 1, 1]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ks6 = Sym.kBoundedSubspace(6).kschur()\n",
    "print(ks6(ks[3,1,1]*ks[3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The $k$-split basis is a second basis of the ring spanned by the $k$-Schur functions with a parameter $t$. The $k$-split basis has the property that $Q'_\\lambda[X;t]$ expands positively in the $k$-split basis and the $k$-split basis conjecturally expands positively in the $k$-Schur functions.:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ksp3[2, 1, 1, 1] + t^2*ksp3[2, 2, 1] + (t^3+t^2)*ksp3[3, 1, 1] + t^4*ksp3[3, 2]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ksp3 = SymS3.ksplit()\n",
    "print(ksp3(Qp[2,1,1,1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ks3[2, 2, 1], ks3[2, 1, 1, 1] + t*ks3[2, 2, 1], ks3[3, 2], ks3[3, 1, 1]]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print([ks(ksp3(la)) for la in ksp3(Qp[2,1,1,1]).support()])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dual $k$-Schur functions\n",
    "\n",
    "The dual space to the subspace spanned by the $k$-Schur functions is most naturally realized as a quotient of the ring of symmetric functions by an ideal. When $t=1$ the ideal is generated by the monomial symmetric functions indexed by partitions whose first part is greater than $k$ :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4*m3[2, 2, 1, 1] + 6*m3[2, 2, 2] + 2*m3[3, 2, 1] + 2*m3[3, 3]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Sym = SymmetricFunctions(QQ)\n",
    "SymQ3 = Sym.kBoundedQuotient(3,t=1)\n",
    "km = SymQ3.kmonomial()\n",
    "print(km[2,1]*km[2,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2*F3[1, 1, 1, 1, 1, 1] + 4*F3[2, 1, 1, 1, 1] + 4*F3[2, 2, 1, 1] + 4*F3[2, 2, 2]\n",
       "+ 2*F3[3, 1, 1, 1] + 4*F3[3, 2, 1] + 2*F3[3, 3]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "F = SymQ3.affineSchur()\n",
    "print(F[2,1]*F[2,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When $t$ is not equal to $1$, the subspace spanned by the $k$-Schur functions is realized as a quotient of the ring of symmetric functions by the ideal generated by the Hall-Littlewood symmetric functions in the P basis indexed by partitions with first part greater than $k$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(t^2+2*t+1)*HLP3[2, 2, 1, 1] + (t^3+2*t^2+2*t+1)*HLP3[2, 2, 2]\n",
       "+ (-t^4-t^3+t+1)*HLP3[3, 1, 1, 1] + (-t^2+t+2)*HLP3[3, 2, 1] + (t+1)*HLP3[3, 3]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Sym = SymmetricFunctions(FractionField(QQ['t']))\n",
    "SymQ3 = Sym.kBoundedQuotient(3)\n",
    "kHLP = SymQ3.kHallLittlewoodP()\n",
    "print(kHLP[2,1]*kHLP[2,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "HLP3[3, 1]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "HLP = Sym.hall_littlewood().P()\n",
    "print(kHLP(HLP[3,1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kHLP(HLP[4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this space, the basis which is dual to the $k$-Schur functions conjecturally expands positively in the $k$-bounded Hall-Littlewood functions and has positive structure coefficients."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(t^4+t^2)*HLP3[1, 1, 1, 1] + t*HLP3[2, 1, 1] + HLP3[2, 2]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dks = SymQ3.dual_k_Schur()\n",
    "print(kHLP(dks[2,2]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(t^2+t)*dks3[1, 1, 1, 1, 1] + (t+1)*dks3[2, 1, 1, 1] + (t+1)*dks3[2, 2, 1]\n",
       "+ dks3[3, 1, 1] + dks3[3, 2]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(dks[2,1]*dks[1,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At $t=1$ the $k$-bounded Hall-Littlewood basis is equal to the $k$-bounded monomial basis and the dual $k$-Schur elements are equal to the affine Schur basis. The $k$-bounded monomial basis and affine Schur functions are faster and should be used instead of the $k$-bounded Hall-Littlewood P basis and dual $k$-Schur functions when $t=1$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SymQ3 = Sym.kBoundedQuotient(3,t=1)\n",
    "dks = SymQ3.dual_k_Schur()\n",
    "F = SymQ3.affineSchur()\n",
    "F[3,1]==dks[3,1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Representation theory of the symmetric group\n",
    "\n",
    "The Schur functions $s_\\lambda$ can also be interpreted as irreducible characters  \n",
    "of the symmetric group $S_n$, where $n$ is the size of the partition $\\lambda$. Since the Schur functions of degree $n$ form a basis of the symmetric functions of degree $n$, it follows that an arbitrary symmetric function (homogeneous of degree $n$) may be interpreted as a function on the symmetric group. In this interpretation the power sum symmetric function $p_\\lambda$ is the characteristic function of the conjugacy class with shape $\\lambda$, multiplied by the order of the centralizer of an element. Hence the irreducible characters can be computed as follows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 1 -1  1  1 -1 -1  1]\n",
       "[ 4 -2  0  1  1  0 -1]\n",
       "[ 5 -1  1 -1 -1  1  0]\n",
       "[ 6  0 -2  0  0  0  1]\n",
       "[ 5  1  1 -1  1 -1  0]\n",
       "[ 4  2  0  1 -1  0 -1]\n",
       "[ 1  1  1  1  1  1  1]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = Matrix([[s[mu.conjugate()].scalar(p[nu.conjugate()]) for nu in Partitions(5)] for mu in Partitions(5)])\n",
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can indeed check that this agrees with the character table of $S_5$, modulo our reordering by"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SymmetricGroup(5).character_table() == M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Inner plethysm\n",
    "\n",
    "The operation of inner plethysm `f.inner_plethysm(g)` models the composition of the $S_n$ representation represented by $g$ with the $GL_m$ representation whose character is $f$. See the documentation of `inner_plethysm`, for more information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "s[2]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g = s[2]^2\n",
    "g.inner_plethysm(s[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[                                  s[4]          s[2, 1, 1] + 2*s[3, 1] + s[4]         s[1, 1, 1, 1] + s[2, 2] + s[4] s[1, 1, 1, 1] + 2*s[2, 1, 1] + s[3, 1]                          s[1, 1, 1, 1]]\n",
       "[                                     0         s[2, 1, 1] + s[2, 2] + s[3, 1]                                s[2, 2]         s[2, 1, 1] + s[2, 2] + s[3, 1]                                      0]\n",
       "[                                     0                          s[1, 1, 1, 1]                                      0                                   s[4]                                      0]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Matrix([[s(mu).inner_plethysm(s(nu)) for nu in Partitions(4)] for mu in Partitions(3)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More specific applications\n",
    "\n",
    "The first part of this tutorial was meant to present general use of symmetric functions in Sage. Here are now more specific applications.\n",
    "\n",
    "Sage knows certain categorical information about this algebra."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Join of Category of hopf algebras over Fraction Field of Univariate Polynomial Ring in t over Rational Field\n",
       "    and Category of graded algebras over Fraction Field of Univariate Polynomial Ring in t over Rational Field\n",
       "    and Category of monoids with realizations\n",
       "    and Category of coalgebras over Fraction Field of Univariate Polynomial Ring in t over Rational Field with realizations"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Sym.category()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us explore the other operations of $p$. We can ask for the mathematical properties of $p$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Category of graded bases of Symmetric Functions over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field,\n",
       " Category of filtered bases of Symmetric Functions over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field,\n",
       " Category of bases of Symmetric Functions over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field,\n",
       " Category of graded hopf algebras with basis over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field,\n",
       " Category of filtered hopf algebras with basis over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field,\n",
       " Category of hopf algebras with basis over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field,\n",
       " Category of realizations of hopf algebras over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field,\n",
       " Category of hopf algebras over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field,\n",
       " Category of graded algebras with basis over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field,\n",
       " Category of filtered algebras with basis over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field,\n",
       " Category of bialgebras with basis over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field,\n",
       " Category of algebras with basis over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field,\n",
       " Category of graded algebras over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field,\n",
       " Category of commutative algebras over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field,\n",
       " Category of filtered algebras over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field,\n",
       " Category of bialgebras over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field,\n",
       " Category of algebras over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field,\n",
       " Category of commutative rings,\n",
       " Category of rings,\n",
       " Category of associative algebras over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field,\n",
       " Category of rngs,\n",
       " Category of semirings,\n",
       " Category of associative additive commutative additive associative additive unital distributive magmas and additive magmas,\n",
       " Category of unital algebras with basis over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field,\n",
       " Category of magmatic algebras with basis over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field,\n",
       " Category of unital algebras over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field,\n",
       " Category of magmatic algebras over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field,\n",
       " Category of additive commutative additive associative additive unital distributive magmas and additive magmas,\n",
       " Category of additive commutative additive associative distributive magmas and additive magmas,\n",
       " Category of additive associative distributive magmas and additive magmas,\n",
       " Category of distributive magmas and additive magmas,\n",
       " Category of magmas and additive magmas,\n",
       " Category of commutative monoids,\n",
       " Category of monoids,\n",
       " Category of semigroups,\n",
       " Category of realizations of unital magmas,\n",
       " Category of realizations of magmas,\n",
       " Category of commutative magmas,\n",
       " Category of unital magmas,\n",
       " Category of magmas,\n",
       " Category of graded modules with basis over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field,\n",
       " Category of filtered modules with basis over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field,\n",
       " Category of coalgebras with basis over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field,\n",
       " Category of vector spaces with basis over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field,\n",
       " Category of modules with basis over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field,\n",
       " Category of graded modules over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field,\n",
       " Category of realizations of coalgebras over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field,\n",
       " Category of filtered modules over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field,\n",
       " Category of coalgebras over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field,\n",
       " Category of vector spaces over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field,\n",
       " Category of modules over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field,\n",
       " Category of bimodules over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field on the left and Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field on the right,\n",
       " Category of right modules over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field,\n",
       " Category of left modules over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field,\n",
       " Category of commutative additive groups,\n",
       " Category of additive groups,\n",
       " Category of additive inverse additive unital additive magmas,\n",
       " Category of commutative additive monoids,\n",
       " Category of additive monoids,\n",
       " Category of additive unital additive magmas,\n",
       " Category of commutative additive semigroups,\n",
       " Category of additive commutative additive magmas,\n",
       " Category of additive semigroups,\n",
       " Category of additive magmas,\n",
       " Category of realizations of Symmetric Functions over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field,\n",
       " Category of realizations of sets,\n",
       " Category of sets,\n",
       " Category of sets with partial maps,\n",
       " Category of objects]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p.categories()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To start with, $p$ is a graded algebra, the grading being induced by the size of the partitions. Due to this, the one is the basis element indexed by the empty partition:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "p[]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p.one()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note also that it is a good idea to use:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "s[]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.one()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.zero()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "instead of $s(1)$ and $s(0)$ within programs where speed is important, in order to prevent unnecessary coercions.\n",
    "\n",
    "## Hopf structure and important identities\n",
    "\n",
    "Many important identities between symmetric functions can be linked to \"the\" Hopf algebra structure on the ring of symmetric function. In part, this means that we have a **coproduct** on symmetric functions that may be described in either of the two forms:\n",
    "\n",
    "$$\\Delta(g) = \\sum_{k+j=n}\\sum_{\\mu\\vdash k,\\ \\nu\\vdash j} a_{\\mu,\\nu}\\, s_\\mu\\otimes s_\\nu$$\n",
    "\n",
    "$$g(\\mathbf{x}+\\mathbf{y})= \\sum_{k+j=n}\\sum_{\\mu\\vdash k,\\ \\nu\\vdash j} a_{\\mu,\\nu}\\, s_\\mu(\\mathbf{x}) s_\\nu(\\mathbf{y})$$\n",
    "\n",
    "For instance, we have :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "One=s[0]\n",
    "X=s[1]\n",
    "Y=tensor([X,One])\n",
    "Z=tensor([One,X])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "s[] # s[3] + s[1] # s[2] + s[2] # s[1] + s[3] # s[]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[3](Y+Z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "s[] # s[3, 2, 1] + s[1] # s[2, 2, 1] + s[1] # s[3, 1, 1] + s[1] # s[3, 2] + s[1, 1] # s[2, 1, 1] + s[1, 1] # s[2, 2] + s[1, 1] # s[3, 1] + s[1, 1, 1] # s[2, 1] + s[2] # s[2, 1, 1] + s[2] # s[2, 2] + s[2] # s[3, 1] + s[2, 1] # s[1, 1, 1] + 2*s[2, 1] # s[2, 1] + s[2, 1] # s[3] + s[2, 1, 1] # s[1, 1] + s[2, 1, 1] # s[2] + s[2, 2] # s[1, 1] + s[2, 2] # s[2] + s[2, 2, 1] # s[1] + s[3] # s[2, 1] + s[3, 1] # s[1, 1] + s[3, 1] # s[2] + s[3, 1, 1] # s[1] + s[3, 2] # s[1] + s[3, 2, 1] # s[]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[3,2,1].coproduct()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "s[] # s[3, 2, 1] + s[1] # s[2, 2, 1] + s[1] # s[3, 1, 1] + s[1] # s[3, 2] + s[1, 1] # s[2, 1, 1] + s[1, 1] # s[2, 2] + s[1, 1] # s[3, 1] + s[1, 1, 1] # s[2, 1] + s[2] # s[2, 1, 1] + s[2] # s[2, 2] + s[2] # s[3, 1] + s[2, 1] # s[1, 1, 1] + 2*s[2, 1] # s[2, 1] + s[2, 1] # s[3] + s[2, 1, 1] # s[1, 1] + s[2, 1, 1] # s[2] + s[2, 2] # s[1, 1] + s[2, 2] # s[2] + s[2, 2, 1] # s[1] + s[3] # s[2, 1] + s[3, 1] # s[1, 1] + s[3, 1] # s[2] + s[3, 1, 1] # s[1] + s[3, 2] # s[1] + s[3, 2, 1] # s[]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[3,2,1](Y+Z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Skew Schur fonctions\n",
    "\n",
    "arise when one considers the effect of coproduct on Schur functions themselves\n",
    "\n",
    "$$\\Delta(s_\\lambda) = \\sum_{\\mu\\subseteq \\lambda} s_{\\lambda/\\mu}\\otimes s_\\mu.$$\n",
    "\n",
    "Skew Schur functions are also implemented in SAGE. For instance, we have the skew Schur $s_{321/2}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Sym = SymmetricFunctions(QQ)\n",
    "Sym.inject_shorthands(verbose=false)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "s[2, 1, 1] + s[2, 2] + s[3, 1]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[3,2,1].skew_by(s[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Thus we get the same result as above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "s[] # s[3, 2, 1] + s[1] # s[2, 2, 1] + s[1] # s[3, 1, 1] + s[1] # s[3, 2] + s[1, 1] # s[2, 1, 1] + s[1, 1] # s[2, 2] + s[1, 1] # s[3, 1] + s[1, 1, 1] # s[2, 1] + s[2] # s[2, 1, 1] + s[2] # s[2, 2] + s[2] # s[3, 1] + s[2, 1] # s[1, 1, 1] + 2*s[2, 1] # s[2, 1] + s[2, 1] # s[3] + s[2, 1, 1] # s[1, 1] + s[2, 1, 1] # s[2] + s[2, 2] # s[1, 1] + s[2, 2] # s[2] + s[2, 2, 1] # s[1] + s[3] # s[2, 1] + s[3, 1] # s[1, 1] + s[3, 1] # s[2] + s[3, 1, 1] # s[1] + s[3, 2] # s[1] + s[3, 2, 1] # s[]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add(tensor([s[3,2,1].skew_by(s(mu)),s(mu)]) for k in range(7) for mu in Partitions(k))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In particular, we get\n",
    "\n",
    "$$\\Delta(h_n) = \\sum_{k+j=n} h_k\\otimes h_j.$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "h[] # h[4] + h[1] # h[3] + h[2] # h[2] + h[3] # h[1] + h[4] # h[]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h[4].coproduct()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "h[] # h[4] + h[1] # h[3] + h[2] # h[2] + h[3] # h[1] + h[4] # h[]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h[4](Y+Z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "h[] # e[4] - h[1] # e[3] + h[2] # e[2] - h[3] # e[1] + h[4] # e[]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tensor([h,e])(h[4](Y-Z))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "s[] # s[2, 1, 1] - s[1] # s[1, 1, 1] - s[1] # s[2, 1] + s[1, 1] # s[1, 1] + s[2] # s[1, 1] + s[2] # s[2] - s[2, 1] # s[1] - s[3] # s[1] + s[3, 1] # s[]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[3,1](Y-Z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cauchy kernel formula\n",
    "\n",
    "The Cauchy kernel is the expression\n",
    "\n",
    "$$\\sum_{n\\geq 0} h_n(\\mathbf{x}\\mathbf{y})=\\prod_{i,j}\\frac{1}{1-x_iy_j}$$\n",
    "\n",
    "written here using plethystic notation. Its degree $n$ homogeneous component plays a crucial role in the description of \"dual bases\" with respect to the scalar product. We have\n",
    "\n",
    "$$h_n(\\mathbf{x}\\mathbf{y})=\\sum_{\\mu\\vdash n} F_\\mu\\otimes G_\\mu\n",
    " \\qquad {\\rm iff}\\qquad\n",
    " \\langle F_\\mu,G_\\lambda\\rangle=\\delta_{\\mu\\lambda}, \\qquad\n",
    " (\\delta_{\\mu \\lambda}:\\ \\hbox{Kronecker \"delta\"})`$$\n",
    "\n",
    "where one \"thinks\" $\\mathbf{x}=s_1\\otimes \\mathbb{1}$ and  \n",
    "$\\mathbf{y}= \\mathbb{1}\\otimes s_1$. One says that $\\{F_\\mu\\}_\\mu$ and $\\{G_\\lambda\\}_\\lambda$ are **dual bases**. Schur functions are self dual, the dual of the $h_{\\mu}$ are the $m_\\mu$, that of the $p_\\mu$ are the $p_{\\mu}/z_{\\mu}$. The \"forgotten\" symmetric function $f_{\\mu}$ appear as the dual of the $e_{\\mu}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "s[1, 1, 1, 1] # s[1, 1, 1, 1] + s[2, 1, 1] # s[2, 1, 1] + s[2, 2] # s[2, 2] + s[3, 1] # s[3, 1] + s[4] # s[4]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h4xy=add(tensor([s(mu),s(mu)]) for mu in Partitions(4)); h4xy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "s[1, 1, 1, 1] # s[1, 1, 1, 1] + s[2, 1, 1] # s[2, 1, 1] + s[2, 2] # s[2, 2] + s[3, 1] # s[3, 1] + s[4] # s[4]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[4](Y*Z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "h[1, 1, 1, 1] # m[1, 1, 1, 1] + h[2, 1, 1] # m[2, 1, 1] + h[2, 2] # m[2, 2] + h[3, 1] # m[3, 1] + h[4] # m[4]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tensor([h,m])(h4xy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "e[1, 1, 1, 1] # h[4] + e[2, 1, 1] # h[3, 1] - 4*e[2, 1, 1] # h[4] + e[2, 2] # h[2, 2] - 2*e[2, 2] # h[3, 1] + 2*e[2, 2] # h[4] + e[3, 1] # h[2, 1, 1] - 2*e[3, 1] # h[2, 2] - e[3, 1] # h[3, 1] + 4*e[3, 1] # h[4] + e[4] # h[1, 1, 1, 1] - 4*e[4] # h[2, 1, 1] + 2*e[4] # h[2, 2] + 4*e[4] # h[3, 1] - 4*e[4] # h[4]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tensor([e,h])(h4xy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1/24*p[1, 1, 1, 1] # p[1, 1, 1, 1] + 1/4*p[2, 1, 1] # p[2, 1, 1] + 1/8*p[2, 2] # p[2, 2] + 1/3*p[3, 1] # p[3, 1] + 1/4*p[4] # p[4]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tensor([p,p])(h4xy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The coproduct, being cocommutative on the generators, is cocommutative everywhere:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "p[] # p[2, 1] + p[1] # p[2] + p[2] # p[1] + p[2, 1] # p[]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p[2, 1].coproduct()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This coproduct, along with the counit which sends every symmetric function to its 0-th homogeneous component, makes the ring of symmetric functions into a graded connected bialgebra. It is known that every graded connected bialgebra has an antipode. For the ring of symmetric functions, the antipode can be characterized explicitly: The antipode is an anti-algebra morphism (thus an algebra morphism, since our algebra is commutative) which sends $p_{\\lambda}$ to $(-1)^{\\mathrm{length}(\\lambda)} p_{\\lambda}$ for every partition $\\lambda$. Thus, in particular, it sends the generators on the $p$ basis to their opposites:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-p[3]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p[3].antipode()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-p[3]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p[3](-X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-s[5, 1, 1]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[3,1,1,1,1].antipode()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-s[5, 1, 1]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[3,1,1,1,1](-X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The graded connected bialgebra of symmetric functions over a $\\mathbb{Q}$-algebra has a rather simply-understood structure: It is (isomorphic to) the symmetric algebra of its space of primitives (which is spanned by the power-sum symmetric functions).\n",
    "\n",
    "Here are further examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "s[1, 1, 1, 1] + s[2, 1, 1] + s[2, 2]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g = s[2]^2\n",
    "g.antipode()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "s[] # s[2, 2] + s[] # s[3, 1] + s[] # s[4] + 2*s[1] # s[2, 1] + 2*s[1] # s[3] + s[1, 1] # s[1, 1] + s[1, 1] # s[2] + s[2] # s[1, 1] + 3*s[2] # s[2] + 2*s[2, 1] # s[1] + s[2, 2] # s[] + 2*s[3] # s[1] + s[3, 1] # s[] + s[4] # s[]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.coproduct()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.coproduct().apply_multilinear_morphism( lambda x,y: x*y.antipode() )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this interpretation of symmetric functions as characters on the symmetric group, the multiplication and comultiplication are interpreted as induction (from $S_n\\times S_m$ to $S_{n+m}$) and restriction, respectively. The Schur functions can also be interpreted as characters of $GL_n$.\n",
    "\n",
    "## The Kronecker product\n",
    "\n",
    "As in the section on the **Representation theory of the symmetric group**, a symmetric function may be considered as a class function on the symmetric group where the elements $p_\\mu/z_\\mu$ are the indicators of a permutation having cycle structure $\\mu$. The Kronecker product of two symmetric functions corresponds to the pointwise product of these class functions.\n",
    "\n",
    "Since the Schur functions are the irreducible characters of the symmetric group under this identification, the Kronecker product of two Schur functions corresponds to the internal tensor product of two irreducible symmetric group representations.\n",
    "\n",
    "Under this identification, the Kronecker product of $p_\\mu/z_\\mu$ and $p_\\nu/z_\\nu$ is $p_\\mu/z_\\mu$ if $\\mu=\\nu$, and the result is equal to $0$ otherwise.\n",
    "\n",
    "`internal_product`, `kronecker_product`, `inner_tensor` and `itensor` are different names for the same function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "s[2, 2] + s[3, 1] + s[4]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "s[1, 1, 1, 1] + 3*s[2, 1, 1] + 4*s[2, 2] + 5*s[3, 1] + 3*s[4]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.kronecker_product(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "s[2, 2] + s[3, 1] + s[4]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.kronecker_product(s[4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "s[1, 1, 1, 1] + s[2, 1, 1] + s[2, 2]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.kronecker_product(e[4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "s[1, 1, 1, 1] + s[2, 1, 1] + s[2, 2]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.omega()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[            p[5]                0                0                0                0                0                0]\n",
       "[               0          p[4, 1]                0                0                0                0                0]\n",
       "[               0                0          p[3, 2]                0                0                0                0]\n",
       "[               0                0                0       p[3, 1, 1]                0                0                0]\n",
       "[               0                0                0                0       p[2, 2, 1]                0                0]\n",
       "[               0                0                0                0                0    p[2, 1, 1, 1]                0]\n",
       "[               0                0                0                0                0                0 p[1, 1, 1, 1, 1]]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Matrix([[p(mu).kronecker_product(p(nu)/zee(nu)) for nu in Partitions(5)] for mu in Partitions(5)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Implementing new bases\n",
    "\n",
    "In order to implement a new symmetric function basis, Sage will need to know at a minimum how to change back and forth between at least one other basis (although they do not necessarily have to be the same basis). All of the standard functions associated with the basis will have a default implementation (although a more specific implementation may be more efficient).\n",
    "\n",
    "To present an idea of how this is done, we will create here the example of how to implement the basis $s_\\mu[X(1-t)]$.\n",
    "\n",
    "To begin, we import the class sage.combinat.sf.sfa.SymmetricFunctionAlgebra\\_generic(). Our new basis will inherit all of the default methods from this class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sage.combinat.sf.sfa import SymmetricFunctionAlgebra_generic as SFA_generic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now the basis we are creating has a parameter $t$ which is possible to specialize. In this example we will convert to and from the Schur basis. For this we implement methods `_self_to_s` and `_s_to_self`. By registering these two functions as coercions, Sage then knows automatically how it possible to change between any two bases for which there is a path of changes of bases."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sage.categories.morphism import SetMorphism\n",
    "class SFA_st(SFA_generic):\n",
    "    def __init__(self, Sym, t):\n",
    "        SFA_generic.__init__(self, Sym, basis_name=\n",
    "          \"Schur functions with a plethystic substitution of X -> X(1-t)\",\n",
    "          prefix='st')\n",
    "        self._s = Sym.s()\n",
    "        self.t = Sym.base_ring()(t)\n",
    "        cat = HopfAlgebras(Sym.base_ring()).WithBasis()\n",
    "        self.register_coercion(\n",
    "          SetMorphism(Hom(self._s, self, cat), self._s_to_self))\n",
    "        self._s.register_coercion(\n",
    "          SetMorphism(Hom(self, self._s, cat), self._self_to_s))\n",
    "    def _s_to_self(self, f):\n",
    "        # f is a Schur function and the output is in the st basis\n",
    "        return self._from_dict(f.theta_qt(0,self.t)._monomial_coefficients)\n",
    "    def _self_to_s(self, f):\n",
    "        # f is in the st basis and the output is in the Schur basis\n",
    "        return self._s.sum(cmu*self._s(mu).theta_qt(self.t,0) for mu,cmu in f)\n",
    "    class Element(SFA_generic.Element):\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An instance of this basis is created by calling it with a symmetric function ring `Sym` and a parameter `t` which is in the base ring of `Sym`. The `Element` class inherits all of the methods from sage.combinat.sf.sfa.SymmetricFunctionAlgebra\\_generic\\_Element.\n",
    "\n",
    "In Macdonald's work, this basis is denoted $S_\\lambda(x;t)$ and the change of basis coefficients of the Macdonald `J` basis are the coefficients $K_{\\lambda\\mu}(q,t)$. Here is an example of its use:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Symmetric Functions over Fraction Field of Multivariate Polynomial\n",
       " Ring in q, t over Rational Field in the Schur functions with a\n",
       " plethystic substitution of X -> X(1-t) basis"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "QQqt = QQ['q','t'].fraction_field()\n",
    "(q,t) = QQqt.gens()\n",
    "st = SFA_st(SymmetricFunctions(QQqt),t)\n",
    "st"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "st[2, 1, 1] + st[2, 2] + st[3, 1]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "st[2,1] * st[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       " st[] # st[2] + st[1] # st[1] + st[2] # st[]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "st([2]).coproduct()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "q*st[1, 1, 1] + (q*t+1)*st[2, 1] + t*st[3]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "J = st.symmetric_function_ring().macdonald().J()\n",
    "st(J[2,1])"
   ]
  }
 ],
 "metadata": {},
 "nbformat": 4,
 "nbformat_minor": 2
}