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-04-10 16:57:08 -05:00
parent 0282f18719
commit bd3b3e8a51
2 changed files with 15 additions and 131 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
examples/07_Simplicial_Sets.ipynb
View File

@ -84,7 +84,9 @@
"For instance, if $\\sigma$ is a non-degenerate simplex, and $\\sigma'$ is the degenerate simplex $\\eta_3\\eta_1\\sigma$, the corresponding abstract simplices are respectively $\\lbrace \\emptyset, \\sigma \\rbrace$ and $\\lbrace \\eta_3\\eta_1, \\sigma \\rbrace$.\n", "For instance, if $\\sigma$ is a non-degenerate simplex, and $\\sigma'$ is the degenerate simplex $\\eta_3\\eta_1\\sigma$, the corresponding abstract simplices are respectively $\\lbrace \\emptyset, \\sigma \\rbrace$ and $\\lbrace \\eta_3\\eta_1, \\sigma \\rbrace$.\n",
"\n", "\n",
"An abstract simplex is represented internally in the system by the following lisp object:\n", "An abstract simplex is represented internally in the system by the following lisp object:\n",
"$$\\texttt{#S(ABSM}\\quad\\texttt{:DGOP}\\quad\\mathit{n}\\quad\\texttt{:GMSM}\\quad\\mathit{any}\\texttt{)}$$\n", "```commonlisp\n",
"#S(ABSM :DGOP n :GMSM any)\n",
"```\n",
"where,\n", "where,\n",
"\n", "\n",
"1. *dgop* is a non-negative integer coding a *strictly decreasing integer list*. This strictly decreasing list of integers represents a sequence of $\\eta$ operators and is coded as a **unique** integer as follows. The iterated degeneracy operator $\\eta_{i_k} \\ldots \\eta_{i_1}$ is coded as the integer $\\sum_{j = 1}^k 2^{i_j}$; in other words we use a binary number where the binary digits 1 correspond to the indices of the $\\eta_i$'s. This is made possible by the \\emph{strictly} decreasing property of the indices. For example the degeneracy operator $\\eta_6 \\eta 3 \\eta_0$ is coded by the integer 73, for $73 = 2^6 + 2^3 + 2^0$. This leads to a compact coding, replacing the numerous operations about degeneracy operators by efficient handlings of bits of fixnums. In particular, 0 codes the void composition of degeneracy operator, that is, the identity operator. Two functions are provided to help the user for the transformation in both directions.\n", "1. *dgop* is a non-negative integer coding a *strictly decreasing integer list*. This strictly decreasing list of integers represents a sequence of $\\eta$ operators and is coded as a **unique** integer as follows. The iterated degeneracy operator $\\eta_{i_k} \\ldots \\eta_{i_1}$ is coded as the integer $\\sum_{j = 1}^k 2^{i_j}$; in other words we use a binary number where the binary digits 1 correspond to the indices of the $\\eta_i$'s. This is made possible by the \\emph{strictly} decreasing property of the indices. For example the degeneracy operator $\\eta_6 \\eta 3 \\eta_0$ is coded by the integer 73, for $73 = 2^6 + 2^3 + 2^0$. This leads to a compact coding, replacing the numerous operations about degeneracy operators by efficient handlings of bits of fixnums. In particular, 0 codes the void composition of degeneracy operator, that is, the identity operator. Two functions are provided to help the user for the transformation in both directions.\n",
@ -381,7 +383,7 @@
"\n", "\n",
"```commonlisp\n", "```commonlisp\n",
"(build-smst :cmpr cmpr :basis basis :bspn bspn :face face\n", "(build-smst :cmpr cmpr :basis basis :bspn bspn :face face\n",
" :face* face* :intr-bndr intr-bndr bndr-strt bndr-strt\n", " :face* face* :intr-bndr intr-bndr :bndr-strt bndr-strt\n",
" :intr-dgnl intr-dgnl :dgnl-strt dgnl-strt :orgn orgn\n", " :intr-dgnl intr-dgnl :dgnl-strt dgnl-strt :orgn orgn\n",
"```\n", "```\n",
"\n", "\n",

140
examples/08_Simplicial_morphisms.ipynb
View File

