diff --git a/examples/Chapter14.ipynb b/examples/Chapter14.ipynb new file mode 100644 index 0000000..08d336e --- /dev/null +++ b/examples/Chapter14.ipynb @@ -0,0 +1,2116 @@ +{ + "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: #\n", + "1. BASIS: #\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: #\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 : ( )" + ] + }, + { + "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 : ( )" + ] + }, + { + "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 : ( )\n", + "\n", + "Dimension = 2:\n", + "\n", + " Simplex : D2\n", + "\n", + " Faces : ( )" + ] + }, + { + "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 : ( )\n", + "\n", + "Dimension = 2:\n", + "\n", + " Simplex : D2\n", + "\n", + " Faces : ( )\n", + "\n", + "Dimension = 3:\n", + "\n", + " Simplex : D3\n", + "\n", + " Faces : ( )" + ] + }, + { + "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": [ + ">>" + ] + }, + "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": [ + ">>" + ] + }, + "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 ' \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", + "<> \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", + " \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", + " \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", + "<> \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", + "<>]>> \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", + "<][3 <>]>> \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", + "<>][2 ]>> \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", + "<>][1 <>][3 <>]>> \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", + "<>][2 ][2 ]>> \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", + "<>][3 <>][1 <>]>> \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", + "<][1 <>][2 ]>> \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", + "<][2 ][1 <>]>> \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", + "<>][1 <>][1 <>]>> \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", + "<>][1 <>][1 <>][2 ]>> \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", + "<>][1 <>][2 ][1 <>]>> \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", + "<>][2 ][1 <>][1 <>]>> \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", + "<][1 <>][1 <>][1 <>]>> \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", + "<>][1 <>][1 <>][1 <>][1 <>]>> \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", + "<>][5 <>]>> \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", + "<>][3 <>]>> \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", + "<>][1 <>]>> \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", + "<>][2 ][3 <>]>> \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", + "<>][3 <>][2 ]>> \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", + "<][1 <>][3 <>]>> \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", + "<][2 ][2 ]>> \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", + "<][3 <>][1 <>]>> \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", + "<>][1 <>][2 ]>> \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", + "<>][2 ][1 <>]>> \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", + "<>][1 <>][1 <>][3 <>]>> \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", + "<>][1 <>][2 ][2 ]>> \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", + "<>][1 <>][3 <>][1 <>]>> \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", + "<>][2 ][1 <>][2 ]>> \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", + "<>][2 ][2 ][1 <>]>> \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", + "<>][3 <>][1 <>][1 <>]>> \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", + "<][1 <>][1 <>][2 ]>> \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", + "<][1 <>][2 ][1 <>]>> \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", + "<][2 ][1 <>][1 <>]>> \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", + "<>][1 <>][1 <>][1 <>]>> \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", + "<>][1 <>][1 <>][1 <>][2 ]>> \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", + "<>][1 <>][1 <>][2 ][1 <>]>> \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", + "<>][1 <>][2 ][1 <>][1 <>]>> \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", + "<>][2 ][1 <>][1 <>][1 <>]>> \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", + "<][1 <>][1 <>][1 <>][1 <>]>> \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", + "<>][1 <>][1 <>][1 <>][1 <>][1 <>]>> \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: #\n", + "1. BASIS: #\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: #\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 ( ))" + ] + }, + "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 +}