mmarco/kenzo
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Added Francis' changes.

Browse Source
This commit is contained in:
gheber 2016-03-17 15:35:43 -05:00
parent 3a7e20e0e7
commit 8f2862f67c
1 changed files with 69 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

137
examples/Chapter2.ipynb
View File

@ -9,12 +9,11 @@
"## Introduction\n", "## Introduction\n",
"\n", "\n",
"The present chapter describes the set of programming tools for handling *objects with effective homology*. The theoretical material may be found in the paper *Constructive Algebraic Topology* by Julio Rubio Garcia and Francis Sergeraert (Available at the web site\n", "The present chapter describes the set of programming tools for handling *objects with effective homology*. The theoretical material may be found in the paper *Constructive Algebraic Topology* by Julio Rubio Garcia and Francis Sergeraert (Available at the web site\n",
"[**https://www-fourier.ujf-grenoble.fr/~sergerar/**](https://www-fourier.ujf-grenoble.fr/~sergerar/)). The terminology used in this chapter is compatible with this reference.). The terminology used in this chapter is compatible with this reference.\n", "[**https://www-fourier.ujf-grenoble.fr/~sergerar/**](https://www-fourier.ujf-grenoble.fr/~sergerar/)). The terminology used in this chapter is compatible with this reference.) The terminology used in this chapter is compatible with this reference.\n",
"\n", "\n",
"## Reduction\n", "## Reduction\n",
"\n", "\n",
"A *reduction* in `Kenzo` is a 5-tuple $(\\hat C, C, f, g, h)$:\n", "A *reduction* in `Kenzo` is a 5-tuple $(\\hat C, C, f, g, h)$:\n",
"\n",
"$$\n", "$$\n",
"\\begin{aligned}\n", "\\begin{aligned}\n",
"\\hat{C}\\quad & \\qquad\\stackrel{h}{\\longrightarrow} & \\mbox{$^s\\hat{C}$} \\\\\n", "\\hat{C}\\quad & \\qquad\\stackrel{h}{\\longrightarrow} & \\mbox{$^s\\hat{C}$} \\\\\n",
@ -22,10 +21,8 @@
"C\\quad & &\n", "C\\quad & &\n",
"\\end{aligned}\n", "\\end{aligned}\n",
"$$\n", "$$\n",
"\n",
"where $\\hat C$ and $C$ are chain complexes, $f$ and $g$ chain complex morphisms and\n", "where $\\hat C$ and $C$ are chain complexes, $f$ and $g$ chain complex morphisms and\n",
"$h$ a homotopy operator. Hereafter, $\\hat C$ is called the *top chain complex* and $C$ the *bottom chain complex*. ${}^s\\hat C$ is $\\hat C$ shifted, i.e. $h$ has degree $1$. The mappings $f$, $g$, $h$, together with the differential operator $d$ on $\\hat C$, must verify the following relations:\n", "$h$ a homotopy operator. Hereafter, $\\hat C$ is called the *top chain complex* and $C$ the *bottom chain complex*. ${}^s\\hat C$ is $\\hat C$ shifted, i.e. $h$ has degree $1$. The mappings $f$, $g$, $h$, together with the differential operator $d$ on $\\hat C$, must verify the following relations:\n",
"\n",
"$$\n", "$$\n",
"\\begin{aligned}\n", "\\begin{aligned}\n",
"f \\circ g & = & 1_C \\\\\n", "f \\circ g & = & 1_C \\\\\n",
@ -35,12 +32,10 @@
"h \\circ h & = & 0 \n", "h \\circ h & = & 0 \n",
"\\end{aligned}\n", "\\end{aligned}\n",
"$$\n", "$$\n",
"\n",
"The morphisms $f$ and $g$ and the homotopy operator $h$ describe the (big) chain complex $\\hat C$ as the direct sum\n", "The morphisms $f$ and $g$ and the homotopy operator $h$ describe the (big) chain complex $\\hat C$ as the direct sum\n",
"\n",
"$$ \\hat C= \\hat C_1 \\oplus \\hat C_2$$\n", "$$ \\hat C= \\hat C_1 \\oplus \\hat C_2$$\n",
"where $\\hat C_1 = Im(g) \\simeq C$ and $\\hat C_2= Ker(f)$. The summands $\\hat{C}_1$ and $\\hat{C}_2$ are sub-chain complexes of $\\hat{C}$ and the second one is acyclic, provided with an explicit contraction, namely the restriction of $h$ to $\\hat{C}_2$.\n",
"\n", "\n",
"where $\\hat C_1 = Im(g) \\simeq C$ and $\\hat C_2= Ker(f)$ ($\\hat C_2$ is acyclic).\n",
"\n", "\n",
"### Representation of a reduction\n", "### Representation of a reduction\n",
"\n", "\n",
@ -65,13 +60,14 @@
"\n", "\n",
"1. `tcc`, the object of type `chain-complex` representing the chain complex $\\hat C$ (top chain complex).\n", "1. `tcc`, the object of type `chain-complex` representing the chain complex $\\hat C$ (top chain complex).\n",
"2. `bcc`, the object of type `chain-complex` representing the chain complex $C$ (bottom chain complex).\n", "2. `bcc`, the object of type `chain-complex` representing the chain complex $C$ (bottom chain complex).\n",
"3. `f`, the object of type `morphism`representing the morphism $f$.\n", "3. `f`, the object of type `morphism` representing the morphism $f$.\n",
"4. `g`, the object of type `morphism` representing the morphism $g$.\n", "4. `g`, the object of type `morphism` representing the morphism $g$.\n",
"5. `h`, the object of type `morphism` representing the morphism $h$.\n", "5. `h`, the object of type `morphism` representing the morphism $h$.\n",
"6. `idmn`, an integer, number plate for the object.\n", "6. `idmn`, an integer, number plate for the object.\n",
"7. `orgn`, a comment list carefully chosen.\n", "7. `orgn`, a comment list carefully chosen.\n",
"\n", "\n",
"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 `REDUCTION` and the external representation of an instance is a string like `[K`*n* `Reduction]`, where `n` is the number plate of the `Kenzo` object.\n", "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 `REDUCTION` and the external representation of an instance is a string like `[Kn Reduction K n' => Kn'']`, where `n` is the identification number of the reduction, `n'` (resp. `n''`) is the identification number of the top (resp. bottom) chain complex.\n",
"\n",
"\n", "\n",
"### The function `build-rdct`\n", "### The function `build-rdct`\n",
"\n", "\n",
@ -90,32 +86,32 @@
"- *h*, the object of type `morphism` representing the morphism $h$.\n", "- *h*, the object of type `morphism` representing the morphism $h$.\n",
"- *orgn*, the comment list carefully chosen since the system does not build a new instance of the class if it finds in the list of already built reductions, `*rdct-list*`, a reduction with the same comment list.\n", "- *orgn*, the comment list carefully chosen since the system does not build a new instance of the class if it finds in the list of already built reductions, `*rdct-list*`, a reduction with the same comment list.\n",
"\n", "\n",
"The `tcc` slot and the `bcc` slot of the instance are taken respectively from the `sorc` slot (source slot) and the `trgt` slot (target slot) of the morphism $f$. The function `build-rdc` controls the validity of the degrees of the morphisms and pushes the new created instance on the list `*rdct-list*`.\n", "The `tcc` slot and the `bcc` slot of the instance are taken respectively from the `sorc` slot (source slot) and the `trgt` slot (target slot) of the morphism $f$. The function `build-rdct` controls the validity of the degrees of the morphisms and pushes the new created instance on the list `*rdct-list*`.\n",
"\n", "\n",
"### Useful macros and functions\n", "### Useful macros and functions\n",
"\n", "\n",
"`(cat-init)` *[Function]*\n", "`(cat-init)` *[Function]*\n",
"> Clear among others, the list `*rdct-list*`, list of user created reductions and reset the global counter to 1. See also the description of this function in chapter 1.\n", "> Clear among others, the list `*rdct-list*`, list of user created reductions and reset the global counter to 1. See also the description of this function in chapter 1.\n",
"\n", "\n",
"`(rdct n)` *[Function]*\n", "`(rdct` *n*`)` *[Function]*\n",
"> Retrieve in the list `*rdct-list*` the reduction instance whose identification (as `Kenzo` object) is `n`. If it does not exist, return `NIL`.\n", "> Retrieve in the list `*rdct-list*` the reduction instance whose identification (as `Kenzo` object) is *n*. If it does not exist, return `NIL`.\n",
"\n", "\n",
"`(bcc rdct &rest args)` *[Macro]*\n", "`(bcc` *rdct* `&rest` *args*`)` *[Macro]*\n",
"> With only one argument (a reduction *rdct*) this macro selects the bottom chain complex of the reduction. Otherwise, it applies the differential of the bottom chain complex of the reduction *rdc* on the arguments *args*, (either *degree generator* or *cmb*).\n", "> With only one argument (a reduction *rdct*) this macro selects the bottom chain complex of the reduction. Otherwise, it applies the differential of the bottom chain complex of the reduction *rdct* on the arguments *args*, (either *degree generator* or *cmb*).\n",
"\n", "\n",
"`(tcc rdct &rest args)` *[Macro]*\n", "`(tcc` *rdct* `&rest` *args*`)` *[Macro]*\n",
"> With only one argument (a reduction *rdct*) this macro selects the top chain complex of the reduction. Otherwise, it applies the differential of the top chain complex of the reduction *rdc* on the arguments *args*, (either *degree generator* or *cmb*).\n", "> With only one argument (a reduction *rdct*) this macro selects the top chain complex of the reduction. Otherwise, it applies the differential of the top chain complex of the reduction *rdct* on the arguments *args*, (either *degree generator* or *cmb*).\n",
"\n", "\n",
"`(f rdct &rest args)` *[Macro]*\n", "`(f` *rdct* `&rest` *args*`)` *[Macro]*\n",
"> With only one argument (a reduction *rdct*) this macro selects the morphism $f$ of the reduction. Otherwise, it applies the morphism $f$ of the reduction *rdc* on the arguments *args*, (either *degree generator* or *cmb*).\n", "> With only one argument (a reduction *rdct*) this macro selects the morphism $f$ of the reduction. Otherwise, it applies the morphism $f$ of the reduction *rdct* on the arguments *args*, (either *degree generator* or *cmb*).\n",
"\n", "\n",
"`(g rdct &rest args)` *[Macro]*\n", "`(g` *rdct* `&rest` *args*`)` *[Macro]*\n",
"> With only one argument (a reduction *rdct* this macro selects the morphism $g$ of the reduction. Otherwise, it applies the morphism $g$ of the reduction *rdc* on the arguments *args*, (either *degree generator* or *cmb*).\n", "> With only one argument (a reduction *rdct* this macro selects the morphism $g$ of the reduction. Otherwise, it applies the morphism $g$ of the reduction *rdc* on the arguments *args*, (either *degree generator* or *cmb*).\n",
"\n", "\n",
"`(h rdct &rest args)` *[Macro]*\n", "`(h` *rdct* `&rest` *args*`)` *[Macro]*\n",
"> With only one argument (a reduction *rdct*) this macro selects the morphism $h$ of the reduction. Otherwise, it applies the morphism $h$ of the reduction *rdc* on the arguments *args*, (either *degree generator* or *cmb*).\n", "> With only one argument (a reduction *rdct*) this macro selects the morphism $h$ of the reduction. Otherwise, it applies the morphism $h$ of the reduction *rdc* on the arguments *args*, (either *degree generator* or *cmb*).\n",
"\n", "\n",
"`(trivial-rdct chcm)` *[Function]*\n", "`(trivial-rdct` *chcm*`)` *[Function]*\n",
"> Build the trivial reduction involving only the chain complex chcm, as shown in the following diagram,\n", "> Build the trivial reduction involving only the chain complex chcm, as shown in the following diagram,\n",
"$$\n", "$$\n",
"\\begin{aligned}\n", "\\begin{aligned}\n",
@ -126,13 +122,13 @@
"$$\n", "$$\n",
"where the morphism *Zero* is the zero morphism of degree 1 in the chain complex $C$ and *Id* is the identity morphism in that chain complex (see the functions `zero-mrph` and `idnt-mrph` in the chain complex chapter).\n", "where the morphism *Zero* is the zero morphism of degree 1 in the chain complex $C$ and *Id* is the identity morphism in that chain complex (see the functions `zero-mrph` and `idnt-mrph` in the chain complex chapter).\n",
"\n", "\n",
"`(cmps brdct trdct)` *[Method]*\n", "`(cmps` *brdct trdct*`)` *[Method]*\n",
"> Build a new reduction from the two reductions $r1$ and $r2$ (here, respectively *brdct* and *trdct*). This is done by a call to `build-rdct` with the following parameters:\n", "> Build a new reduction from the two reductions $b$ and $t$ (here, respectively *brdct* and *trdct*). This is done by a call to `build-rdct` with the following parameters:\n",
"$$\n", "$$\n",
"\\begin{aligned}\n", "\\begin{aligned}\n",
"f & = & f_{r1}\\circ f_{r2}, \\\\\n", "f & = & f_{b}\\circ f_{t}, \\\\\n",
"g & = & g_{r2}\\circ g_{r1}, \\\\\n", "g & = & g_{t}\\circ g_{b}, \\\\\n",
"h & = & h_{r2} + g_{r2} \\circ h_{r1} \\circ f_{r2}.\n", "h & = & h_{t} + g_{t} \\circ h_{b} \\circ f_{t}.\n",
"\\end{aligned}\n", "\\end{aligned}\n",
"$$\n", "$$\n",
"The compositions and additions of morphisms are realized respectively by the methods `cmps`, `i-cmps` and `add` (see chapter 1). We recall that the `tcc` and the `bcc` slots of this new created reduction are respectively the source and target slots of the new morphim $f$.\n", "The compositions and additions of morphisms are realized respectively by the methods `cmps`, `i-cmps` and `add` (see chapter 1). We recall that the `tcc` and the `bcc` slots of this new created reduction are respectively the source and target slots of the new morphim $f$.\n",
@ -148,13 +144,13 @@
"\\end{aligned}\n", "\\end{aligned}\n",
"$$\n", "$$\n",
"\n", "\n",
"`(pre-check-rdct rdct)` *[Function]*\n", "`(pre-check-rdct` *rdct*`)` *[Function]*\n",
"> Assign to the following lisp global variables, the morphism instances computed from the morphisms of the reduction *rdct*, according to the formulas:\n", "> Assign to the following lisp global variables, the morphism instances computed from the morphisms of the reduction *rdct*, according to the formulas:\n",
"$$\n", "$$\n",
"\\begin{aligned}\n", "\\begin{aligned}\n",
" \\mathtt{*tdd*} & = & d_{\\hat C} \\circ d_{\\hat C},\\\\\n", " \\mathtt{*tdd*} & = & d_{\\hat C} \\circ d_{\\hat C},\\\\\n",
" \\mathtt{*bdd*} & = & d_C \\circ d_C , \\\\\n", " \\mathtt{*bdd*} & = & d_C \\circ d_C , \\\\\n",
" \\mathtt{*id-fg*} & = & f \\circ g - Id_C,\n", " \\mathtt{*id-fg*} & = & f \\circ g - Id_C, \\\\\n",
" \\mathtt{*id-gf-dh-hd*} & = & Id_{\\hat C} - g \\circ f - (d_{\\hat C} \\circ h + h \\circ d_{\\hat C}),\\\\\n", " \\mathtt{*id-gf-dh-hd*} & = & Id_{\\hat C} - g \\circ f - (d_{\\hat C} \\circ h + h \\circ d_{\\hat C}),\\\\\n",
" \\mathtt{*hh*} & = & h \\circ h, \\\\\n", " \\mathtt{*hh*} & = & h \\circ h, \\\\\n",
" \\mathtt{*fh*} & = & f \\circ h, \\\\\n", " \\mathtt{*fh*} & = & f \\circ h, \\\\\n",
@ -553,6 +549,13 @@
"(setf *bc* (cmbn 3 4 '(0 1 2 3)))" "(setf *bc* (cmbn 3 4 '(0 1 2 3)))"
] ]
}, },
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In this documentation, we use the non-interactive function `check-rdct-no-wait` which does the whole check at once without waiting the newline input between two elementary checks."
]
},
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 12, "execution_count": 12,
@ -911,24 +914,24 @@
"- `idn`, an integer, number plate for the object, set by the system.\n", "- `idn`, an integer, number plate for the object, set by the system.\n",
"- `orgn`, an adequate comment list.\n", "- `orgn`, an adequate comment list.\n",
"\n", "\n",
"When an instance is created, the printing method associated to the class `HOMOTOPY EQUIVALENCE` prints a string like `[K`*n* `Homotopy-Equivalence]`, where *n* is the number plate of the Kenzo object.\n", "When an instance is created, the printing method associated to the class `HOMOTOPY EQUIVALENCE` prints a string like `[Kn Homotopy-Equivalence Ka <= Kb => Kc]`, where `n` is the number plate of the equivalence, `a` is the id number of $C$, `b` the id number of $\\hat C$, `c` the id number of $EC$.\n",
"\n", "\n",
"\n", "\n",
"### The function `build-hmeq`\n", "### The function `build-hmeq`\n",
"\n", "\n",
"To facilitate the construction of instances of the `HOMOTOPY-EQUIVALENCE` class, the software provides the function, (in fact a method), `build-hmeq` which may be used in the following ways:\n", "To facilitate the construction of instances of the `HOMOTOPY-EQUIVALENCE` class, the program provides the function, (in fact a method), `build-hmeq` which may be used in the following ways:\n",
"either with the two reductions $\\rho_1$ and $\\rho_2$ or explicitly with the morphisms.\n", "either with the two reductions $\\rho_1$ and $\\rho_2$ or explicitly with the morphisms.\n",
"The selection of the adequate method is done by inspecting the first keyword, which is \n", "The selection of the adequate method is done by inspecting the first keyword, which is \n",
"`:lrdct` in the first case and `:lf` in the second one. In both cases the returned value is an instance of the class `HOMOTOPY-EQUIVALENCE`.\n", "`:lrdct` in the first case and `:lf` in the second one. In both cases the returned value is an instance of the class `HOMOTOPY-EQUIVALENCE`.\n",
"\n", "\n",
"1) `(build-hmeq :lrdct lrdct :rrdct rrdc :orgn orgn)` *[Method]*\n", "1) `(build-hmeq :lrdct` *lrdct* `:rrdct` *rrdc* `:orgn` *orgn*`)` *[Method]*\n",
"> The keyword arguments are:\n", "> The keyword arguments are:\n",
"- *lrdct*, the object of type `reduction` representing the reduction $\\rho_1$.\n", "- *lrdct*, the object of type `reduction` representing the reduction $\\rho_1$.\n",
"- *rrdct*, the object of type `reduction` representing the reduction $\\rho_2$.\n", "- *rrdct*, the object of type `reduction` representing the reduction $\\rho_2$.\n",
"- *org*, the comment list.\n", "- *org*, the comment list.\n",
"The function `build-heq-from-rdc` calls internally the standard constructor `make-instance`. All the needed information is contained in the two reductions.\n", "The function `build-heq-from-rdc` calls internally the standard constructor `make-instance`. All the needed information is contained in the two reductions.\n",
"\n", "\n",
"2) `(build-hmeq :lf lf :lg lg :lh lh :rf rf :rg rg :rh rh :orgn orgn)` *[Method]*\n", "2) `(build-hmeq :lf` *lf* `:lg` *lg* `:lh` *lh* `:rf` *rf* `:rg` *rg* `:rh` *rh* `:orgn` *orgn*`)` *[Method]*\n",
"> The keyword arguments are:\n", "> The keyword arguments are:\n",
"- *lf*, the object of type `morphism` representing the morphism $f$ of the reduction $\\rho_1$.\n", "- *lf*, the object of type `morphism` representing the morphism $f$ of the reduction $\\rho_1$.\n",
"- *lg*, the object of type `morphism` representing the morphism $g$ of the reduction $\\rho_1$.\n", "- *lg*, the object of type `morphism` representing the morphism $g$ of the reduction $\\rho_1$.\n",
@ -946,34 +949,34 @@
"`(cat-init)` *[Function]*\n", "`(cat-init)` *[Function]*\n",
"> Clear among others, the list `*hmeq-list*`, list of user created homotopy equivalences and reset the global counter to 1.\n", "> Clear among others, the list `*hmeq-list*`, list of user created homotopy equivalences and reset the global counter to 1.\n",
"\n", "\n",
"`(hmeq n)` *[Function]*\n", "`(hmeq` *n*`)` *[Function]*\n",
"> Retrieve in the list `*hmeq-list*` the homotopy equivalence instance whose identification is $n$. If it does not exist, return `NIL`.\n", "> Retrieve in the list `*hmeq-list*` the homotopy equivalence instance whose identification is $n$. If it does not exist, return `NIL`.\n",
"\n", "\n",
"`(lbcc hmeq &rest args)` *[Macro]*\n", "`(lbcc` *hmeq* `&rest` *args*`)` *[Macro]*\n",
"> With only one argument (a homotopy equivalence *hmeq*) this macro selects the left bottom chain complex of the homotopy equivalence. Otherwise, it applies the differential of the left bottom chain complex of *hmeq* on the arguments *args*, (either *degree generator* or *cmb*).\n", "> With only one argument (a homotopy equivalence *hmeq*) this macro selects the left bottom chain complex of the homotopy equivalence. Otherwise, it applies the differential of the left bottom chain complex of *hmeq* on the arguments *args*, (either *degree generator* or *cmb*).\n",
"\n", "\n",
"`(rbcc hmeq &rest args)` *[Macro]*\n", "`(rbcc` *hmeq* `&rest` *args*`)` *[Macro]*\n",
"> With only one argument (a homotopy equivalence *hmeq*) this macro selects the right bottom chain complex of the homotopy equivalence. Otherwise, it applies the differential of the right bottom chain complex of *hmeq* on the arguments *args*, (either *degree generator* or *cmb*).\n", "> With only one argument (a homotopy equivalence *hmeq*) this macro selects the right bottom chain complex of the homotopy equivalence. Otherwise, it applies the differential of the right bottom chain complex of *hmeq* on the arguments *args*, (either *degree generator* or *cmb*).\n",
"\n", "\n",
"`(lf hmeq &rest args)` *[Macro]*\n", "`(lf` *hmeq* `&rest` *args*`)` *[Macro]*\n",
"> With only one argument (a homotopy equivalence *hmeq*) this macro selects the morphism $f$ of the left reduction of *hmeq*. Otherwise, it applies the morphism $f$ of the left reduction of *hmeq* on the arguments *args*, (either *degree generator* or *cmb*).\n", "> With only one argument (a homotopy equivalence *hmeq*) this macro selects the morphism $f$ of the left reduction of *hmeq*. Otherwise, it applies the morphism $f$ of the left reduction of *hmeq* on the arguments *args*, (either *degree generator* or *cmb*).\n",
"\n", "\n",
"`(lg hmeq &rest args)` *[Macro]*\n", "`(lg` *hmeq* `&rest` *args*`)` *[Macro]*\n",
"> With only one argument (a homotopy equivalence *hmeq*) this macro selects the morphism $g$ of the left reduction of *hmeq*. Otherwise, it applies the morphism $g$ of the left reduction of *hmeq* on the arguments *args*, (either *degree generator* or *cmb*).\n", "> With only one argument (a homotopy equivalence *hmeq*) this macro selects the morphism $g$ of the left reduction of *hmeq*. Otherwise, it applies the morphism $g$ of the left reduction of *hmeq* on the arguments *args*, (either *degree generator* or *cmb*).\n",
"\n", "\n",
"`(lh hmeq &rest args)` *[Macro]*\n", "`(lh` *hmeq* `&rest` *args*`)` *[Macro]*\n",
"> With only one argument (a homotopy equivalence *hmeq*) this macro selects the morphism $h$ of the left reduction of *hmeq*. Otherwise, it applies the morphism $h$ of the left reduction of *hmeq* on the arguments *args*, (either *degree generator* or *cmb*).\n", "> With only one argument (a homotopy equivalence *hmeq*) this macro selects the morphism $h$ of the left reduction of *hmeq*. Otherwise, it applies the morphism $h$ of the left reduction of *hmeq* on the arguments *args*, (either *degree generator* or *cmb*).\n",
"\n", "\n",
"`(rf hmeq &rest args)` *[Macro]*\n", "`(rf` *hmeq* `&rest` *args*`)` *[Macro]*\n",
"> With only one argument (a homotopy equivalence *hmeq*) this macro selects the morphism $f$ of the right reduction of *hmeq*. Otherwise, it applies the morphism $f$ of the right reduction of *hmeq* on the arguments *args*, (either *degree generator* or *cmb*).\n", "> With only one argument (a homotopy equivalence *hmeq*) this macro selects the morphism $f$ of the right reduction of *hmeq*. Otherwise, it applies the morphism $f$ of the right reduction of *hmeq* on the arguments *args*, (either *degree generator* or *cmb*).\n",
"\n", "\n",
"`(rg hmeq &rest args)` *[Macro]*\n", "`(rg` *hmeq* `&rest` *args*`)` *[Macro]*\n",
"> With only one argument (a homotopy equivalence *hmeq*) this macro selects the morphism $g$ of the right reduction of *hmeq*. Otherwise, it applies the morphism $g$ of the right reduction of *hmeq* on the arguments *args*, (either *degree generator* or *cmb*).\n", "> With only one argument (a homotopy equivalence *hmeq*) this macro selects the morphism $g$ of the right reduction of *hmeq*. Otherwise, it applies the morphism $g$ of the right reduction of *hmeq* on the arguments *args*, (either *degree generator* or *cmb*).\n",
"\n", "\n",
"`(rh hmeq &rest args)` *[Macro]*\n", "`(rh` *hmeq* `&rest` *args*`)` *[Macro]*\n",
"> With only one argument (a homotopy equivalence *hmeq*) this macro selects the morphism $h$ of the right reduction of *hmeq*. Otherwise, it applies the morphism $h$ of the right reduction of *hmeq* on the arguments *args*, (either *degree generator* or *cmb*).\n", "> With only one argument (a homotopy equivalence *hmeq*) this macro selects the morphism $h$ of the right reduction of *hmeq*. Otherwise, it applies the morphism $h$ of the right reduction of *hmeq* on the arguments *args*, (either *degree generator* or *cmb*).\n",
"\n", "\n",
"`(trivial-hmeq chcm)` *[Function]*\n", "`(trivial-hmeq` *chcm*`)` *[Function]*\n",
"> Build the trivial homotopy equivalence involving only the chain complex *chcm*. In that case,\n", "> Build the trivial homotopy equivalence involving only the chain complex *chcm*. In that case,\n",
"the 3 chain complexes $C$, $EC$ and $\\hat C$ are the chain complex *chcm* itself and the reductions $\\rho_1$ and $\\rho_2$ are, of course, the trivial reductions on *chcm* built by the statement `(trivial-rdct chcm)`." "the 3 chain complexes $C$, $EC$ and $\\hat C$ are the chain complex *chcm* itself and the reductions $\\rho_1$ and $\\rho_2$ are, of course, the trivial reductions on *chcm* built by the statement `(trivial-rdct chcm)`."
] ]
@ -1019,24 +1022,27 @@
"The functions implementing the perturbation-lemma are actually the heart of the program. They allow us\n", "The functions implementing the perturbation-lemma are actually the heart of the program. They allow us\n",
"to implement the effective versions of the classical spectral sequences (Serre, Eilenberg-Moore, ...). \n", "to implement the effective versions of the classical spectral sequences (Serre, Eilenberg-Moore, ...). \n",
"\n", "\n",
"`(add rdct perturbation)` *[Method]*\n", "`(add` *rdct perturbation*`)` *[Method]*\n",
"> Build a new reduction from the object of type `reduction`, *rdct* and \n", "> Build a new reduction from the object of type `reduction`, *rdct* and \n",
"the object of type `morphism`, *perturbation*, applying the formulas given in the perturbation lemma. In fact, this method calls one or the other of the two following functions according as the perturbation is on the top or on the bottom chain complex and returns the values of the called function.\n", "the object of type `morphism`, *perturbation*, applying the formulas given in the perturbation lemma. In fact, this method calls one or the other of the two following functions according as the perturbation is on the top or on the bottom chain complex and returns the values of the called function.\n",
"\n", "\n",
"`(basic-perturbation-lemma reduction top-perturbation)` *[Function]*\n", "`(basic-perturbation-lemma` *reduction top-perturbation*`)` *[Function]*\n",
"> Return a double value: the perturbed reduction and the computed bottom-perturbation (a morphism)\n", "> Return a double value: the perturbed reduction and the computed bottom-perturbation (a morphism)\n",
"$f \\circ {\\hat \\delta}\\circ \\phi \\circ g$. Of course, to avoid unuseful computations when the morphisms are effectively applied, the function takes in account the simplifications involved for instance whensome morphisms are the null morphism.\n", "$f \\circ {\\hat \\delta}\\circ \\phi \\circ g$. Of course, to avoid unuseful computations when the morphisms are effectively applied, the function takes in account the simplifications involved for instance when some morphisms are the null morphism.\n",
"\n", "\n",
"`(easy-perturbation-lemma reduction bottom-perturbation)` *[Function]*\n", "`(easy-perturbation-lemma` *reduction bottom-perturbation*`)` *[Function]*\n",
"> Return a double value: the perturbed reduction and the computed top-perturbation (a morphism) $g \\circ {\\check \\delta} \\circ f$. Of course, to avoid unuseful computation when the morphisms will be applied, the function takes in account the simplifications involved for instance when some morphisms are the null morphism.\n", "> Return a double value: the perturbed reduction and the computed top-perturbation (a morphism) $g \\circ {\\check \\delta} \\circ f$. Of course, to avoid useless computation when the morphisms will be applied, the function takes in account the simplifications involved for instance when some morphisms are the null morphism.\n",
"\n", "\n",
"`(special-bpl reduction top-perturbation)` *[Function]*\n", "`(special-bpl` *reduction top-perturbation*`)` *[Function]*\n",
"> This function is analogous to `basic-perturbation-lemma` and is used in some special cases when the morphism $g$ is invariant.\n", "> This function is analogous to `basic-perturbation-lemma` and is used in some special cases when the morphism $g$ is invariant.\n",
"\n", "\n",
"`bpl-*-sigma homotopy perturbation)` *[Function]*\n", "`(special-bpl2` *reduction top-perturbation*`)` *[Function]*\n",
"> [analogous to special-bpl when $f$ is invariant.]\n",
"\n",
"`(bpl-*-sigma` *homotopy perturbation*`)` *[Function]*\n",
"> Construct the principal series $\\phi=\\sum_{i=0}^{\\infty}{(-1)^i(h \\circ \\hat{\\delta})^i}$ of the basic perturbation lemma.\n", "> Construct the principal series $\\phi=\\sum_{i=0}^{\\infty}{(-1)^i(h \\circ \\hat{\\delta})^i}$ of the basic perturbation lemma.\n",
"\n", "\n",
"`(add hmeq lb-perturbation)` *[Method]*\n", "`(add` *hmeq lb-perturbation*`)` *[Method]*\n",
"> Build a homotopy equivalence from the `homotopy-equivalence` *hmeq* and the `morphism` *lb-perturbation*, a perturbation of the differential of the left bottom chain complex of *hmeq*. From *hmeq*:\n", "> Build a homotopy equivalence from the `homotopy-equivalence` *hmeq* and the `morphism` *lb-perturbation*, a perturbation of the differential of the left bottom chain complex of *hmeq*. From *hmeq*:\n",
"$$\n", "$$\n",
"\\begin{aligned}\n", "\\begin{aligned}\n",
@ -1142,7 +1148,6 @@
"## Bicones\n", "## Bicones\n",
"\n", "\n",
"Given 3 chain complexes $B$, $C$ and $D$, together with 2 chain homomorphisms $f_1$ and $f_2$ of degree $0$ (commuting with the differentials), as shown in the following diagram, a bicone on these chain complexes is a chain complex, $BCN(f_1,f_2)$ where the $n$-th chain group $[BCN(f_1,f_2)]$ is $B_n \\oplus C_{n+1} \\oplus D_n$.\n", "Given 3 chain complexes $B$, $C$ and $D$, together with 2 chain homomorphisms $f_1$ and $f_2$ of degree $0$ (commuting with the differentials), as shown in the following diagram, a bicone on these chain complexes is a chain complex, $BCN(f_1,f_2)$ where the $n$-th chain group $[BCN(f_1,f_2)]$ is $B_n \\oplus C_{n+1} \\oplus D_n$.\n",
"\n",
"$$\n", "$$\n",
"\\begin{aligned}\n", "\\begin{aligned}\n",
"B & & & \\qquad D & \\\\\n", "B & & & \\qquad D & \\\\\n",
@ -1217,29 +1222,29 @@
"source": [ "source": [
"### Useful functions and macros for bicones\n", "### Useful functions and macros for bicones\n",
"\n", "\n",
"`(bcnb gnrt)` *[Macro]*\n", "`(bcnb` *gnrt*`)` *[Macro]*\n",
"> Build the representation of the generator *gnrt* belonging to the chain complex $B$.\n", "> Build the representation of the generator *gnrt* belonging to the chain complex $B$.\n",
"\n", "\n",
"`(bcnc gnrt)` *[Macro]*\n", "`(bcnc` *gnrt*`)` *[Macro]*\n",
"> Build the representation of the generator *gnrt* belonging to the chain complex $C$.\n", "> Build the representation of the generator *gnrt* belonging to the chain complex $C$.\n",
"\n", "\n",
"`(bcnd gnrt)` *[Macro]*\n", "`(bcnd` *gnrt*`)` *[Macro]*\n",
"> Build the representation of the generator *gnrt* belonging to the chain complex $D$.\n", "> Build the representation of the generator *gnrt* belonging to the chain complex $D$.\n",
"\n", "\n",
"`(make-bicn-cmbn cmbnb cmbnc cmbnd)` *[Function]*\n", "`(make-bicn-cmbn` *cmbnb cmbnc cmbnd*`)` *[Function]*\n",
"> Build a bicone combination from the 3 combinations *cmbnb*, *cmbnc* and *cmbnd* belonging respectively and in that order to $B$, $C$ and $D$. The degrees of the combinations *cmbnb* and *cmbnd* must be the same, say $n$. The degree of *cmbnc* must be $n+1$. The degree of the new created combination is $n$.\n", "> Build a bicone combination from the 3 combinations *cmbnb*, *cmbnc* and *cmbnd* belonging respectively and in that order to $B$, $C$ and $D$. The degrees of the combinations *cmbnb* and *cmbnd* must be the same, say $n$. The degree of *cmbnc* must be $n+1$. The degree of the new created combination is $n$.\n",
"\n", "\n",
"`(bicn-cmbn-cmbnb cmbn)` *[Function]*\n", "`(bicn-cmbn-cmbnb` *cmbn*`)` *[Function]*\n",
"> Extract from the bicone combination of degree $n$, *cmbn*, the combination relative to $B$ as a legal combination of degree $n$ in $B$. If there is no $B$-component, return the null combination of degree $n$.\n", "> Extract from the bicone combination of degree $n$, *cmbn*, the combination relative to $B$ as a legal combination of degree $n$ in $B$. If there is no $B$-component, return the null combination of degree $n$.\n",
"\n", "\n",
"`(bicn-cmbn-cmbnc cmbn)` *[Function]*\n", "`(bicn-cmbn-cmbnc` *cmbn*`)` *[Function]*\n",
"> Extract from the bicone combination of degree $n$, *cmbn*, the combination relative to $C$ as a legal combination of degree $n+1$ in $C$. If there is no $C$-component, return the null combination of degree $n+1$.\n", "> Extract from the bicone combination of degree $n$, *cmbn*, the combination relative to $C$ as a legal combination of degree $n+1$ in $C$. If there is no $C$-component, return the null combination of degree $n+1$.\n",
"\n", "\n",
"`(bicn-cmbn-cmbnd cmbn)` *[Function]*\n", "`(bicn-cmbn-cmbnd` *cmbn*`)` *[Function]*\n",
"> Extract from the bicone combination of degree $n$, *cmbn*, the combination relative to $D$ as a legal combination of degree $n$ in $D$. If there is no $D$-component, return the null combination of degree $n$\n", "> Extract from the bicone combination of degree $n$, *cmbn*, the combination relative to $D$ as a legal combination of degree $n$ in $D$. If there is no $D$-component, return the null combination of degree $n$\n",
"\n", "\n",
"`(dispatch-bicn-cmbn cmbn)` *[Function]*\n", "`(dispatch-bicn-cmbn` *cmbn*`)` *[Function]*\n",
"> Give the 3-values result constitued by the 3 combinations components of the bicone combination *cmbn*. These combinations are valid combinations in their respective chain complexes.\n", "> Give the 3-values result made of the 3 combinations components of the bicone combination *cmbn*. These combinations are valid combinations in their respective chain complexes.\n",
"\n", "\n",
"#### Examples" "#### Examples"
] ]
@ -1559,7 +1564,7 @@
"output_type": "stream", "output_type": "stream",
"text": [ "text": [
"REDEFINITION-WITH-DEFUN: \n", "REDEFINITION-WITH-DEFUN: \n",
" #<SB-KERNEL:REDEFINITION-WITH-DEFUN {1006BBE1E3}>\n" " #<SB-KERNEL:REDEFINITION-WITH-DEFUN {1006BBCF83}>\n"
] ]
}, },
{ {
@ -1909,7 +1914,6 @@
"## Composition of homotopy equivalences\n", "## Composition of homotopy equivalences\n",
"\n", "\n",
"Let us consider 2 homotopy equivalences, as in the following diagram.\n", "Let us consider 2 homotopy equivalences, as in the following diagram.\n",
"\n",
"$$\n", "$$\n",
"\\begin{aligned}\n", "\\begin{aligned}\n",
"& \\qquad B & & & & \\qquad D \\\\\n", "& \\qquad B & & & & \\qquad D \\\\\n",
@ -1918,9 +1922,7 @@
"A \\quad & & C & & C \\quad & & E \\quad\n", "A \\quad & & C & & C \\quad & & E \\quad\n",
"\\end{aligned}\n", "\\end{aligned}\n",
"$$\n", "$$\n",
"\n", "where the right bottom complex of the first one is the same as the left bottom complex of the second. We may use then the bicone concept to build a bicone chain complex with $B$, $C$ and $D$, say $BCN$, and finally build a new homotopy equivalence between $A$, $BCN$ and $E$.\n",
"where the right bottom complex of the first one is the same as the left bottom reduction\n",
"of the second. We may use then the bicone concept to build a bicone chain complex with $B$, $C$ and $D$, say $BCN$, and finally build a new homotopy equivalence between $A$, $BCN$ and $E$.\n",
"\n", "\n",
"$$\n", "$$\n",
"\\begin{aligned}\n", "\\begin{aligned}\n",
@ -1932,9 +1934,8 @@
"\n", "\n",
"This is realized by the method `cmps`.\n", "This is realized by the method `cmps`.\n",
"\n", "\n",
"`(cmps hmeq1 hmeq2)` *[Method]*\n", "`(cmps` *hmeq1 hmeq2*`)` *[Method]*\n",
"> Build a homotopy equivalence by composition of both homotopy equivalences *hmeq1*, *hmeq2*.\n", "> Build a homotopy equivalence by composition of both homotopy equivalences *hmeq1*, *hmeq2*. The system controls the validity of the composition.\n",
"The system controls the validity of the composition.\n",
"\n", "\n",
"### Example\n", "### Example\n",
"\n", "\n",