Corrected LaTeX conversion errors.
This commit is contained in:
gheber
parent
8af42d89bd
commit
e00ad50f0f
@ -16,57 +16,57 @@
|
||||
"\n",
|
||||
"### Example\n",
|
||||
"\n",
|
||||
"We are going to work with the simplices of $\\Delta^\\mathbb{N}$. The set $(\\sigma_1, \\sigma_2) = $ ``((0 2), (0 1))`` is a Kan hat of dimension 2 and index 0. In effect, $\\delta_1\\sigma_1=\\delta_1\\sigma_2 =$ ``(0)``. Likewise, the two sets ``((1 2), (0 1))`` and ``((1 2), (0 2))`` are Kan hats of dimension 2 and of respective index 1 and 2. Of course, this definition applies equally if the simplices are degenerate.\n",
|
||||
"We are going to work with the simplices of $\\Delta^\\mathbb{N}$. The set $(\\sigma_1, \\sigma_2) = $ `((0 2), (0 1))` is a Kan hat of dimension 2 and index 0. In effect, $\\delta_1\\sigma_1=\\delta_1\\sigma_2 =$ `(0)`. Likewise, the two sets `((1 2), (0 1))` and `((1 2), (0 2))` are Kan hats of dimension 2 and of respective index 1 and 2. Of course, this definition applies equally if the simplices are degenerate.\n",
|
||||
"\n",
|
||||
"**Definition 2.** A *filling* of a Kan hat $(\\sigma_0, \\ldots, \\sigma_{i-1}, \\sigma_{i+1}, \\ldots, \\sigma_n)$, is an $n$-simplex $\\tilde{\\sigma}$, such that for every $j \\not= i$, $\\partial_j\\tilde{\\sigma}=\\sigma_j.$\n",
|
||||
"\n",
|
||||
"### Example\n",
|
||||
"\n",
|
||||
"A filling of ``((0 2), (0 1))`` is the 2-simplex ``(0 1 2)``. A filling of the Kan hat ``((1 1), (0 1))`` is the degenerate 2-simplex ``(0 1 1)``. A filling of the vertex ``(0)`` is the degenerate 1-simplex ``(0 0)``.\n",
|
||||
"A filling of `((0 2), (0 1))` is the 2-simplex `(0 1 2)`. A filling of the Kan hat `((1 1), (0 1))` is the degenerate 2-simplex `(0 1 1)`. A filling of the vertex `(0)` is the degenerate 1-simplex `(0 0)`.\n",
|
||||
"\n",
|
||||
"**Definition 3.** A simplicial set is a Kan simplicial set if for every hat there exists a filling.\n",
|
||||
"\n",
|
||||
"### Representation of a Kan simplicial set\n",
|
||||
"\n",
|
||||
"A Kan simplicial set is implemented as an instance of the class ``KAN``, subclass of the class ``SIMPLICIAL-SET``.\n",
|
||||
"A Kan simplicial set is implemented as an instance of the class `KAN`, subclass of the class `SIMPLICIAL-SET`.\n",
|
||||
"\n",
|
||||
"```lisp\n",
|
||||
"```commonlisp\n",
|
||||
"(DEFCLASS KAN (simplicial-set)\n",
|
||||
" ((kfll :type kfll :initarg :kfll :reader kfll1)))\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"We recall that this new class inherits also from the class ``CHAIN-COMPLEX``. It has one slot of its own:\n",
|
||||
"We recall that this new class inherits also from the class `CHAIN-COMPLEX`. It has one slot of its own:\n",
|
||||
"\n",
|
||||
"``kfll``\n",
|
||||
"> an object of type ``KFLL``, in fact a lisp function with 3 parameters describing a Kan hat: an index (an integer), a dimension (an integer) and the Kan hat (a list of abstract simplices). This function must return a filling of the Kan hat argument, i.e. an abstract simplex satisfying the theoritical definition.\n",
|
||||
"`kfll`\n",
|
||||
"> an object of type `KFLL`, in fact a lisp function with 3 parameters describing a Kan hat: an index (an integer), a dimension (an integer) and the Kan hat (a list of abstract simplices). This function must return a filling of the Kan hat argument, i.e. an abstract simplex satisfying the theoritical definition.\n",
|
||||
"\n",
|
||||
"A printing method has been associated to the class ``KAN`` and the external representation of an instance is a string like ``[K``*n* ``Kan-Simplicial-Set]``, where *n* is the number plate of the Kenzo object.\n",
|
||||
"A printing method has been associated to the class `KAN` and the external representation of an instance is a string like `[K`*n* `Kan-Simplicial-Set]`, where *n* is the number plate of the Kenzo object.\n",
|
||||
"\n",
|
||||
"### Helpful functions on Kan simplicial sets\n",
|
||||
"\n",
|
||||
"``cat-init`` *[Function]*\n",
|
||||
"> Clear in particular ``*Kan-list*``, the list of user created Kan simplicial sets and reset the global counter to 1.\n",
|
||||
"`cat-init` *[Function]*\n",
|
||||
"> Clear in particular `*Kan-list*`, the list of user created Kan simplicial sets and reset the global counter to 1.\n",
|
||||
"\n",
|
||||
"``Kan`` *n* *[Function]*\n",
|
||||
"> Retrieve in the list ``*Kan-list*`` the Kan object instance whose the Kenzo identification is n. If it does not exist, return ``NIL``.\n",
|
||||
"`Kan` *n* *[Function]*\n",
|
||||
"> Retrieve in the list `*Kan-list*` the Kan object instance whose the Kenzo identification is n. If it does not exist, return `NIL`.\n",
|
||||
"\n",
|
||||
"``kfll &rest`` *args* *[Macro]*\n",
|
||||
"> With only one argument (a Kan instance) return the slot ``kfll`` of this instance. With 4 arguments\n",
|
||||
"like ``(kfll`` *kan indx dmns hat*``)``, return a filling of the Kan hat *hat*, of dimension *dmns*\n",
|
||||
"and of index *indx* by applying the filling function value of the slot ``kfll`` of the Kan instance *kan*.\n",
|
||||
"`kfll &rest` *args* *[Macro]*\n",
|
||||
"> With only one argument (a Kan instance) return the slot `kfll` of this instance. With 4 arguments\n",
|
||||
"like `(kfll` *kan indx dmns hat*`)`, return a filling of the Kan hat *hat*, of dimension *dmns*\n",
|
||||
"and of index *indx* by applying the filling function value of the slot `kfll` of the Kan instance *kan*.\n",
|
||||
"\n",
|
||||
"``smst-kan`` *smst kfll* *[Function]*\n",
|
||||
"> With the filling lisp function *kfll*, **transform** the simplicial set *smst* in an object of type ``KAN`` (in other word, *smst* is ``modified``). This is the easiest way to build a Kan simplicial set.\n",
|
||||
"`smst-kan` *smst kfll* *[Function]*\n",
|
||||
"> With the filling lisp function *kfll*, **transform** the simplicial set *smst* in an object of type `KAN` (in other word, *smst* is `modified`). This is the easiest way to build a Kan simplicial set.\n",
|
||||
"\n",
|
||||
"``check-hat`` *kan indx dmns hat* *[Function]*\n",
|
||||
"> Useful verification function to check if the collection of simplices ``hat`` is a valid Kan hat of dimension *dmns* and of index *indx* in the Kan simplicial set *kan*. In fact this works equally if *kan* is a general simplicial set.\n",
|
||||
"`check-hat` *kan indx dmns hat* *[Function]*\n",
|
||||
"> Useful verification function to check if the collection of simplices `hat` is a valid Kan hat of dimension *dmns* and of index *indx* in the Kan simplicial set *kan*. In fact this works equally if *kan* is a general simplicial set.\n",
|
||||
"\n",
|
||||
"``check-kan`` *kan indx dmns hat* *[Function]*\n",
|
||||
"`check-kan` *kan indx dmns hat* *[Function]*\n",
|
||||
"> Useful verification function to check if the collection of simplices *hat* is a valid Kan hat of dimension *dmns* and of index *indx* in the Kan simplicial set *kan*. This verification function applies the filling function of the instance *kan* to the argument *hat* and perform the verification of the faces relations upon the resulting $dmns$-simplex.\n",
|
||||
"\n",
|
||||
"### Examples\n",
|
||||
"\n",
|
||||
"Let us take again the small examples of the introduction. First we define a function ``dkfll``, \n",
|
||||
"Let us take again the small examples of the introduction. First we define a function `dkfll`, \n",
|
||||
"a filling function suitable for a Kan hat in $\\Delta^\\mathbb{N}$. The user will note that in the abstract simplices the degeneracy operators and the geometric simplices are coded in binary."
|
||||
]
|
||||
},
|
||||
@ -82,7 +82,7 @@
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"SIMPLE-STYLE-WARNING: \n",
|
||||
" #<SB-INT:SIMPLE-STYLE-WARNING \"undefined ~(~A~): ~S\" {1005215B13}>\n"
|
||||
" #<SB-INT:SIMPLE-STYLE-WARNING \"undefined ~(~A~): ~S\" {1005215EB3}>\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
@ -376,9 +376,9 @@
|
||||
"\n",
|
||||
"### Lisp files concerned in this chapter\n",
|
||||
"\n",
|
||||
"``kan.lisp``.\n",
|
||||
"`kan.lisp`.\n",
|
||||
"\n",
|
||||
"[``classes.lisp``, ``macros.lisp``, ``various.lisp``]."
|
||||
"[`classes.lisp`, `macros.lisp`, `various.lisp`]."
|
||||
]
|
||||
}
|
||||
],
|
||||
|
||||
@ -9,7 +9,7 @@
|
||||
"## Introduction\n",
|
||||
"\n",
|
||||
"One knows that the homology groups of a cartesian product of two spaces $K$ and $L$ may be obtained by considering a chain complex derived from respective chain complexes of $K$ and $L$ by taking their *tensor product*.\n",
|
||||
"But this is only one of the numerous uses of tensor products of chain complexes in algebraic topology, so the ``Kenzo`` software provides the handling of such an important tool.\n",
|
||||
"But this is only one of the numerous uses of tensor products of chain complexes in algebraic topology, so the `Kenzo` software provides the handling of such an important tool.\n",
|
||||
"\n",
|
||||
"Let us recall that chain complexes are free $\\mathbb{Z}$-modules with distinguished basis. A tensor product of chain complexes \n",
|
||||
"is itself a free $\\mathbb{Z}$-module with a natural basis formed by the tensor product of the generators of the chain complex factors. The program conforms to that rule.\n",
|
||||
@ -17,7 +17,7 @@
|
||||
"## Tensor product of generators and combinations\n",
|
||||
"\n",
|
||||
"An elementary tensor product of two generators is represented, in the software, by a structured list in which we may find 4 items for the description of the two generators together with their respective degree. The internal representation of $gnrt1 \\otimes gnrt2$ has the form:\n",
|
||||
"```lisp\n",
|
||||
"```commonlisp\n",
|
||||
"(:tnpr (degr1 . gnrt1) . (degr2 . gnrt2))\n",
|
||||
"```\n",
|
||||
"where,\n",
|
||||
@ -25,33 +25,33 @@
|
||||
"2. *gnrt1* is the first generator of the pair.\n",
|
||||
"3. *degr2* is an integer, the degree of the generator *gnrt2*.\n",
|
||||
"4. *gnrt2* is the second generator of the pair.\n",
|
||||
"To construct such an object, one may use the macro ``tnpr``. The corresponding type is ``TNPR``. The printing method prints the tensor product under the form:\n",
|
||||
">``<TnPr`` *gnrt1 gnrt2*``>`` or ``<TnPr`` *degr1 gnrt1 degr2 gnrt2*``>``\n",
|
||||
"To construct such an object, one may use the macro `tnpr`. The corresponding type is `TNPR`. The printing method prints the tensor product under the form:\n",
|
||||
">`<TnPr` *gnrt1 gnrt2*`>` or `<TnPr` *degr1 gnrt1 degr2 gnrt2*`>`\n",
|
||||
"\n",
|
||||
"according to the boolean value, ``NIL`` (default) or ``T`` of the system variable ``*tnpr-with-degrees*`` (see the examples).\n",
|
||||
"according to the boolean value, `NIL` (default) or `T` of the system variable `*tnpr-with-degrees*` (see the examples).\n",
|
||||
"\n",
|
||||
"### Simple functions for the tensor product\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"``(tnpr degr1 gnrt1 degr2 gnrt2)`` *[Macro]*\n",
|
||||
"`(tnpr degr1 gnrt1 degr2 gnrt2)` *[Macro]*\n",
|
||||
"> Build a tensor product $gnrt1 \\otimes gnrt2$.\n",
|
||||
"\n",
|
||||
"``(tnpr-p object)`` *[Predicate]*\n",
|
||||
"> Test if *object* is of type ``TNPR``.\n",
|
||||
"`(tnpr-p object)` *[Predicate]*\n",
|
||||
"> Test if *object* is of type `TNPR`.\n",
|
||||
"\n",
|
||||
"``(degr1 tnpr)`` *[Macro]*\n",
|
||||
"`(degr1 tnpr)` *[Macro]*\n",
|
||||
"> Select the degree of the first generator in the tensor product *tnpr*.\n",
|
||||
"\n",
|
||||
"``(gnrt1 tnpr)`` *[Macro]*\n",
|
||||
"`(gnrt1 tnpr)` *[Macro]*\n",
|
||||
"> Select the first generator from the object *tnpr*.\n",
|
||||
"\n",
|
||||
"``(degr2 tnpr)`` *[Macro]*\n",
|
||||
"`(degr2 tnpr)` *[Macro]*\n",
|
||||
"> Select the degree of the second generator in the tensor product *tnpr*.\n",
|
||||
"\n",
|
||||
"``(gnrt2 tnpr)`` *[Macro]*\n",
|
||||
"`(gnrt2 tnpr)` *[Macro]*\n",
|
||||
"> Select the second generator from the object *tnpr*.\n",
|
||||
"\n",
|
||||
"``(2cmbn-tnpr cmbn1 cmbn2)`` *[Function]*\n",
|
||||
"`(2cmbn-tnpr cmbn1 cmbn2)` *[Function]*\n",
|
||||
"> Create, from two combinations *cmbn1* and *cmbn2* with respective degree *degr1* and *degr2*, a combination of degree $dgr1 + dgr2$ by applying the tensorial distributive law on the two sums of terms of the combinations.\n",
|
||||
"\n",
|
||||
"#### Example"
|
||||
@ -252,16 +252,16 @@
|
||||
"with $c_m\\in C_m,\\ c_n'\\in C_n'$ and $d$, $d'$ being the respective boundary operators\n",
|
||||
"of $C$ and $C'$.\n",
|
||||
"\n",
|
||||
"In the software, this is realized by the function ``tnsr-prdc``. \n",
|
||||
"In the software, this is realized by the function `tnsr-prdc`. \n",
|
||||
"\n",
|
||||
"``(tnsr-prdc chcm1 chcm2)`` *[Method]*\n",
|
||||
"`(tnsr-prdc chcm1 chcm2)` *[Method]*\n",
|
||||
"> Build a chain complex, tensor product of the two chain complexes *chcm1* and *chcm2*. The elements\n",
|
||||
"of this new chain complex are integer combinations of generators of *TNPR* type. The creation of this\n",
|
||||
"new chain complex is done by a call to the function *build-chcm* with actual parameters defined from the constituting elements of *chcm1* and *chcm2*, according to the mathematical definitions above. If both arguments are *effective*, the function constructs an *effective* chain complex. On the other hand, if at least one of the chain complex is *locally effective*, the tensor product is also *locally effective*. In fact, the construction is correct only if both chain complexes are null in negative degrees, otherwise the result is undefined.\n",
|
||||
"\n",
|
||||
"#### Examples\n",
|
||||
"\n",
|
||||
"Let us take the standard 2-simplex, $\\Delta^2$ and let us build $C_*(\\Delta^2) \\otimes C_*(\\Delta^2)$. To build the corresponding chain complex, we use the function ``cdelta``, defined in a previous chapter."
|
||||
"Let us take the standard 2-simplex, $\\Delta^2$ and let us build $C_*(\\Delta^2) \\otimes C_*(\\Delta^2)$. To build the corresponding chain complex, we use the function `cdelta`, defined in a previous chapter."
|
||||
]
|
||||
},
|
||||
{
|
||||
@ -523,7 +523,7 @@
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"Let us consider now the chain complex, $ccn$, that we used in the chain complex chapter. The basis in any degree are decades produced by the function ``<a-b<``. We build $ccn\\otimes ccn$ and we verify the fundamental property of the associated boundary operator:\n",
|
||||
"Let us consider now the chain complex, $ccn$, that we used in the chain complex chapter. The basis in any degree are decades produced by the function `<a-b<`. We build $ccn\\otimes ccn$ and we verify the fundamental property of the associated boundary operator:\n",
|
||||
"\n",
|
||||
"$$d^\\otimes \\circ d^\\otimes=0.$$"
|
||||
]
|
||||
@ -538,7 +538,7 @@
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"#<FUNCTION (LAMBDA (DGR GNR) :IN \"/root/cl-jupyter-master/cl-jupyter.lisp\") {1005ACB71B}>"
|
||||
"#<FUNCTION (LAMBDA (DGR GNR) :IN \"/root/cl-jupyter-master/cl-jupyter.lisp\") {1005ACABBB}>"
|
||||
]
|
||||
},
|
||||
"execution_count": 18,
|
||||
@ -779,31 +779,31 @@
|
||||
"\n",
|
||||
"$$ (f\\otimes g) (a_1 \\otimes b_1)= (-1)^{deg(g)*deg(a1)}f(a_1) \\otimes g(b_1).$$\n",
|
||||
"\n",
|
||||
"The method ``tnsr-prdc`` already defined for chain complexes, may be also used for that purpose. \n",
|
||||
"The method `tnsr-prdc` already defined for chain complexes, may be also used for that purpose. \n",
|
||||
"\n",
|
||||
"``(tnsr-prdc mrph1 mrph2)`` *[Method]*\n",
|
||||
"`(tnsr-prdc mrph1 mrph2)` *[Method]*\n",
|
||||
"> Return the morphism, tensor product of the two morphisms *mrph1* and *mrph2*. The source\n",
|
||||
"and target of this new morphism are respectively the tensor product of the chain complexes source\n",
|
||||
"and target of *mrph1* and *mrph2*. The degree is the sum of the degrees of the parameters\n",
|
||||
"and the lisp function (the ``:pure`` keyword argument of the function ``build-mrph``) conforms to the mathematical definition above. The strategy is by generator, i.e. the morphism is designed to work with 2 arguments: a degree and a generator which must be an object of type ``TNPR``.\n",
|
||||
"and the lisp function (the `:pure` keyword argument of the function `build-mrph`) conforms to the mathematical definition above. The strategy is by generator, i.e. the morphism is designed to work with 2 arguments: a degree and a generator which must be an object of type `TNPR`.\n",
|
||||
"\n",
|
||||
"``(tnsr-prdc rdct1 rdct2)`` *[Method]*\n",
|
||||
"`(tnsr-prdc rdct1 rdct2)` *[Method]*\n",
|
||||
"> Return the reduction, tensor product of the two reductions *rdct1* and *rdct2*. The algorithm consists essentially in defining\n",
|
||||
"$$f=f1 \\otimes f2,\\, g=g1 \\otimes g2,\\, h= h1 \\otimes (g2 \\circ g2) + Id_{tcc1} \\otimes h2,$$\n",
|
||||
"where $Id_{tcc1}$ is the identity morphism in the top chain complex of the reduction *rdct1*.\n",
|
||||
"The returned reduction is then built by a call to the method ``build-rdct``. This defines completely the chain complexes involved in the reduction.\n",
|
||||
"The returned reduction is then built by a call to the method `build-rdct`. This defines completely the chain complexes involved in the reduction.\n",
|
||||
"\n",
|
||||
"``(tnsr-prdc hmeq1 hmeq2)`` *[Method]*\n",
|
||||
"`(tnsr-prdc hmeq1 hmeq2)` *[Method]*\n",
|
||||
"> Return the homotopy equivalence, tensor product of the two homotopy equivalence *heqm1* and *heqm2*. \n",
|
||||
"This is a homotopy equivalence where the new reductions are the tensor products of the arguments reductions (See the lisp definition just below).\n",
|
||||
"\n",
|
||||
"### Searching homology for tensor products\n",
|
||||
"\n",
|
||||
"The comment list of a tensor product of two chain complexes has the form \n",
|
||||
"``(TNSR-PRDC`` *chcm1 chcm2*``)``. The ``search-efhm`` method applied to a tensor product, looks for the value of the respective ``efhm`` slots of the chain complexes *chcm1* and *chcm2*, (i.e. two homotopy equivalences) or tries to settle these slots if they are still unbound. Then it builds the tensor product of both homotopy equivalences, as shown in the following lisp listing. At its turn,\n",
|
||||
"the resulting homotopy equivalence will become the value of the {\\tt efhm} slot of the initial tensor product chain complex.\n",
|
||||
"`(TNSR-PRDC` *chcm1 chcm2*`)`. The `search-efhm` method applied to a tensor product, looks for the value of the respective `efhm` slots of the chain complexes *chcm1* and *chcm2*, (i.e. two homotopy equivalences) or tries to settle these slots if they are still unbound. Then it builds the tensor product of both homotopy equivalences, as shown in the following lisp listing. At its turn,\n",
|
||||
"the resulting homotopy equivalence will become the value of the `efhm` slot of the initial tensor product chain complex.\n",
|
||||
"\n",
|
||||
"```lisp\n",
|
||||
"```commonlisp\n",
|
||||
"(defmethod SEARCH-EFHM (chcm (orgn (eql 'tnsr-prdc)))\n",
|
||||
" (declare (type chain-complex chcm))\n",
|
||||
" (the homotopy-equivalence\n",
|
||||
@ -821,7 +821,7 @@
|
||||
"\n",
|
||||
"#### Lisp file concerned in this chapter\n",
|
||||
"\n",
|
||||
"``tensor-products.lisp``, ``searching-homology.lisp``."
|
||||
"`tensor-products.lisp`, `searching-homology.lisp`."
|
||||
]
|
||||
}
|
||||
],
|
||||
|
||||
File diff suppressed because one or more lines are too long
@ -6,52 +6,52 @@
|
||||
"source": [
|
||||
"# Simplicial morphisms\n",
|
||||
"\n",
|
||||
"The software ``Kenzo`` implements simplicial morphisms in a way analogous to chain complex morphisms.\n",
|
||||
"The software `Kenzo` implements simplicial morphisms in a way analogous to chain complex morphisms.\n",
|
||||
"\n",
|
||||
"## Representation of a simplicial morphism\n",
|
||||
"\n",
|
||||
"A simplicial morphism is an instance of the class ``SIMPLICIAL-MRPH``, subclass of the class ``MORPHISM``.\n",
|
||||
"A simplicial morphism is an instance of the class `SIMPLICIAL-MRPH`, subclass of the class `MORPHISM`.\n",
|
||||
"\n",
|
||||
"```lisp\n",
|
||||
"```commonlisp\n",
|
||||
"(DEFCLASS SIMPLICIAL-MRPH (morphism)\n",
|
||||
" ((sintr :type sintr :initarg :sintr :reader sintr)))\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"It has one slot of its own:\n",
|
||||
"> ``sintr``, an object of type ``SINTR``, in fact a lisp function defining the morphism between the source and target simplicial sets. It must have 2 parameters: a dimension (an integer) and a geometric simplex of this dimension (a generator of any type) . It must return an abstract simplex, image in the target simplicial set of this geometric simplex.\n",
|
||||
"> `sintr`, an object of type `SINTR`, in fact a lisp function defining the morphism between the source and target simplicial sets. It must have 2 parameters: a dimension (an integer) and a geometric simplex of this dimension (a generator of any type) . It must return an abstract simplex, image in the target simplicial set of this geometric simplex.\n",
|
||||
"\n",
|
||||
"A printing method has been associated to the class ``SIMPLICIAL-MRPH``. A string like ``[K``*n* ``Simplicial-Morphism]`` is the external representation of an instance of such a class, where *n* is the number plate of the ``Kenzo`` object.\n",
|
||||
"A printing method has been associated to the class `SIMPLICIAL-MRPH`. A string like `[K`*n* `Simplicial-Morphism]` is the external representation of an instance of such a class, where *n* is the number plate of the `Kenzo` object.\n",
|
||||
"\n",
|
||||
"## The function ``build-smmr``\n",
|
||||
"## The function `build-smmr`\n",
|
||||
"\n",
|
||||
"To facilitate the construction of instances of the class ``SIMPLICIAL-MRPH`` and to free the user to call the standard constructor ``make-instance``, the software provides the function\n",
|
||||
"To facilitate the construction of instances of the class `SIMPLICIAL-MRPH` and to free the user to call the standard constructor `make-instance`, the software provides the function\n",
|
||||
"\n",
|
||||
"> ``build-smmr :sorc`` *sorc* ``:trgt`` *trgt* ``:degr`` *degr* ``:sintr`` *sintr* ``:intr`` *intr* ``:strt`` *strt* ``:orgn`` *orgn*\n",
|
||||
"> `build-smmr :sorc` *sorc* `:trgt` *trgt* `:degr` *degr* `:sintr` *sintr* `:intr` *intr* `:strt` *strt* `:orgn` *orgn*\n",
|
||||
"\n",
|
||||
"defined with keyword parameters and returning an instance of the class ``SIMPLICIAL-MRPH``. The keyword arguments of ``build-smmr`` are:\n",
|
||||
"defined with keyword parameters and returning an instance of the class `SIMPLICIAL-MRPH`. The keyword arguments of `build-smmr` are:\n",
|
||||
"\n",
|
||||
"- *sorc*, the source object, an object of type ``SIMPLICIAL-SET``.\n",
|
||||
"- *trgt*, the target object, an object of type ``SIMPLICIAL-SET``.\n",
|
||||
"- *sorc*, the source object, an object of type `SIMPLICIAL-SET`.\n",
|
||||
"- *trgt*, the target object, an object of type `SIMPLICIAL-SET`.\n",
|
||||
"- *degr*, the degree of the morphism, an integer. In this chapter, we consider only the 0 degree case (the usual one). The case -1 is particularly important: it allows to implement the notion of twisting operator defining a fibration (See the chapter Fibration).\n",
|
||||
"- *sintr*, the internal lisp function defining the effective mapping between simplicial sets. If the integer *degr* is 0 and if the following keyword argument *intr* is omitted, then the function ``build-smmr`` builds a lisp function implementing the induced mapping between the underlying source and target chain complexes. This function is installed in the slot ``intr``. The strategy is then set to ``:gnrt``.\n",
|
||||
"- ``intr``, a user defined morphism for the underlying chain complexes. This argument is optional and taken in account only if the degree is 0 and in this case, supersedes the previous derived mapping. The strategy is then mandatory. If the degree is not null, the implementor has decided to set the corresponding slot to ``NIL``.\n",
|
||||
"- *strt*, the strategy, i.e. ``:gnrt`` or ``:cmbn`` attached to the previous function.\n",
|
||||
"- *sintr*, the internal lisp function defining the effective mapping between simplicial sets. If the integer *degr* is 0 and if the following keyword argument *intr* is omitted, then the function `build-smmr` builds a lisp function implementing the induced mapping between the underlying source and target chain complexes. This function is installed in the slot `intr`. The strategy is then set to `:gnrt`.\n",
|
||||
"- `intr`, a user defined morphism for the underlying chain complexes. This argument is optional and taken in account only if the degree is 0 and in this case, supersedes the previous derived mapping. The strategy is then mandatory. If the degree is not null, the implementor has decided to set the corresponding slot to `NIL`.\n",
|
||||
"- *strt*, the strategy, i.e. `:gnrt` or `:cmbn` attached to the previous function.\n",
|
||||
"- *orgn*, a relevant comment list.\n",
|
||||
"\n",
|
||||
"After a call to ``build-smmr``, the simplicial morphism instance is added to a list of previously constructed ones (``*smmr-list*``). As the other similar lists, the list ``*smmr-list*`` may be cleared by the function ``cat-init``.\n",
|
||||
"After a call to `build-smmr`, the simplicial morphism instance is added to a list of previously constructed ones (`*smmr-list*`). As the other similar lists, the list `*smmr-list*` may be cleared by the function `cat-init`.\n",
|
||||
"\n",
|
||||
"The effective application of a simplicial morphism upon arguments, is realized with the macro ``?`` which calls the adequate method defined for this kind of objects.\n",
|
||||
"The effective application of a simplicial morphism upon arguments, is realized with the macro `?` which calls the adequate method defined for this kind of objects.\n",
|
||||
"\n",
|
||||
"After a call to ``build-smmr``, the simplicial morphism instance is added to a list of previously constructed ones (``*smmr-list*``). As the other similar lists, the list ``*smmr-list*`` may be cleared by the function ``cat-init``.\n",
|
||||
"After a call to `build-smmr`, the simplicial morphism instance is added to a list of previously constructed ones (`*smmr-list*`). As the other similar lists, the list `*smmr-list*` may be cleared by the function `cat-init`.\n",
|
||||
"\n",
|
||||
"The effective application of a simplicial morphism upon arguments, is realized with the macro ``?`` which calls the adequate method defined for this kind of objects.\n",
|
||||
"The effective application of a simplicial morphism upon arguments, is realized with the macro `?` which calls the adequate method defined for this kind of objects.\n",
|
||||
"\n",
|
||||
"``? &rest`` *args* *[Macro]*\n",
|
||||
"> Versatile macro for applying a simplicial morphism indifferently as ``(?`` *smmr dmns absm-or-gmsm*``)`` or ``(?`` *smmr cmbn*``)``. In the first case, the third argument is either an abstract simplex or a geometric one. In the second case, if the second argument is a combination, *smmr* is then considered as a chain complex morphism and it is the function in the slot ``intr`` which is applied, so that it makes sense only if the degree of the mapping is 0.\n",
|
||||
"`? &rest` *args* *[Macro]*\n",
|
||||
"> Versatile macro for applying a simplicial morphism indifferently as `(?` *smmr dmns absm-or-gmsm*`)` or `(?` *smmr cmbn*`)`. In the first case, the third argument is either an abstract simplex or a geometric one. In the second case, if the second argument is a combination, *smmr* is then considered as a chain complex morphism and it is the function in the slot `intr` which is applied, so that it makes sense only if the degree of the mapping is 0.\n",
|
||||
"\n",
|
||||
"### Examples\n",
|
||||
"\n",
|
||||
"In the following examples, we work with $\\Delta_3$. We define three simplicial morphisms, ``sm1``, ``sm2`` and ``sm3``. In ``sm1``, the mapping is the identity mapping and we can see that this identity mapping has been propagated on the underlying chain complex."
|
||||
"In the following examples, we work with $\\Delta_3$. We define three simplicial morphisms, `sm1`, `sm2` and `sm3`. In `sm1`, the mapping is the identity mapping and we can see that this identity mapping has been propagated on the underlying chain complex."
|
||||
]
|
||||
},
|
||||
{
|
||||
@ -184,7 +184,7 @@
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"In the simplicial morphism ``sm2``, the mapping is the \"null\" mapping. In fact, it consists in applying any abstract simplex in dimension $n$ upon the $n$-degenerate base point. Of course, in terms of chain complex, the corresponding mapping applies any chain complex element upon the null combination of same degree."
|
||||
"In the simplicial morphism `sm2`, the mapping is the \"null\" mapping. In fact, it consists in applying any abstract simplex in dimension $n$ upon the $n$-degenerate base point. Of course, in terms of chain complex, the corresponding mapping applies any chain complex element upon the null combination of same degree."
|
||||
]
|
||||
},
|
||||
{
|
||||
@ -199,7 +199,7 @@
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"SIMPLE-STYLE-WARNING: \n",
|
||||
" #<SB-INT:SIMPLE-STYLE-WARNING \"undefined ~(~A~): ~S\" {1005794753}>\n"
|
||||
" #<SB-INT:SIMPLE-STYLE-WARNING \"undefined ~(~A~): ~S\" {1005794883}>\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
@ -338,7 +338,7 @@
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"In the simplicial morphism ``sm3``, we keep the same \"null\" mapping as in ``sm2`` but we choose as mapping for the underlying chain complex the opposite of any chain complex element."
|
||||
"In the simplicial morphism `sm3`, we keep the same \"null\" mapping as in `sm2` but we choose as mapping for the underlying chain complex the opposite of any chain complex element."
|
||||
]
|
||||
},
|
||||
{
|
||||
@ -353,7 +353,7 @@
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"SIMPLE-STYLE-WARNING: \n",
|
||||
" #<SB-INT:SIMPLE-STYLE-WARNING \"undefined ~(~A~): ~S\" {1005A398C3}>\n"
|
||||
" #<SB-INT:SIMPLE-STYLE-WARNING \"undefined ~(~A~): ~S\" {1005A399D3}>\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
@ -456,9 +456,9 @@
|
||||
"source": [
|
||||
"### Lisp files concerned in this chapter\n",
|
||||
"\n",
|
||||
"``simplicial-mrphs.lisp``.\n",
|
||||
"`simplicial-mrphs.lisp`.\n",
|
||||
"\n",
|
||||
"[``classes.lisp``, ``macros.lisp``, ``various.lisp``]."
|
||||
"[`classes.lisp`, `macros.lisp`, `various.lisp`]."
|
||||
]
|
||||
}
|
||||
],
|
||||
|
||||
File diff suppressed because one or more lines are too long
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue
Block a user