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

First draft of Chapter 7.

Browse Source
This commit is contained in:
gheber 2016-03-05 16:13:20 -06:00
parent 7a71dad219
commit 6f03e38e7f
2 changed files with 391 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

392
examples/Chapter7.ipynb
View File

@ -1955,7 +1955,397 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"## Cartesian product of simplicials sets" "## Cartesian product of simplicials sets\n",
"\n",
"Let $X$ and $Y$ be two simplicial sets, the construction of $X\\times Y$ is based on the very definition $(X\\times Y)_n =X_n\\times Y_n$ where $X_n$, $Y_n$ and $(X\\times Y)_n$ are the *possibly degenerate* simplices of $X$, $Y$ and $X\\times Y$\n",
"respectively. A simplex of the product $X\\times Y$ is characterized by its projections on the factors $X$ and $Y$.\n",
"\n",
"The *non-degenerate* simplices of $X\\times Y$ are represented internally in the system by a lisp object of the form:\n",
"\n",
"> ``(:crpr (``*dgop1* ``.`` *gmsm1*``).(``*dgop2* ``.`` *gmsm2*``))``\n",
"\n",
"where,\n",
"1. ``dgop1`` is an integer representing a coded degeneracy operator.\n",
"2. ``gmsm1`` is a non-degenerate simplex of $X$, to which is applied the degeneracy operator ``dgop1``.\n",
"3. ``dgop2`` is an integer representing a coded degeneracy operator.\n",
"4. ``gmsm2`` is a non-degenerate simplex of $Y$, to which is applied the degeneracy operator ``dgop2``.\n",
"\n",
"This object must be a *non-degenerate* simplex of $X \\times Y$, that is to say, the degeneracy operators *dgop1* and *dgop2* must not have a common $\\eta_j$, and therefore their list representations must have a void intersection.\n",
"The coded representation by binary bit positions, has the same property. The corresponding type is ``CRPR``.\n",
"To construct such an object, one may use the macro ``crpr``. As usual, a printing method has been defined to reflect the structure of the product under the form:\n",
"\n",
"> ``<CrPr`` *ext-dgop1 gmsm1 ext-dgop2 gmsm2*``>``\n",
"\n",
"where the sequence of the operators $\\eta_i$ is printed in explicit form (this is the meaning of *ext-dgop*).\n",
"If this sequence of $\\eta_i$ is void, i.e. if the simplex *gmsm* is not degenerate, the symbol ``-`` is printed instead.\n",
"\n",
"### Functions and macros for the product of simplicial sets\n",
"\n",
"``crpr`` *dgop1 gmsm1 dgop2 gmsm2* *[Macro]*\n",
"> Build an object of type ``CRPR``, using directly the integer coding for the degeneracy operators. The arguments *gmsm1* and *gmsm2* are non-degenerate simplices.\n",
"\n",
"``crpr`` *absm1 absm2* *[Macro]*\n",
"> Build an object of type ``CRPR``, using two abstract simplices *absm1* and *absm2*. If these abstract simplices are degenerate, the degeneracy operators must verify the condition of the definition, i.e. no common $\\eta_i$.\n",
"\n",
"``2absm-acrpr`` *absm1 absm2* *[Function]*\n",
"> Build an abstract simplex, i.e. object of type ``ABSM``, cartesian product of both abstract simplices *absm1* and *absm2*. In contrast with the previous function, there is no condition upon the degeneracy operators of the abstract simplices. Of course, the function ``2absm-acrpr`` returns a legal abstract simplex.\n",
"\n",
"``crpr-p`` *object* *[Predicate]*\n",
">Test if *object* is of type ``CRPR``.\n",
"\n",
"``dgop1`` *crpr* *[Macro]*\n",
"> Select the degeneracy operator *dgop1* from the object ``crpr``.\n",
"\n",
"``gmsm1`` *crpr* *[Macro]*\n",
"> Select the geometric simplex *gmsm1* from the object ``crpr``.\n",
"\n",
"``dgop2`` *crpr* *[Macro]*\n",
"> Select the degeneracy operator *dgop2* from the object ``crpr``.\n",
"\n",
"``gmsm2`` *crpr* *[Macro]*\n",
"> Select the geometric simplex *gmsm2* from the object ``crpr``.\n",
"\n",
"``absm1`` *crpr* *[Macro]*\n",
"> Build the abstract simplex ``(absm`` *dgop1 gmsm1*``)`` from *crpr*.\n",
"\n",
"``absm2`` *crpr* *[Macro]*\n",
"> Build the abstract simplex ``(absm`` *dgop2 gmsm2*``)`` from *crpr*.\n",
"\n",
"``crts-prdc`` *smst1 smst2* *[Function]*\n",
"> Build the simplicial set, cartesian product $smst1 \\times smts2$.\n",
"\n",
"### Examples\n",
"\n",
"In the first example, note that the coded representations of $\\eta_1$ and $\\eta_2$ are respectively 2 and 4, but these degeneracy operators appear clearly as 1 and 2 in the printed result. In the second statement, the integer 28 is the coded representation of the degeneracy ``(4 3 2)``."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"(crpr 2 'a 4 'b)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"(crpr 0 '(0 1 2 3 4 5) 28 '(0 1 2))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"For more clarity, one may also write:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"(crpr 0 '(0 1 2 3 4 5) (dgop-ext-int '(4 3 2)) '(0 1 2))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In the following example, we see that both functions ``crpr`` and ``2absm-acrpr`` return the same geometric simplex,"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"(crpr (absm 4 'a)(absm 3 'b))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"(2absm-acrpr (absm 4 'a)(absm 3 'b))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"whereas, in the following call to ``crpr``, the condition upon the degeneracy operator is not respected and the result is an illegal cartesian product. The function ``2absm-acrpr`` returns the correct answer."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"(crpr (absm 5 'a)(absm 3 'b))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"(2absm-acrpr (absm 5 'a) (absm 3 'b))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The following example is particularly instructive. The simplicial set whose the realization is homeomorphic to the square is built by using the product of two segments. A call like ``(delta n)`` builds the standard $n$-simplex. So first, we generate two copies ``X`` and ``Y`` of the standard 1-simplex and we list the abstract simplices up to dimension 2 for a better understanding of the components of the product ``XY``."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"(def X (delta 1))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"(def Y X)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"(cl-jupyter-user:png-from-file \"ssquare.png\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In list representation (non-coded simplices), the abstract simplices of $X$ up to the dimension 2, including the degenerate ones are:\n",
"\n",
"- Dimension 0: ``<AbSm - (0)>, <AbSm - (1)>``. \n",
"- Dimension 1: ``<AbSm 0 (0)>, <AbSm 0 (1)>, <AbSm - (0 1)>``. \n",
"- Dimension 2: ``<AbSm 1-0 (0)>, <AbSm 1-0 (1)>, <AbSm 0 (0 1)>, <AbSm 1 (0 1)>``.\n",
"\n",
"Let us look first at the non-degenerate simplices of the simplicial set $X \\times Y$. Those simplices are objects of type ``CRPR``. In dimension 1, we see that some projections are degeneracies of vertices and, in dimension 2, the projections are all degeneracies of the 1-simplex ``(0 1)`` coded as 3. Nevertheless, all the listed simplices are *geometric* simplices (i.e. non-degenerate ones) of the product ``XY``. The diagram above shows the relationship between the 3 simplicial sets. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"(def XY (crts-prdc X Y))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"(show-structure XY 2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"To be more readable we may translate the coded representations of the degeneracy operators and of the simplices in the list representation:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"```\n",
"Dimension 0 :\n",
"\n",
" Vertices : (<CrPr - (0) - (0)> \n",
" <CrPr - (0) - (1)> \n",
" <CrPr - (1) - (0)> \n",
" <CrPr - (1) - (1)>)\n",
"\n",
"Dimension 1 :\n",
"\n",
" Simplex : <CrPr 0 (0) - (0 1)>\n",
"\n",
" Faces : (<AbSm - <CrPr - (0) - (1)> >\n",
" <AbSm - <CrPr - (0) - (0)> >)\n",
"\n",
" Simplex : <CrPr 0 (1) - (0 1)>\n",
"\n",
" Faces : (<AbSm - <CrPr - (1) - (1)> >\n",
" <AbSm - <CrPr - (1) - (0)> >)\n",
"\n",
" Simplex : <CrPr - (0 1) 0 (0)>\n",
"\n",
" Faces : (<AbSm - <CrPr - (1) - (0)> >\n",
" <AbSm - <CrPr - (0) - (0)> >)\n",
"\n",
" Simplex : <CrPr - (0 1) 0 (1)>\n",
"\n",
" Faces : (<AbSm - <CrPr - (1) - (1)> >\n",
" <AbSm - <CrPr - (0) - (1)> >)\n",
"\n",
" Simplex : <CrPr - (0 1) - (0 1)>\n",
"\n",
" Faces : (<AbSm - <CrPr - (1) - (1)> >\n",
" <AbSm - <CrPr - (0) - (0)> >)\n",
"\n",
"Dimension 2 :\n",
"\n",
" Simplex : <CrPr 0 (0 1) 1 (0 1)>\n",
"\n",
" Faces : (<AbSm - <CrPr - (0 1) 0 (1)> >\n",
" <AbSm - <CrPr - (0 1) - (0 1)> >\n",
" <AbSm - <CrPr 0 (0) - (0 1)> >)\n",
"\n",
" Simplex : <CrPr 1 (0 1) 0 (0 1)>\n",
"\n",
" Faces : (<AbSm - <CrPr 0 (1) - (0 1)> >\n",
" <AbSm - <CrPr - (0 1) - (0 1)> >\n",
" <AbSm - <CrPr - (0 1) 0 (0)> >)\n",
"```\n",
"\n",
"In an analogous way, let us build the torus as the cartesian product of two 1-spheres. We recall that the base point of the sphere is named ``*``."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"(def s1xs1 (crts-prdc (sphere 1) (sphere 1)))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"(show-structure s1xs1 2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Let us verify that $S^1\\times S^1$ has the same homology groups as the torus."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"(dotimes (i 3)(chcm-homology s1xs1 i))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Of course, we may generate more complex products, whose basis are composed of rather long\n",
"lists of simplices as shown below. The user will also pay attention to the fact that the composition of the macro ``crpr`` is not associative. In the following example, the simplicial sets located respectively by ``p1`` and ``p2`` are different objects, though being canonically isomorphic."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"(def p1 (crts-prdc (sphere 2) (crts-prdc (sphere 2) (sphere 3))))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"(def p2 (crts-prdc (crts-prdc (sphere 2) (sphere 2)) (sphere 3)))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"(dotimes (i 8) (print (length (basis p1 i))))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Lisp files concerned in this chapter\n",
"\n",
"``simplicial-sets.lisp``, ``delta.lisp``, ``specials-smsts.lisp``,\n",
"``cartesian-products.lisp``.\n",
"[``classes.lisp``, ``macros.lisp``, ``various.lisp``]."
] ]
} }
], ],

BIN
examples/ssquare.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 45 KiB