Tutorial1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Topological Data Analysis with Persistent Homology, $1^\\text{st}$ tutorial\n",
    "https://raphaeltinarrage.github.io/EMAp.html\n",
    "## Lesson IV: Simplicial complexes and topological invariants\n",
    "Last update: 29/01/2021"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gudhi \n",
    "import numpy as np\n",
    "import networkx as nx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def PrintSimplices(simpcomplex):\n",
    "    '''\n",
    "    Print a list of the simplices of the simplicial complex 'simpcomplex'.\n",
    "    \n",
    "    Input: \n",
    "        simpcomplex: a gudhi.SimplexTree\n",
    "        \n",
    "    Example:\n",
    "        simpcomplex = gudhi.SimplexTree()\n",
    "        simpcomplex.insert([0])\n",
    "        simpcomplex.insert([1])\n",
    "        PrintSimplices(simpcomplex)\n",
    "    '''\n",
    "    simplices = {i:[] for i in range(simpcomplex.dimension()+1)}\n",
    "    for filtration in simpcomplex.get_simplices():\n",
    "        simplex = filtration[0]\n",
    "        simplices[len(simplex)-1].append(simplex)\n",
    "    print('The simplicial complex contains the following simplices: ')\n",
    "    for i in range(simpcomplex.dimension()+1):\n",
    "        print('Dimension '+repr(i)+': ', end=\"\")\n",
    "        print(*simplices[i], sep = \", \")\n",
    "        \n",
    "def DrawSimplicialComplex(simpcomplex, pos=None):\n",
    "    '''\n",
    "    Draw the 1-skeleton of the simplicial complex 'simpcomplex', in the plane.\n",
    "    If 'pos==None', the position of the vertices are chosen at random, according to the 'spring_layout' of networkx.\n",
    "    If pos is a dict \n",
    "    \n",
    "    Input: \n",
    "        simpcomplex: a gudhi.SimplexTree\n",
    "        pos: a dict {(vertex of simpcomplex): (list of floats of length 2) }\n",
    "        \n",
    "    Example 1:\n",
    "        simpcomplex = gudhi.SimplexTree()\n",
    "        simpcomplex.insert([0])\n",
    "        simpcomplex.insert([1])\n",
    "        DrawSimplicialComplex(simpcomplex)\n",
    "\n",
    "    Example 2:\n",
    "        simpcomplex = gudhi.SimplexTree()\n",
    "        simpcomplex.insert([0])\n",
    "        simpcomplex.insert([1])\n",
    "        pos = {0:[0,0], 1:[0,1]}\n",
    "        DrawSimplicialComplex(simpcomplex, pos=pos)\n",
    "    '''\n",
    "    nodes=[]; edges=[]\n",
    "    for filtr in simpcomplex.get_skeleton(1):\n",
    "        simplex = filtr[0]\n",
    "        if len(simplex)==1:\n",
    "            nodes.append(simplex[0])\n",
    "        if len(simplex)==2:\n",
    "            edges.append(simplex)\n",
    "    G = nx.Graph()\n",
    "    G.add_nodes_from(nodes)\n",
    "    G.add_edges_from(edges)\n",
    "    if pos == None:\n",
    "        pos = nx.spring_layout(G)\n",
    "    nx.draw(G, pos=pos, with_labels=True, font_weight='bold', node_color='magenta')\n",
    "    \n",
    "def NumberOfConnectedComponents(simpcomplex, verbose = 'True'):\n",
    "    '''\n",
    "    Print the number of connected components of the simplicial complex 'simpcomplex'.\n",
    "    \n",
    "    Input: \n",
    "        simpcomplex: a gudhi.SimplexTree\n",
    "        \n",
    "    Example:\n",
    "        simpcomplex = gudhi.SimplexTree()\n",
    "        simpcomplex.insert([0])\n",
    "        simpcomplex.insert([1])\n",
    "        NumberOfConnectedComponents(simpcomplex)\n",
    "    '''    \n",
    "    simpcomplex.compute_persistence()\n",
    "    nbr_components = simpcomplex.betti_numbers()[0]\n",
    "    if verbose: print('The simplicial complex admits '+repr(nbr_components)+' connected component(s).')\n",
    "    return nbr_components\n",
    "\n",
    "def EulerCharacteristic(simpcomplex, verbose = 'True'):\n",
    "    '''\n",
    "    Print the Euler characteristic of the simplicial complex 'simpcomplex'.\n",
    "    \n",
    "    Input: \n",
    "        simpcomplex: a gudhi.SimplexTree\n",
    "        \n",
    "    Example:\n",
    "        simpcomplex = gudhi.SimplexTree()\n",
    "        simpcomplex.insert([0])\n",
    "        simpcomplex.insert([1])\n",
    "        EulerCharacteristic(simpcomplex)\n",
    "    '''\n",
    "    num_simplices = [0 for i in range(simpcomplex.dimension()+1)]\n",
    "    for filtration in simpcomplex.get_simplices():\n",
    "        simplex = filtration[0]\n",
    "        num_simplices[len(simplex)-1]+=1\n",
    "    Euler_characteristic = sum(num_simplices[::2]) - sum(num_simplices[1::2])\n",
    "    if verbose: print('The simplicial complex has Euler characteristic equal to '+repr(Euler_characteristic)+'.')\n",
    "    return Euler_characteristic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Triangulation of the circle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We start by considering a simplicial complex $S$ that is a triangulation of the circle.\n",
    "It is given by:\n",
    "- three vertices: $0$,$1$ and $2$,\n",
    "- three edges: $[0,1]$, $[1,2]$ and $[2,0]$.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<gudhi.simplex_tree.SimplexTree object at 0x7fa8741efcf0>\n"
     ]
    }
   ],
   "source": [
    "# We build a SimplexTree structure on gudhi\n",
    "\n",
    "simpcomplex = gudhi.SimplexTree()\n",
    "print(simpcomplex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We add the vertices\n",
    "\n",
    "simpcomplex.insert([0])\n",
    "simpcomplex.insert([1])\n",
    "simpcomplex.insert([2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The simplicial complex contains the following simplices: \n",
      "Dimension 0: [0], [1], [2]\n"
     ]
    }
   ],
   "source": [
    "# Let us verify that the vertices are correctly added\n",
    "\n",
    "PrintSimplices(simpcomplex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We add the edges\n",
    "\n",
    "simpcomplex.insert([0,1])\n",
    "simpcomplex.insert([1,2])\n",
    "simpcomplex.insert([2,0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The simplicial complex contains the following simplices: \n",
      "Dimension 0: [0], [1], [2]\n",
      "Dimension 1: [0, 1], [0, 2], [1, 2]\n"
     ]
    }
   ],
   "source": [
    "# Let us verify that the edges are correctly added\n",
    "\n",
    "PrintSimplices(simpcomplex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# The following function allows to draw the simplicial complex (uses the library networkx)\n",
    "\n",
    "DrawSimplicialComplex(simpcomplex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The simplicial complex contains the following simplices: \n",
      "Dimension 0: [0], [1], [2]\n",
      "Dimension 1: [0, 1], [0, 2], [1, 2]\n"
     ]
    }
   ],
   "source": [
    "# In Gudhi, if a simplex is added to the complex, then all its faces are\n",
    "# Hence we can use the simpler code:\n",
    "\n",
    "simpcomplex2 = gudhi.SimplexTree()\n",
    "\n",
    "simpcomplex2.insert([0,1])\n",
    "simpcomplex2.insert([1,2])\n",
    "simpcomplex2.insert([2,0])\n",
    "\n",
    "PrintSimplices(simpcomplex2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The simplicial complex contains the following simplices: \n",
      "Dimension 0: [0], [1], [2]\n",
      "Dimension 1: [0, 1], [0, 2], [1, 2]\n"
     ]
    }
   ],
   "source": [
    "# We can do it even faster, by using the remove_maximal_simplex function:\n",
    "\n",
    "simpcomplex3 = gudhi.SimplexTree()\n",
    "\n",
    "simpcomplex3.insert([0,1,2])\n",
    "simpcomplex3.remove_maximal_simplex([0,1,2])\n",
    "\n",
    "PrintSimplices(simpcomplex3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# be careful\n",
    "\n",
    "#simpcomplex3.remove_maximal_simplex([0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Computing topological invariants"
   ]
  },
  {
   "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": [
    "simpcomplexdim2 = gudhi.SimplexTree()\n",
    "\n",
    "simpcomplexdim2.insert([0,1,2])\n",
    "\n",
    "DrawSimplicialComplex(simpcomplexdim2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The following function returns the number of connected components of the complex.\n",
    "# Use verbose = 'True' or verbose = 'False' to print the output sentence.\n",
    "\n",
    "NumberOfConnectedComponents(simpcomplex, verbose = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The simplicial complex has Euler characteristic equal to 0.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The following function returns the Euler characteristic of the complex.\n",
    "# Use verbose = 'True' or verbose = 'False' to print the output sentence.\n",
    "\n",
    "EulerCharacteristic(simpcomplex)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 22"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Build triangulations of the alphabet letters, and compute their Euler characteristic.\n",
    "\n",
    "Given two letters that are homotopy equivalent, is it true thar their Euler characteristic are equal?\n",
    "Given two letters that are not homotopy equivalent, is it true thar their Euler characteristic are different?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The simplicial complex has Euler characteristic equal to 0.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# We build a triangulation of the letter A\n",
    "\n",
    "simpcomplex = gudhi.SimplexTree()\n",
    "\n",
    "simpcomplex.insert([0,1])\n",
    "simpcomplex.insert([1,2])\n",
    "simpcomplex.insert([2,0])\n",
    "simpcomplex.insert([3,0])\n",
    "simpcomplex.insert([4,1])\n",
    "\n",
    "DrawSimplicialComplex(simpcomplex)\n",
    "EulerCharacteristic(simpcomplex)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 23"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For every $n$, triangulate the bouquet of $n$ circles. Compute their Euler characteristic. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 24"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Implement the triangulation of the torus given in the notes.\n",
    "Compute its Euler characteristic."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 25"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider the following dataset of $30$ points $x_0, ..., x_{29}$ in $\\mathbb{R}^2$:\n",
    " ``` \n",
    " {0: [0.29409772548731694, 0.6646626625013836],\n",
    " 1: [0.01625840776679577, 0.1676405753593595],\n",
    " 2: [0.15988905150272759, 0.6411323760808338],\n",
    " 3: [0.9073191075894482, -0.16417982219713312],\n",
    " 4: [-0.18661467838673884, 0.31618948583046413],\n",
    " 5: [-0.3664040542098381, 0.9098590694955988],\n",
    " 6: [-0.43753448716144905, -0.8820102274699417],\n",
    " 7: [0.4096730199915961, -0.23801426675264126],\n",
    " 8: [0.5903822103474676, -0.7285102954232894],\n",
    " 9: [0.9133851839417766, -0.6606557328320093],\n",
    " 10: [-0.15516122940597588, 0.7565411235103017],\n",
    " 11: [-0.38626186295039866, -0.3662321656058476],\n",
    " 12: [0.005209710070218199, 0.27655964872153116],\n",
    " 13: [0.670078068894711, -0.00932202688834849],\n",
    " 14: [-0.011268465716772091, 0.24340880308017376],\n",
    " 15: [-0.6441978411451603, -0.9672635759413206],\n",
    " 16: [-0.2841794022401025, -0.6734801188906114],\n",
    " 17: [-0.15473260248990717, -0.1365357396855129],\n",
    " 18: [0.7177096105982121, 0.9378197891592468],\n",
    " 19: [-0.4677068504994166, 0.1533930130294956],\n",
    " 20: [-0.32379909116817096, 0.9694800649768063],\n",
    " 21: [-0.2886940472879451, -0.039544695812395725],\n",
    " 22: [-0.5900701743351606, 0.8350804500575086],\n",
    " 23: [0.14931959728335853, 0.869106793774487],\n",
    " 24: [-0.14500672678238824, -0.3170082291070364],\n",
    " 25: [0.07324547392476122, 0.6653572287065117],\n",
    " 26: [-0.662990048258566, 0.1908198608241125],\n",
    " 27: [-0.25641262456436276, -0.9844196180941553],\n",
    " 28: [-0.5105685407819842, -0.4236604017060557],\n",
    " 29: [0.6792549581008038, -0.026215820387260003]}\n",
    " ``` \n",
    " \n",
    " Write a function that takes as an input a parameter $r\\geq 0$, and returns the simplicial complex $\\mathcal{G}(r)$ defined as follows:\n",
    "- the vertices of $\\mathcal{G}(r)$ are the points $x_0, ..., x_{29}$,\n",
    "- for all $i, j \\in [0,29]$ with $i\\neq j$, the edge $[i,j]$ belongs to $\\mathcal{G}(r)$ if and only if $||x_i-x_j||\\leq r$.\n",
    "\n",
    "Compute the number of connected components of $\\mathcal{G}(r)$ for several values of $r$. What do you observe?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 26"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A *Erdős–Rényi random graph $\\mathcal{G}(n,p)$* is a simplicial complex obtained as follows:\n",
    "- add $n$ vertices $1,...,n$,\n",
    "- add each edge $[a,b]$, where $a,b \\in [1,n]$, to the complex with probability $p$.\n",
    "\n",
    "Builds a function that, given $n$ and $p$, outputs a simplicial complex $\\mathcal{G}(n,p)$.\n",
    "Observe the influence of $p$ on the number of connected components of $\\mathcal{G}(10,p)$ and $\\mathcal{G}(100,p)$.\n",
    "\n",
    "*Hint:* If $V$ is a list, `itertools.combinations(V,2)` can be used to generate all the non-ordered pairs `[a,b]` in `V` (package `itertools`).\n",
    "The command `random.random()` can be used to generate a random number between 0 and 1, and `random.random()<p` is  `True` with probability  `p` (package `random`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools\n",
    "import random"
   ]
  }
 ],
 "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}