From e00ad50f0f6e1ad1187664ae30e6baaa21116506 Mon Sep 17 00:00:00 2001 From: gheber Date: Fri, 11 Mar 2016 18:33:02 -0600 Subject: [PATCH] Corrected LaTeX conversion errors. --- examples/Chapter10.ipynb | 50 ++-- examples/Chapter4.ipynb | 56 ++-- examples/Chapter7.ipynb | 585 +++++++++++++++++++-------------------- examples/Chapter8.ipynb | 54 ++-- examples/Chapter9.ipynb | 200 ++++++------- examples/Overview.ipynb | 370 ++++++++++++------------- 6 files changed, 657 insertions(+), 658 deletions(-) diff --git a/examples/Chapter10.ipynb b/examples/Chapter10.ipynb index 7a2611a..2fa0c53 100644 --- a/examples/Chapter10.ipynb +++ b/examples/Chapter10.ipynb @@ -16,57 +16,57 @@ "\n", "### Example\n", "\n", - "We are going to work with the simplices of $\\Delta^\\mathbb{N}$. The set $(\\sigma_1, \\sigma_2) = $ ``((0 2), (0 1))`` is a Kan hat of dimension 2 and index 0. In effect, $\\delta_1\\sigma_1=\\delta_1\\sigma_2 =$ ``(0)``. Likewise, the two sets ``((1 2), (0 1))`` and ``((1 2), (0 2))`` are Kan hats of dimension 2 and of respective index 1 and 2. Of course, this definition applies equally if the simplices are degenerate.\n", + "We are going to work with the simplices of $\\Delta^\\mathbb{N}$. The set $(\\sigma_1, \\sigma_2) = $ `((0 2), (0 1))` is a Kan hat of dimension 2 and index 0. In effect, $\\delta_1\\sigma_1=\\delta_1\\sigma_2 =$ `(0)`. Likewise, the two sets `((1 2), (0 1))` and `((1 2), (0 2))` are Kan hats of dimension 2 and of respective index 1 and 2. Of course, this definition applies equally if the simplices are degenerate.\n", "\n", "**Definition 2.** A *filling* of a Kan hat $(\\sigma_0, \\ldots, \\sigma_{i-1}, \\sigma_{i+1}, \\ldots, \\sigma_n)$, is an $n$-simplex $\\tilde{\\sigma}$, such that for every $j \\not= i$, $\\partial_j\\tilde{\\sigma}=\\sigma_j.$\n", "\n", "### Example\n", "\n", - "A filling of ``((0 2), (0 1))`` is the 2-simplex ``(0 1 2)``. A filling of the Kan hat ``((1 1), (0 1))`` is the degenerate 2-simplex ``(0 1 1)``. A filling of the vertex ``(0)`` is the degenerate 1-simplex ``(0 0)``.\n", + "A filling of `((0 2), (0 1))` is the 2-simplex `(0 1 2)`. A filling of the Kan hat `((1 1), (0 1))` is the degenerate 2-simplex `(0 1 1)`. A filling of the vertex `(0)` is the degenerate 1-simplex `(0 0)`.\n", "\n", "**Definition 3.** A simplicial set is a Kan simplicial set if for every hat there exists a filling.\n", "\n", "### Representation of a Kan simplicial set\n", "\n", - "A Kan simplicial set is implemented as an instance of the class ``KAN``, subclass of the class ``SIMPLICIAL-SET``.\n", + "A Kan simplicial set is implemented as an instance of the class `KAN`, subclass of the class `SIMPLICIAL-SET`.\n", "\n", - "```lisp\n", + "```commonlisp\n", "(DEFCLASS KAN (simplicial-set)\n", " ((kfll :type kfll :initarg :kfll :reader kfll1)))\n", "```\n", "\n", - "We recall that this new class inherits also from the class ``CHAIN-COMPLEX``. It has one slot of its own:\n", + "We recall that this new class inherits also from the class `CHAIN-COMPLEX`. It has one slot of its own:\n", "\n", - "``kfll``\n", - "> an object of type ``KFLL``, in fact a lisp function with 3 parameters describing a Kan hat: an index (an integer), a dimension (an integer) and the Kan hat (a list of abstract simplices). This function must return a filling of the Kan hat argument, i.e. an abstract simplex satisfying the theoritical definition.\n", + "`kfll`\n", + "> an object of type `KFLL`, in fact a lisp function with 3 parameters describing a Kan hat: an index (an integer), a dimension (an integer) and the Kan hat (a list of abstract simplices). This function must return a filling of the Kan hat argument, i.e. an abstract simplex satisfying the theoritical definition.\n", "\n", - "A printing method has been associated to the class ``KAN`` and the external representation of an instance is a string like ``[K``*n* ``Kan-Simplicial-Set]``, where *n* is the number plate of the Kenzo object.\n", + "A printing method has been associated to the class `KAN` and the external representation of an instance is a string like `[K`*n* `Kan-Simplicial-Set]`, where *n* is the number plate of the Kenzo object.\n", "\n", "### Helpful functions on Kan simplicial sets\n", "\n", - "``cat-init`` *[Function]*\n", - "> Clear in particular ``*Kan-list*``, the list of user created Kan simplicial sets and reset the global counter to 1.\n", + "`cat-init` *[Function]*\n", + "> Clear in particular `*Kan-list*`, the list of user created Kan simplicial sets and reset the global counter to 1.\n", "\n", - "``Kan`` *n* *[Function]*\n", - "> Retrieve in the list ``*Kan-list*`` the Kan object instance whose the Kenzo identification is n. If it does not exist, return ``NIL``.\n", + "`Kan` *n* *[Function]*\n", + "> Retrieve in the list `*Kan-list*` the Kan object instance whose the Kenzo identification is n. If it does not exist, return `NIL`.\n", "\n", - "``kfll &rest`` *args* *[Macro]*\n", - "> With only one argument (a Kan instance) return the slot ``kfll`` of this instance. With 4 arguments\n", - "like ``(kfll`` *kan indx dmns hat*``)``, return a filling of the Kan hat *hat*, of dimension *dmns*\n", - "and of index *indx* by applying the filling function value of the slot ``kfll`` of the Kan instance *kan*.\n", + "`kfll &rest` *args* *[Macro]*\n", + "> With only one argument (a Kan instance) return the slot `kfll` of this instance. With 4 arguments\n", + "like `(kfll` *kan indx dmns hat*`)`, return a filling of the Kan hat *hat*, of dimension *dmns*\n", + "and of index *indx* by applying the filling function value of the slot `kfll` of the Kan instance *kan*.\n", "\n", - "``smst-kan`` *smst kfll* *[Function]*\n", - "> With the filling lisp function *kfll*, **transform** the simplicial set *smst* in an object of type ``KAN`` (in other word, *smst* is ``modified``). This is the easiest way to build a Kan simplicial set.\n", + "`smst-kan` *smst kfll* *[Function]*\n", + "> With the filling lisp function *kfll*, **transform** the simplicial set *smst* in an object of type `KAN` (in other word, *smst* is `modified`). This is the easiest way to build a Kan simplicial set.\n", "\n", - "``check-hat`` *kan indx dmns hat* *[Function]*\n", - "> Useful verification function to check if the collection of simplices ``hat`` is a valid Kan hat of dimension *dmns* and of index *indx* in the Kan simplicial set *kan*. In fact this works equally if *kan* is a general simplicial set.\n", + "`check-hat` *kan indx dmns hat* *[Function]*\n", + "> Useful verification function to check if the collection of simplices `hat` is a valid Kan hat of dimension *dmns* and of index *indx* in the Kan simplicial set *kan*. In fact this works equally if *kan* is a general simplicial set.\n", "\n", - "``check-kan`` *kan indx dmns hat* *[Function]*\n", + "`check-kan` *kan indx dmns hat* *[Function]*\n", "> Useful verification function to check if the collection of simplices *hat* is a valid Kan hat of dimension *dmns* and of index *indx* in the Kan simplicial set *kan*. This verification function applies the filling function of the instance *kan* to the argument *hat* and perform the verification of the faces relations upon the resulting $dmns$-simplex.\n", "\n", "### Examples\n", "\n", - "Let us take again the small examples of the introduction. First we define a function ``dkfll``, \n", + "Let us take again the small examples of the introduction. First we define a function `dkfll`, \n", "a filling function suitable for a Kan hat in $\\Delta^\\mathbb{N}$. The user will note that in the abstract simplices the degeneracy operators and the geometric simplices are coded in binary." ] }, @@ -82,7 +82,7 @@ "output_type": "stream", "text": [ "SIMPLE-STYLE-WARNING: \n", - " #\n" + " #\n" ] }, { @@ -376,9 +376,9 @@ "\n", "### Lisp files concerned in this chapter\n", "\n", - "``kan.lisp``.\n", + "`kan.lisp`.\n", "\n", - "[``classes.lisp``, ``macros.lisp``, ``various.lisp``]." + "[`classes.lisp`, `macros.lisp`, `various.lisp`]." ] } ], diff --git a/examples/Chapter4.ipynb b/examples/Chapter4.ipynb index d75d6c6..0499b7b 100644 --- a/examples/Chapter4.ipynb +++ b/examples/Chapter4.ipynb @@ -9,7 +9,7 @@ "## Introduction\n", "\n", "One knows that the homology groups of a cartesian product of two spaces $K$ and $L$ may be obtained by considering a chain complex derived from respective chain complexes of $K$ and $L$ by taking their *tensor product*.\n", - "But this is only one of the numerous uses of tensor products of chain complexes in algebraic topology, so the ``Kenzo`` software provides the handling of such an important tool.\n", + "But this is only one of the numerous uses of tensor products of chain complexes in algebraic topology, so the `Kenzo` software provides the handling of such an important tool.\n", "\n", "Let us recall that chain complexes are free $\\mathbb{Z}$-modules with distinguished basis. A tensor product of chain complexes \n", "is itself a free $\\mathbb{Z}$-module with a natural basis formed by the tensor product of the generators of the chain complex factors. The program conforms to that rule.\n", @@ -17,7 +17,7 @@ "## Tensor product of generators and combinations\n", "\n", "An elementary tensor product of two generators is represented, in the software, by a structured list in which we may find 4 items for the description of the two generators together with their respective degree. The internal representation of $gnrt1 \\otimes gnrt2$ has the form:\n", - "```lisp\n", + "```commonlisp\n", "(:tnpr (degr1 . gnrt1) . (degr2 . gnrt2))\n", "```\n", "where,\n", @@ -25,33 +25,33 @@ "2. *gnrt1* is the first generator of the pair.\n", "3. *degr2* is an integer, the degree of the generator *gnrt2*.\n", "4. *gnrt2* is the second generator of the pair.\n", - "To construct such an object, one may use the macro ``tnpr``. The corresponding type is ``TNPR``. The printing method prints the tensor product under the form:\n", - ">```` or ````\n", + "To construct such an object, one may use the macro `tnpr`. The corresponding type is `TNPR`. The printing method prints the tensor product under the form:\n", + ">`` or ``\n", "\n", - "according to the boolean value, ``NIL`` (default) or ``T`` of the system variable ``*tnpr-with-degrees*`` (see the examples).\n", + "according to the boolean value, `NIL` (default) or `T` of the system variable `*tnpr-with-degrees*` (see the examples).\n", "\n", "### Simple functions for the tensor product\n", "\n", "\n", - "``(tnpr degr1 gnrt1 degr2 gnrt2)`` *[Macro]*\n", + "`(tnpr degr1 gnrt1 degr2 gnrt2)` *[Macro]*\n", "> Build a tensor product $gnrt1 \\otimes gnrt2$.\n", "\n", - "``(tnpr-p object)`` *[Predicate]*\n", - "> Test if *object* is of type ``TNPR``.\n", + "`(tnpr-p object)` *[Predicate]*\n", + "> Test if *object* is of type `TNPR`.\n", "\n", - "``(degr1 tnpr)`` *[Macro]*\n", + "`(degr1 tnpr)` *[Macro]*\n", "> Select the degree of the first generator in the tensor product *tnpr*.\n", "\n", - "``(gnrt1 tnpr)`` *[Macro]*\n", + "`(gnrt1 tnpr)` *[Macro]*\n", "> Select the first generator from the object *tnpr*.\n", "\n", - "``(degr2 tnpr)`` *[Macro]*\n", + "`(degr2 tnpr)` *[Macro]*\n", "> Select the degree of the second generator in the tensor product *tnpr*.\n", "\n", - "``(gnrt2 tnpr)`` *[Macro]*\n", + "`(gnrt2 tnpr)` *[Macro]*\n", "> Select the second generator from the object *tnpr*.\n", "\n", - "``(2cmbn-tnpr cmbn1 cmbn2)`` *[Function]*\n", + "`(2cmbn-tnpr cmbn1 cmbn2)` *[Function]*\n", "> Create, from two combinations *cmbn1* and *cmbn2* with respective degree *degr1* and *degr2*, a combination of degree $dgr1 + dgr2$ by applying the tensorial distributive law on the two sums of terms of the combinations.\n", "\n", "#### Example" @@ -252,16 +252,16 @@ "with $c_m\\in C_m,\\ c_n'\\in C_n'$ and $d$, $d'$ being the respective boundary operators\n", "of $C$ and $C'$.\n", "\n", - "In the software, this is realized by the function ``tnsr-prdc``. \n", + "In the software, this is realized by the function `tnsr-prdc`. \n", "\n", - "``(tnsr-prdc chcm1 chcm2)`` *[Method]*\n", + "`(tnsr-prdc chcm1 chcm2)` *[Method]*\n", "> Build a chain complex, tensor product of the two chain complexes *chcm1* and *chcm2*. The elements\n", "of this new chain complex are integer combinations of generators of *TNPR* type. The creation of this\n", "new chain complex is done by a call to the function *build-chcm* with actual parameters defined from the constituting elements of *chcm1* and *chcm2*, according to the mathematical definitions above. If both arguments are *effective*, the function constructs an *effective* chain complex. On the other hand, if at least one of the chain complex is *locally effective*, the tensor product is also *locally effective*. In fact, the construction is correct only if both chain complexes are null in negative degrees, otherwise the result is undefined.\n", "\n", "#### Examples\n", "\n", - "Let us take the standard 2-simplex, $\\Delta^2$ and let us build $C_*(\\Delta^2) \\otimes C_*(\\Delta^2)$. To build the corresponding chain complex, we use the function ``cdelta``, defined in a previous chapter." + "Let us take the standard 2-simplex, $\\Delta^2$ and let us build $C_*(\\Delta^2) \\otimes C_*(\\Delta^2)$. To build the corresponding chain complex, we use the function `cdelta`, defined in a previous chapter." ] }, { @@ -523,7 +523,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Let us consider now the chain complex, $ccn$, that we used in the chain complex chapter. The basis in any degree are decades produced by the function ``" + "#" ] }, "execution_count": 18, @@ -779,31 +779,31 @@ "\n", "$$ (f\\otimes g) (a_1 \\otimes b_1)= (-1)^{deg(g)*deg(a1)}f(a_1) \\otimes g(b_1).$$\n", "\n", - "The method ``tnsr-prdc`` already defined for chain complexes, may be also used for that purpose. \n", + "The method `tnsr-prdc` already defined for chain complexes, may be also used for that purpose. \n", "\n", - "``(tnsr-prdc mrph1 mrph2)`` *[Method]*\n", + "`(tnsr-prdc mrph1 mrph2)` *[Method]*\n", "> Return the morphism, tensor product of the two morphisms *mrph1* and *mrph2*. The source\n", "and target of this new morphism are respectively the tensor product of the chain complexes source\n", "and target of *mrph1* and *mrph2*. The degree is the sum of the degrees of the parameters\n", - "and the lisp function (the ``:pure`` keyword argument of the function ``build-mrph``) conforms to the mathematical definition above. The strategy is by generator, i.e. the morphism is designed to work with 2 arguments: a degree and a generator which must be an object of type ``TNPR``.\n", + "and the lisp function (the `:pure` keyword argument of the function `build-mrph`) conforms to the mathematical definition above. The strategy is by generator, i.e. the morphism is designed to work with 2 arguments: a degree and a generator which must be an object of type `TNPR`.\n", "\n", - "``(tnsr-prdc rdct1 rdct2)`` *[Method]*\n", + "`(tnsr-prdc rdct1 rdct2)` *[Method]*\n", "> Return the reduction, tensor product of the two reductions *rdct1* and *rdct2*. The algorithm consists essentially in defining\n", "$$f=f1 \\otimes f2,\\, g=g1 \\otimes g2,\\, h= h1 \\otimes (g2 \\circ g2) + Id_{tcc1} \\otimes h2,$$\n", "where $Id_{tcc1}$ is the identity morphism in the top chain complex of the reduction *rdct1*.\n", - "The returned reduction is then built by a call to the method ``build-rdct``. This defines completely the chain complexes involved in the reduction.\n", + "The returned reduction is then built by a call to the method `build-rdct`. This defines completely the chain complexes involved in the reduction.\n", "\n", - "``(tnsr-prdc hmeq1 hmeq2)`` *[Method]*\n", + "`(tnsr-prdc hmeq1 hmeq2)` *[Method]*\n", "> Return the homotopy equivalence, tensor product of the two homotopy equivalence *heqm1* and *heqm2*. \n", "This is a homotopy equivalence where the new reductions are the tensor products of the arguments reductions (See the lisp definition just below).\n", "\n", "### Searching homology for tensor products\n", "\n", "The comment list of a tensor product of two chain complexes has the form \n", - "``(TNSR-PRDC`` *chcm1 chcm2*``)``. The ``search-efhm`` method applied to a tensor product, looks for the value of the respective ``efhm`` slots of the chain complexes *chcm1* and *chcm2*, (i.e. two homotopy equivalences) or tries to settle these slots if they are still unbound. Then it builds the tensor product of both homotopy equivalences, as shown in the following lisp listing. At its turn,\n", - "the resulting homotopy equivalence will become the value of the {\\tt efhm} slot of the initial tensor product chain complex.\n", + "`(TNSR-PRDC` *chcm1 chcm2*`)`. The `search-efhm` method applied to a tensor product, looks for the value of the respective `efhm` slots of the chain complexes *chcm1* and *chcm2*, (i.e. two homotopy equivalences) or tries to settle these slots if they are still unbound. Then it builds the tensor product of both homotopy equivalences, as shown in the following lisp listing. At its turn,\n", + "the resulting homotopy equivalence will become the value of the `efhm` slot of the initial tensor product chain complex.\n", "\n", - "```lisp\n", + "```commonlisp\n", "(defmethod SEARCH-EFHM (chcm (orgn (eql 'tnsr-prdc)))\n", " (declare (type chain-complex chcm))\n", " (the homotopy-equivalence\n", @@ -821,7 +821,7 @@ "\n", "#### Lisp file concerned in this chapter\n", "\n", - "``tensor-products.lisp``, ``searching-homology.lisp``." + "`tensor-products.lisp`, `searching-homology.lisp`." ] } ], diff --git a/examples/Chapter7.ipynb b/examples/Chapter7.ipynb index 4eaed9d..9b508a4 100644 --- a/examples/Chapter7.ipynb +++ b/examples/Chapter7.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\\index{simplicial sets}\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", "\n", "$$\\partial_i^q: K^q \\longrightarrow K^{q-1},\\quad q>0,\\quad i=0,\\ldots , q,$$\n", "\n", @@ -17,24 +17,24 @@ "subject to the relations\n", "\n", "$$\n", - "\\begin{align}\n", + "\\begin{aligned}\n", "\\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_j^q & = & \\eta_j^{q-1}\\partial_{i-1}^q, & i > j+1.\\cr \n", - "\\end{align}\n", + "\\end{aligned}\n", "$$\n", "\n", "An element of $K^q$ is an (*abstract*) $q$-simplex of $K$ and the functions $\\partial$ and $\\eta$ are respectively the *face operators* and the *degeneracy operators*. Formally, their action on a simplex is very simple. For instance, if a $q$--simplex is an ordered set of vertices, like $\\lbrace v_0, v_1, \\ldots,v_i,\\ldots, v_q \\rbrace$, the rules are the following (we omit the indication of the dimension of the simplex):\n", "\n", "$$\n", - "\\begin{eqnarray*}\n", + "\\begin{aligned}\n", "\\partial_i \\lbrace v_0, v_1, \\ldots,v_i,\\ldots, v_q \\rbrace & = &\n", " \\lbrace v_0, v_1, \\ldots,{\\bf v_{i-1}}, {\\bf v_{i+1}},\\ldots, v_q \\rbrace, \\\\\n", "\\eta_i \\lbrace v_0, v_1, \\ldots,v_i,\\ldots, v_q \\rbrace & = &\n", " \\lbrace v_0, v_1, \\ldots,{\\bf v_i},{\\bf v_i},\\ldots, v_q \\rbrace.\n", - "\\end{eqnarray*}\n", + "\\end{aligned}\n", "$$\n", "\n", "The operators $\\partial_i^q$ will be used hereafter to define the boundary operator $d^q$ for the $q$-component of the associated chain complex:\n", @@ -86,36 +86,36 @@ "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", "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", + "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", + "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", "$$\\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", + "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", + "`dgop-ext-int` *ext-dgop* *[Function]*\n", ">Code on an integer the valid list representing the degeneracy operator *ext-dgop*.\n", "\n", - "``dgop-int-ext`` *dgop* *[Function]*\n", + "`dgop-int-ext` *dgop* *[Function]*\n", "> Give the list representing a degeneracy operator from the integer *dgop*.\n", "\n", - "``absm`` *dgop gmsm* *[Macro]*\n", + "`absm` *dgop gmsm* *[Macro]*\n", "> Create an abstract simplex, using directly the coded representation, *dgop*, of the degeneracy operator.\n", "\n", - "``dgop`` *absm* *[Macro]*\n", + "`dgop` *absm* *[Macro]*\n", "> Get the integer code of the internal representation of the degeneracy operator of the abstract simplex *absm*.\n", " \n", - "``gmsm`` *absm* *[Macro]*\n", - "> Get the basic non-degenerate simplex part of the abstract simplex ``absm``.\n", + "`gmsm` *absm* *[Macro]*\n", + "> Get the basic non-degenerate simplex part of the abstract simplex `absm`.\n", "\n", - "``absm-p`` *object* *[Predicate]*\n", + "`absm-p` *object* *[Predicate]*\n", ">Test if *object* is an abstract simplex.\n", "\n", "### Examples\n", "\n", - "Let us suppose that ``:sigma`` \"is\" a geometric simplex, we may construct the abstract simplices of the beginning of the section." + "Let us suppose that `:sigma` \"is\" a geometric simplex, we may construct the abstract simplices of the beginning of the section." ] }, { @@ -284,7 +284,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The following command gives the sixth degeneracy of the vertex 0 represented as ``(0)``." + "The following command gives the sixth degeneracy of the vertex 0 represented as `(0)`." ] }, { @@ -359,42 +359,42 @@ "source": [ "## Representation of a simplicial set\n", "\n", - "A simplicial set is implemented as an instance of the class ``SIMPLICIAL-SET``, subclass of the class ``COALGEBRA``.\n", + "A simplicial set is implemented as an instance of the class `SIMPLICIAL-SET`, subclass of the class `COALGEBRA`.\n", "\n", - "```lisp\n", + "```commonlisp\n", "(DEFCLASS SIMPLICIAL-SET (coalgebra)\n", " ((face :type face :initarg :face :reader face1)))\n", "\n", "```\n", "\n", - "This class inherits also from the class ``CHAIN-COMPLEX`` and has one slot of its own:\n", + "This class inherits also from the class `CHAIN-COMPLEX` and has one slot of its own:\n", "\n", - ">``face``, a lisp function computing any face of any geometric simplex of the simplicial set.\n", - "This is a function with 3 arguments: a face index (a non--negative integer, ``indx``), a simplex dimension (a positive integer, ``dmns``) and a geometric simplex (``gmsm``), the $indx$-th face of which is looked for. Whatever the face simplex is, degenerate or not, the simplex returned by this function must be an **abstract** simplex, i.e. an ``ABSM`` object.\n", + ">`face`, a lisp function computing any face of any geometric simplex of the simplicial set.\n", + "This is a function with 3 arguments: a face index (a non--negative integer, `indx`), a simplex dimension (a positive integer, `dmns`) and a geometric simplex (`gmsm`), the $indx$-th face of which is looked for. Whatever the face simplex is, degenerate or not, the simplex returned by this function must be an **abstract** simplex, i.e. an `ABSM` object.\n", "\n", - "A printing method has been associated to the class ``SIMPLICIAL-SET`` and the external representation of an instance is a string like ``[K``*n* ``Simplicial-Set]``, where $n$ is the number plate of the Kenzo object.\n", + "A printing method has been associated to the class `SIMPLICIAL-SET` and the external representation of an instance is a string like `[K`*n* `Simplicial-Set]`, where $n$ is the number plate of the Kenzo object.\n", "\n", - "## The function ``build-smst``\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 software `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", + "`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", "\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", + "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", "The keywords parameters are:\n", "- *cmpr*, a comparison function for generators. \n", - "- *basis*, if the simplicial set is effective, this argument must be the lisp function returning the list of non-degenerate simplices of the simplicial set, in a given dimension; if the simplicial set is locally effective, this argument must be the keyword ``:locally-effective``.\n", - "- *bspn*, the lisp representation of the base point (an item of type ``GMSM``). This is in fact the slot ``bsgn`` of the associated chain complex.\n", + "- *basis*, if the simplicial set is effective, this argument must be the lisp function returning the list of non-degenerate simplices of the simplicial set, in a given dimension; if the simplicial set is locally effective, this argument must be the keyword `:locally-effective`.\n", + "- *bspn*, the lisp representation of the base point (an item of type `GMSM`). This is in fact the slot `bsgn` of the associated chain complex.\n", "- *face*, a lisp function for the face operators.\n", - "- $face*$, a lisp function for the face operators, returning the symbol ``:degenerate`` if the corresponding face is degenerate.\n", + "- $face*$, a lisp function for the face operators, returning the symbol `:degenerate` if the corresponding face is degenerate.\n", "- *intr-bndr*, a lisp function for the differential of the associated chain complex.\n", - "- *bndr-strt*, the strategy (``:cmbn`` or ``:gnrt``) for the function *intr-bndr*.\n", + "- *bndr-strt*, the strategy (`:cmbn` or `:gnrt`) for the function *intr-bndr*.\n", "- *intr-dgnl*, a lisp function for the coproduct of the coalgebra.\n", - "- *dngl-strt*, the strategy (``:cmbn`` or ``:gnrt``) for the function *intr-dgnl*.\n", + "- *dngl-strt*, the strategy (`:cmbn` or `:gnrt`) for the function *intr-dgnl*.\n", "- *org*, the comment list, adequately chosen.\n", "\n", "The three arguments $face*$, *intr-bndr* and *intr-dgnl* are not mandatory. Only the function *face* is necessary to define precisely the simplicial set. From the function *face*, we know that we may construct:\n", @@ -406,21 +406,21 @@ "*last face* operator, so that\n", "$${\\tilde{\\delta}}^{(i)}=\\delta_{n-i+1}\\circ \\cdots \\circ \\delta_{n-1}\\circ \\delta_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 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", "\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", - "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", + "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", + "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", - "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", + "``.\n", + "Note that here, `n` is a global parameter.\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." ] }, @@ -534,13 +534,13 @@ "output_type": "stream", "text": [ "SIMPLE-STYLE-WARNING: \n", - " #\n" + " #\n" ] }, { "data": { "text/plain": [ - "#" + "#" ] }, "execution_count": 15, @@ -560,7 +560,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "To create $\\Delta^n$ for any order $n$, we embed the call of ``build-smst`` in a function having $n$ as parameter." + "To create $\\Delta^n$ for any order $n$, we embed the call of `build-smst` in a function having $n$ as parameter." ] }, { @@ -683,7 +683,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "A second example is the contruction of the simplicial complex $\\Delta^\\mathbb{N}$ freely generated by the positive integers. The construction of the ``SIMPLICIAL-SET`` instance to implement this simplicial set is quite similar to that of $\\Delta^n$, but in this case the ``:basis`` keyword argument is the keyword ``:locally-effective``, since the sets $K^q$ are infinite. Whence, the definition of $\\Delta^\\mathbb{N}$:" + "A second example is the contruction of the simplicial complex $\\Delta^\\mathbb{N}$ freely generated by the positive integers. The construction of the `SIMPLICIAL-SET` instance to implement this simplicial set is quite similar to that of $\\Delta^n$, but in this case the `:basis` keyword argument is the keyword `:locally-effective`, since the sets $K^q$ are infinite. Whence, the definition of $\\Delta^\\mathbb{N}$:" ] }, { @@ -717,7 +717,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^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. " ] }, { @@ -759,39 +759,39 @@ "\n", "We give now a first set of functions, methods or macros acting on simplicial set instances. \n", "\n", - "``cat-init`` *[Function]*\n", - "> Clear in particular ``*smst-list*``, the list of user created simplicial sets and reset the global counter to 1.\n", + "`cat-init` *[Function]*\n", + "> Clear in particular `*smst-list*`, the list of user created simplicial sets and reset the global counter to 1.\n", "\n", - "``smst`` *n* *[Function]*\n", - "> 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", + "`smst` *n* *[Function]*\n", + "> 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", + "`cmpr` *smst absm1 absm2* *[Macro]*\n", "> Compare the abstract simplices *absm1* and *absm2* with the comparison function associated with the simplicial set *smst*.\n", "\n", - "``bspn`` *smst* *[Macro]*\n", + "`bspn` *smst* *[Macro]*\n", "> Return the base point of the simplicial set *smst*.\n", "\n", - "``bndr`` *smst* ``&rest`` *[Macro]*\n", - "> Identical to the macro ``dffr`` (see the chain complex chapter). For simplicial sets, it is more traditional to use the term *boundary*.\n", + "`bndr` *smst* `&rest` *[Macro]*\n", + "> Identical to the macro `dffr` (see the chain complex chapter). For simplicial sets, it is more traditional to use the term *boundary*.\n", "\n", - "``dgnl`` *smst* ``&rest`` *[Macro]*\n", - "> Identical to the macro ``cprd`` (see the coalgebra chapter). For simplicial sets, this recalls the \n", + "`dgnl` *smst* `&rest` *[Macro]*\n", + "> Identical to the macro `cprd` (see the coalgebra chapter). For simplicial sets, this recalls the \n", "Alexander-Witney diagonal.\n", "\n", - "``face`` *smst i k gmsm-or-absm* *[Macro]*\n", + "`face` *smst i k gmsm-or-absm* *[Macro]*\n", "> Versatile macro to apply the face operator $\\partial_i^k$ on the simplex *gmsm-or-absm* of the simplicial set *smst*. The name of the simplex parameter shows clearly that it may be either a geometric simplex or an abstract simplex. With only one argument (*smst*), return the function *face*. \n", - "In any other case, we recall that this application returns always an object of type ``ABSM``.\n", + "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", + "`degenerate-p` *absm* *[Macro]*\n", + "> Return `t` if the abstract simplex *asm* 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", + "`non-degenerate-p` *absm* *[Macro]*\n", + "> Return `t` if the abstract simplex *asm* 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", - "with $k=dmns1,\\ldots, dmns2-1$, applied on the effective simplicial set *smst*, are satisfied, otherwise ``nil``. If the optional parameter *dmns2* is omitted, the test is done only for\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", + "with $k=dmns1,\\ldots, dmns2-1$, applied on the effective simplicial set *smst*, are satisfied, otherwise `nil`. If the optional parameter *dmns2* is omitted, the test is done only for\n", "$k=dmns1$.\n", "\n", "## Examples\n", @@ -972,7 +972,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Let us test the face function. We see that, though ``delta-infty`` is locally effective, nevertheless, we may work with its simplices:" + "Let us test the face function. We see that, though `delta-infty` is locally effective, nevertheless, we may work with its simplices:" ] }, { @@ -1089,7 +1089,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The two following statement show that ``delta-infty`` may be considered also as a coalgebra and a chain complex." + "The two following statement show that `delta-infty` may be considered also as a coalgebra and a chain complex." ] }, { @@ -1154,7 +1154,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The simplicial set ``diabolo-ss``, has also all the properties of a coalgebra and of a chain complex." + "The simplicial set `diabolo-ss`, has also all the properties of a coalgebra and of a chain complex." ] }, { @@ -1286,9 +1286,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## The function ``build-finite-ss``\n", + "## The function `build-finite-ss`\n", "\n", - "The function ``build-finite-ss`` is a powerful function simplifying the creation of a finite simplicial set. From the lisp point of view, it accepts only one argument, the structured list of the simplices and their faces. In this list, every non--degenerate simplex must be coded as a symbol given by the user. The structure of the list is the following:\n", + "The function `build-finite-ss` is a powerful function simplifying the creation of a finite simplicial set. From the lisp point of view, it accepts only one argument, the structured list of the simplices and their faces. In this list, every non--degenerate simplex must be coded as a symbol given by the user. The structure of the list is the following:\n", "\n", "- **0** (in fact, optional)\n", "- $<$Sequence of the vertices, the first item being the base point$>$,\n", @@ -1304,12 +1304,12 @@ "\n", "1. A symbol, the symbolic name of the simplex.\n", "2. A list of faces of this simplex, describing the faces of the simplex. A face can be described in two ways:\n", - " - a symbol, the symbolic name of a {\\bf non-degenerate} simplex composing itself the face.\n", - " - or a list of the form ($i_k\\ i_{k-1}\\ \\ldots \\ i_1 \\ i_0$ ``symbol``) meaning that the degeneracy $\\eta_{i_k}\\eta_{i_{k-1}}\\ldots\\eta_{i_1}\\eta_{i_0}$ is to be applied to the non-degenerate simplex of name ``symbol`` to produce the actual (possibly degenerate) face. If the simplex face has dimension 0 (a vertex), the name of this vertex is sufficient in the face description because the program computes itself the unique possible degeneracy of the vertex, i.e. $\\eta_{k-2}\\ldots\\eta_0$. \n", + " - a symbol, the symbolic name of a **non-degenerate** simplex composing itself the face.\n", + " - or a list of the form ($i_k\\ i_{k-1}\\ \\ldots \\ i_1 \\ i_0$ `symbol`) meaning that the degeneracy $\\eta_{i_k}\\eta_{i_{k-1}}\\ldots\\eta_{i_1}\\eta_{i_0}$ is to be applied to the non-degenerate simplex of name `symbol` to produce the actual (possibly degenerate) face. If the simplex face has dimension 0 (a vertex), the name of this vertex is sufficient in the face description because the program computes itself the unique possible degeneracy of the vertex, i.e. $\\eta_{k-2}\\ldots\\eta_0$. \n", "\n", "### Examples\n", "\n", - "Let us give some examples to clarify the use of ``build-finite-ss``. In the first example, we use ``build-finite-ss`` to create a simplicial complex, corresponding to a triangulation of the torus. As the faces are never degenerated, the description of the faces is of simplified form." + "Let us give some examples to clarify the use of `build-finite-ss`. In the first example, we use `build-finite-ss` to create a simplicial complex, corresponding to a triangulation of the torus. As the faces are never degenerated, the description of the faces is of simplified form." ] }, { @@ -1323,7 +1323,7 @@ "data": { "image/png": "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", "text/plain": [ - "#" + "#" ] }, "execution_count": 42, @@ -1339,10 +1339,10 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The vertices will be named ``v0``, ``v1``, ..., ``v6``, ``v0`` being the base point. The edges\n", - "will be named ``e01``, ``e02``, ..., ``e56``, the list of faces of the edge $e_{ij}$ being\n", - "$(v_j\\ v_i)$. The triangles will be named ``t013``, ``t015``, ..., ``t456``, the list of faces of\n", - "the triangle $t_{ijk}$ being $(e_{jk}\\ e_{ik}\\ e_{ij})$. With this convention of describing the simplices, the call to ``build-finite-ss`` is in simplified form:" + "The vertices will be named `v0`, `v1`, ..., `v6`, `v0` being the base point. The edges\n", + "will be named `e01`, `e02`, ..., `e56`, the list of faces of the edge $e_{ij}$ being\n", + "$(v_j\\ v_i)$. The triangles will be named `t013`, `t015`, ..., `t456`, the list of faces of\n", + "the triangle $t_{ijk}$ being $(e_{jk}\\ e_{ik}\\ e_{ij})$. With this convention of describing the simplices, the call to `build-finite-ss` is in simplified form:" ] }, { @@ -1410,7 +1410,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "After verification of the coherence of the description of the faces, the function ``build-finite-ss`` calls adequately the function ``build-smst`` to create an instance of the class ``SIMPLICIAL SET`` subclass of the class ``CHAIN COMPLEX``. So that, it is easy for the user to obtain the homology groups of the torus, for instance in dimension 1:" + "After verification of the coherence of the description of the faces, the function `build-finite-ss` calls adequately the function `build-smst` to create an instance of the class `SIMPLICIAL SET` subclass of the class `CHAIN COMPLEX`. So that, it is easy for the user to obtain the homology groups of the torus, for instance in dimension 1:" ] }, { @@ -1429,127 +1429,127 @@ "Rank of the source-module : 21.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 1/21 (dimension 1) :\n", "E01 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 2/21 (dimension 1) :\n", "E02 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 3/21 (dimension 1) :\n", "E03 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 4/21 (dimension 1) :\n", "E04 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 5/21 (dimension 1) :\n", "E05 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 6/21 (dimension 1) :\n", "E06 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 7/21 (dimension 1) :\n", "E12 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 8/21 (dimension 1) :\n", "E13 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 9/21 (dimension 1) :\n", "E14 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 10/21 (dimension 1) :\n", "E15 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 11/21 (dimension 1) :\n", "E16 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 12/21 (dimension 1) :\n", "E23 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 13/21 (dimension 1) :\n", "E24 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 14/21 (dimension 1) :\n", "E25 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 15/21 (dimension 1) :\n", "E26 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 16/21 (dimension 1) :\n", "E34 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 17/21 (dimension 1) :\n", "E35 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 18/21 (dimension 1) :\n", "E36 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 19/21 (dimension 1) :\n", "E45 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 20/21 (dimension 1) :\n", "E46 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 21/21 (dimension 1) :\n", "E56 \n", "End of computing.\n", @@ -1559,85 +1559,85 @@ "Rank of the source-module : 14.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 1/14 (dimension 2) :\n", "T013 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 2/14 (dimension 2) :\n", "T015 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 3/14 (dimension 2) :\n", "T024 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 4/14 (dimension 2) :\n", "T026 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 5/14 (dimension 2) :\n", "T036 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 6/14 (dimension 2) :\n", "T045 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 7/14 (dimension 2) :\n", "T125 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 8/14 (dimension 2) :\n", "T126 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 9/14 (dimension 2) :\n", "T134 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 10/14 (dimension 2) :\n", "T146 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 11/14 (dimension 2) :\n", "T234 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 12/14 (dimension 2) :\n", "T235 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 13/14 (dimension 2) :\n", "T356 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 14/14 (dimension 2) :\n", "T456 \n", "End of computing.\n", @@ -1675,7 +1675,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The function ``build-finite-ss`` calls internally some verification functions mentioned above to verify the coherence of the description of the simplicial set and gives an error message if the description of the simplicial set is incorrect. For instance:" + "The function `build-finite-ss` calls internally some verification functions mentioned above to verify the coherence of the description of the simplicial set and gives an error message if the description of the simplicial set is incorrect. For instance:" ] }, { @@ -1742,7 +1742,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In the following examples, we show the power of ``build-finite-ss`` for the description of classical surfaces as simplicial sets, and in each case we verify the well known homology groups of those surfaces. The examples of the torus or the dunce-hat must be compared, as to the simplicity of the definition, to the respective ones in the previous page and in the Homology chapter." + "In the following examples, we show the power of `build-finite-ss` for the description of classical surfaces as simplicial sets, and in each case we verify the well known homology groups of those surfaces. The examples of the torus or the dunce-hat must be compared, as to the simplicity of the definition, to the respective ones in the previous page and in the Homology chapter." ] }, { @@ -1832,13 +1832,13 @@ "Rank of the source-module : 2.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 1/2 (dimension 0) :\n", "V0 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 2/2 (dimension 0) :\n", "V1 \n", "End of computing.\n", @@ -1848,25 +1848,25 @@ "Rank of the source-module : 4.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 1/4 (dimension 1) :\n", "E0 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 2/4 (dimension 1) :\n", "E1 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 3/4 (dimension 1) :\n", "E2 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 4/4 (dimension 1) :\n", "E3 \n", "End of computing.\n", @@ -1885,25 +1885,25 @@ "Rank of the source-module : 4.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 1/4 (dimension 1) :\n", "E0 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 2/4 (dimension 1) :\n", "E1 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 3/4 (dimension 1) :\n", "E2 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 4/4 (dimension 1) :\n", "E3 \n", "End of computing.\n", @@ -1913,13 +1913,13 @@ "Rank of the source-module : 2.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 1/2 (dimension 2) :\n", "T0 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 2/2 (dimension 2) :\n", "T1 \n", "End of computing.\n", @@ -1938,13 +1938,13 @@ "Rank of the source-module : 2.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 1/2 (dimension 2) :\n", "T0 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 2/2 (dimension 2) :\n", "T1 \n", "End of computing.\n", @@ -1989,7 +1989,7 @@ "data": { "image/png": "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", "text/plain": [ - "#" + "#" ] }, "execution_count": 49, @@ -2065,13 +2065,13 @@ "Rank of the source-module : 2.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 1/2 (dimension 0) :\n", "V0 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 2/2 (dimension 0) :\n", "V1 \n", "End of computing.\n", @@ -2081,25 +2081,25 @@ "Rank of the source-module : 4.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 1/4 (dimension 1) :\n", "E0 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 2/4 (dimension 1) :\n", "E1 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 3/4 (dimension 1) :\n", "E2 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 4/4 (dimension 1) :\n", "E3 \n", "End of computing.\n", @@ -2118,25 +2118,25 @@ "Rank of the source-module : 4.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 1/4 (dimension 1) :\n", "E0 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 2/4 (dimension 1) :\n", "E1 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 3/4 (dimension 1) :\n", "E2 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 4/4 (dimension 1) :\n", "E3 \n", "End of computing.\n", @@ -2146,13 +2146,13 @@ "Rank of the source-module : 2.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 1/2 (dimension 2) :\n", "T0 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 2/2 (dimension 2) :\n", "T1 \n", "End of computing.\n", @@ -2171,13 +2171,13 @@ "Rank of the source-module : 2.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 1/2 (dimension 2) :\n", "T0 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 2/2 (dimension 2) :\n", "T1 \n", "End of computing.\n", @@ -2298,7 +2298,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 1/1 (dimension 0) :\n", "V0 \n", "End of computing.\n", @@ -2308,19 +2308,19 @@ "Rank of the source-module : 3.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 1/3 (dimension 1) :\n", "E0 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 2/3 (dimension 1) :\n", "E1 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 3/3 (dimension 1) :\n", "E2 \n", "End of computing.\n", @@ -2339,19 +2339,19 @@ "Rank of the source-module : 3.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 1/3 (dimension 1) :\n", "E0 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 2/3 (dimension 1) :\n", "E1 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 3/3 (dimension 1) :\n", "E2 \n", "End of computing.\n", @@ -2361,13 +2361,13 @@ "Rank of the source-module : 2.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 1/2 (dimension 2) :\n", "T0 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 2/2 (dimension 2) :\n", "T1 \n", "End of computing.\n", @@ -2388,13 +2388,13 @@ "Rank of the source-module : 2.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 1/2 (dimension 2) :\n", "T0 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 2/2 (dimension 2) :\n", "T1 \n", "End of computing.\n", @@ -2441,7 +2441,7 @@ "data": { "image/png": "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", "text/plain": [ - "#" + "#" ] }, "execution_count": 55, @@ -2467,7 +2467,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: V0\n", "3. DFFR: [K52 Morphism (degree -1): K51 -> K51]\n", "4. GRMD: [K51 Simplicial-Set]\n", @@ -2475,7 +2475,7 @@ "6. IDNM: 51\n", "7. ORGN: (BUILD-FINITE-SS (V0 1 E0 (V0 V0) E1 (V0 V0) E2 (V0 V0) 2 T0 ...))\n", "8. CPRD: [K55 Morphism (degree 0): K51 -> K53]\n", - "9. FACE: #\n", + "9. FACE: #\n", "\n", "> \n", "Checking the 0-simplices...\n", @@ -2517,7 +2517,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 1/1 (dimension 0) :\n", "V0 \n", "End of computing.\n", @@ -2527,19 +2527,19 @@ "Rank of the source-module : 3.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 1/3 (dimension 1) :\n", "E0 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 2/3 (dimension 1) :\n", "E1 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 3/3 (dimension 1) :\n", "E2 \n", "End of computing.\n", @@ -2558,19 +2558,19 @@ "Rank of the source-module : 3.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 1/3 (dimension 1) :\n", "E0 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 2/3 (dimension 1) :\n", "E1 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 3/3 (dimension 1) :\n", "E2 \n", "End of computing.\n", @@ -2580,13 +2580,13 @@ "Rank of the source-module : 2.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 1/2 (dimension 2) :\n", "T0 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 2/2 (dimension 2) :\n", "T1 \n", "End of computing.\n", @@ -2607,13 +2607,13 @@ "Rank of the source-module : 2.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 1/2 (dimension 2) :\n", "T0 \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 2/2 (dimension 2) :\n", "T1 \n", "End of computing.\n", @@ -2658,7 +2658,7 @@ "data": { "image/png": "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", "text/plain": [ - "#" + "#" ] }, "execution_count": 58, @@ -2684,7 +2684,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: [K57 Morphism (degree -1): K56 -> K56]\n", "4. GRMD: [K56 Simplicial-Set]\n", @@ -2692,7 +2692,7 @@ "6. IDNM: 56\n", "7. ORGN: (BUILD-FINITE-SS (* 1 E (* *) 2 T (E * E)))\n", "8. CPRD: [K60 Morphism (degree 0): K56 -> K58]\n", - "9. FACE: #\n", + "9. FACE: #\n", "\n", "> \n", "Checking the 0-simplices...\n", @@ -2734,7 +2734,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 1/1 (dimension 0) :\n", "* \n", "End of computing.\n", @@ -2744,7 +2744,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 1/1 (dimension 1) :\n", "E \n", "End of computing.\n", @@ -2763,7 +2763,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 1/1 (dimension 1) :\n", "E \n", "End of computing.\n", @@ -2773,7 +2773,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 1/1 (dimension 2) :\n", "T \n", "End of computing.\n", @@ -2792,7 +2792,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 21s.\n", "Computing the boundary of the generator 1/1 (dimension 2) :\n", "T \n", "End of computing.\n", @@ -2830,7 +2830,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 +2844,7 @@ "data": { "image/png": "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", "text/plain": [ - "#" + "#" ] }, "execution_count": 61, @@ -2870,7 +2870,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 +2878,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 +2920,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 22s.\n", "Computing the boundary of the generator 1/1 (dimension 0) :\n", "* \n", "End of computing.\n", @@ -2930,7 +2930,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 22s.\n", "Computing the boundary of the generator 1/1 (dimension 1) :\n", "E \n", "End of computing.\n", @@ -2949,7 +2949,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 22s.\n", "Computing the boundary of the generator 1/1 (dimension 1) :\n", "E \n", "End of computing.\n", @@ -2959,7 +2959,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 22s.\n", "Computing the boundary of the generator 1/1 (dimension 2) :\n", "T \n", "End of computing.\n", @@ -2976,7 +2976,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 22s.\n", "Computing the boundary of the generator 1/1 (dimension 2) :\n", "T \n", "End of computing.\n", @@ -3016,44 +3016,44 @@ "source": [ "## Special simplicial sets\n", "\n", - "The system provides useful functions to create interesting simplicial sets of constant usage. In particular, the user is advised from now to use the following version of the standard simplex implemented in ``Kenzo`` and not the one given previously for simplicity reason.\n", + "The system provides useful functions to create interesting simplicial sets of constant usage. In particular, the user is advised from now to use the following version of the standard simplex implemented in `Kenzo` and not the one given previously for simplicity reason.\n", "\n", "### The standard simplex\n", "\n", - "``delta`` *dmns* *[Function]*\n", + "`delta` *dmns* *[Function]*\n", "> Create the standard simplex $\\Delta^n$ with vertices $0,1,\\ldots,n$, where *dmns* is the parameter for $n$. This simplicial set is so important in the applications that the implementor has decided to code the simplices in a way similar to the coding\n", "of the degeneracy operators. An increasing sequence of non-negative integers describing a simplex, is coded on a binary integer with the following convention: a number $i$ representing the vertex $i$ is the $(i+1)$--th binary bit of a machine word. The base point $0$ is the bit 1 in position 1 of the word. This representation is very efficient for saving memory space but somehow awkward to read.\n", "\n", - "``delta-infinity`` *[Function]*\n", + "`delta-infinity` *[Function]*\n", "> Create the locally effective standard simplex $\\Delta^\\mathbb{N}$ freely generated by the positive integers.\n", "\n", - "``deltab`` *[Function]*\n", + "`deltab` *[Function]*\n", "> Create the locally effective *reduced* simplicial set $\\bar \\Delta$, built from $\\Delta^\\mathbb{N}$ by identifying all the vertices to the base point.\n", "\n", - "``deltab2`` *[Function]*\n", + "`deltab2` *[Function]*\n", "> Create the locally effective *1-reduced* simplicial set $\\Delta_2^\\mathbb{N}$, obtained from the above $\\bar \\Delta$, by identification of all the edges with the base point. This is the efficient version of the coalgebra that is used as example in the cobar chapter.\n", "\n", - "``dlop-ext-int`` *ext-dlop* *[Function]*\n", + "`dlop-ext-int` *ext-dlop* *[Function]*\n", "> Code on an integer the valid list (increasing order) representing the simplex *ext-dlop* of the standard simplex.\n", "\n", - "``dlop-int-ext`` *dgop* *[Function]*\n", + "`dlop-int-ext` *dgop* *[Function]*\n", "> Give the list representing a simplex of the standard simplex from the integer *dgop*.\n", "\n", - "``vertex-i`` *absm i* *[Function]*\n", - "> Give the $i$-th vertex of the (coded, degenerate or not) abstract simplex ``absm`` belonging to a simplicial set of the $\\Delta$ family.\n", + "`vertex-i` *absm i* *[Function]*\n", + "> Give the $i$-th vertex of the (coded, degenerate or not) abstract simplex `absm` belonging to a simplicial set of the $\\Delta$ family.\n", "\n", - "``absm-ext-int`` *vlist* *[Function]*\n", + "`absm-ext-int` *vlist* *[Function]*\n", "> Create a valid abstract simplex of the $\\Delta$ family from the simplex *vlist* written as a non-decreasing list of non-negative integers (i.e coding of any degenerate or non--degenerate simplex of the $\\Delta$ family).\n", "\n", - "``absm-int-ext`` *absm* *[Function]*\n", + "`absm-int-ext` *absm* *[Function]*\n", "> From an internal coded form of an abstract simplex of the $\\Delta$ family, create the non-decreasing list\n", "of non--negative integers representing the canonical external form of such a simplex.\n", "\n", - "``soft-delta`` *dmns* *[Function]*\n", - "> Create another version of the standard simplex $\\Delta^n$ designed for a better clarity in the printing of the results at testing time. More precisely, the simplices are represented internally by a list of the form ``(:delt`` *binary-code*``)``. With this representation, the system is able to recognize a coded simplex and to print it in a readable form. For the user, the only\n", - "requirement is to write a simplex coded $n$ as ``(d`` *n*``)``, where ``d`` is the macro building the internal representation (see the examples). Attention: the above conversion functions do not work with this representation.\n", + "`soft-delta` *dmns* *[Function]*\n", + "> Create another version of the standard simplex $\\Delta^n$ designed for a better clarity in the printing of the results at testing time. More precisely, the simplices are represented internally by a list of the form `(:delt` *binary-code*`)`. With this representation, the system is able to recognize a coded simplex and to print it in a readable form. For the user, the only\n", + "requirement is to write a simplex coded $n$ as `(d` *n*`)`, where `d` is the macro building the internal representation (see the examples). Attention: the above conversion functions do not work with this representation.\n", "\n", - "``soft-delta-infinity`` *[Function]*\n", + "`soft-delta-infinity` *[Function]*\n", "\n", "### Examples" ] @@ -3157,7 +3157,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The list returned by the following statement getting the basis of $\\Delta^3$ in dimension 2, namely ``(7 11 13 14)`` is in fact the coded list of the following simplices ``((0 1 2) (0 1 3) (0 2 3) (1 2 3))``." + "The list returned by the following statement getting the basis of $\\Delta^3$ in dimension 2, namely `(7 11 13 14)` is in fact the coded list of the following simplices `((0 1 2) (0 1 3) (0 2 3) (1 2 3))`." ] }, { @@ -3186,7 +3186,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In the following statement, the integer $21$ represents the simplex in dimension $2$, ``(0 1 4)``, $1$ represents the operator $\\partial_1$ and the face is therefore ``(0 4)`` represented as the integer $17$." + "In the following statement, the integer $21$ represents the simplex in dimension $2$, `(0 1 4)`, $1$ represents the operator $\\partial_1$ and the face is therefore `(0 4)` represented as the integer $17$." ] }, { @@ -3405,7 +3405,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The following call to the macro ``?`` returns the boundary of the simplex ``(0 2 3)`` of $\\Delta^3$, the integers $5$, $9$ and $12$ representing respectively the simplices ``(0 2)``, ``(0 3)`` and ``(2 3)``. The application of the coproduct ``dgnl`` to the simplex ``(0 1 2 3)``, coded $15$, is also easily interpreted:" + "The following call to the macro `?` returns the boundary of the simplex `(0 2 3)` of $\\Delta^3$, the integers $5$, $9$ and $12$ representing respectively the simplices `(0 2)`, `(0 3)` and `(2 3)`. The application of the coproduct `dgnl` to the simplex `(0 1 2 3)`, coded $15$, is also easily interpreted:" ] }, { @@ -3467,7 +3467,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We may show now some examples with the *soft* version of the standard simplex. Using the macro ``d`` and the function ``dlop-ext-int`` the user may work with a readable form of the simplices and the degeneracy operators." + "We may show now some examples with the *soft* version of the standard simplex. Using the macro `d` and the function `dlop-ext-int` the user may work with a readable form of the simplices and the degeneracy operators." ] }, { @@ -3619,24 +3619,24 @@ "source": [ "### Spheres, Moore spaces and projective spaces\n", "\n", - "``sphere`` *n* *[Function]*\n", - "> 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", + "`sphere` *n* *[Function]*\n", + "> 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", + "`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", "\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", + "`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", "\n", - "``R-proj-space &optional`` *k l* *[Function]*\n", + "`R-proj-space &optional` *k l* *[Function]*\n", "> If $k=1$ or omitted, build a simplicial set model of $K(\\mathbb{Z}_2,1)= P^\\infty\\mathbb{R}$. In dimension $n$, this simplicial set has only one non-degenerate simplex, namely the integer $n$. \n", "The faces of this non-degenerate simplex $n$ are given by the following formulas: $\\partial_0 n = \\partial_n n = n-1$ and for $i \\not= 0$ and $i \\not=n$, $\\partial_i n= \\eta_{i-1} (n-2)$. If $k >1$, build an analogous simplicial set but with no simplices in dimensions $1 \\leq m < k$. If in addition to $k$ the argument $l$, ($l \\geq k$), is provided, build an analogous simplicial set but with no simplices in dimensions $m \\geq l$.\n", "\n", "### Examples\n", "\n", - "Let us define first, an auxiliary function ``show-structure`` with 2 arguments *ss* and *dmn*, to show the structure (i.e. generators and faces) of the simplicial set *ss*, from the dimension 0 up to the dimension *dmn* included.\n", + "Let us define first, an auxiliary function `show-structure` with 2 arguments *ss* and *dmn*, to show the structure (i.e. generators and faces) of the simplicial set *ss*, from the dimension 0 up to the dimension *dmn* included.\n", "\n", - "```lisp\n", + "```commonlisp\n", "(defun show-structure (ss dmn)\n", " (dotimes (i (1+ dmn))\n", " (format t \"~2%Dimension = ~D :\" i)\n", @@ -3648,7 +3648,6 @@ " s (mapcar #'(lambda (j) (face ss j i s))\n", " ( 0 i)))))\n", " )))\n", - "\n", "```\n", "\n", "In these elementary examples, we show the structure of some simplicial sets built\n", @@ -3703,7 +3702,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Applying the function ``basis``, we see that the only non-null simplices are in dimension 0 and 2." + "Applying the function `basis`, we see that the only non-null simplices are in dimension 0 and 2." ] }, { @@ -3816,7 +3815,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The differential of the simplex ``s2`` in dimension 2 is of course the null combination of degree 1:" + "The differential of the simplex `s2` in dimension 2 is of course the null combination of degree 1:" ] }, { @@ -3847,7 +3846,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Now, let us see the stucture of $S^3$, using our auxiliary function ``show-structure``." + "Now, let us see the stucture of $S^3$, using our auxiliary function `show-structure`." ] }, { @@ -4221,7 +4220,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Let us show now some examples with the simplicial sets generated by the function ``R-proj-space``." + "Let us show now some examples with the simplicial sets generated by the function `R-proj-space`." ] }, { @@ -4361,7 +4360,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 22s.\n", "Computing the boundary of the generator 1/1 (dimension 0) :\n", "0 \n", "End of computing.\n", @@ -4371,7 +4370,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 22s.\n", "Computing the boundary of the generator 1/1 (dimension 1) :\n", "1 \n", "End of computing.\n", @@ -4390,7 +4389,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 22s.\n", "Computing the boundary of the generator 1/1 (dimension 1) :\n", "1 \n", "End of computing.\n", @@ -4400,7 +4399,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 22s.\n", "Computing the boundary of the generator 1/1 (dimension 2) :\n", "2 \n", "End of computing.\n", @@ -4419,7 +4418,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 22s.\n", "Computing the boundary of the generator 1/1 (dimension 2) :\n", "2 \n", "End of computing.\n", @@ -4429,7 +4428,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 22s.\n", "Computing the boundary of the generator 1/1 (dimension 3) :\n", "3 \n", "End of computing.\n", @@ -4446,7 +4445,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 22s.\n", "Computing the boundary of the generator 1/1 (dimension 3) :\n", "3 \n", "End of computing.\n", @@ -4456,7 +4455,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 22s.\n", "Computing the boundary of the generator 1/1 (dimension 4) :\n", "4 \n", "End of computing.\n", @@ -4475,7 +4474,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 22s.\n", "Computing the boundary of the generator 1/1 (dimension 4) :\n", "4 \n", "End of computing.\n", @@ -4485,7 +4484,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 22s.\n", "Computing the boundary of the generator 1/1 (dimension 5) :\n", "5 \n", "End of computing.\n", @@ -4600,7 +4599,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 22s.\n", "Computing the boundary of the generator 1/1 (dimension 0) :\n", "0 \n", "End of computing.\n", @@ -4610,7 +4609,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 22s.\n", "Computing the boundary of the generator 1/1 (dimension 1) :\n", "1 \n", "End of computing.\n", @@ -4629,7 +4628,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 22s.\n", "Computing the boundary of the generator 1/1 (dimension 1) :\n", "1 \n", "End of computing.\n", @@ -5045,61 +5044,61 @@ "\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", + "> `(:crpr (`*dgop1* `.` *gmsm1*`).(`*dgop2* `.` *gmsm2*`))`\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. `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", "\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", - "To construct such an object, one may use the macro ``crpr``. As usual, a printing method has been defined to reflect the structure of the product under the form:\n", + "The coded representation by binary bit positions, has the same property. The corresponding type is `CRPR`.\n", + "To construct such an object, one may use the macro `crpr`. As usual, a printing method has been defined to reflect the structure of the product under the form:\n", "\n", - "> ````\n", + "> ``\n", "\n", "where the sequence of the operators $\\eta_i$ is printed in explicit form (this is the meaning of *ext-dgop*).\n", - "If this sequence of $\\eta_i$ is void, i.e. if the simplex *gmsm* is not degenerate, the symbol ``-`` is printed instead.\n", + "If this sequence of $\\eta_i$ is void, i.e. if the simplex *gmsm* is not degenerate, the symbol `-` is printed instead.\n", "\n", "### Functions and macros for the product of simplicial sets\n", "\n", - "``crpr`` *dgop1 gmsm1 dgop2 gmsm2* *[Macro]*\n", - "> Build an object of type ``CRPR``, using directly the integer coding for the degeneracy operators. The arguments *gmsm1* and *gmsm2* are non-degenerate simplices.\n", + "`crpr` *dgop1 gmsm1 dgop2 gmsm2* *[Macro]*\n", + "> Build an object of type `CRPR`, using directly the integer coding for the degeneracy operators. The arguments *gmsm1* and *gmsm2* are non-degenerate simplices.\n", "\n", - "``crpr`` *absm1 absm2* *[Macro]*\n", - "> 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", + "`crpr` *absm1 absm2* *[Macro]*\n", + "> 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", + "`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", "\n", - "``crpr-p`` *object* *[Predicate]*\n", - ">Test if *object* is of type ``CRPR``.\n", + "`crpr-p` *object* *[Predicate]*\n", + ">Test if *object* is of type `CRPR`.\n", "\n", - "``dgop1`` *crpr* *[Macro]*\n", - "> Select the degeneracy operator *dgop1* from the object ``crpr``.\n", + "`dgop1` *crpr* *[Macro]*\n", + "> Select the degeneracy operator *dgop1* from the object `crpr`.\n", "\n", - "``gmsm1`` *crpr* *[Macro]*\n", - "> Select the geometric simplex *gmsm1* from the object ``crpr``.\n", + "`gmsm1` *crpr* *[Macro]*\n", + "> Select the geometric simplex *gmsm1* from the object `crpr`.\n", "\n", - "``dgop2`` *crpr* *[Macro]*\n", - "> Select the degeneracy operator *dgop2* from the object ``crpr``.\n", + "`dgop2` *crpr* *[Macro]*\n", + "> Select the degeneracy operator *dgop2* from the object `crpr`.\n", "\n", - "``gmsm2`` *crpr* *[Macro]*\n", - "> Select the geometric simplex *gmsm2* from the object ``crpr``.\n", + "`gmsm2` *crpr* *[Macro]*\n", + "> Select the geometric simplex *gmsm2* from the object `crpr`.\n", "\n", - "``absm1`` *crpr* *[Macro]*\n", - "> Build the abstract simplex ``(absm`` *dgop1 gmsm1*``)`` from *crpr*.\n", + "`absm1` *crpr* *[Macro]*\n", + "> Build the abstract simplex `(absm` *dgop1 gmsm1*`)` from *crpr*.\n", "\n", - "``absm2`` *crpr* *[Macro]*\n", - "> Build the abstract simplex ``(absm`` *dgop2 gmsm2*``)`` from *crpr*.\n", + "`absm2` *crpr* *[Macro]*\n", + "> Build the abstract simplex `(absm` *dgop2 gmsm2*`)` from *crpr*.\n", "\n", - "``crts-prdc`` *smst1 smst2* *[Function]*\n", + "`crts-prdc` *smst1 smst2* *[Function]*\n", "> Build the simplicial set, cartesian product $smst1 \\times smts2$.\n", "\n", "### Examples\n", "\n", - "In the first example, note that the coded representations of $\\eta_1$ and $\\eta_2$ are respectively 2 and 4, but these degeneracy operators appear clearly as 1 and 2 in the printed result. In the second statement, the integer 28 is the coded representation of the degeneracy ``(4 3 2)``." + "In the first example, note that the coded representations of $\\eta_1$ and $\\eta_2$ are respectively 2 and 4, but these degeneracy operators appear clearly as 1 and 2 in the printed result. In the second statement, the integer 28 is the coded representation of the degeneracy `(4 3 2)`." ] }, { @@ -5179,7 +5178,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In the following example, we see that both functions ``crpr`` and ``2absm-acrpr`` return the same geometric simplex," + "In the following example, we see that both functions `crpr` and `2absm-acrpr` return the same geometric simplex," ] }, { @@ -5230,7 +5229,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "whereas, in the following call to ``crpr``, the condition upon the degeneracy operator is not respected and the result is an illegal cartesian product. The function ``2absm-acrpr`` returns the correct answer." + "whereas, in the following call to `crpr`, the condition upon the degeneracy operator is not respected and the result is an illegal cartesian product. The function `2absm-acrpr` returns the correct answer." ] }, { @@ -5281,7 +5280,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The following example is particularly instructive. The simplicial set whose the realization is homeomorphic to the square is built by using the product of two segments. A call like ``(delta n)`` builds the standard $n$-simplex. So first, we generate two copies ``X`` and ``Y`` of the standard 1-simplex and we list the abstract simplices up to dimension 2 for a better understanding of the components of the product ``XY``." + "The following example is particularly instructive. The simplicial set whose the realization is homeomorphic to the square is built by using the product of two segments. A call like `(delta n)` builds the standard $n$-simplex. So first, we generate two copies `X` and `Y` of the standard 1-simplex and we list the abstract simplices up to dimension 2 for a better understanding of the components of the product `XY`." ] }, { @@ -5339,7 +5338,7 @@ "data": { "image/png": "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", "text/plain": [ - "#" + "#" ] }, "execution_count": 129, @@ -5357,11 +5356,11 @@ "source": [ "In list representation (non-coded simplices), the abstract simplices of $X$ up to the dimension 2, including the degenerate ones are:\n", "\n", - "- Dimension 0: ``, ``. \n", - "- Dimension 1: ``, , ``. \n", - "- Dimension 2: ``, , , ``.\n", + "- Dimension 0: `, `. \n", + "- Dimension 1: `, , `. \n", + "- Dimension 2: `, , , `.\n", "\n", - "Let us look first at the non-degenerate simplices of the simplicial set $X \\times Y$. Those simplices are objects of type ``CRPR``. In dimension 1, we see that some projections are degeneracies of vertices and, in dimension 2, the projections are all degeneracies of the 1-simplex ``(0 1)`` coded as 3. Nevertheless, all the listed simplices are *geometric* simplices (i.e. non-degenerate ones) of the product ``XY``. The diagram above shows the relationship between the 3 simplicial sets. " + "Let us look first at the non-degenerate simplices of the simplicial set $X \\times Y$. Those simplices are objects of type `CRPR`. In dimension 1, we see that some projections are degeneracies of vertices and, in dimension 2, the projections are all degeneracies of the 1-simplex `(0 1)` coded as 3. Nevertheless, all the listed simplices are *geometric* simplices (i.e. non-degenerate ones) of the product `XY`. The diagram above shows the relationship between the 3 simplicial sets. " ] }, { @@ -5512,7 +5511,7 @@ " >)\n", "```\n", "\n", - "In an analogous way, let us build the torus as the cartesian product of two 1-spheres. We recall that the base point of the sphere is named ``*``." + "In an analogous way, let us build the torus as the cartesian product of two 1-spheres. We recall that the base point of the sphere is named `*`." ] }, { @@ -5617,7 +5616,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 22s.\n", "Computing the boundary of the generator 1/1 (dimension 0) :\n", " \n", "End of computing.\n", @@ -5627,19 +5626,19 @@ "Rank of the source-module : 3.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 22s.\n", "Computing the boundary of the generator 1/3 (dimension 1) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 22s.\n", "Computing the boundary of the generator 2/3 (dimension 1) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 22s.\n", "Computing the boundary of the generator 3/3 (dimension 1) :\n", " \n", "End of computing.\n", @@ -5658,19 +5657,19 @@ "Rank of the source-module : 3.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 22s.\n", "Computing the boundary of the generator 1/3 (dimension 1) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 22s.\n", "Computing the boundary of the generator 2/3 (dimension 1) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 22s.\n", "Computing the boundary of the generator 3/3 (dimension 1) :\n", " \n", "End of computing.\n", @@ -5680,13 +5679,13 @@ "Rank of the source-module : 2.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 22s.\n", "Computing the boundary of the generator 1/2 (dimension 2) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 22s.\n", "Computing the boundary of the generator 2/2 (dimension 2) :\n", " \n", "End of computing.\n", @@ -5707,13 +5706,13 @@ "Rank of the source-module : 2.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 22s.\n", "Computing the boundary of the generator 1/2 (dimension 2) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 18m 25s.\n", + ";; Clock -> 2016-03-11, 23h 47m 22s.\n", "Computing the boundary of the generator 2/2 (dimension 2) :\n", " \n", "End of computing.\n", @@ -5754,7 +5753,7 @@ "metadata": {}, "source": [ "Of course, we may generate more complex products, whose basis are composed of rather long\n", - "lists of simplices as shown below. The user will also pay attention to the fact that the composition of the macro ``crpr`` is not associative. In the following example, the simplicial sets located respectively by ``p1`` and ``p2`` are different objects, though being canonically isomorphic." + "lists of simplices as shown below. The user will also pay attention to the fact that the composition of the macro `crpr` is not associative. In the following example, the simplicial sets located respectively by `p1` and `p2` are different objects, though being canonically isomorphic." ] }, { @@ -5844,9 +5843,9 @@ "source": [ "### Lisp files concerned in this chapter\n", "\n", - "``simplicial-sets.lisp``, ``delta.lisp``, ``specials-smsts.lisp``, ``cartesian-products.lisp``.\n", + "`simplicial-sets.lisp`, `delta.lisp`, `specials-smsts.lisp`, `cartesian-products.lisp`.\n", "\n", - "[``classes.lisp``, ``macros.lisp``, ``various.lisp``]." + "[`classes.lisp`, `macros.lisp`, `various.lisp`]." ] } ], diff --git a/examples/Chapter8.ipynb b/examples/Chapter8.ipynb index 5a8f8c0..f50cf55 100644 --- a/examples/Chapter8.ipynb +++ b/examples/Chapter8.ipynb @@ -6,52 +6,52 @@ "source": [ "# Simplicial morphisms\n", "\n", - "The software ``Kenzo`` implements simplicial morphisms in a way analogous to chain complex morphisms.\n", + "The software `Kenzo` implements simplicial morphisms in a way analogous to chain complex morphisms.\n", "\n", "## Representation of a simplicial morphism\n", "\n", - "A simplicial morphism is an instance of the class ``SIMPLICIAL-MRPH``, subclass of the class ``MORPHISM``.\n", + "A simplicial morphism is an instance of the class `SIMPLICIAL-MRPH`, subclass of the class `MORPHISM`.\n", "\n", - "```lisp\n", + "```commonlisp\n", "(DEFCLASS SIMPLICIAL-MRPH (morphism)\n", " ((sintr :type sintr :initarg :sintr :reader sintr)))\n", "```\n", "\n", "It has one slot of its own:\n", - "> ``sintr``, an object of type ``SINTR``, in fact a lisp function defining the morphism between the source and target simplicial sets. It must have 2 parameters: a dimension (an integer) and a geometric simplex of this dimension (a generator of any type) . It must return an abstract simplex, image in the target simplicial set of this geometric simplex.\n", + "> `sintr`, an object of type `SINTR`, in fact a lisp function defining the morphism between the source and target simplicial sets. It must have 2 parameters: a dimension (an integer) and a geometric simplex of this dimension (a generator of any type) . It must return an abstract simplex, image in the target simplicial set of this geometric simplex.\n", "\n", - "A printing method has been associated to the class ``SIMPLICIAL-MRPH``. A string like ``[K``*n* ``Simplicial-Morphism]`` is the external representation of an instance of such a class, where *n* is the number plate of the ``Kenzo`` object.\n", + "A printing method has been associated to the class `SIMPLICIAL-MRPH`. A string like `[K`*n* `Simplicial-Morphism]` is the external representation of an instance of such a class, where *n* is the number plate of the `Kenzo` object.\n", "\n", - "## The function ``build-smmr``\n", + "## The function `build-smmr`\n", "\n", - "To facilitate the construction of instances of the class ``SIMPLICIAL-MRPH`` and to free the user to call the standard constructor ``make-instance``, the software provides the function\n", + "To facilitate the construction of instances of the class `SIMPLICIAL-MRPH` and to free the user to call the standard constructor `make-instance`, the software provides the function\n", "\n", - "> ``build-smmr :sorc`` *sorc* ``:trgt`` *trgt* ``:degr`` *degr* ``:sintr`` *sintr* ``:intr`` *intr* ``:strt`` *strt* ``:orgn`` *orgn*\n", + "> `build-smmr :sorc` *sorc* `:trgt` *trgt* `:degr` *degr* `:sintr` *sintr* `:intr` *intr* `:strt` *strt* `:orgn` *orgn*\n", "\n", - "defined with keyword parameters and returning an instance of the class ``SIMPLICIAL-MRPH``. The keyword arguments of ``build-smmr`` are:\n", + "defined with keyword parameters and returning an instance of the class `SIMPLICIAL-MRPH`. The keyword arguments of `build-smmr` are:\n", "\n", - "- *sorc*, the source object, an object of type ``SIMPLICIAL-SET``.\n", - "- *trgt*, the target object, an object of type ``SIMPLICIAL-SET``.\n", + "- *sorc*, the source object, an object of type `SIMPLICIAL-SET`.\n", + "- *trgt*, the target object, an object of type `SIMPLICIAL-SET`.\n", "- *degr*, the degree of the morphism, an integer. In this chapter, we consider only the 0 degree case (the usual one). The case -1 is particularly important: it allows to implement the notion of twisting operator defining a fibration (See the chapter Fibration).\n", - "- *sintr*, the internal lisp function defining the effective mapping between simplicial sets. If the integer *degr* is 0 and if the following keyword argument *intr* is omitted, then the function ``build-smmr`` builds a lisp function implementing the induced mapping between the underlying source and target chain complexes. This function is installed in the slot ``intr``. The strategy is then set to ``:gnrt``.\n", - "- ``intr``, a user defined morphism for the underlying chain complexes. This argument is optional and taken in account only if the degree is 0 and in this case, supersedes the previous derived mapping. The strategy is then mandatory. If the degree is not null, the implementor has decided to set the corresponding slot to ``NIL``.\n", - "- *strt*, the strategy, i.e. ``:gnrt`` or ``:cmbn`` attached to the previous function.\n", + "- *sintr*, the internal lisp function defining the effective mapping between simplicial sets. If the integer *degr* is 0 and if the following keyword argument *intr* is omitted, then the function `build-smmr` builds a lisp function implementing the induced mapping between the underlying source and target chain complexes. This function is installed in the slot `intr`. The strategy is then set to `:gnrt`.\n", + "- `intr`, a user defined morphism for the underlying chain complexes. This argument is optional and taken in account only if the degree is 0 and in this case, supersedes the previous derived mapping. The strategy is then mandatory. If the degree is not null, the implementor has decided to set the corresponding slot to `NIL`.\n", + "- *strt*, the strategy, i.e. `:gnrt` or `:cmbn` attached to the previous function.\n", "- *orgn*, a relevant comment list.\n", "\n", - "After a call to ``build-smmr``, the simplicial morphism instance is added to a list of previously constructed ones (``*smmr-list*``). As the other similar lists, the list ``*smmr-list*`` may be cleared by the function ``cat-init``.\n", + "After a call to `build-smmr`, the simplicial morphism instance is added to a list of previously constructed ones (`*smmr-list*`). As the other similar lists, the list `*smmr-list*` may be cleared by the function `cat-init`.\n", "\n", - "The effective application of a simplicial morphism upon arguments, is realized with the macro ``?`` which calls the adequate method defined for this kind of objects.\n", + "The effective application of a simplicial morphism upon arguments, is realized with the macro `?` which calls the adequate method defined for this kind of objects.\n", "\n", - "After a call to ``build-smmr``, the simplicial morphism instance is added to a list of previously constructed ones (``*smmr-list*``). As the other similar lists, the list ``*smmr-list*`` may be cleared by the function ``cat-init``.\n", + "After a call to `build-smmr`, the simplicial morphism instance is added to a list of previously constructed ones (`*smmr-list*`). As the other similar lists, the list `*smmr-list*` may be cleared by the function `cat-init`.\n", "\n", - "The effective application of a simplicial morphism upon arguments, is realized with the macro ``?`` which calls the adequate method defined for this kind of objects.\n", + "The effective application of a simplicial morphism upon arguments, is realized with the macro `?` which calls the adequate method defined for this kind of objects.\n", "\n", - "``? &rest`` *args* *[Macro]*\n", - "> Versatile macro for applying a simplicial morphism indifferently as ``(?`` *smmr dmns absm-or-gmsm*``)`` or ``(?`` *smmr cmbn*``)``. In the first case, the third argument is either an abstract simplex or a geometric one. In the second case, if the second argument is a combination, *smmr* is then considered as a chain complex morphism and it is the function in the slot ``intr`` which is applied, so that it makes sense only if the degree of the mapping is 0.\n", + "`? &rest` *args* *[Macro]*\n", + "> Versatile macro for applying a simplicial morphism indifferently as `(?` *smmr dmns absm-or-gmsm*`)` or `(?` *smmr cmbn*`)`. In the first case, the third argument is either an abstract simplex or a geometric one. In the second case, if the second argument is a combination, *smmr* is then considered as a chain complex morphism and it is the function in the slot `intr` which is applied, so that it makes sense only if the degree of the mapping is 0.\n", "\n", "### Examples\n", "\n", - "In the following examples, we work with $\\Delta_3$. We define three simplicial morphisms, ``sm1``, ``sm2`` and ``sm3``. In ``sm1``, the mapping is the identity mapping and we can see that this identity mapping has been propagated on the underlying chain complex." + "In the following examples, we work with $\\Delta_3$. We define three simplicial morphisms, `sm1`, `sm2` and `sm3`. In `sm1`, the mapping is the identity mapping and we can see that this identity mapping has been propagated on the underlying chain complex." ] }, { @@ -184,7 +184,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In the simplicial morphism ``sm2``, the mapping is the \"null\" mapping. In fact, it consists in applying any abstract simplex in dimension $n$ upon the $n$-degenerate base point. Of course, in terms of chain complex, the corresponding mapping applies any chain complex element upon the null combination of same degree." + "In the simplicial morphism `sm2`, the mapping is the \"null\" mapping. In fact, it consists in applying any abstract simplex in dimension $n$ upon the $n$-degenerate base point. Of course, in terms of chain complex, the corresponding mapping applies any chain complex element upon the null combination of same degree." ] }, { @@ -199,7 +199,7 @@ "output_type": "stream", "text": [ "SIMPLE-STYLE-WARNING: \n", - " #\n" + " #\n" ] }, { @@ -338,7 +338,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In the simplicial morphism ``sm3``, we keep the same \"null\" mapping as in ``sm2`` but we choose as mapping for the underlying chain complex the opposite of any chain complex element." + "In the simplicial morphism `sm3`, we keep the same \"null\" mapping as in `sm2` but we choose as mapping for the underlying chain complex the opposite of any chain complex element." ] }, { @@ -353,7 +353,7 @@ "output_type": "stream", "text": [ "SIMPLE-STYLE-WARNING: \n", - " #\n" + " #\n" ] }, { @@ -456,9 +456,9 @@ "source": [ "### Lisp files concerned in this chapter\n", "\n", - "``simplicial-mrphs.lisp``.\n", + "`simplicial-mrphs.lisp`.\n", "\n", - "[``classes.lisp``, ``macros.lisp``, ``various.lisp``]." + "[`classes.lisp`, `macros.lisp`, `various.lisp`]." ] } ], diff --git a/examples/Chapter9.ipynb b/examples/Chapter9.ipynb index 10e9ac5..d861832 100644 --- a/examples/Chapter9.ipynb +++ b/examples/Chapter9.ipynb @@ -6,9 +6,9 @@ "source": [ "# The Eilenberg-Zilber module\n", "\n", - "The functions of this module are related to the chain complex of the product of two simplicial sets. They implement the Eilenberg-Mac Lane homomorphism (function ``eml``) and the Alexander-Whitney homomorphism (function ``aw``).\n", + "The functions of this module are related to the chain complex of the product of two simplicial sets. They implement the Eilenberg-Mac Lane homomorphism (function `eml`) and the Alexander-Whitney homomorphism (function `aw`).\n", "\n", - "``eml`` *ssx ssy* *[Function]*\n", + "`eml` *ssx ssy* *[Function]*\n", "> build the Eilenberg-Mac Lane homomorphism $\\cal EML$, also called the *shuffle homomorphism*. (**Marvin Greenberg**, *Lectures on Algebraic Topology*, W.A. Benjamin Inc, 1967.) The arguments *ssx* and *ssy* represent some simplicial sets $X$ and $Y$. The homomorphism \n", "$${\\cal EML}:{\\cal C}_*(X) \\otimes {\\cal C}_*(Y) \\longrightarrow {\\cal C}_*(X \\times Y)$$\n", "is defined by:\n", @@ -17,7 +17,7 @@ "where $X\\times Y$ is the simplicial cartesian product of the two simplicial sets $X$ and $Y$, $\\alpha$ (resp. $\\beta$) is a geometric simplex of $X$ (resp. $Y$), $\\eta_k$ is the $k^{th}$ degeneracy operator, the sum is over all permutations $\\varpi= (i_1 \\ldots i_p j_1 \\ldots j_q)$ of $(0 \\ldots p+q-1)$ such that $$ i_1 < i_2 < \\cdots < i_p,\\quad j_1 < j_2 < \\cdots < j_q, \\quad p+q=n$$\n", "and $\\varepsilon(\\varpi)$ is the signature of the corresponding permutation. The sum at the right hand part determines a decomposition of the geometric product $\\alpha \\times \\beta$ into a combination of generators of the simplicial cartesian product (see the simplicial sets chapter). The combination takes in account the orientation of every simplex. These generators are non-degenerate simplices of the cartesian product but their projections are in general degenerate simplices of $X$ and $Y$ (see the examples).\n", " \n", - "``aw`` *ssx ssy* *[Function]*\n", + "`aw` *ssx ssy* *[Function]*\n", "> build the Alexander-Whitney chain homomorphism. The arguments *ssx* and *ssy* represent some simplicial sets $X$ and $Y$. The homomorphism \n", "$${\\cal AW}:{\\cal C}_*(X \\times Y) \\longrightarrow {\\cal C}_*(X) \\otimes {\\cal C}_*(Y)$$\n", "is defined by the following rule: let $\\sigma$ be an $n$-simplex and let us define\n", @@ -33,21 +33,21 @@ "This sum can be interpreted as a decomposition, up to a homotopy, of the simplex $\\alpha \\times \\beta$\n", "($\\alpha$ **and** $\\beta$ can be degenerate even if $\\alpha \\times \\beta$ is not) in terms of (tensor) products of non-degenerate simplices.\n", "\n", - "``phi`` *ssx ssy* *[Function]*\n", + "`phi` *ssx ssy* *[Function]*\n", "> build the homotopy chain morphism \n", "$$\\Phi: {\\cal C}_*(X \\times Y) \\longrightarrow {\\cal C}_*(X \\times Y)$$\n", "satisfying the formula\n", "$$d \\circ \\Phi + \\Phi \\circ d = Id - {\\cal EML} \\circ {\\cal AW}.$$\n", "\n", - "``ez`` *ssx ssy* *[Function]*\n", + "`ez` *ssx ssy* *[Function]*\n", "> build the Eilenberg--Zilber reduction as shown by the following diagram, where $X={\\mathit ssx}$ \n", "and $Y={\\mathit ssy}$.\n", "$$\n", - "\\begin{align}\n", + "\\begin{aligned}\n", "{{\\cal C}_*(X \\times Y)}\\quad & \\quad \\stackrel{\\Phi}{\\longrightarrow} & {}^s{{\\cal C}_*(X \\times Y)} \\cr\n", " {\\scriptstyle {\\cal AW}} \\downarrow \\uparrow {\\scriptstyle {\\cal EML}} & & \\cr\n", " {{\\cal C}_*(X) \\otimes {\\cal C}_*(Y)} & &\\cr\n", - "\\end{align}\n", + "\\end{aligned}\n", "$$\n", "\n", "## Examples" @@ -64,7 +64,7 @@ "data": { "image/png": "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", "text/plain": [ - "#" + "#" ] }, "execution_count": 1, @@ -80,7 +80,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "As simplicial sets $X$ and $Y$, let us use two copies of $\\Delta^\\mathbb{N}$, that we may build by the lisp statement ``(soft-delta-infinity)`` (Though we repeat this statement in the following line, there will be only a simplicial set created). We have chosen the *soft* version, to inspect the results more easily." + "As simplicial sets $X$ and $Y$, let us use two copies of $\\Delta^\\mathbb{N}$, that we may build by the lisp statement `(soft-delta-infinity)` (Though we repeat this statement in the following line, there will be only a simplicial set created). We have chosen the *soft* version, to inspect the results more easily." ] }, { @@ -147,7 +147,7 @@ "\n", "For the tensor product $(0\\,1\\,2)\\otimes (3\\,4)$, an intuitive description is still possible, as shown in the following diagram, but not in higher dimensions.\n", "\n", - "As the input of simplices is sometimes cumbersome, we have defined a macro called ``code`` to facilitate the input of the simplices." + "As the input of simplices is sometimes cumbersome, we have defined a macro called `code` to facilitate the input of the simplices." ] }, { @@ -476,7 +476,7 @@ "metadata": {}, "source": [ "But the composition ${\\cal EML} \\circ {\\cal AW}$ is by no means the identity. This composition\n", - "is related to the identity via the homotopy morphism $\\Phi$. Let us consider the two following simple simplicial sets {\\tt delta-0-1} and {\\tt delta-2-3}, where the second is the simplicial set, model of the segment $[2,\\,3]$. To build ``delta-2-3``, we have just changed the basis function, the base point and the comment in the system function ``soft-delta``." + "is related to the identity via the homotopy morphism $\\Phi$. Let us consider the two following simple simplicial sets {\\tt delta-0-1} and {\\tt delta-2-3}, where the second is the simplicial set, model of the segment $[2,\\,3]$. To build `delta-2-3`, we have just changed the basis function, the base point and the comment in the system function `soft-delta`." ] }, { @@ -917,7 +917,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Let us inspect now the reduction generated by the function ``ez`` and verify on reasonably general combinations that the involved morphisms are coherent." + "Let us inspect now the reduction generated by the function `ez` and verify on reasonably general combinations that the involved morphisms are coherent." ] }, { @@ -1348,7 +1348,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The simplicial set ``p2-X-s3`` is obtained from the cartesian product of the two simplicial sets ``p2`` and ``s3``." + "The simplicial set `p2-X-s3` is obtained from the cartesian product of the two simplicial sets `p2` and `s3`." ] }, { @@ -1377,7 +1377,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Now, the chain complex ``p2-T-s3`` is obtained from the tensor product of the two chain complexes associated to both simplicial sets ``p2`` and ``s3`` (don't forget that the class ``SIMPLICIAL SET`` is a subclass of the class ``CHAIN COMPLEX``)." + "Now, the chain complex `p2-T-s3` is obtained from the tensor product of the two chain complexes associated to both simplicial sets `p2` and `s3` (don't forget that the class `SIMPLICIAL SET` is a subclass of the class `CHAIN COMPLEX`)." ] }, { @@ -1406,7 +1406,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Applying successively the function ``chcm-homology`` (which computes directly the homology groups without using a homotopy equivalence) on these chain complexes, shows that the homology groups are effectively isomorphic, but the method of the tensor product is much faster than the method of the simple cartesian product, the number of generators being much more smaller." + "Applying successively the function `chcm-homology` (which computes directly the homology groups without using a homotopy equivalence) on these chain complexes, shows that the homology groups are effectively isomorphic, but the method of the tensor product is much faster than the method of the simple cartesian product, the number of generators being much more smaller." ] }, { @@ -1425,7 +1425,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 1/1 (dimension 0) :\n", " \n", "End of computing.\n", @@ -1435,7 +1435,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 1/1 (dimension 1) :\n", " \n", "End of computing.\n", @@ -1454,7 +1454,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 1/1 (dimension 1) :\n", " \n", "End of computing.\n", @@ -1464,7 +1464,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 1/1 (dimension 2) :\n", " \n", "End of computing.\n", @@ -1483,7 +1483,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 1/1 (dimension 2) :\n", " \n", "End of computing.\n", @@ -1493,43 +1493,43 @@ "Rank of the source-module : 7.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 1/7 (dimension 3) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 2/7 (dimension 3) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 3/7 (dimension 3) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 4/7 (dimension 3) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 5/7 (dimension 3) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 6/7 (dimension 3) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 7/7 (dimension 3) :\n", " \n", "End of computing.\n", @@ -1546,43 +1546,43 @@ "Rank of the source-module : 7.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 1/7 (dimension 3) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 2/7 (dimension 3) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 3/7 (dimension 3) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 4/7 (dimension 3) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 5/7 (dimension 3) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 6/7 (dimension 3) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 7/7 (dimension 3) :\n", " \n", "End of computing.\n", @@ -1592,97 +1592,97 @@ "Rank of the source-module : 16.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 1/16 (dimension 4) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 2/16 (dimension 4) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 3/16 (dimension 4) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 4/16 (dimension 4) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 5/16 (dimension 4) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 6/16 (dimension 4) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 7/16 (dimension 4) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 8/16 (dimension 4) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 9/16 (dimension 4) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 10/16 (dimension 4) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 11/16 (dimension 4) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 12/16 (dimension 4) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 13/16 (dimension 4) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 14/16 (dimension 4) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 15/16 (dimension 4) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 16/16 (dimension 4) :\n", " \n", "End of computing.\n", @@ -1701,97 +1701,97 @@ "Rank of the source-module : 16.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 1/16 (dimension 4) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 2/16 (dimension 4) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 3/16 (dimension 4) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 4/16 (dimension 4) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 5/16 (dimension 4) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 6/16 (dimension 4) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 7/16 (dimension 4) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 8/16 (dimension 4) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 9/16 (dimension 4) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 10/16 (dimension 4) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 11/16 (dimension 4) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 12/16 (dimension 4) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 13/16 (dimension 4) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 14/16 (dimension 4) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 15/16 (dimension 4) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 16/16 (dimension 4) :\n", " \n", "End of computing.\n", @@ -1801,61 +1801,61 @@ "Rank of the source-module : 10.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 1/10 (dimension 5) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 2/10 (dimension 5) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 3/10 (dimension 5) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 4/10 (dimension 5) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 5/10 (dimension 5) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 6/10 (dimension 5) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 7/10 (dimension 5) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 8/10 (dimension 5) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 9/10 (dimension 5) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 10/10 (dimension 5) :\n", " \n", "End of computing.\n", @@ -1874,61 +1874,61 @@ "Rank of the source-module : 10.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 1/10 (dimension 5) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 2/10 (dimension 5) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 3/10 (dimension 5) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 4/10 (dimension 5) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 5/10 (dimension 5) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 6/10 (dimension 5) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 7/10 (dimension 5) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 8/10 (dimension 5) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 9/10 (dimension 5) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 10/10 (dimension 5) :\n", " \n", "End of computing.\n", @@ -1978,7 +1978,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 1/1 (dimension 0) :\n", " \n", "End of computing.\n", @@ -1988,7 +1988,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 1/1 (dimension 1) :\n", " \n", "End of computing.\n", @@ -2007,7 +2007,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 1/1 (dimension 1) :\n", " \n", "End of computing.\n", @@ -2017,7 +2017,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 1/1 (dimension 2) :\n", " \n", "End of computing.\n", @@ -2036,7 +2036,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 1/1 (dimension 2) :\n", " \n", "End of computing.\n", @@ -2046,7 +2046,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 1/1 (dimension 3) :\n", " \n", "End of computing.\n", @@ -2063,7 +2063,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 1/1 (dimension 3) :\n", " \n", "End of computing.\n", @@ -2073,7 +2073,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 1/1 (dimension 4) :\n", " \n", "End of computing.\n", @@ -2092,7 +2092,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 1/1 (dimension 4) :\n", " \n", "End of computing.\n", @@ -2102,7 +2102,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 1/1 (dimension 5) :\n", " \n", "End of computing.\n", @@ -2121,7 +2121,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 20m 29s.\n", + ";; Clock -> 2016-03-12, 0h 20m 33s.\n", "Computing the boundary of the generator 1/1 (dimension 5) :\n", " \n", "End of computing.\n", @@ -2380,9 +2380,9 @@ "source": [ "### Searching homology process for cartesian products\n", "\n", - "When the ``search-efhm`` method recognizes a cartesian product, by means of the comment list (slot ``orgn``) of the object, it builds a homotopy equivalence where the right bottom chain complex is created by the function ``ez``. The process may be recursif as shown by the very definition of the method:\n", + "When the `search-efhm` method recognizes a cartesian product, by means of the comment list (slot `orgn`) of the object, it builds a homotopy equivalence where the right bottom chain complex is created by the function `ez`. The process may be recursif as shown by the very definition of the method:\n", "\n", - "```lisp\n", + "```commonlisp\n", "(defun LEFT-CRTS-PRDC-EFHM (smst1 smst2)\n", " (declare (type simplicial-set smst1 smst2))\n", " (the homotopy-equivalence\n", @@ -2402,7 +2402,7 @@ "\n", "### Lisp files concerned in this chapter\n", "\n", - "``eilenberg-zilber.lisp``, ``searching-homology.lisp``." + "`eilenberg-zilber.lisp`, `searching-homology.lisp`." ] } ], diff --git a/examples/Overview.ipynb b/examples/Overview.ipynb index ece5646..9a54c10 100644 --- a/examples/Overview.ipynb +++ b/examples/Overview.ipynb @@ -11,20 +11,20 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In this overview we try to show, without entering in detailed explanations, various possibilities of ``Kenzo`` in algebraic topology.\n", + "In this overview we try to show, without entering in detailed explanations, various possibilities of `Kenzo` in algebraic topology.\n", "\n", - "The material is arranged in a sequence of cells. Cells marked with ``In [*]`` represent (editable) input expressions, which in a traditional REPL (Read-Evaluate-Print Loop) would be typed by the user in a Lisp session. Only the ``In [*]`` mark is visible if the Lisp statement is not yet run; if run, another ``Out [*]`` mark is displayed with the corresponding object returned by the execution. Finally, there might be additional, non-editable, diagnostic output printed before the output component, most often a side-effect of the input form evaluation.\n", + "The material is arranged in a sequence of cells. Cells marked with `In [*]` represent (editable) input expressions, which in a traditional REPL (Read-Evaluate-Print Loop) would be typed by the user in a Lisp session. Only the `In [*]` mark is visible if the Lisp statement is not yet run; if run, another `Out [*]` mark is displayed with the corresponding object returned by the execution. Finally, there might be additional, non-editable, diagnostic output printed before the output component, most often a side-effect of the input form evaluation.\n", "\n", - "Other cells are the ``text`` cells, giving various explanations about the Lisp statements and their evaluations. Not editable by the user." + "Other cells are the `text` cells, giving various explanations about the Lisp statements and their evaluations. Not editable by the user." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## ``Kenzo`` in Action\n", + "## `Kenzo` in Action\n", "\n", - "Let us begin by the space $\\mathrm{Moore}(\\mathbb{Z}/2\\mathbb{Z}, 3)$ described as a simplicial set having only three non-degenerate simplices, namely in dimension $0$, $3$ and $4$. In the representation created by the software, the 0-simplex (base point), the 3-simplex and the 4-simplex are respectively labelled ``*``, ``M3`` and ``N4``. The faces 0 and 2 of the 4-simplex ``N4`` are identified with (pasted to) the 3-simplex ``M3``, the others being contracted on the base point. To create the simplicial set one types simply:" + "Let us begin by the space $\\mathrm{Moore}(\\mathbb{Z}/2\\mathbb{Z}, 3)$ described as a simplicial set having only three non-degenerate simplices, namely in dimension $0$, $3$ and $4$. In the representation created by the software, the 0-simplex (base point), the 3-simplex and the 4-simplex are respectively labelled `*`, `M3` and `N4`. The faces 0 and 2 of the 4-simplex `N4` are identified with (pasted to) the 3-simplex `M3`, the others being contracted on the base point. To create the simplicial set one types simply:" ] }, { @@ -53,7 +53,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The system answers that a ``Kenzo`` object has been created, with number 1 and type ``SIMPLICIAL SET``. This object may be referenced by the symbol ``m23``." + "The system answers that a `Kenzo` object has been created, with number 1 and type `SIMPLICIAL SET`. This object may be referenced by the symbol `m23`." ] }, { @@ -101,7 +101,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 1/1 (dimension 0) :\n", "* \n", "End of computing.\n", @@ -121,7 +121,7 @@ "\n", "---done---\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "\n", "\n", "Computing boundary-matrix in dimension 1.\n", @@ -140,7 +140,7 @@ "\n", "---done---\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "\n", "\n", "Computing boundary-matrix in dimension 2.\n", @@ -151,7 +151,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 1/1 (dimension 3) :\n", "M3 \n", "End of computing.\n", @@ -165,14 +165,14 @@ "\n", "---done---\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "\n", "\n", "Computing boundary-matrix in dimension 3.\n", "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 1/1 (dimension 3) :\n", "M3 \n", "End of computing.\n", @@ -182,7 +182,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 1/1 (dimension 4) :\n", "N4 \n", "End of computing.\n", @@ -198,14 +198,14 @@ "\n", "---done---\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "\n", "\n", "Computing boundary-matrix in dimension 4.\n", "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 1/1 (dimension 4) :\n", "N4 \n", "End of computing.\n", @@ -223,7 +223,7 @@ "\n", "---done---\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "\n" ] }, @@ -246,9 +246,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The homology of ``m23`` is $(Z,0,0,Z/2,0,\\ldots)$; the reduced homology is only $Z/2$ in dimension 3, defining the Moore space up to homotopy.\n", + "The homology of `m23` is $(Z,0,0,Z/2,0,\\ldots)$; the reduced homology is only $Z/2$ in dimension 3, defining the Moore space up to homotopy.\n", "\n", - "As ``m23`` is a simplicial set, it is possible to create the cartesian product $\\texttt{m23}\\times\\texttt{m23}$ by the function ``crts-prdc`` (= CaRTeSian PRoDuCt). This is a new simplicial set." + "As `m23` is a simplicial set, it is possible to create the cartesian product $\\texttt{m23}\\times\\texttt{m23}$ by the function `crts-prdc` (= CaRTeSian PRoDuCt). This is a new simplicial set." ] }, { @@ -328,9 +328,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "As shown by the last command, the number of elements of the basis is quite large (230). The user will note that the basis elements are in this particular case formed by cartesian products of *degenerated simplices*. In the list, an element like ```` means $\\eta_1\\eta_0\\mathrm{N4}\\times\\eta_5\\eta_3\\eta_2\\mathrm{M3}$.\n", + "As shown by the last command, the number of elements of the basis is quite large (230). The user will note that the basis elements are in this particular case formed by cartesian products of *degenerated simplices*. In the list, an element like `` means $\\eta_1\\eta_0\\mathrm{N4}\\times\\eta_5\\eta_3\\eta_2\\mathrm{M3}$.\n", "\n", - "We may construct also the tensor product $\\mathrm{m23}\\otimes\\mathrm{m23}$ from the underlying chain complex of the simplicial set ``m23``. The tensor product of two simplicial sets do not make sense, and Kenzo understands to work on the underlying chain complex ``m23``. This tensor product is a new chain complex and we see that the basis in dimension 6 has only one element:" + "We may construct also the tensor product $\\mathrm{m23}\\otimes\\mathrm{m23}$ from the underlying chain complex of the simplicial set `m23`. The tensor product of two simplicial sets do not make sense, and Kenzo understands to work on the underlying chain complex `m23`. This tensor product is a new chain complex and we see that the basis in dimension 6 has only one element:" ] }, { @@ -381,7 +381,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The Eilenberg-Zilber theorem is used to compute the homology groups of the cartesian product space: as chain complexes, ``m23xm23`` and ``t2m23`` have the same homology groups, but the computations using the tensor product are considerably faster. The user can check Künneth's theorem." + "The Eilenberg-Zilber theorem is used to compute the homology groups of the cartesian product space: as chain complexes, `m23xm23` and `t2m23` have the same homology groups, but the computations using the tensor product are considerably faster. The user can check Künneth's theorem." ] }, { @@ -400,7 +400,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 1/1 (dimension 0) :\n", " \n", "End of computing.\n", @@ -420,7 +420,7 @@ "\n", "---done---\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "\n", "\n", "Computing boundary-matrix in dimension 1.\n", @@ -439,7 +439,7 @@ "\n", "---done---\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "\n", "\n", "Computing boundary-matrix in dimension 2.\n", @@ -450,13 +450,13 @@ "Rank of the source-module : 2.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 1/2 (dimension 3) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 2/2 (dimension 3) :\n", " \n", "End of computing.\n", @@ -470,20 +470,20 @@ "\n", "---done---\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "\n", "\n", "Computing boundary-matrix in dimension 3.\n", "Rank of the source-module : 2.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 1/2 (dimension 3) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 2/2 (dimension 3) :\n", " \n", "End of computing.\n", @@ -493,13 +493,13 @@ "Rank of the source-module : 2.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 1/2 (dimension 4) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 2/2 (dimension 4) :\n", " \n", "End of computing.\n", @@ -517,20 +517,20 @@ "\n", "---done---\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "\n", "\n", "Computing boundary-matrix in dimension 4.\n", "Rank of the source-module : 2.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 1/2 (dimension 4) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 2/2 (dimension 4) :\n", " \n", "End of computing.\n", @@ -548,7 +548,7 @@ "\n", "---done---\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "\n", "\n", "Computing boundary-matrix in dimension 5.\n", @@ -559,7 +559,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 1/1 (dimension 6) :\n", " \n", "End of computing.\n", @@ -573,14 +573,14 @@ "\n", "---done---\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "\n", "\n", "Computing boundary-matrix in dimension 6.\n", "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 1/1 (dimension 6) :\n", " \n", "End of computing.\n", @@ -590,13 +590,13 @@ "Rank of the source-module : 2.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 1/2 (dimension 7) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 2/2 (dimension 7) :\n", " \n", "End of computing.\n", @@ -612,20 +612,20 @@ "\n", "---done---\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "\n", "\n", "Computing boundary-matrix in dimension 7.\n", "Rank of the source-module : 2.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 1/2 (dimension 7) :\n", " \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 2/2 (dimension 7) :\n", " \n", "End of computing.\n", @@ -635,7 +635,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 1/1 (dimension 8) :\n", " \n", "End of computing.\n", @@ -651,7 +651,7 @@ "\n", "---done---\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "\n" ] }, @@ -674,8 +674,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Let us consider now the space $\\mathrm{K}(\\mathbb{Z}, 1)$. This is an Abelian simplicial group created in ``Kenzo`` by the function ``k-z``. In this simplicial group, a simplex in dimension $n$ is mathematically represented by a sequence of integers, known as a *bar* object: $$ [a_1 \\mid a_2 \\mid \\ldots \\mid a_n].$$\n", - "In ``Kenzo``, a non-degenerate simplex of $\\mathrm{K}(\\mathbb{Z}, 1)$ in dimension $n$ will be simply a list of $n$ non-null integers, for instance: ``(2 3 4 5)``. In dimension 0, the only simplex is ``NIL`` (the base point)." + "Let us consider now the space $\\mathrm{K}(\\mathbb{Z}, 1)$. This is an Abelian simplicial group created in `Kenzo` by the function `k-z`. In this simplicial group, a simplex in dimension $n$ is mathematically represented by a sequence of integers, known as a *bar* object: $$ [a_1 \\mid a_2 \\mid \\ldots \\mid a_n].$$\n", + "In `Kenzo`, a non-degenerate simplex of $\\mathrm{K}(\\mathbb{Z}, 1)$ in dimension $n$ will be simply a list of $n$ non-null integers, for instance: `(2 3 4 5)`. In dimension 0, the only simplex is `NIL` (the base point)." ] }, { @@ -776,7 +776,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The printed results are the printed representation of *combinations*, i.e., integer linear combinations of generators resulting from the application of the morphisms. The degree of the combination is indicated by the information: ``CMBN n``. \n", + "The printed results are the printed representation of *combinations*, i.e., integer linear combinations of generators resulting from the application of the morphisms. The degree of the combination is indicated by the information: `CMBN n`. \n", "\n", "In the same way, we may create the Abelian simplicial groups $\\mathrm{K}(\\mathbb{Z}/2\\mathbb{Z}, n)$:" ] @@ -819,13 +819,13 @@ "Rank of the source-module : 2.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 1/2 (dimension 4) :\n", "<> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 2/2 (dimension 4) :\n", "<> \n", "End of computing.\n", @@ -835,19 +835,19 @@ "Rank of the source-module : 3.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 1/3 (dimension 5) :\n", "<> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 2/3 (dimension 5) :\n", "<> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 3/3 (dimension 5) :\n", "<> \n", "End of computing.\n", @@ -863,7 +863,7 @@ "\n", "---done---\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "\n" ] }, @@ -887,7 +887,7 @@ "metadata": {}, "source": [ "Let us play now with the sphere $S^3$ and its loop spaces. $S^3$ and $\\Omega^2 S^3$ are created by \n", - "respective calls to the functions ``sphere`` and ``loop-space``. Then we compute the $H_4$ and $H_5$ of $\\Omega^2 S^3$:" + "respective calls to the functions `sphere` and `loop-space`. Then we compute the $H_4$ and $H_5$ of $\\Omega^2 S^3$:" ] }, { @@ -950,19 +950,19 @@ "Rank of the source-module : 3.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 1/3 (dimension 4) :\n", "<>][3 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 2/3 (dimension 4) :\n", "<>][1 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 3/3 (dimension 4) :\n", "<>][1 <>][1 <>][1 <>]>> \n", "End of computing.\n", @@ -972,31 +972,31 @@ "Rank of the source-module : 5.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 1/5 (dimension 5) :\n", "<>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 2/5 (dimension 5) :\n", "<>][1 <>][3 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 3/5 (dimension 5) :\n", "<>][3 <>][1 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 4/5 (dimension 5) :\n", "<>][1 <>][1 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 5/5 (dimension 5) :\n", "<>][1 <>][1 <>][1 <>][1 <>]>> \n", "End of computing.\n", @@ -1014,38 +1014,38 @@ "\n", "---done---\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "\n", "\n", "Computing boundary-matrix in dimension 5.\n", "Rank of the source-module : 5.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 1/5 (dimension 5) :\n", "<>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 2/5 (dimension 5) :\n", "<>][1 <>][3 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 3/5 (dimension 5) :\n", "<>][3 <>][1 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 4/5 (dimension 5) :\n", "<>][1 <>][1 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 5/5 (dimension 5) :\n", "<>][1 <>][1 <>][1 <>][1 <>]>> \n", "End of computing.\n", @@ -1055,49 +1055,49 @@ "Rank of the source-module : 8.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 1/8 (dimension 6) :\n", "<>][5 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 2/8 (dimension 6) :\n", "<>][3 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 3/8 (dimension 6) :\n", "<>][1 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 4/8 (dimension 6) :\n", "<>][1 <>][1 <>][3 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 5/8 (dimension 6) :\n", "<>][1 <>][3 <>][1 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 6/8 (dimension 6) :\n", "<>][3 <>][1 <>][1 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 7/8 (dimension 6) :\n", "<>][1 <>][1 <>][1 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 8/8 (dimension 6) :\n", "<>][1 <>][1 <>][1 <>][1 <>][1 <>]>> \n", "End of computing.\n", @@ -1115,7 +1115,7 @@ "\n", "---done---\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "\n" ] }, @@ -1167,7 +1167,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In the following instruction, we locate in the symbol ``L1`` the canonical generator of $\\pi_2 (\\Omega^1S^3)$, that is the 2-simplex coming from the original sphere. In fact, the object created by the command $\\texttt{(loop3 0 's3 1)}$ is the \"word\" $S3^1$ belonging to the Kan simplicial version $G(S^3)$ (a simplicial group) of the loop space $\\Omega S^3$." + "In the following instruction, we locate in the symbol `L1` the canonical generator of $\\pi_2 (\\Omega^1S^3)$, that is the 2-simplex coming from the original sphere. In fact, the object created by the command $\\texttt{(loop3 0 's3 1)}$ is the \"word\" $S3^1$ belonging to the Kan simplicial version $G(S^3)$ (a simplicial group) of the loop space $\\Omega S^3$." ] }, { @@ -1225,7 +1225,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We may build now a new space by pasting a disk $D3$ as indicated by the following call. It means that we \"paste\" to the space ``os3`` a 3-simplex named ``D3``, the attaching map being described by the list of its faces in dimension 2. The faces 0 and 2 of D3 are pasted to L1, the faces 1 and 3 are collapsed on the base point; in this way the attaching map $(S^2 \\rightarrow \\Omega S^3)$ has degree 2." + "We may build now a new space by pasting a disk $D3$ as indicated by the following call. It means that we \"paste\" to the space `os3` a 3-simplex named `D3`, the attaching map being described by the list of its faces in dimension 2. The faces 0 and 2 of D3 are pasted to L1, the faces 1 and 3 are collapsed on the base point; in this way the attaching map $(S^2 \\rightarrow \\Omega S^3)$ has degree 2." ] }, { @@ -1255,7 +1255,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Let us compute a few homology groups of the new space ``dos3``:" + "Let us compute a few homology groups of the new space `dos3`:" ] }, { @@ -1274,7 +1274,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 1/1 (dimension 2) :\n", "<> \n", "End of computing.\n", @@ -1284,7 +1284,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 1/1 (dimension 3) :\n", " \n", "End of computing.\n", @@ -1300,14 +1300,14 @@ "\n", "---done---\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "\n", "\n", "Computing boundary-matrix in dimension 3.\n", "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 1/1 (dimension 3) :\n", " \n", "End of computing.\n", @@ -1317,7 +1317,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 1/1 (dimension 4) :\n", "<> \n", "End of computing.\n", @@ -1331,7 +1331,7 @@ "\n", "---done---\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "\n" ] }, @@ -1354,7 +1354,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "But more interesting, let us build the loop space of the object ``dos3`` and let us compute the homology in dimension 5:" + "But more interesting, let us build the loop space of the object `dos3` and let us compute the homology in dimension 5:" ] }, { @@ -1395,85 +1395,85 @@ "Rank of the source-module : 14.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 1/14 (dimension 5) :\n", "<>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 2/14 (dimension 5) :\n", "<][3 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 3/14 (dimension 5) :\n", "<>][2 ]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 4/14 (dimension 5) :\n", "<>][1 <>][3 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 5/14 (dimension 5) :\n", "<>][2 ][2 ]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 6/14 (dimension 5) :\n", "<>][3 <>][1 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 7/14 (dimension 5) :\n", "<][1 <>][2 ]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 8/14 (dimension 5) :\n", "<][2 ][1 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 9/14 (dimension 5) :\n", "<>][1 <>][1 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 10/14 (dimension 5) :\n", "<>][1 <>][1 <>][2 ]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 11/14 (dimension 5) :\n", "<>][1 <>][2 ][1 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 12/14 (dimension 5) :\n", "<>][2 ][1 <>][1 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 13/14 (dimension 5) :\n", "<][1 <>][1 <>][1 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 14/14 (dimension 5) :\n", "<>][1 <>][1 <>][1 <>][1 <>]>> \n", "End of computing.\n", @@ -1483,157 +1483,157 @@ "Rank of the source-module : 26.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 1/26 (dimension 6) :\n", "<>][5 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 2/26 (dimension 6) :\n", "<>][3 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 3/26 (dimension 6) :\n", "<>][1 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 4/26 (dimension 6) :\n", "<>][2 ][3 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 5/26 (dimension 6) :\n", "<>][3 <>][2 ]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 6/26 (dimension 6) :\n", "<][1 <>][3 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 7/26 (dimension 6) :\n", "<][2 ][2 ]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 8/26 (dimension 6) :\n", "<][3 <>][1 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 9/26 (dimension 6) :\n", "<>][1 <>][2 ]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 10/26 (dimension 6) :\n", "<>][2 ][1 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 11/26 (dimension 6) :\n", "<>][1 <>][1 <>][3 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 12/26 (dimension 6) :\n", "<>][1 <>][2 ][2 ]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 13/26 (dimension 6) :\n", "<>][1 <>][3 <>][1 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 14/26 (dimension 6) :\n", "<>][2 ][1 <>][2 ]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 15/26 (dimension 6) :\n", "<>][2 ][2 ][1 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 16/26 (dimension 6) :\n", "<>][3 <>][1 <>][1 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 17/26 (dimension 6) :\n", "<][1 <>][1 <>][2 ]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 18/26 (dimension 6) :\n", "<][1 <>][2 ][1 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 19/26 (dimension 6) :\n", "<][2 ][1 <>][1 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 20/26 (dimension 6) :\n", "<>][1 <>][1 <>][1 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 21/26 (dimension 6) :\n", "<>][1 <>][1 <>][1 <>][2 ]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 22/26 (dimension 6) :\n", "<>][1 <>][1 <>][2 ][1 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 23/26 (dimension 6) :\n", "<>][1 <>][2 ][1 <>][1 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 15s.\n", "Computing the boundary of the generator 24/26 (dimension 6) :\n", "<>][2 ][1 <>][1 <>][1 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 25/26 (dimension 6) :\n", "<][1 <>][1 <>][1 <>][1 <>]>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 26/26 (dimension 6) :\n", "<>][1 <>][1 <>][1 <>][1 <>][1 <>]>> \n", "End of computing.\n", @@ -1661,7 +1661,7 @@ "\n", "---done---\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "\n" ] }, @@ -1838,7 +1838,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We see that the result is a linear combination of words composed from degeneracies of ``L2``. The following instruction selects the generator part of the \n", + "We see that the result is a linear combination of words composed from degeneracies of `L2`. The following instruction selects the generator part of the \n", "second element of the previous combination." ] }, @@ -1868,7 +1868,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Let us use the lisp function ``mapcar`` (one among the various iteration functions of Lisp) to create the list of the faces 1, 2, 3 and 4 of the object ``L4``, this list is a \"Kan horn\"." + "Let us use the lisp function `mapcar` (one among the various iteration functions of Lisp) to create the list of the faces 1, 2, 3 and 4 of the object `L4`, this list is a \"Kan horn\"." ] }, { @@ -1897,7 +1897,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The function ``kfll`` tries to find a filling of this \"Kan horn\", and we see that the face 2 of the resulting simplex (which is very different from ``L4``) is the same as the face 2 of ``L4``." + "The function `kfll` tries to find a filling of this \"Kan horn\", and we see that the face 2 of the resulting simplex (which is very different from `L4`) is the same as the face 2 of `L4`." ] }, { @@ -1970,7 +1970,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Let ${\\cal G}$ be a simplicial group 0-reduced. $\\Omega S^3$ is such a group. The program ``Kenzo`` allows the construction of the universal bundle $\\mathcal{WG}$ and in particular of its base space $\\overline{\\mathcal{W}} \\mathcal{G}$, i.e. the classifying space of ${\\cal G}$. In our case, as $\\Omega S^3$ in non-Abelian, the result is not a simplicial group but only a simplicial set. We verify that the $H_4$, which in principle should be isomorphic to $H_4 S^3 = 0$, is really null." + "Let ${\\cal G}$ be a simplicial group 0-reduced. $\\Omega S^3$ is such a group. The program `Kenzo` allows the construction of the universal bundle $\\mathcal{WG}$ and in particular of its base space $\\overline{\\mathcal{W}} \\mathcal{G}$, i.e. the classifying space of ${\\cal G}$. In our case, as $\\Omega S^3$ in non-Abelian, the result is not a simplicial group but only a simplicial set. We verify that the $H_4$, which in principle should be isomorphic to $H_4 S^3 = 0$, is really null." ] }, { @@ -2037,7 +2037,7 @@ "Rank of the source-module : 1.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 1/1 (dimension 5) :\n", "<>]>> \n", "End of computing.\n", @@ -2051,7 +2051,7 @@ "\n", "---done---\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "\n" ] }, @@ -2074,7 +2074,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Let us end this short overview with an example of computation of homotopy groups. The method used in ``Kenzo`` is the Whitehead tower. An extended version of the Kenzo program due to Ana Romero is more general, but in this present version only the case where the first non-null homology group (in non-null dimension) is $\\mathbb{Z}$ or $\\mathbb{Z}/{2\\mathbb{Z}}$ can be processed; however if this homology group is a direct sum of several copies of $\\mathbb{Z}$ or $\\mathbb{Z}/{2 \\mathbb{Z}}$, then the corresponding stage of the Whitehead tower may also be constructed step by step.\n", + "Let us end this short overview with an example of computation of homotopy groups. The method used in `Kenzo` is the Whitehead tower. An extended version of the Kenzo program due to Ana Romero is more general, but in this present version only the case where the first non-null homology group (in non-null dimension) is $\\mathbb{Z}$ or $\\mathbb{Z}/{2\\mathbb{Z}}$ can be processed; however if this homology group is a direct sum of several copies of $\\mathbb{Z}$ or $\\mathbb{Z}/{2 \\mathbb{Z}}$, then the corresponding stage of the Whitehead tower may also be constructed step by step.\n", "\n", "We take again $\\mathrm{Moore}(\\mathbb{Z}/2\\mathbb{Z}, 3)$ whose $H_3$ is $\\mathbb{Z}/2\\mathbb{Z}$. First the fundamental cohomology class is constructed:" ] @@ -2105,7 +2105,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Then the function ``z2-whitehead`` is called to build a fibration over the simplicial set ``m23`` canonically associated to the cohomology class ``ch3``." + "Then the function `z2-whitehead` is called to build a fibration over the simplicial set `m23` canonically associated to the cohomology class `ch3`." ] }, { @@ -2182,13 +2182,13 @@ "Rank of the source-module : 2.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 1/2 (dimension 3) :\n", ">> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 2/2 (dimension 3) :\n", ">> \n", "End of computing.\n", @@ -2198,19 +2198,19 @@ "Rank of the source-module : 3.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 1/3 (dimension 4) :\n", ">> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 2/3 (dimension 4) :\n", ">> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 3/3 (dimension 4) :\n", ">> \n", "End of computing.\n", @@ -2224,26 +2224,26 @@ "\n", "---done---\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "\n", "\n", "Computing boundary-matrix in dimension 4.\n", "Rank of the source-module : 3.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 1/3 (dimension 4) :\n", ">> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 2/3 (dimension 4) :\n", ">> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 3/3 (dimension 4) :\n", ">> \n", "End of computing.\n", @@ -2253,25 +2253,25 @@ "Rank of the source-module : 4.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 1/4 (dimension 5) :\n", ">> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 2/4 (dimension 5) :\n", ">> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 3/4 (dimension 5) :\n", ">> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 4/4 (dimension 5) :\n", ">> \n", "End of computing.\n", @@ -2287,7 +2287,7 @@ "\n", "---done---\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "\n" ] }, @@ -2395,25 +2395,25 @@ "Rank of the source-module : 4.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 1/4 (dimension 4) :\n", ">> <>]>>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 2/4 (dimension 4) :\n", ">> <>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 3/4 (dimension 4) :\n", ">> <>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 4/4 (dimension 4) :\n", ">> <>> \n", "End of computing.\n", @@ -2423,43 +2423,43 @@ "Rank of the source-module : 7.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 1/7 (dimension 5) :\n", ">> <>]>>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 2/7 (dimension 5) :\n", ">> <>]>>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 3/7 (dimension 5) :\n", ">> <>]>>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 4/7 (dimension 5) :\n", ">> <>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 5/7 (dimension 5) :\n", ">> <>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 6/7 (dimension 5) :\n", ">> <>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 7/7 (dimension 5) :\n", ">> <>> \n", "End of computing.\n", @@ -2473,50 +2473,50 @@ "\n", "---done---\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "\n", "\n", "Computing boundary-matrix in dimension 5.\n", "Rank of the source-module : 7.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 1/7 (dimension 5) :\n", ">> <>]>>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 2/7 (dimension 5) :\n", ">> <>]>>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 3/7 (dimension 5) :\n", ">> <>]>>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 4/7 (dimension 5) :\n", ">> <>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 5/7 (dimension 5) :\n", ">> <>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 6/7 (dimension 5) :\n", ">> <>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 7/7 (dimension 5) :\n", ">> <>> \n", "End of computing.\n", @@ -2526,85 +2526,85 @@ "Rank of the source-module : 14.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 1/14 (dimension 6) :\n", ">> <>]>>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 2/14 (dimension 6) :\n", ">> <>]>>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 3/14 (dimension 6) :\n", ">> <>]>>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 4/14 (dimension 6) :\n", ">> <>][3 <>]>>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 5/14 (dimension 6) :\n", ">> <>]>>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 6/14 (dimension 6) :\n", ">> <>]>>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 7/14 (dimension 6) :\n", ">> <>]>>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 8/14 (dimension 6) :\n", ">> <>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 9/14 (dimension 6) :\n", ">> <>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 10/14 (dimension 6) :\n", ">> <>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 11/14 (dimension 6) :\n", ">> <>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 12/14 (dimension 6) :\n", ">> <>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 13/14 (dimension 6) :\n", ">> <>> \n", "End of computing.\n", "\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "Computing the boundary of the generator 14/14 (dimension 6) :\n", ">> <>> \n", "End of computing.\n", @@ -2620,7 +2620,7 @@ "\n", "---done---\n", "\n", - ";; Clock -> 2016-03-10, 2h 10m 52s.\n", + ";; Clock -> 2016-03-12, 0h 31m 16s.\n", "\n" ] },