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