871 lines
23 KiB
Plaintext
871 lines
23 KiB
Plaintext
{
|
|
"cells": [
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"# Tensor product of chain complexes\n",
|
|
"\n",
|
|
"## Introduction\n",
|
|
"\n",
|
|
"One knows that the homology groups of a cartesian product of two spaces $K$ and $L$ may be obtained by considering a chain complex derived from respective chain complexes of $K$ and $L$ by taking their *tensor product*. The connection between this tensor product and the chain complex of $K \\times L$ is the *Eilenberg-Zilber reduction*, a central point in *constructive* Algebraic Topology. This reduction is implemented in the `eilenberg-zilber` module of this program.\n",
|
|
"\n",
|
|
"Let us recall that chain complexes are free $\\mathbb{Z}$-modules with distinguished basis. A tensor product of chain complexes \n",
|
|
"is itself a free $\\mathbb{Z}$-module with a natural basis formed by the tensor products of the generators of the chain complex factors.\n",
|
|
"\n",
|
|
"## Tensor product of generators and combinations\n",
|
|
"\n",
|
|
"An elementary tensor product of two generators is represented, in the program, by an object of the structure-class `TNPR`. There are four slots to define such an object:\n",
|
|
"1. *degr1* is an integer, the degree of the generator *gnrt1*.\n",
|
|
"2. *gnrt1* is the first generator of the pair.\n",
|
|
"3. *degr2* is an integer, the degree of the generator *gnrt2*.\n",
|
|
"4. *gnrt2* is the second generator of the pair.\n",
|
|
"To construct such an object, one may use the macro `tnpr`. The corresponding type is `TNPR`. The printing method prints the tensor product under the form:\n",
|
|
">`<TnPr` *gnrt1 gnrt2*`>` or `<TnPr` *degr1 gnrt1 degr2 gnrt2*`>`\n",
|
|
"\n",
|
|
"according to the boolean value, `NIL` (default) or `T` of the system variable `*tnpr-with-degrees*` (see the examples).\n",
|
|
"\n",
|
|
"### Simple functions for the tensor product\n",
|
|
"\n",
|
|
"\n",
|
|
"`(tnpr degr1 gnrt1 degr2 gnrt2)` *[Macro]*\n",
|
|
"> Build a tensor product $gnrt1 \\otimes gnrt2$, the factors being of respective degree `degr1` and `degr2`.\n",
|
|
"\n",
|
|
"`(tnpr-p object)` *[Predicate]*\n",
|
|
"> Test if *object* is of type `TNPR`.\n",
|
|
"\n",
|
|
"`(degr1 tnpr)` *[Macro]*\n",
|
|
"> Select the degree of the first generator in the tensor product *tnpr*.\n",
|
|
"\n",
|
|
"`(gnrt1 tnpr)` *[Macro]*\n",
|
|
"> Select the first generator from the object *tnpr*.\n",
|
|
"\n",
|
|
"`(degr2 tnpr)` *[Macro]*\n",
|
|
"> Select the degree of the second generator in the tensor product *tnpr*.\n",
|
|
"\n",
|
|
"`(gnrt2 tnpr)` *[Macro]*\n",
|
|
"> Select the second generator from the object *tnpr*.\n",
|
|
"\n",
|
|
"`(2cmbn-tnpr cmbn1 cmbn2)` *[Function]*\n",
|
|
"> Create, from two combinations *cmbn1* and *cmbn2* with respective degree *degr1* and *degr2*, a combination of degree $dgr1 + dgr2$ by applying the tensorial distributive law on the two sums of terms of the combinations.\n",
|
|
"\n",
|
|
"#### Example"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 1,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"<TnPr A B>"
|
|
]
|
|
},
|
|
"execution_count": 1,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(tnpr 1 'a 2 'b)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 2,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"\n",
|
|
"The object is a STRUCTURE-OBJECT of type TNPR.\n",
|
|
"0. DEGR1: 1\n",
|
|
"1. GNRT1: A\n",
|
|
"2. DEGR2: 2\n",
|
|
"3. GNRT2: B\n",
|
|
"\n",
|
|
"> "
|
|
]
|
|
},
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"NIL"
|
|
]
|
|
},
|
|
"execution_count": 2,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(inspect *)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 3,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"T"
|
|
]
|
|
},
|
|
"execution_count": 3,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(tnpr-p **)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 4,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"NIL"
|
|
]
|
|
},
|
|
"execution_count": 4,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(tnpr-p (cmbn 0 1 'a 2 'b))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 5,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"T"
|
|
]
|
|
},
|
|
"execution_count": 5,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(setf *tnpr-with-degrees* t)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 6,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"\n",
|
|
"----------------------------------------------------------------------{CMBN 5}\n",
|
|
"<12 * <TnPr 2 A 3 X>>\n",
|
|
"<-9 * <TnPr 2 A 3 Y>>\n",
|
|
"<6 * <TnPr 2 A 3 Z>>\n",
|
|
"<16 * <TnPr 2 B 3 X>>\n",
|
|
"<-12 * <TnPr 2 B 3 Y>>\n",
|
|
"<8 * <TnPr 2 B 3 Z>>\n",
|
|
"<-20 * <TnPr 2 C 3 X>>\n",
|
|
"<15 * <TnPr 2 C 3 Y>>\n",
|
|
"<-10 * <TnPr 2 C 3 Z>>\n",
|
|
"------------------------------------------------------------------------------\n"
|
|
]
|
|
},
|
|
"execution_count": 6,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(2cmbn-tnpr (cmbn 2 3 'a 4 'b -5 'c) (cmbn 3 4 'x -3 'y 2 'z))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 7,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"NIL"
|
|
]
|
|
},
|
|
"execution_count": 7,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(setf *tnpr-with-degrees* nil)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 8,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"\n",
|
|
"----------------------------------------------------------------------{CMBN 5}\n",
|
|
"<12 * <TnPr A X>>\n",
|
|
"<-9 * <TnPr A Y>>\n",
|
|
"<6 * <TnPr A Z>>\n",
|
|
"<16 * <TnPr B X>>\n",
|
|
"<-12 * <TnPr B Y>>\n",
|
|
"<8 * <TnPr B Z>>\n",
|
|
"<-20 * <TnPr C X>>\n",
|
|
"<15 * <TnPr C Y>>\n",
|
|
"<-10 * <TnPr C Z>>\n",
|
|
"------------------------------------------------------------------------------\n"
|
|
]
|
|
},
|
|
"execution_count": 8,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"**"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## Tensor product of chain complexes\n",
|
|
"\n",
|
|
"The program implements the tensor product of chain complexes according to the classical following definition. Let $C$ and $C'$ be two chain complexes. The tensor product $C\\otimes C'$ is the chain complex $D$ such that:\n",
|
|
"$$\n",
|
|
"D_p=\\bigoplus_{m+n=p}C_m\\otimes C_n',\n",
|
|
"$$\n",
|
|
"$C_m\\otimes C_n'$ being the tensor product of the two modules $C_m$ and $C_n'$. A basis for $D_p$ is the union of the basis of $C_m\\otimes C_n'$, with $m+n=p$.\n",
|
|
"\n",
|
|
"The boundary operator $d^{\\otimes}$ is defined, according to the Koszul rule, by:\n",
|
|
"\n",
|
|
"$$d^{\\otimes}(c_m\\otimes c_n')=d(c_m)\\otimes c_n' +(-1)^m c_m\\otimes d'(c_n'),$$\n",
|
|
"\n",
|
|
"with $c_m\\in C_m,\\ c_n'\\in C_n'$ and $d$, $d'$ being the respective boundary operators\n",
|
|
"of $C$ and $C'$.\n",
|
|
"\n",
|
|
"In the program, this is realized by the function `tnsr-prdc`. \n",
|
|
"\n",
|
|
"`(tnsr-prdc chcm1 chcm2)` *[Method]*\n",
|
|
"> Build a chain complex, tensor product of the two chain complexes *chcm1* and *chcm2*. The elements\n",
|
|
"of this new chain complex are integer combinations of generators of *TNPR* type. The creation of this\n",
|
|
"new chain complex is done by a call to the function *build-chcm* with actual parameters defined from the constituting elements of *chcm1* and *chcm2*, according to the mathematical definitions above. If both arguments are *effective*, the function constructs an *effective* chain complex. On the other hand, if at least one of the chain complex is *locally effective*, the tensor product is also *locally effective*. In fact, the construction is correct only if both chain complexes are null in negative degrees, otherwise the result is undefined.\n",
|
|
"\n",
|
|
"#### Examples\n",
|
|
"\n",
|
|
"Let us take the standard 2-simplex, $\\Delta^2$ and let us build $C_*(\\Delta^2) \\otimes C_*(\\Delta^2)$. To build the corresponding chain complex, we use the function `cdelta`, defined in a previous chapter."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 9,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"\n",
|
|
"---done---"
|
|
]
|
|
},
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"NIL"
|
|
]
|
|
},
|
|
"execution_count": 9,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(cat-init)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 10,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"CDELTA"
|
|
]
|
|
},
|
|
"execution_count": 10,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(defun cdelta (dmns)\n",
|
|
" (build-chcm\n",
|
|
" :cmpr #'l-cmpr\n",
|
|
" :basis #'(lambda (n)\n",
|
|
" (mapcar #'dlop-int-ext (funcall (delta-n-basis dmns) n)))\n",
|
|
" :bsgn '(0)\n",
|
|
" :intr-dffr\n",
|
|
" #'(lambda (degr gmsm)\n",
|
|
" (make-cmbn\n",
|
|
" :degr (1- degr)\n",
|
|
" :list (do ((rslt +empty-list+\n",
|
|
" (cons (cons sign\n",
|
|
" (append\n",
|
|
" (subseq gmsm 0 nark)\n",
|
|
" (subseq gmsm (1+ nark))))\n",
|
|
" rslt))\n",
|
|
" (sign 1 (- sign))\n",
|
|
" (nark 0 (1+ nark)))\n",
|
|
" ((> nark degr) rslt))))\n",
|
|
" :strt :gnrt\n",
|
|
" :orgn `(Effective version of C_* delta ,dmns)))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 11,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"[K1 Chain-Complex]"
|
|
]
|
|
},
|
|
"execution_count": 11,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(def triangle (cdelta 2))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 12,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"((0 1) (0 2) (1 2))"
|
|
]
|
|
},
|
|
"execution_count": 12,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(basis triangle 1)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 13,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"[K3 Chain-Complex]"
|
|
]
|
|
},
|
|
"execution_count": 13,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(def tpr-triangles (tnsr-prdc triangle triangle))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"Let us inspect some basis of this newly created chain complex."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 14,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"(<TnPr (0) (0)> <TnPr (0) (1)> <TnPr (0) (2)> <TnPr (1) (0)> <TnPr (1) (1)> <TnPr (1) (2)> <TnPr (2) (0)> <TnPr (2) (1)> <TnPr (2) (2)>)"
|
|
]
|
|
},
|
|
"execution_count": 14,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(basis tpr-triangles 0)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 15,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"(<TnPr (0) (0 1)> <TnPr (0) (0 2)> <TnPr (0) (1 2)> <TnPr (1) (0 1)> <TnPr (1) (0 2)> <TnPr (1) (1 2)> <TnPr (2) (0 1)> <TnPr (2) (0 2)> <TnPr (2) (1 2)> <TnPr (0 1) (0)> ...)"
|
|
]
|
|
},
|
|
"execution_count": 15,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(basis tpr-triangles 1)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 16,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"(<TnPr (0) (0 1 2)> <TnPr (1) (0 1 2)> <TnPr (2) (0 1 2)> <TnPr (0 1) (0 1)> <TnPr (0 1) (0 2)> <TnPr (0 1) (1 2)> <TnPr (0 2) (0 1)> <TnPr (0 2) (0 2)> <TnPr (0 2) (1 2)> <TnPr (1 2) (0 1)> ...)"
|
|
]
|
|
},
|
|
"execution_count": 16,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(basis tpr-triangles 2)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 17,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"(<TnPr (0 1) (0 1 2)> <TnPr (0 2) (0 1 2)> <TnPr (1 2) (0 1 2)> <TnPr (0 1 2) (0 1)> <TnPr (0 1 2) (0 2)> <TnPr (0 1 2) (1 2)>)"
|
|
]
|
|
},
|
|
"execution_count": 17,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(basis tpr-triangles 3)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 18,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"(<TnPr (0 1 2) (0 1 2)>)"
|
|
]
|
|
},
|
|
"execution_count": 18,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(basis tpr-triangles 4)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"Let us consider now the chain complex, $ccn$, that we used in the chain complex chapter. The basis in any degree are decades produced by the function `<a-b<`. We build $ccn\\otimes ccn$ and we verify the fundamental property of the associated boundary operator:\n",
|
|
"\n",
|
|
"$$d^\\otimes \\circ d^\\otimes=0.$$"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 19,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"#<FUNCTION (LAMBDA (DGR GNR) :IN \"/root/cl-jupyter-master/cl-jupyter.lisp\") {1005B3B8EB}>"
|
|
]
|
|
},
|
|
"execution_count": 19,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(def ccn-boundary #'(lambda (dgr gnr)\n",
|
|
" (if (evenp (+ dgr gnr))\n",
|
|
" (cmbn (1- dgr) 1 (- gnr 10))\n",
|
|
" (cmbn (1- dgr)))))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 20,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"[K5 Chain-Complex]"
|
|
]
|
|
},
|
|
"execution_count": 20,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(def ccn (build-chcm :cmpr #'f-cmpr\n",
|
|
" :basis #'(lambda (n) (<a-b< (* 10 n) (* 10 (1+ n))))\n",
|
|
" :intr-dffr ccn-boundary\n",
|
|
" :strt :gnrt\n",
|
|
" :orgn '(ccn) ))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 21,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"(30 31 32 33 34 35 36 37 38 39)"
|
|
]
|
|
},
|
|
"execution_count": 21,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(basis ccn 3)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 22,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"[K7 Chain-Complex]"
|
|
]
|
|
},
|
|
"execution_count": 22,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(def tpr-ccn-ccn (tnsr-prdc ccn ccn))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 23,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"\n",
|
|
"----------------------------------------------------------------------{CMBN 2}\n",
|
|
"<1 * 21>\n",
|
|
"<5 * 25>\n",
|
|
"<9 * 29>\n",
|
|
"------------------------------------------------------------------------------\n"
|
|
]
|
|
},
|
|
"execution_count": 23,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(def comb2 (cmbn 2 1 21 5 25 9 29))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 24,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"\n",
|
|
"----------------------------------------------------------------------{CMBN 3}\n",
|
|
"<2 * 32>\n",
|
|
"<3 * 33>\n",
|
|
"<-4 * 34>\n",
|
|
"<-6 * 36>\n",
|
|
"------------------------------------------------------------------------------\n"
|
|
]
|
|
},
|
|
"execution_count": 24,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(def comb3 (cmbn 3 2 32 3 33 -4 34 -6 36))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 25,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"\n",
|
|
"----------------------------------------------------------------------{CMBN 5}\n",
|
|
"<2 * <TnPr 21 32>>\n",
|
|
"<3 * <TnPr 21 33>>\n",
|
|
"<-4 * <TnPr 21 34>>\n",
|
|
"<-6 * <TnPr 21 36>>\n",
|
|
"<10 * <TnPr 25 32>>\n",
|
|
"<15 * <TnPr 25 33>>\n",
|
|
"<-20 * <TnPr 25 34>>\n",
|
|
"<-30 * <TnPr 25 36>>\n",
|
|
"<18 * <TnPr 29 32>>\n",
|
|
"<27 * <TnPr 29 33>>\n",
|
|
"... ...\n",
|
|
"------------------------------------------------------------------------------\n"
|
|
]
|
|
},
|
|
"execution_count": 25,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(def tcmb (2cmbn-tnpr comb2 comb3))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 26,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"\n",
|
|
"----------------------------------------------------------------------{CMBN 4}\n",
|
|
"<3 * <TnPr 21 23>>\n",
|
|
"<15 * <TnPr 25 23>>\n",
|
|
"<27 * <TnPr 29 23>>\n",
|
|
"------------------------------------------------------------------------------\n"
|
|
]
|
|
},
|
|
"execution_count": 26,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(? tpr-ccn-ccn *)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 27,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"\n",
|
|
"----------------------------------------------------------------------{CMBN 3}\n",
|
|
"------------------------------------------------------------------------------\n"
|
|
]
|
|
},
|
|
"execution_count": 27,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(? tpr-ccn-ccn *)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## Tensor product of morphisms, reductions, homotopy equivalences.\n",
|
|
"\n",
|
|
"Let $f:A_1 \\longrightarrow A_2$ and $g:B_1 \\longrightarrow B_2$ two morphisms between \n",
|
|
"two chain complexes. The tensor product $f \\otimes g$ is the morphism\n",
|
|
"\n",
|
|
"$$f\\otimes g : A_1\\otimes B_1 \\longrightarrow A_2\\otimes B_2$$ \n",
|
|
"\n",
|
|
"defined by the following formula respecting the Koszul rule:\n",
|
|
"\n",
|
|
"$$ (f\\otimes g) (a_1 \\otimes b_1)= (-1)^{deg(g)*deg(a1)}f(a_1) \\otimes g(b_1).$$\n",
|
|
"\n",
|
|
"The method `tnsr-prdc` already defined for chain complexes, may be also used for that purpose. \n",
|
|
"\n",
|
|
"`(tnsr-prdc mrph1 mrph2)` *[Method]*\n",
|
|
"> Return the morphism, tensor product of the two morphisms *mrph1* and *mrph2*. The source and target of this new morphism are respectively the tensor product of the chain complexes source and target of *mrph1* and *mrph2*. The degree is the sum of the degrees of the parameters and the lisp function (the `:intr` keyword argument of the function `build-mrph`) conforms to the mathematical definition above. The internal strategy is by generator, i.e. the morphism is designed to work with 2 arguments: a degree and a generator which must be an object of type `TNPR`.\n",
|
|
"\n",
|
|
"`(tnsr-prdc rdct1 rdct2)` *[Method]*\n",
|
|
"> Return the reduction, tensor product of the two reductions *rdct1* and *rdct2*. The algorithm consists essentially in defining\n",
|
|
"$$f=f1 \\otimes f2,\\, g=g1 \\otimes g2,\\, h= h1 \\otimes (g2 \\circ g2) + Id_{tcc1} \\otimes h2,$$\n",
|
|
"where $Id_{tcc1}$ is the identity morphism in the top chain complex of the reduction *rdct1*.\n",
|
|
"The returned reduction is then built by a call to the method `build-rdct`. This defines completely the chain complexes involved in the reduction.\n",
|
|
"\n",
|
|
"`(tnsr-prdc hmeq1 hmeq2)` *[Method]*\n",
|
|
"> Return the homotopy equivalence, tensor product of the two homotopy equivalences *heqm1* and *heqm2*. This is a homotopy equivalence where the new reductions are the tensor products of the arguments reductions (See the lisp definition just above).\n",
|
|
"\n",
|
|
"### Searching homology for tensor products\n",
|
|
"\n",
|
|
"The comment list of a tensor product of two chain complexes has the form \n",
|
|
"`(TNSR-PRDC` *chcm1 chcm2*`)`. The `search-efhm` method applied to a tensor product, looks for the value of the respective `efhm` slots of the chain complexes *chcm1* and *chcm2*, (i.e. two homotopy equivalences) or tries to settle these slots if they are still unbound. Then it builds the tensor product of both homotopy equivalences, as shown in the following lisp listing. In turn, the resulting homotopy equivalence will become the value of the `efhm` slot of the initial tensor product chain complex.\n",
|
|
"\n",
|
|
"```commonlisp\n",
|
|
"(defmethod SEARCH-EFHM (chcm (orgn (eql 'tnsr-prdc)))\n",
|
|
" (declare (type chain-complex chcm))\n",
|
|
" (the homotopy-equivalence\n",
|
|
" (tnsr-prdc (efhm (second (orgn chcm)))\n",
|
|
" (efhm (third (orgn chcm))))))\n",
|
|
"\n",
|
|
"(defmethod TNSR-PRDC ((hmeq1 homotopy-equivalence)\n",
|
|
"\t\t (hmeq2 homotopy-equivalence))\n",
|
|
" (the homotopy-equivalence\n",
|
|
" (build-hmeq\n",
|
|
" :lrdct (tnsr-prdc (lrdct hmeq1) (lrdct hmeq2))\n",
|
|
" :rrdct (tnsr-prdc (rrdct hmeq1) (rrdct hmeq2))\n",
|
|
" :orgn `(tnsr-prdc ,hmeq1 ,hmeq2))))\n",
|
|
"```\n",
|
|
"\n",
|
|
"#### Lisp file concerned in this chapter\n",
|
|
"\n",
|
|
"`tensor-products.lisp`, `searching-homology.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": 0
|
|
}
|