qudit_surface_codes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hybrid Qudit Surface Code Graphs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I this notebook we are going to implement the `HybridSurfaceCodeGraph` class which allows us to create surface codes with qudits of varying dimensions which depend on the lengths of permutations given by a dessin d'enfant given by a constellation $[\\sigma, \\alpha, \\phi]$. The permuation $\\sigma$ gives the vertices of the graph of the dessin which is cellularly embedded in a Riemann surface. Each cycle of $\\sigma$ has a length and determines a qudit of the same dimension as the length of the cycle. Similarly, each cycle of $\\phi$ determines a face of the embedded graph and determines a qudit of the same dimension as the length of the cycle. The nodes corresponding to cycles in $\\alpha$ are all $2$-cycles and so define *qubits*, i.e. $2$-level systems (such as electrons). The coefficients in this implementation are in $\\mathbb{Z}$ as apposed to the usual $\\mathbb{Z}/2\\mathbb{Z}$ coefficients used in standard *qubit* surface codes. Because the dimension of each qudit in the surface code is different it is not clear what other coefficient might be useful. One may at some point want coefficients in $\\mathbb{Z}/N\\mathbb{Z}$ where $N = d_1^{k_1}d_2^{k_2} \\cdots d_n^{k_n}$, where the $d_j^{k_j}$ are the dimensions of the qudits in the surface code. Using the Fundamental Theorem of Abelian Groups this would naturally decompose into a direct product of groups\n",
    "\n",
    "\\begin{align}\n",
    "\\prod_{j} \\mathbb{Z}/p_j^{m_j}\\mathbb{Z}\n",
    "\\end{align}\n",
    "\n",
    "where each $p_j^{m_j}$ is a prime power. This may be implemented later on if there seems to be a need, but currently is not implemented. The coefficients that show up when computing boundaries are given by [multisets](https://multiset.readthedocs.io/en/stable/). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: multiset in /opt/anaconda3/lib/python3.7/site-packages (2.1.1)\n",
      "\u001b[33mWARNING: You are using pip version 20.1; however, version 20.2 is available.\n",
      "You should consider upgrading via the '/opt/anaconda3/bin/python -m pip install --upgrade pip' command.\u001b[0m\n",
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    }
   ],
   "source": [
    "pip install multiset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: multiset\n",
      "Version: 2.1.1\n",
      "Summary: An implementation of a multiset.\n",
      "Home-page: https://github.com/wheerd/multiset\n",
      "Author: Manuel Krebber\n",
      "Author-email: admin@wheerd.de\n",
      "License: MIT\n",
      "Location: /opt/anaconda3/lib/python3.7/site-packages\n",
      "Requires: \n",
      "Required-by: \n",
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    }
   ],
   "source": [
    "pip show multiset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The HybridSurfaceCodeGraph Class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter\n",
    "from typing import Tuple, List\n",
    "import numpy as np\n",
    "\n",
    "from networkx import MultiGraph\n",
    "from networkx import nx\n",
    "from networkx.algorithms import bipartite\n",
    "from sympy.combinatorics import Permutation\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import multiset\n",
    "from multiset import Multiset\n",
    "\n",
    "\n",
    "# from SurfaceCodes.utilites import permlist_to_tuple\n",
    "\n",
    "\n",
    "class HybridSurfaceCodeGraph(MultiGraph):\n",
    "    def __init__(self, sigma: Tuple[Tuple[int]], alpha: Tuple[Tuple[int]]):\n",
    "        super().__init__()\n",
    "        self.sigma = sigma  # should include singletons corresponding to fixed points\n",
    "        self.alpha = alpha  # should include singletons corresponding to fixed points\n",
    "        f = self.compute_phi()\n",
    "        self.phi = self.permlist_to_tuple(f)\n",
    "        self.build_node_info()  # print dictionary for [sigma, alpha, phi]\n",
    "        self.node_dict = self.sigma_dict, self.alpha_dict, self.phi_dict\n",
    "        \n",
    "        self.node_info = [\"sigma:\", self.sigma_dict, \n",
    "                          \"alpha:\", self.alpha_dict, \n",
    "                          \"phi:\", self.phi_dict]\n",
    "\n",
    "        self.code_graph = nx.MultiGraph()\n",
    "\n",
    "        # Create black nodes for each cycle in sigma along with white nodes\n",
    "        # representing \"half edges\" around the black nodes\n",
    "        for cycle in self.sigma:\n",
    "            self.code_graph.add_node(cycle, bipartite=1)\n",
    "            for node in cycle:\n",
    "                self.code_graph.add_node(node, bipartite=0)\n",
    "                self.code_graph.add_edge(cycle, node)\n",
    "\n",
    "        # Create black nodes for each cycle in phi along with white nodes\n",
    "        # representing \"half edges\" around the black nodes\n",
    "        for cycle in self.phi:\n",
    "            self.code_graph.add_node(cycle, bipartite=1)\n",
    "            for node in cycle:\n",
    "                self.code_graph.add_edge(cycle, node)\n",
    "\n",
    "        # Create nodes for each cycle in alpha then\n",
    "        # glue the nodes corresponding to a the pairs\n",
    "        for pair in self.alpha:\n",
    "            self.code_graph.add_node(pair)\n",
    "            self.code_graph = nx.contracted_nodes(self.code_graph, pair[0], pair[1], self_loops=True)\n",
    "            # Now contract pair with pair[0] to make sure edges (white nodes) are labeled\n",
    "            # by the pairs in alpha to keep track of the gluing from the previous step\n",
    "            self.code_graph = nx.contracted_nodes(self.code_graph, pair, pair[0], self_loops=True)\n",
    "            \n",
    "        # Define the white and black nodes. White correspond to edges labeled by \n",
    "        # cycles in alpha. Black correspond to nodes labeled by cycles in sigma\n",
    "        # (vertices) and phi (faces)\n",
    "        self.black_nodes, self.white_nodes = bipartite.sets(self.code_graph)\n",
    "        self.vertex_basis()\n",
    "        self.edge_basis()\n",
    "        self.face_basis()\n",
    "        self.d_2()\n",
    "        self.d_1()\n",
    "\n",
    "    def permlist_to_tuple(self, perms):\n",
    "        \"\"\"\n",
    "        convert list of lists to tuple of tuples in order to have two level iterables\n",
    "        that are hashable for the dictionaries used later\n",
    "        \"\"\"\n",
    "        return tuple(tuple(perm) for perm in perms)\n",
    "\n",
    "    def compute_phi(self):\n",
    "        \"\"\"compute the list of lists full cyclic form of phi (faces of dessin [sigma, alpha, phi])\"\"\"\n",
    "        s = Permutation(self.sigma)\n",
    "        a = Permutation(self.alpha)\n",
    "        f = ~(a * s)\n",
    "        f = f.full_cyclic_form  # prints permutation as a list of lists including all singletons (fixed points)\n",
    "        return f\n",
    "\n",
    "    def build_node_info(self):\n",
    "        count = -1\n",
    "\n",
    "        self.sigma_dict = dict()\n",
    "        for count, cycle in enumerate(self.sigma):\n",
    "            self.sigma_dict[cycle] = count\n",
    "\n",
    "        self.phi_dict = dict()\n",
    "        for count, cycle in enumerate(self.phi, start=count + 1):\n",
    "            self.phi_dict[cycle] = count\n",
    "\n",
    "        self.alpha_dict = dict()\n",
    "        for count, pair in enumerate(self.alpha, start=count + 1):\n",
    "            self.alpha_dict[pair] = count\n",
    "        return tuple([self.sigma_dict, self.alpha_dict, self.phi_dict])\n",
    "    \n",
    "    def boundary_1(self, edge):\n",
    "        \"\"\"\n",
    "        compute boundary of a single edge given by a white node (cycle in alpha)\n",
    "        \"\"\"\n",
    "        boundary1 = [node for node in self.code_graph.neighbors(edge) if node in self.sigma_dict]\n",
    "        return boundary1\n",
    "    \n",
    "    def del_1(self, edges: List[Tuple[int]]):\n",
    "        \"\"\"\n",
    "        boundary of a list of edges, i.e. an arbitrary 1-chain over Z/2Z\n",
    "        \"\"\"\n",
    "        boundary_list = Multiset()\n",
    "        for edge in edges:\n",
    "            boundary_list.update(Multiset(self.boundary_1(edge)))\n",
    "        return boundary_list\n",
    "\n",
    "    def boundary_2(self, face):\n",
    "        \"\"\"\n",
    "        compute boundary of a single face\n",
    "        \"\"\"\n",
    "        boundary2 = list(self.code_graph.neighbors(face))\n",
    "        return boundary2\n",
    "\n",
    "    def del_2(self, faces: List[Tuple[int]]):\n",
    "        \"\"\"\n",
    "        boundary of a list of faces, i.e. an arbitrary 2-chain over Z/2Z\n",
    "        \"\"\"\n",
    "        boundary_list = Multiset()\n",
    "        for face in faces:\n",
    "            boundary_list.update(Multiset(self.boundary_2(face)))\n",
    "        return boundary_list\n",
    "\n",
    "    def coboundary_1(self, star):\n",
    "        \"\"\"\n",
    "        compute coboundary of a single star\n",
    "        \"\"\"\n",
    "        coboundary = self.code_graph.neighbors(star)\n",
    "        return coboundary\n",
    "\n",
    "    def delta_1(self, stars: List[Tuple[int]]):\n",
    "        \"\"\"\n",
    "        coboundary of a list of stars, i.e. an arbitrary 0-cochain over Z/2Z\n",
    "        \"\"\"\n",
    "        coboundary_list = Multiset()\n",
    "        for star in stars:\n",
    "            coboundary_list.update(Multiset(self.boundary_1(star)))\n",
    "        return coboundary_list\n",
    "    \n",
    "    def coboundary_2(self, edge):\n",
    "        \"\"\"\n",
    "        compute coboundary of a single edge given by a white node (cycle in alpha)\n",
    "        \"\"\"\n",
    "        coboundary2 = [node for node in self.code_graph.neighbors(edge) if node in self.phi_dict]\n",
    "        return coboundary2\n",
    "    \n",
    "    def delta_2(self, edges: List[Tuple[int]]):\n",
    "        \"\"\"\n",
    "        coboundary of a list of edges, i.e. an arbitrary 1-cochain over Z/2Z\n",
    "        given by a list of cycles in alpha\n",
    "        \"\"\"\n",
    "        coboundary_list = Multiset()\n",
    "        for edge in edges:\n",
    "            coboundary_list.update(Multiset(self.boundary_1(edge)))\n",
    "        return coboundary_list\n",
    "\n",
    "    def euler_characteristic(self):\n",
    "        \"\"\"\n",
    "        Compute the Euler characteristic of the surface in which the graph is embedded\n",
    "        \"\"\"\n",
    "        chi = len(self.phi) - len(self.alpha) + len(self.sigma)\n",
    "        return (chi)\n",
    "\n",
    "    def genus(self):\n",
    "        \"\"\"\n",
    "        Compute the genus of the surface in which the graph is embedded\n",
    "        \"\"\"\n",
    "        g = int(-(len(self.phi) - len(self.alpha) + len(self.sigma) - 2) / 2)\n",
    "        return (g)\n",
    "    \n",
    "    \n",
    "    def vertex_basis(self):\n",
    "        self.v_basis_dict = dict()\n",
    "        self.v_dict = dict()\n",
    "        A = np.eye(len(self.sigma), dtype=np.uint8)\n",
    "        for count, cycle in enumerate(self.sigma):\n",
    "            self.v_dict[cycle] = count\n",
    "            self.v_basis_dict[cycle] = A[:, count]\n",
    "\n",
    "    def edge_basis(self):\n",
    "        self.e_basis_dict = dict()\n",
    "        self.e_dict = dict()\n",
    "        B = np.eye(len(self.alpha), dtype=np.uint8)\n",
    "        for count, cycle in enumerate(self.alpha):\n",
    "            self.e_dict[cycle] = count\n",
    "            self.e_basis_dict[cycle] = B[count, :].reshape(1,-1)\n",
    "\n",
    "    def face_basis(self):\n",
    "        self.f_basis_dict = dict()\n",
    "        self.f_dict = dict()\n",
    "        C = np.eye(len(self.phi), dtype=np.uint8)\n",
    "        for count, cycle in enumerate(self.phi):\n",
    "            self.f_dict[cycle] = count\n",
    "            self.f_basis_dict[cycle] = C[count, :].reshape(1,-1)\n",
    "\n",
    "    def d_2(self):\n",
    "        \"\"\"\n",
    "        Create the matrix D2 for the differential d_2 in the chain complex\n",
    "        that maps faces to their boundary edges. This can be used in the homology\n",
    "        class as one of the input matrices.\n",
    "        :return: matrix D2 of the differential d_2\n",
    "        \"\"\"\n",
    "        self.D2 = np.zeros(len(self.e_basis_dict), dtype=np.uint8)\n",
    "        for cycle in self.phi:\n",
    "            bd = self.boundary_2(cycle)\n",
    "            if bd != []:\n",
    "                image = sum([self.e_basis_dict[edge] for edge in bd])\n",
    "            else:\n",
    "                image = np.zeros(len(self.e_basis_dict))\n",
    "            self.D2 = np.vstack((self.D2, image))\n",
    "        self.D2 = np.array(self.D2[1:, :]).T\n",
    "    \n",
    "    def d_1(self):\n",
    "        \"\"\"\n",
    "        Create the matrix D1 for the differential d_1 in the chain complex\n",
    "        that maps edges to their boundary vertices. This can be used in the homology\n",
    "        class as one of the input matrices\n",
    "        :return: matrix D1 of the differential d_1\n",
    "        \"\"\"\n",
    "        self.D1 = np.zeros(len(self.v_basis_dict), dtype=np.uint8)\n",
    "        for cycle in self.alpha:\n",
    "            bd = self.boundary_1(cycle)\n",
    "            if bd != []:\n",
    "                image = sum([self.v_basis_dict[vertex] for vertex in bd])\n",
    "            else:\n",
    "                image = np.zeros(len(self.v_basis_dict))\n",
    "            self.D1 = np.vstack((self.D1, image))\n",
    "        self.D1 = np.array(self.D1[1:, :]).T\n",
    "    \n",
    "    def draw(self, node_type='', layout = ''):\n",
    "        \"\"\"\n",
    "        Draw graph with vertices, edges, and faces labeled by colored nodes and their integer indices \n",
    "        corresponding to the qubit indices for the surface code\n",
    "        \"\"\"\n",
    "        if not node_type in ['cycles', 'dict']:\n",
    "            raise ValueError('node_type can be \"cycles\" or \"dict\"')\n",
    "        \n",
    "        if layout == 'spring':\n",
    "            pos=nx.spring_layout(self.code_graph)\n",
    "        if layout == 'spectral':\n",
    "            pos=nx.spectral_layout(self.code_graph)\n",
    "        if layout == 'planar':\n",
    "            pos=nx.planar_layout(self.code_graph)\n",
    "        if layout == 'shell':\n",
    "            pos=nx.shell_layout(self.code_graph)\n",
    "        if layout == 'circular':\n",
    "            pos=nx.circular_layout(self.code_graph)\n",
    "        if layout == 'spiral':\n",
    "            pos=nx.spiral_layout(self.code_graph)\n",
    "        if layout == 'random':\n",
    "            pos=nx.random_layout(self.code_graph)\n",
    "        # white nodes\n",
    "        nx.draw_networkx_nodes(self.code_graph, pos,\n",
    "                       nodelist=list(self.alpha),\n",
    "                       node_color='c',\n",
    "                       node_size=500,\n",
    "                    alpha=0.3)\n",
    "        # vertex nodes\n",
    "        nx.draw_networkx_nodes(self.code_graph, pos,\n",
    "                       nodelist=list(self.sigma),\n",
    "                       node_color='b',\n",
    "                       node_size=500,\n",
    "                    alpha=0.6)\n",
    "         # face nodes\n",
    "        nx.draw_networkx_nodes(self.code_graph, pos,\n",
    "                       nodelist=list(self.phi),\n",
    "                       node_color='r',\n",
    "                       node_size=500,\n",
    "                    alpha=0.6)\n",
    "        # edges\n",
    "        nx.draw_networkx_edges(self.code_graph, pos, width=1.0, alpha=0.5)\n",
    "\n",
    "        labels={}\n",
    "\n",
    "        if node_type == 'cycles':\n",
    "            '''\n",
    "            label nodes the cycles of sigma, alpha, and phi\n",
    "            '''\n",
    "            for node in self.alpha_dict:\n",
    "                # stuff = self.alpha_dict[node]\n",
    "                labels[node]=f'$e$({node})'\n",
    "            for node in self.sigma_dict:\n",
    "                # something = self.sigma_dict[node]\n",
    "                labels[node]=f'$v$({node})'\n",
    "            for node in self.phi_dict:\n",
    "                # something2 = self.phi_dict[node]\n",
    "                labels[node]=f'$f$({node})'\n",
    "            nx.draw_networkx_labels(self.code_graph, pos, labels, font_size=12)\n",
    "\n",
    "        if node_type == 'dict':\n",
    "            '''\n",
    "            label nodes with v, e, f and indices given by node_dict corresponding to\n",
    "            qubit indices of surface code\n",
    "            '''\n",
    "\n",
    "            for node in self.alpha_dict:\n",
    "                # stuff = self.alpha_dict[node]\n",
    "                labels[node]=f'$e$({self.alpha_dict[node]})'\n",
    "            for node in self.sigma_dict:\n",
    "                # something = self.sigma_dict[node]\n",
    "                labels[node]=f'$v$({self.sigma_dict[node]})'\n",
    "            for node in self.phi_dict:\n",
    "                # something2 = self.phi_dict[node]\n",
    "                labels[node]=f'$f$({self.phi_dict[node]})'\n",
    "            nx.draw_networkx_labels(self.code_graph, pos, labels, font_size=12)\n",
    "        \n",
    "        # plt.axis('off')\n",
    "        # plt.savefig(\"labels_and_colors.png\") # save as png\n",
    "        plt.show() # display"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Much of this class works in a very similar way to the `SurfaceCodeGraph` class, which can be found [here](https://github.com/The-Singularity-Research/SurfaceCodes). We first define a constellation by defining $\\sigma$ and $\\alpha$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.HybridSurfaceCodeGraph at 0x7fe10256b350>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sigma = ((0,1,2),(3,4,5),(6,7))\n",
    "alpha = ((0,3),(1,6),(2,4),(5,7))\n",
    "SCG = HybridSurfaceCodeGraph(sigma, alpha)\n",
    "SCG"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `draw` method draws the graph with face nodes in red, vertex nodes in blue, and edge nodes in cyan. The `'cycles'` option labels the nodes by the corresponding cycles. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "SCG.draw('cycles', 'spring')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also print $\\sigma$, $\\alpha$, and $\\phi$ to get a tuple of tuples (cycles). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((0, 4), (1, 3, 7), (2, 6, 5))"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SCG.phi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `node_info` prints a dictionary for $\\sigma$, $\\alpha$, and $\\phi$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['sigma:',\n",
       " {(0, 1, 2): 0, (3, 4, 5): 1, (6, 7): 2},\n",
       " 'alpha:',\n",
       " {(0, 3): 6, (1, 6): 7, (2, 4): 8, (5, 7): 9},\n",
       " 'phi:',\n",
       " {(0, 4): 3, (1, 3, 7): 4, (2, 6, 5): 5}]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SCG.node_info"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also print off all of the nodes in the graph. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "NodeView(((0, 1, 2), (3, 4, 5), (6, 7), (0, 4), (1, 3, 7), (2, 6, 5), (0, 3), (1, 6), (2, 4), (5, 7)))"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SCG.code_graph.nodes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following prints of the \"black nodes\" and \"white nodes\". Black corresponds to vertex and face nodes, and white corrsponds to edge nodes. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "({(0, 1, 2), (0, 4), (1, 3, 7), (2, 6, 5), (3, 4, 5), (6, 7)},\n",
       " {(0, 3), (1, 6), (2, 4), (5, 7)})"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bipartite.sets(SCG.code_graph)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{(0, 3), (1, 6), (2, 4), (5, 7)}"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SCG.white_nodes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{(0, 1, 2), (0, 4), (1, 3, 7), (2, 6, 5), (3, 4, 5), (6, 7)}"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SCG.black_nodes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The other option for drawing the graph is `'dict'` which labels the nodes by their indices in the `node_info` dictionary. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "SCG.draw('dict', 'spring')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can compute the Euler characteristic of the dessin. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SCG.euler_characteristic()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also compute the genus. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SCG.genus()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are boundary and coboundary operators to compute the boundary and coboundary of lists of vertices, edges, or faces. `del_1` and `del_2` as well as `delta_1` and `delta_2` take into account multiplicity allowing for coefficients in $\\mathbb{Z}$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 3), (2, 4)]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SCG.boundary_2((0,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 3), (1, 6), (5, 7)]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SCG.boundary_2((1,3,7))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 1, 2), (3, 4, 5)]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SCG.boundary_1((0,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 1, 2), (6, 7)]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SCG.boundary_1((1,6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Multiset({(0, 3): 1, (2, 4): 1})"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SCG.del_2([(0, 4)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Multiset({(0, 3): 1, (1, 6): 1, (5, 7): 1})"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SCG.del_2([(1,3,7)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Multiset({(0, 3): 2, (2, 4): 1, (1, 6): 1, (5, 7): 1})"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SCG.del_2([(0, 4), (1,3,7)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To define basis vectors for the vector spaces in the chain complex\n",
    "\n",
    "\\begin{align}\n",
    "C_2 \\to C_1 \\to C_0\n",
    "\\end{align}\n",
    "\n",
    "which might also be labeled\n",
    "\n",
    "\\begin{align}\n",
    "F \\to E \\to V\n",
    "\\end{align}\n",
    "\n",
    "we have the following methods. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{(0, 4): array([[1, 0, 0]], dtype=uint8),\n",
       " (1, 3, 7): array([[0, 1, 0]], dtype=uint8),\n",
       " (2, 6, 5): array([[0, 0, 1]], dtype=uint8)}"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SCG.f_basis_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{(0, 3): array([[1, 0, 0, 0]], dtype=uint8),\n",
       " (1, 6): array([[0, 1, 0, 0]], dtype=uint8),\n",
       " (2, 4): array([[0, 0, 1, 0]], dtype=uint8),\n",
       " (5, 7): array([[0, 0, 0, 1]], dtype=uint8)}"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SCG.e_basis_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{(0, 1, 2): array([1, 0, 0], dtype=uint8),\n",
       " (3, 4, 5): array([0, 1, 0], dtype=uint8),\n",
       " (6, 7): array([0, 0, 1], dtype=uint8)}"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SCG.v_basis_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We also have matrix representations of the boundary operators $\\partial_2: C_2 \\to C_1$ and $\\partial_1: C_1 \\to C_0$, we have the following methods.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1, 0],\n",
       "       [0, 1, 1],\n",
       "       [1, 0, 1],\n",
       "       [0, 1, 1]], dtype=uint8)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SCG.D2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1, 1, 0],\n",
       "       [1, 0, 1, 1],\n",
       "       [0, 1, 0, 1]], dtype=uint8)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SCG.D1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The purpose of this was of course to generalize surface codes to the case of hybrid qudits. As a secondary goal we also wish to give a way to implement the Hilbert-Polya conjecture using the mathematics mentioned in some of the following papers which served as inspira"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## References"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "- [Synthesis of multi-qudit Hybrid and d-valued Quantum Logic Circuits by Decomposition](https://arxiv.org/pdf/quant-ph/0511019v1.pdf)\n",
    "\n",
    "- [Quantum gates on hybrid qudits](https://arxiv.org/pdf/quant-ph/0211185.pdf)\n",
    "\n",
    "- [Qudit surface codes and gauge theory with finite\n",
    "cyclic groups](https://arxiv.org/pdf/quant-ph/0609070.pdf)\n",
    "\n",
    "- [A fast fault-tolerant decoder for qubit and qudit surface codes](https://arxiv.org/pdf/1411.3028.pdf)\n",
    "\n",
    "- [Projecting onto Qubit Irreps of Young Diagrams](https://arxiv.org/pdf/quant-ph/0608150.pdf)\n",
    "\n",
    "- [The Riemann zeros as spectrum and the Riemann hypothesis](https://arxiv.org/pdf/1601.01797.pdf)\n",
    "\n",
    "- [Hilbert-Polya Conjecture, Zeta-functions, and Bosonic Quantum Field Theories](https://arxiv.org/pdf/1305.3342.pdf)\n",
    "\n",
    "- [Affine Schubert Varieties and Circular Complexes](https://arxiv.org/pdf/math/0210151.pdf)\n",
    "\n",
    "- [SURFACE ALGEBRAS I: DESSINS D’ENFANTS, SURFACE ALGEBRAS, AND DESSIN\n",
    "ORDERS](https://arxiv.org/pdf/1810.06750.pdf)\n",
    "\n",
    "- [SURFACE ALGEBRAS AND SURFACE ORDERS II: AFFINE BUNDLES ON CURVES](https://arxiv.org/pdf/1812.00621.pdf)"
   ]
  },
  {
   "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}