183 lines
6.8 KiB
TeX
183 lines
6.8 KiB
TeX
\chapter {Programming the Kan theory}
|
|
|
|
\section {Introduction}
|
|
|
|
Let us recall some definitions in relation with the Kan simplicial sets.
|
|
\vskip 0.40cm
|
|
{\bf Definition 1.} A Kan ``hat''\index{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:
|
|
$$ \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. $$
|
|
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.
|
|
\subsection* {Example}
|
|
|
|
We are going to work with the simplices of $\Delta^{\N}$. The set $(\sigma_1, \sigma_2) = $ {\tt ((0 2), (0 1))}
|
|
is a Kan hat of dimension $2$ and index $0$. In effect, $\delta_1\sigma_1=\delta_1\sigma_2 = {\tt (0)}$.
|
|
Likewise, the two sets {\tt ((1 2), (0 1))} and {\tt ((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.
|
|
\vskip 0.40cm
|
|
{\bf Definition 2.} A {\em filling} of a Kan hat\index{Kan hat!filling},
|
|
$(\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.$
|
|
|
|
\subsection* {Example}
|
|
|
|
A filling of {\tt ((0 2), (0 1))} is the $2$-simplex {\tt (0 1 2)}. A filling of the Kan hat
|
|
{\tt ((1 1), (0 1))} is the degenerate $2$-simplex {\tt (0 1 1)}. A filling
|
|
of the vertex {\tt (0)} is the degenerate $1$--simplex {\tt (0 0)}.
|
|
\vskip 0.40cm
|
|
{\bf Definition 3.} A simplicial set is a Kan simplicial set if for every hat there exists a filling.
|
|
|
|
\subsection {Representation of a Kan simplicial set}
|
|
|
|
A Kan simplicial set is implemented as an instance\index{class!{\tt KAN}} of the class {\tt KAN},
|
|
subclass of the class {\tt SIMPLICIAL-SET}.
|
|
{\footnotesize\begin{verbatim}
|
|
(DEFCLASS KAN (simplicial-set)
|
|
((kfll :type kfll :initarg :kfll :reader kfll1)))
|
|
\end{verbatim}}
|
|
We recall that this new class inherits also from the class {\tt CHAIN-COMPLEX}. It has one
|
|
slot of its own:
|
|
\begin{description}
|
|
\item {{\tt kfll}}, an object of type {\tt 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.
|
|
\end{description}
|
|
A printing method has been associated to the class {\tt KAN} and the external re\-pre\-sen\-ta\-ti\-on
|
|
of an instance is a string like {\tt [K{\em n} Kan-Simplicial-Set]}, where {\em n} is the number plate of
|
|
the Kenzo object.
|
|
|
|
\subsection {Helpful functions on Kan simplicial sets}
|
|
|
|
{\parindent=0mm
|
|
{\leftskip=5mm
|
|
{\tt cat-init} \hfill {\em [Function]} \par}
|
|
{\leftskip=15mm
|
|
Clear in particular {\tt *Kan-list*}, the list of user created Kan simplicial sets and reset
|
|
the global counter to $1$. \par}
|
|
{\leftskip=5mm
|
|
{\tt Kan} {\em n} \hfill {\em [Function]}\par}
|
|
{\leftskip=15mm
|
|
Retrieve in the list {\tt *Kan-list*} the Kan object instance whose the Kenzo identification is $n$.
|
|
If it does not exist, return {\tt NIL}. \par}
|
|
{\leftskip=5mm
|
|
{\tt kfll \&rest} {\em args} \hfill {\em [Macro]}\par}
|
|
{\leftskip=15mm
|
|
With only one argument (a Kan instance) return the slot {\tt kfll} of this instance. With $4$ arguments
|
|
like {\tt (kfll {\em kan indx dmns hat})}, return a filling of the Kan hat {\em hat}, of dimension {\em dmns}
|
|
and of index {\em indx} by applying the filling function value of the slot {\tt kfll} of the Kan instance
|
|
{\em kan}. \par}
|
|
}
|
|
\newpage
|
|
{\parindent=0mm
|
|
{\leftskip=5mm
|
|
{\tt smst-kan} {\em smst kfll} \hfill {\em [Function]}\par}
|
|
{\leftskip=15mm
|
|
With the filling lisp function {\em kfll},
|
|
{\bf transform} the simplicial set {\em smst} in an object of type {\tt KAN}
|
|
(in other word, {\em smst} is {\tt modified}).
|
|
This is the easiest way to build a Kan simplicial set. \par}
|
|
{\leftskip=5mm
|
|
{\tt check-hat} {\em kan indx dmns hat} \hfill {\em [Function]}\par}
|
|
{\leftskip=15mm
|
|
Useful verification function to check if the collection of simplices {\em hat} is a valid Kan hat
|
|
of dimension {\em dmns} and of index {\em indx} in the Kan simplicial set {\em kan}. In fact this
|
|
works equally if {\em kan} is a general simplicial set. \par}
|
|
{\leftskip=5mm
|
|
{\tt check-kan} {\em kan indx dmns hat} \hfill {\em [Function]}\par}
|
|
{\leftskip=15mm
|
|
Useful verification function to check if the collection of simplices {\em hat} is a valid Kan hat
|
|
of dimension {\em dmns} and of index {\em indx} in the Kan simplicial set {\em kan}. This verification
|
|
function applies the filling function of the instance {\em kan} to the argument {\em hat} and perform
|
|
the verification of the faces relations upon the resulting $dmns$--simplex. \par}
|
|
}
|
|
|
|
\subsection* {Examples}
|
|
|
|
Let us take again the small examples of the introduction. First we define a function {\tt dkfll},
|
|
a filling function suitable for a Kan hat in $\Delta^{\N}$. The user will note that
|
|
in the abstract simplices the degeneracy operators and the geometric simplices are coded in binary.
|
|
{\footnotesize\begin{verbatim}
|
|
(defun dkfll (indx dmns hat)
|
|
(cond ((= 1 dmns)
|
|
(absm 1 (gmsm (first hat))))
|
|
((= 0 indx)
|
|
(let ((del-1 (absm-int-ext (first hat)))
|
|
(del-2 (absm-int-ext (second hat))))
|
|
(absm-ext-int
|
|
(cons (first del-1)
|
|
(cons (second del-2) (rest del-1))))))
|
|
((= 1 indx)
|
|
(let ((del-0 (absm-int-ext (first hat)))
|
|
(del-2 (absm-int-ext (second hat))))
|
|
(absm-ext-int
|
|
(cons (first del-2) del-0))))
|
|
(t
|
|
(let ((del-0 (absm-int-ext (first hat)))
|
|
(del-1 (absm-int-ext (second hat))))
|
|
(absm-ext-int
|
|
(cons (first del-1) del-0))))))
|
|
|
|
DKFLL
|
|
|
|
(setf d (delta-infinity)) ==>
|
|
|
|
[K5 Simplicial-Set]
|
|
|
|
(smst-kan d #'dkfll) ==>
|
|
|
|
[K5 Kan-Simplicial-Set]
|
|
|
|
(kfll d 0 1 (list (absm 0 1))) ==>
|
|
|
|
<AbSm 0 1>
|
|
|
|
(kfll d 0 2 (list (absm 0 5) (absm 0 3))) ==>
|
|
|
|
<AbSm - 7>
|
|
|
|
(kfll d 1 2 (list (absm 0 6) (absm 0 3))) ==>
|
|
|
|
<AbSm - 7>
|
|
|
|
(kfll d 2 2 (list (absm 0 6) (absm 0 5))) ==>
|
|
|
|
<AbSm - 7>
|
|
|
|
(kfll d 0 2 (list (absm 0 3) (absm 0 3))) ==>
|
|
|
|
<AbSm 1 3>
|
|
|
|
(kfll d 1 2 (list (absm 1 2) (absm 0 3))) ==>
|
|
|
|
<AbSm 1 3>
|
|
|
|
(check-hat d 1 2 (list (absm 1 2) (absm 0 3))) ==>
|
|
|
|
T
|
|
|
|
(check-hat d 0 1 (list (absm 0 1))) ==>
|
|
|
|
T
|
|
|
|
(check-kan d 0 1 (list (absm 0 1))) ==>
|
|
|
|
---done---
|
|
\end{verbatim}}
|
|
|
|
More elaborate examples with Kan simplicial sets will be given later in the
|
|
loop spaces chapter.
|
|
|
|
\subsection* {Lisp files concerned in this chapter}
|
|
|
|
{\tt kan.lisp}.
|
|
\par
|
|
[{\tt classes.lisp }, {\tt macros.lisp}, {\tt various.lisp}].
|