{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Programming the Kan theory\n",
    "\n",
    "## Introduction\n",
    "\n",
    "Let us recall some definitions in relation with the Kan simplicial sets.\n",
    "\n",
    "**Definition 1.** A Kan \"hat\" of dimension $n$ and index $i$ is a collection of $n$ simplices of dimension  $(n-1)$, noted  $(\\sigma_0, \\ldots, \\sigma_{i-1}, \\sigma_{i+1}, \\ldots, \\sigma_n)$, such that the following conditions are fulfilled:\n",
    "$$ \\partial_j\\sigma_k=\\partial_k\\sigma_{j+1},\\quad k \\not= i,\\quad j+1 \\not= i, \\quad 0 \\leq j \\leq n-1, \\quad 0 \\leq k \\leq n-1, \\quad k \\leq j. $$\n",
    "Note that there is no $\\sigma_i$ term in the list above; in a sense, the Kan process consists in constructing the missing $\\sigma_i$ to be considered as a \"composition\" of the given $\\sigma_j$'s.\n",
    "\n",
    "### Example\n",
    "\n",
    "We are going to work with the simplices of $\\Delta^\\mathbb{N}$. The set $(\\sigma_1, \\sigma_2) = $ ``((0 2), (0 1))`` is a Kan hat of dimension 2 and index 0. In effect, $\\delta_1\\sigma_1=\\delta_1\\sigma_2 =$ ``(0)``. Likewise, the two sets ``((1 2), (0 1))`` and ``((1 2), (0 2))`` are  Kan hats  of dimension 2 and of respective index 1 and 2. Of course, this definition applies equally if the simplices are degenerate.\n",
    "\n",
    "**Definition 2.** A *filling* of a Kan hat $(\\sigma_0, \\ldots, \\sigma_{i-1}, \\sigma_{i+1}, \\ldots, \\sigma_n)$, is an $n$-simplex $\\tilde{\\sigma}$, such that for every $j \\not= i$, $\\partial_j\\tilde{\\sigma}=\\sigma_j.$\n",
    "\n",
    "### Example\n",
    "\n",
    "A filling of ``((0 2), (0 1))`` is the 2-simplex ``(0 1 2)``. A filling of the Kan hat ``((1 1), (0 1))`` is the degenerate 2-simplex ``(0 1 1)``. A filling of the vertex ``(0)`` is the degenerate 1-simplex ``(0 0)``.\n",
    "\n",
    "**Definition 3.** A simplicial set is a Kan simplicial set if for every hat there exists a filling.\n",
    "\n",
    "### Representation of a Kan simplicial set\n",
    "\n",
    "A Kan simplicial set is implemented as an instance of the class ``KAN``, subclass of the class ``SIMPLICIAL-SET``.\n",
    "\n",
    "```lisp\n",
    "(DEFCLASS KAN (simplicial-set)\n",
    "  ((kfll :type kfll :initarg :kfll :reader kfll1)))\n",
    "```\n",
    "\n",
    "We recall that this new class inherits also from the class ``CHAIN-COMPLEX``. It has one slot of its own:\n",
    "\n",
    "``kfll``\n",
    "> an object of type ``KFLL``, in fact a lisp function with 3 parameters describing a Kan hat: an index (an integer), a dimension (an integer) and the Kan hat (a list of abstract simplices). This function must return a filling of the Kan hat argument, i.e. an abstract simplex satisfying the theoritical definition.\n",
    "\n",
    "A printing method has been associated to the class ``KAN`` and the external representation of  an instance is a string like ``[K``*n* ``Kan-Simplicial-Set]``, where *n* is the number plate of the Kenzo object.\n",
    "\n",
    "### Helpful functions on Kan simplicial sets\n",
    "\n",
    "``cat-init`` *[Function]*\n",
    "> Clear in particular ``*Kan-list*``, the list of user created Kan simplicial sets  and reset the global counter to 1.\n",
    "\n",
    "``Kan`` *n* *[Function]*\n",
    "> Retrieve in the list ``*Kan-list*`` the Kan object instance whose the Kenzo identification  is n. If it does not exist, return ``NIL``.\n",
    "\n",
    "``kfll &rest`` *args* *[Macro]*\n",
    "> With only one argument (a Kan instance) return the slot ``kfll`` of this instance. With 4 arguments\n",
    "like ``(kfll`` *kan indx dmns hat*``)``, return a filling of the Kan hat *hat*, of dimension *dmns*\n",
    "and of index *indx* by applying the filling function value of the slot ``kfll`` of the Kan instance *kan*.\n",
    "\n",
    "``smst-kan`` *smst kfll* *[Function]*\n",
    "> With the filling lisp function *kfll*, **transform** the simplicial set *smst* in an object of type ``KAN`` (in other word, *smst* is ``modified``). This is the easiest way to build a Kan simplicial set.\n",
    "\n",
    "``check-hat`` *kan indx dmns hat* *[Function]*\n",
    "> Useful verification function to check if the collection of simplices ``hat`` is a valid Kan hat of dimension *dmns* and of index *indx* in the Kan simplicial set *kan*. In fact this works equally if *kan* is a general simplicial set.\n",
    "\n",
    "``check-kan`` *kan indx dmns hat* *[Function]*\n",
    "> Useful verification function to check if the collection of simplices *hat* is a valid Kan hat of dimension *dmns* and of index *indx* in the Kan simplicial set *kan*. This verification function applies the filling function of the instance *kan* to the argument *hat* and perform the  verification of the faces relations upon the resulting $dmns$-simplex.\n",
    "\n",
    "### Examples\n",
    "\n",
    "Let us take again the small examples of the introduction. First we  define a function ``dkfll``, \n",
    "a filling function suitable for a  Kan hat in $\\Delta^\\mathbb{N}$. The user will note that in the abstract simplices the degeneracy operators and the geometric simplices are coded in binary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "(defun dkfll (indx dmns hat)\n",
    "     (cond ((= 1 dmns)\n",
    "            (absm 1 (gmsm (first hat))))\n",
    "           ((= 0 indx)\n",
    "            (let ((del-1 (absm-int-ext (first hat)))\n",
    "                  (del-2 (absm-int-ext (second hat))))\n",
    "              (absm-ext-int\n",
    "                 (cons (first del-1)\n",
    "                       (cons (second del-2) (rest del-1))))))\n",
    "           ((= 1 indx)\n",
    "            (let ((del-0 (absm-int-ext (first hat)))\n",
    "                  (del-2 (absm-int-ext (second hat))))\n",
    "              (absm-ext-int\n",
    "                 (cons (first del-2) del-0))))\n",
    "           (t\n",
    "            (let ((del-0 (absm-int-ext (first hat)))\n",
    "                  (del-1 (absm-int-ext (second hat))))\n",
    "              (absm-ext-int\n",
    "                 (cons (first del-1) del-0))))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "(def d (delta-infinity))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "(smst-kan d #'dkfll)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "(kfll d 0 1 (list (absm 0 1)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "(kfll d 0 2 (list (absm 0 5) (absm 0 3)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "(kfll d 1 2 (list (absm 0 6) (absm 0 3)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "(kfll d 2 2 (list (absm 0 6) (absm 0 5)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "(kfll d 0 2 (list (absm 0 3) (absm 0 3)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "(kfll d 1 2 (list (absm 1 2) (absm 0 3)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "(check-hat d 1 2 (list (absm 1 2) (absm 0 3)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "(check-hat d 0 1 (list (absm 0 1)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "(check-kan d 0 1 (list (absm 0 1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "More elaborate examples with Kan simplicial sets will be given later in the loop spaces chapter.\n",
    "\n",
    "### Lisp files concerned in this chapter\n",
    "\n",
    "``kan.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": 0
}