{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "To load \"kenzo\":\n", " Load 1 ASDF system:\n", " kenzo\n", "; Loading \"kenzo\"\n", "\n" ] }, { "data": { "text/plain": [ "#" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(ql:quickload \"kenzo\")\n", "(in-package :cat)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Simplicial morphisms\n", "\n", "The program `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", "\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", "\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", "## 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 program provides the function\n", "\n", "```commonlisp\n", "build-smmr :sorc sorc :trgt trgt :degr degr :sintr sintr :intr intr :strt strt :orgn orgn\n", "```\n", "\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", "- *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. 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", "- *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", "\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", "\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." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[K1 Simplicial-Set]" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(def d3 (delta 3))" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[K6 Simplicial-Morphism K1 -> K1]" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(def sm1 (build-smmr\n", " :sorc d3 :trgt d3 :degr 0\n", " :sintr #'(lambda (dmns gmsm)\n", " (declare (ignore dmns))\n", " (absm 0 gmsm))\n", " :orgn '(identity delta-3)))" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(? sm1 2 7)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(? sm1 1 (absm 1 1))" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\n", "----------------------------------------------------------------------{CMBN 2}\n", "<1 * 7>\n", "------------------------------------------------------------------------------\n" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(? sm1 (cmbn 2 1 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, except in degree 0." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[K7 Simplicial-Morphism K1 -> K1]" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(def sm2 (build-smmr\n", " :sorc d3 :trgt d3 :degr 0\n", " :sintr #'(lambda (dmns gmsm)\n", " (declare (ignore gmsm))\n", " (absm (mask dmns) 1)) ;;; mask(n)=2^n - 1 \n", " :orgn '(null delta-3)))" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(? sm2 0 4)" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(? sm2 2 7)" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(? sm2 1 (absm 1 1))" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(? sm2 3 15)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\n", "----------------------------------------------------------------------{CMBN 3}\n", "------------------------------------------------------------------------------\n" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(? sm2 (cmbn 3 2 15))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Lisp files concerned in this chapter\n", "\n", "`simplicial-mrphs.lisp`.\n", "\n", "[`classes.lisp`, `macros.lisp`, `various.lisp`]." ] } ], "metadata": { "kernelspec": { "display_name": "SBCL Lisp", "language": "lisp", "name": "lisp" }, "language_info": { "codemirror_mode": "text/x-common-lisp", "mimetype": "text/x-common-lisp", "name": "common-lisp", "pygments_lexer": "common-lisp", "version": "X3J13" } }, "nbformat": 4, "nbformat_minor": 1 }