{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def x(i):\n",
    "    return SR.var('x_{}'.format(i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def vcoding(lam,g,t):\n",
    "    '''\n",
    "    this function returns the V_{g,t} coding of a partition\n",
    "    lam is the partition\n",
    "    g is the value of the parameter depending on the type of Lie algebra considered\n",
    "    t is the rank of the Lie algebra\n",
    "    '''\n",
    "    l=lam.length()\n",
    "    tmp=[lam[i]-i-1  for i in range(l)]\n",
    "    res = [abs(tmp[i]%g) for i in range(l)]\n",
    "    #print(tmp)\n",
    "    #print(set(res))\n",
    "    #setres =set(res)\n",
    "    cnt = 1\n",
    "    while len(set(res))<t:\n",
    "        tmp.append(-l-cnt)\n",
    "        res.append((-l-cnt)%g)\n",
    "        cnt+=1\n",
    "    tmp_res=[]\n",
    "    v=[]\n",
    "    for i in range(len(tmp)):\n",
    "        if res[i] not in tmp_res:\n",
    "            v.append(tmp[i]+g)\n",
    "            tmp_res.append(res[i])\n",
    "        \n",
    "    return v[:t]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def g_value(ty,t):\n",
    "    '''\n",
    "    ty: type of the Lie algebra, can be a (for A^{(1)}), b (for B^{(1)}), bv for (for A_{odd}^{(2)}), c (for C^{(1)}),\n",
    "    cv (for D_{t+1}^{(2)}), bc (for A_even^{(2)}) or d (for D^{(1)})\n",
    "    this function computes the value of the parameter g for each type\n",
    "    '''\n",
    "    if ty=='a':\n",
    "        g=t\n",
    "    elif ty=='b':\n",
    "        g=2*t-1\n",
    "    elif ty=='c':\n",
    "        g=2*t+2\n",
    "    elif ty=='d':\n",
    "        g=2*t-2\n",
    "    elif ty=='bc':\n",
    "        g=2*t+1\n",
    "    elif ty=='cv':\n",
    "        g=2*t\n",
    "    elif ty=='bv':\n",
    "        g=2*t\n",
    "    return g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def constant_coding(ty,t):\n",
    "    '''\n",
    "    constant coding is a function which takes the type ty of the Lie algebra and the rank t\n",
    "    and return the constant c by which are shifted the elements of the V_{g,t}-coding in Section 4.2\n",
    "    '''\n",
    "    if ty=='a':\n",
    "        c=0\n",
    "    elif ty=='b':\n",
    "        g=2*t-1\n",
    "        c=g/2-1\n",
    "    elif ty=='c':\n",
    "        g=2*t+2\n",
    "        c=g/2\n",
    "    elif ty=='d':\n",
    "        g=2*t-2\n",
    "        c=g/2-1\n",
    "    elif ty=='bc':\n",
    "        g=2*t+1\n",
    "        c=g/2\n",
    "    elif ty=='bv':\n",
    "        g=2*t\n",
    "        c=g/2-1\n",
    "        \n",
    "    elif ty=='cv':\n",
    "        g=2*t\n",
    "        c=g/2-1/2\n",
    "    return c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_size(lam,ty,t):\n",
    "    '''\n",
    "    this function takes a partition lam , a type ty and the rank t of the Lie algebra.\n",
    "    this function then computes the right-hand side of the first equation of all the Theorems of Section 4.2:\n",
    "    it gives the size of lambda computed from the V_{g,t}-coding\n",
    "    '''\n",
    "    #value of the parameter g\n",
    "    g=g_value(ty,t)\n",
    "    #c is the constant to go from the V_{g,t}-coding to the vector (r_i) in the Theorems of Section 4.2\n",
    "    c=constant_coding(ty,t)\n",
    "    \n",
    "    #ct is the constant we substract to the 1/g sum of (r_i)^2 (or in type A 1/(2g)sum of (r_i)^2)\n",
    "    #to obtain the size of the corresponding partition\n",
    "    if ty=='a':\n",
    "        ct =(g-1)*(2*g-1)/12\n",
    "    elif ty=='b':\n",
    "        ct =(g+2)*(g//2+1)/12\n",
    "    elif ty=='c':\n",
    "        ct = (g/2-1)*(g-1)/12\n",
    "    elif ty=='d':\n",
    "        ct =(g+1)*(g//2+1)/12\n",
    "    elif ty=='bc':\n",
    "        ct =(g-2)*(g//2)/12\n",
    "    elif ty=='cv':\n",
    "        ct =(g*g-1)/24\n",
    "    elif ty=='bv':\n",
    "        ct =(g+1)*(g//2+1)/12\n",
    "        \n",
    "    v=vcoding(lam,g,t)\n",
    "    \n",
    "    tmp =sum([(v[i]-c)*(v[i]-c) for i in range(len(v))])\n",
    "    if ty=='a':\n",
    "        tmp=tmp/(2*g)-ct\n",
    "    else:\n",
    "        tmp=tmp/(g)-ct\n",
    "    \n",
    "    return tmp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Id(i,t):\n",
    "    '''\n",
    "    identity to set a default value function \n",
    "    '''\n",
    "    return i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hook_functionty(lam,ty,t,x,x_hook=Id):\n",
    "    '''\n",
    "    this function returns both sides of Theorems of Section 4.2 as the first two outputs. Moreover it outputs the values of\n",
    "    the signed statistic of the Lemma of Section 6.1. The last output is the product over boxes on the main diagonal which\n",
    "    appears in the Lemmas from Section 6.1 when the formal variables are specialized. \n",
    "    \n",
    "    \n",
    "    lambda is a partition. It has to be chosen so that it matches the type of the affine Lie algebras. For instance\n",
    "    it has to be a doubled distinct 6 cores if one looks at C_3^{(1)}\n",
    "    \n",
    "    ty: type of the Lie algebra, can be a (for A^{(1)}), b (for B^{(1)}), bv for (for A_{odd}^{(2)}), c (for C^{(1)}),\n",
    "    cv (for D_{t+1}^{(2)}), bc (for A_even^{(2)}) or d (for D^{(1)})\n",
    "    \n",
    "    t is the rank\n",
    "    \n",
    "    x is the set of formal variables, note that it needs to be shifted because SR does not support negative index,\n",
    "    it can therefore be specialized as a function. \n",
    "    \n",
    "    WARNING: to avoid sagemath issues with handling variables with negative index, all of the indices of the variable are added +g.\n",
    "    Therefore when specializing the set of variables as in Section 6.1, we have to shift our specializations by -g to recover \n",
    "    the computations from Section 6.1\n",
    "   \n",
    "    \n",
    "    x_hook corresponds to the function necessary to compute the product on the main diagonal of Lambda \n",
    "    '''\n",
    "    #Macdonald g value\n",
    "    g=g_value(ty,t)\n",
    "    \n",
    "    #length of the partition\n",
    "    l=lam.length()\n",
    "    #length of the main diagonal\n",
    "    d_l=lam.frobenius_rank()\n",
    "    #sgn encodes the value of (-1)^{number of hook lengths <g such that Epsilon =1 (if type <>A)}\n",
    "    sgn=1\n",
    "    #sgn_diag encodes the value of (-1)^{number of hook lengths <g such that Epsilon =1 (if type <>A) that are on the main diagonal}\n",
    "    sgn_diag=1\n",
    "    #P is the product of hook lengths on the left-hand side of Theorems from Section 4.2\n",
    "    P=1\n",
    "    Q=1\n",
    "    P_hookdiag=1\n",
    "    for i in range(l):\n",
    "        for j in range(lam[i]):\n",
    "            h=lam.hook_length(i,j)\n",
    "            #apart from the type A case, the products on the left-hand side of the theorems in Section 4.2 depend on the position\n",
    "            #of a box with respect to the main diagonal\n",
    "            if ty=='a':\n",
    "                P=P*(x(h))/(x(h+g))*(x(h+2*g))/(x(h+g))\n",
    "                if h<g:\n",
    "                    Q=Q*(x(h))/(x(2*g-h))\n",
    "                    sgn=-sgn\n",
    "            else:\n",
    "                if i<j:\n",
    "                    P=P*(x(h))/(x(h+g))\n",
    "                    if h<g:\n",
    "                        sgn =-sgn\n",
    "                        Q=Q*(x(h))/(x(2*g-h))\n",
    "                elif i==j:\n",
    "                    if ty=='d':\n",
    "                        P=P*(x(h+2*g))/(x(h+g))\n",
    "                    else:\n",
    "                        P_hookdiag=P_hookdiag*(x_hook(h+g+g,ty))/x_hook(h-g+g,ty)\n",
    "                        if h<g:\n",
    "                            Q=Q*(x(h))/(x(2*g-h))\n",
    "                            sgn=-sgn\n",
    "                            sgn_diag = -sgn_diag\n",
    "                        P=P*(x(h))/(x(h+g))\n",
    "                elif i>j:\n",
    "                    P=P*(x(h+2*g))/(x(h+g))\n",
    "    vg=vcoding(lam,g,t)\n",
    "    '''this part fills Q to be the right-hand side of Theorems from Section 4.2. \n",
    "    Since all of variables must be of positive index, the indices are shifted by g.\n",
    "    Recall also that range(n) goes from 0 to n-1 which explains the (i+1) and the (j+1)\n",
    "    '''\n",
    "    for i in range(len(vg)):\n",
    "        if ty=='c':\n",
    "            Q=Q*x(vg[i]+g/2)/x(i+1+g)\n",
    "        elif ty=='bv':\n",
    "            Q=Q*x(vg[i]+g/2+1)/x(i+1+g)\n",
    "        elif ty=='d':\n",
    "            if x(vg[i]+g/2+1)==0:\n",
    "                #here we just handle the exception r_i=0, then tau(2r_i)/tau(r_i)=1 in order to call \n",
    "                #hook_functionty for the applications to the q Nekrasov-Okounkov formula\n",
    "                Q=Q\n",
    "            else:\n",
    "                Q=Q*x(2*vg[i]+2)/x(vg[i]+g/2+1)\n",
    "            if i<len(vg)-1:\n",
    "                Q=Q*x(i+1+g)/x(2*(i+1)+g)\n",
    "\n",
    "        for j in range(i+1,len(vg)):\n",
    "            if ty=='a':\n",
    "                Q=Q*x(vg[i]-vg[j]+g)/x(j-i+g)\n",
    "            elif ty in ['c','bc']:\n",
    "                Q=Q*x(vg[i]-vg[j]+g)/x(j-i+g)*x(vg[i]+vg[j])/x(g-(i+1)-(j+1)+g)\n",
    "            elif ty in ['d','b','bv']:\n",
    "                Q=Q*x(vg[i]-vg[j]+g)/x(j-i+g)*x(vg[i]+vg[j]+2)/x(g+2-(i+1)-(j+1)+g)\n",
    "            elif ty=='cv':\n",
    "                Q=Q*x(vg[i]-vg[j]+g)/x(j-i+g)*x(vg[i]+vg[j]+1)/x(g+1-(i+1)-(j+1)+g)\n",
    "    return [P,Q,sgn,sgn_diag,P_hookdiag]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "lambda_d=Partition([4,4,4,3,3])\n",
    "testd=hook_functionty(lambda_d,'d',3,x)\n",
    "print(testd[0]-testd[1])   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "lambda_bv=Partition([4,4,2,2,2])\n",
    "testbv=hook_functionty(lambda_bv,'bv',10,x)\n",
    "print('test')\n",
    "print(testbv[0]-testbv[1])    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "lambda_d=Partition([4,4,4,3,3])\n",
    "testd=hook_functionty(Partition([8,5,2,2,2,2,1,1,1]),'d',3,x)\n",
    "print(testd[0]-testd[1])   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def det_type(v,ty,x):\n",
    "    '''\n",
    "    v is the vector corresponding to the r_i\n",
    "    ty stands for the type\n",
    "    x is a set of formal variable\n",
    "    this function returns the matrix whose determinant is either the numerator or the denominator of a schur function\n",
    "    '''\n",
    "    t=len(v)\n",
    "    tmp=[]\n",
    "    if ty=='a':\n",
    "        for i in range(t):\n",
    "            tmp.append([x(i)^(v[j]) for j in range(t)])\n",
    "    elif ty=='d':\n",
    "        for i in range(t):\n",
    "            tmp.append([x(i)^(v[j])+x(i)^(-v[j]) for j in range(t)])\n",
    "    else:\n",
    "        for i in range(t):\n",
    "            tmp.append([x(i)^(v[j])-x(i)^(-v[j]) for j in range(t)])\n",
    "    return matrix(tmp)\n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hook_functiontychar(lam,t,ty,y,x):\n",
    "    \n",
    "    '''\n",
    "    lam : partition\n",
    "    \n",
    "    t: rank of the Lie alebra\n",
    "    \n",
    "    ty: type of the Lie algebra, can be a (for A^{(1)}), b (for B^{(1)}), bv for (for A_{odd}^{(2)}), c (for C^{(1)}),\n",
    "    cv (for D_{t+1}^{(2)}), bc (for A_even^{(2)}) or d (for D^{(1)})\n",
    "    \n",
    "    y : set of variables which are specialized as the function tau in the Lemmas of Section 6.1\n",
    "    and in the checks performed below\n",
    "    \n",
    "    x : set of variables used to compute the characters. These are to be chosen in the applications\n",
    "    as powers of the variable q to perform the checks of the Lemmas of Section 6.1\n",
    "    \n",
    "    this function returns the character \n",
    "    '''\n",
    "    \n",
    "    #c is the constant you have to substract from the V_g,t coding to obtain the r_i from Theorems of Section 4.2\n",
    "    g=g_value(ty,t)\n",
    "    c=constant_coding(ty,t)\n",
    "    \n",
    "    var('q')\n",
    "    \n",
    "    def x_hook(i,ty):\n",
    "        '''\n",
    "        auxillary function which computes the function appearing in the product over the boxes over Delta in Lemmas in Section 6.1\n",
    "        \n",
    "        ty is the type\n",
    "        \n",
    "        ct is the constant 1/2 when the terms of the product are quotients of terms of the form  1+/- q^{+/-g+h_s/2}\n",
    "        and 1 if the terms are of the form  1+/- q^{+/-g+h_s}\n",
    "        '''\n",
    "        ct=1\n",
    "        sgn=1\n",
    "        if ty=='a':\n",
    "            g=t\n",
    "        elif ty=='b':\n",
    "            g=2*t-1\n",
    "            ct=1\n",
    "            sgn =-1\n",
    "        elif ty=='c':\n",
    "            g=2*t+2\n",
    "            ct=1/2\n",
    "        elif ty=='d':\n",
    "            g=2*t-2\n",
    "            ct=1\n",
    "        elif ty=='bc':\n",
    "            g=2*t+1\n",
    "            ct=1\n",
    "            sgn =-1\n",
    "        elif ty=='cv':\n",
    "            g=2*t\n",
    "            ct=1\n",
    "            sgn =-1\n",
    "\n",
    "        elif ty=='bv':\n",
    "            g=2*t\n",
    "            ct=1/2\n",
    "        return 1+sgn*q^(ct*(i-g))\n",
    "        \n",
    "    def x_app(x,g):\n",
    "        if ty=='a':\n",
    "            g=t\n",
    "        elif ty=='b':\n",
    "            g=2*t-1\n",
    "            c=g/2-1\n",
    "        elif ty=='c':\n",
    "            g=2*t+2\n",
    "            c=g/2\n",
    "        elif ty=='d':\n",
    "            g=2*t-2\n",
    "            c=g/2-1\n",
    "        elif ty=='bc':\n",
    "            g=2*t+1\n",
    "            c=g/2\n",
    "        elif ty=='bv':\n",
    "            g=2*t\n",
    "            c=g/2-1\n",
    "\n",
    "        elif ty=='cv':\n",
    "            g=2*t\n",
    "            c=g/2-1/2\n",
    "\n",
    "        def tmp_fun(i):\n",
    "            return x(i-g)\n",
    "        return tmp_fun\n",
    "    \n",
    "    l=lam.length()\n",
    "    d_l=lam.frobenius_rank()\n",
    "    vg=vcoding(lam,g,t)\n",
    "    vg0=vcoding(Partition([]),g,t)\n",
    "    r=[vg[i]-c for i in range(len(vg))]\n",
    "    r0=[vg0[i]-c for i in range(len(vg0))]\n",
    "    \n",
    "    tmp=hook_functionty(lam,ty,t,x_app(y,ty),x_hook)\n",
    "    print('function tau in 0 is equal to')\n",
    "    print(x_app(y,ty)(0))\n",
    "    print(\"the function appearing in the products over the main diagonal in Lemmas 6.1 evaluated in 0 is\")\n",
    "    print(x_hook(0,ty))\n",
    "    #P is the product of hook lengths\n",
    "    P=tmp[0]\n",
    "    #sgn is the signature of the corresponding affine Grassmannian element\n",
    "    sgn=tmp[2]\n",
    "    #sgn_diag is the (-1)^{number of hooks on the main diagonal Delta whose length<g}\n",
    "    sgn_diag=tmp[3]\n",
    "    #P_hook is the correcting factor which is a product of boxes on the main diagonal\n",
    "    P_hook=tmp[4]\n",
    "    print('Product of theorems of Section 4.2 is')\n",
    "    print(P)\n",
    "    print('r coding is')\n",
    "    print(r)\n",
    "    #handling the case of type D character (eq 1.14)\n",
    "    if ty=='d':\n",
    "        if r[-1]==0:\n",
    "            character=det_type(r,ty,x).det()/det_type(r0,ty,x).det()\n",
    "        else:\n",
    "            character=2*det_type(r,ty,x).det()/det_type(r0,ty,x).det()\n",
    "    else:\n",
    "        character=det_type(r,ty,x).det()/det_type(r0,ty,x).det()\n",
    "    \n",
    "    factor=1\n",
    "    if ty=='c':\n",
    "        factor=sgn*(1-x_app(y,ty)(g/2*d_l+g))\n",
    "    elif ty=='b':\n",
    "        factor=(1-x_app(y,ty)(-g/2*d_l+g))*sgn*sgn_diag\n",
    "    elif ty=='bv':\n",
    "        factor=(1-x_app(y,ty)(-g/2*d_l+g))*sgn\n",
    "    elif ty=='cv':\n",
    "        factor=(-1)^(d_l)\n",
    "    elif ty=='bc':\n",
    "        factor=sgn*sgn_diag*(1-x_app(y,ty)(d_l*g/2+g))\n",
    "    elif ty=='d':\n",
    "        factor=(1-x_app(y,ty)(-g*d_l+g))*sgn\n",
    "    print('the power of (+/-u) appearing in the q Nekrasov Okounkov formula is when u is specialized to a power of q')\n",
    "    print(factor)\n",
    "    print('the product of hook length on the main diagonal specific to that type is ')\n",
    "    print(P_hook)\n",
    "    hook_prod=factor*P*P_hook\n",
    "    return [character,hook_prod]\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def x_even(i):\n",
    "    var('q')\n",
    "    return 1-q^(2*(i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def x_clas(i):\n",
    "    var('q')\n",
    "    return 1-q^(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def y_clas(i):\n",
    "    var('q')\n",
    "    return q^(i+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def y_odd(i):\n",
    "    var('q')\n",
    "    return q^(2*i+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def x_odd(i):\n",
    "    var('q')\n",
    "    return 1-q^(2*(i)+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "lambda_a=Partition([10,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n",
      "15\n"
     ]
    }
   ],
   "source": [
    "print(lambda_a.size())\n",
    "print(check_size(lambda_a,'a',6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "function tau in 0 is equal to\n",
      "-1/q^6 + 1\n",
      "the function appearing in the products over the main diagonal in Lemmas 6.1 evaluated in 0 is\n",
      "1/q^6 + 1\n",
      "Product of theorems of Section 4.2 is\n",
      "(q^17 - 1)*(q^16 - 1)*(q^15 - 1)*(q^14 - 1)*(q^13 - 1)*(1/q - 1)^2*(1/q^2 - 1)^2*(1/q^3 - 1)^2*(1/q^4 - 1)^2*(1/q^5 - 1)^2/((q^5 - 1)^3*(q^4 - 1)^3*(q^3 - 1)^3*(q^2 - 1)^3*(q - 1)^3)\n",
      "r coding is\n",
      "[15, 2, 1, 0, -1, -2]\n",
      "the power of (+/-u) appearing in the q Nekrasov Okounkov formula is when u is specialized to a power of q\n",
      "1\n",
      "the product of hook length on the main diagonal specific to that type is \n",
      "1\n"
     ]
    }
   ],
   "source": [
    "[test1a,test2a]=hook_functiontychar(lambda_a,6,'a',x_clas,y_clas)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#testing if the expressions for Lemma 6.3 actually match\n",
    "(test1a-test2a).canonicalize_radical().full_simplify()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "lambda_c=Partition([5,3,1,1])\n",
    "print(lambda_c.size())\n",
    "print(check_size(lambda_c,'c',2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "function tau in 0 is equal to\n",
      "-1/q^6 + 1\n",
      "the function appearing in the products over the main diagonal in Lemmas 6.1 evaluated in 0 is\n",
      "1/q^3 + 1\n",
      "Product of theorems of Section 4.2 is\n",
      "(q^11 - 1)*(q^7 - 1)*(1/q - 1)*(1/q^2 - 1)*(1/q^4 - 1)^2*(1/q^5 - 1)^2/((q^5 - 1)^2*(q^4 - 1)*(q^2 - 1)^2*(q - 1)^3)\n",
      "r coding is\n",
      "[7, 4]\n",
      "the power of (+/-u) appearing in the q Nekrasov Okounkov formula is when u is specialized to a power of q\n",
      "q^6\n",
      "the product of hook length on the main diagonal specific to that type is \n",
      "(q^7 + 1)*(q^4 + 1)/((q + 1)*(1/q^2 + 1))\n"
     ]
    }
   ],
   "source": [
    "[test1c,test2c]=hook_functiontychar(lambda_c,2,'c',x_clas,y_clas)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#testing if the expressions for Lemma 6.3 actually match\n",
    "(test1c-test2c).canonicalize_radical().full_simplify()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "lambda_bc=Partition([5,3,1,1])\n",
    "print(lambda_bc.size())\n",
    "print(check_size(lambda_bc,'bc',3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "function tau in 0 is equal to\n",
      "-1/q^14 + 1\n",
      "the function appearing in the products over the main diagonal in Lemmas 6.1 evaluated in 0 is\n",
      "-1/q^7 + 1\n",
      "Product of theorems of Section 4.2 is\n",
      "(q^24 - 1)*(q^18 - 1)*(1/q^4 - 1)*(1/q^6 - 1)*(1/q^10 - 1)^2*(1/q^12 - 1)^2/((q^10 - 1)^2*(q^8 - 1)*(q^4 - 1)^3*(q^2 - 1)^2)\n",
      "r coding is\n",
      "[15/2, 9/2, 3/2]\n",
      "the power of (+/-u) appearing in the q Nekrasov Okounkov formula is when u is specialized to a power of q\n",
      "-q^14\n",
      "the product of hook length on the main diagonal specific to that type is \n",
      "(q^15 - 1)*(q^9 - 1)/((q - 1)*(1/q^5 - 1))\n"
     ]
    }
   ],
   "source": [
    "[test1bc,test2bc]=hook_functiontychar(lambda_bc,3,'bc',x_even,y_odd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "#testing if the expressions for Lemma 6.10 actually match"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(test1bc-test2bc).canonicalize_radical().full_simplify()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "lambda_bv=Partition([4,1,1,1,1])\n",
    "print(lambda_bv.size())\n",
    "print(check_size(lambda_bv,'bv',2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "function tau in 0 is equal to\n",
      "-1/q^4 + 1\n",
      "the function appearing in the products over the main diagonal in Lemmas 6.1 evaluated in 0 is\n",
      "1/q^2 + 1\n",
      "Product of theorems of Section 4.2 is\n",
      "(q^7 - 1)*(q^6 - 1)*(q^5 - 1)*(1/q - 1)*(1/q^2 - 1)*(1/q^3 - 1)/((q^3 - 1)^2*(q^2 - 1)^2*(q - 1)^2)\n",
      "r coding is\n",
      "[6, 1]\n",
      "the power of (+/-u) appearing in the q Nekrasov Okounkov formula is when u is specialized to a power of q\n",
      "-1/q^2\n",
      "the product of hook length on the main diagonal specific to that type is \n",
      "(q^6 + 1)/(q^2 + 1)\n"
     ]
    }
   ],
   "source": [
    "[test1bv,test2bv]=hook_functiontychar(lambda_bv,2,'bv',x_clas,y_clas)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#testing if the expressions for Lemma 6.6 actually match\n",
    "(test1bv-test2bv).canonicalize_radical().full_simplify()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "lambda_d=Partition([6,5,4,4,4,2,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "26\n",
      "26\n"
     ]
    }
   ],
   "source": [
    "print(lambda_d.size())\n",
    "print(check_size(lambda_d,'d',3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "function tau in 0 is equal to\n",
      "-1/q^8 + 1\n",
      "the function appearing in the products over the main diagonal in Lemmas 6.1 evaluated in 0 is\n",
      "1/q^4 + 1\n",
      "Product of theorems of Section 4.2 is\n",
      "(q^32 - 1)*(q^28 - 1)*(q^24 - 1)*(q^22 - 1)*(q^18 - 1)*(q^10 - 1)*(1/q^2 - 1)^2*(1/q^6 - 1)^2/((q^16 - 1)*(q^8 - 1)*(q^6 - 1)^3*(q^4 - 1)*(q^2 - 1)^4)\n",
      "r coding is\n",
      "[8, 6, 3]\n",
      "the power of (+/-u) appearing in the q Nekrasov Okounkov formula is when u is specialized to a power of q\n",
      "q^(-32)\n",
      "the product of hook length on the main diagonal specific to that type is \n",
      "1\n"
     ]
    }
   ],
   "source": [
    "[test1d,test2d]=hook_functiontychar(lambda_d,3,'d',x_even,y_odd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(test1d-test2d).canonicalize_radical().full_simplify()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n",
      "12\n"
     ]
    }
   ],
   "source": [
    "lambda_cv=Partition([4,4,2,2])\n",
    "print(lambda_cv.size())\n",
    "print(check_size(lambda_cv,'cv',2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "function tau in 0 is equal to\n",
      "-1/q^8 + 1\n",
      "the function appearing in the products over the main diagonal in Lemmas 6.1 evaluated in 0 is\n",
      "-1/q^4 + 1\n",
      "Product of theorems of Section 4.2 is\n",
      "(q^20 - 1)*(1/q^2 - 1)*(1/q^4 - 1)^2*(1/q^6 - 1)/((q^6 - 1)*(q^4 - 1)^3*(q^2 - 1))\n",
      "r coding is\n",
      "[11/2, 9/2]\n",
      "the power of (+/-u) appearing in the q Nekrasov Okounkov formula is when u is specialized to a power of q\n",
      "1\n",
      "the product of hook length on the main diagonal specific to that type is \n",
      "(q^11 - 1)*(q^9 - 1)/((q^3 - 1)*(q - 1))\n"
     ]
    }
   ],
   "source": [
    "[test1cv,test2cv]=hook_functiontychar(lambda_cv,2,'cv',x_even,y_odd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(test1cv-test2cv).canonicalize_radical().full_simplify()"
   ]
  }
 ],
 "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.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}