mmarco/kenzo
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
adcd323909
kenzo/examples/06_Algebras_and_bars.ipynb
Gerd Heber adcd323909 Updated Dockerfile & Jupyter notebooks.
2017-10-08 20:11:31 -05:00

898 lines
33 KiB
Plaintext
Raw Blame History

{
"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": [
"# Algebras and Bars\n",
"\n",
"## Algebra\n",
"\n",
"An algebra is a pair $(A, \\varpi)$ where\n",
"\n",
"1. $A$ is a chain complex.\n",
"2. $\\varpi$ (the *product*) is a chain complex morphism \n",
"$$\\varpi: A \\otimes A \\rightarrow A.$$\n",
"\n",
"These components must satisfy the usual structural properties of the algebras.\n",
"\n",
"### Implementation of an algebra\n",
"\n",
"An algebra is represented as an instance of the CLOS class `ALGEBRA`, subclass of the ` CHAIN COMPLEX` class. The definition of this new class is simply:\n",
"\n",
"```commonlisp\n",
"(DEFCLASS ALGEBRA (chain-complex)\n",
" ((aprd :type morphism :initarg :aprd :reader aprd1))) ;; product\n",
"```\n",
"\n",
"So, this new class inherits the slots of the `CHAIN COMPLEX` class and has a slot of its own, namely `aprd`, an object of type `MORPHISM` representing the product. Like in a coalgebra, the user will note the important following fact that, **once an algebra has been defined, one may use on it any function or method applicable to a chain complex**.\n",
"\n",
"### The function `build-algb`\n",
"\n",
"To facilitate the construction of instances of the `ALGEBRA` class, the program **Kenzo** provides the function `build-algb`:\n",
"\n",
"```commonlisp\n",
"build-algb :cmpr cmpr :basis basis :bsgn bsgn :intr-dffr intr-dffr\n",
" :dffr-strt dffr-strt :intr-aprd intr-aprd\n",
" :aprd-strt aprd-strt :orgn orgn\n",
"```\n",
"\n",
"defined with keyword parameters. The returned value is an instance of type `ALGEBRA`. \n",
"The keyword arguments are:\n",
"\n",
"- *cmpr*, a comparison function for generators.\n",
"- *basis*, the basis function for the underlying chain complex.\n",
"- *bsgn*, the base point, a generator of any type.\n",
"- *intr-dffr*, the differential lisp function for the chain complex.\n",
"- *dffr-strt*, the strategy (`:gnrt` or `:cmbn`) for the differential.\n",
"- *intr-aprd*, the lisp function for the product of the algebra.\n",
"- *aprd-strt*, the strategy (`:gnrt` or `:cmbn`) for the product.\n",
"- *orgn*, an adequate comment list.\n",
"\n",
"The function `build-algb` calls the function `build-chcm` and with the help of the function `build-mrph` builds the product morphism of degree 0 to settle the slot `aprd` of the instance. According to the definition, the source slot of the product morphism is the tensor product of this chain complex with itself and the target slot is the underlying chain complex. An identification number $n$ (slot `idnm`) is assigned to this Kenzo object and the `ALGEBRA` instance is pushed onto the list `*algb-list*`. The associated printing method prints a string like `[K`*n* `Algebra]`.\n",
"\n",
"### Miscellaneous functions and macros for algebras\n",
"\n",
"`cat-init` *[Function]*\n",
"> Clear among others, the list `*algb-list*`, list of user created algebras and reset the global counter to 1.\n",
"\n",
"`algb` *n* *[Function]*\n",
"> Retrieve in the list `*algb-list*` the algebra instance whose identification is $n$. If it does not exist, return `NIL`.\n",
"\n",
"`aprd` *algb* `&rest` *[Macro]*\n",
"> Versatile macro relative to the product of an algebra. The first argument is an `ALGEBRA`\n",
"instance. With only one argument, this macro returns the product morphism of the algebra.\n",
"With more arguments, it applies the product morphism on a combination (`(aprd` *algb cmbn*`)`)\n",
"or on a pair *degree, tensor-product* (`(aprd` *algb degr tensor-product*`)`).\n",
"\n",
"`change-chcm-to-algb` *chcm* `:intr-aprd` *intr-aprd* `:aprd-strt` *aprd-strt* `:orgn` *orgn* *[Function]*\n",
"> Build an algebra instance from the already created chain complex *chcm*. The user must give via key arguments a lisp function for the product, its strategy and a comment list.\n",
"\n",
"## Hopf Algebra\n",
"\n",
"In **Kenzo**, a Hopf Algebra is an instance of the class `HOPF-ALGEBRA`, the definition of which being simply:\n",
"\n",
"```commonlisp\n",
"(DEFCLASS HOPF-ALGEBRA (coalgebra algebra)\n",
" ())\n",
"```\n",
"\n",
"So, this class (multi-) inherits the slots of the `COALGEBRA` and `ALGEBRA` classes. The associated printing method prints a string like `[K`*n* `Hopf-Algebra]`, and the function `hopf` may be used to retrieve the Hopf instance, in the list `*hopf-list*`. As usual, it is the responsability of the user to be sure the standard coherence properties between product, coproduct, differential and base generator are satisfied.\n",
"\n",
"### Example of algebra\n",
"\n",
"We shall see later important examples of algebras. Let us content ourself for the moment\n",
"to define the trivial algebra on a given chain complex *having only one generator in degree* 0. If this chain complex *chcm* already exists, we use simply the function `change-chcm-to-algb` and we have to provide for the keyword `:intr-aprd`, a lisp function for the product morphism. We recall that the argument of the product in the algebra is a tensor product.\n",
"This function must obey the rule of the multiplication by the unit and otherwise will return a null combination of degree the sum of the two degrees in the tensor product."
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"TRIVIAL-ALGEBRA"
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(defun trivial-algebra (chcm)\n",
" (change-chcm-to-algb \n",
" chcm\n",
" :intr-aprd #'(lambda (degr tnpr)\n",
" (declare (ignore degr))\n",
" (with-tnpr (degr1 gnrt1 degr2 gnrt2) tnpr\n",
" (if (zerop degr1)\n",
" (cmbn degr2 1 gnrt2)\n",
" (if (zerop degr2)\n",
" (cmbn degr1 1 gnrt1)\n",
" (zero-cmbn (+ degr1 degr2))))))\n",
" :aprd-strt :gnrt\n",
" :orgn `(trivial-algebra ,chcm)))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"A good example of a chain complex to be given as argument to the previous function, is the simplicial set `smp-deltab2` that we used as simple example in the coalgebra chapter:"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[K1 Simplicial-Set]"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(def smp-deltab2\n",
" (build-smst\n",
" :cmpr #'(lambda(gsm1 gsm2)\n",
" (if(rest gsm1) (l-cmpr gsm1 gsm2) :equal))\n",
" :basis :locally-effective\n",
" :bspn '(0)\n",
" :face #'(lambda (i dmn gsm)\n",
" (case dmn\n",
" (0 (error \"No face in dimension 0\"))\n",
" (1 (error \"No non-degenerate simplex in dimension 1\"))\n",
" (2 (absm 1 '(0)))\n",
" (otherwise (absm 0 (append (subseq gsm 0 i)\n",
" (subseq gsm (1+ i))))) ))\n",
" :orgn '(simple-deltab2)))"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[K1 Algebra]"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(trivial-algebra smp-deltab2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Note that now `smp-deltab2` is of type `ALGEBRA` and has kept its Kenzo numbering."
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[K1 Algebra]"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"smp-deltab2"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"The object is a STANDARD-OBJECT of type ALGEBRA.\n",
"0. CMPR: #<FUNCTION (LAMBDA (GSM1 GSM2) :IN \"/root/cl-jupyter/cl-jupyter.lisp\") {1001AEC60B}>\n",
"1. BASIS: :LOCALLY-EFFECTIVE\n",
"2. BSGN: (0)\n",
"3. DFFR: [K2 Morphism (degree -1): K1 -> K1]\n",
"4. GRMD: [K1 Algebra]\n",
"5. EFHM: \"unbound\"\n",
"6. IDNM: 1\n",
"7. ORGN: (SIMPLE-DELTAB2)\n",
"8. APRD: [K6 Morphism (degree 0): K3 -> K1]\n",
"> "
]
},
{
"data": {
"text/plain": [
"NIL"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(inspect smp-deltab2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Note the simplicial structure has been lost: the `face` component is no longer present in the object. We will see later the CLASS `simplicial-group` where the group structure automatically induces an algebra structure: the class `simplicial-group` is a subclass of the classes `simplicial-set` and `algebra`.\n",
"\n",
"Let us test now the product in this trivial algebra:"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"\n",
"----------------------------------------------------------------------{CMBN 3}\n",
"<1 * (1 2 3 4)>\n",
"------------------------------------------------------------------------------\n"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(aprd smp-deltab2 3 (tnpr 0 '(0) 3 '(1 2 3 4)))"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"\n",
"----------------------------------------------------------------------{CMBN 3}\n",
"<1 * (1 2 3 4)>\n",
"------------------------------------------------------------------------------\n"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(aprd smp-deltab2 3 (tnpr 3 '(1 2 3 4) 0 '(0)))"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"\n",
"----------------------------------------------------------------------{CMBN 5}\n",
"------------------------------------------------------------------------------\n"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(aprd smp-deltab2 5 (tnpr 2 '(0 1 2) 3 '(6 7 8 9)))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## The Bar construction\n",
"\n",
"Let $\\cal A$ be an associative algebra, assumed connected, that is, ${\\cal A}_0 \\simeq \\mathbb{Z}$. Furthermore let us suppose that ${\\cal A}$ is a free $\\mathbb{Z}$-module, more precisely, for every $i \\geq 0$, a \"distinguished\" basis is chosen for $\\mathcal{A}_i$, the elements of which will be called the (distinguished) *generators* of $\\mathcal{A}_i$. Then it is possible to define a chain complex, $Bar^{\\cal A}(\\mathbb{Z}, \\mathbb{Z})$ - simply denoted here by $Bar({\\cal A})$ - whose $n$-th component is the free $\\mathbb{Z}$-module generated by the \"bars\":\n",
"$$ [Bar({\\cal A})]_n = \\{ [g_1 \\mid g_2 \\mid \\ldots \\mid g_k] \\}, \\quad \\sum_{j=1}^{k} [deg(g_j)+1] =n. $$\n",
"where the $g_i$'s are distinguished generators of arbitrary *positive* degree.\n",
"\n",
"The object denoted $[g_1 \\mid g_2 \\mid \\ldots \\mid g_k]$ \n",
"with $\\sum_{j=1}^{k} [deg(g_j)+1] =n$, is traditionally called a *bar* and is in fact, an element of the $n$-th iterated suspension of ${\\cal A}^{\\otimes n}$. The integer $n$ is the *total degree*. The structure of the bar of the algebra ${\\cal A}$ is recalled in the following figure, where $\\bar{\\cal A}$ is ${\\cal A}$ without its component of degree 0. In the vertical sense, we have the *tensorial degree*, whereas in the horizontal one, we have the *simplicial degree*. The *total degree* $n$ is the sum of both degrees.\n",
"\n",
"$$\n",
"\\begin{array}{|ccccc}\n",
" \\vdots & \\vdots & \\vdots &\\vdots & \\vdots \\\\\n",
" 0 & \\bar{\\cal A}_3 & (\\bar{\\cal A} \\otimes \\bar{\\cal A})_3 & \n",
" (\\bar{\\cal A}\\otimes \\bar{\\cal A}\\otimes\\bar{\\cal A})_3 & \\cdots \\\\\n",
" 0 & \\bar{\\cal A}_2 & (\\bar{\\cal A}\\otimes\\bar{\\cal A})_2 & 0 & \\cdots \\\\\n",
" 0 & \\bar{\\cal A}_1 & 0 & 0 & \\cdots \\\\\n",
" \\mathbb{Z} & 0 & 0 & 0 & \\cdots \\\\ \\hline\n",
" & & & & \\\\\n",
" \\bar{\\cal A}^{\\otimes 0} & \\bar{\\cal A}^{\\otimes 1} & \\bar{\\cal A}^{\\otimes 2} &\n",
" \\bar{\\cal A}^{\\otimes 3} & \\cdots \n",
"\\end{array}\n",
"$$\n",
"\n",
"### Representation of a bar object\n",
"\n",
"An elementary bar object - not to be confused with the chain complex $Bar({\\cal A})$ - is represented in `Kenzo` by a lisp object of the structure class `ABAR`:\n",
"\n",
"`(:ABAR :LIST` (($i_1\\, . \\, a_1$) $\\ldots$ ($i_k\\, . \\, a_k$))`)`\n",
"\n",
"where the $i_j$ are the degrees *in the bar chain complex* of the generators $a_j$. In the original algebra $\\cal A$, the generators $a_j$ had the degree $i_j-1$. The corresponding type is `ABAR`. The function building such an object is also called `abar`\n",
"\n",
"`abar` *degr1 gnr1 degr2 gnr2 ... degrk gnrk* *[Function]*\n",
"> Construct an elementary bar object, i.e. a \"suspended tensorial product\" of degree $\\sum degr_i$. The sequence of pairs $\\lbrace degr_i,\\, gnr_i \\rbrace$ has an undefinite length and may be void. In this case, the bar is the null bar object, also located in the system through the constant `+null-abar+`. The function `abar` accepts also as unique argument a list of the form `(`*degr1 gnr1 degr2 gnr2 ... degrk gnrk*`)`.\n",
"\n",
"`abar-p` *object* *[Function]*\n",
"> Test if *object* is an elementary bar object.\n",
"\n",
"The associated printing method prints the object under the form:\n",
"\n",
"`<<Abar [`$i_1\\quad a_1$ `]` ... `[` $i_k\\quad a_k$ `] >>`\n",
"\n",
"#### Examples\n",
"\n",
"These simple commands show the two different ways to create bar objects\n",
"from elements of an algebra (or a chain complex)."
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"<<Abar[2 A][3 B][5 C]>>"
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(abar 2 'a 3 'b 5 'c)"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"<<Abar[2 A][3 B][5 C]>>"
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(abar '(2 a 3 b 5 c))"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"<<Abar>>"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(abar)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Definition of the chain complex Bar\n",
"\n",
"The definition of the differential in the bar chain complex, will be done in three steps. This is better understood,\n",
"if we consider the following diagram.\n",
"\n",
"$$\n",
"\\begin{aligned}\n",
" & & \\downarrow\\quad & & \\downarrow\\quad \\cr\n",
"\\cdots\\quad & \\leftarrow & ({\\bar{\\cal A}}_*^{\\otimes p})_q & \\qquad\\buildrel {d_h} \\over \\longleftarrow \n",
" & ({\\bar{\\cal A}}_*^{\\otimes {p+1}})_q & \\quad\\leftarrow & \\cdots \\cr\n",
" & & \\downarrow {\\scriptstyle d}_v & & \\downarrow {\\scriptstyle d}_v \\cr\n",
"\\cdots\\quad & \\leftarrow &({\\bar{\\cal A}}_*^{\\otimes p})_{q-1} & \\qquad\\buildrel {d_h} \\over \\longleftarrow \n",
" & ({\\bar{\\cal A}}_*^{\\otimes {p+1}})_{q-1} & \\quad\\leftarrow & \\cdots \\cr \n",
" & & \\downarrow\\quad & & \\downarrow\\quad \\cr\n",
"\\end{aligned}\n",
"$$\n",
"\n",
"- A chain complex called `vertical-bar` is defined with the *vertical differential* $d_v$. In this case, only the underlying chain complex structure of the $\\mathcal{A}i$'s is used.\n",
"- A horizontal differential $d_h$ is defined. This uses the product structure.\n",
"- The final chain complex `bar` is created with differential $d_v+d_h$.\n",
"\n",
"#### Definition of the vertical bar\n",
"\n",
"To define the vertical bar chain complex from the chain complex ${\\cal A}$, the following functions are provided:\n",
"\n",
"`bar-cmpr` *cmpr* *[Function]*\n",
"> From the comparison function *cmpr*, build a comparison function for objects of type `abar`.\n",
"\n",
"`bar-basis` *basis* *[Function]*\n",
"> From the function *basis* of a chain complex ${\\cal A}$, build a basis function for the vertical bar chain complex defined on ${\\cal A}$. In dimension 0, there is only one basis element, namely the null abar object. If ${\\cal A}$ is locally effective, this function returns the symbol `:locally-effective`.\n",
"\n",
"`bar-intr-vrtc-dffr` *dffr* *[Function]*\n",
"> From the `lisp` function *dffr* of a chain complex ${\\cal A}$, build a lisp function for the differential of the vertical bar chain complex, according to the formula:\n",
"$$d_v [a_1 \\mid \\cdots \\mid a_n]=\n",
"-\\sum_{i=1}^n{(-1)^{\\sum_{j=1}^{i-1}{\\mid a_j \\mid}}}\n",
" {[a_1 \\mid \\cdots \\mid a_{i-1} \\mid {\\bf da_i} \\mid a_{i+1} \\mid \\cdots \\mid a_n]},$$\n",
"where $da_i$ is the differential of the generator $a_i$ in the original chain complex (function *dffr*) and $\\mid a_i \\mid$ is in the exponent of $(-1)$ the degree of the generator $a_i$ *in the bar chain complex*.\n",
"In general, the differential $da_i$ is a sum of objects. So, applying the distributive law, the right member is a sum of bar objects, represented by a combination.\n",
"\n",
"`vrtc-bar` *chcm* *[Method]*\n",
"> Build the vertical bar chain complex from the underlying chain complex *chcm*. This is simply done by the call to `build-chcm`:\n",
"```commonlisp\n",
" (build-chcm\n",
" :cmpr (bar-cmpr cmpr)\n",
" :basis (bar-basis basis)\n",
" :bsgn +null-abar+\n",
" :intr-dffr (bar-intr-vrtc-dffr dffr)\n",
" :strt :gnrt\n",
" :orgn `(vrtc-bar ,chcm))\n",
"```\n",
"where, *cmpr*, *basis* and *dffr* are extracted from the chain complex *chcm*. Note that the base generator is the null bar object.\n",
"\n",
"#### Examples\n",
"\n",
"First, let us test the functions `bar-cmpr` and `bar-basis`. With the first one, applied to the elementary comparison function `s-cmpr`, we create a comparison function suitable for algebras where the generators are symbols."
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"#<CLOSURE (FLET RSLT :IN BAR-CMPR) {10022131CB}>"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(def cmpr-for-bar (bar-cmpr #'s-cmpr))"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
":EQUAL"
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(funcall cmpr-for-bar (abar)(abar))"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
":LESS"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(funcall cmpr-for-bar (abar 3 'a 7 'q) (abar 4 'b 2 'p 4 'q))"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
":EQUAL"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(funcall cmpr-for-bar (abar '(1 x 2 y 3 z) )(abar 1 'x 2 'y 3 'z))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Let us suppose now that the function `simple-basis` is the basis function for a certain algebra (chain complex): in degree $i$, the basis is only the list $(a_i)$."
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"#<FUNCTION (LAMBDA (DEGR) :IN \"/root/cl-jupyter/cl-jupyter.lisp\") {100238964B}>"
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(def simple-basis #'(lambda(degr) \n",
" (list (intern(format nil \"A~D\" degr)))))"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(A5)"
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(funcall simple-basis 5)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The function `bar-basis` creates the function for the basis of the corresponding bar chain complex. Note that when this new function is applied, it returns a priori the null abar in dimension 0 and a null basis in dimension 1. Note also that the basis elements of the underlying algebra (the $a_i$'s) are suspended."
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"#<CLOSURE (FLET RSLT :IN BAR-BASIS) {1002416CEB}>"
]
},
"execution_count": 19,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(def basis-for-bar (bar-basis simple-basis))"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"0 (<<Abar>>)\n",
"1 NIL\n",
"2 (<<Abar[2 A1]>>)\n",
"3 (<<Abar[3 A2]>>)\n",
"4 (<<Abar[4 A3]>> <<Abar[2 A1][2 A1]>>)\n",
"5 (<<Abar[5 A4]>> <<Abar[2 A1][3 A2]>> <<Abar[3 A2][2 A1]>>)\n",
"6 (<<Abar[6 A5]>> <<Abar[2 A1][4 A3]>> <<Abar[3 A2][3 A2]>> <<Abar[4 A3][2 A1]>> <<Abar[2 A1][2 A1][2 A1]>>)"
]
},
{
"data": {
"text/plain": [
"NIL"
]
},
"execution_count": 20,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(dotimes (i 7)\n",
" (format t \"~%~D ~A\" i (funcall basis-for-bar i)))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"To test the vertical differential, let us take the simplicial set `smp-deltab2` which is also a chain complex. We may use it for testing the function `vrtc-bar` which defines a chain complex independently of the product of the algebra. We recall that, in dimension $n$, the elements of the chain complex `smp-deltab2` are represented by lists of increasing $n+1$ integers. So, in the abar objects, the degree of such elements are $n+1$."
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[K7 Chain-Complex]"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(def vrt-bar (vrtc-bar smp-deltab2))"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"\n",
"----------------------------------------------------------------------{CMBN 8}\n",
"<1 * <<Abar[3 (0 1 2)][5 (4 5 6 7 8)]>>>\n",
"<-1 * <<Abar[3 (0 1 3)][5 (4 5 6 7 8)]>>>\n",
"<1 * <<Abar[3 (0 2 3)][5 (4 5 6 7 8)]>>>\n",
"<-1 * <<Abar[3 (1 2 3)][5 (4 5 6 7 8)]>>>\n",
"<-1 * <<Abar[4 (0 1 2 3)][4 (4 5 6 7)]>>>\n",
"<1 * <<Abar[4 (0 1 2 3)][4 (4 5 6 8)]>>>\n",
"<-1 * <<Abar[4 (0 1 2 3)][4 (4 5 7 8)]>>>\n",
"<1 * <<Abar[4 (0 1 2 3)][4 (4 6 7 8)]>>>\n",
"<-1 * <<Abar[4 (0 1 2 3)][4 (5 6 7 8)]>>>\n",
"------------------------------------------------------------------------------\n"
]
},
"execution_count": 22,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(? vrt-bar 9 (abar 4 '(0 1 2 3) 5 '(4 5 6 7 8)))"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"\n",
"----------------------------------------------------------------------{CMBN 7}\n",
"------------------------------------------------------------------------------\n"
]
},
"execution_count": 23,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(? vrt-bar *)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Definition of the horizontal differential\n",
"\n",
"So far, the algebra structure has not been used but now it will be the main ingredient.\n",
"The canonical \"horizontal\" differential $d_h$ is defined as follows:\n",
"\n",
"$$d_h:({\\bar{\\cal A}}_*^{\\otimes p})_q \\longrightarrow ({\\bar{\\cal A}}_*^{\\otimes {p-1}})_q,$$\n",
"\n",
"$$d_h [a_1 \\mid \\cdots \\mid a_k] = \\sum_{i=2}^n{(-1)^{\\sum_{j=1}^{i-1}{\\mid a_j \\mid}}}\n",
" [a_1 \\mid \\cdots \\mid a_{i-2} \\mid {\\bf a_{i-1}a_i} \\mid a_{i+1} \\mid \\cdots \\mid a_k]$$\n",
"\n",
"where the product in the algebra is noted simply by the concatenation and $\\mid a_i \\mid$ in the exponent of $(-1)$ is the degree of $a_i$ in $Bar({\\cal A})$. In `Kenzo`, two functions are designed for building the horizontal differential:\n",
"\n",
"`bar-intr-hrzn-dffr` *aprd* *[Function]*\n",
"> From the product morphism *aprd*, build the lisp function with 2 arguments: a degree and an `abar` object (i.e. a generator) realizing the algorithm for $d_h$.\n",
"\n",
"`bar-hrzn-dffr` *algb* *[Function]*\n",
"Build the horizontal differential morphism, using the slot product *aprd* of the algebra *algb* and the previous function. Note that when called, this function creates, if not already created, the vertical bar chain complex on *algb*:\n",
"```commonlisp\n",
" (build-mrph\n",
" :sorc (vrtc-bar algb) \n",
" :trgt (vrtc-bar algb) \n",
" :degr -1\n",
" :intr (bar-intr-hrzn-dffr aprd) \n",
" :strt :gnrt\n",
" :orgn `(bar-hrzn-dffr ,algb))\n",
"```\n",
"\n",
"#### Final definition of the bar of an algebra\n",
"\n",
"To define completely the bar chain complex, we have to provide the lisp function for the differential $d_v + d_h$ and, once created the vertical bar chain complex, we have to call the building function `build-chcm` with adequate arguments.\n",
"\n",
"`bar-intr-dffr` *vrtc-dffr hrzn-dffr* *[Function]*\n",
"> Define the lisp function for the differential $d_v+d_h$ from the two morphisms *vrtc-dffr* and *hrzn-dffr*. For efficiency reasons, the implementor has chosen to define this new function rather than to use simply\n",
"the addition of two morphisms.\n",
"\n",
"`bar` *algebra* *[Method]*\n",
"> Build first the vertical bar chain complex on the algebra. Then return a chain complex with the same slots as the vertical bar chain complex but with new `:intr-dffr` and `:orgn` slots, as shown in the following definition:\n",
"```commonlisp\n",
" (defmethod BAR ((algebra algebra))\n",
" (let ((vrtc-bar (vrtc-bar algebra))\n",
" (bar-hrzn-dffr (bar-hrzn-dffr algebra)))\n",
" (declare (type chain-complex vrtc-abr hrzn-bar))\n",
" (the chain-complex\n",
" (build-chcm\n",
" :cmpr (cmpr vrtc-bar)\n",
" :basis (basis vrtc-bar)\n",
" :bsgn +null-abar+\n",
" :intr-dffr (bar-intr-dffr (dffr vrtc-bar) \n",
" bar-hrzn-dffr)\n",
" :strt :gnrt\n",
" :orgn `(add ,vrtc-bar ,bar-hrzn-dffr)))))\n",
"```\n",
"\n",
"We postpone the examples for the bar of an algebra, up to the chapter on simplicial groups where we shall build interesting examples of algebras.\n",
"\n",
"## Other functions for the bar construction\n",
"\n",
"The vertical bar construction is *natural* and therefore defines a functor. Consequently, the `Kenzo` program contains the following methods.\n",
"\n",
"`vrtc-bar` *mrph* *[Method]*\n",
"> From the morphism *mrph*, build a new morphism between the vertical-bar of the source of *mrph* and the vertical bar of the target of *mrph*, the morphism itself being induced in a natural way by the underlying morphism.\n",
"\n",
"`vrtc-bar` *rdct* *[Method]*\n",
"> From the reduction *rdct*, build a new reduction, by applying the vertical bar method to the functions $f$ and $g$. The new homotopy cannot be obtained so simply, being a function of the $f$, $g$ and $h$ of *rdct*. Nevertheless, the source and target of the new homotopy are the vertical bar of the underlying homotopy.\n",
"\n",
"`vrtc-bar` *hmeq* *[Method]*\n",
"> Build a homotopy equivalence by applying the vertical bar construction to the left and right reductions of the homotopy equivalence *hmeq*.\n",
"\n",
"`bar` *hmeq* *[Method]*\n",
"> Build a homotopy equivalence where the bar construction is applied to the underlying homotopy equivalence in the following way. First this construction is limited to the case where the left bottom chain complex of *hmeq* is an ** algebra**. Then the vertical bar construction is applied to *hmeq* and the horizontal differential of the left bottom chain complex is propagated upon the new homotopy equivalence with the help of the method `add`. In other words,\n",
"starting from the left bottom chain complex, firstly the easy pertubation lemma is applied to obtain a new differential on the top chain complex; then the basic perturbation lemma is applied to the right reduction. If *hmeq* is a trivial homotopy equivalence, this function returns a trivial one, built on the bar of the left bottom chain complex of * hmeq*.\n",
"\n",
"### Lisp files concerned in this chapter\n",
"\n",
"`algebras.lisp`, `bar.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": 1
}
Reference in New Issue View Git Blame Copy Permalink