26 KiB
(ql:quickload "kenzo") (in-package :cat)
To load "kenzo":
Load 1 ASDF system:
kenzo
; Loading "kenzo"
#<PACKAGE "CAT">
Loop Spaces¶
Introduction¶
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}$.
Definition. $a_i$ and its formal inverse $a_i^{-1}$ are letters.
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.
Now, let $F(\cal A)$ the set of words on $\cal A$. It is easy to show that if we define in $F(\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 $F(\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: $$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}$$ and its inverse is $$a_k^{-n_k}\ldots a_2^{-n_2}a_1^{-n_1}.$$ Now 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: $$ GX_n=F(X^+_{n+1}),\ X^+_{n+1}=X_{n+1}-\eta_n X_n. $$ In fact, from a strictly mathematical point of view, the right definition is $$ GX_n = F(X^+_{n+1}) / {\overline{\eta_n X_n}},$$ i.e. the quotient group of $F(X^+_{n+1})$, the free group generated by all the $n+1$-simplices, the $n$-degenerate ones 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.
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 $${\tau(\sigma_1)}^{\epsilon_1} {\tau(\sigma_2)}^{\epsilon_2} \ldots {\tau(\sigma_p)}^{\epsilon_p}.$$ Now, let us define two homomorphisms: $$\overline{\partial}_i^n: GX_n \longrightarrow GX_{n-1},\ \overline{\eta}_i^n: GX_n \longrightarrow GX_{n+1},$$ 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$: $$ \begin{aligned} \overline{\partial}_i(\tau(\sigma)) & = & \tau(\partial_i\sigma),\qquad 0 \leq i < n, \\ \overline{\partial}_n(\tau(\sigma)) & = & \tau(\partial_{n+1}\sigma)^{-1}\tau(\partial_n\sigma), \\ \overline{\eta}_i(\tau(\sigma)) & = & \tau(\eta_i\sigma),\qquad 0 \leq i \leq n. \end{aligned} $$
These definitions for the generators of $GX_n$ extend to arbitrary elements in a unique way, for example: $$ \overline{\partial}_i(a_1^{n_1} \cdots a_k^{n_k}) = (\partial_i(a_1))^{n_1} \cdots (\partial_i(a_k))^{n_k} $$ 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 a 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.
Representation of letters and words¶
In the system, the chosen representation for letters and words follows the very definition of the free group $F(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:
- A term like $\sigma^p$ is a power.
- A word ${\sigma_1}^{\epsilon_1} {\sigma_2}^{\epsilon_2} \ldots {\sigma_p}^{\epsilon_p}$ is a loop.
Note that, in this framework the operator $\tau$ is not visible.
Representation of a power¶
A power is internally represented by a lisp object of type apowr. This has the form:
(dgop gmsm . expn)
in which we may recognize:
- the components of the abstract simplex: dgop and gmsm,
- the exponent of the letter: expn, a non-zero integer.
The associated constructor is the macro apowr.
apowr dgop gmsm expn [Macro]
Build an object of type
apowr. The accessor macros are respectivelyapdgop,apgmsmandapexpn. There is no special printing function since the real object interesting for the user is not the power but rather the loop.
Representation of a loop¶
A loop is represented by a lisp object of the form:
#S(LOOP $apower_1$ ... $apower_k$)
The corresponding type is LOOP. The constructor is the macro make-loop but the practical one is loop3 and the associated
printing function prints the object under the form:
<<Loop [ext-dgop1 gmsm1 expn1] ... [ext-dgopk gmsmk expnk]>>
where the ext-dgop's are under the form of a readable sequence of $\eta$ operators.
Notion of normalized loop¶
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 <AbSm 4-3-2-1-0 <<Loop>>>. For non-null loops, the following examples show the transformation. We have written the loops under the form printed by the system.
<<Loop [1-0 A\2]>> ===> <AbSm 1-0 <<Loop [A\2]>>>
<<Loop [3-2-1 A\2] [4-2 B\3]>> ===> <AbSm 2 <<Loop [2-1 A\2] [3 B\3]>>>.
<<Loop [2-1 A\2] [2-0 B\2] [1-0 A\3]>> ===>
<AbSm - <<Loop [2-1 A\2] [2-0 B\2] [1-0 A\3]>>>
<<Loop [2-1-0 A\2] [2-1-0 B\2] [2-1-0 A\3]>> ===>
<AbSm 2-1-0 <<Loop [A\2] [B\2] [A\3]>>>
A set of functions for loops¶
To facilitate the construction of objects of LOOP type, a set of useful functions is provided by the system.
loop3 dgop1 gmsm1 pwr1 ... dgopk gmsmk pwrk [Function]
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
apowrfrom the arguments. 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 functionloop3does 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.
loop-space-cmpr cmpr [Function]
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.
loop-space-face cmpr face [Function]
From the comparison function cmpr and the face function face, build a face function for an object of type
LOOPreturning the face of such an object as anABSMtype object (a normalized loop)
loop-space-face* cmpr face [Function]
From the comparison function cmpr and the face function face, build a face$*$ function. See the description of the slot
face*in the simplicial sets chapter.
loop-space-grml-sintr cmpr [Function]
From the comparison function cmpr, build a function for the group operation of the loop space (a simplicial group).
loop-space-grin-sintr dmns loop [Function]
Build the inverse of the object loop in the simplicial group. The first argument dmns is mandatory but ignored.
loop-space smst &optional (n 1) [Function]
If the second argument is
1or 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 functionbuild-smgr:
(build-smgr :cmpr (loop-space-cmpr cmpr)
:basis :locally-effective
:bspn +null-loop+
:face (loop-space-face cmpr face)
:face* (loop-space-face* cmpr face)
:sintr-grml (loop-space-grml-sintr cmpr)
:sintr-grin #'loop-space-grin-sintr
:orgn `(loop-space ,smst))
gdeltab [Function]
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. $\Delta^\mathbb{N}$ is the locally effective simplicial set freely generated by the positive integers.
Examples¶
(loop3)
<<Loop>>
(loop3 0 'a 2 20 'b -3 12 'c 1)
<<Loop[A\2][4-2 B\-3][3-2 C]>>
(loop3 0 'a 2 20 'b -3 12 'c 1 0 'a 3)
<<Loop[A\2][4-2 B\-3][3-2 C][A\3]>>
(loop3 (dgop-ext-int '(2 1 0)) 'p 2 (dgop-ext-int '(5 4 3 2 1)) 'q 5)
<<Loop[2-1-0 P\2][5-4-3-2-1 Q\5]>>
Let us consider now a true reduced simplicial set, namely $Moore(\mathbb{Z}/{2\mathbb{Z}}, 3)$,
whose structure is shown using the function show-structure defined in the Simplicial Sets chapter.
(def moore23 (moore 2 3))
[K1 Simplicial-Set]
(show-structure moore23 4)
Dimension = 0:
Vertices : (*)
Dimension = 1:
Dimension = 2:
Dimension = 3:
Simplex : M3
Faces : (<AbSm 1-0 *> <AbSm 1-0 *> <AbSm 1-0 *> <AbSm 1-0 *>)
Dimension = 4:
Simplex : N4
Faces : (<AbSm - M3> <AbSm 2-1-0 *> <AbSm - M3> <AbSm 2-1-0 *> <AbSm 2-1-0 *>)
NIL
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.
(def o-moore23 (loop-space moore23))
[K6 Simplicial-Group]
(face o-moore23 0 4 +null-loop+)
<AbSm 2-1-0 <<Loop>>>
(face o-moore23 0 3 (loop3 0 'N4 2))
<AbSm - <<Loop[M3\2]>>>
(face o-moore23 1 3 (loop3 0 'N4 2))
<AbSm 1-0 <<Loop>>>
(face o-moore23 1 4 (loop3 1 'N4 2))
<AbSm - <<Loop[N4\2]>>>
(face o-moore23 0 2 (loop3 0 'M3 2))
<AbSm 0 <<Loop>>>
Let us do the same with the following reduced simplicial set (ss2) and with $\Omega^1(\bar{\Delta})$.
(def ss2 (build-finite-ss '( * 2 s2 (* * *) 3 s3 (s2 s2 s2 s2))))
The object is a STANDARD-OBJECT of type SIMPLICIAL-SET.
0. CMPR: #<FUNCTION S-CMPR>
1. BASIS: #<CLOSURE (FLET RSLT :IN FINITE-SS-BASIS) {1001EE2CFB}>
2. BSGN: *
3. DFFR: [K19 Morphism (degree -1): K18 -> K18]
4. GRMD: [K18 Simplicial-Set]
5. EFHM: "unbound"
6. IDNM: 18
7. ORGN: (BUILD-FINITE-SS (* 2 S2 (* * *) 3 S3 (S2 S2 S2 S2)))
8. CPRD: [K22 Morphism (degree 0): K18 -> K20]
9. FACE: #<CLOSURE (FLET RSLT :IN FINITE-SS-FACE) {1001EE2D1B}>
>
Checking the 0-simplices...
Checking the 1-simplices...
Checking the 2-simplices...
Checking the 3-simplices...
[K18 Simplicial-Set]
(def o-ss2 (loop-space ss2))
[K23 Simplicial-Group]
(face o-ss2 0 1 (loop3 0 's2 1))
<AbSm - <<Loop>>>
(face o-ss2 0 2 (loop3 0 's3 2))
<AbSm - <<Loop[S2\2]>>>
(face o-ss2 1 2 (loop3 0 's3 2))
<AbSm - <<Loop[S2\2]>>>
(face o-ss2 1 2 (loop3 0 's3 2))
<AbSm - <<Loop[S2\2]>>>
(def db (gdeltab))
[K40 Simplicial-Group]
(face db 3 3 (loop3 12 7 3))
<AbSm 1-0 <<Loop>>>
(face db 3 3 (loop3 5 7 3))
<AbSm 0 <<Loop[7\3]>>>
(face db 3 3 (loop3 6 7 3 5 7 3 3 7 3))
<AbSm - <<Loop[1 7\3][0 7\3][1-0 3\-1][1-0 5][1-0 3\-1][1-0 5][1-0 3\-1][1-0 5]>>>
(face db 3 2 *)
<AbSm - <<Loop[7\3][0 3\-1][0 5][0 3\-1][0 5][0 3\-1][0 5][0 3\-1][0 5][0 3\-1][0 5][0 3\-1][0 5]>>>
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$).
(? db (? db 3 (loop3 (dgop-ext-int '(3 2)) (dlop-ext-int '(0 1 2)) 3 (dgop-ext-int '(3 1)) (dlop-ext-int '(0 1 2)) 3 (dgop-ext-int '(2 1)) (dlop-ext-int '(0 1 2)) 3)))
----------------------------------------------------------------------{CMBN 1}
------------------------------------------------------------------------------
The loop spaces of reduced simplicial sets, provide us with new examples of algebras. So, we may apply the functor bar.
(def moore-22 (moore 2 2))
[K52 Simplicial-Set]
(dotimes (i 4) (print (basis moore-22 i :dgnr)))
(<AbSm - *>) (<AbSm 0 *>) (<AbSm - M2> <AbSm 1-0 *>) (<AbSm - N3> <AbSm 0 M2> <AbSm 1 M2> <AbSm 2 M2> <AbSm 2-1-0 *>)
NIL
(def o-moore-22 (loop-space moore-22))
[K57 Simplicial-Group]
(aprd o-moore-22 3 (tnpr 1 (loop3 0 'm2 1) 2 (loop3 0 'n3 1)))
----------------------------------------------------------------------{CMBN 3}
<1 * <<Loop[1-0 M2][2 N3]>>>
<-1 * <<Loop[2-0 M2][1 N3]>>>
<1 * <<Loop[2-1 M2][0 N3]>>>
------------------------------------------------------------------------------
(def bar-om (bar o-moore-22))
[K74 Chain-Complex]
(? bar-om 5 (abar 2 (loop3 0 'm2 1) 3 (loop3 0 'n3 1)))
----------------------------------------------------------------------{CMBN 4}
<1 * <<Abar[4 <<Loop[1-0 M2][2 N3]>>]>>>
<-1 * <<Abar[4 <<Loop[2-0 M2][1 N3]>>]>>>
<1 * <<Abar[4 <<Loop[2-1 M2][0 N3]>>]>>>
<-2 * <<Abar[2 <<Loop[M2]>>][2 <<Loop[M2]>>]>>>
------------------------------------------------------------------------------
Lisp file concerned in this chapter¶
loop-spaces.lisp.