TokuyamaExpression.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NOTE: Run the following installation cell and restart the notebook if you haven't run it already."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING: The easy_install command is deprecated and will be removed in a future version.\r\n",
      "Searching for pandas\r\n",
      "Best match: pandas 1.3.0\r\n",
      "Processing pandas-1.3.0-py3.9-macosx-10.9-x86_64.egg\r\n",
      "pandas 1.3.0 is already the active version in easy-install.pth\r\n",
      "\r\n",
      "Using /Applications/SageMath/local/lib/python3.9/site-packages/pandas-1.3.0-py3.9-macosx-10.9-x86_64.egg\r\n",
      "Processing dependencies for pandas\r\n",
      "Finished processing dependencies for pandas\r\n"
     ]
    }
   ],
   "source": [
    "!easy_install pandas # TODO: make explicit note about this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sage.combinat.gelfand_tsetlin_patterns import GelfandTsetlinPattern\n",
    "import itertools\n",
    "import numpy as np\n",
    "import collections\n",
    "import pandas as pd\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_dominant(row):\n",
    "    return len(row) == len(list(set(row)))\n",
    "\n",
    "\n",
    "def get_all_possible_next_rows(row, include_non_strict=False): # TODO: include_non_strict\n",
    "    l = list(itertools.product(*[list(range(left_el, row[i+1]-1, -1)) for i, left_el in enumerate(row[:-1])]))\n",
    "    l = [el for el in l if is_dominant(el)]\n",
    "    return l\n",
    "\n",
    "\n",
    "def row_pair_is_legal(upper_row, lower_row):\n",
    "    assert len(upper_row) > 0\n",
    "    assert len(lower_row) > 0\n",
    "    \n",
    "    for i, left_upper_el in enumerate(upper_row[:-1]):\n",
    "        right_upper_el = upper_row[i+1]\n",
    "        lower_el = lower_row[i]\n",
    "        if not ((lower_el <= left_upper_el) and (lower_el >= right_upper_el)):\n",
    "            return False\n",
    "    \n",
    "    return True\n",
    "\n",
    "\n",
    "def pattern_is_legal(pattern): \n",
    "    top_row_length = len(pattern[0])\n",
    "    for i, row in enumerate(pattern):\n",
    "        if not len(row) == top_row_length - i:\n",
    "            return False\n",
    "        \n",
    "    return all([row_pair_is_legal(upper_row, pattern[i+1]) for i, upper_row in enumerate(pattern[:-1])])\n",
    "\n",
    "\n",
    "def get_all_patterns_from_top_row(top_row):\n",
    "    \n",
    "    def recurse(pattern_so_far):\n",
    "        assert type(pattern_so_far) == list\n",
    "        lowest_row_so_far = pattern_so_far[-1]\n",
    "        assert len(lowest_row_so_far) > 0\n",
    "\n",
    "        if len(lowest_row_so_far) == 1:\n",
    "            if pattern_is_legal(pattern_so_far):\n",
    "                return [pattern_so_far]\n",
    "            else:\n",
    "                return []\n",
    "\n",
    "        results = []\n",
    "        for new_row in get_all_possible_next_rows(lowest_row_so_far):\n",
    "            results += recurse(pattern_so_far + [list(new_row)])\n",
    "\n",
    "        return results\n",
    "\n",
    "    assert len(top_row) > 0\n",
    "    assert top_row == sorted(top_row, reverse=True)\n",
    "    \n",
    "    if len(top_row) == 1:\n",
    "        return [top_row]\n",
    "                    \n",
    "    return reversed(recurse([top_row]))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_tokuyama_formula(lam, variables, ice='gamma', verbose=False):\n",
    "    n = len(lam)\n",
    "    top_row = [lam[i] + (n - (i+1)) for i in range(n)]\n",
    "    \n",
    "    if n == 1:\n",
    "        return SR.symbol(f'{variables[-1]}')^top_row[0] \n",
    "\n",
    "    patterns = get_all_patterns_from_top_row(top_row=top_row)\n",
    "\n",
    "    formula = 0\n",
    "    for pattern in patterns:\n",
    "        g = GelfandTsetlinPattern(pattern)\n",
    "        \n",
    "        if not g.is_strict():\n",
    "            continue\n",
    "\n",
    "        if verbose:\n",
    "            g.pp()\n",
    "\n",
    "        term = 1\n",
    "\n",
    "        t = SR.symbol('t')\n",
    "        term *= (t+1)^(len(g.special_entries()))\n",
    "        \n",
    "        if ice == 'gamma':\n",
    "            term *= t^len(g.boxed_entries())\n",
    "        elif ice == 'delta':\n",
    "            term *= t^len(g.circled_entries())\n",
    "        else:\n",
    "            raise Exception('') # TODO\n",
    "            \n",
    "        d_list = g.row_sums() + [0]\n",
    "        d_exponents = [d - d_list[i+1] for i, d in enumerate(d_list[:-1])]\n",
    "        if ice == 'gamma': \n",
    "            d_exponents = list(reversed(d_exponents))\n",
    "        \n",
    "        for i, d_exp in enumerate(d_exponents):\n",
    "            term *= SR.symbol(variables[i])^(d_exp)\n",
    "\n",
    "        if verbose:\n",
    "            print(f\"Term: {term}\")\n",
    "\n",
    "        formula += term\n",
    "\n",
    "        if verbose:\n",
    "            print(\"=\"*40)\n",
    "            \n",
    "    return formula\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_num_left(lam, mu):\n",
    "    assert len(lam) == len(mu) + 1\n",
    "    \n",
    "    return sum([1 if lam[i] == mu[i] else 0 for i in range(len(mu))])\n",
    "\n",
    "def get_num_right(lam, mu):\n",
    "    assert len(lam) == len(mu) + 1\n",
    "    \n",
    "    return sum([1 if lam[i+1] == mu[i] else 0 for i in range(len(mu))])\n",
    "\n",
    "def get_num_generic(lam, mu):\n",
    "    assert len(lam) == len(mu) + 1\n",
    "    \n",
    "    return sum([1 if lam[i] > mu[i] and lam[i+1] < mu[i] else 0 for i in range(len(mu))])    \n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def branching_term(lam, mu, var, param, ice='gamma'):\n",
    "    term = 1\n",
    "\n",
    "    param_symbol = SR.symbol(param)\n",
    "    term *= (param_symbol+1)^get_num_generic(lam, mu)\n",
    "\n",
    "    if ice == 'gamma':\n",
    "        term *= param_symbol^get_num_left(lam, mu)\n",
    "    elif ice == 'delta':\n",
    "        term *= param_symbol^get_num_right(lam, mu)\n",
    "    else:\n",
    "        raise Exception('') #TODO\n",
    "\n",
    "    d_exp = sum(lam) - sum(mu)\n",
    "    term *= SR.symbol(var)^(d_exp)\n",
    "    \n",
    "    return term\n",
    "\n",
    "\n",
    "def swf(lam, variables, parameters, ice='gamma', verbose=False):\n",
    "    assert len(lam) == len(variables)\n",
    "    \n",
    "    n = len(lam)\n",
    "    rho = [n - (i+1) for i in range(n)]\n",
    "    top_row = [lam[i] + r for i, r in enumerate(rho)]\n",
    "    \n",
    "    if len(variables) == 1:\n",
    "        return SR.symbol(variables[0])^lam[0]\n",
    "\n",
    "    total = 0\n",
    "    next_rows = get_all_possible_next_rows(top_row)\n",
    "    for next_row in next_rows:        \n",
    "        if verbose:\n",
    "            print(f\"Top row: {top_row}\")\n",
    "            print(f\"Next row: {next_row}\")\n",
    "\n",
    "        if ice == 'gamma':\n",
    "            new_variables = variables[:-1]\n",
    "            new_parameters = parameters[:-1]\n",
    "        elif ice == 'delta':\n",
    "            new_variables = variables[1:]\n",
    "            new_parameters = parameters[1:]\n",
    "        \n",
    "        branch = swf(np.array(next_row) - np.array(rho[1:]), new_variables, new_parameters, ice=ice, verbose=verbose)\n",
    "        \n",
    "        if ice == 'gamma':\n",
    "            branching_var = variables[-1]\n",
    "            branching_param = parameters[-1]\n",
    "        elif ice == 'delta':\n",
    "            branching_var = variables[0]\n",
    "            branching_param = parameters[0]\n",
    "        term = branching_term(top_row, next_row, branching_var, branching_param, ice)\n",
    "        \n",
    "        total += (term*branch)\n",
    "\n",
    "        if verbose:\n",
    "            print(f\"Term: {term}\")\n",
    "            print(f\"Branch: {branch.simplify().factor()}\")\n",
    "\n",
    "        if verbose:\n",
    "            print(\"=\"*40)\n",
    "            \n",
    "    return total\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_table(lam):\n",
    "    \n",
    "    n = len(lam)\n",
    "    rho = [n - (i+1) for i in range(n)]\n",
    "    top_row = [lam[i] + r for i, r in enumerate(rho)]\n",
    "    \n",
    "    variables = [f'z_{i}' for i in range(1, n+1, 1)]\n",
    "    parameters = [f't_{i}' for i in range(1, n+1, 1)]\n",
    "    \n",
    "    next_rows = get_all_possible_next_rows(top_row)\n",
    "    d = collections.defaultdict(list)\n",
    "    for mu in next_rows:        \n",
    "        shifted_mu = np.array(mu) - np.array(rho[1:])\n",
    "        contribution_gamma = branching_term(top_row, shifted_mu, f'z_{n}', f't_{n}', ice='gamma')\n",
    "        contribution_delta = branching_term(top_row, shifted_mu, 'z_1', 't_1', ice='delta')\n",
    "        \n",
    "        branch_gamma = swf(mu, variables[:-1], parameters[:-1], ice='gamma')\n",
    "        branch_delta = swf(mu, variables[1:], parameters[1:], ice='delta')\n",
    "        \n",
    "        d['mu'].append(mu)\n",
    "        d['gamma_contribution'].append(contribution_gamma)\n",
    "        d['gamma_branch'].append(branch_gamma)\n",
    "        d['delta_contribution'].append(contribution_delta)\n",
    "        d['delta_branch'].append(branch_delta)\n",
    "        \n",
    "    df = pd.DataFrame(data=d)\n",
    "    df.set_index('mu')\n",
    "    \n",
    "    return df\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Notice that the following are equal:\n",
      "\n",
      "Tokuyama formula:\n",
      "\t (t*z_1 + z_2)*(t*z_1 + z_3)*(t*z_2 + z_3)*(z_1 + z_2 + z_3)\n",
      "\n",
      "Spherical Whittaker function for the general linear group over a non-archimedian local field:\n",
      "\t (t*z_1 + z_2)*(t*z_1 + z_3)*(t*z_2 + z_3)*(z_1 + z_2 + z_3)\n"
     ]
    }
   ],
   "source": [
    "lam = [1,0,0]\n",
    "\n",
    "variables = [f'z_{i}' for i in range(1, len(lam)+1, 1)]\n",
    "parameters = ['t' for i in range(len(lam))]\n",
    "\n",
    "print(\"Notice that the following are equal:\\n\")\n",
    "print(\"Tokuyama formula:\\n\\t\",  get_tokuyama_formula(lam, variables).simplify().factor())\n",
    "print()\n",
    "print(\"Spherical Whittaker function for the general linear group over a non-archimedian local field:\\n\\t\", swf(lam, variables, parameters, ice='gamma').simplify().factor())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Notice that the following are equal:\n",
      "\n",
      "Gamma:\n",
      "\t (t_2*z_1 + z_2)*(t_3*z_1 + z_3)*(t_3*z_2 + z_3)*(z_1 + z_2 + z_3)\n",
      "\n",
      "Delta:\n",
      "\t (t_1*z_1 + z_2)*(t_1*z_1 + z_3)*(t_2*z_2 + z_3)*(z_1 + z_2 + z_3)\n"
     ]
    }
   ],
   "source": [
    "lam = [1,0,0]\n",
    "\n",
    "variables = [f'z_{i}' for i in range(1, len(lam)+1, 1)]\n",
    "parameters = [f't_{i}' for i in range(1, len(lam)+1, 1)]\n",
    "\n",
    "print(\"Notice that the following are equal:\\n\")\n",
    "print(\"Gamma:\\n\\t\", swf(lam, variables, parameters, ice='gamma').simplify().factor())\n",
    "print()\n",
    "print(\"Delta:\\n\\t\", swf(lam, variables, parameters, ice='delta').simplify().factor())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Given lambda=[1, 0, 0], we get the following table:\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>mu</th>\n",
       "      <th>gamma_contribution</th>\n",
       "      <th>gamma_branch</th>\n",
       "      <th>delta_contribution</th>\n",
       "      <th>delta_branch</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>(3, 1)</td>\n",
       "      <td>(t_3 + 1)*t_3*z_3</td>\n",
       "      <td>t_2*z_1^4*z_2 + (t_2 + 1)*z_1^3*z_2^2 + (t_2 +...</td>\n",
       "      <td>(t_1 + 1)*z_1</td>\n",
       "      <td>t_2*z_2^4*z_3 + (t_2 + 1)*z_2^3*z_3^2 + (t_2 +...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>(3, 0)</td>\n",
       "      <td>(t_3 + 1)*z_3^2</td>\n",
       "      <td>t_2*z_1^4 + (t_2 + 1)*z_1^3*z_2 + (t_2 + 1)*z_...</td>\n",
       "      <td>(t_1 + 1)*t_1*z_1^2</td>\n",
       "      <td>t_2*z_2^4 + (t_2 + 1)*z_2^3*z_3 + (t_2 + 1)*z_...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>(2, 1)</td>\n",
       "      <td>t_3*z_3^2</td>\n",
       "      <td>t_2*z_1^3*z_2 + (t_2 + 1)*z_1^2*z_2^2 + z_1*z_2^3</td>\n",
       "      <td>t_1*z_1^2</td>\n",
       "      <td>t_2*z_2^3*z_3 + (t_2 + 1)*z_2^2*z_3^2 + z_2*z_3^3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>(2, 0)</td>\n",
       "      <td>z_3^3</td>\n",
       "      <td>t_2*z_1^3 + (t_2 + 1)*z_1^2*z_2 + (t_2 + 1)*z_...</td>\n",
       "      <td>t_1^2*z_1^3</td>\n",
       "      <td>t_2*z_2^3 + (t_2 + 1)*z_2^2*z_3 + (t_2 + 1)*z_...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>(1, 0)</td>\n",
       "      <td>z_3^4</td>\n",
       "      <td>t_2*z_1^2 + (t_2 + 1)*z_1*z_2 + z_2^2</td>\n",
       "      <td>t_1*z_1^4</td>\n",
       "      <td>t_2*z_2^2 + (t_2 + 1)*z_2*z_3 + z_3^2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       mu gamma_contribution  \\\n",
       "0  (3, 1)  (t_3 + 1)*t_3*z_3   \n",
       "1  (3, 0)    (t_3 + 1)*z_3^2   \n",
       "2  (2, 1)          t_3*z_3^2   \n",
       "3  (2, 0)              z_3^3   \n",
       "4  (1, 0)              z_3^4   \n",
       "\n",
       "                                        gamma_branch   delta_contribution  \\\n",
       "0  t_2*z_1^4*z_2 + (t_2 + 1)*z_1^3*z_2^2 + (t_2 +...        (t_1 + 1)*z_1   \n",
       "1  t_2*z_1^4 + (t_2 + 1)*z_1^3*z_2 + (t_2 + 1)*z_...  (t_1 + 1)*t_1*z_1^2   \n",
       "2  t_2*z_1^3*z_2 + (t_2 + 1)*z_1^2*z_2^2 + z_1*z_2^3            t_1*z_1^2   \n",
       "3  t_2*z_1^3 + (t_2 + 1)*z_1^2*z_2 + (t_2 + 1)*z_...          t_1^2*z_1^3   \n",
       "4              t_2*z_1^2 + (t_2 + 1)*z_1*z_2 + z_2^2            t_1*z_1^4   \n",
       "\n",
       "                                        delta_branch  \n",
       "0  t_2*z_2^4*z_3 + (t_2 + 1)*z_2^3*z_3^2 + (t_2 +...  \n",
       "1  t_2*z_2^4 + (t_2 + 1)*z_2^3*z_3 + (t_2 + 1)*z_...  \n",
       "2  t_2*z_2^3*z_3 + (t_2 + 1)*z_2^2*z_3^2 + z_2*z_3^3  \n",
       "3  t_2*z_2^3 + (t_2 + 1)*z_2^2*z_3 + (t_2 + 1)*z_...  \n",
       "4              t_2*z_2^2 + (t_2 + 1)*z_2*z_3 + z_3^2  "
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = get_table(lam=[1,0,0])\n",
    "\n",
    "print(f'Given lambda={lam}, we get the following table:')\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "SageMath 9.3",
   "language": "sage",
   "name": "sagemath"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}