diff --git a/examples/Chapter17.ipynb b/examples/Chapter17.ipynb new file mode 100644 index 0000000..e04bf9b --- /dev/null +++ b/examples/Chapter17.ipynb @@ -0,0 +1,1262 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Classifying Spaces\n", + "\n", + "## Introduction\n", + "\n", + "Let ${\\cal G}$ be a simplicial group $0$-reduced. The software `Kenzo` allows the construction of the universal bundle $\\bar{\\cal W}{\\cal G}$, called the classifying space of ${\\cal G}$. It is known that this is the base space of a principal bundle such that the total space is contractible. We know also that if ${\\cal G}$ is an Abelian simplicial group then $\\bar{\\cal W}{\\cal G}$ is also an Abelian simplicial group, otherwise if ${\\cal G}$ is non-Abelian, then $\\bar{\\cal W}{\\cal G}$ is only a simplicial set. In dimension $n$ the simplices of the classifying space are elements of the product:\n", + "$${\\cal G}_{n-1}\\times {\\cal G}_{n-2}\\times\\cdots\\times{\\cal G}_0,$$\n", + "where ${\\cal G}_k$ is the set of the $k$-simplices of the given simplicial group.\n", + "\n", + "A simplex of $\\bar{\\cal W}{\\cal G}$ is called **gbar** (*geometric* bar) and may be seen as an $n$-tuple\n", + "$$(g_{n-1}, g_{n-2}, \\ldots, g_1, g_0),$$\n", + "where the $g_i$'s are elements of ${\\cal G}_i$, possibly *degenerated*.\n", + "In `Kenzo` a gbar is represented externally under the form:\n", + "\n", + "`<<`$[\\eta g]_{n-2}$ `> ... <` $[\\eta g]_1$ `> < -` $g_0$`> >>`\n", + "\n", + "where a term such as $[\\eta g]_i$ is a simplex of ${\\cal G}_i$. Let us recall that our group ${\\cal G}$ is assumed 0-reduced; as a consequence, the $g_0$ compound of a gbar is necessarily the identity element of ${\\cal G}$.\n", + "\n", + "In the symbolic expression $[\\eta g]_i$, the operator $\\eta$ represents a sequence (possibly the void one) of degeneracy operators applied coherently upon some element of ${\\cal G}_k$, for $k\\leq i$. For instance $[\\eta g]_1$ can be $\\eta_0 g_0$, i.e. the 0-degeneracy of the base point and $[\\eta g]_2$ can be can be $\\eta_1\\eta_0 g_0$. To be more explicit, let us take the Abelian simplicial group $K(\\mathbb{Z}_2, 1)$ (see the simplicial groups chapter), then some elements of the basis in dimension 4 of its classifying space are, for instance:\n", + "```\n", + "<<- 2><- 1><- 0>>>\n", + "<<1-0 0><0 0><- 0>>>\n", + "<<- 2><0 0><- 0>>>\n", + "<<0 1><0 0><- 0>>>\n", + "<<1 1><0 0><- 0>>>\n", + "<<1 1><0 0><- 0>>>\n", + "<<1 1><- 1><- 0>>>\n", + "<<0 1><0 0><- 0>>>\n", + "```\n", + "We recall that the symbol `-`, in front of an element means \"no degeneracy\".\n", + "\n", + "## Face, degeneracy and group operations\n", + "\n", + "Let us denote a gbar under the following generic form:\n", + "$$\n", + "g_{bar}=(g_{n-1}, g_{n-2}, \\ldots, {\\bf g_j}, \\ldots, g_1, g_0).\n", + "$$\n", + "In this symbolism, $g_0$ is also the base point of the initial simplicial group. The rule for the face operators is the following:\n", + "- If $j=n$, $\\delta_n g_{bar}= (g_{n-2}, g_{n-3}, \\ldots, g_1, g_0).$\n", + "- If $j \\not=n$, $\\delta_j g_{bar}= (\\delta_j g_{n-1}, \\ldots, {\\bf \\delta_j g_{j+1}, g_{j-1}.\\delta_j g_j, g_{j-1}}, \\ldots, g_1, g_0),$ where in the term $\\bf g_{j-1}.\\delta_j g_j$, the dot represents the group composition.\n", + "- If $j=0$, $\\delta_0 g_{bar}= (\\delta_0 g_{n-1}, \\ldots, \\delta_0 g_1).$\n", + "\n", + "The rule for the degeneracy operators is:\n", + "\n", + "$$\n", + "\\eta_j g_{bar}= (\\eta_j g_{n-1}, \\ldots, {\\bf \\eta_j g_{j+1}, \\eta_{j-1}\\eta_{j-2}\\ldots\\eta_1\\eta_0 g_0, g_{j-1}}, \\ldots, g_1, g_0).\n", + "$$\n", + "\n", + "If ${\\cal G}$ is Abelian then $\\bar{\\cal W}{\\cal G}$ is also Abelian and its composition law is simply:\n", + "\n", + "$$\n", + "(g_{n-1}, \\ldots, g_1, g_0).(g'_{n-1}, g'_1, g'_0)=(g_{n-1}.g'_{n-1}, \\ldots, g_1.g'_1, g_0.g'_0).\n", + "$$\n", + "\n", + "It is well known that if the initial group is not Abelian then, in general, the previous composition law is not compatible with the simplicial structure.\n", + "\n", + "## The functions for the classifying spaces\n", + "\n", + "`gbar` *dmns dop-1 elem-1 ... dop-n elem-n* *[Macro]*\n", + "> Build a gbar in dimension *dmns*. The sequence *dop-1 elem-1 ... dop-n elem-n*, is a sequence of pairs (*dop-k, elem-k*), where *dop-k* is a **binary coded** degeneracy operator and *elem-k* a simplex of the initial simplicial group. The ordering of the pairs in the sequence must conform to the theoritical definition of a gbar. If the sequence of pairs is void, the special call `(gbar 0)`, creates the base point of the classifying space externally represented by `<>`. This base point can be reached through the system symbol `+null-gbar+`.\n", + "\n", + "`classifying-space-cmpr` *cmpr* *[Function]*\n", + "> From a comparison function *cmpr* defined for a simplicial group ${\\cal G}$, build a comparison function for the classifying space of ${\\cal G}$.\n", + "\n", + "`classifying-space-basis` *basis* *[Function]*\n", + "> From the basis function *basis* of a simplicial group ${\\cal G}$, build a basis function for the classifying space of ${\\cal G}$. If ${\\cal G}$ is locally effective, this function returns the symbol `:locally-effective`.\n", + "\n", + "`classifying-space-face` *face sintr-grml* *[Function]*\n", + "> From the face function *face* and the lisp function for the group law, *sintr-grml*, of a simplicial group ${\\cal G}$, build a face function for the classifying space of ${\\cal G}$.\n", + "\n", + "`classifying-space` *smgr* *[Method]*\n", + "> Build the simplicial set, classifying space of the simplicial group *smgr*. The construction uses the three preceding auxiliary functions. The base point of the returned simplicial set is the null gbar `+null-gbar+`.\n", + "\n", + "`classifying-space` *A-smgr* *[Method]*\n", + "> Build the Abelian simplicial group, classifying space of the Abelian simplicial group *A-smgr*. The group law and its inverse (slots `:sintr-grml` and `:sintr-grin`) are built by the two auxiliary functions: \n", + "`classifying-space-grml-sintr` and \n", + "`classifying-space-grin-sintr`, \n", + "defining the laws of this new group from the corresponding laws of *A-smgr*.\n", + "\n", + "## Eilenberg-Mac Lane spaces $K(\\pi,n)$\n", + "\n", + "We have already described $K(\\mathbb{Z},1)$ and $K(\\mathbb{Z}_2,1)$ in the chapter on simplicial groups. This section gives some complements about the construction of $K(\\mathbb{Z},n)$ and $K(\\mathbb{Z}_2,n)$. The trivial case for $n=0$ is not implemented in `Kenzo`. For $n > 1$, these simplicial groups are built recursively as the classifying spaces of $K(\\mathbb{Z},n-1)$ and $K(\\mathbb{Z}_2,n-1)$, respectively, as shown in the following description:\n", + "\n", + "`k-z` *n* *[Function]*\n", + "> Build $K(\\mathbb{Z},n)$ recursively from $K(\\mathbb{Z},n-1)$. If $n=1$, return $K(\\mathbb{Z},1)$\n", + "```commonlisp\n", + " (defun K-Z (n)\n", + " (the ab-simplicial-group\n", + " (if (= n 1)\n", + " (k-z-1)\n", + " (classifying-space (k-z (1- n))))))\n", + "```\n", + "\n", + "`k-z2` *n* *[Function]*\n", + "> Build $K(\\mathbb{Z}_2,n)$ recursively from $K(\\mathbb{Z}_2,n-1)$. If $n=1$, return $K(\\mathbb{Z}_2,1)$\n", + "```commonlisp\n", + " (defun K-Z2 (n)\n", + " (the ab-simplicial-group\n", + " (if (= n 1)\n", + " (k-z2-1)\n", + " (classifying-space (k-z2 (1- n))))))\n", + "```\n", + "\n", + "These spaces have an effective homology which is computed via a *search-efhm* method (described in a next chapter). For the case $n=1$, we may recall here that $K(\\mathbb{Z},1)$, though being locally effective, has the homology of $S^1$. The *search-efhm* method applied to this chain complex does the following: a reduction between $K(\\mathbb{Z},1)$ and the chain complex `circle` (described in the chain complex chapter) is built using the function `kz1-rdct` and the homotopy equivalence, value of the slot `efhm`, is built between this reduction and the trivial reduction of $K(\\mathbb{Z},1)$ upon itself.\n", + "\n", + "On the other hand, $K(\\mathbb{Z},2)$ has a very simple finite basis in every dimension (see $\\mathbb{R}$-projective spaces), so its homology is computed directly from its basis. The homotopy equivalence, value of the slot `efhm`, is the trivial homotopy equivalence of $K(\\mathbb{Z},2)$ upon itself.\n", + "\n", + "### Examples\n", + "\n", + "Let us begin by showing some examples of gbars built from various initial simplicial groups. In the second statement, the initial simplicial group is $K(\\mathbb{Z}_2, 1)$, in the third, it is $\\Omega({\\mathit Moore}(2,2))$. We recall that in the call of the function `gbar`, the degeneracy operators appear as integers, according to the general rule in `Kenzo`, but the printed result shows in clear the sequence of $\\eta_i$'s." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "<<1 B>>>" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(gbar 2 1 'a 2 'b)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "<<1-0 0><0 0><- 0>>>" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(gbar 4 0 3 3 0 1 0 0 0)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "<>><- <>><- <>><- <>>>>" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(def gbar-m22 (gbar 4 0 (loop3 3 'm2 1 4 'n3 1)\n", + " 0 (loop3 0 'n3 1)\n", + " 0 (loop3 0 'm2 1)\n", + " 0 +null-loop+))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let us test the face function upon this simplex. The user will note that the face function returns an abstract simplex." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[K6 Simplicial-Group]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(def om (loop-space (moore 2 2)))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "#" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(def face (classifying-space-face (face om) (sintr (grml om))))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + ">><- <>><- <>>>>> \n", + ">><- <>>>>> \n", + ">><- <>><- <>>>>> \n", + ">><- <>><- <>>>>> \n", + ">><- <>><- <>>>>> " + ] + }, + { + "data": { + "text/plain": [ + "NIL" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(dotimes (i 5) (print (funcall face i 4 gbar-m22)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let us work now, directly with the classifying space of $K(\\mathbb{Z}_2, 1)$." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[K30 Abelian-Simplicial-Group]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(def cs-kz21 (classifying-space (k-z2-1))) " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(CLASSIFYING-SPACE [K18 Abelian-Simplicial-Group])" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(orgn cs-kz21)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "<<- 2><- 1><- 0>>>" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(def elem-1 (first (basis cs-kz21 4)))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "\n", + "----------------------------------------------------------------------{CMBN 3}\n", + "<2 * <<- 1><- 0>>>>\n", + "------------------------------------------------------------------------------\n" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(? cs-kz21 4 elem-1)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "\n", + "----------------------------------------------------------------------{CMBN 2}\n", + "------------------------------------------------------------------------------\n" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(? cs-kz21 *)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "\n", + "----------------------------------------------------------------------{CMBN 4}\n", + "<1 * > <<- 2><- 1><- 0>>>>>\n", + "<1 * <- 0>>> <<- 0>>>>>\n", + "<1 * <- 2><- 1><- 0>>> <>>>\n", + "------------------------------------------------------------------------------\n" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(cprd cs-kz21 4 elem-1)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "<- 1><- 0>>>> \n", + "<- 0>>>> \n", + "<- 0>>>> \n", + "<- 0>>>> \n", + "<- 1><- 0>>>> " + ] + }, + { + "data": { + "text/plain": [ + "NIL" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(dotimes (i 5)\n", + " (print (face cs-kz21 i 4 elem-1)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let us test the law group with $K(\\mathbb{Z}, 1)$. We recall the simplices of this Abelian simplicial group are represented as lists of integers. The functions `grml` and `grin` accept also the gbars under the form of abstract simplices (see the last statement)." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[K54 Abelian-Simplicial-Group]" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(def cs-kz1 (classifying-space (k-z-1)))" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + ">>" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(grml cs-kz1 3 (crpr 0 (gbar 3 0 '(1 2) 0 '(3) 0 '())\n", + " 0 (gbar 3 0 '(-1 -2) 0 '(-3) 0 '())))" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "<0 NIL><- NIL>>>>" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(grml cs-kz1 3 (crpr 0 (gbar 3 0 '(1 2) 0 '(3) 0 '())\n", + " 4 (gbar 2 0 '(-3) 0 '()))) " + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "<- (3)><- NIL>>>>" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(grml cs-kz1 3 (crpr 0 (gbar 3 0 '(1 2) 0 '(3) 0 '())\n", + " 1 (gbar 2 0 '(-3) 0 '())))" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "<0 NIL><- NIL>>>>" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(grin cs-kz1 3 (gbar 3 0 '(1 2) 1 '() 0 '()))" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "<0 NIL><- NIL>>>>" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(grin cs-kz1 3 *)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As $K(\\mathbb{Z}, 1)$ and $K(\\mathbb{Z_2}, 1)$ are Abelian simplicial groups, we may iterate the classifying space construction and retrieve some known results." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "---done---" + ] + }, + { + "data": { + "text/plain": [ + "NIL" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(cat-init) ;; re-initialization" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[K25 Abelian-Simplicial-Group]" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(def k-z-3 (k-z 3))" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "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-19, 17h 57m 16s.\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 : 0.\n", + "\n", + "\n", + "\n", + "\n", + "Homology in dimension 0 :\n", + "\n", + "\n", + "Component Z\n", + "\n", + "\n", + "---done---\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\n", + "\n", + "\n", + "Computing boundary-matrix in dimension 1.\n", + "Rank of the source-module : 0.\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", + "\n", + "---done---\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\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 : 1.\n", + "\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\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", + "\n", + "---done---\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\n", + "\n", + "\n", + "Computing boundary-matrix in dimension 3.\n", + "Rank of the source-module : 1.\n", + "\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\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 : 0.\n", + "\n", + "\n", + "\n", + "\n", + "Homology in dimension 3 :\n", + "\n", + "\n", + "Component Z\n", + "\n", + "\n", + "---done---\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\n", + "\n", + "\n", + "Computing boundary-matrix in dimension 4.\n", + "Rank of the source-module : 0.\n", + "\n", + "\n", + "Computing boundary-matrix in dimension 5.\n", + "Rank of the source-module : 1.\n", + "\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\n", + "Computing the boundary of the generator 1/1 (dimension 5) :\n", + "<>]>> \n", + "End of computing.\n", + "\n", + "\n", + "\n", + "\n", + "Homology in dimension 4 :\n", + "\n", + "\n", + "\n", + "---done---\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\n", + "\n", + "\n", + "Computing boundary-matrix in dimension 5.\n", + "Rank of the source-module : 1.\n", + "\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\n", + "Computing the boundary of the generator 1/1 (dimension 5) :\n", + "<>]>> \n", + "End of computing.\n", + "\n", + "\n", + "Computing boundary-matrix in dimension 6.\n", + "Rank of the source-module : 1.\n", + "\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\n", + "Computing the boundary of the generator 1/1 (dimension 6) :\n", + "<>][3 <>]>> \n", + "End of computing.\n", + "\n", + "\n", + "\n", + "\n", + "Homology in dimension 5 :\n", + "\n", + "\n", + "Component Z/2Z\n", + "\n", + "\n", + "---done---\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\n", + "\n", + "\n", + "Computing boundary-matrix in dimension 6.\n", + "Rank of the source-module : 1.\n", + "\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\n", + "Computing the boundary of the generator 1/1 (dimension 6) :\n", + "<>][3 <>]>> \n", + "End of computing.\n", + "\n", + "\n", + "Computing boundary-matrix in dimension 7.\n", + "Rank of the source-module : 1.\n", + "\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\n", + "Computing the boundary of the generator 1/1 (dimension 7) :\n", + "<>]>> \n", + "End of computing.\n", + "\n", + "\n", + "\n", + "\n", + "Homology in dimension 6 :\n", + "\n", + "\n", + "\n", + "---done---\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\n", + "\n", + "\n", + "Computing boundary-matrix in dimension 7.\n", + "Rank of the source-module : 1.\n", + "\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\n", + "Computing the boundary of the generator 1/1 (dimension 7) :\n", + "<>]>> \n", + "End of computing.\n", + "\n", + "\n", + "Computing boundary-matrix in dimension 8.\n", + "Rank of the source-module : 2.\n", + "\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\n", + "Computing the boundary of the generator 1/2 (dimension 8) :\n", + "<>][5 <>]>> \n", + "End of computing.\n", + "\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\n", + "Computing the boundary of the generator 2/2 (dimension 8) :\n", + "<>][3 <>]>> \n", + "End of computing.\n", + "\n", + "\n", + "\n", + "\n", + "Homology in dimension 7 :\n", + "\n", + "\n", + "Component Z/3Z\n", + "\n", + "\n", + "---done---\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\n", + "\n", + "\n", + "Computing boundary-matrix in dimension 8.\n", + "Rank of the source-module : 2.\n", + "\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\n", + "Computing the boundary of the generator 1/2 (dimension 8) :\n", + "<>][5 <>]>> \n", + "End of computing.\n", + "\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\n", + "Computing the boundary of the generator 2/2 (dimension 8) :\n", + "<>][3 <>]>> \n", + "End of computing.\n", + "\n", + "\n", + "Computing boundary-matrix in dimension 9.\n", + "Rank of the source-module : 2.\n", + "\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\n", + "Computing the boundary of the generator 1/2 (dimension 9) :\n", + "<>]>> \n", + "End of computing.\n", + "\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\n", + "Computing the boundary of the generator 2/2 (dimension 9) :\n", + "<>][3 <>][3 <>]>> \n", + "End of computing.\n", + "\n", + "\n", + "\n", + "\n", + "Homology in dimension 8 :\n", + "\n", + "\n", + "Component Z/2Z\n", + "\n", + "\n", + "---done---\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\n", + "\n", + "\n", + "Computing boundary-matrix in dimension 9.\n", + "Rank of the source-module : 2.\n", + "\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\n", + "Computing the boundary of the generator 1/2 (dimension 9) :\n", + "<>]>> \n", + "End of computing.\n", + "\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\n", + "Computing the boundary of the generator 2/2 (dimension 9) :\n", + "<>][3 <>][3 <>]>> \n", + "End of computing.\n", + "\n", + "\n", + "Computing boundary-matrix in dimension 10.\n", + "Rank of the source-module : 3.\n", + "\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\n", + "Computing the boundary of the generator 1/3 (dimension 10) :\n", + "<>][7 <>]>> \n", + "End of computing.\n", + "\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\n", + "Computing the boundary of the generator 2/3 (dimension 10) :\n", + "<>][5 <>]>> \n", + "End of computing.\n", + "\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\n", + "Computing the boundary of the generator 3/3 (dimension 10) :\n", + "<>][3 <>]>> \n", + "End of computing.\n", + "\n", + "\n", + "\n", + "\n", + "Homology in dimension 9 :\n", + "\n", + "\n", + "Component Z/2Z\n", + "\n", + "\n", + "---done---\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "NIL" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(homology k-z-3 0 10)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[K342 Abelian-Simplicial-Group]" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(def k-z2-5 (k-z2 5))" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "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-19, 17h 57m 16s.\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 : 0.\n", + "\n", + "\n", + "\n", + "\n", + "Homology in dimension 0 :\n", + "\n", + "\n", + "Component Z\n", + "\n", + "\n", + "---done---\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\n", + "\n", + "\n", + "Computing boundary-matrix in dimension 1.\n", + "Rank of the source-module : 0.\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", + "\n", + "---done---\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\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-19, 17h 57m 16s.\n", + "\n", + "\n", + "Computing boundary-matrix in dimension 3.\n", + "Rank of the source-module : 0.\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", + "\n", + "---done---\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\n", + "\n", + "\n", + "Computing boundary-matrix in dimension 4.\n", + "Rank of the source-module : 0.\n", + "\n", + "\n", + "Computing boundary-matrix in dimension 5.\n", + "Rank of the source-module : 1.\n", + "\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\n", + "Computing the boundary of the generator 1/1 (dimension 5) :\n", + "<>]>>]>>]>> \n", + "End of computing.\n", + "\n", + "\n", + "\n", + "\n", + "Homology in dimension 4 :\n", + "\n", + "\n", + "\n", + "---done---\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\n", + "\n", + "\n", + "Computing boundary-matrix in dimension 5.\n", + "Rank of the source-module : 1.\n", + "\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\n", + "Computing the boundary of the generator 1/1 (dimension 5) :\n", + "<>]>>]>>]>> \n", + "End of computing.\n", + "\n", + "\n", + "Computing boundary-matrix in dimension 6.\n", + "Rank of the source-module : 1.\n", + "\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\n", + "Computing the boundary of the generator 1/1 (dimension 6) :\n", + "<>]>>]>>]>> \n", + "End of computing.\n", + "\n", + "\n", + "\n", + "\n", + "Homology in dimension 5 :\n", + "\n", + "\n", + "Component Z/2Z\n", + "\n", + "\n", + "---done---\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\n", + "\n", + "\n", + "Computing boundary-matrix in dimension 6.\n", + "Rank of the source-module : 1.\n", + "\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\n", + "Computing the boundary of the generator 1/1 (dimension 6) :\n", + "<>]>>]>>]>> \n", + "End of computing.\n", + "\n", + "\n", + "Computing boundary-matrix in dimension 7.\n", + "Rank of the source-module : 2.\n", + "\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\n", + "Computing the boundary of the generator 1/2 (dimension 7) :\n", + "<>]>>]>>]>> \n", + "End of computing.\n", + "\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\n", + "Computing the boundary of the generator 2/2 (dimension 7) :\n", + "<>]>>]>>]>> \n", + "End of computing.\n", + "\n", + "\n", + "\n", + "\n", + "Homology in dimension 6 :\n", + "\n", + "\n", + "\n", + "---done---\n", + "\n", + ";; Clock -> 2016-03-19, 17h 57m 16s.\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "NIL" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(homology k-z2-5 0 7)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Lisp files concerned in this chapter\n", + "\n", + "`classifying-space.lisp`, `k-pi-n.lisp`." + ] + } + ], + "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 +}