{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "To load \"kenzo\":\n", " Load 1 ASDF system:\n", " kenzo\n", "; Loading \"kenzo\"\n", "\n" ] }, { "data": { "text/plain": [ "#" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(ql:quickload \"kenzo\")\n", "(in-package :cat)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# The Homology Module\n", "\n", "This chapter is devoted to the description of the functions for computing the homology groups of a chain complex.\n", "\n", "## List of functions\n", "\n", "`chcm-homology` *chcm dim* *[Function]*\n", "> Return a description of the $\\mathbb{Z}$-homology group in dimension *dim* of the chain complex *chcm* in terms of *components* of the form $\\mathbb{Z}$ or $\\mathbb{Z}/{n\\, \\mathbb{Z}}$. The desired homology group is the direct sum of these components. No canonical presentation is looked for, so that, if for instance, a homology group is $\\mathbb{Z}/{6\\, \\mathbb{Z}}$, it can be displayed as one component $\\mathbb{Z}/{6\\, \\mathbb{Z}}$ or two components $\\mathbb{Z}/{2\\, \\mathbb{Z}}$ and $\\mathbb{Z}/{3\\, \\mathbb{Z}}$. On the other hand, if the component part is void, this means the homology group is the null group. The function `chcm-homology` implements the usual algorithms to compute the homology group associated to two integer matrices, the composite of which is null. The current version is verbose: for each group asked for, the program displays the rank of each integer matrix and each generator of the source module. Timing indications are also given. In the examples, only the components are printed.\n", "\n", "`chcm-homology-gen` *chcm n* *[Function]*\n", "> This function computes the homology group in dimension $n$ of the chain complex *chcm* and prints a generator of degree $n$ in *chcm* for each component of the group, that is, a combination of the basis elements of degree $n$ of the chain complex, some cycle representing the corresponding homology class.\n", "\n", "`chcm-mat` *chcm n* *[Function]*\n", "> Return the matrix of the linear homomorphism $d_n: C_n \\rightarrow C_{n-1}$, where $C_n$ is the $n$-th chain group of the chain complex *chcm*. More precisely, each column of this matrix contains the integer coefficients in the basis of $C_{n-1}$ of the image by $d_n$ of each basis element of $C_n$. So the number of rows (resp. columns) of the matrix is the number of elements of the basis of $C_{n-1}$ (resp. $C_n$). The homology group ${\\cal H}_n={\\cal Z}_n/{\\cal B}_n$ is computed from the two matrices `MZ` $=$ `chcm-mat` *(chcm,n)* and `NB` $=$ `chcm-mat` *(chcm, n+1)*. By well known algorithms on matrix reduction (**S. MacLane & G. Birkhoff**, *Algebra*, The MacMillan Company, 1967), the matrix `MZ` is used to find a basis for the kernel ${\\cal Z}_n$ and the matrix `NB`, to find in ${\\cal Z}_n$ a presentation of the group ${\\cal H}_n={\\cal Z}_n/{\\cal B}_n$ by generators and relations. This is performed by the internal function `homologie` (beware: not `homology`!).\n", "\n", "`homology` *chcm degr1* `&optional (`*degr2* `(1+` *degr1*`))` *[Method]*\n", "> Compute the homology groups from $degr_1$ to $degr_2-1$ (default: only $degr_1$, if *degr2* is omitted) of the right chain complex of the homotopy equivalence contained in the slot `:efhm` of the\n", "chain complex instance *chcm*. At the creation of the chain complex, this slot is unbound and is set during execution by an adequate CLOS method. If this slot cannot be bound, an error is returned and the homology groups cannot be computed. A more elaborated explanation of the mechanism used by the function `homology` is given in the section: **The general method for computing homology groups.**\n", "\n", "\n", "## Example\n", "\n", "Let us get the homology groups for the example `diabolo` of the chapter 1." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[K1 Chain-Complex]" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(def diabolo (build-chcm\n", " :cmpr #'s-cmpr\n", " :basis #'(lambda (dmn)\n", " (case dmn\n", " (0 '(s0 s1 s2 s3 s4 s5))\n", " (1 '(s01 s02 s12 s23 s34 s35 s45))\n", " (2 '(s345))\n", " (otherwise nil)))\n", " :bsgn 's0\n", " :intr-dffr #'(lambda (dmn gnr)\n", " (unless (<= 0 dmn 2)\n", " (error \"Incorrect dimension for diabolo-dp.\"))\n", " (case dmn\n", " (0 (cmbn -1)) ; Note the null combination of degree -1\n", " (1 (case gnr\n", " (s01 (cmbn 0 -1 's0 1 's1))\n", " (s02 (cmbn 0 -1 's0 1 's2))\n", " (s12 (cmbn 0 -1 's1 1 's2))\n", " (s23 (cmbn 0 -1 's2 1 's3))\n", " (s34 (cmbn 0 -1 's3 1 's4))\n", " (s35 (cmbn 0 -1 's3 1 's5))\n", " (s45 (cmbn 0 -1 's4 1 's5))))\n", " (2 (case gnr\n", " (s345 (cmbn 1 1 's34 -1 's35 1 's45))))\n", " (otherwise (error \"Bad generator for complex diabolo\"))))\n", " :strt :GNRT\n", " :orgn '(diabolo-for-example)))" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Computing boundary-matrix in dimension 0.\n", "Rank of the source-module : 6.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 1/6 (dimension 0) :\n", "S0 \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 2/6 (dimension 0) :\n", "S1 \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 3/6 (dimension 0) :\n", "S2 \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 4/6 (dimension 0) :\n", "S3 \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 5/6 (dimension 0) :\n", "S4 \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 6/6 (dimension 0) :\n", "S5 \n", "End of computing.\n", "\n", "\n", "Computing boundary-matrix in dimension 1.\n", "Rank of the source-module : 7.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 1/7 (dimension 1) :\n", "S01 \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 2/7 (dimension 1) :\n", "S02 \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 3/7 (dimension 1) :\n", "S12 \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 4/7 (dimension 1) :\n", "S23 \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 5/7 (dimension 1) :\n", "S34 \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 6/7 (dimension 1) :\n", "S35 \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 7/7 (dimension 1) :\n", "S45 \n", "End of computing.\n", "\n", "\n", "\n", "\n", "Homology in dimension 0 :\n", "\n", "\n", "Component Z\n", "\n", "\n", "---done---" ] }, { "data": { "text/plain": [ "NIL" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(chcm-homology diabolo 0)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Computing boundary-matrix in dimension 1.\n", "Rank of the source-module : 7.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 1/7 (dimension 1) :\n", "S01 \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 2/7 (dimension 1) :\n", "S02 \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 3/7 (dimension 1) :\n", "S12 \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 4/7 (dimension 1) :\n", "S23 \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 5/7 (dimension 1) :\n", "S34 \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 6/7 (dimension 1) :\n", "S35 \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 7/7 (dimension 1) :\n", "S45 \n", "End of computing.\n", "\n", "\n", "Computing boundary-matrix in dimension 2.\n", "Rank of the source-module : 1.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 1/1 (dimension 2) :\n", "S345 \n", "End of computing.\n", "\n", "\n", "\n", "\n", "Homology in dimension 1 :\n", "\n", "\n", "Component Z\n", "\n", "\n", "---done---" ] }, { "data": { "text/plain": [ "NIL" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(chcm-homology diabolo 1)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "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 -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 1/1 (dimension 2) :\n", "S345 \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---" ] }, { "data": { "text/plain": [ "NIL" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(chcm-homology diabolo 2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Another simple example is the following 2-chain complex corresponding to the well known *dunce hat*. We shall see later in the chapter `Simplicial Sets` a much more elegant method to describe this object." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "#" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(cl-jupyter-user:png-from-file \"dunce.png\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The diagram shows a permissible triangulation. For the generators, we have chosen lists rather symbols: a vertex $s_i$ is represented as `(i)`, an edge $s_is_j$ as `(i j)` and a triangle $s_is_js_k$ as `(i j k)`. The enumeration of the elements of the basis is a little cumbersome but defining the boundary homomorphism is very easy, bearing in mind the boundary rule:\n", "\n", "$$\n", "\\mathbf{d}[s_0s_1\\ldots s_n] = \\sum_{i=0}^n{(-1)^is_0s_1\\ldots\\widehat{s_i}\\ldots s_n}.\n", "$$\n", "\n", "As for diabolo, the vertices are implicitly ordered." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "#" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(def duncehat-basis #'(lambda (dmn)\n", " (case dmn\n", " (0 '((0) (1) (2) (3) (4) (5) (6) (7)))\n", " (1 '((0 1) (0 2) (0 3)\n", " (0 4) (0 5) (0 6)\n", " (0 7) (1 2) (1 3)\n", " (1 4) (1 5) (1 6)\n", " (1 7) (2 3) (2 4)\n", " (2 6) (2 7) (3 4)\n", " (3 5) (4 5) (4 6)\n", " (5 6) (5 7) (6 7)))\n", " (2 '((0 1 5) (0 1 6) (0 1 7)\n", " (0 2 3) (0 2 4) (0 2 6)\n", " (0 3 4) (0 5 7) (1 2 3)\n", " (1 2 4) (1 2 7) (1 3 5)\n", " (1 4 6) (2 6 7) (3 4 5)\n", " (4 5 6) (5 6 7)))\n", " (otherwise nil))))" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "#" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(def duncehat-df #'(lambda (dmn gnr)\n", " (case dmn\n", " (0 (cmbn -1))\n", " (1 (cmbn 0 -1 (list (first gnr)) 1 (rest gnr)))\n", " (2 (cmbn 1 1 (list (first gnr) (second gnr))\n", " -1 (list (first gnr) (third gnr))\n", " 1 (rest gnr)))\n", " (otherwise nil))))" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[K3 Chain-Complex]" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(def duncehat (build-chcm :cmpr #'l-cmpr\n", " :basis duncehat-basis\n", " :bsgn '(0)\n", " :intr-dffr duncehat-df\n", " :strt :gnrt\n", " :orgn '(dunce hat)))" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Computing boundary-matrix in dimension 0.\n", "Rank of the source-module : 8.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 1/8 (dimension 0) :\n", "(0) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 2/8 (dimension 0) :\n", "(1) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 3/8 (dimension 0) :\n", "(2) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 4/8 (dimension 0) :\n", "(3) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 5/8 (dimension 0) :\n", "(4) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 6/8 (dimension 0) :\n", "(5) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 7/8 (dimension 0) :\n", "(6) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 8/8 (dimension 0) :\n", "(7) \n", "End of computing.\n", "\n", "\n", "Computing boundary-matrix in dimension 1.\n", "Rank of the source-module : 24.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 1/24 (dimension 1) :\n", "(0 1) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 2/24 (dimension 1) :\n", "(0 2) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 3/24 (dimension 1) :\n", "(0 3) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 4/24 (dimension 1) :\n", "(0 4) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 5/24 (dimension 1) :\n", "(0 5) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 6/24 (dimension 1) :\n", "(0 6) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 7/24 (dimension 1) :\n", "(0 7) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 8/24 (dimension 1) :\n", "(1 2) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 9/24 (dimension 1) :\n", "(1 3) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 10/24 (dimension 1) :\n", "(1 4) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 11/24 (dimension 1) :\n", "(1 5) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 12/24 (dimension 1) :\n", "(1 6) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 13/24 (dimension 1) :\n", "(1 7) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 14/24 (dimension 1) :\n", "(2 3) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 15/24 (dimension 1) :\n", "(2 4) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 16/24 (dimension 1) :\n", "(2 6) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 17/24 (dimension 1) :\n", "(2 7) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 18/24 (dimension 1) :\n", "(3 4) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 19/24 (dimension 1) :\n", "(3 5) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 20/24 (dimension 1) :\n", "(4 5) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 21/24 (dimension 1) :\n", "(4 6) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 22/24 (dimension 1) :\n", "(5 6) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 23/24 (dimension 1) :\n", "(5 7) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 24/24 (dimension 1) :\n", "(6 7) \n", "End of computing.\n", "\n", "\n", "\n", "\n", "Homology in dimension 0 :\n", "\n", "\n", "Component Z\n", "\n", "\n", "---done---" ] }, { "data": { "text/plain": [ "NIL" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(chcm-homology duncehat 0)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Computing boundary-matrix in dimension 1.\n", "Rank of the source-module : 24.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 1/24 (dimension 1) :\n", "(0 1) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 2/24 (dimension 1) :\n", "(0 2) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 3/24 (dimension 1) :\n", "(0 3) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 4/24 (dimension 1) :\n", "(0 4) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 5/24 (dimension 1) :\n", "(0 5) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 6/24 (dimension 1) :\n", "(0 6) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 7/24 (dimension 1) :\n", "(0 7) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 8/24 (dimension 1) :\n", "(1 2) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 9/24 (dimension 1) :\n", "(1 3) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 10/24 (dimension 1) :\n", "(1 4) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 11/24 (dimension 1) :\n", "(1 5) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 12/24 (dimension 1) :\n", "(1 6) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 13/24 (dimension 1) :\n", "(1 7) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 14/24 (dimension 1) :\n", "(2 3) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 15/24 (dimension 1) :\n", "(2 4) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 16/24 (dimension 1) :\n", "(2 6) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 17/24 (dimension 1) :\n", "(2 7) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 18/24 (dimension 1) :\n", "(3 4) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 19/24 (dimension 1) :\n", "(3 5) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 20/24 (dimension 1) :\n", "(4 5) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 21/24 (dimension 1) :\n", "(4 6) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 22/24 (dimension 1) :\n", "(5 6) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 23/24 (dimension 1) :\n", "(5 7) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 24/24 (dimension 1) :\n", "(6 7) \n", "End of computing.\n", "\n", "\n", "Computing boundary-matrix in dimension 2.\n", "Rank of the source-module : 17.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 1/17 (dimension 2) :\n", "(0 1 5) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 2/17 (dimension 2) :\n", "(0 1 6) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 3/17 (dimension 2) :\n", "(0 1 7) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 4/17 (dimension 2) :\n", "(0 2 3) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 5/17 (dimension 2) :\n", "(0 2 4) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 6/17 (dimension 2) :\n", "(0 2 6) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 7/17 (dimension 2) :\n", "(0 3 4) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 8/17 (dimension 2) :\n", "(0 5 7) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 9/17 (dimension 2) :\n", "(1 2 3) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 10/17 (dimension 2) :\n", "(1 2 4) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 11/17 (dimension 2) :\n", "(1 2 7) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 12/17 (dimension 2) :\n", "(1 3 5) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 13/17 (dimension 2) :\n", "(1 4 6) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 14/17 (dimension 2) :\n", "(2 6 7) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 15/17 (dimension 2) :\n", "(3 4 5) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 16/17 (dimension 2) :\n", "(4 5 6) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 17/17 (dimension 2) :\n", "(5 6 7) \n", "End of computing.\n", "\n", "\n", "\n", "\n", "Homology in dimension 1 :\n", "\n", "\n", "\n", "---done---" ] }, { "data": { "text/plain": [ "NIL" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(chcm-homology duncehat 1)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Computing boundary-matrix in dimension 2.\n", "Rank of the source-module : 17.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 1/17 (dimension 2) :\n", "(0 1 5) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 2/17 (dimension 2) :\n", "(0 1 6) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 3/17 (dimension 2) :\n", "(0 1 7) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 4/17 (dimension 2) :\n", "(0 2 3) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 5/17 (dimension 2) :\n", "(0 2 4) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 6/17 (dimension 2) :\n", "(0 2 6) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 7/17 (dimension 2) :\n", "(0 3 4) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 8/17 (dimension 2) :\n", "(0 5 7) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 9/17 (dimension 2) :\n", "(1 2 3) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 10/17 (dimension 2) :\n", "(1 2 4) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 11/17 (dimension 2) :\n", "(1 2 7) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 12/17 (dimension 2) :\n", "(1 3 5) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 13/17 (dimension 2) :\n", "(1 4 6) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 14/17 (dimension 2) :\n", "(2 6 7) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 15/17 (dimension 2) :\n", "(3 4 5) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 16/17 (dimension 2) :\n", "(4 5 6) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 17/17 (dimension 2) :\n", "(5 6 7) \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---" ] }, { "data": { "text/plain": [ "NIL" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(chcm-homology duncehat 2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We remark the homology of this \"dunce hat\" is the homology of one point. Good exercise: compute the $\\pi_1$. A maximal \"tree\" is the path $01234567$, and the standard reduction process, for example $35~345$, etc., shows the $\\pi_1$ is generated by the loop $0120$. The same sort of argument shows this loop is homotopic to its double, and therefore null-homotopic, so that finally $\\pi_1 = 0$. A famous theorem of Whitehead then asserts our \"dunce hat\" is contractible, which is not really intuitive. The same result via the minimal triangulation of the dunce hat as a simplicial set is much easier.\n", "\n", "Let us take again the chain complex `duncehat`. The two matrices of the homomorphisms $d_1: C_1 \\rightarrow C_0$ and $d_2: C_2 \\rightarrow C_1$ are obtained by calling `chcm-mat`." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Computing boundary-matrix in dimension 1.\n", "Rank of the source-module : 24.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 1/24 (dimension 1) :\n", "(0 1) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 2/24 (dimension 1) :\n", "(0 2) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 3/24 (dimension 1) :\n", "(0 3) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 4/24 (dimension 1) :\n", "(0 4) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 5/24 (dimension 1) :\n", "(0 5) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 6/24 (dimension 1) :\n", "(0 6) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 7/24 (dimension 1) :\n", "(0 7) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 8/24 (dimension 1) :\n", "(1 2) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 9/24 (dimension 1) :\n", "(1 3) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 10/24 (dimension 1) :\n", "(1 4) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 11/24 (dimension 1) :\n", "(1 5) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 12/24 (dimension 1) :\n", "(1 6) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 13/24 (dimension 1) :\n", "(1 7) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 14/24 (dimension 1) :\n", "(2 3) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 15/24 (dimension 1) :\n", "(2 4) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 16/24 (dimension 1) :\n", "(2 6) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 17/24 (dimension 1) :\n", "(2 7) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 18/24 (dimension 1) :\n", "(3 4) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 19/24 (dimension 1) :\n", "(3 5) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 20/24 (dimension 1) :\n", "(4 5) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 21/24 (dimension 1) :\n", "(4 6) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 22/24 (dimension 1) :\n", "(5 6) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 23/24 (dimension 1) :\n", "(5 7) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 24/24 (dimension 1) :\n", "(6 7) \n", "End of computing.\n", "\n" ] }, { "data": { "text/plain": [ "\n", "========== MATRIX 8 lines + 24 columns =====\n", "L1=[C1=-1][C2=-1][C3=-1][C4=-1][C5=-1][C6=-1][C7=-1]\n", "L2=[C1=1][C8=-1][C9=-1][C10=-1][C11=-1][C12=-1][C13=-1]\n", "L3=[C2=1][C8=1][C14=-1][C15=-1][C16=-1][C17=-1]\n", "L4=[C3=1][C9=1][C14=1][C18=-1][C19=-1]\n", "L5=[C4=1][C10=1][C15=1][C18=1][C20=-1][C21=-1]\n", "L6=[C5=1][C11=1][C19=1][C20=1][C22=-1][C23=-1]\n", "L7=[C6=1][C12=1][C16=1][C21=1][C22=1][C24=-1]\n", "L8=[C7=1][C13=1][C17=1][C23=1][C24=1]\n", "========== END-MATRIX" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(def mz (chcm-mat duncehat 1))" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Computing boundary-matrix in dimension 2.\n", "Rank of the source-module : 17.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 1/17 (dimension 2) :\n", "(0 1 5) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 2/17 (dimension 2) :\n", "(0 1 6) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 3/17 (dimension 2) :\n", "(0 1 7) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 4/17 (dimension 2) :\n", "(0 2 3) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 5/17 (dimension 2) :\n", "(0 2 4) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 6/17 (dimension 2) :\n", "(0 2 6) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 7/17 (dimension 2) :\n", "(0 3 4) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 8/17 (dimension 2) :\n", "(0 5 7) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 9/17 (dimension 2) :\n", "(1 2 3) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 10/17 (dimension 2) :\n", "(1 2 4) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 11/17 (dimension 2) :\n", "(1 2 7) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 12/17 (dimension 2) :\n", "(1 3 5) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 13/17 (dimension 2) :\n", "(1 4 6) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 14/17 (dimension 2) :\n", "(2 6 7) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 15/17 (dimension 2) :\n", "(3 4 5) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 16/17 (dimension 2) :\n", "(4 5 6) \n", "End of computing.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 17/17 (dimension 2) :\n", "(5 6 7) \n", "End of computing.\n", "\n" ] }, { "data": { "text/plain": [ "\n", "========== MATRIX 24 lines + 17 columns =====\n", "L1=[C1=1][C2=1][C3=1]\n", "L2=[C4=1][C5=1][C6=1]\n", "L3=[C4=-1][C7=1]\n", "L4=[C5=-1][C7=-1]\n", "L5=[C1=-1][C8=1]\n", "L6=[C2=-1][C6=-1]\n", "L7=[C3=-1][C8=-1]\n", "L8=[C9=1][C10=1][C11=1]\n", "L9=[C9=-1][C12=1]\n", "L10=[C10=-1][C13=1]\n", "L11=[C1=1][C12=-1]\n", "L12=[C2=1][C13=-1]\n", "L13=[C3=1][C11=-1]\n", "L14=[C4=1][C9=1]\n", "L15=[C5=1][C10=1]\n", "L16=[C6=1][C14=1]\n", "L17=[C11=1][C14=-1]\n", "L18=[C7=1][C15=1]\n", "L19=[C12=1][C15=-1]\n", "L20=[C15=1][C16=1]\n", "L21=[C13=1][C16=-1]\n", "L22=[C16=1][C17=1]\n", "L23=[C8=1][C17=-1]\n", "L24=[C14=1][C17=1]\n", "========== END-MATRIX" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(def nb (chcm-mat duncehat 2))" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "NIL" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(homologie mz nb)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## The general method for computing homology\n", "\n", "Among the slots of the instance of an object inheriting the `CHAIN COMPLEX` class, a slot `efhm`\n", "has been reserved to point (possibly) to a homotopy equivalence where the right bottom chain complex is effective. The function `homology` is designed to get the right bottom chain complex of the homotopy equivalence value of the slot. If the slot has been bound, then the homology groups are computed by the function `chcm-homology` as shown in the following definition:\n", "\n", "```commonlisp\n", "(DEFMETHOD HOMOLOGY ((chcm chain-complex) degr1 &optional (degr2 (1+ degr1)))\n", " (do ((degr degr1 (1+ degr)))\n", " ((>= degr degr2))\n", " --> (chcm-homology (rbcc (efhm chcm)) degr)\n", " (terpri) (clock) (terpri)))\n", "```\n", "\n", "But, at the creation of the object, the slot `efhm` is unbound and as soon as the `homology`\n", "function tries to get the content of the slot `efhm` via the call `(efchm chcm)`, the *slot-unbound* mechanism of CLOS is triggered, calling at its turn a method `search-efhm` depending on the object. If no method is available for this object, `NIL` is returned. In the following chapters, we shall see that cases have been written for cartesian products, tensor products, suspensions, disk pasting, fibrations, loop spaces, and classifying spaces. The selection of the case is done thanks to the information contained in the comment list of the object (slot `orgn`). In each case, the `search-efhm` method builds - in general with a complex machinery, including a possible recursivity - a homotopy equivalence where the right bottom chain complex is *effective*. The slot `efhm` of the object is then settled and the homology group computation may begin. If `NIL` is returned, then and only at this moment, the slot-unbound mechanism looks if the chain complex is finite (checking if a basis function exists). If this is the case, then the *trivial homotopy equivalence* is built upon the chain complex and this gives the value of the slot `efhm`. If there is no basis function, meaning that probably the chain complex is locally effective, an error is returned.\n", "\n", "*Remark.* The user may wonder why one does not look first if the given object is effective. We recall simply that even in the case of an effective chain complex, it is sometimes possible to find another effective chain complex, homotopic to the first and whose number of basis elements, in any dimensions, is considerably smaller in comparison with the first one. A striking case will be shown in a further chapter, showing the application of the Eilenberg-Zilber theorem to a cartesian product.\n", "\n", "\n", "### Example\n", "\n", "*The reading of this subsection may be postponed until a full reading of this user's guide.* The following examples show how are filled the slots `efhm` of the various objects. Starting from the sphere $S^2$, we verify first that the *efhm* slot is unbound. Then we ask for ${\\cal H}_1$ and verify that, though there is a finite basis, `Kenzo` has nevertheless built a trivial homotopy equivalence on this object." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "---done---" ] }, { "data": { "text/plain": [ "NIL" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(cat-init)" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[K1 Simplicial-Set]" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(def s2 (sphere 2))" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "The object is a STANDARD-OBJECT of type 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: (SPHERE 2)\n", "8. CPRD: [K5 Morphism (degree 0): K1 -> K3]\n", "9. FACE: #\n", "> " ] }, { "data": { "text/plain": [ "NIL" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(inspect s2)" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\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 : 1.\n", "\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "Computing the boundary of the generator 1/1 (dimension 2) :\n", "S2 \n", "End of computing.\n", "\n", "\n", "\n", "\n", "Homology in dimension 1 :\n", "\n", "\n", "\n", "---done---\n", "\n", ";; Clock -> 2017-10-08, 0h 52m 47s.\n", "\n" ] }, { "data": { "text/plain": [ "NIL" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(homology s2 1)" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "The object is a STANDARD-OBJECT of type 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: [K9 Homotopy-Equivalence K1 <= K1 => K1]\n", "6. IDNM: 1\n", "7. ORGN: (SPHERE 2)\n", "8. CPRD: [K5 Morphism (degree 0): K1 -> K3]\n", "9. FACE: #\n", "> " ] }, { "data": { "text/plain": [ "NIL" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(inspect s2)" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(TRIVIAL-HMEQ [K1 Simplicial-Set])" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(orgn (hmeq 9))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now, we create $\\Omega^1(S^2)$. Getting the value of the slot `efhm` by a call to the accessor function `efhm`, triggers the search-efhm method for a loop space. A homotopy equivalence is built and the slot is set." ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[K10 Simplicial-Group]" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(def os2 (loop-space s2))" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "The object is a STANDARD-OBJECT of type SIMPLICIAL-GROUP.\n", "0. CMPR: #\n", "1. BASIS: :LOCALLY-EFFECTIVE\n", "2. BSGN: <>\n", "3. DFFR: [K11 Morphism (degree -1): K10 -> K10]\n", "4. GRMD: [K10 Simplicial-Group]\n", "5. EFHM: \"unbound\"\n", "6. IDNM: 10\n", "7. ORGN: (LOOP-SPACE [K1 Simplicial-Set])\n", "8. APRD: \"unbound\"\n", "9. CPRD: [K14 Morphism (degree 0): K10 -> K12]\n", "10. FACE: #\n", "11. KFLL: \"unbound\"\n", "12. GRML: [K20 Simplicial-Morphism K15 -> K10]\n", "13. GRIN: [K21 Simplicial-Morphism K10 -> K10]\n", "> " ] }, { "data": { "text/plain": [ "NIL" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(inspect os2)" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(LOOP-SPACE [K1 Simplicial-Set])" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(orgn os2)" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[K118 Homotopy-Equivalence K10 <= K108 => K25]" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(efhm os2)" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "The object is a STANDARD-OBJECT of type SIMPLICIAL-GROUP.\n", "0. CMPR: #\n", "1. BASIS: :LOCALLY-EFFECTIVE\n", "2. BSGN: <>\n", "3. DFFR: [K11 Morphism (degree -1): K10 -> K10]\n", "4. GRMD: [K10 Simplicial-Group]\n", "5. EFHM: [K118 Homotopy-Equivalence K10 <= K108 => K25]\n", "6. IDNM: 10\n", "7. ORGN: (LOOP-SPACE [K1 Simplicial-Set])\n", "8. APRD: \"unbound\"\n", "9. CPRD: [K14 Morphism (degree 0): K10 -> K12]\n", "10. FACE: #\n", "11. KFLL: \"unbound\"\n", "12. GRML: [K20 Simplicial-Morphism K15 -> K10]\n", "13. GRIN: [K21 Simplicial-Morphism K10 -> K10]\n", "> " ] }, { "data": { "text/plain": [ "NIL" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(inspect os2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The following example shows the recursion mechanism when one wants to get the value of the slot `efhm` of an iterated loop space, namely $\\Omega^3(S^4)$." ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[K119 Simplicial-Set]" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(def s4 (sphere 4))" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "The object is a STANDARD-OBJECT of type SIMPLICIAL-SET.\n", "0. CMPR: #\n", "1. BASIS: #\n", "2. BSGN: *\n", "3. DFFR: [K120 Morphism (degree -1): K119 -> K119]\n", "4. GRMD: [K119 Simplicial-Set]\n", "5. EFHM: \"unbound\"\n", "6. IDNM: 119\n", "7. ORGN: (SPHERE 4)\n", "8. CPRD: [K123 Morphism (degree 0): K119 -> K121]\n", "9. FACE: #\n", "> " ] }, { "data": { "text/plain": [ "NIL" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(inspect s4)" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[K148 Simplicial-Group]" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(def ooos4 (loop-space (loop-space (loop-space s4))))" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(LOOP-SPACE [K136 Simplicial-Group])" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(orgn ooos4)" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(LOOP-SPACE [K124 Simplicial-Group])" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(orgn (second *))" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(LOOP-SPACE [K119 Simplicial-Set])" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(orgn (second *))" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(SPHERE 4)" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(orgn (second *))" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "The object is a STANDARD-OBJECT of type SIMPLICIAL-GROUP.\n", "0. CMPR: #\n", "1. BASIS: :LOCALLY-EFFECTIVE\n", "2. BSGN: <>\n", "3. DFFR: [K149 Morphism (degree -1): K148 -> K148]\n", "4. GRMD: [K148 Simplicial-Group]\n", "5. EFHM: \"unbound\"\n", "6. IDNM: 148\n", "7. ORGN: (LOOP-SPACE [K136 Simplicial-Group])\n", "8. APRD: \"unbound\"\n", "9. CPRD: [K152 Morphism (degree 0): K148 -> K150]\n", "10. FACE: #\n", "11. KFLL: \"unbound\"\n", "12. GRML: [K158 Simplicial-Morphism K153 -> K148]\n", "13. GRIN: [K159 Simplicial-Morphism K148 -> K148]\n", "> " ] }, { "data": { "text/plain": [ "NIL" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(inspect ooos4)" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "The object is a STANDARD-OBJECT of type SIMPLICIAL-GROUP.\n", "0. CMPR: #\n", "1. BASIS: :LOCALLY-EFFECTIVE\n", "2. BSGN: <>\n", "3. DFFR: [K125 Morphism (degree -1): K124 -> K124]\n", "4. GRMD: [K124 Simplicial-Group]\n", "5. EFHM: \"unbound\"\n", "6. IDNM: 124\n", "7. ORGN: (LOOP-SPACE [K119 Simplicial-Set])\n", "8. APRD: \"unbound\"\n", "9. CPRD: [K128 Morphism (degree 0): K124 -> K126]\n", "10. FACE: #\n", "11. KFLL: \"unbound\"\n", "12. GRML: [K134 Simplicial-Morphism K129 -> K124]\n", "13. GRIN: [K135 Simplicial-Morphism K124 -> K124]\n", "> " ] }, { "data": { "text/plain": [ "NIL" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(inspect (smgr 124))" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "The object is a STANDARD-OBJECT of type SIMPLICIAL-SET.\n", "0. CMPR: #\n", "1. BASIS: #\n", "2. BSGN: *\n", "3. DFFR: [K120 Morphism (degree -1): K119 -> K119]\n", "4. GRMD: [K119 Simplicial-Set]\n", "5. EFHM: \"unbound\"\n", "6. IDNM: 119\n", "7. ORGN: (SPHERE 4)\n", "8. CPRD: [K123 Morphism (degree 0): K119 -> K121]\n", "9. FACE: #\n", "> " ] }, { "data": { "text/plain": [ "NIL" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(inspect (smst 119))" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[K522 Homotopy-Equivalence K148 <= K512 => K508]" ] }, "execution_count": 37, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(efhm ooos4)" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "The object is a STANDARD-OBJECT of type SIMPLICIAL-GROUP.\n", "0. CMPR: #\n", "1. BASIS: :LOCALLY-EFFECTIVE\n", "2. BSGN: <>\n", "3. DFFR: [K125 Morphism (degree -1): K124 -> K124]\n", "4. GRMD: [K124 Simplicial-Group]\n", "5. EFHM: [K426 Homotopy-Equivalence K124 <= K416 => K329]\n", "6. IDNM: 124\n", "7. ORGN: (LOOP-SPACE [K119 Simplicial-Set])\n", "8. APRD: \"unbound\"\n", "9. CPRD: [K128 Morphism (degree 0): K124 -> K126]\n", "10. FACE: #\n", "11. KFLL: \"unbound\"\n", "12. GRML: [K134 Simplicial-Morphism K129 -> K124]\n", "13. GRIN: [K135 Simplicial-Morphism K124 -> K124]\n", "> " ] }, { "data": { "text/plain": [ "NIL" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(inspect (smgr 124))" ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "The object is a STANDARD-OBJECT of type SIMPLICIAL-SET.\n", "0. CMPR: #\n", "1. BASIS: #\n", "2. BSGN: *\n", "3. DFFR: [K120 Morphism (degree -1): K119 -> K119]\n", "4. GRMD: [K119 Simplicial-Set]\n", "5. EFHM: [K412 Homotopy-Equivalence K119 <= K119 => K119]\n", "6. IDNM: 119\n", "7. ORGN: (SPHERE 4)\n", "8. CPRD: [K123 Morphism (degree 0): K119 -> K121]\n", "9. FACE: #\n", "> " ] }, { "data": { "text/plain": [ "NIL" ] }, "execution_count": 39, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(inspect (smst 119))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Lisp files concerned in this chapter}\n", "\n", "`homology-groups.lisp`, `searching-homology` and files containing a `search-efhm` method." ] } ], "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": 1 }