app_qsries_scratch.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "45f2cacf-2d5c-437c-9142-66d5adb822f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "#importing\n",
    "import panel as pn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "7113f434-e156-4ded-9766-b59ef7ed7990",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Partition function list\n",
    "def effparti(n):\n",
    "    '''partition function that generates partitions and returns a list of them till n (input) using eulers algoritm'''\n",
    "    \n",
    "    pat=[1,1,2,3,5,7,11]\n",
    "    n=int(n)\n",
    "    if n<0  :\n",
    "        return pat[1] \n",
    "    elif n<7:\n",
    "        return pat[0:n+1]\n",
    "    else:\n",
    "        pt=pat\n",
    "        for j in range (7,n+1):\n",
    "            P=0\n",
    "            \n",
    "            for i in range (1,j+1):\n",
    "                k1=int((i*(3*i+1))/2)\n",
    "                k2=int((i*(3*i-1))/2)\n",
    "                if j-k1<0 and j-k2 <0:\n",
    "                    break\n",
    "                elif j-k1<0 :\n",
    "                    P+=((-1)**(i+1))*(pt[j-k2])\n",
    "                elif j-k2<0 :\n",
    "                    P+=((-1)**(i+1))*(pt[j-k1])\n",
    "                else:\n",
    "                    P+=((-1)**(i+1))*(pt[j-k1]+pt[j-k2]) # eulers formula iteration\n",
    "\n",
    "            pt.append(P)\n",
    "        return pt "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "019a2728-2d8c-4e26-b97e-e9b1b059b945",
   "metadata": {},
   "outputs": [],
   "source": [
    "def outsci(stat,n): # converts number to scientific (10^n) form\n",
    "    st=str(stat)\n",
    "    m=len(st)\n",
    "    stt=''\n",
    "    if m>n:\n",
    "        for i in range(n):\n",
    "                try:\n",
    "                    stt=stt+st[i]\n",
    "                except:\n",
    "                    stt+='0'\n",
    "        at=m-n\n",
    "        return f'$ {stt} \\\\times 10^{ {at} } $'\n",
    "    else:\n",
    "        return f'$ {st} $' "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "1f3032a6",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# q-series generation \n",
    "\n",
    "def qf1(n,m=1):\n",
    "    ''' outputs a dictionary in which we concider its keys as 'q' raised to power and \n",
    "    values is the respective coefficient = 1 as (LaTeX): (q^m;q^m)_\\infty = \\Pi_{i=1}^\\infty (1-q^{m i})'''\n",
    "    \n",
    "    n=n//m\n",
    "    return {m*i:1 for i in range(n+1)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "c8286631",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# q-series multiplication\n",
    "\n",
    "def qmul(a,b,t=100):\n",
    "    ''' we define qmul as multiplication of two dictionaries in a way to replicate multiplication in q series'''\n",
    "    p={}\n",
    "    \n",
    "    for i,j in a.items():\n",
    "        for k,l in b.items():\n",
    "            if (i+k)<=t:\n",
    "                try:\n",
    "                    p[i+k]+=(j*l) #main step of adding powers and multiplying coefficients\n",
    "                except:\n",
    "                    p[i+k]=(j*l)\n",
    "    return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "8949efce",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# 1/f1 p(n)q^n generator\n",
    "\n",
    "def f_1(s):\n",
    "    '''outputs 1/f1 = 1/(q;q)_\\infty restricted till q^s term'''\n",
    "    \n",
    "    p={0:1}\n",
    "    for i in range(1,s+1):\n",
    "    \n",
    "        p=qmul(p,qf1(s,i),s)\n",
    "\n",
    "    return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "6e5c9ff9",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# superscript output function\n",
    "\n",
    "def supspt(n):\n",
    "    '''outputs superscripts of the int input with help of UniCode'''\n",
    "    \n",
    "    ss={'0':'\\u2070','1':'\\u00b9','2':'\\u00b2','3':'\\u00b3','4':'\\u2074',\n",
    "        '5':'\\u2075','6':'\\u2076','7':'\\u2077','8':'\\u2078','9':'\\u2079'}\n",
    "    \n",
    "    st=str(int(n))\n",
    "    sd=''\n",
    "    \n",
    "    for i in st:\n",
    "        sd+=ss[i]\n",
    "        \n",
    "    return f'{sd}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "52f43761",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# print q-series from Dictionary\n",
    "\n",
    "def qprint(a):\n",
    "    ''' outputs q series representations from raw dictionary'''\n",
    "    d=''\n",
    "    if len(a)>0:\n",
    "        d=str(a[0])\n",
    "        coef=''\n",
    "        \n",
    "        for i in range(1,len(a)):\n",
    "            \n",
    "            coef=' + '+str(a[i])+' q'+supspt(i)\n",
    "            d+=coef\n",
    "        \n",
    "    return d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "acad88ee-2a20-447a-88b2-0d63466df96a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# dictionary to list \n",
    "\n",
    "def to_list(q):\n",
    "    ''' outputs values of dictionary in ordered list'''\n",
    "    ll=[q[i] for i in range(len(q))]\n",
    "    return ll"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "6a3dfc72-bc85-40ae-84d3-0216b8592a2e",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# l-regular partition function generator\n",
    "\n",
    "def f_l_regular(l,s=100):\n",
    "    '''outputs fl/f1 = (q^l;q^l)_\\infty / (q;q)_\\infty restricted till q^s term'''\n",
    "    \n",
    "    p={0:1}\n",
    "    for i in range(1,s+1):\n",
    "        \n",
    "        if i%l != 0:\n",
    "            p=qmul(p,qf1(s,i),s)\n",
    "    \n",
    "    return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "dc928d68-5365-49a1-8c13-cc44304ad167",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# (l,m)-regular partition function generator\n",
    "\n",
    "def f_lm_regular(l,m,s=100):\n",
    "    '''outputs fl fm /f1 flm = (q^l;q^l)_\\infty (q^m;q^m)_\\infty / (q;q)_\\infty (q^{lm};q^{lm})_\\infty restricted till q^s term'''\n",
    "    \n",
    "    p={0:1}\n",
    "    \n",
    "    for i in range(1,s+1):\n",
    "        \n",
    "        if i%l != 0 and i%m !=0 :\n",
    "            p=qmul(p,qf1(s,i),s)\n",
    "    \n",
    "    return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "a318b3eb-bde1-4573-8902-5eb04bdf42dc",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "#2 colour (l,m) - regular partition function generator\n",
    "\n",
    "def C2_lm_regular(l,m,s=100):\n",
    "    '''outputs (fl fm /f1 flm)^2 = ((q^l;q^l)_\\infty (q^m;q^m)_\\infty / (q;q)_\\infty (q^{lm};q^{lm})_\\infty)^2 restricted till q^s term for co-prime m and l'''\n",
    "    \n",
    "    p={0:1}\n",
    "    \n",
    "    for i in range(1,s+1):\n",
    "        \n",
    "        if i%l != 0 and i%m !=0 :\n",
    "            p=qmul(p,qf1(s,i),s) \n",
    "            p=qmul(p,qf1(s,i),s) # square is converted to 2 step multiplication by same quantity\n",
    "    \n",
    "    return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "1e7bb6e6-b6c5-492a-96dd-0418b06c596f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# n colored partitions i.e. 1/f1^n i.e. C_n(m)q^m generator\n",
    "\n",
    "def C_f_1(n,s):\n",
    "    '''outputs 1/f1^n = 1/(q;q)_\\infty^n restricted till q^s term'''\n",
    "    \n",
    "    p={0:1}\n",
    "    for i in range(1,s+1):\n",
    "        \n",
    "        for j in range(0,n):\n",
    "            p=qmul(p,qf1(s,i),s)\n",
    "\n",
    "    return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "d4ea790a-a093-4ba9-9b04-e9ce78d67f91",
   "metadata": {},
   "outputs": [],
   "source": [
    "# n colored l-regular partition function generator\n",
    "\n",
    "def C_l_regular(n,l,s=100):\n",
    "    '''outputs (fl/f1)^n = ((q^l;q^l)_\\infty / (q;q)_\\infty)^n restricted till q^s term'''\n",
    "    \n",
    "    p={0:1}\n",
    "    for i in range(1,s+1):\n",
    "        \n",
    "        if i%l != 0:\n",
    "            for j in range(0,n):\n",
    "                p=qmul(p,qf1(s,i),s)\n",
    "    \n",
    "    return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "d0d069bc-d571-490e-872f-b091a0baed9d",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "#2 colour (l,m) - regular partition function generator\n",
    "\n",
    "def C_lm_regular(n,l,m,s=100):\n",
    "    '''outputs (fl fm /f1 flm)^n = ((q^l;q^l)_\\infty (q^m;q^m)_\\infty / (q;q)_\\infty (q^{lm};q^{lm})_\\infty)^n restricted till q^s term for co-prime m and l'''\n",
    "    \n",
    "    p={0:1}\n",
    "    \n",
    "    for i in range(1,s+1):\n",
    "        \n",
    "        if i%l != 0 and i%m !=0 :\n",
    "            for j in range(0,n):\n",
    "                p=qmul(p,qf1(s,i),s) \n",
    "            \n",
    "    return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "e4c0c8ff-b244-416a-bd6e-9fd50a7f8558",
   "metadata": {},
   "outputs": [],
   "source": [
    "def str_to_list(a): #coverts string to a numerical list\n",
    "    lll=a[1:-1]\n",
    "    lll=lll.split(',')\n",
    "    lll=[ int(j) for i,j in enumerate(lll)]\n",
    "    return lll"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "e13b8920-6db6-4057-8412-492756fd9845",
   "metadata": {},
   "outputs": [],
   "source": [
    "def filter_mod(a,b,c,d,e):\n",
    "    ''' collapses list a to ci+d for i variable indexes and filters it with [..]mod b = e to give exceptions'''\n",
    "    try:\n",
    "        a=str_to_list(a)\n",
    "        l=[]\n",
    "        tt=0\n",
    "        i=0\n",
    "            \n",
    "        while tt<=len(a) :\n",
    "            tt=c*i+d\n",
    "            if tt<len(a) :\n",
    "                l.append(a[tt])\n",
    "            i+=1\n",
    "            \n",
    "        res=list(filter(lambda x : (x%b)-e ,l))\n",
    "            \n",
    "        if len(res)==0:\n",
    "            t=f'No exceptions found for list[{c}n+{d}] mod {b} = {e} '\n",
    "            \n",
    "        else:\n",
    "            lmn=[]\n",
    "            for i,j in enumerate(res):\n",
    "                k=a.index(j)\n",
    "                lmn.append(k)\n",
    "            t= f'Exceptions for list[{c}n+{d}] mod {b} = {e} they are list{lmn} = {res}'\n",
    "    except:\n",
    "        t = 'input a proper list with numerical values (eg format: [2,4,8])'\n",
    "    return t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "328dc07c-0a6b-4ced-ba1f-2c6346ba7c7f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Partitions of n block\n",
    "\n",
    "intro = pn.pane.LaTeX(r'partition of $n$ = $p(n)$', styles={'font-size': '18pt'})\n",
    "ipt = pn.widgets.IntInput(name='p(n=)', value=0)\n",
    "res = pn.pane.LaTeX(r'', styles={'font-size': '18pt'})\n",
    "btn = pn.widgets.Button(name='=', button_type='primary',disabled=False)\n",
    "prs = pn.widgets.Button(name='precisely = ', button_type='primary',disabled=True)\n",
    "prs_res=pn.widgets.TextAreaInput()\n",
    "list_parti=pn.widgets.TextAreaInput()\n",
    "l_p_btn = pn.widgets.Button(name='list of partitions upto = ', button_type='primary',disabled=True)\n",
    "qser_parti=pn.widgets.TextAreaInput()\n",
    "q_p_btn = pn.widgets.Button(name='show in q-series form', button_type='primary',disabled=True)\n",
    "\n",
    "def click(k,n): # main function\n",
    "    if k:\n",
    "        global p,p_\n",
    "        btn.name='loading...'\n",
    "        btn.disabled=True\n",
    "        prs.disabled=True\n",
    "        l_p_btn.disabled=True\n",
    "        q_p_btn.disabled=True\n",
    "        p=effparti(n)\n",
    "        p_=p[-1]\n",
    "        btn.name='='\n",
    "        btn.disabled=False\n",
    "        res.object=outsci(p_,10)\n",
    "        prs.disabled=False\n",
    "        l_p_btn.disabled=False \n",
    "        q_p_btn.disabled=False\n",
    "        \n",
    "def prclic(l):\n",
    "    if l:\n",
    "        prs_res.value=str(p_)  \n",
    "        \n",
    "def l_p_btn_click(k):\n",
    "    if k:\n",
    "        list_parti.value=str(p)\n",
    "\n",
    "def q_p_btn_click(m):\n",
    "    if m:\n",
    "        qser_parti.value=str(qprint(p))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "53e52dca-3db5-4ccd-9458-4480d0501909",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Partitions of n block to show\n",
    "\n",
    "pn.bind(click,btn,ipt,watch='True')\n",
    "pn.bind(prclic,prs,watch='True')\n",
    "pn.bind(l_p_btn_click,l_p_btn,watch='True')\n",
    "pn.bind(q_p_btn_click,q_p_btn,watch='True')\n",
    "parti_tab=pn.Column(\n",
    "    pn.layout.VSpacer(),\n",
    "    pn.Row(\n",
    "    pn.layout.HSpacer(),\n",
    "    pn.Column(intro, ipt, btn,res,prs,prs_res,l_p_btn,list_parti,q_p_btn,qser_parti),\n",
    "    pn.layout.HSpacer()),\n",
    "    pn.layout.VSpacer()\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "b19a8a9a-9179-474e-88e6-eb9a624d2f18",
   "metadata": {},
   "outputs": [],
   "source": [
    "#f_l_regular(k) l-regular partition block\n",
    "\n",
    "intropl= pn.pane.LaTeX(r'$f_l(l)$ = $f_l/f_1$ = $\\frac{(q^l;q^l)_\\infty}{(q;q)_\\infty}$', styles={'font-size': '18pt'})\n",
    "intropl1= pn.pane.LaTeX(r'which represents the $l-regular$ partition i.e. partitions of n in which no part is divisible by $l$', styles={'font-size': '18pt'})\n",
    "intropl2 = pn.pane.LaTeX(r'also input n so that expression can be expanded till n', styles={'font-size': '18pt'})\n",
    "iptpl = pn.widgets.IntInput(name=' l =', value=2)\n",
    "iptpl1 = pn.widgets.IntInput(name=' n =', value=20)\n",
    "tboxpl_list=pn.widgets.TextAreaInput(disabled=True)\n",
    "btnpl_list = pn.widgets.Button(name='expand in list', button_type='primary')\n",
    "tboxpl_qser =pn.widgets.TextAreaInput(disabled=True)\n",
    "btnpl_qser = pn.widgets.Button(name='list in q-series', button_type='primary')\n",
    "\n",
    "\n",
    "def clickpl_ls(okl,pkl,pnl):\n",
    "    if okl:\n",
    "        global pl1\n",
    "        btnpl_list.name='loading...'\n",
    "        btnpl_list.disabled=True\n",
    "        btnpl_qser.disabled=True\n",
    "        pl1=f_l_regular(pkl,pnl)\n",
    "        tboxpl_list.value=str(to_list(pl1))\n",
    "        btnpl_list.name='expand in list'\n",
    "        btnpl_list.disabled=False\n",
    "        tboxpl_list.disabled=False\n",
    "        btnpl_qser.disabled=False\n",
    "        \n",
    "def clickpl_qs(m):\n",
    "    if m:\n",
    "        tboxpl_qser.value=str(qprint(pl1))\n",
    "        tboxpl_qser.disabled=False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "b28a04fe-57d2-49a4-a69d-104d557a8cab",
   "metadata": {},
   "outputs": [],
   "source": [
    "#f_l(k) l-regular partition block to show\n",
    "\n",
    "pn.bind(clickpl_ls,btnpl_list,iptpl,iptpl1,watch='True')\n",
    "pn.bind(clickpl_qs,btnpl_qser,watch='True')\n",
    "lreg_tab=pn.Column(pn.layout.VSpacer(),\n",
    "         pn.Row(\n",
    "         pn.layout.HSpacer(),\n",
    "         pn.Column(intropl),\n",
    "         pn.layout.HSpacer()),\n",
    "         pn.Row(\n",
    "         pn.layout.HSpacer(),\n",
    "         pn.Column(intropl1),\n",
    "         pn.layout.HSpacer()),\n",
    "         pn.Row(\n",
    "         pn.layout.HSpacer(),\n",
    "         pn.Column(intropl2),\n",
    "         pn.layout.HSpacer()),\n",
    "         pn.layout.VSpacer(),\n",
    "         pn.Row(\n",
    "         pn.layout.HSpacer(),\n",
    "         pn.Column(iptpl,iptpl1,btnpl_list,tboxpl_list,btnpl_qser,tboxpl_qser),\n",
    "         pn.layout.HSpacer()),\n",
    "         pn.layout.VSpacer()\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "3c403c41-2156-4185-bd91-ce09a274294d",
   "metadata": {},
   "outputs": [],
   "source": [
    "#f_lm_regular(k) (l,m)-regular partition block\n",
    "\n",
    "introplm= pn.pane.LaTeX(r'$f_{(l,j)}(l,j)$ = $f_l f_j/f_1 f_{lj}$ = $\\frac{(q^l;q^l)_\\infty(q^j;q^j)_\\infty}{(q;q)_\\infty(q^{lj};q^{lj})_\\infty}$', styles={'font-size': '18pt'})\n",
    "introplm1= pn.pane.LaTeX(r'which represents the $(l,j)-regular$ partition i.e. partitions of n in which no part is divisible by $l$ and or $j$' , styles={'font-size': '18pt'})\n",
    "introplm2 = pn.pane.LaTeX(r'also input n so that expression can be expanded till n', styles={'font-size': '18pt'})\n",
    "iptplm = pn.widgets.IntInput(name=' l =', value=2)\n",
    "iptplm1 = pn.widgets.IntInput(name=' j =', value=3)\n",
    "iptplm2 = pn.widgets.IntInput(name=' n =', value=20)\n",
    "tboxplm_list=pn.widgets.TextAreaInput(disabled=True)\n",
    "btnplm_list = pn.widgets.Button(name='expand in list', button_type='primary')\n",
    "tboxplm_qser =pn.widgets.TextAreaInput(disabled=True)\n",
    "btnplm_qser = pn.widgets.Button(name='list in q-series', button_type='primary')\n",
    "\n",
    "def clickplm_ls(oklm,pklm,pjlm,pnlm):\n",
    "    global plm1\n",
    "    if oklm:\n",
    "        btnplm_list.name='loading...'\n",
    "        btnplm_list.disabled=True\n",
    "        btnplm_qser.disaled=True\n",
    "        \n",
    "        plm1=f_lm_regular(pklm,pjlm,pnlm)\n",
    "        \n",
    "        tboxplm_list.value=str(to_list(plm1))\n",
    "        \n",
    "        btnplm_list.name='expand in list'\n",
    "        btnplm_list.disabled=False\n",
    "        tboxplm_list.disabled=False\n",
    "        btnplm_qser.disaled=False\n",
    "\n",
    "def clickplm_qs(oo):\n",
    "    if oo:\n",
    "        tboxplm_qser.value=str(qprint(plm1))\n",
    "        tboxplm_qser.disabled=False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "75445605-5679-4f0d-bfd9-c5c106ffe6a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "pn.bind(clickplm_ls,btnplm_list,iptplm,iptplm1,iptplm2,watch='True')\n",
    "pn.bind(clickplm_qs,btnplm_qser,watch='True')\n",
    "lmreg_tab=pn.Column(pn.layout.VSpacer(),\n",
    "         pn.Row(\n",
    "         pn.layout.HSpacer(),\n",
    "         pn.Column(introplm),\n",
    "         pn.layout.HSpacer()),\n",
    "         pn.Row(\n",
    "         pn.layout.HSpacer(),\n",
    "         pn.Column(introplm1),\n",
    "         pn.layout.HSpacer()),\n",
    "         pn.Row(\n",
    "         pn.layout.HSpacer(),\n",
    "         pn.Column(introplm2),\n",
    "         pn.layout.HSpacer()),\n",
    "         pn.layout.VSpacer(),\n",
    "         pn.Row(\n",
    "         pn.layout.HSpacer(),\n",
    "         pn.Column(iptplm,iptplm1,iptplm2,btnplm_list,tboxplm_list,btnplm_qser,tboxplm_qser),\n",
    "         pn.layout.HSpacer()),\n",
    "         pn.layout.VSpacer()\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "921372f1-3847-4047-9d94-203bb4edfe04",
   "metadata": {},
   "outputs": [],
   "source": [
    "#C_l_regular(s) (l)-regular partition block\n",
    "color_l_intro= pn.pane.LaTeX(r'$C_{n(l)}(s)$ = $f_l^n /f_1^n $ = $\\frac{(q^l;q^l)_\\infty^n}{(q;q)_\\infty^n}$', styles={'font-size': '18pt'})\n",
    "color_l_intro1= pn.pane.LaTeX(r'which represents the $n-Colored \\; l-regular$ partition i.e. n-colored partitions of n in which no part is divisible by $l$' , styles={'font-size': '18pt'})\n",
    "color_l_intro2 = pn.pane.LaTeX(r'also input s so that expression can be expanded till $q^s$', styles={'font-size': '18pt'})\n",
    "color_l_n = pn.widgets.IntInput(name=' n =', value=2)\n",
    "color_l_l = pn.widgets.IntInput(name=' l =', value=3)\n",
    "color_l_s = pn.widgets.IntInput(name=' s =', value=100)\n",
    "color_l_list=pn.widgets.TextAreaInput(disabled=True)\n",
    "color_l_btn_list = pn.widgets.Button(name='expand in list', button_type='primary')\n",
    "color_l_qser =pn.widgets.TextAreaInput(disabled=True)\n",
    "color_l_btn_qser = pn.widgets.Button(name='list in q-series', button_type='primary')\n",
    "\n",
    "def color_l_click_list(color_l_click,n,l,s):\n",
    "    global pcl_dict\n",
    "    if color_l_click:\n",
    "        color_l_btn_list.name='loading...'\n",
    "        color_l_btn_list.disabled=True\n",
    "        color_l_btn_qser.disaled=True\n",
    "        \n",
    "        pcl_dict=C_lm_regular(n,l,s)\n",
    "        \n",
    "        color_l_list.value=str(to_list(pcl_dict))\n",
    "        \n",
    "        color_l_btn_list.name='expand in list'\n",
    "        color_l_list.disabled=False\n",
    "        color_l_btn_list.disabled=False\n",
    "        color_l_btn_qser.disaled=False\n",
    "\n",
    "def color_l_click_qser(ooc):\n",
    "    if ooc:\n",
    "        color_l_qser.value=str(qprint(pcl_dict))\n",
    "        color_l_qser.disabled=False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "662da5df-5110-4ca5-89f9-ca60bad64fe0",
   "metadata": {},
   "outputs": [],
   "source": [
    "pn.bind(color_l_click_list,color_l_btn_list,color_l_n,color_l_l,color_l_s,watch='True')\n",
    "pn.bind(color_l_click_qser,color_l_btn_qser,watch='True')\n",
    "\n",
    "Clreg_tab=pn.Column(pn.layout.VSpacer(),\n",
    "         pn.Row(\n",
    "         pn.layout.HSpacer(),\n",
    "         pn.Column(color_l_intro),\n",
    "         pn.layout.HSpacer()),\n",
    "         pn.Row(\n",
    "         pn.layout.HSpacer(),\n",
    "         pn.Column(color_l_intro1),\n",
    "         pn.layout.HSpacer()),\n",
    "         pn.Row(\n",
    "         pn.layout.HSpacer(),\n",
    "         pn.Column(color_l_intro2),\n",
    "         pn.layout.HSpacer()),\n",
    "         pn.layout.VSpacer(),\n",
    "         pn.Row(\n",
    "         pn.layout.HSpacer(),\n",
    "         pn.Column(color_l_n,color_l_l,color_l_s,color_l_btn_list,color_l_list,color_l_btn_qser,color_l_qser),\n",
    "         pn.layout.HSpacer()),\n",
    "         pn.layout.VSpacer()\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "09c5b42a-b0a7-4d71-98cd-1dda9c14ce89",
   "metadata": {},
   "outputs": [],
   "source": [
    "#C_lm_regular(s) (l,m)-regular partition block\n",
    "color_lm_intro= pn.pane.LaTeX(r'$C_{n(l,m)}(s)$ = $f_l^n f_m^n/f_1^n f_{lm}^n $ = $\\frac{(q^l;q^l)_\\infty^n (q^m;q^m)_\\infty^n}{(q;q)_\\infty^n (q^{lj};q^{lj})_\\infty^n}$', styles={'font-size': '18pt'})\n",
    "color_lm_intro1= pn.pane.LaTeX(r'which represents the $n-Colored \\; (l,m)-regular$ partition i.e. n-colored partitions of n in which no part is divisible by $l$ and or $m$' , styles={'font-size': '18pt'})\n",
    "color_lm_intro2 = pn.pane.LaTeX(r'also input s so that expression can be expanded till $q^s$', styles={'font-size': '18pt'})\n",
    "color_lm_n = pn.widgets.IntInput(name=' n =', value=2)\n",
    "color_lm_l = pn.widgets.IntInput(name=' l =', value=3)\n",
    "color_lm_m = pn.widgets.IntInput(name=' m =', value=4)\n",
    "color_lm_s = pn.widgets.IntInput(name=' s =', value=100)\n",
    "color_lm_list=pn.widgets.TextAreaInput(disabled=True)\n",
    "color_lm_btn_list = pn.widgets.Button(name='expand in list', button_type='primary')\n",
    "color_lm_qser =pn.widgets.TextAreaInput(disabled=True)\n",
    "color_lm_btn_qser = pn.widgets.Button(name='list in q-series', button_type='primary')\n",
    "\n",
    "def color_lm_click_list(color_lm_click,n,l,m,s):\n",
    "    global pclm_dict\n",
    "    if color_lm_click:\n",
    "        color_lm_btn_list.name='loading...'\n",
    "        color_lm_btn_list.disabled=True\n",
    "        color_lm_btn_qser.disaled=True\n",
    "        \n",
    "        pclm_dict=C_lm_regular(n,l,m,s)\n",
    "        \n",
    "        color_lm_list.value=str(to_list(pclm_dict))\n",
    "        \n",
    "        color_lm_btn_list.name='expand in list'\n",
    "        color_lm_list.disabled=False\n",
    "        color_lm_btn_list.disabled=False\n",
    "        color_lm_btn_qser.disaled=False\n",
    "\n",
    "def color_lm_click_qser(oocm):\n",
    "    if oocm:\n",
    "        color_lm_qser.value=str(qprint(pclm_dict))\n",
    "        color_lm_qser.disabled=False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "cc299a5f-41f7-48b7-938e-a82031f195a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "pn.bind(color_lm_click_list,color_lm_btn_list,color_lm_n,color_lm_l,color_lm_m,color_lm_s,watch='True')\n",
    "pn.bind(color_lm_click_qser,color_lm_btn_qser,watch='True')\n",
    "\n",
    "Clmreg_tab=pn.Column(pn.layout.VSpacer(),\n",
    "         pn.Row(\n",
    "         pn.layout.HSpacer(),\n",
    "         pn.Column(color_lm_intro),\n",
    "         pn.layout.HSpacer()),\n",
    "         pn.Row(\n",
    "         pn.layout.HSpacer(),\n",
    "         pn.Column(color_lm_intro1),\n",
    "         pn.layout.HSpacer()),\n",
    "         pn.Row(\n",
    "         pn.layout.HSpacer(),\n",
    "         pn.Column(color_lm_intro2),\n",
    "         pn.layout.HSpacer()),\n",
    "         pn.layout.VSpacer(),\n",
    "         pn.Row(\n",
    "         pn.layout.HSpacer(),\n",
    "         pn.Column(color_lm_n,color_lm_l,color_lm_m,color_lm_s,color_lm_btn_list,color_lm_list,color_lm_btn_qser,color_lm_qser),\n",
    "         pn.layout.HSpacer()),\n",
    "         pn.layout.VSpacer()\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "473718d7-26c5-4dcf-ae01-a12682e81556",
   "metadata": {},
   "outputs": [],
   "source": [
    "# mod block\n",
    "mod_intro = pn.pane.LaTeX(r'Check for $a \\; mod \\; b \\equiv e$ for `$ c\\;i+d $` indices ($i$ variable) of a list $a$', styles={'font-size': '18pt'})\n",
    "mod_intro1 = pn.pane.LaTeX(r'input a list $a$ (copy any list from \"expand in list\" output) and integers $b,c,d,e$ as for above operations' , styles={'font-size': '18pt'})\n",
    "mod_v_a = pn.widgets.TextAreaInput(name=' a =',max_length=10000000)\n",
    "mod_v_b = pn.widgets.IntInput(name=' b =', value=2)\n",
    "mod_v_c = pn.widgets.IntInput(name=' c =', value=3)\n",
    "mod_v_d = pn.widgets.IntInput(name=' d =', value=4)\n",
    "mod_v_e = pn.widgets.IntInput(name=' e =', value=0)\n",
    "mod_btn = pn.widgets.Button(name='check', button_type='primary')\n",
    "mod_val = pn.widgets.TextAreaInput(disabled=True)\n",
    "\n",
    "def mod_click(oo,a,b,c,d,e):\n",
    "    if oo:\n",
    "        mod_btn.name='loading..'\n",
    "        mod_btn.disabled=True\n",
    "\n",
    "        result=filter_mod(a,b,c,d,e)\n",
    "        mod_val.value=str(result)\n",
    "\n",
    "        mod_btn.name='check'\n",
    "        mod_btn.disabled=False\n",
    "        mod_val.disabled=False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "1036bdb8-a5f1-471b-bba1-7be5394fa1ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "pn.bind(mod_click,mod_btn,mod_v_a,mod_v_b,mod_v_c,mod_v_d,mod_v_e,watch='True')\n",
    "\n",
    "mod_tab=pn.Column(pn.layout.VSpacer(),\n",
    "         pn.Row(\n",
    "         pn.layout.HSpacer(),\n",
    "         pn.Column(mod_intro),\n",
    "         pn.layout.HSpacer()),\n",
    "         pn.Row(\n",
    "         pn.layout.HSpacer(),\n",
    "         pn.Column(mod_intro1),\n",
    "         pn.layout.HSpacer()),\n",
    "         pn.Row(\n",
    "         pn.layout.HSpacer(),\n",
    "         pn.Column(mod_v_a,mod_v_b,mod_v_c,mod_v_d,mod_v_e,mod_btn,mod_val),\n",
    "         pn.layout.HSpacer()),\n",
    "         pn.layout.VSpacer()\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "c7b644d8-7978-404d-920f-99cd79fda838",
   "metadata": {},
   "outputs": [],
   "source": [
    "hed=pn.pane.Markdown(r\"\"\" Number theorists are like lotus-eaters having tasted this food they can never give it up.  \n",
    "                      <div style=\"text-align: right\"> - Leopold Kronecker</div>\n",
    "                    \"\"\")\n",
    "\n",
    "about=pn.pane.Markdown(r\"\"\"\n",
    "# Create by Yashas.N  [<img src=\"https://raw.githubusercontent.com/FortAwesome/Font-Awesome/6.x/svgs/brands/github.svg\" width=\"30\" height=\"30\">](https://github.com/Yn37git)  \n",
    "  \n",
    "## explore:\n",
    "- [Partition Function](https://en.wikipedia.org/wiki/Partition_function_(number_theory))\n",
    "- [Partition Functions](https://mathworld.wolfram.com/PartitionFunctionP.html)\n",
    "- [Euler's Pentagonal number Theorem](https://en.wikipedia.org/wiki/Pentagonal_number_theorem)\n",
    "- [Congruence Theorems](https://en.wikipedia.org/wiki/Ramanujan%27s_congruences)\n",
    "- [basic q series foundations](https://en.wikipedia.org/wiki/Euler_function)\n",
    "- [l-regular and (l,j)-regular partitions](https://github.com/Yn37git/Partition-number-theory/blob/main/q_ser_sympy.ipynb)\n",
    "\"\"\")\n",
    "abt=pn.Column(hed,about)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "017cf8ae-19ef-42fe-9168-c1683157cd7c",
   "metadata": {},
   "outputs": [],
   "source": [
    "tabb=pn.Tabs(('Partitions of n',parti_tab),\n",
    "             ('Mod Check',mod_tab),\n",
    "             ('l-regular',lreg_tab),\n",
    "             ('(l,m)-regular',lmreg_tab),\n",
    "             ('Colored-l-regular',Clreg_tab),\n",
    "             ('Colored-(l,m)-regular',Clmreg_tab),\n",
    "             ('about',abt)\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "87d1034c-358f-4697-b386-ccb0b2637b39",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Launching server at http://localhost:45807\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<panel.io.server.Server at 0x7f41caf24a50>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "tem = pn.template.FastListTemplate(title=\"Partition Functions\",\n",
    "                                   main=tabb,\n",
    "                                   logo=\"https://www.svgrepo.com/show/466290/sort.svg\",\n",
    "                                   accent_base_color=\"#2cacbc\",\n",
    "                                   header_background=\"#bcf4d4\",\n",
    "                                  )\n",
    "\n",
    "tem.servable()\n",
    "tem.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "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.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}