Alg_Examples.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far, there are two objects:\n",
    "- Sym_UTB_Matrix, which represents a direct sum of symbolic matrices (where each matrix in the direct sum is assumed to be an upper triangular block matrices)\n",
    "- UTB_Subspace, which represents a particular kind of subspace of a direct sum of upper triangular block matrices. In particular, the subspace is specified as: every block is either 0, can take any scalar value (i.e. a scalar times the identity), or can take the value of any matrix (of the appropariate dimension)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from Sym_UTB_Matrix import Sym_UTB_Matrix\n",
    "from UTB_Subspace import UTB_Subspace"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sym_UTB_Matrix - Simple example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider a simple example of these symbolic matrices, e.g. the generators for computing two first order Dyson terms:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Matrix([\n",
       " [G, A],\n",
       " [0, G]]), Matrix([\n",
       " [G, B],\n",
       " [0, G]])]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "first_order = Sym_UTB_Matrix([[['G','A'],[0,'G']], [['G','B'],[0,'G']]])\n",
    "first_order.mat_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can get a concise description of this matrix, i.e. a list of the unique symbols, along with their locations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape:\n",
      "------\n",
      "[2, 2]\n",
      "Non-commutative symbols:\n",
      "------------------------\n",
      "G {(1, 0, 0), (0, 1, 1), (1, 1, 1), (0, 0, 0)}\n",
      "A {(0, 0, 1)}\n",
      "B {(1, 0, 1)}\n",
      "Commutative symbols:\n",
      "--------------------\n"
     ]
    }
   ],
   "source": [
    "first_order.concise_display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above says: \n",
    "- the shape is [2,2], i.e. each matrix in the direct sum has block dimension 2\n",
    "- the unique non-commutative symbols are 'G', 'A', and 'B', and their locations are listed, where for the index (i, j, k), i represents which part of the direct sum it lives in, and (j,k) is the location of the block in that direct sum\n",
    "- Here, there are no commutative symbols (scalars)\n",
    "\n",
    "We can define another matrix of this form, and multiply them"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape:\n",
      "------\n",
      "[2, 2]\n",
      "Non-commutative symbols:\n",
      "------------------------\n",
      "G*H {(1, 0, 0), (0, 1, 1), (1, 1, 1), (0, 0, 0)}\n",
      "A*H + G*C {(0, 0, 1)}\n",
      "B*H + G*D {(1, 0, 1)}\n",
      "Commutative symbols:\n",
      "--------------------\n"
     ]
    }
   ],
   "source": [
    "first_order2 = Sym_UTB_Matrix([[['H','C'],[0,'H']], [['H','D'],[0,'H']]])\n",
    "first_product = first_order.mult(first_order2)\n",
    "first_product.concise_display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above shows the unique symbols in the product of the two, which in this case gives exactly a symbolic description of the reduced multiplication rules we are ultimately after.\n",
    "\n",
    "We can also add, or take powers of them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape:\n",
      "------\n",
      "[2, 2]\n",
      "Non-commutative symbols:\n",
      "------------------------\n",
      "G + H {(1, 0, 0), (0, 1, 1), (1, 1, 1), (0, 0, 0)}\n",
      "A + C {(0, 0, 1)}\n",
      "B + D {(1, 0, 1)}\n",
      "Commutative symbols:\n",
      "--------------------\n",
      "Shape:\n",
      "------\n",
      "[2, 2]\n",
      "Non-commutative symbols:\n",
      "------------------------\n",
      "G**2 {(1, 0, 0), (0, 1, 1), (1, 1, 1), (0, 0, 0)}\n",
      "A*G + G*A {(0, 0, 1)}\n",
      "B*G + G*B {(1, 0, 1)}\n",
      "Commutative symbols:\n",
      "--------------------\n"
     ]
    }
   ],
   "source": [
    "first_order.add(first_order2).concise_display()\n",
    "first_order.power(2).concise_display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### UTB_Subspace - simple example\n",
    "\n",
    "Next, consider the UTB_Subspace object. Here, we consider the form of a second order generator, and display it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unique non-commutative blocks:\n",
      "------------------------------\n",
      "1. frozenset({(0, 1, 1), (0, 0, 0), (0, 2, 2)})\n",
      "2. frozenset({(0, 0, 1)})\n",
      "3. frozenset({(0, 1, 2)})\n",
      "Unique commutative blocks:\n",
      "--------------------------\n",
      "Zero blocks:\n",
      "------------\n",
      "frozenset({(0, 0, 2)})\n"
     ]
    }
   ],
   "source": [
    "second_subspace = UTB_Subspace.from_matrix([['G', 'A', 0], [0,'G','B'], [0,0,'G']])\n",
    "second_subspace.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: what the matrix [['G', 'A', 0], [0,'G','B'], [0,0,'G']] represents when used to construct this object, is the subspace of 3x3 UTB matrices where the diagonal blocks are the same (but could be any matrix), the first off diagonal blocks can be any matrix, and the top rigth block is 0.\n",
    "\n",
    "As this object is supposed to represent a subspace, it \"forgets\" the symbols used, all it does is keep track of sets of indices that represent the same object (either a matrix, a scalar, or a zero block). (Note that we are storing them as frozensets due to implementation details.) The above description says that the diagonals are all the same matrix, and the first off diagonals are free to vary as any matrix, the top rigth block is 0, and the there are no commutative blocks (i.e. no blocks represented by scalars).\n",
    "\n",
    "The methods of this object are meant to represent manipulations one would normally want to consider for subspace. E.g. we can add subspaces to get a new subspace, multiply subspaces to get a new subspace, check if one subspace is a subset of another, or if they are equal.\n",
    "\n",
    "Importantly for us, we can check if the subspace also happens to be an algebra:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "second_subspace.is_algebra()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This subspace is not an algebra, i.e. if you multiply matrices in this subspace together, you get matrices outside of the subspace. Specifically, the top right block will become non-zero when these are multiplied together. We can see this by generating symbolic elements of the subspace, and multiplying them together."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mat1\n",
      "Shape:\n",
      "------\n",
      "[3]\n",
      "Non-commutative symbols:\n",
      "------------------------\n",
      "A0 {(0, 1, 1), (0, 0, 0), (0, 2, 2)}\n",
      "A1 {(0, 0, 1)}\n",
      "A2 {(0, 1, 2)}\n",
      "Commutative symbols:\n",
      "--------------------\n",
      "0 {(0, 0, 2)}\n",
      "mat2\n",
      "Shape:\n",
      "------\n",
      "[3]\n",
      "Non-commutative symbols:\n",
      "------------------------\n",
      "B0 {(0, 1, 1), (0, 0, 0), (0, 2, 2)}\n",
      "B1 {(0, 0, 1)}\n",
      "B2 {(0, 1, 2)}\n",
      "Commutative symbols:\n",
      "--------------------\n",
      "0 {(0, 0, 2)}\n",
      "mat1 mult mat2\n",
      "Shape:\n",
      "------\n",
      "[3]\n",
      "Non-commutative symbols:\n",
      "------------------------\n",
      "A0*B0 {(0, 1, 1), (0, 0, 0), (0, 2, 2)}\n",
      "A0*B1 + A1*B0 {(0, 0, 1)}\n",
      "A0*B2 + A2*B0 {(0, 1, 2)}\n",
      "A1*B2 {(0, 0, 2)}\n",
      "Commutative symbols:\n",
      "--------------------\n"
     ]
    }
   ],
   "source": [
    "mat1 = second_subspace.get_subspace_member(['A0','A1','A2'])\n",
    "mat2 = second_subspace.get_subspace_member(['B0','B1','B2'])\n",
    "\n",
    "print('mat1')\n",
    "mat1.concise_display()\n",
    "print('mat2')\n",
    "mat2.concise_display()\n",
    "\n",
    "print('mat1 mult mat2')\n",
    "mat1.mult(mat2).concise_display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since the subspace is not an algebra, we may want to retrieve the algebra it lives in:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unique non-commutative blocks:\n",
      "------------------------------\n",
      "1. frozenset({(0, 1, 1), (0, 0, 0), (0, 2, 2)})\n",
      "2. frozenset({(0, 0, 1)})\n",
      "3. frozenset({(0, 1, 2)})\n",
      "4. frozenset({(0, 0, 2)})\n",
      "Unique commutative blocks:\n",
      "--------------------------\n",
      "Zero blocks:\n",
      "------------\n",
      "frozenset()\n"
     ]
    }
   ],
   "source": [
    "second_alg = second_subspace.containing_algebra()\n",
    "second_alg.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that the description of second_alg is similar to second_subspace, except the top rigth block has been moved from a zero block, to a block that can take the value of any matrix.\n",
    "\n",
    "Lastly, we want to see how to more efficiently multiply matrices in this algebra. In particular, this algebra contains elements with 4 unique blocks, so we need to extract the rules for multiplying these matrices. (The interface for this is something I need to work on, but doing it with the existing code only requires a few lines.) To do this, we get two arbitrary symbolic representatives from the algebra, and multiply them together:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "first member:\n",
      "[Matrix([\n",
      "[A0, A1, A3],\n",
      "[ 0, A0, A2],\n",
      "[ 0,  0, A0]])]\n",
      "second member:\n",
      "[Matrix([\n",
      "[B0, B1, B3],\n",
      "[ 0, B0, B2],\n",
      "[ 0,  0, B0]])]\n",
      "multiplication rules:\n",
      "Shape:\n",
      "------\n",
      "[3]\n",
      "Non-commutative symbols:\n",
      "------------------------\n",
      "A0*B0 {(0, 1, 1), (0, 0, 0), (0, 2, 2)}\n",
      "A0*B1 + A1*B0 {(0, 0, 1)}\n",
      "A0*B2 + A2*B0 {(0, 1, 2)}\n",
      "A0*B3 + A1*B2 + A3*B0 {(0, 0, 2)}\n",
      "Commutative symbols:\n",
      "--------------------\n"
     ]
    }
   ],
   "source": [
    "mat1 = second_alg.get_subspace_member('A')\n",
    "mat2 = second_alg.get_subspace_member('B')\n",
    "\n",
    "print('first member:')\n",
    "print(mat1.mat_list)\n",
    "print('second member:')\n",
    "print(mat2.mat_list)\n",
    "\n",
    "print('multiplication rules:')\n",
    "mat3 = mat1.mult(mat2)\n",
    "mat3.concise_display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above, the reduced multiplication rules are given by the non-commutative symbols"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### More complicated example\n",
    "Consider the case where we have X and Y control of a qubit, and want to compute the first order dyson terms for all Paulis: X, Y, and Z. Furthermore, consider the generators for computing these terms, along with the derivatives with of these terms with respect to X and Y."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Matrix([\n",
      "[G, X, X, 0],\n",
      "[0, G, 0, X],\n",
      "[0, 0, G, X],\n",
      "[0, 0, 0, G]]), Matrix([\n",
      "[G, X, Y, 0],\n",
      "[0, G, 0, Y],\n",
      "[0, 0, G, X],\n",
      "[0, 0, 0, G]]), Matrix([\n",
      "[G, Y, X, 0],\n",
      "[0, G, 0, X],\n",
      "[0, 0, G, Y],\n",
      "[0, 0, 0, G]]), Matrix([\n",
      "[G, Y, Y, 0],\n",
      "[0, G, 0, Y],\n",
      "[0, 0, G, Y],\n",
      "[0, 0, 0, G]]), Matrix([\n",
      "[G, Z, X, 0],\n",
      "[0, G, 0, X],\n",
      "[0, 0, G, Z],\n",
      "[0, 0, 0, G]]), Matrix([\n",
      "[G, Z, Y, 0],\n",
      "[0, G, 0, Y],\n",
      "[0, 0, G, Z],\n",
      "[0, 0, 0, G]])]\n"
     ]
    }
   ],
   "source": [
    "deriv_system = Sym_UTB_Matrix([[['G','X','X',0], [0, 'G',0,'X'],[0,0,'G','X'],[0,0,0,'G']],[['G','X','Y',0], [0, 'G',0,'Y'],[0,0,'G','X'],[0,0,0,'G']], [['G','Y','X',0], [0, 'G',0,'X'],[0,0,'G','Y'],[0,0,0,'G']], [['G','Y','Y',0], [0, 'G',0,'Y'],[0,0,'G','Y'],[0,0,0,'G']], [['G','Z','X',0], [0, 'G',0,'X'],[0,0,'G','Z'],[0,0,0,'G']], [['G','Z','Y',0], [0, 'G',0,'Y'],[0,0,'G','Z'],[0,0,0,'G']]   ])\n",
    "print(deriv_system.mat_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above are the generators for doing this. These obviously have a lot of redundancies. Furthermore, you can possibly convince yourself that the 0 block in the (1, 2) position (using indexing starting at 0) will always be zero regardless of how many powers or linear combinations of matrices you take of this form. The concise description is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape:\n",
      "------\n",
      "[4, 4, 4, 4, 4, 4]\n",
      "Non-commutative symbols:\n",
      "------------------------\n",
      "G {(0, 1, 1), (4, 2, 2), (1, 0, 0), (4, 3, 3), (5, 2, 2), (3, 3, 3), (4, 0, 0), (2, 3, 3), (5, 1, 1), (0, 2, 2), (3, 2, 2), (2, 0, 0), (0, 3, 3), (3, 1, 1), (1, 2, 2), (5, 3, 3), (0, 0, 0), (4, 1, 1), (1, 1, 1), (5, 0, 0), (2, 2, 2), (2, 1, 1), (3, 0, 0), (1, 3, 3)}\n",
      "X {(4, 1, 3), (0, 0, 2), (0, 2, 3), (2, 0, 2), (0, 0, 1), (1, 2, 3), (1, 0, 1), (0, 1, 3), (4, 0, 2), (2, 1, 3)}\n",
      "Y {(3, 0, 2), (3, 2, 3), (1, 1, 3), (2, 2, 3), (5, 0, 2), (2, 0, 1), (3, 1, 3), (3, 0, 1), (1, 0, 2), (5, 1, 3)}\n",
      "Z {(4, 0, 1), (5, 2, 3), (5, 0, 1), (4, 2, 3)}\n",
      "Commutative symbols:\n",
      "--------------------\n",
      "0 {(1, 0, 3), (5, 1, 2), (2, 0, 3), (3, 0, 3), (0, 1, 2), (1, 1, 2), (4, 0, 3), (5, 0, 3), (2, 1, 2), (4, 1, 2), (3, 1, 2), (0, 0, 3)}\n"
     ]
    }
   ],
   "source": [
    "deriv_system.concise_display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I.e. there are 4 unique symbols representing these matrices: {G, X, Y, Z}, and their positions are given above.\n",
    "\n",
    "Next, we want the algebra that matrices of the above form are living in. To do this, we construct a subspace from the above description, and then retrieve the algebra containing it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "deriv_subspace = UTB_Subspace.from_Sym_UTB_Matrix(deriv_system)\n",
    "deriv_alg = deriv_subspace.containing_algebra()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see the structure of the algebra by looking at a representative:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Matrix([\n",
       " [A0, A1, A1, A4],\n",
       " [ 0, A0,  0, A1],\n",
       " [ 0,  0, A0, A1],\n",
       " [ 0,  0,  0, A0]]), Matrix([\n",
       " [A0, A1, A2, A5],\n",
       " [ 0, A0,  0, A2],\n",
       " [ 0,  0, A0, A1],\n",
       " [ 0,  0,  0, A0]]), Matrix([\n",
       " [A0, A2, A1, A5],\n",
       " [ 0, A0,  0, A1],\n",
       " [ 0,  0, A0, A2],\n",
       " [ 0,  0,  0, A0]]), Matrix([\n",
       " [A0, A2, A2, A6],\n",
       " [ 0, A0,  0, A2],\n",
       " [ 0,  0, A0, A2],\n",
       " [ 0,  0,  0, A0]]), Matrix([\n",
       " [A0, A3, A1, A7],\n",
       " [ 0, A0,  0, A1],\n",
       " [ 0,  0, A0, A3],\n",
       " [ 0,  0,  0, A0]]), Matrix([\n",
       " [A0, A3, A2, A8],\n",
       " [ 0, A0,  0, A2],\n",
       " [ 0,  0, A0, A3],\n",
       " [ 0,  0,  0, A0]])]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alg_member = deriv_alg.get_subspace_member()\n",
    "alg_member.mat_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe: the generated algebra now has non-zero blocks in the top right, which are themselves unique for each of the matrices. Furthermore, the (1,2) spot remains a 0. The description of the algebra:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unique non-commutative blocks:\n",
      "------------------------------\n",
      "1. frozenset({(0, 1, 1), (0, 3, 3), (4, 2, 2), (3, 1, 1), (1, 0, 0), (1, 2, 2), (5, 3, 3), (0, 0, 0), (4, 3, 3), (4, 1, 1), (1, 1, 1), (5, 2, 2), (5, 0, 0), (3, 3, 3), (2, 2, 2), (4, 0, 0), (2, 3, 3), (2, 1, 1), (5, 1, 1), (0, 2, 2), (3, 2, 2), (3, 0, 0), (2, 0, 0), (1, 3, 3)})\n",
      "2. frozenset({(4, 1, 3), (0, 0, 2), (0, 2, 3), (2, 0, 2), (0, 0, 1), (1, 2, 3), (1, 0, 1), (0, 1, 3), (4, 0, 2), (2, 1, 3)})\n",
      "3. frozenset({(3, 0, 2), (3, 2, 3), (1, 1, 3), (2, 2, 3), (5, 0, 2), (2, 0, 1), (3, 1, 3), (3, 0, 1), (1, 0, 2), (5, 1, 3)})\n",
      "4. frozenset({(4, 0, 1), (5, 2, 3), (5, 0, 1), (4, 2, 3)})\n",
      "5. frozenset({(0, 0, 3)})\n",
      "6. frozenset({(1, 0, 3), (2, 0, 3)})\n",
      "7. frozenset({(3, 0, 3)})\n",
      "8. frozenset({(4, 0, 3)})\n",
      "9. frozenset({(5, 0, 3)})\n",
      "Unique commutative blocks:\n",
      "--------------------------\n",
      "Zero blocks:\n",
      "------------\n",
      "frozenset({(5, 1, 2), (2, 1, 2), (0, 1, 2), (4, 1, 2), (3, 1, 2), (1, 1, 2)})\n"
     ]
    }
   ],
   "source": [
    "deriv_alg.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I.e. there are 9 unique blocks with location given above, and the locations of the zero blocks are also listed. \n",
    "\n",
    "Finally, we can get the multiplication rules as before; get two symbolic representatives from this algebra, multiply them together, and the custom multiplication rules are encoded in the symbolic expression:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape:\n",
      "------\n",
      "[4, 4, 4, 4, 4, 4]\n",
      "Non-commutative symbols:\n",
      "------------------------\n",
      "A0*B0 {(0, 1, 1), (4, 2, 2), (1, 0, 0), (4, 3, 3), (5, 2, 2), (3, 3, 3), (4, 0, 0), (2, 3, 3), (5, 1, 1), (0, 2, 2), (3, 2, 2), (2, 0, 0), (0, 3, 3), (3, 1, 1), (1, 2, 2), (5, 3, 3), (0, 0, 0), (4, 1, 1), (1, 1, 1), (5, 0, 0), (2, 2, 2), (2, 1, 1), (3, 0, 0), (1, 3, 3)}\n",
      "A0*B1 + A1*B0 {(4, 1, 3), (0, 0, 2), (0, 2, 3), (2, 0, 2), (0, 0, 1), (1, 2, 3), (1, 0, 1), (0, 1, 3), (4, 0, 2), (2, 1, 3)}\n",
      "A0*B2 + A2*B0 {(3, 0, 2), (3, 2, 3), (1, 1, 3), (2, 2, 3), (5, 0, 2), (2, 0, 1), (3, 1, 3), (3, 0, 1), (1, 0, 2), (5, 1, 3)}\n",
      "A0*B3 + A3*B0 {(4, 0, 1), (5, 2, 3), (5, 0, 1), (4, 2, 3)}\n",
      "A0*B4 + 2*A1*B1 + A4*B0 {(0, 0, 3)}\n",
      "A0*B5 + A1*B2 + A2*B1 + A5*B0 {(1, 0, 3), (2, 0, 3)}\n",
      "A0*B6 + 2*A2*B2 + A6*B0 {(3, 0, 3)}\n",
      "A0*B7 + A1*B3 + A3*B1 + A7*B0 {(4, 0, 3)}\n",
      "A0*B8 + A2*B3 + A3*B2 + A8*B0 {(5, 0, 3)}\n",
      "Commutative symbols:\n",
      "--------------------\n",
      "0 {(5, 1, 2), (0, 1, 2), (1, 1, 2), (2, 1, 2), (4, 1, 2), (3, 1, 2)}\n"
     ]
    }
   ],
   "source": [
    "member1 = deriv_alg.get_subspace_member('A')\n",
    "member2 = deriv_alg.get_subspace_member('B')\n",
    "\n",
    "member1.mult(member2).concise_display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, the above shows that to work with these huge block matrices, we only need to actually keep track of and manipulate 9 unique blocks, with the multiplication rules given above.\n",
    "\n",
    "Note: there are some things I need to be more careful with in terms of preserving symbol ordering and what not, but it all seems to be working."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Polynomial test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unique non-commutative blocks:\n",
      "------------------------------\n",
      "1. frozenset({(0, 1, 1), (0, 3, 3), (0, 5, 5), (0, 0, 0), (0, 6, 6), (0, 4, 4), (0, 2, 2)})\n",
      "2. frozenset({(0, 2, 3), (0, 5, 6)})\n",
      "3. frozenset({(0, 4, 5)})\n",
      "4. frozenset({(0, 0, 2), (0, 1, 3)})\n",
      "5. frozenset({(0, 3, 5), (0, 2, 4)})\n",
      "6. frozenset({(0, 4, 6)})\n",
      "7. frozenset({(0, 0, 3)})\n",
      "8. frozenset({(0, 2, 5)})\n",
      "9. frozenset({(0, 3, 6)})\n",
      "10. frozenset({(0, 1, 5), (0, 0, 4)})\n",
      "11. frozenset({(0, 2, 6)})\n",
      "12. frozenset({(0, 0, 5)})\n",
      "13. frozenset({(0, 1, 6)})\n",
      "14. frozenset({(0, 0, 6)})\n",
      "Unique commutative blocks:\n",
      "--------------------------\n",
      "Zero blocks:\n",
      "------------\n",
      "frozenset({(0, 1, 2), (0, 1, 4), (0, 0, 1), (0, 3, 4)})\n"
     ]
    }
   ],
   "source": [
    "poly11_gen = Sym_UTB_Matrix([\n",
    "                        ['G', 0, 'A', 0, 0, 0, 0],\n",
    "                        [0, 'G', 0, 'A', 0, 0, 0],\n",
    "                        [0, 0, 'G', 1, 'B', 0, 0],\n",
    "                        [0, 0, 0, 'G', 0, 'B', 0],\n",
    "                        [0, 0, 0, 0, 'G', 2, 0],\n",
    "                        [0, 0, 0, 0, 0, 'G', 1],\n",
    "                        [0, 0, 0, 0, 0, 0, 'G']])\n",
    "poly11_sub = UTB_Subspace.from_Sym_UTB_Matrix(poly11_gen)\n",
    "poly11_alg = poly11_sub.containing_algebra()\n",
    "poly11_alg.display()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape:\n",
      "------\n",
      "[7]\n",
      "Non-commutative symbols:\n",
      "------------------------\n",
      "A0*B0 {(0, 1, 1), (0, 3, 3), (0, 5, 5), (0, 4, 4), (0, 2, 2), (0, 6, 6), (0, 0, 0)}\n",
      "A0*B1 + A1*B0 {(0, 2, 3), (0, 5, 6)}\n",
      "A0*B2 + A2*B0 {(0, 4, 5)}\n",
      "A0*B3 + A3*B0 {(0, 0, 2), (0, 1, 3)}\n",
      "A0*B4 + A4*B0 {(0, 3, 5), (0, 2, 4)}\n",
      "A0*B5 + A2*B1 + A5*B0 {(0, 4, 6)}\n",
      "A0*B6 + A3*B1 + A6*B0 {(0, 0, 3)}\n",
      "A0*B7 + A1*B4 + A4*B2 + A7*B0 {(0, 2, 5)}\n",
      "A0*B8 + A4*B1 + A8*B0 {(0, 3, 6)}\n",
      "A0*B9 + A3*B4 + A9*B0 {(0, 1, 5), (0, 0, 4)}\n",
      "A0*B10 + A1*B8 + A10*B0 + A4*B5 + A7*B1 {(0, 2, 6)}\n",
      "A0*B11 + A11*B0 + A3*B7 + A6*B4 + A9*B2 {(0, 0, 5)}\n",
      "A0*B12 + A12*B0 + A3*B8 + A9*B1 {(0, 1, 6)}\n",
      "A0*B13 + A11*B1 + A13*B0 + A3*B10 + A6*B8 + A9*B5 {(0, 0, 6)}\n",
      "Commutative symbols:\n",
      "--------------------\n",
      "0 {(0, 1, 2), (0, 1, 4), (0, 0, 1), (0, 3, 4)}\n"
     ]
    }
   ],
   "source": [
    "poly11_alg.get_subspace_member('A','a').mult(poly11_alg.get_subspace_member('B','b')).concise_display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### cross talk type computations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unique non-commutative blocks:\n",
      "------------------------------\n",
      "1. frozenset({(0, 1, 1), (0, 0, 0)})\n",
      "2. frozenset({(1, 0, 0), (1, 1, 1)})\n",
      "3. frozenset({(0, 0, 1)})\n",
      "4. frozenset({(1, 0, 1)})\n",
      "Unique commutative blocks:\n",
      "--------------------------\n",
      "Zero blocks:\n",
      "------------\n",
      "frozenset()\n"
     ]
    }
   ],
   "source": [
    "xtalk_sub = UTB_Subspace.from_matrix([[['X','Y'],[0,'X']], [['Y','X'],[0,'Y']]])\n",
    "test_alg = test.containing_algebra()\n",
    "test2 = Sym_UTB_Matrix([[['X','Y'],[0,'X']], [['Y','X'],[0,'Y']]])\n",
    "test_alg.display()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test.is_algebra()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}