@ -6,7 +6,7 @@
"source": [ "source": [
"# Simplicial morphisms\n", "# Simplicial morphisms\n",
"\n", "\n",
"The software `Kenzo` implements simplicial morphisms in a way analogous to chain complex morphisms.\n", "The program `Kenzo` implements simplicial morphisms in a way analogous to chain complex morphisms.\n",
"\n", "\n",
"## Representation of a simplicial morphism\n", "## Representation of a simplicial morphism\n",
"\n", "\n",
@ -20,20 +20,22 @@
"It has one slot of its own:\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", "\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 `[Simplicial-Morphism K`*s* `-> K`*t*`]` is the external representation of an instance of such a class, where *s* (resp. *t*) is the identification number of the source (resp. target) simplicial set. \n",
"\n", "\n",
"## The function `build-smmr`\n", "## The function `build-smmr`\n",
"\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 program provides the function\n",
"\n", "\n",
"> `build-smmr :sorc` *sorc* `:trgt` *trgt* `:degr` *degr* `:sintr` *sintr* `:intr` *intr* `:strt` *strt* `:orgn` *orgn*\n", "```commonlisp\n",
"build-smmr :sorc sorc :trgt trgt :degr degr :sintr sintr :intr intr :strt strt :orgn orgn\n",
"```\n",
"\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", "\n",
"- *sorc*, the source 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", "- *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", "- *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", "- *sintr*, the internal lisp function defining the effective mapping between simplicial sets. This argument is mandatory. 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", "- `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", "- *strt*, the strategy, i.e. `:gnrt` or `:cmbn` attached to the previous function.\n",
"- *orgn*, a relevant comment list.\n", "- *orgn*, a relevant comment list.\n",
@ -42,16 +44,12 @@
"\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", "\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",
"\n",
"`? &rest` *args* *[Macro]*\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", "> 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", "\n",
"### Examples\n", "### Examples\n",
"\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."
] ]
}, },
{ {
@ -88,7 +86,7 @@
"output_type": "stream", "output_type": "stream",
"text": [ "text": [
"SIMPLE-STYLE-WARNING: \n", "SIMPLE-STYLE-WARNING: \n",
" #<SB-INT:SIMPLE-STYLE-WARNING \"undefined ~(~A~): ~S\" {10053D8EA3}>\n" " #<SB-INT:SIMPLE-STYLE-WARNING \"undefined ~(~A~): ~S\" {10054A0D93}>\n"
] ]
}, },
{ {
@ -184,7 +182,7 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "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, except in degree 0."
] ]
}, },
{ {
@ -199,7 +197,7 @@
"output_type": "stream", "output_type": "stream",
"text": [ "text": [
"SIMPLE-STYLE-WARNING: \n", "SIMPLE-STYLE-WARNING: \n",
" #<SB-INT:SIMPLE-STYLE-WARNING \"undefined ~(~A~): ~S\" {1005794883}>\n" " #<SB-INT:SIMPLE-STYLE-WARNING \"undefined ~(~A~): ~S\" {100585DE93}>\n"
] ]
}, },
{ {
@ -334,122 +332,6 @@
"(? sm2 (cmbn 3 2 15))" "(? sm2 (cmbn 3 2 15))"
] ]
}, },
{
"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."
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"SIMPLE-STYLE-WARNING: \n",
" #<SB-INT:SIMPLE-STYLE-WARNING \"undefined ~(~A~): ~S\" {1005A399D3}>\n"
]
},
{
"data": {
"text/plain": [
"[K8 Simplicial-Morphism K1 -> K1]"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(def sm3 (build-smmr\n",
" :sorc d3 :trgt d3 :degr 0\n",
" :sintr #'(lambda (dmns gmsm)\n",
" (declare (ignore gmsm))\n",
" (absm (mask dmns) 1))\n",
" :intr #'cmbn-opps\n",
" :strt :cmbn\n",
" :orgn '(null and opposite delta-3)))"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"<AbSm 2-1-0 1>"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(? sm3 3 15)"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"\n",
"----------------------------------------------------------------------{CMBN 3}\n",
"<-7 * 15>\n",
"------------------------------------------------------------------------------\n"
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(? sm3 (cmbn 3 7 15))"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"\n",
"----------------------------------------------------------------------{CMBN 3}\n",
"<-11 * 15>\n",
"------------------------------------------------------------------------------\n"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(? sm3 (cmbn 3 11 (dlop-ext-int '(0 1 2 3))))"
]
},
{ {
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},