{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Disk pasting and suspension\n",
    "\n",
    "## Introduction\n",
    "\n",
    "Let us recall the technique of space construction by *attaching maps* (**Marvin Greenberg** in\n",
    "*Lectures on Algebraic Topology.* Benjamin Inc, 1967.). Let $A$ be a subspace of a space $X$ and a map $f$ of $A$ into a space $Y$. In the space $X \\coprod Y$, let us identify each $x$ in $A$ with its image $f(x)$ in $Y$. The quotient space $Z=X\\bigcup_f Y$ of the space $X\\coprod Y$ by the equivalence relation that the identification above determines, is called the *adjunction space* of the system $(X \\supset A), (Y\\supset f(A))$. The quotient map $g: X\\coprod Y \\rightarrow Z$ sends $Y$ onto a subspace of $Z$. \n",
    "\n",
    "In this section, we shall take as pair $(X,A)$ the pair $(D^n, S^{n-1})$, where $D^n$ is the  unit disc of $\\mathbb{R}^n$ and  $S^{n-1}$ is the sphere of dimension ${n-1}$, boundary of $D^n$. In this case, the space $Z=D^n\\bigcup_f Y$ is said to be obtained from $Y$ by *attaching an n-disc via* $f$, or *disk pasting*.\n",
    "\n",
    "## The functions for  disk pasting\n",
    "\n",
    "The **Kenzo** program implements the previous technique of  space construction, via simplicial sets.\n",
    "We know that $D^n$ is homeomorphic to the standard simplex $\\Delta^n$. The method used by the implementor is the following:\n",
    "\n",
    "Starting from a simplicial set *ss* representing $Y$, build a new one having the same simplices as *ss* and in dimension $n$, a new added simplex described by the user. This description consists of:\n",
    "- a name (a symbol) for this new generator,\n",
    "- the list of all its $n+1$ faces.\n",
    "\n",
    "`disk-pasting` *smst dmns new faces* *[Function]*\n",
    "> Construct, from the  simplicial set  smst, a new simplicial set by attaching the unit disc of dimension *dmns*. The argument *faces* is the list of  $dmn+1$  simplices corresponding to the faces of the new simplex attached to *smst*. These simplices are, in principle, written as abstract simplices (*absm*), nevertheless it is possible to write them as geometric simplices (*gmsm*). In this case, the corresponding geometric simplices must have the correct dimension. The program will transform the list of *gmsm*'s into a list of *absm*'s.  The argument *new* allows the user to name this new added simplex. The program verifies the coherence of the addition of the new simplex by calling internally the function `check-faces`.\n",
    "\n",
    "`chcm-disk-pasting` *chcm dmns new  bndr* *[Function]*\n",
    "> Construct, from the chain complex  *chcm* (chain groups ${\\cal C}_*$), a new chain complex (chain groups ${\\cal C}_*'$), where:\n",
    "$$C'_p=C_p,\\quad \\forall p \\not= dmn,$$\n",
    "$$C'_{dmn}= C_{dmn} \\oplus \\mathbb{Z}\\, new.$$\n",
    "The symbol `new` is the name given by the user to a new generator in dimension $dmns$ and *bndr* is a combination of degree $dmns-1$ representing the  boundary of the generator *new*. Of course, one must have $d_{dmns-1}(bndr)=0.$\n",
    "\n",
    "`hmeq-disk-pasting` *hmeq dmns new bndr* `&key` *new-lbcc* *[Function]*\n",
    "> Construct a homotopy equivalence by attaching  the  generator *new* of dimension *dmns* with boundary *bndr* to the left bottom chain complex of the homotopy equivalence *hmeq*. This modification of the left bottom chain complex is propagated along the whole new homotopy equivalence.\n",
    "The key parameter *new-lbcc* is for internal use.\n",
    "\n",
    "### Example\n",
    "\n",
    "Let us begin by a trivial example corresponding to the well known following result: if $f$ maps $S^{n-1}$ onto a point $Y$, then by disk pasting we obtain a space homeomorphic to $S^n$. Here, the point $Y$ will be represented by the trivial simplicial set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "The object is a STANDARD-OBJECT of type CAT::SIMPLICIAL-SET.\n",
      "0. CMPR: #<FUNCTION S-CMPR>\n",
      "1. BASIS: #<CLOSURE (FLET CAT::RSLT :IN CAT::FINITE-SS-BASIS) {100507BF4B}>\n",
      "2. BSGN: *\n",
      "3. DFFR: [K2 Morphism (degree -1): K1 -> K1]\n",
      "4. GRMD: [K1 Simplicial-Set]\n",
      "5. EFHM: \"unbound\"\n",
      "6. IDNM: 1\n",
      "7. ORGN: (BUILD-FINITE-SS (*))\n",
      "8. CPRD: [K5 Morphism (degree 0): K1 -> K3]\n",
      "9. FACE: #<CLOSURE (FLET CAT::RSLT :IN CAT::FINITE-SS-FACE) {100507BF6B}>\n",
      "\n",
      "> \n",
      "Checking the 0-simplices..."
     ]
    },
    {
     "data": {
      "text/plain": [
       "[K1 Simplicial-Set]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def s0 (build-finite-ss '(*)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the identification process, the 1-simplices boundaries of the 2-simplex $\\Delta^2$ are applied on the 0--degeneracy of the base point $*$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[K6 Simplicial-Set]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def s2 (disk-pasting s0 \n",
    "                        2 \n",
    "                       's2 \n",
    "                       (list (absm 1 '*) (absm 1 '*) (absm 1 '*))  )) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Dimension = 0:\n",
      "\n",
      "       Vertices :  (*)\n",
      "\n",
      "Dimension = 1:\n",
      "\n",
      "Dimension = 2:\n",
      "\n",
      "       Simplex : S2\n",
      "\n",
      "               Faces : (<AbSm 0 *> <AbSm 0 *> <AbSm 0 *>)"
     ]
    },
    {
     "data": {
      "text/plain": [
       "NIL"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(show-structure s2 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "More interesting is the construction of the successive projectives spaces $P^i\\mathbb{R}$. Let us begin by $P^1\\mathbb{R}$. We start from a point (the simplicial set `s0`) and we identify the two boundary points of $\\Delta^1$ to the base point of `s0`. The new simplex to be added to `s0` is of dimension 1 and its 2 faces  are the base point itself. It is well known that the resulting corresponding  space is homeomorphic to the circle $S^1$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[K11 Simplicial-Set]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def p1r (disk-pasting s0 1 'd1 (list (absm 0 '*)(absm 0 '*))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Dimension = 0:\n",
      "\n",
      "       Vertices :  (*)\n",
      "\n",
      "Dimension = 1:\n",
      "\n",
      "       Simplex : D1\n",
      "\n",
      "               Faces : (<AbSm - *> <AbSm - *>)"
     ]
    },
    {
     "data": {
      "text/plain": [
       "NIL"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(show-structure p1r 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Computing boundary-matrix in dimension 0.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 44m 29s.\n",
      "Computing the boundary of the generator 1/1 (dimension 0) :\n",
      "* \n",
      "End of computing.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 1.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 44m 29s.\n",
      "Computing the boundary of the generator 1/1 (dimension 1) :\n",
      "D1 \n",
      "End of computing.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "Homology in dimension 0 :\n",
      "\n",
      "\n",
      "Component Z\n",
      "\n",
      "\n",
      "---done---\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 44m 29s.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 1.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 44m 29s.\n",
      "Computing the boundary of the generator 1/1 (dimension 1) :\n",
      "D1 \n",
      "End of computing.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 2.\n",
      "Rank of the source-module : 0.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "Homology in dimension 1 :\n",
      "\n",
      "\n",
      "Component Z\n",
      "\n",
      "\n",
      "---done---\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 44m 29s.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 2.\n",
      "Rank of the source-module : 0.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 3.\n",
      "Rank of the source-module : 0.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "Homology in dimension 2 :\n",
      "\n",
      "\n",
      "\n",
      "---done---\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 44m 29s.\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "NIL"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(dotimes (i 3) (homology p1r i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The projective spaces $P^n\\mathbb{R}$ of higher degree may be constructed by the following iterative rule. Suppose we have built a simplicial set corresponding to $P^{n-1}\\mathbb{R}$ and that we have named the  additional simplex $d_{n-1}$. Suppose also that $d_{n-2}$ has been previously defined ($d_0$ is the base point). Then the simplicial set corresponding to $P^n\\mathbb{R}$ is obtained by pasting $\\Delta^n$ with the following description of the additional simplex: \n",
    "\n",
    "- the name of the new simplex is  $d_n$,\n",
    "- the  faces of $d_n$ are:\n",
    "$$\n",
    "\\begin{aligned}\n",
    "\\partial_0 d_n & = & d_{n-1},\\\\\n",
    "\\partial_1 d_n & = & \\eta_0 d_{n-2},\\\\\n",
    "\\partial_2 d_n & = & \\eta_1 d_{n-2},\\\\\n",
    "\\cdots         & = & \\cdots , \\\\\n",
    "\\partial_{n-1} d_n & = & \\eta_{n-2} d_{n-2},\\\\\n",
    "\\partial_n d_n & = & d_{n-1}.\n",
    "\\end{aligned}\n",
    "$$\n",
    "\n",
    "So, applying this rule, we may construct a  model for  $P^i\\mathbb{R},\\, i=2,3,4$ and verify  the well known results about their respective homology groups."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[K31 Simplicial-Set]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def p2r (disk-pasting p1r 2 'd2\n",
    "                        (list (absm 0 'd1)\n",
    "                              (absm 1 '*)\n",
    "                              (absm 0 'd1)) ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Dimension = 0:\n",
      "\n",
      "       Vertices :  (*)\n",
      "\n",
      "Dimension = 1:\n",
      "\n",
      "       Simplex : D1\n",
      "\n",
      "               Faces : (<AbSm - *> <AbSm - *>)\n",
      "\n",
      "Dimension = 2:\n",
      "\n",
      "       Simplex : D2\n",
      "\n",
      "               Faces : (<AbSm - D1> <AbSm 0 *> <AbSm - D1>)"
     ]
    },
    {
     "data": {
      "text/plain": [
       "NIL"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(show-structure p2r 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Computing boundary-matrix in dimension 0.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 47m 15s.\n",
      "Computing the boundary of the generator 1/1 (dimension 0) :\n",
      "* \n",
      "End of computing.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 1.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 47m 15s.\n",
      "Computing the boundary of the generator 1/1 (dimension 1) :\n",
      "D1 \n",
      "End of computing.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "Homology in dimension 0 :\n",
      "\n",
      "\n",
      "Component Z\n",
      "\n",
      "\n",
      "---done---\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 47m 15s.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 1.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 47m 15s.\n",
      "Computing the boundary of the generator 1/1 (dimension 1) :\n",
      "D1 \n",
      "End of computing.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 2.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 47m 15s.\n",
      "Computing the boundary of the generator 1/1 (dimension 2) :\n",
      "D2 \n",
      "End of computing.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "Homology in dimension 1 :\n",
      "\n",
      "\n",
      "Component Z/2Z\n",
      "\n",
      "\n",
      "---done---\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 47m 15s.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 2.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 47m 15s.\n",
      "Computing the boundary of the generator 1/1 (dimension 2) :\n",
      "D2 \n",
      "End of computing.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 3.\n",
      "Rank of the source-module : 0.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "Homology in dimension 2 :\n",
      "\n",
      "\n",
      "\n",
      "---done---\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 47m 15s.\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "NIL"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(dotimes (i 3) (homology p2r i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[K49 Simplicial-Set]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def p3r (disk-pasting p2r 3 'd3\n",
    "                        (list (absm 0 'd2) \n",
    "                              (absm 1 'd1)\n",
    "                              (absm 2 'd1)\n",
    "                              (absm 0 'd2))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Dimension = 0:\n",
      "\n",
      "       Vertices :  (*)\n",
      "\n",
      "Dimension = 1:\n",
      "\n",
      "       Simplex : D1\n",
      "\n",
      "               Faces : (<AbSm - *> <AbSm - *>)\n",
      "\n",
      "Dimension = 2:\n",
      "\n",
      "       Simplex : D2\n",
      "\n",
      "               Faces : (<AbSm - D1> <AbSm 0 *> <AbSm - D1>)\n",
      "\n",
      "Dimension = 3:\n",
      "\n",
      "       Simplex : D3\n",
      "\n",
      "               Faces : (<AbSm - D2> <AbSm 0 D1> <AbSm 1 D1> <AbSm - D2>)"
     ]
    },
    {
     "data": {
      "text/plain": [
       "NIL"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(show-structure p3r 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Computing boundary-matrix in dimension 0.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 48m 3s.\n",
      "Computing the boundary of the generator 1/1 (dimension 0) :\n",
      "* \n",
      "End of computing.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 1.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 48m 3s.\n",
      "Computing the boundary of the generator 1/1 (dimension 1) :\n",
      "D1 \n",
      "End of computing.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "Homology in dimension 0 :\n",
      "\n",
      "\n",
      "Component Z\n",
      "\n",
      "\n",
      "---done---\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 48m 3s.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 1.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 48m 3s.\n",
      "Computing the boundary of the generator 1/1 (dimension 1) :\n",
      "D1 \n",
      "End of computing.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 2.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 48m 3s.\n",
      "Computing the boundary of the generator 1/1 (dimension 2) :\n",
      "D2 \n",
      "End of computing.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "Homology in dimension 1 :\n",
      "\n",
      "\n",
      "Component Z/2Z\n",
      "\n",
      "\n",
      "---done---\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 48m 3s.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 2.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 48m 3s.\n",
      "Computing the boundary of the generator 1/1 (dimension 2) :\n",
      "D2 \n",
      "End of computing.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 3.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 48m 3s.\n",
      "Computing the boundary of the generator 1/1 (dimension 3) :\n",
      "D3 \n",
      "End of computing.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "Homology in dimension 2 :\n",
      "\n",
      "\n",
      "\n",
      "---done---\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 48m 3s.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 3.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 48m 3s.\n",
      "Computing the boundary of the generator 1/1 (dimension 3) :\n",
      "D3 \n",
      "End of computing.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 4.\n",
      "Rank of the source-module : 0.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "Homology in dimension 3 :\n",
      "\n",
      "\n",
      "Component Z\n",
      "\n",
      "\n",
      "---done---\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 48m 3s.\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "NIL"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(dotimes (i 4)(homology p3r i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[K67 Simplicial-Set]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def p4r (disk-pasting p3r 4 'd4 \n",
    "                        (list (absm 0 'd3)\n",
    "                              (absm 1 'd2)\n",
    "                              (absm 2 'd2) \n",
    "                              (absm 4 'd2)\n",
    "                              (absm 0 'd3))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Computing boundary-matrix in dimension 0.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 48m 48s.\n",
      "Computing the boundary of the generator 1/1 (dimension 0) :\n",
      "* \n",
      "End of computing.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 1.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 48m 48s.\n",
      "Computing the boundary of the generator 1/1 (dimension 1) :\n",
      "D1 \n",
      "End of computing.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "Homology in dimension 0 :\n",
      "\n",
      "\n",
      "Component Z\n",
      "\n",
      "\n",
      "---done---\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 48m 48s.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 1.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 48m 48s.\n",
      "Computing the boundary of the generator 1/1 (dimension 1) :\n",
      "D1 \n",
      "End of computing.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 2.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 48m 48s.\n",
      "Computing the boundary of the generator 1/1 (dimension 2) :\n",
      "D2 \n",
      "End of computing.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "Homology in dimension 1 :\n",
      "\n",
      "\n",
      "Component Z/2Z\n",
      "\n",
      "\n",
      "---done---\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 48m 48s.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 2.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 48m 48s.\n",
      "Computing the boundary of the generator 1/1 (dimension 2) :\n",
      "D2 \n",
      "End of computing.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 3.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 48m 48s.\n",
      "Computing the boundary of the generator 1/1 (dimension 3) :\n",
      "D3 \n",
      "End of computing.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "Homology in dimension 2 :\n",
      "\n",
      "\n",
      "\n",
      "---done---\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 48m 48s.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 3.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 48m 48s.\n",
      "Computing the boundary of the generator 1/1 (dimension 3) :\n",
      "D3 \n",
      "End of computing.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 4.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 48m 48s.\n",
      "Computing the boundary of the generator 1/1 (dimension 4) :\n",
      "D4 \n",
      "End of computing.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "Homology in dimension 3 :\n",
      "\n",
      "\n",
      "Component Z/2Z\n",
      "\n",
      "\n",
      "---done---\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 48m 48s.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 4.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 48m 48s.\n",
      "Computing the boundary of the generator 1/1 (dimension 4) :\n",
      "D4 \n",
      "End of computing.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 5.\n",
      "Rank of the source-module : 0.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "Homology in dimension 4 :\n",
      "\n",
      "\n",
      "\n",
      "---done---\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 48m 48s.\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "NIL"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(dotimes (i 5) (homology p4r i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us give now some examples with the function `chcm-disk-pasting`. We are going to work with the unit chain complex (obtained by the function `z-chcm`, see chapter 1), having a unique non null component, namely a $\\mathbb{Z}$-module of degree 0 generated by the unique generator `:Z-gnrt`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[K85 Chain-Complex]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def *ccz* (z-chcm))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the function `chcm-disk-pasting`, let us construct from `*ccz*` a new chain complex  having in dimension 1 a unique  new generator `gen-1` whose boundary  is 5 times the unique generator in dimension 0. In this new chain complex the homology group in dimension 0 is $\\mathbb{Z}/5\\,\\mathbb{Z}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[K87 Chain-Complex]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def newcc-0 (chcm-disk-pasting *ccz* 1 'gen-1 (cmbn 0 5 :Z-gnrt)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Computing boundary-matrix in dimension 0.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 51m 43s.\n",
      "Computing the boundary of the generator 1/1 (dimension 0) :\n",
      ":Z-GNRT \n",
      "End of computing.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 1.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 51m 43s.\n",
      "Computing the boundary of the generator 1/1 (dimension 1) :\n",
      "GEN-1 \n",
      "End of computing.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "Homology in dimension 0 :\n",
      "\n",
      "Component Z/5Z\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(\n",
       "----------------------------------------------------------------------{CMBN 0}\n",
       "<1 * Z-GNRT>\n",
       "------------------------------------------------------------------------------\n",
       ")"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(chcm-homology-gen newcc-0 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Computing boundary-matrix in dimension 1.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 51m 58s.\n",
      "Computing the boundary of the generator 1/1 (dimension 1) :\n",
      "GEN-1 \n",
      "End of computing.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 2.\n",
      "Rank of the source-module : 0.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "Homology in dimension 1 :\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "NIL"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(chcm-homology-gen newcc-0 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us do the same with a generator whose boundary is  165 times the generator `:Z-gnrt`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[K91 Chain-Complex]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def newcc-1 (chcm-disk-pasting *ccz* 1 'gen-1 (cmbn 0 165 :Z-gnrt)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Computing boundary-matrix in dimension 0.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 52m 59s.\n",
      "Computing the boundary of the generator 1/1 (dimension 0) :\n",
      ":Z-GNRT \n",
      "End of computing.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 1.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 52m 59s.\n",
      "Computing the boundary of the generator 1/1 (dimension 1) :\n",
      "GEN-1 \n",
      "End of computing.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "Homology in dimension 0 :\n",
      "\n",
      "Component Z/165Z\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(\n",
       "----------------------------------------------------------------------{CMBN 0}\n",
       "<1 * Z-GNRT>\n",
       "------------------------------------------------------------------------------\n",
       ")"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(chcm-homology-gen newcc-1 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now from the chain complex `newcc-1`, let us build a new one, `newcc-2`, by adding in dimension 1 a second generator whose boundary  is 182 times the generator `:Z-gnrt`. The homology group in dimension 0 of this new chain complex is  the null group, since 165 and 182 are relatively prime integers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[K93 Chain-Complex]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def newcc-2 (chcm-disk-pasting newcc-1 1 'gen-2 (cmbn 0 182 :Z-gnrt)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Computing boundary-matrix in dimension 0.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 54m 35s.\n",
      "Computing the boundary of the generator 1/1 (dimension 0) :\n",
      ":Z-GNRT \n",
      "End of computing.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 1.\n",
      "Rank of the source-module : 2.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 54m 35s.\n",
      "Computing the boundary of the generator 1/2 (dimension 1) :\n",
      "GEN-2 \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 54m 35s.\n",
      "Computing the boundary of the generator 2/2 (dimension 1) :\n",
      "GEN-1 \n",
      "End of computing.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "Homology in dimension 0 :\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "NIL"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(chcm-homology-gen newcc-2 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Computing boundary-matrix in dimension 1.\n",
      "Rank of the source-module : 2.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 54m 50s.\n",
      "Computing the boundary of the generator 1/2 (dimension 1) :\n",
      "GEN-2 \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 54m 50s.\n",
      "Computing the boundary of the generator 2/2 (dimension 1) :\n",
      "GEN-1 \n",
      "End of computing.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 2.\n",
      "Rank of the source-module : 0.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "Homology in dimension 1 :\n",
      "\n",
      "Component Z\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(\n",
       "----------------------------------------------------------------------{CMBN 1}\n",
       "<-165 * GEN-2>\n",
       "<182 * GEN-1>\n",
       "------------------------------------------------------------------------------\n",
       ")"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(chcm-homology-gen newcc-2 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a second example, let us start from $\\Omega^1(S^3)$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[K95 Simplicial-Set]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def s3 (sphere 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[K100 Simplicial-Group]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def os3 (loop-space s3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the following instruction, we locate in the symbol `fund-simp` the canonical generator of $\\pi_2 (\\Omega^1S^3)$, that is the 2-simplex coming from the original sphere:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AbSm - <<Loop[S3]>>>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def fund-simp (absm 0 (loop3 0 's3 1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We need also the 2-degeneracy of the base point of the loop space:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AbSm 1-0 <<Loop>>>"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def null-simp (absm 3 +null-loop+))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We may  build now a new  object by pasting a disk $D^3$ as indicated by the following call:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[K112 Simplicial-Set]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def dos3 (disk-pasting os3 3 '<D3> \n",
    "                        (list fund-simp null-simp fund-simp null-simp)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Computing boundary-matrix in dimension 2.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 57m 56s.\n",
      "Computing the boundary of the generator 1/1 (dimension 2) :\n",
      "<<AlLp[2 S3]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 3.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 57m 56s.\n",
      "Computing the boundary of the generator 1/1 (dimension 3) :\n",
      "<D3> \n",
      "End of computing.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "Homology in dimension 2 :\n",
      "\n",
      "\n",
      "Component Z/2Z\n",
      "\n",
      "\n",
      "---done---\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 57m 56s.\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "NIL"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(homology dos3 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Computing boundary-matrix in dimension 3.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 58m 8s.\n",
      "Computing the boundary of the generator 1/1 (dimension 3) :\n",
      "<D3> \n",
      "End of computing.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 4.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 58m 8s.\n",
      "Computing the boundary of the generator 1/1 (dimension 4) :\n",
      "<<AlLp[2 S3][2 S3]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "Homology in dimension 3 :\n",
      "\n",
      "\n",
      "\n",
      "---done---\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 58m 8s.\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "NIL"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(homology dos3 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then, let us  build the  loop space of the object `dos3` and show the homology in dimension 5:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[K231 Simplicial-Group]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def odos3 (loop-space dos3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Computing boundary-matrix in dimension 5.\n",
      "Rank of the source-module : 14.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 1/14 (dimension 5) :\n",
      "<<AlLp[5 <<AlLp[2 S3][2 S3][2 S3]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 2/14 (dimension 5) :\n",
      "<<AlLp[2 <D3>][3 <<AlLp[2 S3][2 S3]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 3/14 (dimension 5) :\n",
      "<<AlLp[3 <<AlLp[2 S3][2 S3]>>][2 <D3>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 4/14 (dimension 5) :\n",
      "<<AlLp[1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>][3 <<AlLp[2 S3][2 S3]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 5/14 (dimension 5) :\n",
      "<<AlLp[1 <<AlLp[2 S3]>>][2 <D3>][2 <D3>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 6/14 (dimension 5) :\n",
      "<<AlLp[1 <<AlLp[2 S3]>>][3 <<AlLp[2 S3][2 S3]>>][1 <<AlLp[2 S3]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 7/14 (dimension 5) :\n",
      "<<AlLp[2 <D3>][1 <<AlLp[2 S3]>>][2 <D3>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 8/14 (dimension 5) :\n",
      "<<AlLp[2 <D3>][2 <D3>][1 <<AlLp[2 S3]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 9/14 (dimension 5) :\n",
      "<<AlLp[3 <<AlLp[2 S3][2 S3]>>][1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 10/14 (dimension 5) :\n",
      "<<AlLp[1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>][2 <D3>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 11/14 (dimension 5) :\n",
      "<<AlLp[1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>][2 <D3>][1 <<AlLp[2 S3]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 12/14 (dimension 5) :\n",
      "<<AlLp[1 <<AlLp[2 S3]>>][2 <D3>][1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 13/14 (dimension 5) :\n",
      "<<AlLp[2 <D3>][1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 14/14 (dimension 5) :\n",
      "<<AlLp[1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 6.\n",
      "Rank of the source-module : 26.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 1/26 (dimension 6) :\n",
      "<<AlLp[1 <<AlLp[2 S3]>>][5 <<AlLp[2 S3][2 S3][2 S3]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 2/26 (dimension 6) :\n",
      "<<AlLp[3 <<AlLp[2 S3][2 S3]>>][3 <<AlLp[2 S3][2 S3]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 3/26 (dimension 6) :\n",
      "<<AlLp[5 <<AlLp[2 S3][2 S3][2 S3]>>][1 <<AlLp[2 S3]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 4/26 (dimension 6) :\n",
      "<<AlLp[1 <<AlLp[2 S3]>>][2 <D3>][3 <<AlLp[2 S3][2 S3]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 5/26 (dimension 6) :\n",
      "<<AlLp[1 <<AlLp[2 S3]>>][3 <<AlLp[2 S3][2 S3]>>][2 <D3>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 6/26 (dimension 6) :\n",
      "<<AlLp[2 <D3>][1 <<AlLp[2 S3]>>][3 <<AlLp[2 S3][2 S3]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 7/26 (dimension 6) :\n",
      "<<AlLp[2 <D3>][2 <D3>][2 <D3>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 8/26 (dimension 6) :\n",
      "<<AlLp[2 <D3>][3 <<AlLp[2 S3][2 S3]>>][1 <<AlLp[2 S3]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 9/26 (dimension 6) :\n",
      "<<AlLp[3 <<AlLp[2 S3][2 S3]>>][1 <<AlLp[2 S3]>>][2 <D3>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 10/26 (dimension 6) :\n",
      "<<AlLp[3 <<AlLp[2 S3][2 S3]>>][2 <D3>][1 <<AlLp[2 S3]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 11/26 (dimension 6) :\n",
      "<<AlLp[1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>][3 <<AlLp[2 S3][2 S3]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 12/26 (dimension 6) :\n",
      "<<AlLp[1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>][2 <D3>][2 <D3>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 13/26 (dimension 6) :\n",
      "<<AlLp[1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>][3 <<AlLp[2 S3][2 S3]>>][1 <<AlLp[2 S3]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 14/26 (dimension 6) :\n",
      "<<AlLp[1 <<AlLp[2 S3]>>][2 <D3>][1 <<AlLp[2 S3]>>][2 <D3>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 15/26 (dimension 6) :\n",
      "<<AlLp[1 <<AlLp[2 S3]>>][2 <D3>][2 <D3>][1 <<AlLp[2 S3]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 16/26 (dimension 6) :\n",
      "<<AlLp[1 <<AlLp[2 S3]>>][3 <<AlLp[2 S3][2 S3]>>][1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 17/26 (dimension 6) :\n",
      "<<AlLp[2 <D3>][1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>][2 <D3>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 18/26 (dimension 6) :\n",
      "<<AlLp[2 <D3>][1 <<AlLp[2 S3]>>][2 <D3>][1 <<AlLp[2 S3]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 19/26 (dimension 6) :\n",
      "<<AlLp[2 <D3>][2 <D3>][1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 20/26 (dimension 6) :\n",
      "<<AlLp[3 <<AlLp[2 S3][2 S3]>>][1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 21/26 (dimension 6) :\n",
      "<<AlLp[1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>][2 <D3>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 22/26 (dimension 6) :\n",
      "<<AlLp[1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>][2 <D3>][1 <<AlLp[2 S3]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 23/26 (dimension 6) :\n",
      "<<AlLp[1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>][2 <D3>][1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 24/26 (dimension 6) :\n",
      "<<AlLp[1 <<AlLp[2 S3]>>][2 <D3>][1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 25/26 (dimension 6) :\n",
      "<<AlLp[2 <D3>][1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "Computing the boundary of the generator 26/26 (dimension 6) :\n",
      "<<AlLp[1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>][1 <<AlLp[2 S3]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "Homology in dimension 5 :\n",
      "\n",
      "\n",
      "Component Z/2Z\n",
      "\n",
      "Component Z/2Z\n",
      "\n",
      "Component Z/2Z\n",
      "\n",
      "Component Z/2Z\n",
      "\n",
      "Component Z/2Z\n",
      "\n",
      "Component Z/2Z\n",
      "\n",
      "Component Z\n",
      "\n",
      "\n",
      "---done---\n",
      "\n",
      ";; Clock -> 2016-03-15, 11h 59m 11s.\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "NIL"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(homology odos3 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Searching Homology for objects created by disk pasting\n",
    "\n",
    "The comment list of an object created by disk pasting contains various informations as shown by the simple following example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "The object is a STANDARD-OBJECT of type CAT::SIMPLICIAL-SET.\n",
      "0. CMPR: #<FUNCTION S-CMPR>\n",
      "1. BASIS: #<CLOSURE (FLET CAT::RSLT :IN CAT::FINITE-SS-BASIS) {1007875F3B}>\n",
      "2. BSGN: *\n",
      "3. DFFR: [K2 Morphism (degree -1): K1 -> K1]\n",
      "4. GRMD: [K1 Simplicial-Set]\n",
      "5. EFHM: [K19 Homotopy-Equivalence K1 <= K1 => K1]\n",
      "6. IDNM: 1\n",
      "7. ORGN: (BUILD-FINITE-SS (*))\n",
      "8. CPRD: [K5 Morphism (degree 0): K1 -> K3]\n",
      "9. FACE: #<CLOSURE (FLET CAT::RSLT :IN CAT::FINITE-SS-FACE) {1007875F7B}>\n",
      "\n",
      "> \n",
      "Checking the 0-simplices..."
     ]
    },
    {
     "data": {
      "text/plain": [
       "[K1 Simplicial-Set]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def s0 (build-finite-ss '(*)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[K374 Simplicial-Set]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def s2 (disk-pasting s0 \n",
    "                        2 \n",
    "                       's2 \n",
    "                       (list (absm 1 '*) (absm 1 '*) (absm 1 '*))  ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(DISK-PASTING [K1 Simplicial-Set] 2 S2 (<AbSm 0 *> <AbSm 0 *> <AbSm 0 *>))"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(orgn s2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In fact, the comment list contains the very arguments used to realize the attaching. The method retrieves those arguments, gets the homotopy equivalence value of the `efhm` slot of the old object -creating it if necessary - then build a new homotopy equivalence, by calling the function `hmeq-disk-pasting` *hmeq* which takes into account the attaching.\n",
    "\n",
    "```commonlisp\n",
    "(DEFMETHOD SEARCH-EFHM (smst (orgn (eql 'disk-pasting)))\n",
    "  (declare (type simplicial-set smst))\n",
    "  (the homotopy-equivalence\n",
    "   (destructuring-bind (old-smst dmns new faces) (rest (orgn smst))\n",
    "       (declare\n",
    "          (type simplicial-set old-smst)\n",
    "          (fixnum dmns)\n",
    "          (symbol new)\n",
    "          (ignore faces))\n",
    "       (hmeq-disk-pasting \n",
    "               (efhm old-smst)\n",
    "               dmns new (? smst dmns new)\n",
    "               :new-lbcc smst))))\n",
    "```\n",
    "\n",
    "## The functions for the suspension"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "SBCL Lisp",
   "language": "lisp",
   "name": "lisp"
  },
  "language_info": {
   "codemirror_mode": "text/x-common-lisp",
   "mimetype": "text/x-common-lisp",
   "name": "common-lisp",
   "pygments_lexer": "common-lisp",
   "version": "X3J13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}