coLie.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### LieTree\n",
    "\n",
    "LieTree is a data structure for Lie brackets which is used to quickly separate brackets and sub-brackets into left and right components.\n",
    "LieTrees are initialized with a Lie bracket expression on alphabetical generators.   Whitespace is stripped away during initialization.\n",
    "\n",
    "Example:\n",
    " > LieTree(\"[ [a,b] , [a, [b,a] ] ]\")\n",
    "\n",
    "Attributes are:\n",
    "* value:     string for bracket expression\n",
    "* short:      bracket expression without ,\n",
    "* weight:   number brackets in subexpression\n",
    "* left:         LieTree on left side\n",
    "* right:       LieTree on right side\n",
    "\n",
    "Note: single letter expressions (i.e. no brackets) have:\n",
    "* value    = letter\n",
    "* weight  = 0\n",
    "* left        = None\n",
    "* right      = None\n",
    "\n",
    "Multiplication is overloaded to perform bracket"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "import re   # used for weakly comparing trees \n",
    "\n",
    "class ValueTree():\n",
    "    \"\"\"ValueTree is class with attributes and methods common to trees of values\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    value : str     (default = \"\")\n",
    "          Value for the root vertex of tree (used to generate the rest of tree)\n",
    "    root  : boolean (default = True)\n",
    "          Indicates if this is the root vertex (first call) of tree\n",
    "          \n",
    "    Attributes\n",
    "    ----------\n",
    "    value    : string\n",
    "          Value of this vertex\n",
    "    weight   : integer\n",
    "          Weight (number of edges) supported by vertex\n",
    "    _branches : list of ValueTrees\n",
    "          Array of child nodes (subtrees)\n",
    "    \"\"\"\n",
    "    \n",
    "    \n",
    "    _pos = 0   # use global position variable when scanning expressions to build trees\n",
    "    \n",
    "    \n",
    "    def __init__(self,root=True):\n",
    "        self._branches = []   # list of branches out of vertex (\"child trees\")\n",
    "        self.value    = \"\"     # value tree stores a value at each vertex\n",
    "        self.weight   = -1     # weight is total number of edges supported at vertex\n",
    "                \n",
    "        if root:               # if this is not within a recursion\n",
    "            ValueTree._pos = 0 #  then start reading at the beginning\n",
    "\n",
    "            \n",
    "    def __str__(self):\n",
    "        \"\"\"String version of tree is value at root\"\"\"\n",
    "        return self.value\n",
    "    \n",
    "    \n",
    "    def __len__(self):\n",
    "        \"\"\"weight is number of edges, len is number of vertices\"\"\"\n",
    "        return self.weight + 1\n",
    "    \n",
    "        \n",
    "    def letters(self):\n",
    "        \"\"\"Get letters and multiplicities from tree\"\"\"\n",
    "        return ''.join(sorted(re.sub(r'[/\\W+/g]', '', self.value))) \n",
    "    \n",
    "    #########################\n",
    "    # & is 'weak pairing' -- verify that objects use same letters with same multiplicity\n",
    "    #                        this is used when computing pairings of symbols and Lie brackets\n",
    "    #\n",
    "    def __and__(self,other):\n",
    "        \"\"\"weak pairing of two objects: compare letters and multiplicity\"\"\"\n",
    "        \n",
    "        if self.weight != other.weight:                           # check lengths\n",
    "            return False\n",
    "        \n",
    "        for x in list(set(re.sub(r'[/\\W+/g]', '', self.value))):  # get list of unique letters\n",
    "            if not self.value.count(x) == other.value.count(x):   # compare multiplicity of letters\n",
    "                return False\n",
    "        return True\n",
    "    #\n",
    "    ##########################\n",
    "    \n",
    "\n",
    "    \n",
    "    def __iter__(self):\n",
    "        \"\"\"Dept-first iteration\"\"\"\n",
    "        yield self\n",
    "        \n",
    "        for branch in self._branches:\n",
    "            for twig in branch:\n",
    "                yield twig\n",
    "                \n",
    "        # note: maybe better to use chain and imap from itertools???\n",
    "        #\n",
    "        # from itertools import chain, imap\n",
    "        # for node in chain(*imap(iter, self._branches)):\n",
    "        #     yield node\n",
    "        # yield self\n",
    "\n",
    "        \n",
    "    #################\n",
    "    #\n",
    "    #  currently unused methods, but interesting\n",
    "    #\n",
    "    def __bool__(self):\n",
    "        \"\"\"True if tree is nonempty\"\"\"\n",
    "        return self.weight != -1\n",
    "       \n",
    "    \n",
    "    def __eq__(self,other):\n",
    "        \"\"\"trees are equal if values at root are equal\"\"\"\n",
    "        return str(self) == str(other)\n",
    "    \n",
    "    \n",
    "    def __lt__(self,other):\n",
    "        \"\"\"ordering is by weight then value\"\"\"\n",
    "        return (self.weight, self.value) < (other.weight, other.value)\n",
    "    \n",
    "        \n",
    "        \n",
    "##################################################################\n",
    "##################################################################\n",
    "\n",
    "   \n",
    "class LieTree(ValueTree):\n",
    "    \"\"\"LieTree is a Lie bracket and tree of subbrackets, used to quickly get left and right subbrackets\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    bracket : string   (default \"\")\n",
    "         The Lie bracket to split apart. Use letters for generators, spaces are ignored, commas optional.\n",
    "    root    : boolean  (default True)\n",
    "         This parameter is only used interally when recursively building a tree.  DON'T USE IT!\n",
    "         \n",
    "    Example\n",
    "    -------\n",
    "    bracket = LieTree(\"[ [a,b] , [ [c,d], e] ]\")\n",
    "    \n",
    "    \n",
    "    Attributes\n",
    "    ----------\n",
    "    value    : string\n",
    "         The Lie bracket supported at this node\n",
    "    weight   : integer\n",
    "         The weight (number of bracket symbols) of bracket\n",
    "    bracket  : list of LieTrees\n",
    "         The left and right subbrackets\n",
    "    short    : string\n",
    "         Short version of bracket (don't print ,)\n",
    "    \"\"\"\n",
    "\n",
    "    \n",
    "    def __init__(self, bracket=\"\", root=True):\n",
    "        super().__init__(root)\n",
    "        \n",
    "        if root:            # on initial call, strip whitespace, comma, and ]\n",
    "            #                 (assume valid bracket input with single letter entries)\n",
    "            bracket = re.sub(r'[\\],\\s]', '', bracket)\n",
    "     \n",
    "        if bracket == \"\":\n",
    "            return\n",
    "        \n",
    "        # read left to right across the bracket expression using the _pos pointer to\n",
    "        # track where we are looking between recursive calls\n",
    "\n",
    "        \n",
    "        if bracket[ValueTree._pos] == \"[\":   # this node is a bracket of subexpressions\n",
    "            ValueTree._pos += 1                            # advance past [\n",
    "            \n",
    "            self.bracket = [LieTree(bracket,False) , LieTree(bracket,False)] \n",
    "\n",
    "        else:                            # this node is a single element\n",
    "            self.value  = bracket[ValueTree._pos]         # include element\n",
    "            self.weight = 0\n",
    "            ValueTree._pos += 1                           # advance to next position\n",
    "                    \n",
    "\n",
    "    @property\n",
    "    def bracket(self):\n",
    "        return _branches\n",
    "    \n",
    "    \n",
    "    @bracket.setter\n",
    "    def bracket(self, bracket):\n",
    "        \"\"\"\"set left and right values of bracket -- only do this at a root!\"\"\"\n",
    "        self._branches = bracket\n",
    "        self.value = f'[{self._branches[0].value},{self._branches[1].value}]'\n",
    "        self.weight = 1 + self._branches[0].weight + self._branches[1].weight\n",
    "\n",
    "\n",
    "    @property\n",
    "    def left(self):\n",
    "        \"\"\"Left subbracket expression\"\"\"\n",
    "        \n",
    "        if self.weight > 0:\n",
    "            return self._branches[0]\n",
    "        \n",
    "        return None\n",
    "    \n",
    "    @property\n",
    "    def right(self):\n",
    "        \"\"\"Right subbracket expression\"\"\"\n",
    "        \n",
    "        if self.weight > 0:\n",
    "            return self._branches[1]\n",
    "        \n",
    "        return None        \n",
    "    \n",
    "    @left.setter\n",
    "    def left(self, subbracket):\n",
    "        \"\"\"set left subbracket -- only do this at the root!\"\"\"\n",
    "        if len(self._branches) == 0:\n",
    "            self._branches.append(subbracket)\n",
    "        else:\n",
    "            self._branches[0] = subbracket\n",
    "        \n",
    "        if len(self._branches) == 2 and isinstance(self._branches[1],LieTree):\n",
    "            self.value  = f'[{self._branches[0].value},{self._branches[1].value}]'\n",
    "            self.weight = 1 + self._branches[0].weight + self._branches[1].weight\n",
    "            \n",
    "    @right.setter\n",
    "    def right(self, subbracket):\n",
    "        \"\"\"set right subbracket -- only do this at the root!\"\"\"\n",
    "        if len(self._branches) == 0:\n",
    "            self._branches[0] = None\n",
    "            self._branches.append(subbracket)\n",
    "        elif len(self._branches) == 1:\n",
    "            self._branches.append(subbracket)\n",
    "        else:            \n",
    "            self._branches[1] = subbracket\n",
    "        \n",
    "        if isinstance(self._branches[0],LieTree):\n",
    "            self.value  = f'[{self._branches[0].value},{self._branches[1].value}]'\n",
    "            self.weight = 1 + self._branches[0].weight + self._branches[1].weight\n",
    "        \n",
    "    \n",
    "    @property\n",
    "    def short(self):\n",
    "        return re.sub(',','', self.value)\n",
    "    \n",
    "    @short.setter         # you probably shouldn't change the bracket value of a node\n",
    "    def short(self,string):\n",
    "        value = list(string)\n",
    "        for i in reversed(range(1,len(value))):\n",
    "            if ((value[i-1].isalpha() and value[i].isalpha()) or\n",
    "                (value[i-1] == ']'    and value[i].isalpha()) or\n",
    "                (value[i-1].isalpha() and value[i] == '[')):\n",
    "                value[i:i] = [',']\n",
    "        self.value = ''.join(value)\n",
    "       \n",
    "        \n",
    "        \n",
    "    ###################\n",
    "    #\n",
    "    # Interesting things that aren't currently used\n",
    "    #    \n",
    "    def __mul__(self, other):\n",
    "        \"\"\"Overload multiplication to be Lie bracket\"\"\"\n",
    "        \n",
    "        if isinstance(other, LieTree):\n",
    "            product = LieTree()\n",
    "        \n",
    "            product.bracket = [ self , other ]\n",
    "            \n",
    "            return product\n",
    "        \n",
    "        return NotImplemented\n",
    "\n",
    "        \n",
    "    def __repr__(self):\n",
    "        return f\"LieTree('{self.value}')\"\n",
    "\n",
    "\n",
    "##################################################################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "Test the code so far by making a Lie tree and iterating through the subexpressions.\n",
    "\n",
    "Also test products and .left .right attributes\n",
    "\n",
    "And test weak comparison operator & which compares the grading by number of generators in expressions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      bracket = [a,[[b,c],[d,[e,f]]]]\n",
      "short version = [a[[bc][d[ef]]]]\n",
      "\n",
      " subbrackets:\n",
      "[a,[[b,c],[d,[e,f]]]]\n",
      "a\n",
      "[[b,c],[d,[e,f]]]\n",
      "[b,c]\n",
      "b\n",
      "c\n",
      "[d,[e,f]]\n",
      "d\n",
      "[e,f]\n",
      "e\n",
      "f\n",
      "\n",
      "[[a,b],[c,d]]\n",
      "[a,b]\n",
      "[c,d]\n",
      "True\n",
      "False\n",
      "abcd\n"
     ]
    }
   ],
   "source": [
    "#################################################\n",
    "#     TESTING BLOCK!!!!                         #\n",
    "#################################################\n",
    "\n",
    "lie = LieTree(\"[a,[[b,c],[d,[e,f]]]]\")\n",
    "\n",
    "print(f'      bracket = {lie}\\nshort version = {lie.short}\\n\\n subbrackets:')\n",
    "\n",
    "for n in lie:\n",
    "    print(n)\n",
    "\n",
    "print()\n",
    "\n",
    "lie = LieTree(\"[a,b]\") * LieTree(\"[c,d]\")\n",
    "print(lie)\n",
    "\n",
    "print(lie.left)\n",
    "print(lie.right)\n",
    "\n",
    "print(LieTree(\"[[a,a],[b,c]]\") & LieTree(\"[[a,b],[c,a]]\"))  # grading is 2a 1b 1c for both\n",
    "print(LieTree(\"[[a,b],[b,c]]\") & LieTree(\"[[a,b],[c,a]]\"))  # grading for left is 1a 2b 1c\n",
    "\n",
    "print(lie.letters())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "--------\n",
    "--------\n",
    "### EilWord\n",
    "\n",
    "EilWord is a data structure for linear symbols, such as (((a)b)c)d.  Such symbols generate all Eil symbols (with relations given by the shuffle products).  We can write linear symbols as (associative) words: abcd instead of (((a)b)c)d.  It is fairly easy to pair these with Lie brackets and evaluate them on finitely presented group elements, but they don't give much freedom for choosing good bases.  Note that the coproduct on Eil words is given by cutting... so this is a \"warm-up\" for working with full general symbols.\n",
    "\n",
    "EilWords are initialized by supplying an associative word.  For example:\n",
    "> EilWord(\"abaa\")\n",
    "\n",
    "Attributes are:\n",
    "* value:    associative word\n",
    "* weight:   length - 1 \n",
    "* symbol:  symbol representation of word\n",
    "\n",
    "Multiplication / using as a function is overloaded so that it performs pairing with bracket / evaluating on word:\n",
    "* EilWord * LieTree computes the Lie coalgebra-algebra pairing of symbols and brackets\n",
    "* EilWord * SignedWord computes the combinatorial braiding product of a symbol and a word"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "##################################################################\n",
    "\n",
    "class EilWord():\n",
    "    \"\"\"EilWord is a linear coLie symbol <=> associative word\n",
    "      EilWord objects have multiplication overloaded to perform pairing with Lie brackets and configuration braiding with group elements\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    word : string   (default \"\")\n",
    "        This is the linear symbol written as a word Example: abaa <=> (((a)b)a)a\n",
    "\n",
    "         \n",
    "    Example\n",
    "    -------\n",
    "    word = EilWord(\"abaab\")\n",
    "    \n",
    "    \n",
    "    Attributes\n",
    "    ----------\n",
    "    value    : string\n",
    "         The word\n",
    "    weight   : integer\n",
    "         The weight of the corresponding symbol\n",
    "    symbol   : string\n",
    "         The symbol corresponding to the associative eil word\n",
    "    \"\"\"\n",
    "    \n",
    "    \n",
    "    def __init__(self,word):\n",
    "        self.value = word\n",
    "    \n",
    "    \n",
    "\n",
    "    def __mul__(self,other):\n",
    "        \"\"\"Multiplication is overloaded to compute pairing with Lie brackets and configuration braiding with group elements\"\"\"\n",
    "        \n",
    "        #########################\n",
    "        #\n",
    "        # Pairing with Lie Brackets recursively using bracket-cobracket compatibility from [SiWa]\n",
    "        #\n",
    "        if isinstance(other, LieTree):\n",
    "            \n",
    "            if not self.__weakPair(self.value,other):  # check weakpairing\n",
    "                return 0    \n",
    "            \n",
    "            return self.__pair(self.value,other)       # recursively comput pairing\n",
    "        \n",
    "       \n",
    "        #########################\n",
    "        #\n",
    "        # Counting configuration braidings in words using algorithm from [GOSW]\n",
    "        #\n",
    "        if isinstance(other, SignedWord):        # Algorithm in [GOSW]:\n",
    "            \n",
    "            sum   = [0] * len(self.value)        # s value for each eil position\n",
    "            delta = [0] * len(self.value)        # Δ value for each eil position\n",
    "            \n",
    "            for letter in other:                 # pass across the word\n",
    "                for i in range(len(self.value)): #  evaluating eil symbol from leaf to root\n",
    "                    \n",
    "                    sum[i]  += delta[i]          # 1. add Δ value to s value\n",
    "                    delta[i] = 0                 #    and set Δ to 0 \n",
    "                    \n",
    "                    value = 0                    # 2. get value of branches\n",
    "                    \n",
    "                    if self.value[i] == letter.value:   # check if update is needed\n",
    "                        if i == 0:               #    at first vertex there is no branch\n",
    "                            value = 1 \n",
    "                        else:                    #    otherwise look at value above\n",
    "                            value = sum[i-1]\n",
    "                            \n",
    "                    if not letter:               # 3. update s and Δ\n",
    "                        sum[i]  -= value         #    at inverses, immediately update s\n",
    "                    else:\n",
    "                        delta[i] = value         #    at generators, update Δ\n",
    "                        \n",
    "            return sum[-1] + delta[-1]           # Braiding value is s + Δ at root\n",
    "        \n",
    "        \n",
    "        return NotImplemented\n",
    "    \n",
    "    \n",
    "    \n",
    "    def __weakPair(self,word,lie):\n",
    "        \"\"\"weakPair is used internally to quickly rule out pairings that will be 0\n",
    "           It only compares multiplicity of letters appearing in word and Lie bracket\n",
    "           This is the analog of the & operation in ValueTree (which is used for general symbols)\n",
    "        \"\"\"\n",
    "                \n",
    "        if len(word) != len(lie):                         # compare length\n",
    "            return False\n",
    "        \n",
    "        for x in list(set(word)):                         # get list of unique letters\n",
    "            if not word.count(x) == lie.value.count(x):   # compare multiplicity of letters\n",
    "                return False\n",
    "        return True\n",
    "\n",
    "    \n",
    "    \n",
    "    def __pair(self,word,other):\n",
    "        \"\"\"pair is used internally to recursively compute pairings of eil words with Lie brackets\n",
    "           Pairing is computed by recursively using bracket-cobracket duality. Cobracket of eil words is given by cutting.\n",
    "           To speed things up, we compare size and letter grading (weakPair) before recursing.  This immediately eliminates most 0 pairings.\n",
    "        \"\"\"\n",
    "        \n",
    "        if len(word) == 1:                  # Base case!  Length 1 words are just a single generator\n",
    "            return int(word == other.value) # Check if generators match!\n",
    "        \n",
    "        pairing = 0                         # Otherwise we use cobracket-bracket compatibility with pairing [SiWa]\n",
    "        \n",
    "        #       < eil , lie > =  < L(eil) , L(lie) > * < R(eil) , R(lie) >\n",
    "        #                      - < R(eil) , L(lie) > * < L(eil) , R(lie) >\n",
    "        #\n",
    "        # where  ]eil[ = sum L(eil) x R(eil)   and    lie = [ L(lie) , R(lie) ]\n",
    "        \n",
    "        if self.__weakPair(word[:len(other.left)], other.left):     # before recursing, weakpair start with left \n",
    "            pairing += self.__pair(word[:len(other.left)],other.left) * self.__pair(word[len(other.left):],other.right)\n",
    "\n",
    "        if self.__weakPair(word[:len(other.right)], other.right):   # before recursing, weakpair start with right \n",
    "            pairing -= self.__pair(word[:len(other.right)],other.right) * self.__pair(word[len(other.right):],other.left)            \n",
    "\n",
    "            \n",
    "        return pairing\n",
    "    \n",
    "    \n",
    "    #####################\n",
    "    #\n",
    "    # maybe we should allow eil(lie) instead of just eil * lie ???\n",
    "    #\n",
    "    def __call__(self, other):\n",
    "        return self * other\n",
    "    \n",
    "    \n",
    "    \n",
    "    def __str__(self):\n",
    "        return self.value\n",
    "    \n",
    "    \n",
    "    \n",
    "    ###################\n",
    "    #\n",
    "    # Interesting things that aren't currently used\n",
    "    #\n",
    "    @property\n",
    "    def symbol(self):\n",
    "        n = len(self.value)-2\n",
    "\n",
    "        symbol = ['('] * (n+1)\n",
    "        symbol.append(self.value[0])\n",
    "        for i in range(1,len(self.value)):\n",
    "            symbol.extend([')',self.value[i]])\n",
    "                        \n",
    "        return ''.join(symbol) \n",
    "\n",
    "    \n",
    "    @property\n",
    "    def weight(self):\n",
    "        return len(self.value)-1\n",
    "       \n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.value)\n",
    "\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return f'EilWord(\"{self.value}\")'\n",
    "    \n",
    "    \n",
    "    def __eq__(self,other):\n",
    "        return self.value == other.value\n",
    "    \n",
    "    \n",
    "    def __lt__(self,other):\n",
    "        return self.value < other.value\n",
    "    \n",
    "    \n",
    "    def cobracket(self):\n",
    "        \"\"\"This returns a generator which yields tuples of the cobracket (cutting the word at each position)\"\"\"\n",
    "        return ( (EilWord(self.value[:n]), EilWord(self.value[n:]))  for n in range(1, len(self.value)) )\n",
    "    \n",
    "    \n",
    "##################################################################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "Let's do some quick testing before continuing with full coLie symbols!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "aab --> ((a)a)b\n",
      "  pairing with [[a,b],a] = -1\n",
      " evaluation on [[a,b],a] = -1\n",
      "\n",
      " Cobracket of aabb:\n",
      "[('a', 'abb'), ('aa', 'bb'), ('aab', 'b')]\n",
      "\n",
      " Pairing matrix for (3,2) grading of Lie algebra:\n",
      "[1, 0]\n",
      "[-2, 1]\n"
     ]
    }
   ],
   "source": [
    "#################################################\n",
    "#     TESTING BLOCK!!!!                         #\n",
    "#################################################\n",
    "\n",
    "word = EilWord(\"aab\")\n",
    "print(f'{word} --> {word.symbol}')\n",
    "\n",
    "print(f'  pairing with [[a,b],a] = {word * LieTree(\"[[a,b],a]\")}')\n",
    "print(f' evaluation on [[a,b],a] = {word(LieTree(\"[[a,b],a]\"))}')\n",
    "\n",
    "word = EilWord(\"aabb\")\n",
    "\n",
    "print(f'\\n Cobracket of {word}:')\n",
    "print([(str(cobr[0]),str(cobr[1])) for cobr in word.cobracket()])\n",
    "\n",
    "print(\"\\n Pairing matrix for (3,2) grading of Lie algebra:\")\n",
    "print([EilWord(\"aaabb\")*LieTree(\"[a,[a,[[a,b],b]]]\"), EilWord(\"aaabb\")*LieTree(\"[[a,[a,b]],[a,b]]\")])\n",
    "print([EilWord(\"aabab\")*LieTree(\"[a,[a,[[a,b],b]]]\"), EilWord(\"aabab\")*LieTree(\"[[a,[a,b]],[a,b]]\")])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "----------\n",
    "----------\n",
    "### EilTree\n",
    "\n",
    "EilTree is a data structure for Lie cobrackets (symbols) which is used to quickly construct sub and quotient trees (symbols).  EilTrees are initialized by supplying a symbol representation on alphabetical generators using parenthesis as delimiters.\n",
    "\n",
    "[Recall that a symbol is an expression with nested parenthesis such that each parenthesis contains exactly one 'free' (not further parenthesized) generator.]\n",
    "\n",
    "Example:\n",
    "  > EilTree(\"( (a)(b)a ) ( ((b)b)a ) (b) a\")\n",
    "\n",
    "Whitespace is ignored when creating a symbol.  Any valid symbol is acceptable, for example (a)(b)c and (a)c(b) and c(a)(b) are all fine (and should be evaluated as equal symbols, though their storage structure will recall the given ordering, in case we want to add graded stsuff with Koszul signs later).\n",
    "\n",
    "Attributes are:\n",
    "* value:         string\n",
    "* weight:       number parenthesis in subexpression\n",
    "* branches:   list of subtrees\n",
    "* decoration: free generator at root\n",
    "* normalValue:  \"normalized\" symbol -- move all free variables to right, etc.\n",
    "\n",
    "Multiplication / using as function is overloaded so that it performs pairing with bracket / evaluation on word:\n",
    "* EilTree * LieTree computes the Lie coalgebra-algebra pairing of symbols and brackets\n",
    "* EilTree * SignedWord evaluates the combinatorial braiding of a symbol on a word"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "##################################################################\n",
    "\n",
    "class EilTree(ValueTree):\n",
    "    \"\"\"EilTree encodes the tree structure of a coLie symbol\n",
    "      EilTre objects have multiplication overloaded to perform pairing with Lie brackets and configuration braiding with group elements\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    symbol : string   (default \"\")\n",
    "         The symbol to split apart. Use letters for generators, spaces are ignored.\n",
    "    root   : boolean  (default True)\n",
    "         This parameter is only used interally when recursively building a tree.  DON'T USE IT!\n",
    "         \n",
    "    Example\n",
    "    -------\n",
    "    symbol = EilTree(\"( ((a)(b)b) (b ((a)b)) a)\")\n",
    "    \n",
    "    \n",
    "    Attributes\n",
    "    ----------\n",
    "    value      : string             (default: \"\")\n",
    "         The symbol supported at this node\n",
    "    decoration : string             (default: \"\")\n",
    "         The free variable of the symbol (at the given node)\n",
    "    weight     : integer            (default: -1)\n",
    "         The weight (number of parenthesis pairs) of symbol (supported by the given node)\n",
    "    subsymbols : list of EilTree's  (default: [])\n",
    "         The immediate subsymbols of the given symbol\n",
    "    normalValue : string\n",
    "         A \"normalized\" version of the symbol -- move free variables to right, etc\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, symbol=\"\", root=True):\n",
    "        super().__init__(root)\n",
    "        \n",
    "        self.decoration = \"\"     # keep track of decoration for each vertex\n",
    "\n",
    "        if root:                 # on initial call, strip whitespace\n",
    "            symbol = symbol.translate(str.maketrans('', '', ' \\n\\t\\r'))\n",
    "            \n",
    "        if symbol == \"\":\n",
    "            return\n",
    " \n",
    "        # read left to right across the symbol expression using the _pos pointer to\n",
    "        # track where we are looking between recursive calls\n",
    "\n",
    "        start = ValueTree._pos           # this is the staring position for the subsymbol\n",
    "        \n",
    "        while ValueTree._pos < len(symbol) and not symbol[ValueTree._pos] == \")\":\n",
    "            \n",
    "            if symbol[ValueTree._pos] == \"(\":            # begin a subsymbol\n",
    "                ValueTree._pos  += 1                       # advance into subsymbol\n",
    "                self._branches.append(EilTree(symbol,False))# append new subtree\n",
    "                \n",
    "            else:                                        # this is free variable (decoration of vertex)\n",
    "                self.decoration = symbol[ValueTree._pos]   # record free variable\n",
    "                ValueTree._pos += 1                        # advance past\n",
    "                \n",
    "        end = ValueTree._pos             # this is the ending position for the subsymbol\n",
    "        \n",
    "        self.value = symbol[start:end]   # this is the current subsymbol\n",
    "        \n",
    "        self.weight = sum([branch.weight + 1 for branch in self.subsymbols])\n",
    "        # self.weight = self.value.count('(')            # this is equivalent but probably slower?\n",
    "\n",
    "        ValueTree._pos += 1      # advance past the closing of subsymbol\n",
    "\n",
    "        \n",
    "\n",
    "    def __mul__(self, other):\n",
    "        \"\"\"Multiplication is overloaded to compute pairing with Lie brackets and configuration braiding with group elements\"\"\"\n",
    "        \n",
    "        #########################\n",
    "        #\n",
    "        # Pairing with Lie Brackets recursively using bracket-cobracket compatibility from [SiWa]\n",
    "        #   \n",
    "        if isinstance(other, LieTree):\n",
    "            \n",
    "            if not self & other:       # check weakpairing\n",
    "                return 0    \n",
    "            \n",
    "            return self.__pair(other)  # recursively compute pairing\n",
    "  \n",
    "\n",
    "        #########################\n",
    "        #\n",
    "        # Counting configuration braidings in words using algorithm from [GOSW]\n",
    "        #\n",
    "        if isinstance(other, SignedWord):\n",
    "            counter = CountTree(self)    # analog of sum and delta arrays for EilWord\n",
    "            \n",
    "            for letter in other.word:\n",
    "                counter.evaluate(letter) # evaluate the counter on each letter in the word\n",
    "                \n",
    "            return counter.total         # this is s + Δ at root\n",
    "            \n",
    "        \n",
    "        return NotImplemented\n",
    "    \n",
    "    \n",
    "    \n",
    "    def __pair(self, other):\n",
    "        \"\"\"pair is used internally to recursively compute pairings of eil symbols with Lie brackets\n",
    "           Pairing is computed by recursively using bracket-cobracket duality. \n",
    "           Cobracket of symbols is given by cutting out a subtree, yielding sub and excised trees.\n",
    "           To speed things up, we compare size and letter grading (weakPair) before recursing.  This immediately eliminates most 0 pairings.\n",
    "        \"\"\"        \n",
    "        \n",
    "        if self.weight == 0:            # Base case! Symbol is a single character \n",
    "            return int(self.value == other.value)   # compare vs Lie value\n",
    "        \n",
    "        pairing = 0          # Otherwise we use cobracket-bracket compatibility with pairing [SiWa]\n",
    "        \n",
    "        #       < eil , lie > =  < L(eil) , L(lie) > * < R(eil) , R(lie) >\n",
    "        #                      - < R(eil) , L(lie) > * < L(eil) , R(lie) >\n",
    "        #\n",
    "        # where  ]eil[ = sum L(eil) x R(eil)   and    lie = [ L(lie) , R(lie) ]\n",
    "        #    L(eil) is subsymbol\n",
    "        #    R(eil) is result of excising subsymbol\n",
    "        \n",
    "        for subsymbol in self:           # iterate through all subsymbols of symbol\n",
    "            if subsymbol & other.left:   #   weakpair with subsymbol first, since excised symbol requires computation\n",
    "                pairing += subsymbol.__pair(other.left) * self.__excise(subsymbol).__pair(other.right)\n",
    "            \n",
    "            if subsymbol & other.right:  #   weakpair with subsymbol first, since excised symbol requires computation\n",
    "                pairing -= subsymbol.__pair(other.right) * self.__excise(subsymbol).__pair(other.left)\n",
    "            \n",
    "        return pairing\n",
    "    \n",
    "        # Note: this might be sped up by sorting subsymbols by weight initially rather than searching for weights matching other.left and other.right\n",
    "                \n",
    "               \n",
    "        \n",
    "       \n",
    "    def __excise(self, subsymbol):  \n",
    "        \"\"\"excise is used internally to compute the symbol remaining after a subsymbol is removed\n",
    "           It recursively copies a tree, skipping the excised subsymbol (and its supported subtree).\n",
    "        \"\"\"\n",
    "        \n",
    "        #if self is subsymbol:  # This should never happen during internal recursive usage!\n",
    "        #    return EilTree()   \n",
    "        \n",
    "        eil = EilTree()        # Begin with a blank node\n",
    "        \n",
    "        eil.decoration = self.decoration # copy the decoration\n",
    "        \n",
    "        if self.weight == 0:   # Direct copy if this is a leaf node\n",
    "            eil.weight = 0\n",
    "            eil.value  = self.value\n",
    "            \n",
    "        else:    \n",
    "            eil.subsymbols = [symbol.__excise(subsymbol) for symbol in self.subsymbols if not symbol is subsymbol]\n",
    "            \n",
    "        return eil\n",
    "    \n",
    "    @property\n",
    "    def subsymbols(self):\n",
    "        return self._branches\n",
    "    \n",
    "    @subsymbols.setter\n",
    "    def subsymbols(self, list):\n",
    "        self._branches = list\n",
    "        self.value = ''.join([f'({str(branch)})' for branch in self._branches]+[self.decoration])\n",
    "        self.weight = sum([branch.weight + 1 for branch in self._branches])   \n",
    "    \n",
    "    # I like to write free elements last, so append() and extend()  will actually insert at start...   \n",
    "    def append(self, subsymbol):\n",
    "        self._branches[:0] = [subsymbol]                  # insert subsymbol at start\n",
    "        self.weight += subsymbol.weight+1                 # add to weight\n",
    "        self.value   = f'({subsymbol.value}){self.value}' # add to value \n",
    "        \n",
    "    def extend(self, subsymbols):\n",
    "        self._branches[:0] = subsymbols\n",
    "        self.weight += sum([symbol.weight+1 for symbol in subsymbols])\n",
    "        tmp          = ')('.join([symbol.value for symbol in subsymbols])\n",
    "        self.value   = f'({tmp}){self.value}'\n",
    "\n",
    "    def copy(self):\n",
    "        \"\"\"Make a deep copy of symbol and subsymbols\"\"\"\n",
    "        eil = EilTree()\n",
    "        eil.decoration = self.decoration\n",
    "        eil.value , eil.weight = self.value , self.weight\n",
    "                \n",
    "        if len(self._branches) > 0:\n",
    "            eil._branches = [subsymbol.copy() for subsymbol in self._branches]\n",
    "        \n",
    "        return eil      \n",
    "\n",
    "    \n",
    "    ###################\n",
    "    #\n",
    "    # Interesting things that aren't currently used\n",
    "    #\n",
    "    @property\n",
    "    def normalValue(self):       # the normal Value has free terms written last\n",
    "        if self.weight == 0:     #  this should probably also sort branches nicely\n",
    "            return self.value    #  define < used for sorting later....\n",
    "        \n",
    "        return ''.join([f'({branch.normalValue})' for branch in sorted(self._branches,reverse=True)]+[self.decoration])\n",
    " \n",
    "\n",
    "    \n",
    "    def normalize(self):\n",
    "        \"\"\"Convert EilTree to 'normalized' form -- sort branches and move free letter to the far right\"\"\"\n",
    "        for symbol in self._branches:    \n",
    "            symbol.normalize()\n",
    "            \n",
    "        #self.value = ''.join([f'({str(branch)})' for branch in sorted(self.branches,reverse=True)]+[self.decoration])\n",
    "        self.subsymbols = [branch for branch in sorted(self._branches,reverse=True)]\n",
    "     \n",
    "    \n",
    "    def __eq__(self,other):               # compare normalized forms so (a)b == b(a)\n",
    "        if isinstance(other, EilTree):    #   Note: isn't perfect...\n",
    "            return self.normalValue == other.normalValue\n",
    "        \n",
    "        return False\n",
    "  \n",
    "\n",
    "    # < is used when writing in normal form and comparing EilTrees\n",
    "    def __lt__(self,other):\n",
    "        if self.value == other.value:     # if values match then these are equal\n",
    "            return False\n",
    "        \n",
    "                                          # next sort by weight and decoration\n",
    "        if (self.weight,self.decoration) < (other.weight,other.decoration):\n",
    "            return True\n",
    "        if (self.weight,self.decoration) > (other.weight,other.decoration):\n",
    "            return False\n",
    "        \n",
    "                                          # next sort by number of branches\n",
    "        if len(self.subsymbols) < len(other.subsymbols):\n",
    "            return True\n",
    "        if len(self.subsymbols) > len(other.subsymbols):\n",
    "            return False\n",
    "        \n",
    "                                           # next look at decorations and weights of branches\n",
    "        return sorted([(branch.decoration,branch.weight) for branch in self.subsymbols]) < sorted([(branch.decoration,branch.weight) for branch in other.subsymbols])\n",
    "    \n",
    "        # note: this may incorrectly sort a(a(b)) and a(a(c))\n",
    "    \n",
    "    \n",
    "        \n",
    "    def __gt__(self,other):\n",
    "        return other < self\n",
    "        \n",
    "        \n",
    "    def __repr__(self):\n",
    "        return f\"EilTree('{self.value}')\"        \n",
    "    \n",
    "    \n",
    "    \n",
    "    ################\n",
    "    #\n",
    "    # allow eil(lie) instead of just eil * lie\n",
    "    #\n",
    "    def __call__(self, other):\n",
    "        return self * other\n",
    "\n",
    "    \n",
    "    def cobracket(self): \n",
    "        \"\"\"returns a generator with tuples of cobracket elements\"\"\"\n",
    "        subsymbols = iter(self)\n",
    "        next(subsymbols)    # the first term in the iterator is the entire symbol (skip it)\n",
    "        \n",
    "        return ((subsymbol,self.__excise(subsymbol)) for subsymbol in subsymbols)\n",
    "    \n",
    "##################################################################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "Test the code so far by making an EilTree and getting normalized version of symbol\n",
    "\n",
    "Also test the pairing computation of some symbols and Lie brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(((g)(f)e)((f)d)c)(((f)(f)e)((f)d)c)(b)(a)c\n",
      "abcccddeefffff\n",
      "-1\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "#################################################\n",
    "#     TESTING BLOCK!!!!                         #\n",
    "#################################################\n",
    "\n",
    "eil = EilTree(\"c(b)(a)(c(d(f))(e(f)(g)))(c(d(f))(e(f)(f))\")\n",
    "\n",
    "print(eil.normalValue)\n",
    "\n",
    "print(eil.letters())\n",
    "\n",
    "print(EilTree(\"(a)b(c)\") * LieTree(\"[a,[b,c]]\"))\n",
    "\n",
    "print(EilTree(\"(((a)b)c)d\") * LieTree(\"[[[a,b],c],d]\"))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "------------\n",
    "------------\n",
    "### SignedWord\n",
    "\n",
    "SignedWord is a data structure for storing finitely presented group elements.  SignedWords can be initialized in a few different ways.\n",
    "\n",
    "Using LaTeX notation:\n",
    "> SignedWord(\"aba^{-1}b^{-1}\")\n",
    "\n",
    "Using \"lazy\" notation:\n",
    "> SignedWord(\"aba-b-\")\n",
    "\n",
    "As an array:\n",
    "> SignedWord( [ (\"a\",1), (\"b\",1), (\"a\",-1), (\"b\",-1) ] )\n",
    "\n",
    "Multiplying an EilTree or an EilWord by a signed word will evaluate the combinatorial braiding value of the symbol on the word.\n",
    "\n",
    "For example\n",
    "> EilWord(\"aba\") * SignedWord(\"abab-a-\")\n",
    "\n",
    "will compute the (signed) count of \"a then b then a\" within the word $abab^{-1}a^{-1}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "##################################################################\n",
    "\n",
    "\n",
    "class CountTree():\n",
    "    \"\"\"CountTree is a helper class for combinatorial braiding of coLie symbols on words.\n",
    "    This copies the structure of an EilTree and takes the place of the 'sum' and 'delta' arrays that were used in the __mul__ method of EilWord. \n",
    "    \n",
    "    Objects of this class should only be used internally!\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    eil : EilTree\n",
    "       corresponding node of an EilTree\n",
    "       \n",
    "    Attributes\n",
    "    ----------\n",
    "    sum      : integer\n",
    "       current s value for this node (initialized to 0)\n",
    "    delta    : integer\n",
    "       current Δ value for this node (initialized to 0)\n",
    "    branches : list of CountTree's\n",
    "       list of branches from this node\n",
    "    eil      : EilTree\n",
    "       corresponding node of the EilTree\n",
    "    total    : integer\n",
    "       sum + delta\n",
    "    \"\"\"\n",
    "    \n",
    "    \n",
    "    def __init__(self,eil):\n",
    "        self.sum   = 0\n",
    "        self.delta = 0\n",
    "        self.eil   = eil\n",
    "        \n",
    "        self.branches = [CountTree(branch) for branch in eil.subsymbols]\n",
    "        \n",
    "        \n",
    "    @property \n",
    "    def total(self):\n",
    "        return self.sum + self.delta\n",
    "    \n",
    "    \n",
    "    def evaluate(self,letter):\n",
    "        \"\"\"evaluate updates values of the counter tree at the given letter following the algorithm outlined in [GOSW]\n",
    "           Compare to the use of 'sum' and 'delta' arrays in the __mul__() method of EilWord.\n",
    "        \"\"\"\n",
    "        \n",
    "        \n",
    "        for branch in self.branches:    # Evaluate leaf to root\n",
    "            branch.evaluate(letter)     #   (update branch values first)   \n",
    "            \n",
    "        self.sum  += self.delta         # 1. add Δ to s\n",
    "        self.delta = 0                  #    and set Δ = 0\n",
    "        \n",
    "        value = 0                       # 2. incorporate values from branches\n",
    " \n",
    "        if letter.value == self.eil.decoration: # check if update is needed\n",
    "            if len(self.branches) == 0: #    at leaf just copy the value\n",
    "                value = 1\n",
    "            else:                       #    otherwise add values from branches\n",
    "                value = sum([branch.sum for branch in self.branches])\n",
    "            \n",
    "            \n",
    "        if not letter:                  # 3. at inverses, immediately update s\n",
    "            self.sum   -= value\n",
    "        else:                           #    otherwise, update Δ\n",
    "            self.delta  = value\n",
    "        \n",
    " \n",
    "\n",
    "    ###################\n",
    "    #\n",
    "    # Interesting things that aren't currently used\n",
    "    #\n",
    "    def __iter__(self):\n",
    "        for branch in self.branches:\n",
    "            for twig in branch:\n",
    "                yield twig          \n",
    "        yield self\n",
    "\n",
    "\n",
    "\n",
    "##################################################################\n",
    "##################################################################\n",
    "\n",
    "\n",
    "class SignedLetter():\n",
    "    \"\"\"SignedLetter is a letter with a sign, intended to represent a generator or an inverse\n",
    "     * as a boolean it is True for generator and False for inverse\n",
    "     * as an integer it is 1 for generator and -1 for inverse\n",
    "     * as a string it looks pretty\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    letter : string\n",
    "        this should be a single character\n",
    "    sign   : boolean or integer\n",
    "    \n",
    "    Examples: \n",
    "      SignedLetter(\"a\",False)\n",
    "      SignedLetter(\"a\",-1)\n",
    "    \n",
    "    Attributes\n",
    "    ----------\n",
    "    value : string\n",
    "        this is the letter\n",
    "    sign  : boolean\n",
    "        True corresponds to generator\n",
    "        False correspnds to inverse\n",
    "    \n",
    "    \"\"\"\n",
    "    def __init__(self,letter,sign):\n",
    "        self.value = letter\n",
    "        self.sign  = True if sign == 1 else False\n",
    "    \n",
    "    def __bool__(self):\n",
    "        return self.sign\n",
    "    \n",
    "    def __int__(self):\n",
    "        return 1 if self.sign else -1\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f'{self.value}' if self.sign else f'{self.value}\\N{SUPERSCRIPT MINUS}\\N{SUPERSCRIPT ONE}'\n",
    "\n",
    "\n",
    "##################################################################\n",
    "\n",
    "\n",
    "class SignedWord():\n",
    "    \"\"\"SignedWord is a list of SignedLetters\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    word : string or list\n",
    "    \n",
    "    Examples: \n",
    "     SignedWord(\"aba^{-1}b^{-1}\")\n",
    "     SignedWord(\"aba-b-\")\n",
    "     SignedWord( [ (\"a\",1), (\"b\",1), (\"a\",-1), (\"b\",-1) ] )\n",
    "    \n",
    "    Attributes\n",
    "    ----------\n",
    "    word : list of SignedLetters\n",
    "    \"\"\"\n",
    "    def __init__(self,word):\n",
    "        self.word = []\n",
    "        \n",
    "        if isinstance(word, str):\n",
    "            i = 0\n",
    "            while i < len(word):\n",
    "                if i+1 < len(word) and (word[i+1] == \"-\" or word[i+1] == \"^\"):\n",
    "                    self.word.append(SignedLetter(word[i],-1))\n",
    "                else:\n",
    "                    self.word.append(SignedLetter(word[i], 1))\n",
    "                i += 1\n",
    "                \n",
    "                while i < len(word) and not word[i].isalpha():\n",
    "                    i += 1\n",
    "        elif isinstance(word, list):\n",
    "            if isinstance(word[0], SignedLetter):\n",
    "                self.word = word\n",
    "            else:    \n",
    "                self.word = [SignedLetter(x[0],x[1]) for x in word]\n",
    "        else:\n",
    "            raise ValueError(\"Word format not recognized!\")\n",
    "            \n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.word)\n",
    "            \n",
    "    def __str__(self):\n",
    "        return ''.join([str(x) for x in self.word])\n",
    "        \n",
    "    def __iter__(self):\n",
    "        return iter(self.word)      \n",
    "    \n",
    "    def letters(self):\n",
    "        return ''.join(sorted(set([letter.value for letter in self.word])))\n",
    "\n",
    "    \n",
    "##################################################################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "Test the code by computing some letter braiding!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a⁻¹\n",
      "aba⁻¹b⁻¹\n",
      "aba⁻¹b⁻¹\n",
      "1\n",
      "1\n",
      "ab\n"
     ]
    }
   ],
   "source": [
    "#################################################\n",
    "#     TESTING BLOCK!!!!                         #\n",
    "#################################################\n",
    "\n",
    "print(SignedLetter('a',-1))\n",
    "\n",
    "print(SignedWord('a b a^{-1} b^{-1}'))\n",
    "\n",
    "print( SignedWord( [ (\"a\",1), (\"b\",1), (\"a\",-1), (\"b\",-1) ] ) )\n",
    "\n",
    "print(EilTree(\"(a)b\") * SignedWord(\"aba-b-\"))\n",
    "\n",
    "print(EilWord(\"ab\") * SignedWord(\"aba-b-\"))\n",
    "\n",
    "print(SignedWord(\"aba-b-\").letters())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "\n",
    "## Work continues in the [lieBasis.ipynb](https://cocalc.com/share/public_paths/ccde0bda31c37b3eef778f4b384d30f93cc45b5d) workbook.....\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "argv": [
    "sage-10.3",
    "--python",
    "-m",
    "sage.repl.ipython_kernel",
    "--matplotlib=inline",
    "-f",
    "{connection_file}"
   ],
   "display_name": "SageMath 10.3",
   "env": {
   },
   "language": "sagemath",
   "metadata": {
    "cocalc": {
     "description": "Open-source mathematical software system",
     "priority": 10,
     "url": "https://www.sagemath.org/"
    }
   },
   "name": "sage-10.3",
   "resource_dir": "/ext/jupyter/kernels/sage-10.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}