From b9d65f477f825ca927a2ddc76161f305e229be03 Mon Sep 17 00:00:00 2001 From: Gerd Heber Date: Thu, 11 Feb 2016 22:31:41 -0500 Subject: [PATCH] Notebook updates. --- examples/Chapter1.ipynb | 1677 +++++++++++++++++++-------------------- 1 file changed, 810 insertions(+), 867 deletions(-) diff --git a/examples/Chapter1.ipynb b/examples/Chapter1.ipynb index 5fb8e1d..0d0d181 100644 --- a/examples/Chapter1.ipynb +++ b/examples/Chapter1.ipynb @@ -137,7 +137,7 @@ "data": { "image/png": "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", "text/plain": [ - "#" + "#" ] }, "execution_count": 4, @@ -161,27 +161,39 @@ "\n", "The elements of either of those groups $C_p$ are linear integer combinations of the corresponding basis (set of $\\sigma_i$'s), i.e., elements of the form\n", "$$\\sum\\lambda_i\\sigma_i, \\quad \\lambda_i\\in\\mathbb{Z}.$$\n", - "An element $\\sigma_i$ of any basis is also called a *generator* and in our specific case this generator will be represented by a Lisp symbol. For instance, $s_{45}$ will be translated into $\\texttt{s45}$. However, the user should be aware that in more realistic usage of the software, generators may be of any type. A product such as $\\lambda_i\\sigma_i$ is called a *term* and a sum of terms, a *combination*.\n", + "An element $\\sigma_i$ of any basis is also called a *generator* and in our specific case this generator will be represented by a Lisp symbol. For instance, $s_{45}$ will be translated into `s45`. However, the user should be aware that in more realistic usage of the software, generators may be of any type. A product such as $\\lambda_i\\sigma_i$ is called a *term* and a sum of terms, a *combination*.\n", "\n", "### Representation of a combination\n", "\n", "A combination is represented internally in the system by a structure having the following general form:\n", + "\n", "$$\\#\\texttt{S(CMBN}\\quad\\texttt{DEGREE P}\\quad\\texttt{LIST (}\\texttt{(}\\lambda_1\\cdot\\sigma_1\\texttt{)}\\dots\\texttt{(}\\lambda_k\\cdot\\sigma_k\\texttt{)))}$$\n", "and containing\n", "\n", "1. The degree of the combination corresponding to the index $p\\in\\mathbb{Z}$ of the group $C_p$ to which this combination belongs.\n", "2. The list of the internal representation of the terms, namely the list of pairs $(\\lambda_i\\cdot\\sigma_i)$.\n", "\n", - "This choice of representation implaies that only homogeneous combinations will be considered. A type $\\texttt{CMBN}$ and a printing method are provided with this internal representation. The external form of a combination is shown in the examples.\n", + "This choice of representation implaies that only homogeneous combinations will be considered. A type `CMBN` and a printing method are provided with this internal representation. The external form of a combination is shown in the examples.\n", "\n", "### Ordering the generators\n", "\n", - "In order to speed up the execution of algorithms involving combinations, the list of pairs $(\\lambda_i.\\sigma_i)$ is ordered by an adequate ordering function (ex: the lexicographical ordering n the symbols). For programming convenience, an enumerated type $\\texttt{CMPR}$ has been defined:\n", + "In order to speed up the execution of algorithms involving combinations, the list of pairs $(\\lambda_i.\\sigma_i)$ is ordered by an adequate ordering function (ex: the lexicographical ordering n the symbols). For programming convenience, an enumerated type `CMPR` has been defined:\n", "```lisp\n", "(deftype cmpr() '(member :less :equal :greater))\n", "```\n", - "A number of macros, functions and methods have been defined on usual sets (symbols, numbers, lists, etc.) taking their value in the set $\\texttt{[:less, :equal, :greater]}$. Of course, the user may define its own function for a particular case.\n", - "The functions $\\texttt{f-cmpr}$, $\\texttt{s-cmpr}$, and $\\texttt{l-cmpr}$ can be used to compare various couples of common items." + "A number of macros, functions and methods have been defined on usual sets (symbols, numbers, lists, etc.) taking their value in the set `[:less, :equal, :greater]`. Of course, the user may define its own function for a particular case. There exists functions to compare various couples of usual items:\n", + "\n", + "> *Function* `(f-cmpr n1 n2)`\n", + ">> Return `:less`, `:equal`, `:greater`, according to the result of the canonical comparison of both integers `n1` and `n2`.\n", + "\n", + "> *Function* `(s-cmpr symbol1 symbol2)`\n", + ">> Return `:less`, `:equal`, `:greater`, according to the result of the lisp comparison functions on the strings `(symbol-name symbol1)` and `(symbol-name symbol2)`\n", + "\n", + "> *Function* `(l-cmpr list1 list2)`\n", + ">> Return `:less`, `:equal`, `:greater`, according to the lexicographical ordering of the two lists `list1`\n", + "and `list2` representing legal generators in this implementation.\n", + "\n", + "#### Examples" ] }, { @@ -194,12 +206,7 @@ { "data": { "text/plain": [ - "\"--------------------------------------------------------------[function-doc]\n", - "F-CMPR\n", - "Args: (n1 n2)\n", - "Returns :LESS, :EQUAL, or :GREATER, according to the result of the canonical\n", - "comparison of the integers N1 and N2.\n", - "------------------------------------------------------------------------------\"" + ":LESS" ] }, "execution_count": 5, @@ -208,7 +215,7 @@ } ], "source": [ - "(documentation 'f-cmpr 'function)" + "(f-cmpr 123 789)" ] }, { @@ -221,7 +228,7 @@ { "data": { "text/plain": [ - ":LESS" + ":GREATER" ] }, "execution_count": 6, @@ -230,7 +237,7 @@ } ], "source": [ - "(f-cmpr 123 789)" + "(s-cmpr 'circulation 'circular)" ] }, { @@ -243,13 +250,7 @@ { "data": { "text/plain": [ - "\"--------------------------------------------------------------[function-doc]\n", - "S-CMPR\n", - "Args: (symbol1 symbol2)\n", - "Returns :LESS, :EQUAL, or :GREATER, according to the result of the Lisp string\n", - "comparison function of the strings (SYMBOL-NAME SYMBOL1) and\n", - "(SYMBOL-NAME SYMBOL2).\n", - "------------------------------------------------------------------------------\"" + ":EQUAL" ] }, "execution_count": 7, @@ -258,7 +259,7 @@ } ], "source": [ - "(documentation 's-cmpr 'function)" + "(s-cmpr 'qwerty 'qwerty)" ] }, { @@ -279,55 +280,6 @@ "output_type": "execute_result" } ], - "source": [ - "(s-cmpr 'circulation 'circular)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "\"--------------------------------------------------------------[function-doc]\n", - "L-CMPR\n", - "Args: (list1 list2)\n", - "Returns :LESS, :EQUAL, or :GREATER, according to the lexicographical ordering\n", - "of the generator lists LIST1 and LIST2.\n", - "------------------------------------------------------------------------------\"" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(documentation 'l-cmpr 'function)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - ":GREATER" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "(l-cmpr '(1 a b) '(1 a))" ] @@ -336,43 +288,62 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Functions handling combinations\n", + "1.2.3 Functions handling combinations\n", "\n", - "The software provides a set of functions, methods, and macros to create or modify combinations." + "The software provides a set of functions, methods, and macros to create or modify combinations.\n", + "\n", + "> *Macro* `(term-cmbn dgr cf gnr)`\n", + ">> Construct the combination of degree `dgr` with unique term `cf * gnr`.\n", + "\n", + "> *Function* `(cmbn dgr cf1 gnr1 cf2 gnr2 ... cfn gnrn)`\n", + ">> Construct a combination of degree `dgr`, sum of the terms $cf_i * gnr_i$. The sequence of pairs $\\lbrace cf_i\\ gnr_i\\rbrace$ has an undefinite length and may be void. In this case, the combination is a null combination of degree `dgr`. \n", + "\n", + "> *Function* `(cmbn-p object)`\n", + ">> Test is `object` is a legal combination.\n", + "\n", + "> *Macro* `(cmbn-degr cmbn)\n", + ">> Get the degree (an integer) of the combination `cmbn`.\n", + "\n", + "> *Macro* `(cmbn-list cmbn)`\n", + ">> Get the list of the terms of the combination `cmbn`. Beware: a term is not a `Kenzo` object. One may select the coefficient (an integer) or the generator - a `Kenzo` object - respectively by the macros `cffc` and `gnrt`.\n", + "\n", + "> *Function* `(zero-cmbn dgr)`\n", + ">> Create an instance of a null combination in the degree `dgr`.\n", + "\n", + "> *Function* `(zero-pure-dffr cmbn)`\n", + ">> Create a null combination of degree $degr(cmbn) - 1$.\n", + "\n", + "> *Macro* `(cmbn-zero-p cmbn)`\n", + ">> Test if `cmbn` is a null combination in any degree.\n", + "\n", + "> *Macro* `(cmbn-non-zero-p cmbn)`\n", + ">> Test if `cmbn` is a non-null combination in any degree.\n", + "\n", + "> *Function* `(cmbn-opps cmbn)`\n", + ">> Create a combination opposite to `cmbn`.\n", + "\n", + "> *Function* `(n-cmbn n cmbn)`\n", + ">> Create a combination multiple of `cmbn` by the factor `n`.\n", + "\n", + "> *Function* `(2cmbn-add cmpr cmbn1 cmbn2)`\n", + ">> Create a combination, sum of both combinations `cmbn1` and `cmbn2`. The first argument, `cmpr`, must be a function or macro relevant to compare the generators of the involved combinations, in order to return an ordered combination.\n", + "\n", + "> *Function* `(ncmbn-add cmpr cmbn1 cmbn2 ... cmbnk)`\n", + ">> Create a combination, sum of the indefinite number of combinations $cmbn_i$. As to the first argument, `cmpr`, see the function `2cmbn-add`.\n", + "\n", + "> *Function* `(2n-2cmbn cmpr n1 cmbn1 n2 cmbn2)`\n", + ">> Build the combination `n1 * cmbn1 + n2 * cmbn2`. Both integers `n1` and `n2` must be\n", + "non null. As to the first argument, `cmpr`, see the function `2cmbn-add`.\n", + "\n", + "> *Function* `(2cmbn-sbtr cmpr cmbn1 cmbn2)`\n", + ">> Create a combination, difference of `cmbn1` and `cmbn2`. As to the first argument, `cmpr`, see the function `2cmbn-add`.\n", + "\n", + "#### Examples" ] }, { "cell_type": "code", - "execution_count": 11, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "\"--------------------------------------------------------------[function-doc]\n", - "CMBN\n", - "Args: (degr &rest rest)\n", - "Returns a combination of degree DEGR from a sum of terms provided as a sequence\n", - "CF1 GNRT1 CF2 GNRT2 ... CFn GNRTn of coefficient / generator pairs in REST.\n", - "REST can be of arbitrary length including NIL, in which case the combination\n", - "is an instance of the null combination of degree DEGR.\n", - "------------------------------------------------------------------------------\"" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(documentation 'cmbn 'function)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, + "execution_count": 9, "metadata": { "collapsed": false }, @@ -389,7 +360,7 @@ "------------------------------------------------------------------------------\n" ] }, - "execution_count": 12, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -398,6 +369,72 @@ "(def comb1 (cmbn 1 1 'u 2 'v 3 'w 4 'z))" ] }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "T" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(cmbn-non-zero-p comb1)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "((1 . U) (2 . V) (3 . W) (4 . Z))" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(cmbn-list comb1)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(3 . W)" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(def term3 (third *)) ;; not a Kenzo object!" + ] + }, { "cell_type": "code", "execution_count": 13, @@ -408,11 +445,7 @@ { "data": { "text/plain": [ - "\"-----------------------------------------------------------------[macro-doc]\n", - "CMBN-NON-ZERO-P\n", - "Args: (cmbn)\n", - "Tests if the combination CMBN is a non-null combination of any degree.\n", - "------------------------------------------------------------------------------\"" + "3" ] }, "execution_count": 13, @@ -421,7 +454,7 @@ } ], "source": [ - "(documentation 'cmbn-non-zero-p 'function)" + "(cffc term3)" ] }, { @@ -430,153 +463,6 @@ "metadata": { "collapsed": false }, - "outputs": [ - { - "data": { - "text/plain": [ - "T" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(cmbn-non-zero-p comb1)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The reader function $\\texttt{cat:cmbn-list}$ gets the list of terms of the combination $\\texttt{cmbn}$. Beware: a term is not a Kenzo object." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "((1 . U) (2 . V) (3 . W) (4 . Z))" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(cmbn-list comb1)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "(3 . W)" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(def term3 (third (cmbn-list comb1)))" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "\"-----------------------------------------------------------------[macro-doc]\n", - "CFFC\n", - "Args: (term)\n", - "Returns the the coefficient (integer) of a term.\n", - "------------------------------------------------------------------------------\"" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(documentation 'cffc 'function)" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "3" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(cffc term3)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "\"-----------------------------------------------------------------[macro-doc]\n", - "GNRT\n", - "Args: (term)\n", - "Returns the the generator of a term.\n", - "------------------------------------------------------------------------------\"" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(documentation 'gnrt 'function)" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": { - "collapsed": false - }, "outputs": [ { "data": { @@ -584,7 +470,7 @@ "W" ] }, - "execution_count": 20, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -595,33 +481,7 @@ }, { "cell_type": "code", - "execution_count": 21, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "\"--------------------------------------------------------------[function-doc]\n", - "CMBN-OPPS\n", - "Args: (cmbn)\n", - "Returns the combination opposite combination of CMBN.\n", - "------------------------------------------------------------------------------\"" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(documentation 'cmbn-opps 'function)" - ] - }, - { - "cell_type": "code", - "execution_count": 22, + "execution_count": 15, "metadata": { "collapsed": false }, @@ -638,7 +498,7 @@ "------------------------------------------------------------------------------\n" ] }, - "execution_count": 22, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -649,33 +509,7 @@ }, { "cell_type": "code", - "execution_count": 23, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "\"--------------------------------------------------------------[function-doc]\n", - "N-CMBN\n", - "Args: (n cmbn)\n", - "Returns N times the combination CMBN. N must be non-zero.\n", - "------------------------------------------------------------------------------\"" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(documentation 'n-cmbn 'function)" - ] - }, - { - "cell_type": "code", - "execution_count": 24, + "execution_count": 16, "metadata": { "collapsed": false }, @@ -692,7 +526,7 @@ "------------------------------------------------------------------------------\n" ] }, - "execution_count": 24, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -703,36 +537,7 @@ }, { "cell_type": "code", - "execution_count": 25, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "\"--------------------------------------------------------------[function-doc]\n", - "2CMBN-ADD\n", - "Args: (cmpr cmbn1 cmbn2)\n", - "Returns the combination, which is the sum of CMBN1 and CMBN2. The first\n", - "argument, CMPR, must be a function or macro, which is used to compare the\n", - "generators of the combination arguments and to order the terms of the result\n", - "combination.\n", - "------------------------------------------------------------------------------\"" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(documentation '2cmbn-add 'function)" - ] - }, - { - "cell_type": "code", - "execution_count": 26, + "execution_count": 17, "metadata": { "collapsed": false }, @@ -749,7 +554,7 @@ "------------------------------------------------------------------------------\n" ] }, - "execution_count": 26, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -760,7 +565,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 18, "metadata": { "collapsed": false }, @@ -768,56 +573,27 @@ { "data": { "text/plain": [ - "\"--------------------------------------------------------------[function-doc]\n", - "2CMBN-SBTR\n", - "Args: (cmpr cmbn1 cmbn2)\n", - "Returns the combination, which is the difference of CMBN1 and CMBN2. The first\n", - "argument, CMPR, must be a function or macro, which is used to compare the\n", - "generators of the combination arguments and to order the terms of the result\n", - "combination.\n", - "------------------------------------------------------------------------------\"" + "\n", + "----------------------------------------------------------------------{CMBN 1}\n", + "<-10 * U>\n", + "<-20 * V>\n", + "<-30 * W>\n", + "<-40 * Z>\n", + "------------------------------------------------------------------------------\n" ] }, - "execution_count": 27, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "(documentation '2cmbn-sbtr 'function)" + "(2cmbn-sbtr #'s-cmpr comb1 cmb12)" ] }, { "cell_type": "code", - "execution_count": 28, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "\"--------------------------------------------------------------[function-doc]\n", - "NCMBN-ADD\n", - "Args: (cmpr cmbn &rest rest)\n", - "Returns the sum of an arbitrary number of combinations. The first argument,\n", - "CMPR, must be a function or macro, which is used to compare the generators of\n", - "the input combinations and to order the terms of the result combination.\n", - "------------------------------------------------------------------------------\"" - ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(documentation 'ncmbn-add 'function)" - ] - }, - { - "cell_type": "code", - "execution_count": 29, + "execution_count": 19, "metadata": { "collapsed": false }, @@ -834,7 +610,7 @@ "------------------------------------------------------------------------------\n" ] }, - "execution_count": 29, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -850,14 +626,69 @@ "source": [ "## Representation of a chain complex\n", "\n", - "### The function build-chcm\n", + "A chain complex is implemented as an instance of a `CLOS` class, \n", + "the class `CHAIN-COMPLEX`, whose definition is\n", "\n", - "#### A first example of a chain complex" + "```lisp\n", + "(DEFCLASS CHAIN-COMPLEX ()\n", + " ((cmpr :type cmprf :initarg :cmpr :reader cmpr1)\n", + " (basis :type basis :initarg :basis :reader basis1)\n", + " ;; BaSe GeNerator\n", + " (bsgn :type gnrt :initarg :bsgn :reader bsgn)\n", + " ;; DiFFeRential\n", + " (dffr :type morphism :initarg :dffr :reader dffr1)\n", + " ;; GRound MoDule\n", + " (grmd :type chain-complex :initarg :grmd :reader grmd)\n", + " ;; EFfective HoMology\n", + " (efhm :type homotopy-equivalence :initarg :efhm :reader efhm)\n", + " ;; IDentification NuMber\n", + " (idnm :type fixnum :initform (incf *idnm-counter*) :reader idnm)\n", + " ;; ORiGiN\n", + " (orgn :type list :initarg :orgn :reader orgn)))\n", + "```\n", + "\n", + "This class has 8 slots:\n", + "\n", + "1. `cmpr`, a comparison function or method for generators with a range in the set `[:less, :equal, :greater]`. It is very important to note that the generators to be compared are assumed to be of the *same degree*, i.e. they must belong to the same group $C_p$. As an exception with the general policy of the software, this degree is not explicitly precised. The implementor has chosen to avoid additional tests because in real problems the program spends a lot of time comparing generators.\n", + "2. `basis`, a lisp function giving the distinguished **ordered** basis of the free $\\mathbb{Z}$-modules ($C_p$). (Recall that in the software, only free chain complexes are considered.) When some components of the chain complex are not finitely generated, we say that the chain complex is *locally effective*. In this case the value of this slot must be the keyword `locally-effective`.\n", + "3. `bsgn`, a lisp object of any type representing a distinguished generator in dimension 0, the base generator. \n", + "4. `dffr`, the differential morphism, instance of the class `MORPHISM`, defined hereafter. The pure lisp function corresponding to the differential homomorphism for each $p$ ($d_p : C_p \\rightarrow C_{p-1}$) is defined in the instance morphism object and not directly in the instance chain complex object.\n", + "5. `idnm`, an integer, number plate for this object. This is generated by the system in a sequential way, each time a new `Kenzo` object is created.\n", + "6. `orgn`, a list containing a comment to recall to the user the *origin* of the object. This comment must be chosen with care because, when the user creates a new chain complex instance, the system `Kenzo` uses the comment list information to search in a specific list (here `*chcm-list*`) if the object has not been already built. So, one avoids the duplication of instances of the same object.\n", + "\n", + "The two slots `grmd` and `efhm` will be explained later. The accessors of the slots are the functions whose name appears after the specifier `:reader` in the class definition. A printing method has been associated to the class `CHAIN-COMPLEX` and the external representation of a chain complex instance is a string like `[Kn Chain-Complex]`, \n", + "where `n` is the number plate of this `Kenzo` object.\n", + "\n", + "\n", + "### The function `build-chcm`\n", + "\n", + "To facilitate the construction of instances of the class `CHAIN-COMPLEX` and to free the user to call\n", + "the standard constructor `make-instance`, the software provides the function\n", + "\n", + "```lisp\n", + "build-chcm :cmpr cmpr :basis basis :bsgn bsgn :intr-dffr intr-dffr :strt strt :orgn orgn\n", + "```\n", + "\n", + "defined with keyword parameters. The returned value is an instance of the class `CHAIN-COMPLEX`. In particular, this function frees the user to build himself the instance of the class `MORPHISM` corresponding to the differential homomorphism. The keyword arguments of `build-chcm` are:\n", + "\n", + "- `cmpr`, the comparison function for generators.\n", + "- `basis`, the function defining the distinguished basis of the free $\\mathbb{Z}$-modules $C_p$ or the keyword `:locally-effective`.\n", + "- `bsgn`, a generator, the base point of the underlying set.\n", + "- `intr-dffr`, a **lisp function** defining the differential homomorphism for each $p$ ($d_p : C_p \\rightarrow C_{p-1}$).\n", + "- `strt`, one of the two values: `:gnrt` or `:cmbn`, defining the mapping *strategy* of the differential homomorphism, either by generator or by combination. The default is `:gnrt`. The real connection between the arguments `intr-dffr` and `strt`will be detailed hereafter through typical examples. The general idea is the following: if the strategy is `:gnrt`, the `:intr-dffr` argument function uses two arguments, namely a degree and a generator of this degree and computes the boundary combination of this generator. If the strategy is `:cmbn`, the `:intr-dffr` argument function uses a combination as argument and computes the boundary combination of this argument. We recall that a combination contains its own degree.\n", + "- `orgn`, a list containing a relevant and carefully chosen comment about the `origin` of the chain complex. If, during a Lisp session, the user wishes to modify any slot of an existing chain complex, by calling again `build-chcm`, he must change also the comment, otherwise the new version of the object will not be created. This remark is valid for any kind of instantiation of `Kenzo` objects. For avoiding such a constraint, one may use the function `cat-init`, before the redefinition.\n", + "\n", + "After creation of an instance of chain complex, the function `build-chcm` pushes this\n", + "object in the list of already created chain complexes `*chcm-list*`.\n", + "\n", + "#### A first example of a chain complex\n", + "\n", + "Let us consider our small example *diabolo*. We shall give the same name to the corresponding chain complex instance. Let us define, one by one, the values of the key parameters, though it is possible to put them directly in the `build-chcm` call. First, the function `s-cmpr`, already seen above, is the natural choice to compare generators, which are here, lisp symbols:" ] }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 20, "metadata": { "collapsed": false }, @@ -868,7 +699,7 @@ "#" ] }, - "execution_count": 30, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -877,9 +708,16 @@ "(def diabolo-cmpr #'s-cmpr)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The function for the basis consists in enumerating the distinguished basis as lisp lists according to the degree:" + ] + }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 21, "metadata": { "collapsed": false }, @@ -887,10 +725,10 @@ { "data": { "text/plain": [ - "#" + "#" ] }, - "execution_count": 31, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } @@ -904,9 +742,16 @@ " (otherwise nil))))" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For the base point, we may choose any vertex:" + ] + }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 22, "metadata": { "collapsed": false }, @@ -917,7 +762,7 @@ "S0" ] }, - "execution_count": 32, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -926,9 +771,20 @@ "(def diabolo-bspn 's0)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The lisp function for the differential homomorphism, also called boundary homomorphism, computes the boundary of each generator, in this case, according to the classical (simplicial) rule:\n", + "\n", + "$$ {\\bf d}[{s_0s_1\\ldots s_n}] = \\sum_{i=0}^n{(-1)^is_0s_1\\ldots\\widehat{s_i}\\ldots s_n}.$$\n", + "\n", + "It must be noted that our differential uses a predefined choice for the order of the vertices." + ] + }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 23, "metadata": { "collapsed": false }, @@ -936,10 +792,10 @@ { "data": { "text/plain": [ - "#" + "#" ] }, - "execution_count": 33, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } @@ -964,9 +820,16 @@ " (otherwise (error \"Bad generator for complex diabolo\")))))" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The strategy is by generator and the comment recalls the name of the problem:" + ] + }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 24, "metadata": { "collapsed": false }, @@ -977,7 +840,7 @@ ":GNRT" ] }, - "execution_count": 34, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -988,7 +851,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 25, "metadata": { "collapsed": false }, @@ -999,7 +862,7 @@ "(DIABOLO-FOR-EXAMPLE)" ] }, - "execution_count": 35, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -1009,59 +872,15 @@ ] }, { - "cell_type": "code", - "execution_count": 36, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "\"--------------------------------------------------------------[function-doc]\n", - "BUILD-CHCM\n", - "Args: (&key cmpr basis bsgn intr-dffr strt orgn)\n", - "Returns an instance of the class CHAIN-COMPLEX. The keyword arguments are as\n", - "follows:\n", - "\n", - ":CMPR CMPR, the comparison function for generators\n", - "\n", - ":BASIS BASIS, the function defining the basis of the freee Z-modules C_p or the\n", - " the keyword :LOCALLY-EFFECTIVE\n", - "\n", - ":BSGN BSGN, a generator, the base point of the underlying set\n", - "\n", - ":INTR-DFFR INTR-DFFR, a Lisp function defining the differential homomorphism\n", - " for each p (d_p: C_p -> C_{p-1}\n", - "\n", - ":STRT STRT, one of the keywords :GNRT or :CMBN, defining the mapping strategy\n", - " of the differential homomorphism, either by generator or by\n", - " combination. The default is :GNRT\n", - "\n", - ":ORGN ORGN, a list which is the copy of a Lisp statement, in principle the\n", - " statement which was at the origin of the creation of this Kenzo\n", - " object. A caching process, using this slot, prevents the creation\n", - " of multiple copies of the same mathematical object, which is\n", - " important for efficiency. It is used also for debugging and\n", - " analyzing the program.\n", - "\n", - "Use this function instead of creating instances via the standard constructor\n", - "MAKE-INSTANCE.\n", - "------------------------------------------------------------------------------\"" - ] - }, - "execution_count": 36, - "metadata": {}, - "output_type": "execute_result" - } - ], + "cell_type": "markdown", + "metadata": {}, "source": [ - "(documentation 'build-chcm 'function)" + "The effective call to `build-chcm` is now reduced to:" ] }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 26, "metadata": { "collapsed": false }, @@ -1072,7 +891,7 @@ "[K1 Chain-Complex]" ] }, - "execution_count": 37, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -1083,9 +902,40 @@ " :strt diabolo-strt :orgn diabolo-orgn))" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The value of the symbol `diabolo` is the `CHAIN-COMPLEX` instance which is here the first created `Kenzo` object. The string `[K1 Chain-Complex]` is printed by the printing method associated to the class.\n", + "\n", + "### Simple functions handling chain complexes\n", + "\n", + "> *Function* `(cat-init)`\n", + ">> Clear among others, the list `*chcm-list*`, list of user created chain complexes and reset the global counter to 1. The existing objects and in particular here the chain complexes, are not destroyed but they will not enter any more in account during the search process for duplicated objects. This remark is general for the other types of objects saved in specific lists. \n", + "\n", + "> *Functions* `(chcm n)`\n", + ">> Return from the list `*chcm-list*` the chain complex instance whose the Kenzo identification is `n`; if it does not exist, return `NIL`.\n", + "\n", + "> *Macro* `(cmpr object item1 item2)`\n", + ">> Apply the comparison function associated to the chain complex `object` to the two generators `item1` and `item2`.\n", + "\n", + "> *Macro* `(basis object n :dgnr)\n", + ">> With only one argument (`object`), get the function attached to the slot `basis` of the chain complex object. With two arguments, get the distinguished basis of the group of degree `n` in the chain complex `object`. If the chain complex is locally effective, this function returns an error because, in some degrees, the corresponding set of generators is probably infinite. With a third argument, the keyword `:dgnr`, get also the *degenerate* elements of the basis in degree `n`.\n", + "\n", + "> *Macro* `(dffr chcm &rest)`\n", + ">> Versatile macro to apply the differential morphism of the chain complex `chcm` either to a combination or a generator with a degree, respectively `(dffr chcm cmbn)` or `(dffr chcm degr gnrt)`. The macro `?`, described later, may be used for the same purpose.\n", + "\n", + "> *Function* `(z-chcm)`\n", + ">> Build the unit chain complex (see hereafter).\n", + "\n", + "#### Examples\n", + "\n", + "Let us apply some accessors functions and the simple functions above to the chain complex `diabolo`. First, we see that the list `*chcm-list*` contains only one element, namely the chain complex just created." + ] + }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 27, "metadata": { "collapsed": false }, @@ -1093,26 +943,21 @@ { "data": { "text/plain": [ - "\"--------------------------------------------------------------[function-doc]\n", - "CHCM\n", - "Args: (idnm)\n", - "Return from the list *CHCM-LIST* the chain complex instance with Kenzo\n", - "identifier IDNUM or NIL, if it doesn't exist.\n", - "------------------------------------------------------------------------------\"" + "([K1 Chain-Complex])" ] }, - "execution_count": 38, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "(documentation 'chcm 'function)" + "*chcm-list*" ] }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 28, "metadata": { "collapsed": false }, @@ -1123,7 +968,7 @@ "[K1 Chain-Complex]" ] }, - "execution_count": 39, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } @@ -1134,7 +979,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 29, "metadata": { "collapsed": false }, @@ -1145,7 +990,7 @@ "(DIABOLO-FOR-EXAMPLE)" ] }, - "execution_count": 40, + "execution_count": 29, "metadata": {}, "output_type": "execute_result" } @@ -1156,7 +1001,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 30, "metadata": { "collapsed": false }, @@ -1167,7 +1012,7 @@ "1" ] }, - "execution_count": 41, + "execution_count": 30, "metadata": {}, "output_type": "execute_result" } @@ -1178,7 +1023,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 31, "metadata": { "collapsed": false }, @@ -1189,7 +1034,7 @@ "(S0 S1 S2 S3 S4 S5)" ] }, - "execution_count": 42, + "execution_count": 31, "metadata": {}, "output_type": "execute_result" } @@ -1200,7 +1045,7 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 32, "metadata": { "collapsed": false }, @@ -1211,7 +1056,7 @@ "(S01 S02 S12 S23 S34 S35 S45)" ] }, - "execution_count": 43, + "execution_count": 32, "metadata": {}, "output_type": "execute_result" } @@ -1222,7 +1067,7 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 33, "metadata": { "collapsed": false }, @@ -1233,7 +1078,7 @@ "(S345)" ] }, - "execution_count": 44, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" } @@ -1244,7 +1089,7 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 34, "metadata": { "collapsed": false }, @@ -1255,7 +1100,7 @@ "NIL" ] }, - "execution_count": 45, + "execution_count": 34, "metadata": {}, "output_type": "execute_result" } @@ -1266,7 +1111,7 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 35, "metadata": { "collapsed": false }, @@ -1282,7 +1127,7 @@ "------------------------------------------------------------------------------\n" ] }, - "execution_count": 46, + "execution_count": 35, "metadata": {}, "output_type": "execute_result" } @@ -1293,7 +1138,7 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 36, "metadata": { "collapsed": false }, @@ -1306,7 +1151,7 @@ "------------------------------------------------------------------------------\n" ] }, - "execution_count": 47, + "execution_count": 36, "metadata": {}, "output_type": "execute_result" } @@ -1319,12 +1164,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### An important trivial case: the unit chain complex, $\\mathbb{Z}$" + "#### An important trivial case: the unit chain complex, $\\mathbb{Z}$\n", + "\n", + "The unit chain complex, has a unique non null component, namely a $\\mathbb{Z}$-module of degree 0 generated by a unique generator, called here `:Z-gnrt`. It is defined by the following call to `build-chcm`:" ] }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 37, "metadata": { "collapsed": false }, @@ -1335,7 +1182,7 @@ "[K3 Chain-Complex]" ] }, - "execution_count": 48, + "execution_count": 37, "metadata": {}, "output_type": "execute_result" } @@ -1358,41 +1205,35 @@ ] }, { - "cell_type": "code", - "execution_count": 49, + "cell_type": "markdown", "metadata": { "collapsed": false }, - "outputs": [ - { - "data": { - "text/plain": [ - "\"--------------------------------------------------------------[function-doc]\n", - "Z-CHCM\n", - "Args: ()\n", - "Build the unit chain complex.\n", - "------------------------------------------------------------------------------\"" - ] - }, - "execution_count": 49, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ - "(documentation 'z-chcm 'function)" + "In this definition,\n", + "\n", + "1. The `:cmpr` keyword argument is a function returning `:equal` on any pair on generators (because there is a unique generator!).\n", + "2. The `:basis` keyword argument is a lisp function returning the null basis (the constant `+empty-list+ = ()`) for $p \\not= 0$ and the list `(:Z-gnrt)`, for $p=0$.\n", + "3. The base generator is of course `Z-gnrt`.\n", + "4. The `:intr-dffr` keyword argument is a lisp function defining the differential which, to any combination of degre $p$ of the chain complex, returns a *null combination* of degree $p-1$. This simple lisp function is also provided in `Kenzo` and is called `zero-intr-dffr`.\n", + "5. The `:strt` keyword argument is the combination strategy (`:cmbn`).\n", + "6. The `:orgn` keyword argument is the comment list `(zcc-constant)`.\n", + "\n", + "In the software `Kenzo`, the chain complex instance `ZCC` may be built, when needed, by the lisp statement: `(z-chcm)`. This statement may be used freely each time one needs this chain complex, since the system recognizes if it has already been created." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#### The chain complex $\\texttt{circle}$" + "#### The chain complex `circle`\n", + "\n", + "On the model of the previous chain complex, one may define a function `circle` for building a chain complex having the same homology as the circle." ] }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 38, "metadata": { "collapsed": false }, @@ -1402,7 +1243,7 @@ "output_type": "stream", "text": [ "REDEFINITION-WITH-DEFUN: \n", - " #\n" + " #\n" ] }, { @@ -1411,7 +1252,7 @@ "CIRCLE" ] }, - "execution_count": 50, + "execution_count": 38, "metadata": {}, "output_type": "execute_result" } @@ -1442,7 +1283,7 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 39, "metadata": { "collapsed": false }, @@ -1501,7 +1342,7 @@ "-----------------------------------------------------------------------------\"" ] }, - "execution_count": 51, + "execution_count": 39, "metadata": {}, "output_type": "execute_result" } @@ -1519,7 +1360,7 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 40, "metadata": { "collapsed": false }, @@ -1557,7 +1398,7 @@ "------------------------------------------------------------------------------\"" ] }, - "execution_count": 52, + "execution_count": 40, "metadata": {}, "output_type": "execute_result" } @@ -1575,7 +1416,7 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 41, "metadata": { "collapsed": false }, @@ -1594,7 +1435,7 @@ "NIL" ] }, - "execution_count": 53, + "execution_count": 41, "metadata": {}, "output_type": "execute_result" } @@ -1605,7 +1446,7 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 42, "metadata": { "collapsed": false }, @@ -1616,7 +1457,7 @@ "[K1 Chain-Complex]" ] }, - "execution_count": 54, + "execution_count": 42, "metadata": {}, "output_type": "execute_result" } @@ -1627,7 +1468,7 @@ }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 43, "metadata": { "collapsed": false }, @@ -1638,7 +1479,7 @@ "[K3 Cohomology-Class on K1 of degree 1]" ] }, - "execution_count": 55, + "execution_count": 43, "metadata": {}, "output_type": "execute_result" } @@ -1655,7 +1496,7 @@ }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 44, "metadata": { "collapsed": false }, @@ -1666,7 +1507,7 @@ "[K4 Cohomology-Class on K1 of degree 0]" ] }, - "execution_count": 56, + "execution_count": 44, "metadata": {}, "output_type": "execute_result" } @@ -1691,7 +1532,7 @@ }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 45, "metadata": { "collapsed": false }, @@ -1699,10 +1540,10 @@ { "data": { "text/plain": [ - "#" + "#" ] }, - "execution_count": 57, + "execution_count": 45, "metadata": {}, "output_type": "execute_result" } @@ -1716,7 +1557,7 @@ }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 46, "metadata": { "collapsed": false }, @@ -1727,7 +1568,7 @@ "[K5 Chain-Complex]" ] }, - "execution_count": 58, + "execution_count": 46, "metadata": {}, "output_type": "execute_result" } @@ -1743,7 +1584,7 @@ }, { "cell_type": "code", - "execution_count": 59, + "execution_count": 47, "metadata": { "collapsed": false }, @@ -1754,7 +1595,7 @@ "[K7 Morphism (degree 1): K5 -> K5]" ] }, - "execution_count": 59, + "execution_count": 47, "metadata": {}, "output_type": "execute_result" } @@ -1768,7 +1609,7 @@ }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 48, "metadata": { "collapsed": false }, @@ -1779,7 +1620,7 @@ "[K8 Morphism (degree -1): K5 -> K5]" ] }, - "execution_count": 60, + "execution_count": 48, "metadata": {}, "output_type": "execute_result" } @@ -1793,7 +1634,7 @@ }, { "cell_type": "code", - "execution_count": 61, + "execution_count": 49, "metadata": { "collapsed": false }, @@ -1807,7 +1648,7 @@ "------------------------------------------------------------------------------\n" ] }, - "execution_count": 61, + "execution_count": 49, "metadata": {}, "output_type": "execute_result" } @@ -1818,7 +1659,7 @@ }, { "cell_type": "code", - "execution_count": 62, + "execution_count": 50, "metadata": { "collapsed": false }, @@ -1831,7 +1672,7 @@ "------------------------------------------------------------------------------\n" ] }, - "execution_count": 62, + "execution_count": 50, "metadata": {}, "output_type": "execute_result" } @@ -1842,7 +1683,7 @@ }, { "cell_type": "code", - "execution_count": 63, + "execution_count": 51, "metadata": { "collapsed": false }, @@ -1858,7 +1699,7 @@ "------------------------------------------------------------------------------\n" ] }, - "execution_count": 63, + "execution_count": 51, "metadata": {}, "output_type": "execute_result" } @@ -1869,7 +1710,7 @@ }, { "cell_type": "code", - "execution_count": 64, + "execution_count": 52, "metadata": { "collapsed": false }, @@ -1884,7 +1725,7 @@ "------------------------------------------------------------------------------\n" ] }, - "execution_count": 64, + "execution_count": 52, "metadata": {}, "output_type": "execute_result" } @@ -1895,7 +1736,7 @@ }, { "cell_type": "code", - "execution_count": 65, + "execution_count": 53, "metadata": { "collapsed": false }, @@ -1908,7 +1749,7 @@ "------------------------------------------------------------------------------\n" ] }, - "execution_count": 65, + "execution_count": 53, "metadata": {}, "output_type": "execute_result" } @@ -1919,7 +1760,7 @@ }, { "cell_type": "code", - "execution_count": 66, + "execution_count": 54, "metadata": { "collapsed": false }, @@ -1933,7 +1774,7 @@ "------------------------------------------------------------------------------\n" ] }, - "execution_count": 66, + "execution_count": 54, "metadata": {}, "output_type": "execute_result" } @@ -1944,7 +1785,7 @@ }, { "cell_type": "code", - "execution_count": 67, + "execution_count": 55, "metadata": { "collapsed": false }, @@ -1958,7 +1799,7 @@ "------------------------------------------------------------------------------\n" ] }, - "execution_count": 67, + "execution_count": 55, "metadata": {}, "output_type": "execute_result" } @@ -1969,7 +1810,7 @@ }, { "cell_type": "code", - "execution_count": 68, + "execution_count": 56, "metadata": { "collapsed": false }, @@ -1983,7 +1824,7 @@ "------------------------------------------------------------------------------\n" ] }, - "execution_count": 68, + "execution_count": 56, "metadata": {}, "output_type": "execute_result" } @@ -1994,7 +1835,7 @@ }, { "cell_type": "code", - "execution_count": 69, + "execution_count": 57, "metadata": { "collapsed": false }, @@ -2011,7 +1852,7 @@ "------------------------------------------------------------------------------\n" ] }, - "execution_count": 69, + "execution_count": 57, "metadata": {}, "output_type": "execute_result" } @@ -2020,6 +1861,290 @@ "(def comb1 (cmbn 1 1 10 2 11 3 12 4 13))" ] }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[K9 Morphism (degree 0): K5 -> K5]" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(def identity? (cmps upper-shift lower-shift))" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(degr identity?)" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "\n", + "----------------------------------------------------------------------{CMBN 1}\n", + "<1 * 10>\n", + "<2 * 11>\n", + "<3 * 12>\n", + "<4 * 13>\n", + "------------------------------------------------------------------------------\n" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(? identity? comb1)" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "\n", + "----------------------------------------------------------------------{CMBN 1}\n", + "------------------------------------------------------------------------------\n" + ] + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(2cmbn-sbtr (cmpr ccn) comb1 *)" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[K10 Morphism (degree 2): K5 -> K5]" + ] + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(def upper-shift2 (cmps upper-shift upper-shift))" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "2" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(degr upper-shift2)" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "\n", + "----------------------------------------------------------------------{CMBN 3}\n", + "<1 * 30>\n", + "<2 * 31>\n", + "<3 * 32>\n", + "<4 * 33>\n", + "------------------------------------------------------------------------------\n" + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(? upper-shift2 comb1)" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[K11 Morphism (degree 1): K5 -> K5]" + ] + }, + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(def twice-up-shift (add upper-shift upper-shift))" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 66, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(degr twice-up-shift)" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "\n", + "----------------------------------------------------------------------{CMBN 2}\n", + "<2 * 20>\n", + "<4 * 21>\n", + "<6 * 22>\n", + "<8 * 23>\n", + "------------------------------------------------------------------------------\n" + ] + }, + "execution_count": 67, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(? twice-up-shift comb1)" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[K12 Morphism (degree 0): K5 -> K5]" + ] + }, + "execution_count": 68, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(def up-d (cmps upper-shift (dffr1 ccn)))" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[K13 Morphism (degree 0): K5 -> K5]" + ] + }, + "execution_count": 69, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(def d-up (cmps (dffr1 ccn) upper-shift))" + ] + }, { "cell_type": "code", "execution_count": 70, @@ -2030,7 +2155,10 @@ { "data": { "text/plain": [ - "[K9 Morphism (degree 0): K5 -> K5]" + "\n", + "----------------------------------------------------------------------{CMBN 1}\n", + "<1 * 11>\n", + "------------------------------------------------------------------------------\n" ] }, "execution_count": 70, @@ -2039,7 +2167,7 @@ } ], "source": [ - "(def identity? (cmps upper-shift lower-shift))" + "(? up-d 1 11)" ] }, { @@ -2052,7 +2180,9 @@ { "data": { "text/plain": [ - "0" + "\n", + "----------------------------------------------------------------------{CMBN 1}\n", + "------------------------------------------------------------------------------\n" ] }, "execution_count": 71, @@ -2061,7 +2191,7 @@ } ], "source": [ - "(degr identity?)" + "(? d-up 1 11)" ] }, { @@ -2080,6 +2210,8 @@ "<2 * 11>\n", "<3 * 12>\n", "<4 * 13>\n", + "<5 * 14>\n", + "<6 * 15>\n", "------------------------------------------------------------------------------\n" ] }, @@ -2089,7 +2221,7 @@ } ], "source": [ - "(? identity? comb1)" + "(def comb3 (cmbn 1 1 10 2 11 3 12 4 13 5 14 6 15))" ] }, { @@ -2104,6 +2236,9 @@ "text/plain": [ "\n", "----------------------------------------------------------------------{CMBN 1}\n", + "<2 * 11>\n", + "<4 * 13>\n", + "<6 * 15>\n", "------------------------------------------------------------------------------\n" ] }, @@ -2113,7 +2248,7 @@ } ], "source": [ - "(2cmbn-sbtr (cmpr ccn) comb1 *)" + "(? up-d comb3)" ] }, { @@ -2126,7 +2261,12 @@ { "data": { "text/plain": [ - "[K10 Morphism (degree 2): K5 -> K5]" + "\n", + "----------------------------------------------------------------------{CMBN 1}\n", + "<1 * 10>\n", + "<3 * 12>\n", + "<5 * 14>\n", + "------------------------------------------------------------------------------\n" ] }, "execution_count": 74, @@ -2134,305 +2274,6 @@ "output_type": "execute_result" } ], - "source": [ - "(def upper-shift2 (cmps upper-shift upper-shift))" - ] - }, - { - "cell_type": "code", - "execution_count": 75, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "2" - ] - }, - "execution_count": 75, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(degr upper-shift2)" - ] - }, - { - "cell_type": "code", - "execution_count": 76, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "\n", - "----------------------------------------------------------------------{CMBN 3}\n", - "<1 * 30>\n", - "<2 * 31>\n", - "<3 * 32>\n", - "<4 * 33>\n", - "------------------------------------------------------------------------------\n" - ] - }, - "execution_count": 76, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(? upper-shift2 comb1)" - ] - }, - { - "cell_type": "code", - "execution_count": 77, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[K11 Morphism (degree 1): K5 -> K5]" - ] - }, - "execution_count": 77, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(def twice-up-shift (add upper-shift upper-shift))" - ] - }, - { - "cell_type": "code", - "execution_count": 78, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "1" - ] - }, - "execution_count": 78, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(degr twice-up-shift)" - ] - }, - { - "cell_type": "code", - "execution_count": 79, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "\n", - "----------------------------------------------------------------------{CMBN 2}\n", - "<2 * 20>\n", - "<4 * 21>\n", - "<6 * 22>\n", - "<8 * 23>\n", - "------------------------------------------------------------------------------\n" - ] - }, - "execution_count": 79, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(? twice-up-shift comb1)" - ] - }, - { - "cell_type": "code", - "execution_count": 80, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[K12 Morphism (degree 0): K5 -> K5]" - ] - }, - "execution_count": 80, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(def up-d (cmps upper-shift (dffr1 ccn)))" - ] - }, - { - "cell_type": "code", - "execution_count": 81, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[K13 Morphism (degree 0): K5 -> K5]" - ] - }, - "execution_count": 81, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(def d-up (cmps (dffr1 ccn) upper-shift))" - ] - }, - { - "cell_type": "code", - "execution_count": 82, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "\n", - "----------------------------------------------------------------------{CMBN 1}\n", - "<1 * 11>\n", - "------------------------------------------------------------------------------\n" - ] - }, - "execution_count": 82, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(? up-d 1 11)" - ] - }, - { - "cell_type": "code", - "execution_count": 83, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "\n", - "----------------------------------------------------------------------{CMBN 1}\n", - "------------------------------------------------------------------------------\n" - ] - }, - "execution_count": 83, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(? d-up 1 11)" - ] - }, - { - "cell_type": "code", - "execution_count": 84, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "\n", - "----------------------------------------------------------------------{CMBN 1}\n", - "<1 * 10>\n", - "<2 * 11>\n", - "<3 * 12>\n", - "<4 * 13>\n", - "<5 * 14>\n", - "<6 * 15>\n", - "------------------------------------------------------------------------------\n" - ] - }, - "execution_count": 84, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(def comb3 (cmbn 1 1 10 2 11 3 12 4 13 5 14 6 15))" - ] - }, - { - "cell_type": "code", - "execution_count": 85, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "\n", - "----------------------------------------------------------------------{CMBN 1}\n", - "<2 * 11>\n", - "<4 * 13>\n", - "<6 * 15>\n", - "------------------------------------------------------------------------------\n" - ] - }, - "execution_count": 85, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(? up-d comb3)" - ] - }, - { - "cell_type": "code", - "execution_count": 86, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "\n", - "----------------------------------------------------------------------{CMBN 1}\n", - "<1 * 10>\n", - "<3 * 12>\n", - "<5 * 14>\n", - "------------------------------------------------------------------------------\n" - ] - }, - "execution_count": 86, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "(? d-up comb3)" ] @@ -2441,12 +2282,44 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Accessing $\\texttt{Kenzo}$ objects" + "### Accessing `Kenzo` objects\n", + "\n", + "Up to now, we have seen two kinds of `Kenzo` objects stored in specific lists and retrievable by a number, namely the chain complexes and the morphisms. The retrieval functions are specific to the object: `chcm` for a chain complex, `mrph` for a morphism. The same scheme will be applied for others kinds of objects: reductions, homotopy equivalences, \n", + "coalgebras, algebras, simplicial morphism, etc, each having its specific list. But, in fact the numbering is independent\n", + "of the type of the object and is incremented each time an object is created. Three general functions are at the disposal of the user to get information about the `n`-th `Kenzo` object: `K`, `KD`, and `KD2`. They may be useful for debugging purpose.\n", + "\n", + "#### Function `K`" ] }, { "cell_type": "code", - "execution_count": 87, + "execution_count": 75, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "\"--------------------------------------------------------------[function-doc]\n", + "K\n", + "Args: (idnm)\n", + "Returns the IDNM-th Kenzo object.\n", + "------------------------------------------------------------------------------\"" + ] + }, + "execution_count": 75, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(documentation 'k 'function)" + ] + }, + { + "cell_type": "code", + "execution_count": 76, "metadata": { "collapsed": false }, @@ -2457,7 +2330,7 @@ "[K1 Chain-Complex]" ] }, - "execution_count": 87, + "execution_count": 76, "metadata": {}, "output_type": "execute_result" } @@ -2466,9 +2339,43 @@ "(k 1)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Function `KD`" + ] + }, { "cell_type": "code", - "execution_count": 88, + "execution_count": 77, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "\"--------------------------------------------------------------[function-doc]\n", + "KD\n", + "Args: (idnm)\n", + "Return the type of Kenzo object number IDNM and print the comment list\n", + "(SLOT :ORGN) of the object.\n", + "------------------------------------------------------------------------------\"" + ] + }, + "execution_count": 77, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(documentation 'kd 'function)" + ] + }, + { + "cell_type": "code", + "execution_count": 78, "metadata": { "collapsed": false }, @@ -2489,7 +2396,7 @@ "NIL" ] }, - "execution_count": 88, + "execution_count": 78, "metadata": {}, "output_type": "execute_result" } @@ -2500,7 +2407,7 @@ }, { "cell_type": "code", - "execution_count": 89, + "execution_count": 79, "metadata": { "collapsed": false }, @@ -2511,7 +2418,7 @@ "[K3 Cohomology-Class on K1 of degree 1]" ] }, - "execution_count": 89, + "execution_count": 79, "metadata": {}, "output_type": "execute_result" } @@ -2522,7 +2429,7 @@ }, { "cell_type": "code", - "execution_count": 90, + "execution_count": 80, "metadata": { "collapsed": false }, @@ -2543,7 +2450,7 @@ "NIL" ] }, - "execution_count": 90, + "execution_count": 80, "metadata": {}, "output_type": "execute_result" } @@ -2554,7 +2461,7 @@ }, { "cell_type": "code", - "execution_count": 91, + "execution_count": 81, "metadata": { "collapsed": false }, @@ -2575,7 +2482,7 @@ "NIL" ] }, - "execution_count": 91, + "execution_count": 81, "metadata": {}, "output_type": "execute_result" } @@ -2586,7 +2493,7 @@ }, { "cell_type": "code", - "execution_count": 92, + "execution_count": 82, "metadata": { "collapsed": false }, @@ -2607,7 +2514,7 @@ "NIL" ] }, - "execution_count": 92, + "execution_count": 82, "metadata": {}, "output_type": "execute_result" } @@ -2618,7 +2525,7 @@ }, { "cell_type": "code", - "execution_count": 93, + "execution_count": 83, "metadata": { "collapsed": false }, @@ -2639,7 +2546,7 @@ "NIL" ] }, - "execution_count": 93, + "execution_count": 83, "metadata": {}, "output_type": "execute_result" } @@ -2648,9 +2555,45 @@ "(kd 9)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Function `KD2`" + ] + }, { "cell_type": "code", - "execution_count": 94, + "execution_count": 84, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "\"--------------------------------------------------------------[function-doc]\n", + "KD2\n", + "Args: (idnm)\n", + "Return the type of Kenzo object number IDNM, print the comment list\n", + "(SLOT :ORGN) of the object and, recursively, return the same information\n", + "for all Kenzo objects of the same type in relation with this object. Return\n", + "the list of object numbers.\n", + "------------------------------------------------------------------------------\"" + ] + }, + "execution_count": 84, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(documentation 'kd2 'function)" + ] + }, + { + "cell_type": "code", + "execution_count": 85, "metadata": { "collapsed": false }, @@ -2679,7 +2622,7 @@ "(9 8 7)" ] }, - "execution_count": 94, + "execution_count": 85, "metadata": {}, "output_type": "execute_result" }