diff --git a/examples/Chapter7.ipynb b/examples/Chapter7.ipynb index a84a45f..09c75b4 100644 --- a/examples/Chapter7.ipynb +++ b/examples/Chapter7.ipynb @@ -1955,7 +1955,397 @@ "cell_type": "markdown", "metadata": {}, "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", + "> ````\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: ``, ``. \n", + "- Dimension 1: ``, , ``. \n", + "- Dimension 2: ``, , , ``.\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 : ( \n", + " \n", + " \n", + " )\n", + "\n", + "Dimension 1 :\n", + "\n", + " Simplex : \n", + "\n", + " Faces : ( >\n", + " >)\n", + "\n", + " Simplex : \n", + "\n", + " Faces : ( >\n", + " >)\n", + "\n", + " Simplex : \n", + "\n", + " Faces : ( >\n", + " >)\n", + "\n", + " Simplex : \n", + "\n", + " Faces : ( >\n", + " >)\n", + "\n", + " Simplex : \n", + "\n", + " Faces : ( >\n", + " >)\n", + "\n", + "Dimension 2 :\n", + "\n", + " Simplex : \n", + "\n", + " Faces : ( >\n", + " >\n", + " >)\n", + "\n", + " Simplex : \n", + "\n", + " Faces : ( >\n", + " >\n", + " >)\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``]." ] } ], diff --git a/examples/ssquare.png b/examples/ssquare.png new file mode 100644 index 0000000..3807b0d Binary files /dev/null and b/examples/ssquare.png differ