kenzo/examples/Chapter10.ipynb

Programming the Kan theory¶

Introduction¶

Let us recall some definitions in relation with the Kan simplicial sets.

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: $$ \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.

Example¶

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.

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.$

Example¶

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).

Definition 3. A simplicial set is a Kan simplicial set if for every hat there exists a filling.

Representation of a Kan simplicial set¶

A Kan simplicial set is implemented as an instance of the class KAN, subclass of the class SIMPLICIAL-SET.

(DEFCLASS KAN (simplicial-set)
  ((kfll :type kfll :initarg :kfll :reader kfll1)))

We recall that this new class inherits also from the class CHAIN-COMPLEX. It has one slot of its own:

kfll

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.

A printing method has been associated to the class KAN and the external representation of an instance is a string like [Kn Kan-Simplicial-Set], where n is the number plate of the Kenzo object.

Helpful functions on Kan simplicial sets¶

cat-init [Function]

Clear in particular *Kan-list*, the list of user created Kan simplicial sets and reset the global counter to 1.

Kan n [Function]

Retrieve in the list *Kan-list* the Kan object instance whose the Kenzo identification is n. If it does not exist, return NIL.

With only one argument (a Kan instance) return the slot kfll of this instance. With 4 arguments

kfll &rest args [Macro] like (kfll kan indx dmns hat), return a filling of the Kan hat hat, of dimension dmns and of index indx by applying the filling function value of the slot kfll of the Kan instance kan.

smst-kan smst kfll [Function]

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.

check-hat kan indx dmns hat [Function]

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.

check-kan kan indx dmns hat [Function]

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.

Examples¶

Let us take again the small examples of the introduction. First we define a function dkfll, 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.

In [ ]:

(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))))))

In [ ]:

(def d (delta-infinity))

In [ ]:

(smst-kan d #'dkfll)

In [ ]:

(kfll d 0 1 (list (absm 0 1)))

In [ ]:

(kfll d 0 2 (list (absm 0 5) (absm 0 3)))

In [ ]:

(kfll d 1 2 (list (absm 0 6) (absm 0 3)))

In [ ]:

(kfll d 2 2 (list (absm 0 6) (absm 0 5)))

In [ ]:

(kfll d 0 2 (list (absm 0 3) (absm 0 3)))

In [ ]:

(kfll d 1 2 (list (absm 1 2) (absm 0 3)))

In [ ]:

(check-hat d 1 2 (list (absm 1 2) (absm 0 3)))

In [ ]:

(check-hat d 0 1 (list (absm 0 1)))

In [ ]:

(check-kan d 0 1 (list (absm 0 1)))

More elaborate examples with Kan simplicial sets will be given later in the loop spaces chapter.

Lisp files concerned in this chapter¶

kan.lisp.

[classes.lisp, macros.lisp, various.lisp].