From cdff20c1a59934ffc34cb712c9eae283aec6cc08 Mon Sep 17 00:00:00 2001 From: gheber Date: Mon, 14 Mar 2016 19:04:14 -0500 Subject: [PATCH] First draft of Chapter 13. --- examples/Chapter13.ipynb | 546 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 546 insertions(+) create mode 100644 examples/Chapter13.ipynb diff --git a/examples/Chapter13.ipynb b/examples/Chapter13.ipynb new file mode 100644 index 0000000..779105b --- /dev/null +++ b/examples/Chapter13.ipynb @@ -0,0 +1,546 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Loop Spaces\n", + "\n", + "## Introduction\n", + "\n", + "Let us recall the definition of the *free group* generated by a set ${\\cal A}$. Consider the set ${\\cal A}\\times \\lbrace +1, -1 \\rbrace$ and make, as long as there is no ambiguity, the identification $a_i= (a_i,1)$ and $a_i^{-1}= (a_i,-1)$ for all $a_i\\in{\\cal A}$.\n", + "\n", + "**Definition.** $a_i$ and its formal inverse $a_i^{-1}$ are {\\em letters}.\n", + "\n", + "**Definition.** A word is a *finite* sequence of letters, possibly repeated, without any pair of the form $a_ja_j^{-1}$ and $a_k^{-1}a_k$. The word is said *reduced*.\n", + "\n", + "Now, let $\\mathbb{Z}^{*{\\cal A}}$ the set of *words* on $\\cal A$. It is easy to show that if we define in $\\mathbb{Z}^{*{\\cal A}}$ an internal law of composition as the formal *concatenation* of two words, on which the cancelation rule is applied, i.e. any pair of the form $a_ja_j^{-1}$ and $a_k^{-1}a_k$ is replaced by the *void sequence*, then $\\mathbb{Z}^{*{\\cal A}}$ is a group (non-commutative in general). The void word is the neutral element for that law. If we consider the concatenation as a *product*, then, as usual in group theory, a sequence of $k$ times the same letter $a$ will be written $a^k$ and a sequence of $k$ times the same letter $a^{-1}$, $a^{-k}$. So a word formed from letters by the concatenation product together with the cancellation rule, will be written under the reduced form:\n", + "$$a_1^{n_1}a_2^{n_2}\\ldots a_k^{n_k},\\ n_i\\in \\mathbb{Z}^*,\\ a_i\\in {\\cal A},\\ a_i \\not= a_{i+1}$$\n", + "and its inverse is\n", + "$$a_k^{-n_k}\\ldots a_2^{-n_2}a_1^{-n_1}.$$\n", + "After this resume, let $X$ be a reduced simplicial set (i.e. having only one 0-simplex, namely its base point). The Kan simplicial version $GX$ of the loop space $\\Omega(|X|)$ is defined as follows. The set of $n$-simplices $GX_n$ is the free group generated by the $(n+1)$-simplices $\\sigma \\in X_{n+1}$ except those which are $n$-degenerate. In other words:\n", + "$$ GX_n=\\mathbb{Z}^{*X^+_{n+1}},\\ X^+_{n+1}=X_{n+1}-\\eta_n X_n. $$\n", + "In fact, from a strictly mathematical point of view, the right definition is \n", + "$$ GX_n = \\mathbb{Z}^{*X^+_{n+1}} / {\\overline{\\eta_n X_n}},$$\n", + "i.e. the quotient group of $\\mathbb{Z}^{*X^+_{n+1}}$, the free group generated by **all** the $n+1$--simplices, the $n$-degenerate included, by the normal subgroup ${\\overline{\\eta_n X_n}}$ generated by the $n$-degenerate simplices. Both definitions are equivalent, the second is mathematicaly correct but only the first one is visible in the program.\n", + "\n", + "For a better understanding, we may distinguish carefully a generator $\\sigma$ belonging to $X_{n+1}$ and the corresponding letter $\\tau (\\sigma) \\in GX_n$. So a word, element of $GX_n$ will be written \n", + "$${\\tau(\\sigma_1)}^{\\epsilon_1} {\\tau(\\sigma_2)}^{\\epsilon_2} \\ldots {\\tau(\\sigma_p)}^{\\epsilon_p}.$$\n", + "Now, let us define two homomorphisms:\n", + "$$\\overline{\\partial}_i^n: GX_n \\longrightarrow GX_{n-1},\\ \\overline{\\eta}_i^n: GX_n \\longrightarrow GX_{n+1},$$\n", + "by the following relations, keeping in mind that $\\partial_i$ and $\\eta_i$ are respectively the face and degeneracy operators acting on the simplices of $X$:\n", + "$$\n", + "\\begin{aligned}\n", + "\\overline{\\partial}_i(\\tau(\\sigma)) & = & \\tau(\\partial_i\\sigma),\\qquad 0 \\leq i < n, \\\\\n", + "\\overline{\\partial}_n(\\tau(\\sigma)) & = & \\tau(\\partial_{n+1}\\sigma)^{-1}\\tau(\\partial_n\\sigma), \\\\\n", + "\\overline{\\eta}_i(\\tau(\\sigma)) & = & \\tau(\\eta_i\\sigma),\\qquad 0 \\leq i \\leq n.\n", + "\\end{aligned}\n", + "$$\n", + "When applied to words, the two homomorphisms, $\\overline{\\partial}$ and $\\overline{\\eta}$, satisfy (for clarity, we omit here the operator $\\tau$):\n", + "$$\n", + "\\begin{aligned}\n", + "\\overline{\\partial}(a_1^{n_1}\\ldots a_k^{n_k}) &=& (\\overline{\\partial}(a_1))^{n_1}\\ldots \n", + " (\\overline{\\partial}(a_k))^{n_k}, \\\\\n", + "\\overline{\\eta}(a_1^{n_1}\\ldots a_k^{n_k}) &=& (\\overline{\\eta}(a_1))^{n_1}\\ldots (\\overline{\\eta}(a_k))^{n_k}. \n", + "\\end{aligned}\n", + "$$\n", + "It is known that the $\\overline{\\partial}_i$ and the $\\overline{\\eta}_i$ satisfy the fundamental relations between face and degeneracy operators (see the chapter on simplicial sets). So, $GX$ is itself a simplicial set; each $GX_n$ is a group, each face and degeneracy operator is an homomorphism, so that $GX$ is a *simplicial group*. The importance of the simplicial group $GX$ is emphasized by the Kan theorem, stating that if we consider the realization $|X|$ of $X$ and the loop space $\\Omega(|X|, x_0)$ at the base point $x_0 \\in |X|$, then $\\Omega(|X|, x_0)$ and the realization $|GX|$ of $GX$ have the same homotopy type.\n", + "\n", + "## Representation of letters and words\n", + "\n", + "In the system, the chosen representation for letters and words follows the very definition of the free group $\\mathbb{Z}^{*X_{n+1}^+}$. Here, a letter is a generator of $GX_n$ i.e. an **abstract simplex** $\\sigma$ of $X^+_{n+1}$. A word will be implemented as a sequence of such letters to a certain power (including 1). The chosen terminology is the following:\n", + "\n", + "- A term like $\\sigma^p$ is a **power**.\n", + "- A word ${\\sigma_1}^{\\epsilon_1} {\\sigma_2}^{\\epsilon_2} \\ldots {\\sigma_p}^{\\epsilon_p}$ is a **loop**. \n", + "\n", + "Note that, in this framework the operator $\\tau$ is not visible.\n", + "\n", + "### Representation of a power\n", + "\n", + "A power is internally represented by lisp object of type `apowr`. This has the form:\n", + "\n", + "`(`*dgop* *gmsm* `.` *expn*`)`\n", + "\n", + "in which we may recognize:\n", + "\n", + "- the components of the abstract simplex: *dgop* and *gmsm*,\n", + "- the exponent of the letter: *expn*, an integer.\n", + "\n", + "The associated constructor is the macro `apowr`.\n", + "\n", + "`apowr` *dgop gmsm expn* *[Macro]*\n", + "> Build an object of type `apowr`. The accessor macros are respectively `apdgop`, `apgmsm` and `apexpn`. There is no special printing function since the real object interesting for the user is not the power but rather the loop.\n", + "\n", + "### Representation of a loop\n", + "\n", + "A loop is represented by a lisp object of the form:\n", + "\n", + "`(:loop` $apower_1$ ... $apower_k$`)`\n", + "\n", + "The corresponding type is `LOOP`. The constructor is the macro `make-loop` but the pratical one is `loop3` and the associated\n", + "printing function prints the object under the form:\n", + "\n", + "`<>`\n", + "\n", + "where the *ext-dgop*'s are under the form of a readable sequence of $\\eta$ operators.\n", + "\n", + "#### Notion of normalized loop\n", + "\n", + "Normalizing a loop is a matter of factoring the degeneracy operators components (the *dgop*'s) of the *apowr*'s and building an object of type `ABSM` belonging to the simplicial set $GX$. For instance, the normalized null-loop in dimension 5 is `>>`. For non-null loops, the following examples show the transformation. We have written the loops under the form printed by the system.\n", + "\n", + "```\n", + "<> ===> >>\n", + "\n", + "<> ===> >>.\n", + "\n", + "<> ===> \n", + "\n", + " >>\n", + "\n", + "<> ===> \n", + "\n", + " >>\n", + "```\n", + "\n", + "## A set of functions for loops\n", + "\n", + "To facilitate the construction of objects of `LOOP` type, a set of useful functions is provided by the system.\n", + "\n", + "`loop3` *dgop1 gmsm1 pwr1 ... dgopk gmsmk pwrk* *[Function]*\n", + "> Construct a loop (a word) corresponding to the product of the abstract simplices $asm_i$, the components of which being $dgop_i$ and $gmsm_i$, to the power $pwr_i$. The function constructs itself the objects of type `apowr` from the arguments.\n", + "It accepts an indefinite number of arguments, including none. If there is no argument, the null loop is created. It exists in fact in the system the constant `+null-loop+` which is the base point of the underlying simplicial group. **Warning**: the function `loop3` does return neither a normalized loop nor a reduced word (no automatic simplification), so it is up to the user to give a correct sequence of arguments corresponding to a reduced word.\n", + "\n", + "`loop-space-cmpr` *cmpr* *[Function]*\n", + "> From the comparison function *cmpr* suitable for comparing the geometrical simplices belonging to the underlying simplicial set, build a comparison function for objects of type `LOOP`.\n", + "\n", + "`loop-space-face` *cmpr face* *[Function]*\n", + "> From the comparison function *cmpr* and the face function *face*, build a face function for an object of type `LOOP` returning the face of such an object as an `ABSM` type object (a normalized loop)\n", + "\n", + "`loop-space-face*` *cmpr face* *[Function]*\n", + "> From the comparison function *cmpr* and the face function *face*, build a *face*$*$ function.\n", + "See the description of the slot `face*` in the simplicial sets chapter.\n", + "\n", + "`loop-space-grml-sintr` *cmpr* *[Function]*\n", + "> From the comparison function *cmpr*, build a function for the group operation of the loop space (a simplicial group).\n", + "\n", + "`loop-space-grin-sintr` *dmns loop* *[Function]*\n", + "> Build the inverse of the object *loop* in the simplicial group. The first argument *dmns* is mandatory but ignored.\n", + "\n", + "`loop-space` *smst* `&optional (n 1)` *[Function]*\n", + "> If the second argument is `1` or omitted, construct, from the **reduced** simplicial set $X$, here the argument *smst*, the corresponding simplicial group $GX$. The new created simplicial set is of course locally effective and its base point is the null loop. For any other positive integer value $n$ of the second argument, build the $n$-th iterated loop space of $X$. The basic construction is given by the following call to the function `build-smgr`:\n", + "```\n", + " (build-smgr :cmpr (loop-space-cmpr cmpr)\n", + " :basis :locally-effective\n", + " :bspn +null-loop+\n", + " :face (loop-space-face cmpr face)\n", + " :face* (loop-space-face* cmpr face)\n", + " :sintr-grml (loop-space-grml-sintr cmpr)\n", + " :sintr-grin #'loop-space-grin-sintr\n", + " :orgn `(loop-space ,smst))\n", + "```\n", + "\n", + "`gdeltab` *[Function]*\n", + "> Build $\\Omega^1(\\bar{\\Delta})$. This is simply `(loop-space(deltab))`. We recall that $\\bar{\\Delta}$ is the reduced and locally effective simplicial set obtained from ${\\Delta}^\\mathbb{N}$, by identifying all the vertices to the base point.\n", + "$\\Delta^\\mathbb{N}$ is the locally effective simplicial set freely generated by the positive integers.\n", + "\n", + "### Examples" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "(loop3)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "(loop3 0 'a 2 20 'b -3 12 'c 1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "(loop3 0 'a 2 20 'b -3 12 'c 1 0 'a 3)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "(loop3 (dgop-ext-int '(2 1 0)) 'p 2 \n", + " (dgop-ext-int '(5 4 3 2 1)) 'q 5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let us consider now a true reduced simplicial set, namely $Moore(\\mathbb{Z}/{2\\mathbb{Z}}, 3)$, \n", + "whose structure is shown using the function `show-structure` defined in the Simplicial Sets chapter." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "(def moore23 (moore 2 3))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "(show-structure moore23 4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let us build now $\\Omega^1(Moore(\\mathbb{Z}/{2\\mathbb{Z}}, 3))$ and ask for faces of some loops. The user will note that the function face admits either `LOOP` type objects or `ABSM` type objects (normalized loop) but always returns normalized loops, i.e. an abstract simplex, according to the normal behaviour of the face function in a simplicial set." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "(def o-moore23 (loop-space moore23))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "(face o-moore23 0 4 +null-loop+)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "(face o-moore23 0 3 (loop3 0 'N4 2))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "(face o-moore23 1 3 (loop3 0 'N4 2))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "(face o-moore23 1 4 (loop3 1 'N4 2))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "(face o-moore23 0 2 (loop3 0 'M3 2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let us do the same with the following reduced simplicial set (`ss2`) and with $\\Omega^1(\\bar{\\Delta})$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "(def ss2 (build-finite-ss '( * \n", + " 2 s2 (* * *) \n", + " 3 s3 (s2 s2 s2 s2))))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "(def o-ss2 (loop-space ss2))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "(face o-ss2 0 1 (loop3 0 's2 1))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "(face o-ss2 0 2 (loop3 0 's3 2))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "(face o-ss2 1 2 (loop3 0 's3 2))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "(face o-ss2 1 2 (loop3 0 's3 2))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "(def db (gdeltab))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "(face db 3 3 (loop3 12 7 3))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "(face db 3 3 (loop3 5 7 3))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "(face db 3 3 (loop3 6 7 3 5 7 3 3 7 3))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "(face db 3 2 *)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The last statement shows that the boundary operator attached to the chain complex derived from all this machinery satisfies its fundamental property ($d\\circ d=0$)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "(? db (? db 3 (loop3 (dgop-ext-int '(3 2)) (dlop-ext-int '(0 1 2)) 3\n", + " (dgop-ext-int '(3 1)) (dlop-ext-int '(0 1 2)) 3\n", + " (dgop-ext-int '(2 1)) (dlop-ext-int '(0 1 2)) 3)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The loop spaces of reduced simplicial sets, provide us with new examples of algebras. So, we may apply the functor `bar`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "(def moore-22 (moore 2 2)) " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "(dotimes (i 4) (print (basis moore-22 i :dgnr)))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "(def o-moore-22 (loop-space moore-22))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "(aprd o-moore-22 3 (tnpr 1 (loop3 0 'm2 1) 2 (loop3 0 'n3 1)))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "(def bar-om (bar o-moore-22))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "(? bar-om 5 (abar 2 (loop3 0 'm2 1) 3 (loop3 0 'n3 1)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Lisp file concerned in this chapter\n", + "\n", + "`loop-spaces.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": 0 +}