402 lines
11 KiB
Plaintext
402 lines
11 KiB
Plaintext
{
|
|
"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",
|
|
"```commonlisp\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": 1,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"name": "stderr",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"SIMPLE-STYLE-WARNING: \n",
|
|
" #<SB-INT:SIMPLE-STYLE-WARNING \"undefined ~(~A~): ~S\" {1005215EB3}>\n"
|
|
]
|
|
},
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"DKFLL"
|
|
]
|
|
},
|
|
"execution_count": 1,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"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": 2,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"[K1 Simplicial-Set]"
|
|
]
|
|
},
|
|
"execution_count": 2,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(def d (delta-infinity))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 3,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"[K1 Kan-Simplicial-Set]"
|
|
]
|
|
},
|
|
"execution_count": 3,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(smst-kan d #'dkfll)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 4,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"<AbSm 0 1>"
|
|
]
|
|
},
|
|
"execution_count": 4,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(kfll d 0 1 (list (absm 0 1)))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 5,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"<AbSm - 7>"
|
|
]
|
|
},
|
|
"execution_count": 5,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(kfll d 0 2 (list (absm 0 5) (absm 0 3)))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 6,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"<AbSm - 7>"
|
|
]
|
|
},
|
|
"execution_count": 6,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(kfll d 1 2 (list (absm 0 6) (absm 0 3)))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 7,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"<AbSm - 7>"
|
|
]
|
|
},
|
|
"execution_count": 7,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(kfll d 2 2 (list (absm 0 6) (absm 0 5)))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 8,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"<AbSm 1 3>"
|
|
]
|
|
},
|
|
"execution_count": 8,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(kfll d 0 2 (list (absm 0 3) (absm 0 3)))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 9,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"<AbSm 1 3>"
|
|
]
|
|
},
|
|
"execution_count": 9,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(kfll d 1 2 (list (absm 1 2) (absm 0 3)))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 10,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"T"
|
|
]
|
|
},
|
|
"execution_count": 10,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(check-hat d 1 2 (list (absm 1 2) (absm 0 3)))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 11,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"T"
|
|
]
|
|
},
|
|
"execution_count": 11,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(check-hat d 0 1 (list (absm 0 1)))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 12,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"\n",
|
|
"---done---"
|
|
]
|
|
},
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"NIL"
|
|
]
|
|
},
|
|
"execution_count": 12,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"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
|
|
}
|