{
 "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": [
       "#<PACKAGE \"CAT\">"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(ql:quickload \"kenzo\")\n",
    "(in-package :cat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classifying Spaces\n",
    "\n",
    "## Introduction\n",
    "\n",
    "Let ${\\cal G}$ be a simplicial group $0$-reduced. The program `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",
    "`<<GBar <` $[\\eta_{n-1}, g_{n-1}]$ `><` $[\\eta_{n-2}, g_{n-2}]$ `> ...  <` $[\\eta_1, g_1]$ `> < -` $g_0$`> >>`\n",
    "\n",
    "where a term such as $[\\eta_i, 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_i, 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_1, g_1]$ can be the pair $((0),g_0)$, internally implemented as an `absm` object, i.e. the 0-degeneracy of the base point and $[\\eta_2, g_2]$ can be $((1 0), g_0)$, that is, the only possible 2-degeneracy of the base point $g_0$ of $mathcal{G}$. In particular, the dimension of the \"geometric\" simplex $g_i$ is $i - \\ell$ with $\\ell$ the length of the integer sequence $\\eta_i$. 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",
    "<<GBar<- 3><- 2><- 1><- 0>>>\n",
    "<<GBar<- 3><1-0 0><0 0><- 0>>>\n",
    "<<GBar<1 2><- 2><0 0><- 0>>>\n",
    "<<GBar<1 2><0 1><0 0><- 0>>>\n",
    "<<GBar<2 2><1 1><0 0><- 0>>>\n",
    "<<GBar<2-0 1><1 1><0 0><- 0>>>\n",
    "<<GBar<2-1 1><1 1><- 1><- 0>>>\n",
    "<<GBar<2-1 1><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, 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, \\delta_j g_{j+1}, g_{j-1}.\\delta_j g_j, g_{j-1}, \\ldots, g_1, g_0),$ where in the term $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, \\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",
    "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 `<<GBAR>>`. 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": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<<GBar<0 A><1 B>>>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(gbar 2 1 'a 2 'b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<<GBar<- 3><1-0 0><0 0><- 0>>>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(gbar 4 0 3 3 0 1 0 0 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<<GBar<- <<Loop[1-0 M2][2 N3]>>><- <<Loop[N3]>>><- <<Loop[M2]>>><- <<Loop>>>>>"
      ]
     },
     "execution_count": 4,
     "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": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[K6 Simplicial-Group]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def om (loop-space (moore 2 2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#<CLOSURE (FLET RSLT :IN CLASSIFYING-SPACE-FACE) {1001CE47FB}>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def face (classifying-space-face (face om) (sintr (grml om))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "<AbSm - <<GBar<- <<Loop[0 M2][1 M2]>>><- <<Loop[M2]>>><- <<Loop>>>>>> \n",
      "<AbSm 0 <<GBar<- <<Loop[M2]>>><- <<Loop>>>>>> \n",
      "<AbSm - <<GBar<- <<Loop[0 M2][N3]>>><- <<Loop[M2\\2]>>><- <<Loop>>>>>> \n",
      "<AbSm - <<GBar<- <<Loop[N3\\2]>>><- <<Loop[M2]>>><- <<Loop>>>>>> \n",
      "<AbSm - <<GBar<- <<Loop[N3]>>><- <<Loop[M2]>>><- <<Loop>>>>>> "
     ]
    },
    {
     "data": {
      "text/plain": [
       "NIL"
      ]
     },
     "execution_count": 7,
     "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": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[K30 Abelian-Simplicial-Group]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def cs-kz21 (classifying-space (k-z2-1))) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(CLASSIFYING-SPACE [K18 Abelian-Simplicial-Group])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(orgn cs-kz21)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<<GBar<- 3><- 2><- 1><- 0>>>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def elem-1 (first (basis cs-kz21 4)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       "----------------------------------------------------------------------{CMBN 3}\n",
       "<2 * <<GBar<- 2><- 1><- 0>>>>\n",
       "------------------------------------------------------------------------------\n"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(? cs-kz21 4 elem-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       "----------------------------------------------------------------------{CMBN 2}\n",
       "------------------------------------------------------------------------------\n"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(? cs-kz21 *)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       "----------------------------------------------------------------------{CMBN 4}\n",
       "<1 * <TnPr <<GBar>> <<GBar<- 3><- 2><- 1><- 0>>>>>\n",
       "<1 * <TnPr <<GBar<- 1><- 0>>> <<GBar<- 1><- 0>>>>>\n",
       "<1 * <TnPr <<GBar<- 3><- 2><- 1><- 0>>> <<GBar>>>>\n",
       "------------------------------------------------------------------------------\n"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(cprd cs-kz21  4 elem-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "<AbSm - <<GBar<- 2><- 1><- 0>>>> \n",
      "<AbSm 0 <<GBar<- 1><- 0>>>> \n",
      "<AbSm 1 <<GBar<- 1><- 0>>>> \n",
      "<AbSm 2 <<GBar<- 1><- 0>>>> \n",
      "<AbSm - <<GBar<- 2><- 1><- 0>>>> "
     ]
    },
    {
     "data": {
      "text/plain": [
       "NIL"
      ]
     },
     "execution_count": 14,
     "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": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[K54 Abelian-Simplicial-Group]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def cs-kz1 (classifying-space (k-z-1)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AbSm 2-1-0 <<GBar>>>"
      ]
     },
     "execution_count": 16,
     "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": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AbSm - <<GBar<- (1 2)><0 NIL><- 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",
    "                     4 (gbar 2 0 '(-3) 0 '()))) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AbSm - <<GBar<- (1 -1)><- (3)><- NIL>>>>"
      ]
     },
     "execution_count": 18,
     "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": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AbSm - <<GBar<- (-1 -2)><0 NIL><- NIL>>>>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(grin cs-kz1 3 (gbar 3 0 '(1 2) 1 '() 0 '()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AbSm - <<GBar<- (1 2)><0 NIL><- NIL>>>>"
      ]
     },
     "execution_count": 20,
     "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": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "---done---"
     ]
    },
    {
     "data": {
      "text/plain": [
       "NIL"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(cat-init)    ;; re-initialization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[K25 Abelian-Simplicial-Group]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def k-z-3 (k-z 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "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 -> 2017-10-08, 12h 28m 49s.\n",
      "Computing the boundary of the generator 1/1 (dimension 0) :\n",
      "<<Abar>> \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 -> 2017-10-08, 12h 28m 49s.\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 -> 2017-10-08, 12h 28m 49s.\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 -> 2017-10-08, 12h 28m 49s.\n",
      "Computing the boundary of the generator 1/1 (dimension 3) :\n",
      "<<Abar[3 <<Abar[2 S1]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "Homology in dimension 2 :\n",
      "\n",
      "\n",
      "\n",
      "---done---\n",
      "\n",
      ";; Clock -> 2017-10-08, 12h 28m 49s.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 3.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2017-10-08, 12h 28m 49s.\n",
      "Computing the boundary of the generator 1/1 (dimension 3) :\n",
      "<<Abar[3 <<Abar[2 S1]>>]>> \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 -> 2017-10-08, 12h 28m 49s.\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 -> 2017-10-08, 12h 28m 49s.\n",
      "Computing the boundary of the generator 1/1 (dimension 5) :\n",
      "<<Abar[5 <<Abar[2 S1][2 S1]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "Homology in dimension 4 :\n",
      "\n",
      "\n",
      "\n",
      "---done---\n",
      "\n",
      ";; Clock -> 2017-10-08, 12h 28m 49s.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 5.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2017-10-08, 12h 28m 49s.\n",
      "Computing the boundary of the generator 1/1 (dimension 5) :\n",
      "<<Abar[5 <<Abar[2 S1][2 S1]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 6.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2017-10-08, 12h 28m 49s.\n",
      "Computing the boundary of the generator 1/1 (dimension 6) :\n",
      "<<Abar[3 <<Abar[2 S1]>>][3 <<Abar[2 S1]>>]>> \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 -> 2017-10-08, 12h 28m 49s.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 6.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2017-10-08, 12h 28m 49s.\n",
      "Computing the boundary of the generator 1/1 (dimension 6) :\n",
      "<<Abar[3 <<Abar[2 S1]>>][3 <<Abar[2 S1]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 7.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2017-10-08, 12h 28m 49s.\n",
      "Computing the boundary of the generator 1/1 (dimension 7) :\n",
      "<<Abar[7 <<Abar[2 S1][2 S1][2 S1]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "Homology in dimension 6 :\n",
      "\n",
      "\n",
      "\n",
      "---done---\n",
      "\n",
      ";; Clock -> 2017-10-08, 12h 28m 49s.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 7.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2017-10-08, 12h 28m 49s.\n",
      "Computing the boundary of the generator 1/1 (dimension 7) :\n",
      "<<Abar[7 <<Abar[2 S1][2 S1][2 S1]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 8.\n",
      "Rank of the source-module : 2.\n",
      "\n",
      "\n",
      ";; Clock -> 2017-10-08, 12h 28m 49s.\n",
      "Computing the boundary of the generator 1/2 (dimension 8) :\n",
      "<<Abar[3 <<Abar[2 S1]>>][5 <<Abar[2 S1][2 S1]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2017-10-08, 12h 28m 49s.\n",
      "Computing the boundary of the generator 2/2 (dimension 8) :\n",
      "<<Abar[5 <<Abar[2 S1][2 S1]>>][3 <<Abar[2 S1]>>]>> \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 -> 2017-10-08, 12h 28m 49s.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 8.\n",
      "Rank of the source-module : 2.\n",
      "\n",
      "\n",
      ";; Clock -> 2017-10-08, 12h 28m 49s.\n",
      "Computing the boundary of the generator 1/2 (dimension 8) :\n",
      "<<Abar[3 <<Abar[2 S1]>>][5 <<Abar[2 S1][2 S1]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2017-10-08, 12h 28m 49s.\n",
      "Computing the boundary of the generator 2/2 (dimension 8) :\n",
      "<<Abar[5 <<Abar[2 S1][2 S1]>>][3 <<Abar[2 S1]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 9.\n",
      "Rank of the source-module : 2.\n",
      "\n",
      "\n",
      ";; Clock -> 2017-10-08, 12h 28m 49s.\n",
      "Computing the boundary of the generator 1/2 (dimension 9) :\n",
      "<<Abar[9 <<Abar[2 S1][2 S1][2 S1][2 S1]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2017-10-08, 12h 28m 49s.\n",
      "Computing the boundary of the generator 2/2 (dimension 9) :\n",
      "<<Abar[3 <<Abar[2 S1]>>][3 <<Abar[2 S1]>>][3 <<Abar[2 S1]>>]>> \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 -> 2017-10-08, 12h 28m 49s.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 9.\n",
      "Rank of the source-module : 2.\n",
      "\n",
      "\n",
      ";; Clock -> 2017-10-08, 12h 28m 49s.\n",
      "Computing the boundary of the generator 1/2 (dimension 9) :\n",
      "<<Abar[9 <<Abar[2 S1][2 S1][2 S1][2 S1]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2017-10-08, 12h 28m 49s.\n",
      "Computing the boundary of the generator 2/2 (dimension 9) :\n",
      "<<Abar[3 <<Abar[2 S1]>>][3 <<Abar[2 S1]>>][3 <<Abar[2 S1]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 10.\n",
      "Rank of the source-module : 3.\n",
      "\n",
      "\n",
      ";; Clock -> 2017-10-08, 12h 28m 49s.\n",
      "Computing the boundary of the generator 1/3 (dimension 10) :\n",
      "<<Abar[3 <<Abar[2 S1]>>][7 <<Abar[2 S1][2 S1][2 S1]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2017-10-08, 12h 28m 49s.\n",
      "Computing the boundary of the generator 2/3 (dimension 10) :\n",
      "<<Abar[5 <<Abar[2 S1][2 S1]>>][5 <<Abar[2 S1][2 S1]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2017-10-08, 12h 28m 49s.\n",
      "Computing the boundary of the generator 3/3 (dimension 10) :\n",
      "<<Abar[7 <<Abar[2 S1][2 S1][2 S1]>>][3 <<Abar[2 S1]>>]>> \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 -> 2017-10-08, 12h 28m 49s.\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "NIL"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(homology k-z-3 0 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[K342 Abelian-Simplicial-Group]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def k-z2-5 (k-z2 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "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 -> 2017-10-08, 12h 28m 49s.\n",
      "Computing the boundary of the generator 1/1 (dimension 0) :\n",
      "<<Abar>> \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 -> 2017-10-08, 12h 28m 49s.\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 -> 2017-10-08, 12h 28m 49s.\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 -> 2017-10-08, 12h 28m 49s.\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 -> 2017-10-08, 12h 28m 49s.\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 -> 2017-10-08, 12h 28m 49s.\n",
      "Computing the boundary of the generator 1/1 (dimension 5) :\n",
      "<<Abar[5 <<Abar[4 <<Abar[3 <<Abar[2 1]>>]>>]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "Homology in dimension 4 :\n",
      "\n",
      "\n",
      "\n",
      "---done---\n",
      "\n",
      ";; Clock -> 2017-10-08, 12h 28m 49s.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 5.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2017-10-08, 12h 28m 49s.\n",
      "Computing the boundary of the generator 1/1 (dimension 5) :\n",
      "<<Abar[5 <<Abar[4 <<Abar[3 <<Abar[2 1]>>]>>]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 6.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2017-10-08, 12h 28m 49s.\n",
      "Computing the boundary of the generator 1/1 (dimension 6) :\n",
      "<<Abar[6 <<Abar[5 <<Abar[4 <<Abar[3 2]>>]>>]>>]>> \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 -> 2017-10-08, 12h 28m 49s.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 6.\n",
      "Rank of the source-module : 1.\n",
      "\n",
      "\n",
      ";; Clock -> 2017-10-08, 12h 28m 49s.\n",
      "Computing the boundary of the generator 1/1 (dimension 6) :\n",
      "<<Abar[6 <<Abar[5 <<Abar[4 <<Abar[3 2]>>]>>]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      "Computing boundary-matrix in dimension 7.\n",
      "Rank of the source-module : 2.\n",
      "\n",
      "\n",
      ";; Clock -> 2017-10-08, 12h 28m 49s.\n",
      "Computing the boundary of the generator 1/2 (dimension 7) :\n",
      "<<Abar[7 <<Abar[6 <<Abar[5 <<Abar[4 3]>>]>>]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      ";; Clock -> 2017-10-08, 12h 28m 49s.\n",
      "Computing the boundary of the generator 2/2 (dimension 7) :\n",
      "<<Abar[7 <<Abar[6 <<Abar[5 <<Abar[2 1][2 1]>>]>>]>>]>> \n",
      "End of computing.\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "Homology in dimension 6 :\n",
      "\n",
      "\n",
      "\n",
      "---done---\n",
      "\n",
      ";; Clock -> 2017-10-08, 12h 28m 49s.\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "NIL"
      ]
     },
     "execution_count": 25,
     "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": 1
}