From 0282f1871921b34d0fdadea9b46a385cd91fc83b Mon Sep 17 00:00:00 2001 From: gheber Date: Sun, 10 Apr 2016 16:31:34 -0500 Subject: [PATCH] Added Francis' changes. --- examples/07_Simplicial_Sets.ipynb | 332 +++++++++++++++--------------- 1 file changed, 168 insertions(+), 164 deletions(-) diff --git a/examples/07_Simplicial_Sets.ipynb b/examples/07_Simplicial_Sets.ipynb index 0a3cef5..b16f2d1 100644 --- a/examples/07_Simplicial_Sets.ipynb +++ b/examples/07_Simplicial_Sets.ipynb @@ -8,7 +8,7 @@ "\n", "## Introduction\n", "\n", - "A *simplicial set* (**Hilton & Wylie**, *Homology theory*, Cambridge University Press, 1967) $K$ is a union $K={\\displaystyle{\\bigcup_{q\\ge 0}{K^q}}}$, where the $K^q$ are disjoints sets, together with functions\n", + "A *simplicial set* (**J. Peter May**, Simplicial objects in Algebrac Topology, University of Chicago press, 2nd edition, 1992) $K$ is a union $K={\\displaystyle{\\bigcup_{q\\ge 0}{K^q}}}$, where the $K^q$ are disjoints sets, together with functions\n", "\n", "$$\\partial_i^q: K^q \\longrightarrow K^{q-1},\\quad q>0,\\quad i=0,\\ldots , q,$$\n", "\n", @@ -21,7 +21,7 @@ "\\partial_i^{q-1}\\partial_j^q & = & \\partial_{j-1}^{q-1}\\partial_i^q, & i < j \\cr\n", "\\eta_i^{q+1}\\eta_j^q & = & \\eta_j^{q+1}\\eta_{i-1}^q, & i > j \\cr\n", "\\partial_i^{q+1}\\eta_j^q & = & \\eta_{j-1}^{q-1}\\partial_i^q, & i < j \\cr\n", - "\\partial_i^{q+1}\\eta_i^q & = & \\partial_{i+1}^{q+1}\\eta_i^q & Identity, \\cr\n", + "\\partial_i^{q+1}\\eta_i^q & = & \\partial_{i+1}^{q+1}\\eta_i^q & = \\mbox{Identity}, \\cr\n", "\\partial_i^{q+1}\\eta_j^q & = & \\eta_j^{q-1}\\partial_{i-1}^q, & i > j+1.\\cr \n", "\\end{aligned}\n", "$$\n", @@ -73,7 +73,7 @@ "$$\\eta_0 (0\\ 1) = (0\\ 0\\ 1),\\ \n", " \\eta_1 (1\\ 2)= (1\\ 2\\ 2),\\ \\eta_2(3\\ 4\\ 5)=(3\\ 4\\ 5\\ 5). $$\n", "\n", - "By the way, we see that a simplex is non-degenerate if the list is strictly increasing.\n", + "By the way, we see that, in this case, a simplex is non-degenerate if the list is strictly increasing.\n", "\n", "## Notion of abstract simplex in this Lisp implementation\n", "\n", @@ -84,19 +84,20 @@ "For instance, if $\\sigma$ is a non-degenerate simplex, and $\\sigma'$ is the degenerate simplex $\\eta_3\\eta_1\\sigma$, the corresponding abstract simplices are respectively $\\lbrace \\emptyset, \\sigma \\rbrace$ and $\\lbrace \\eta_3\\eta_1, \\sigma \\rbrace$.\n", "\n", "An abstract simplex is represented internally in the system by the following lisp object:\n", - "$$\\texttt{(:absm}\\quad\\mathit{dgop}\\quad\\texttt{.}\\quad\\mathit{gmsm}\\texttt{)}$$\n", + "$$\\texttt{#S(ABSM}\\quad\\texttt{:DGOP}\\quad\\mathit{n}\\quad\\texttt{:GMSM}\\quad\\mathit{any}\\texttt{)}$$\n", "where,\n", - "1. *dgop* is a non-negative integer coding a *strictly decreasing integer list*. This strictly decreasing list of integers represents a sequence of $\\eta$ operators and is coded as a **unique** integer with the following convention: a number $i$ in the sequence is the $i+1$--th binary bit of a machine word. The null list is coded as the number 0 whereas the list `(0)`, i.e. the $\\eta_0$ operator, is coded as the integer `1`, etc. Two functions are provided to help the user for the transformation in both directions.\n", - "2. *gmsm* is a geometric simplex, i.e. any kind lisp object modelizing a non-degenerate simplex. For practical reason, a type `GMSM`, (any kind of lisp object), has been defined.\n", "\n", - "The simplest constructor is the macro `(absm (dgop-ext-int` *dgop-list*`)` *gmsm*`)`, where *dgop-list* is a strictly decreasing integer list. A type `ABSM` has been defined. The associated printing method prints such an object under the form:\n", + "1. *dgop* is a non-negative integer coding a *strictly decreasing integer list*. This strictly decreasing list of integers represents a sequence of $\\eta$ operators and is coded as a **unique** integer as follows. The iterated degeneracy operator $\\eta_{i_k} \\ldots \\eta_{i_1}$ is coded as the integer $\\sum_{j = 1}^k 2^{i_j}$; in other words we use a binary number where the binary digits 1 correspond to the indices of the $\\eta_i$'s. This is made possible by the \\emph{strictly} decreasing property of the indices. For example the degeneracy operator $\\eta_6 \\eta 3 \\eta_0$ is coded by the integer 73, for $73 = 2^6 + 2^3 + 2^0$. This leads to a compact coding, replacing the numerous operations about degeneracy operators by efficient handlings of bits of fixnums. In particular, 0 codes the void composition of degeneracy operator, that is, the identity operator. Two functions are provided to help the user for the transformation in both directions.\n", + "2. *gmsm* is a geometric simplex, i.e. any kind of lisp object modelizing a non-degenerate simplex. For practical reason, a type `GMSM`, (any kind of lisp object), has been defined.\n", + "\n", + "The simplest constructor is the macro `(absm (dgop-ext-int` *dgop-list*`)` *gmsm*`)`, where *dgop-list* is a strictly decreasing integer list. A structure class `ABSM` has been defined. The associated printing method prints such an object under the form:\n", "$$\\texttt{}$$\n", "where *ext-dgop* shows clearly the sequence of the operators $\\eta_i$ (see the examples). The accessor functions for the components are the macros `dgop` and `gmsm`.\n", "\n", "### Simple functions for abstract simplices\n", "\n", "`dgop-ext-int` *ext-dgop* *[Function]*\n", - ">Code on an integer the valid list representing the degeneracy operator *ext-dgop*.\n", + "> Code on an integer the valid list representing the degeneracy operator *ext-dgop*.\n", "\n", "`dgop-int-ext` *dgop* *[Function]*\n", "> Give the list representing a degeneracy operator from the integer *dgop*.\n", @@ -111,7 +112,7 @@ "> Get the basic non-degenerate simplex part of the abstract simplex `absm`.\n", "\n", "`absm-p` *object* *[Predicate]*\n", - ">Test if *object* is an abstract simplex.\n", + "> Test if *object* is an abstract simplex.\n", "\n", "### Examples\n", "\n", @@ -376,12 +377,13 @@ "\n", "## The function `build-smst`\n", "\n", - "To facilitate the construction of instances of the class `SIMPLICIAL-SET`, the software `Kenzo` provides the function `build-smst` defined with keyword parameters:\n", + "To facilitate the construction of instances of the class `SIMPLICIAL-SET`, the program `Kenzo` provides the function `build-smst` defined with keyword parameters:\n", "\n", - "`build-smst`\n", - ">`:cmpr` *cmpr* `:basis` *basis* `:bspn` *bspn* `:face` *face* \n", - "`:face*` *face$*$* `:intr-bndr` *intr-bndr* `:bndr-strt` *bndr-strt* \n", - "`:intr-dgnl` *intr-dgnl* `:dgnl-strt` *dgnl-strt* `:orgn` *orgn*\n", + "```commonlisp\n", + "(build-smst :cmpr cmpr :basis basis :bspn bspn :face face\n", + " :face* face* :intr-bndr intr-bndr bndr-strt bndr-strt\n", + " :intr-dgnl intr-dgnl :dgnl-strt dgnl-strt :orgn orgn\n", + "```\n", "\n", "The returned value is an object of type `SIMPLICIAL-SET`. This function assigns an identification number `idnm` to the Kenzo object instance in a sequential way and pushes this object on the list of already created simplicial sets instances, `*smst-list*`.\n", "\n", @@ -404,22 +406,22 @@ "$$\\Delta(\\sigma)= \\sum_{i=0}^{n}{{\\tilde{\\delta}}^{(i)}\\sigma \\otimes \\delta_0^{(i)} \\sigma},$$\n", "where the power $(i)$ denotes the $i$-th composition of the operator and $\\tilde{\\delta}$ is the\n", "*last face* operator, so that\n", - "$${\\tilde{\\delta}}^{(i)}=\\delta_{n-i+1}\\circ \\cdots \\circ \\delta_{n-1}\\circ \\delta_n.$$\n", + "$$\n", + "\\widetilde{\\delta}^{(i)} = \\partial_{n-i+1} \\circ \\cdots \\circ \\partial_n \\\\\n", + "\\widetilde{\\delta}_0^{(i)} = \\partial_0 \\circ \\cdots \\circ \\partial_{i-1}\n", + "$$\n", "\n", - "But, as the differential ignore degenerate faces, it may be interesting for the user to provide a face function, weaker than the function *face* but sufficient and more efficient to compute the boundary of a simplex. It is the raison d'etre of the parameter $face*$ which may be used as an alternative to *face*. In both cases, the strategy is set to `:gnrt` by the system. It may also arrive that the user knows a particularly simple form for the differential, he may then use the parameter *intr-bndr*. In the computation of differentials in the associated chain complex, this function will be used instead of the canonical differential computed from the face function. In this last case, the user is required to provide the strategy. Same remark for the parameter *intr-dgnl*.\n", + "But, as the differential ignore degenerate faces, it could be interesting for the user to provide a face function, weaker than the function *face* but sufficient and more efficient to compute the boundary of a simplex. It is the raison d'etre of the parameter $face*$ which may be used as an alternative to *face*. In both cases, the strategy is set to `:gnrt` by the system. It may also arrive that the user knows a particularly simple form for the differential, he may then use the parameter *intr-bndr*. In the computation of differentials in the associated chain complex, this function will be used instead of the canonical differential computed from the face function. In this last case, the user is required to provide the strategy. Same remark for the parameter *intr-dgnl*.\n", "\n", "### Examples\n", "\n", "As first example, we give the construction of the simplicial set $\\Delta^n$ corresponding to the \n", "standard $n$-simplex. This is given only as example. The program `Kenzo` provides a function\n", "for the same purpose which will be described later. For every simplex, we shall use a list representation as in our first example `diabolo`. The various keyword arguments for the call to `build-smst`, are:\n", + "\n", "1. *bspn*, the list `(0)`, i.e. the representation of the vertex 0.\n", "2. *cmpr*, the lisp function `#'l-cmpr`, since this function is adequate to compare the lists representing the simplices.\n", - "3. *basis*, the lisp function returning the list of all possible non-degenerate simplices in some dimension. Here, this is the combinatory function returning the set of all the lists of $p+1$ objects taken among $n+1$. Such a function is for instance the function (`delta-inj` *p n*) whose definition is given hereafter. So, the `:basis` keyword argument is simply:\n", - "``lisp\n", - "#'(lambda(dmn) (delta-inj dmn n))\n", - "``.\n", - "Note that here, `n` is a global parameter.\n", + "3. *basis*, the lisp function returning the list of all possible non-degenerate simplices in some dimension. Here, this is the combinatory function returning the set of all the lists of $p+1$ objects taken among $n+1$. Such a function is for instance the function (`delta-inj` *p n*) whose definition is given hereafter. So, the `:basis` keyword argument is simply: `#'(lambda(dmn) (delta-inj dmn n))`. Note that here the binding of `n` is defined outside the $\\lambda$-expression, which requires a *closure* for the implementation of this $\\lambda$-expression.\n", "4. *face*, the lisp function for the face operators (`face-delta-n`). It consists simply in removing the $i$-th element of the list describing a simplex ($i$ starting at 0).\n", "5. *org* will be a comment." ] @@ -540,7 +542,7 @@ { "data": { "text/plain": [ - "#" + "#" ] }, "execution_count": 15, @@ -582,7 +584,7 @@ } ], "source": [ - "(defun delta-n(n)\n", + "(defun delta-n (n)\n", " (declare (type fixnum n))\n", " (build-smst :cmpr #'l-cmpr\n", " :basis #'(lambda(dmn)(delta-inj dmn n))\n", @@ -717,7 +719,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "A third example is the construction of the simplicial set corresponding to `diabolo`. This simplicial set is a sub-complex of $\\Delta^2$. The `:face` function is exactly the same as in the examples above and the `:basis` function returns the sub-simplices of `diabolo`, by enumeration. " + "A third example is the construction of the simplicial set corresponding to `diabolo`. This simplicial set is a sub-complex of $\\Delta^5$. The `:face` function is exactly the same as in the examples above and the `:basis` function returns the sub-simplices of `diabolo`, by enumeration. " ] }, { @@ -766,7 +768,7 @@ "> Retrieve in the list `*smst-list*` the simplicial set instance whose the Kenzo identification\n", "is $n$. If it does not exist, return `NIL`.\n", "\n", - "`cmpr` *smst absm1 absm2* *[Macro]*\n", + "`a-cmpr3` *smst absm1 absm2* *[Function]*\n", "> Compare the abstract simplices *absm1* and *absm2* with the comparison function associated with the simplicial set *smst*.\n", "\n", "`bspn` *smst* *[Macro]*\n", @@ -784,10 +786,10 @@ "In any other case, we recall that this application returns always an object of type `ABSM`.\n", "\n", "`degenerate-p` *absm* *[Macro]*\n", - "> Return `t` if the abstract simplex *asm* is degenerate, `nil` otherwise.\n", + "> Return `t` if the abstract simplex *absm* is degenerate, `nil` otherwise.\n", "\n", "`non-degenerate-p` *absm* *[Macro]*\n", - "> Return `t` if the abstract simplex *asm* is non-degenerate, `nil` otherwise.\n", + "> Return `t` if the abstract simplex *absm* is non-degenerate, `nil` otherwise.\n", "\n", "`check-smst` *smst dmns1* `&optional` *dmns2 (1+ dmns1)* *[Function]*\n", "> Return `t` if the fundamental relations between the face operators $\\partial_i^k$\n", @@ -1323,7 +1325,7 @@ "data": { "image/png": "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", "text/plain": [ - "#" + "#" ] }, "execution_count": 42, @@ -1429,127 +1431,127 @@ "Rank of the source-module : 21.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/21 (dimension 1) :\n", "E01 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 2/21 (dimension 1) :\n", "E02 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 3/21 (dimension 1) :\n", "E03 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 4/21 (dimension 1) :\n", "E04 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 5/21 (dimension 1) :\n", "E05 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 6/21 (dimension 1) :\n", "E06 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 7/21 (dimension 1) :\n", "E12 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 8/21 (dimension 1) :\n", "E13 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 9/21 (dimension 1) :\n", "E14 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 10/21 (dimension 1) :\n", "E15 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 11/21 (dimension 1) :\n", "E16 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 12/21 (dimension 1) :\n", "E23 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 13/21 (dimension 1) :\n", "E24 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 14/21 (dimension 1) :\n", "E25 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 15/21 (dimension 1) :\n", "E26 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 16/21 (dimension 1) :\n", "E34 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 17/21 (dimension 1) :\n", "E35 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 18/21 (dimension 1) :\n", "E36 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 19/21 (dimension 1) :\n", "E45 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 20/21 (dimension 1) :\n", "E46 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 21/21 (dimension 1) :\n", "E56 \n", "End of computing.\n", @@ -1559,85 +1561,85 @@ "Rank of the source-module : 14.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/14 (dimension 2) :\n", "T013 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 2/14 (dimension 2) :\n", "T015 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 3/14 (dimension 2) :\n", "T024 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 4/14 (dimension 2) :\n", "T026 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 5/14 (dimension 2) :\n", "T036 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 6/14 (dimension 2) :\n", "T045 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 7/14 (dimension 2) :\n", "T125 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 8/14 (dimension 2) :\n", "T126 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 9/14 (dimension 2) :\n", "T134 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 10/14 (dimension 2) :\n", "T146 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 11/14 (dimension 2) :\n", "T234 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 12/14 (dimension 2) :\n", "T235 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 13/14 (dimension 2) :\n", "T356 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 14/14 (dimension 2) :\n", "T456 \n", "End of computing.\n", @@ -1832,13 +1834,13 @@ "Rank of the source-module : 2.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/2 (dimension 0) :\n", "V0 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 2/2 (dimension 0) :\n", "V1 \n", "End of computing.\n", @@ -1848,25 +1850,25 @@ "Rank of the source-module : 4.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/4 (dimension 1) :\n", "E0 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 2/4 (dimension 1) :\n", "E1 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 3/4 (dimension 1) :\n", "E2 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 4/4 (dimension 1) :\n", "E3 \n", "End of computing.\n", @@ -1885,25 +1887,25 @@ "Rank of the source-module : 4.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/4 (dimension 1) :\n", "E0 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 2/4 (dimension 1) :\n", "E1 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 3/4 (dimension 1) :\n", "E2 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 4/4 (dimension 1) :\n", "E3 \n", "End of computing.\n", @@ -1913,13 +1915,13 @@ "Rank of the source-module : 2.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/2 (dimension 2) :\n", "T0 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 2/2 (dimension 2) :\n", "T1 \n", "End of computing.\n", @@ -1938,13 +1940,13 @@ "Rank of the source-module : 2.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/2 (dimension 2) :\n", "T0 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 2/2 (dimension 2) :\n", "T1 \n", "End of computing.\n", @@ -2065,13 +2067,13 @@ "Rank of the source-module : 2.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/2 (dimension 0) :\n", "V0 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 2/2 (dimension 0) :\n", "V1 \n", "End of computing.\n", @@ -2081,25 +2083,25 @@ "Rank of the source-module : 4.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/4 (dimension 1) :\n", "E0 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 2/4 (dimension 1) :\n", "E1 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 3/4 (dimension 1) :\n", "E2 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 4/4 (dimension 1) :\n", "E3 \n", "End of computing.\n", @@ -2118,25 +2120,25 @@ "Rank of the source-module : 4.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/4 (dimension 1) :\n", "E0 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 2/4 (dimension 1) :\n", "E1 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 3/4 (dimension 1) :\n", "E2 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 4/4 (dimension 1) :\n", "E3 \n", "End of computing.\n", @@ -2146,13 +2148,13 @@ "Rank of the source-module : 2.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/2 (dimension 2) :\n", "T0 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 2/2 (dimension 2) :\n", "T1 \n", "End of computing.\n", @@ -2171,13 +2173,13 @@ "Rank of the source-module : 2.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/2 (dimension 2) :\n", "T0 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 2/2 (dimension 2) :\n", "T1 \n", "End of computing.\n", @@ -2298,7 +2300,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/1 (dimension 0) :\n", "V0 \n", "End of computing.\n", @@ -2308,19 +2310,19 @@ "Rank of the source-module : 3.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/3 (dimension 1) :\n", "E0 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 2/3 (dimension 1) :\n", "E1 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 3/3 (dimension 1) :\n", "E2 \n", "End of computing.\n", @@ -2339,19 +2341,19 @@ "Rank of the source-module : 3.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/3 (dimension 1) :\n", "E0 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 2/3 (dimension 1) :\n", "E1 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 3/3 (dimension 1) :\n", "E2 \n", "End of computing.\n", @@ -2361,13 +2363,13 @@ "Rank of the source-module : 2.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/2 (dimension 2) :\n", "T0 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 2/2 (dimension 2) :\n", "T1 \n", "End of computing.\n", @@ -2388,13 +2390,13 @@ "Rank of the source-module : 2.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/2 (dimension 2) :\n", "T0 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 2/2 (dimension 2) :\n", "T1 \n", "End of computing.\n", @@ -2441,7 +2443,7 @@ "data": { "image/png": "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", "text/plain": [ - "#" + "#" ] }, "execution_count": 55, @@ -2517,7 +2519,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/1 (dimension 0) :\n", "V0 \n", "End of computing.\n", @@ -2527,19 +2529,19 @@ "Rank of the source-module : 3.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/3 (dimension 1) :\n", "E0 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 2/3 (dimension 1) :\n", "E1 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 3/3 (dimension 1) :\n", "E2 \n", "End of computing.\n", @@ -2558,19 +2560,19 @@ "Rank of the source-module : 3.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/3 (dimension 1) :\n", "E0 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 2/3 (dimension 1) :\n", "E1 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 3/3 (dimension 1) :\n", "E2 \n", "End of computing.\n", @@ -2580,13 +2582,13 @@ "Rank of the source-module : 2.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/2 (dimension 2) :\n", "T0 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 2/2 (dimension 2) :\n", "T1 \n", "End of computing.\n", @@ -2607,13 +2609,13 @@ "Rank of the source-module : 2.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/2 (dimension 2) :\n", "T0 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 2/2 (dimension 2) :\n", "T1 \n", "End of computing.\n", @@ -2734,7 +2736,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/1 (dimension 0) :\n", "* \n", "End of computing.\n", @@ -2744,7 +2746,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/1 (dimension 1) :\n", "E \n", "End of computing.\n", @@ -2763,7 +2765,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/1 (dimension 1) :\n", "E \n", "End of computing.\n", @@ -2773,7 +2775,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/1 (dimension 2) :\n", "T \n", "End of computing.\n", @@ -2792,7 +2794,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/1 (dimension 2) :\n", "T \n", "End of computing.\n", @@ -2830,7 +2832,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The user will note that the list of faces for the 2-simplex `t`, is in simplified form. In particular, as the face 1 of `t` is the 0-degeneracy of the base point \"$*$\", it is sufficient to code the face 1 of `t`by \"`*`\" instead of the complete form `(0 *)`." + "The user will note that the list of faces for the 2-simplex `t`, is in simplified form. In particular, as the face 1 of `t` is the 0-degeneracy of the base point \"$*$\", it is sufficient to code the face 1 of `t` by \"`*`\" instead of the complete form `(0 *)`." ] }, { @@ -2844,7 +2846,7 @@ "data": { "image/png": "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", "text/plain": [ - "#" + "#" ] }, "execution_count": 61, @@ -2870,7 +2872,7 @@ "\n", "The object is a STANDARD-OBJECT of type CAT::SIMPLICIAL-SET.\n", "0. CMPR: #\n", - "1. BASIS: #\n", + "1. BASIS: #\n", "2. BSGN: *\n", "3. DFFR: [K62 Morphism (degree -1): K61 -> K61]\n", "4. GRMD: [K61 Simplicial-Set]\n", @@ -2878,7 +2880,7 @@ "6. IDNM: 61\n", "7. ORGN: (BUILD-FINITE-SS (* 1 E (* *) 2 T (E E E)))\n", "8. CPRD: [K65 Morphism (degree 0): K61 -> K63]\n", - "9. FACE: #\n", + "9. FACE: #\n", "\n", "> \n", "Checking the 0-simplices...\n", @@ -2920,7 +2922,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/1 (dimension 0) :\n", "* \n", "End of computing.\n", @@ -2930,7 +2932,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/1 (dimension 1) :\n", "E \n", "End of computing.\n", @@ -2949,7 +2951,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/1 (dimension 1) :\n", "E \n", "End of computing.\n", @@ -2959,7 +2961,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/1 (dimension 2) :\n", "T \n", "End of computing.\n", @@ -2976,7 +2978,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/1 (dimension 2) :\n", "T \n", "End of computing.\n", @@ -3623,7 +3625,7 @@ "> Create a simplicial set, a model for the sphere of dimension $n$, ($n \\geq 0$). This is a typical example where the differential is known a priori to be null, so the `:intr-bndr` keyword parameter is set to function `zero-pure-dffr`. This function generates a name `S`*n* for the **unique** simplex of dimension $n$ whose faces are the degeneracies of the base point labelled \"`*`\".\n", "\n", "`sphere-wedge` *dmns1 ... dmnsn* *[Function]*\n", - "> Create a simplicial set for the wedge of spheres. Here, the $dmns_i$ are integers, namely the dimensions of the spheres to be wedged. The differential is null. In the representation created by the software, the 0-simplex (base point) is labelled \"`*`\" and in dimension $p$ the simplexes are labelled `S`*p*`-`*1*, ..., `S`*p*`-`*s*, where *s* is the number of spheres of dimension $p$ in the wedge. (See the example).\n", + "> Create a simplicial set for a wedge of spheres. Here, the $dmns_i$ are integers, namely the dimensions of the spheres to be wedged. The differential is null. In the representation created by the program, the 0-simplex (base point) is labelled \"`*`\" and in dimension $p$ the simplices are labelled `S`*p*`-`*1*, ..., `S`*p*`-`*s*, where *s* is the number of spheres of dimension $p$ in the wedge. (See the example).\n", "\n", "`moore` *p n* *[Function]*\n", "> Construct a simplicial set, a model for ${\\rm Moore}(\\mathbb{Z}/{p\\mathbb{Z}},n)$. The integers $p$ and $n$ must satisfy the conditions $p>1,\\ n> 2p-4$, otherwise the result is undefined. ${\\rm Moore}(\\mathbb{Z}/{p\\mathbb{Z}},n)$ is a space, whose the only non-null homology groups are $H_0=\\mathbb{Z}$ and $H_n=\\mathbb{Z}/{p\\mathbb{Z}}$. A Moore space has only three non-degenerate simplices, namely in dimension $0$, $n$ and $n+1$. A number $p$ of faces of the $(n+1)$-simplex are identified with the $n$-simplex, the others faces being contracted on the base point. In the representation created by the software, the 0-simplex (base point), the $n$-simplex and the $(n+1)$-simplex are respectively labelled \"`*`\", `M`$n$ and `N`$n'$, where $n'=n+1$.\n", @@ -4359,7 +4361,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/1 (dimension 0) :\n", "0 \n", "End of computing.\n", @@ -4369,7 +4371,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/1 (dimension 1) :\n", "1 \n", "End of computing.\n", @@ -4388,7 +4390,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/1 (dimension 1) :\n", "1 \n", "End of computing.\n", @@ -4398,7 +4400,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/1 (dimension 2) :\n", "2 \n", "End of computing.\n", @@ -4417,7 +4419,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/1 (dimension 2) :\n", "2 \n", "End of computing.\n", @@ -4427,7 +4429,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/1 (dimension 3) :\n", "3 \n", "End of computing.\n", @@ -4444,7 +4446,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/1 (dimension 3) :\n", "3 \n", "End of computing.\n", @@ -4454,7 +4456,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/1 (dimension 4) :\n", "4 \n", "End of computing.\n", @@ -4473,7 +4475,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/1 (dimension 4) :\n", "4 \n", "End of computing.\n", @@ -4483,7 +4485,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/1 (dimension 5) :\n", "5 \n", "End of computing.\n", @@ -4610,7 +4612,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/1 (dimension 0) :\n", "0 \n", "End of computing.\n", @@ -4637,7 +4639,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/1 (dimension 2) :\n", "2 \n", "End of computing.\n", @@ -4654,7 +4656,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/1 (dimension 2) :\n", "2 \n", "End of computing.\n", @@ -4664,7 +4666,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/1 (dimension 3) :\n", "3 \n", "End of computing.\n", @@ -4683,7 +4685,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/1 (dimension 3) :\n", "3 \n", "End of computing.\n", @@ -4693,7 +4695,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/1 (dimension 4) :\n", "4 \n", "End of computing.\n", @@ -4712,7 +4714,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/1 (dimension 4) :\n", "4 \n", "End of computing.\n", @@ -4722,7 +4724,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/1 (dimension 5) :\n", "5 \n", "End of computing.\n", @@ -5112,13 +5114,15 @@ "\n", "The *non-degenerate* simplices of $X\\times Y$ are represented internally in the system by a lisp object of the form:\n", "\n", - "> `(:crpr (`*dgop1* `.` *gmsm1*`).(`*dgop2* `.` *gmsm2*`))`\n", + "```commonlisp\n", + "#S(CRPR :DGOP1 n1 :GMSM1 a1 :DGOP2 n2 :GMSM2 a2)\n", + "```\n", "\n", "where,\n", - "1. `dgop1` is an integer representing a coded degeneracy operator.\n", - "2. `gmsm1` is a non-degenerate simplex of $X$, to which is applied the degeneracy operator `dgop1`.\n", - "3. `dgop2` is an integer representing a coded degeneracy operator.\n", - "4. `gmsm2` is a non-degenerate simplex of $Y$, to which is applied the degeneracy operator `dgop2`.\n", + "1. `n1` is an integer representing a coded degeneracy operator.\n", + "2. `a1` is a non-degenerate simplex of $X$, to which is applied the degeneracy operator `dgop1`.\n", + "3. `n2` is an integer representing a coded degeneracy operator.\n", + "4. `a2` is a non-degenerate simplex of $Y$, to which is applied the degeneracy operator `dgop2`.\n", "\n", "This object must be a *non-degenerate* simplex of $X \\times Y$, that is to say, the degeneracy operators *dgop1* and *dgop2* must not have a common $\\eta_j$, and therefore their list representations must have a void intersection.\n", "The coded representation by binary bit positions, has the same property. The corresponding type is `CRPR`.\n", @@ -5138,7 +5142,7 @@ "> Build an object of type `CRPR`, using two abstract simplices *absm1* and *absm2*. If these abstract simplices are degenerate, the degeneracy operators must verify the condition of the definition, i.e. no common $\\eta_i$.\n", "\n", "`2absm-acrpr` *absm1 absm2* *[Function]*\n", - "> Build an abstract simplex, i.e. object of type `ABSM`, cartesian product of both abstract simplices *absm1* and *absm2*. In contrast with the previous function, there is no condition upon the degeneracy operators of the abstract simplices. Of course, the function `2absm-acrpr` returns a legal abstract simplex.\n", + "> Build an abstract simplex, i.e. object of type `ABSM`, cartesian product of both abstract simplices *absm1* and *absm2*. In contrast with the previous function, there is no condition upon the degeneracy operators of the abstract simplices. Of course, the function `2absm-acrpr` returns a legal abstract simplex in normalized form.\n", "\n", "`crpr-p` *object* *[Predicate]*\n", ">Test if *object* is of type `CRPR`.\n", @@ -5684,7 +5688,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/1 (dimension 0) :\n", " \n", "End of computing.\n", @@ -5694,19 +5698,19 @@ "Rank of the source-module : 3.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/3 (dimension 1) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 2/3 (dimension 1) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 3/3 (dimension 1) :\n", " \n", "End of computing.\n", @@ -5725,19 +5729,19 @@ "Rank of the source-module : 3.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/3 (dimension 1) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 2/3 (dimension 1) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 3/3 (dimension 1) :\n", " \n", "End of computing.\n", @@ -5747,13 +5751,13 @@ "Rank of the source-module : 2.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/2 (dimension 2) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 2/2 (dimension 2) :\n", " \n", "End of computing.\n", @@ -5774,13 +5778,13 @@ "Rank of the source-module : 2.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 1/2 (dimension 2) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-04-03, 22h 57m 39s.\n", + ";; Clock -> 2016-04-10, 21h 29m 50s.\n", "Computing the boundary of the generator 2/2 (dimension 2) :\n", " \n", "End of computing.\n",