1871 lines
51 KiB
Plaintext
1871 lines
51 KiB
Plaintext
{
|
|
"cells": [
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"# Simplicial Groups\n",
|
|
"\n",
|
|
"## Representation of a simplicial group\n",
|
|
"\n",
|
|
"A simplicial group is an instance of the class `SIMPLICIAL-GROUP`, subclass of the classes `KAN` and `HOPF-ALGEBRA`.\n",
|
|
"```commonlisp\n",
|
|
"(DEFCLASS SIMPLICIAL-GROUP (kan hopf-algebra)\n",
|
|
" ((grml :type simplicial-mrph :initarg :grml :reader grml1)\n",
|
|
" (grin :type simplicial-mrph :initarg :grin :reader grin1)))\n",
|
|
"```\n",
|
|
"We recall that this new class (multi-) inherits from the following classes: `KAN`, `SIMPLICIAL-SET`, `COALGEBRA`, `ALGEBRA` and `CHAIN-COMPLEX`. It has two slots of its own:\n",
|
|
"\n",
|
|
"`grml`, an object of type `SIMPLICIAL-MRPH`, defining in the underlying simplicial set $S$, the group operation as a simplicial morphism from $S \\times S$ onto $S$, compatible with the face and degeneracy operators in $S$, i.e. the $\\partial$'s and $\\eta$'s operators are also group morphisms. In dimension $n$, the neutral element is assumed to be the $n$-th degeneracy of the base point of the underlying simplicial set.\n",
|
|
"\n",
|
|
"`grin`, an object of type `SIMPLICIAL-MRPH`, defining the inverse of an element of the Kan simplicial set with respect to the preceding group law.\n",
|
|
"\n",
|
|
"A printing method has been associated to the class `SIMPLICIAL GROUP` and the external representation of an instance is a string like `[K`*n* `Simplicial-Group]`, where *n* is the number plate of the Kenzo object.\n",
|
|
"\n",
|
|
"## Representation of an Abelian simplicial group\n",
|
|
"\n",
|
|
"The class of Abelian simplicial group, `AB-SIMPLICIAL-GROUP`, inherits all the properties of the class `SIMPLICIAL-GROUP` and has not slots of its own, as shown by:\n",
|
|
"```commonlisp\n",
|
|
"(DEFCLASS AB-SIMPLICIAL-GROUP (simplicial-group) ())\n",
|
|
"```\n",
|
|
"The difference is purely mathematical: it is up to the user to provide as slot *grml*, a simplicial morphism which is **commutative**. As expected, the external representation of an instance of this class, is a string like\n",
|
|
"`[K`*n* `Abelian-Simplicial-Group]`, where *n* is the number plate of the Kenzo object.\n",
|
|
"\n",
|
|
"## The functions `build-smgr` and `build-ab-smrg`\n",
|
|
"\n",
|
|
"To facilitate the construction of instances of the classes `SIMPLICIAL-GROUP` and `AB-SIMPLICIAL-GROUP` and to free the user to call the standard constructor `make-instance`, the software provides the functions *build-smrg* and *build-ab-smrg*.\n",
|
|
"\n",
|
|
"`build-smgr`\n",
|
|
"> `:cmpr` *cmpr* `:basis` *basis* `:bspn` *bspn* `:face` *face* `:face*` *face*$*$ \n",
|
|
"`:intr-bndr` *intr-bndr* `:bndr-strt` *bndr-strt* `:intr-dgnl` *intr-dgnl* \n",
|
|
"`:dgnl-strt` *dgnl-strt* `:sintr-grml` *sintr-grml* `:sintr-grin` *sintr-grin* \n",
|
|
"`:orgn` *orgn*\n",
|
|
"\n",
|
|
"defined with keyword parameters and returning an instance of the class `SIMPLICIAL-GROUP`. The keyword arguments *cmpr*, *basis*, *bspn*, *face*, *face*$*$, *intr-bndr*, *bndr-strt*, *intr-dgnl* and *dgnl-strt* are the arguments provided to build the underlying simplicial set using the function `build-smst`. Let us call it $S$. As usual, an adequate comment list must be provided for the parameter `:orgn`. The only two new arguments are:\n",
|
|
"\n",
|
|
"- *sintr-grml*, a lisp function defining the group operation $S \\times S \\longrightarrow S$. The function `build-smgr` uses this lisp function to build a simplicial morphism of degree 0 between the cartesian product of the newly created simplicial set $S$ and itself. This new simplicial morphism is the value of the slot `grml` of the cartesian square of the simplicial group instance.\n",
|
|
"- *sintr-grin*, a lisp function defining the inverse w.r.t the preceding group law of an element of $S$. The function `build-smgr` uses this lisp function to build a simplicial morphism of degree 0 between $S$ and itself. This new simplicial morphism is the value of the slot `grin` of the simplicial group instance.\n",
|
|
"\n",
|
|
"After a call to `build-smgr`, the simplicial group instance is pushed onto the list of previously constructed ones (`*smgr-list*`). The simplicial group with Kenzo identification $n$, may be retrieved in the `*smgr-list*`, by a call to the function `sgmr` as `(sgmr` *n*`)`. The list `*smgr-list*` may be cleared by the function `cat-init`.\n",
|
|
"\n",
|
|
"Up to now the slot `kfll` has not been filled. As long as the user does not make use of the filling function, directly or indirectly, this slot remains unbound. But as soon as it is needed, the *slot-unbound* mechanism of CLOS enters in action and the filling function is defined by the system with the help of the functions `face`, `sintr-grml` and `sintr-grin`. The automatic creation of the filling function is possible because mathematically, a simplicial group is always a Kan simplicial set. This is realized by the internal function `smgr-kfll-intr`.\n",
|
|
"\n",
|
|
"For the user, the two simplicial morphisms, values of the specific slots of a `SIMPLICIAL-GROUP` are applied via the two following macros:\n",
|
|
"\n",
|
|
"`grml` *smgr dmns crpr* *[Macro]*\n",
|
|
"> Apply the simplicial morphism, value of the slot `grml` of the simplicial group instance *smgr* to the cartesian product *crpr* in dimension *dmns*. Mathematically, this realizes the group operation. In principle, the simplicial morphism must accept the *crpr* argument on both forms: either a geometric cartesian product or an abstract simplex, the geometric part of which is a geometric cartesian product (see the examples). With only one argument (*smgr*) the macro selects the simplicial morphism instance.\n",
|
|
"\n",
|
|
"`grin` *smgr dmns absm-or-gsm* *[Macro]*\n",
|
|
"> Apply the simplicial morphism, value of the slot `grin` of the simplicial group instance *smgr* to the element *absm-or-gsm* in dimension *dmns*. Mathematically this gives the inverse in the group of the element. As suggested by the name of the parameter, this must work with geometric simplices as well as abstract simplices. With only one argument (*smgr*) the macro selects the simplicial morphism.\n",
|
|
"\n",
|
|
"`build-ab-smgr`\n",
|
|
"> `:cmpr` *cmpr* `:basis` *basis* `:bspn` *bspn* `:face` *face* `:face*` *face*$*$ \n",
|
|
"`:intr-bndr` *intr-bndr* `:bndr-strt` *bndr-strt* `:intr-dgnl` *intr-dgnl* \n",
|
|
"`:dgnl-strt` *dgnl-strt* `:sintr-grml` *sintr-grml* `:sintr-grin` *sintr-grin* \n",
|
|
"`:orgn` *orgn*\n",
|
|
"\n",
|
|
"The description of the parameters is exactly the same as in the previous function, but in this case, the group operation given by the user, (argument *sintr-grml*), must be commutative. The lisp definition of `build-ab-smgr` is simply:\n",
|
|
"```commonlisp\n",
|
|
"(DEFMACRO BUILD-AB-SMGR (&rest rest)\n",
|
|
" `(change-class (build-smgr ,@rest) 'ab-simplicial-group))\n",
|
|
"```\n",
|
|
"\n",
|
|
"## Two important Abelian simplicial groups: $K(\\mathbb{Z}, 1)$ and $K(\\mathbb{Z}_2, 1)$}\n",
|
|
"\n",
|
|
"Let us recall the notion of classifying space in the framework of simplicial sets and in the particular case of discrete groups. Given a discrete group $\\cal G$, we know that we may build a simplicial set $K({\\cal G}, 1)$; in dimension $n$, we have $(K({\\cal G}, 1))_n = {\\cal G}^n$, the simplices or *bar objects* being conventionally represented as sequences of elements of $\\cal G$:\n",
|
|
"$$ [g_1 \\mid g_2 \\mid \\ldots \\mid g_n]. $$\n",
|
|
"The base point is the void bar object $[\\ ]$, the only vertex of $K(\\mathcal{G},1)$. Let us note the group law multiplicatively.\n",
|
|
"\n",
|
|
"The face operators are defined as follows:\n",
|
|
"$$\n",
|
|
"\\begin{aligned}\n",
|
|
"\\partial_0 [g_1 \\mid g_2 \\mid \\ldots \\mid g_n] & = & [g_2 \\mid g_3 \\mid \\ldots \\mid g_n], \\\\\n",
|
|
"\\partial_1 [g_1 \\mid g_2 \\mid \\ldots \\mid g_n] & = & [{\\bf g_1g_2} \\mid g_3 \\mid \\ldots \\mid g_n], \\\\\n",
|
|
"\\partial_2 [g_1 \\mid g_2 \\mid \\ldots \\mid g_n] & = & [g_1 \\mid {\\bf g_2g_3} \\mid \\ldots \\mid g_n], \\\\\n",
|
|
" ...... & = & ...... \\\\\n",
|
|
"\\partial_{n-1} [g_1 \\mid g_2 \\mid \\ldots \\mid g_n] & = & [g_1 \\mid g_2 \\mid \\ldots \\mid g_{n-2} \\mid {\\bf g_{n-1}g_n}], \\\\\n",
|
|
"\\partial_n [g_1 \\mid g_2 \\mid \\ldots \\mid g_n] & = & [g_1 \\mid g_2 \\mid \\ldots \\mid g_{n-1}].\n",
|
|
"\\end{aligned}\n",
|
|
"$$\n",
|
|
"The degeneracy operators are defined as follows:\n",
|
|
"$$ \\eta_i [g_1 \\mid \\ldots \\mid g_{i-1} \\mid g_i \\mid g_{i+1} \\mid \\ldots \\mid g_n] =\n",
|
|
" [g_1 \\mid \\ldots \\mid g_{i-1} \\mid g_i \\mid {\\bf e} \\mid g_{i+1} \\mid \\ldots \\mid g_n],$$\n",
|
|
"where $e$ is the neutral element of $\\cal G$.\n",
|
|
"\\par\n",
|
|
"If, in addition $\\cal G$ is abelian, then $K({\\cal G}, 1)$ is itself a *simplicial group*, with the\n",
|
|
"following group law, in dimension $n$:\n",
|
|
"$$[a_1 \\mid \\cdots \\mid a_n] . [b_1 \\mid \\cdots \\mid b_n] = [a_1+b_1 \\mid \\cdots \\mid a_n+b_n], $$\n",
|
|
"$$[a_1 \\mid \\cdots \\mid a_n]^{-1}= [-a_1 \\mid \\cdots \\mid -a_n],\\quad a,b \\in {\\cal G}$$\n",
|
|
"In dimension $n$, the neutral element is the bar object constitued by a sequence of $n$ times the neutral $e$ of ${\\cal G}$; this is also the $n$-th degeneracy of the base point $[\\ ]$ of $K({\\cal G}, 1)$.\n",
|
|
"\n",
|
|
"The two important simplicial groups $K(\\mathbb{Z}, 1)$ and $K(\\mathbb{Z}_2, 1)$ may be constructed in `Kenzo`.\n",
|
|
"\n",
|
|
"`k-z-1` *[Function]*\n",
|
|
"> Build the simplicial group $K(\\mathbb{Z},1)$. In this simplicial group, a simplex in dimension $n$ is mathematically represented by a sequence of integers, known as a *bar* object:\n",
|
|
"$$ [a_1 \\mid a_2 \\mid \\ldots \\mid a_n]. $$\n",
|
|
"Such a simplex of $K(\\mathbb{Z},1)$ is really, mathematically speaking, a *bar* object, but exceptionally is not implemented as a `bar` structure object, as it will be the rule later for arbitrary *classifying spaces*.\n",
|
|
"The group operation inherits the additive law of $\\mathbb{Z}$:\n",
|
|
"$$[a_1 \\mid \\cdots \\mid a_n] + [b_1 \\mid \\cdots \\mid b_n] = [a_1+b_1 \\mid \\cdots \\mid a_n+b_n]$$\n",
|
|
"and the inverse of $[a_1 \\mid \\ldots \\mid a_n]$ is $[-a_1 \\mid \\ldots \\mid -a_n]. $\n",
|
|
"In `Kenzo`, a non-degenerate simplex of $K(\\mathbb{Z},1)$ in dimension $n$ will be simply a list of $n$ non-null integers. The underlying simplicial set is locally effective and its base point is `NIL`, i.e the void bar object\n",
|
|
"$[\\ ]$. To be coherent with the general policy of `Kenzo`, a degenerate simplex must be represented by\n",
|
|
"an abstract simplex of the form `#S(ABSM :dgop` *n* `:gmsm` *list*`)` where *gmsm* is a non-degenerate simplex, here a list of non-null integers. But, for the computations in the simplicial group, the general form of a bar object, including an arbitrary number of 0's, is more natural and more convenient. Consequently, two conversion functions are provided (see below).\n",
|
|
"\n",
|
|
"`k-z2-1` *[Function]*\n",
|
|
"> Build the simplicial group $K(\\mathbb{Z}_2,1)$. Mathematically, in dimension $n$, the only non-degenerate simplex is\n",
|
|
"a sequence of $n$ 1's. But one may show that as simplicial set, $K(\\mathbb{Z}_2,1)$ is isomorphic to $P^\\infty \\mathbb{R}$ which may be built by the statement `(R-proj-space)`. This is the representation adopted in `Kenzo`. In dimension $n$, this simplicial set has only one non-degenerate simplex, namely the integer $n$. The formulas for the faces of one non-degenerate simplex conventionally represented by the integer $n$ become:\n",
|
|
"$$\n",
|
|
"\\begin{aligned}\n",
|
|
"\\partial_0 n & = & n-1, \\\\\n",
|
|
"\\partial_i n & = & \\eta_{i-1} (n-2), \\quad i \\not= 0, i \\not=n, \\\\\n",
|
|
"\\partial_n n & = & n-1.\n",
|
|
"\\end{aligned}\n",
|
|
"$$\n",
|
|
"\n",
|
|
"As a group, in dimension $n$, the non-degenerate element $n$ is its own inverse and the neutral is the $n$-th degeneracy of 0. As in $K(\\mathbb{Z}, 1)$ a degenerate simplex must be represented by a valid abstract simplex, but as the computations are more convenient if the general bar objects are represented by a sequence of mixed 0's and 1's, two conversion functions are\n",
|
|
"provided.\n",
|
|
"\n",
|
|
"`z-bar-absm` *bar* *[Function]*\n",
|
|
"> Transform a general mathematical bar object *bar* of $K(\\mathbb{Z}, 1)$, represented by a list of integers (including 0's), into a valid abstract simplex (an object of type `ABSM`), `#S(ABSM :dgop` *n* `:gmsm` *list*`)`, where *gmsm* is a sequence of non-null integers representing a non-degenerate bar object of $K(\\mathbb{Z},1)$ and *dgop* a coded sequence of degeneracy operators $\\eta_i$'s.\n",
|
|
"\n",
|
|
"`z-absm-bar` *absm* *[Function]*\n",
|
|
"> Transform the abstract simplex *absm*, `#S(ABSM :dgop` *n* `:gmsm` *list*`)`, where *gmsm* is a sequence of non-null integers representing a nondegenerate bar object of $K(\\mathbb{Z},1)$ and *dgop* a coded sequence of degeneracy operators, into a list of integers representing a bar object, degenerate or not, of $K(\\mathbb{Z},1)$, for more convenience in the internal computations or for more clarity in external printing.\n",
|
|
"\n",
|
|
"`z2-bar-absm` *bar* *[Function]*\n",
|
|
"> Function analogous to `z-bar-absm` but for $K(\\mathbb{Z}_2, 1)$.\n",
|
|
"\n",
|
|
"`z2-absm-bar` *absm* *[Function]*\n",
|
|
"> Function analogous to `z-absm-bar` but for $K(\\mathbb{Z}_2, 1)$.\n",
|
|
"\n",
|
|
"### Examples"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 1,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"[K1 Abelian-Simplicial-Group]"
|
|
]
|
|
},
|
|
"execution_count": 1,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(def KZ1 (k-z-1))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 2,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"(1 10 100)"
|
|
]
|
|
},
|
|
"execution_count": 2,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(def simplex '(1 10 100))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 3,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"<AbSm - (10 100)>"
|
|
]
|
|
},
|
|
"execution_count": 3,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(face KZ1 0 3 simplex)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"Let us build the list of the four faces and by suppressing successively, each face one after the other in this list, let us verify that we have always a Kan horn (we recall that the lisp function `remove`, works on a copy of the list, i.e. the argument `hat` is not modified). In the forth statement, we verify the property of minimality of this special simplicial group."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 4,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"(<AbSm - (10 100)> <AbSm - (11 100)> <AbSm - (1 110)> <AbSm - (1 10)>)"
|
|
]
|
|
},
|
|
"execution_count": 4,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(def hat (mapcar #'(lambda (i) (face KZ1 i 3 simplex)) (<a-b> 0 3)))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 5,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"\n",
|
|
"---done---\n",
|
|
"---done---\n",
|
|
"---done---\n",
|
|
"---done---"
|
|
]
|
|
},
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"NIL"
|
|
]
|
|
},
|
|
"execution_count": 5,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(dotimes (i 4)\n",
|
|
" (check-kan KZ1 i 3 (remove (nth i hat) hat)))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 6,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"(<AbSm - (10 100)> <AbSm - (1 110)> <AbSm - (1 10)>)"
|
|
]
|
|
},
|
|
"execution_count": 6,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(def hat1 (remove (nth 1 hat) hat))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 7,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"<AbSm - (1 10 100)>"
|
|
]
|
|
},
|
|
"execution_count": 7,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(kfll KZ1 1 3 hat1)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"We test now the two macros `grml` and `grin` related to the group operation."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 8,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"<AbSm - (2 20 200)>"
|
|
]
|
|
},
|
|
"execution_count": 8,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(grml KZ1 3 (crpr 0 simplex 0 simplex))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 9,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"<AbSm - (-1 -10 -100)>"
|
|
]
|
|
},
|
|
"execution_count": 9,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(def invsimplex (grin KZ1 3 simplex))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 10,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"<AbSm - (1 10 100)>"
|
|
]
|
|
},
|
|
"execution_count": 10,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(grin KZ1 3 *) "
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 11,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"<AbSm 2-1-0 NIL>"
|
|
]
|
|
},
|
|
"execution_count": 11,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(grml KZ1 3 (crpr 0 simplex 0 (gmsm invsimplex)))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 12,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"<AbSm - <CrPr - (1 10 100) - (-1 -10 -100)>>"
|
|
]
|
|
},
|
|
"execution_count": 12,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(2absm-acrpr (absm 0 simplex ) (grin KZ1 3 simplex))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 13,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"<AbSm 2-1-0 NIL>"
|
|
]
|
|
},
|
|
"execution_count": 13,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(grml KZ1 3 *) "
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 14,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"[K13 Abelian-Simplicial-Group]"
|
|
]
|
|
},
|
|
"execution_count": 14,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(def KZ2 (k-z2-1))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 15,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"<AbSm 2-1-0 0>"
|
|
]
|
|
},
|
|
"execution_count": 15,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(grml KZ2 3 (crpr 0 3 0 3))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 16,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"<AbSm - 4>"
|
|
]
|
|
},
|
|
"execution_count": 16,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(grin KZ2 4 4)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 17,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"<AbSm 3-2-1-0 0>"
|
|
]
|
|
},
|
|
"execution_count": 17,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(grml KZ2 4 (crpr 0 4 0 4))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"Let us show some examples of conversions, between general bar objects and valid abstract simplices:"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 18,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"NIL"
|
|
]
|
|
},
|
|
"execution_count": 18,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(z-absm-bar (absm 0 '()))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 19,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"(0)"
|
|
]
|
|
},
|
|
"execution_count": 19,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(z-absm-bar (absm 1 '()))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 20,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"(2)"
|
|
]
|
|
},
|
|
"execution_count": 20,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(z-absm-bar (absm 0 '(2)))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 21,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"(0 0 0 1 1 1 1 1 1 1)"
|
|
]
|
|
},
|
|
"execution_count": 21,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(z2-absm-bar (absm 7 7))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 22,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"(1 1 1 1 1 1 1)"
|
|
]
|
|
},
|
|
"execution_count": 22,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(z2-absm-bar (absm 0 7))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"Let us suppose that the value of the symbol `labsms` is a list of abstract simplices built from the simplex `(3 6)` in dimension 1 of $K(\\mathbb{Z}, 1)$. The application of the function `z-absm-bar` on this list gives the representation of the simplices under the classical mathematical representation. Applying then `z-bar-absm` returns the original list. A similar example is given with the symbol `labsm2` in dimension 0."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 23,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"(<AbSm - (3 6)> <AbSm 0 (3 6)> <AbSm 1 (3 6)> <AbSm 1-0 (3 6)> <AbSm 2 (3 6)> <AbSm 2-0 (3 6)> <AbSm 2-1 (3 6)> <AbSm 2-1-0 (3 6)>)"
|
|
]
|
|
},
|
|
"execution_count": 23,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(def labsms (mapcar #'(lambda (n) (absm n '(3 6))) '(0 1 2 3 4 5 6 7)))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 24,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"((3 6) (0 3 6) (3 0 6) (0 0 3 6) (3 6 0) (0 3 0 6) (3 0 0 6) (0 0 0 3 6))"
|
|
]
|
|
},
|
|
"execution_count": 24,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(mapcar #'z-absm-bar labsms)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 25,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"(<AbSm - (3 6)> <AbSm 0 (3 6)> <AbSm 1 (3 6)> <AbSm 1-0 (3 6)> <AbSm 2 (3 6)> <AbSm 2-0 (3 6)> <AbSm 2-1 (3 6)> <AbSm 2-1-0 (3 6)>)"
|
|
]
|
|
},
|
|
"execution_count": 25,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(mapcar #'z-bar-absm *)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 26,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"(<AbSm - 0> <AbSm - 1> <AbSm - 2> <AbSm - 3> <AbSm 0 0> <AbSm 0 1> <AbSm 0 2> <AbSm 0 3> <AbSm 1-0 0> <AbSm 1-0 1> ...)"
|
|
]
|
|
},
|
|
"execution_count": 26,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(def labsms2 (append (mapcar #'(lambda (n) (absm 0 n)) '(0 1 2 3))\n",
|
|
" (mapcar #'(lambda (n) (absm 1 n)) '(0 1 2 3))\n",
|
|
" (mapcar #'(lambda (n) (absm 3 n)) '(0 1 2 3))))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 27,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"(NIL (1) (1 1) (1 1 1) (0) (0 1) (0 1 1) (0 1 1 1) (0 0) (0 0 1) ...)"
|
|
]
|
|
},
|
|
"execution_count": 27,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(mapcar #'z2-absm-bar labsms2)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 28,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"(<AbSm - 0> <AbSm - 1> <AbSm - 2> <AbSm - 3> <AbSm 0 0> <AbSm 0 1> <AbSm 0 2> <AbSm 0 3> <AbSm 1-0 0> <AbSm 1-0 1> ...)"
|
|
]
|
|
},
|
|
"execution_count": 28,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(mapcar #'z2-bar-absm *)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## Simplicial Groups as Algebras\n",
|
|
"\n",
|
|
"If we consider a simplicial group ${\\cal G}$, with group operation $\\tau$, there is a canonical product for the algebra\n",
|
|
"$$\\varpi : C_*({\\cal G}) \\otimes C_*({\\cal G}) \\longrightarrow C_*({\\cal G}), $$\n",
|
|
"defined as the composition $\\tau \\circ {\\cal EML}$, where ${\\cal EML}$ is the Eilenberg-Mac Lane homomorphism or the *shuffle homomorphism* (see the Eilenberg-Zilber chapter):\n",
|
|
"$$C_*({\\cal G}) \\otimes C_*({\\cal G}) \\buildrel {{\\cal EML}} \\over \\longrightarrow\n",
|
|
" C_*({\\cal G} \\times {\\cal G}) \\buildrel {\\tau} \\over \\longrightarrow C_*({\\cal G}). $$\n",
|
|
"For instance let us look at the simplicial group $K(\\mathbb{Z}, 1)$:"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 29,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"[K1 Abelian-Simplicial-Group]"
|
|
]
|
|
},
|
|
"execution_count": 29,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(def kz1 (k-z-1))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 30,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"\n",
|
|
"The object is a STANDARD-OBJECT of type AB-SIMPLICIAL-GROUP.\n",
|
|
"0. CMPR: #<FUNCTION K-Z-1-CMPR>\n",
|
|
"1. BASIS: :LOCALLY-EFFECTIVE\n",
|
|
"2. BSGN: NIL\n",
|
|
"3. DFFR: [K2 Morphism (degree -1): K1 -> K1]\n",
|
|
"4. GRMD: [K1 Abelian-Simplicial-Group]\n",
|
|
"5. EFHM: \"unbound\"\n",
|
|
"6. IDNM: 1\n",
|
|
"7. ORGN: (K-Z-1)\n",
|
|
"8. APRD: \"unbound\"\n",
|
|
"9. CPRD: [K5 Morphism (degree 0): K1 -> K3]\n",
|
|
"10. FACE: #<FUNCTION K-Z-1-FACE>\n",
|
|
"11. KFLL: #<CLOSURE (FLET CAT::RSLT :IN CAT::SMGR-KFLL-INTR) {100579D84B}>\n",
|
|
"12. GRML: [K11 Simplicial-Morphism K6 -> K1]\n",
|
|
"13. GRIN: [K12 Simplicial-Morphism K1 -> K1]\n",
|
|
"\n",
|
|
"> "
|
|
]
|
|
},
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"NIL"
|
|
]
|
|
},
|
|
"execution_count": 30,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(inspect kz1)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"We see that the slot `aprd` has not been filled. As long as the user does not need, directly or indirectly, the product of the algebra, this slot remains unbound. But as soon as it is needed, the *slot-unbound* mecanism of CLOS enters in action, the canonical algebra product morphism is defined by the system, and the slot\n",
|
|
"`aprd` is set.\n",
|
|
"\n",
|
|
"For instance, let us take the tensor product of two elements of $K(\\mathbb{Z}, 1)$ and apply the product in the algebra:"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 31,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"<TnPr (1 2) (7 8 9)>"
|
|
]
|
|
},
|
|
"execution_count": 31,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(def tnsrp (tnpr 2 '(1 2) 3 '(7 8 9))) "
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 32,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"\n",
|
|
"----------------------------------------------------------------------{CMBN 5}\n",
|
|
"<1 * (1 2 7 8 9)>\n",
|
|
"<-1 * (1 7 2 8 9)>\n",
|
|
"<1 * (1 7 8 2 9)>\n",
|
|
"<-1 * (1 7 8 9 2)>\n",
|
|
"<1 * (7 1 2 8 9)>\n",
|
|
"<-1 * (7 1 8 2 9)>\n",
|
|
"<1 * (7 1 8 9 2)>\n",
|
|
"<1 * (7 8 1 2 9)>\n",
|
|
"<-1 * (7 8 1 9 2)>\n",
|
|
"<1 * (7 8 9 1 2)>\n",
|
|
"------------------------------------------------------------------------------\n"
|
|
]
|
|
},
|
|
"execution_count": 32,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(aprd kz1 5 tnsrp)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"The system `Kenzo` has automatically created the needed algebra product morphism and this is shown in the slot instance `aprd`:"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 33,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"\n",
|
|
"The object is a STANDARD-OBJECT of type AB-SIMPLICIAL-GROUP.\n",
|
|
"0. CMPR: #<FUNCTION K-Z-1-CMPR>\n",
|
|
"1. BASIS: :LOCALLY-EFFECTIVE\n",
|
|
"2. BSGN: NIL\n",
|
|
"3. DFFR: [K2 Morphism (degree -1): K1 -> K1]\n",
|
|
"4. GRMD: [K1 Abelian-Simplicial-Group]\n",
|
|
"5. EFHM: \"unbound\"\n",
|
|
"6. IDNM: 1\n",
|
|
"7. ORGN: (K-Z-1)\n",
|
|
"8. APRD: [K26 Morphism (degree 0): K3 -> K1]\n",
|
|
"9. CPRD: [K5 Morphism (degree 0): K1 -> K3]\n",
|
|
"10. FACE: #<FUNCTION K-Z-1-FACE>\n",
|
|
"11. KFLL: #<CLOSURE (FLET CAT::RSLT :IN CAT::SMGR-KFLL-INTR) {100579D84B}>\n",
|
|
"12. GRML: [K11 Simplicial-Morphism K6 -> K1]\n",
|
|
"13. GRIN: [K12 Simplicial-Morphism K1 -> K1]\n",
|
|
"\n",
|
|
"> "
|
|
]
|
|
},
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"NIL"
|
|
]
|
|
},
|
|
"execution_count": 33,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(inspect kz1)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"An interesting example is to show the associativity of the canonical product of an algebra, by defining in `Kenzo` the morphisms of the following diagram and verifying that this diagram is commutative. In the diagram, $\\nabla$ is the algebra product of ${\\cal A}$, $1$ is the identity morphism on ${\\cal A}$ and\n",
|
|
"*assoc*, the morphism\n",
|
|
"$$assoc: ({\\cal A}\\otimes {\\cal A}) \\otimes {\\cal A} \\longrightarrow {\\cal A} \\otimes ({\\cal A}\\otimes {\\cal A}),$$\n",
|
|
"with:\n",
|
|
"$$assoc((a\\otimes b)\\otimes c) = a \\otimes (b \\otimes c).$$\n",
|
|
"\n",
|
|
"$$\n",
|
|
"\\begin{aligned}\n",
|
|
"({\\cal A}\\otimes {\\cal A}) \\otimes {\\cal A} & \\quad\\buildrel {assoc} \\over \\longrightarrow &\n",
|
|
" {\\cal A} \\otimes ({\\cal A}\\otimes {\\cal A}) \\cr\n",
|
|
"{\\scriptstyle \\nabla \\otimes 1}\\downarrow \\qquad& & \\downarrow {\\scriptstyle 1 \\otimes \\nabla}\\quad \\cr\n",
|
|
"{\\cal A}\\otimes {\\cal A}\\quad & & {\\cal A}\\otimes {\\cal A}\\quad \\cr\n",
|
|
"{\\scriptstyle \\nabla}\\searrow \\quad & & \\swarrow {\\scriptstyle \\nabla} \\qquad \\cr\n",
|
|
" & \\qquad{\\cal A} & \\cr\n",
|
|
"\\end{aligned}\n",
|
|
"$$\n",
|
|
"\n",
|
|
"Let us define two chain complexes with the two ways to compose two tensorial products:"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 34,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"[K1 Abelian-Simplicial-Group]"
|
|
]
|
|
},
|
|
"execution_count": 34,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(def kz1 (k-z-1))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 35,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"[K27 Chain-Complex]"
|
|
]
|
|
},
|
|
"execution_count": 35,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(def 3-left (tnsr-prdc (tnsr-prdc kz1 kz1) kz1))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 36,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"[K29 Chain-Complex]"
|
|
]
|
|
},
|
|
"execution_count": 36,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(def 3-right (tnsr-prdc kz1 (tnsr-prdc kz1 kz1)))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"Then we define the morphism `assoc` and test it:"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 37,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"[K31 Morphism (degree 0): K27 -> K29]"
|
|
]
|
|
},
|
|
"execution_count": 37,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(def assoc1 (build-mrph\n",
|
|
" :sorc 3-left\n",
|
|
" :trgt 3-right\n",
|
|
" :degr 0\n",
|
|
" :intr #'(lambda (degr a2-a)\n",
|
|
" (declare (ignore degr))\n",
|
|
" (with-tnpr (degra2 gnrta2 degra gnrta) a2-a\n",
|
|
" (declare (ignore degra2))\n",
|
|
" (with-tnpr (degr1 gnrt1 degr2 gnrt2) gnrta2\n",
|
|
" (cmbn (+ degr1 degr2 degra) \n",
|
|
" 1 (tnpr degr1 gnrt1 \n",
|
|
" (+ degr2 degra) \n",
|
|
" (tnpr degr2 gnrt2 degra gnrta))))))\n",
|
|
" :strt :gnrt\n",
|
|
" :orgn '(assoc-double-tensor-product)))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 38,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"T"
|
|
]
|
|
},
|
|
"execution_count": 38,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(setf *tnpr-with-degrees* t)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 39,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"\n",
|
|
"----------------------------------------------------------------------{CMBN 7}\n",
|
|
"<1 * <TnPr 2 (1 2) 5 <TnPr 2 (2 3) 3 (4 5 6)>>>\n",
|
|
"------------------------------------------------------------------------------\n"
|
|
]
|
|
},
|
|
"execution_count": 39,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(? assoc1 7 (tnpr 4 (tnpr 2 '(1 2) 2 '(2 3)) 3 '(4 5 6)))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"We define now the other morphisms shown in the diagram:"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 40,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"[K26 Morphism (degree 0): K3 -> K1]"
|
|
]
|
|
},
|
|
"execution_count": 40,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(def nabla (aprd kz1))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 41,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"[K32 Morphism (degree 0): K1 -> K1]"
|
|
]
|
|
},
|
|
"execution_count": 41,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(def idnt (idnt-mrph kz1))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 42,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"[K33 Morphism (degree 0): K29 -> K3]"
|
|
]
|
|
},
|
|
"execution_count": 42,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(def 1-t-nabla (tnsr-prdc idnt nabla))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 43,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"[K34 Morphism (degree 0): K27 -> K3]"
|
|
]
|
|
},
|
|
"execution_count": 43,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(def nabla-t-1 (tnsr-prdc nabla idnt)) "
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"Now, if the diagram is commutative, the difference morphism, noted `zero`, between the following morphisms `right` and `left`, must give the null combination if applied to an element of $K(\\mathbb{Z}, 1) \\otimes K(\\mathbb{Z}, 1)) \\otimes K(\\mathbb{Z},1).$"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 44,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"[K35 Morphism (degree 0): K27 -> K1]"
|
|
]
|
|
},
|
|
"execution_count": 44,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(def left (cmps nabla nabla-t-1))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 45,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"[K37 Morphism (degree 0): K27 -> K1]"
|
|
]
|
|
},
|
|
"execution_count": 45,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(def right (i-cmps nabla 1-t-nabla assoc1))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 46,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"[K38 Morphism (degree 0): K27 -> K1]"
|
|
]
|
|
},
|
|
"execution_count": 46,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(def zero (sbtr left right))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 47,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"\n",
|
|
"----------------------------------------------------------------------{CMBN 7}\n",
|
|
"------------------------------------------------------------------------------\n"
|
|
]
|
|
},
|
|
"execution_count": 47,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(? zero 7 (tnpr 4 (tnpr 2 '(1 2) 2 '(2 3)) 3 '(4 5 6)))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 48,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"\n",
|
|
"----------------------------------------------------------------------{CMBN 9}\n",
|
|
"------------------------------------------------------------------------------\n"
|
|
]
|
|
},
|
|
"execution_count": 48,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(? zero 9 (tnpr 7 (tnpr 3 '(2 3 4) 4 '(5 6 7 8)) 2 '(11 12)))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"It happens the resulting combination of the rather simple double tensor product has 140 terms:"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 49,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"\n",
|
|
"----------------------------------------------------------------------{CMBN 7}\n",
|
|
"<1 * (1 2 3 2 4 5 6)>\n",
|
|
"<-1 * (1 2 3 4 2 5 6)>\n",
|
|
"<1 * (1 2 3 4 5 2 6)>\n",
|
|
"<-1 * (1 2 3 4 5 6 2)>\n",
|
|
"<1 * (1 2 4 3 2 5 6)>\n",
|
|
"<-1 * (1 2 4 3 5 2 6)>\n",
|
|
"<1 * (1 2 4 3 5 6 2)>\n",
|
|
"<1 * (1 2 4 5 3 2 6)>\n",
|
|
"<-1 * (1 2 4 5 3 6 2)>\n",
|
|
"<1 * (1 2 4 5 6 3 2)>\n",
|
|
"... ...\n",
|
|
"------------------------------------------------------------------------------\n"
|
|
]
|
|
},
|
|
"execution_count": 49,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(? right 7 (tnpr 4 (tnpr 2 '(1 2) 2 '(2 3)) 3 '(4 5 6)))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 50,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"140"
|
|
]
|
|
},
|
|
"execution_count": 50,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(length (cmbn-list *))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## Coming back to the Bar of an algebra\n",
|
|
"\n",
|
|
"The existence of a canonical product for the underlying algebra of a simplicial group allows us now to generate the bar of this algebra. Let us use again $K(\\mathbb{Z}, 1).$ We begin to test separately the vertical and the horizontal differential."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 51,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"[K1 Abelian-Simplicial-Group]"
|
|
]
|
|
},
|
|
"execution_count": 51,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(def kz1 (k-z-1))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 52,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"#<CLOSURE (LAMBDA (DEGR ABAR) :IN BAR-INTR-VRTC-DFFR) {1006FD5A6B}>"
|
|
]
|
|
},
|
|
"execution_count": 52,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(def d-vert (bar-intr-vrtc-dffr (dffr kz1)))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 53,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"\n",
|
|
"----------------------------------------------------------------------{CMBN -1}\n",
|
|
"------------------------------------------------------------------------------\n"
|
|
]
|
|
},
|
|
"execution_count": 53,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(funcall d-vert 0 (abar))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 54,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"<<Abar[3 (1 2)][3 (-1 -2)][3 (3 4)]>>"
|
|
]
|
|
},
|
|
"execution_count": 54,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(def abar0 (abar 3 '(1 2) 3 '(-1 -2) 3 '(3 4)))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 55,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"\n",
|
|
"----------------------------------------------------------------------{CMBN 8}\n",
|
|
"<-1 * <<Abar[2 (1)][3 (-1 -2)][3 (3 4)]>>>\n",
|
|
"<-1 * <<Abar[2 (2)][3 (-1 -2)][3 (3 4)]>>>\n",
|
|
"<1 * <<Abar[2 (3)][3 (-1 -2)][3 (3 4)]>>>\n",
|
|
"<-1 * <<Abar[3 (1 2)][2 (-3)][3 (3 4)]>>>\n",
|
|
"<1 * <<Abar[3 (1 2)][2 (-2)][3 (3 4)]>>>\n",
|
|
"<1 * <<Abar[3 (1 2)][2 (-1)][3 (3 4)]>>>\n",
|
|
"<-1 * <<Abar[3 (1 2)][3 (-1 -2)][2 (3)]>>>\n",
|
|
"<-1 * <<Abar[3 (1 2)][3 (-1 -2)][2 (4)]>>>\n",
|
|
"<1 * <<Abar[3 (1 2)][3 (-1 -2)][2 (7)]>>>\n",
|
|
"------------------------------------------------------------------------------\n"
|
|
]
|
|
},
|
|
"execution_count": 55,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(funcall d-vert 9 abar0)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 56,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"#<CLOSURE (LAMBDA (DEGR ABAR) :IN BAR-INTR-HRZN-DFFR) {100714F0DB}>"
|
|
]
|
|
},
|
|
"execution_count": 56,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(def d-hrz (bar-intr-hrzn-dffr (aprd kz1)))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 57,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"\n",
|
|
"----------------------------------------------------------------------{CMBN 8}\n",
|
|
"<1 * <<Abar[3 (1 2)][5 (-1 -2 3 4)]>>>\n",
|
|
"<-1 * <<Abar[3 (1 2)][5 (-1 3 -2 4)]>>>\n",
|
|
"<1 * <<Abar[3 (1 2)][5 (-1 3 4 -2)]>>>\n",
|
|
"<1 * <<Abar[3 (1 2)][5 (3 -1 -2 4)]>>>\n",
|
|
"<-1 * <<Abar[3 (1 2)][5 (3 -1 4 -2)]>>>\n",
|
|
"<1 * <<Abar[3 (1 2)][5 (3 4 -1 -2)]>>>\n",
|
|
"<-1 * <<Abar[5 (-1 -2 1 2)][3 (3 4)]>>>\n",
|
|
"<1 * <<Abar[5 (-1 1 -2 2)][3 (3 4)]>>>\n",
|
|
"<-1 * <<Abar[5 (-1 1 2 -2)][3 (3 4)]>>>\n",
|
|
"<-1 * <<Abar[5 (1 -1 -2 2)][3 (3 4)]>>>\n",
|
|
"... ...\n",
|
|
"------------------------------------------------------------------------------\n"
|
|
]
|
|
},
|
|
"execution_count": 57,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(funcall d-hrz 9 abar0)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"We may now construct the bar chain complex of the algebra `kz1` and test the differential, sum of both previous ones:"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 58,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"[K42 Chain-Complex]"
|
|
]
|
|
},
|
|
"execution_count": 58,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(def bara (bar kz1))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 59,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"\n",
|
|
"----------------------------------------------------------------------{CMBN 8}\n",
|
|
"<1 * <<Abar[3 (1 2)][5 (-1 -2 3 4)]>>>\n",
|
|
"<-1 * <<Abar[3 (1 2)][5 (-1 3 -2 4)]>>>\n",
|
|
"<1 * <<Abar[3 (1 2)][5 (-1 3 4 -2)]>>>\n",
|
|
"<1 * <<Abar[3 (1 2)][5 (3 -1 -2 4)]>>>\n",
|
|
"<-1 * <<Abar[3 (1 2)][5 (3 -1 4 -2)]>>>\n",
|
|
"<1 * <<Abar[3 (1 2)][5 (3 4 -1 -2)]>>>\n",
|
|
"<-1 * <<Abar[5 (-1 -2 1 2)][3 (3 4)]>>>\n",
|
|
"<1 * <<Abar[5 (-1 1 -2 2)][3 (3 4)]>>>\n",
|
|
"<-1 * <<Abar[5 (-1 1 2 -2)][3 (3 4)]>>>\n",
|
|
"<-1 * <<Abar[5 (1 -1 -2 2)][3 (3 4)]>>>\n",
|
|
"... ...\n",
|
|
"------------------------------------------------------------------------------\n"
|
|
]
|
|
},
|
|
"execution_count": 59,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(? bara 9 abar0)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 60,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"\n",
|
|
"----------------------------------------------------------------------{CMBN 7}\n",
|
|
"------------------------------------------------------------------------------\n"
|
|
]
|
|
},
|
|
"execution_count": 60,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(? bara *)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 61,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"<<Abar[5 (7 11 4 -9)][4 (8 3 2)][5 (-1 -2 -3 -4)]>>"
|
|
]
|
|
},
|
|
"execution_count": 61,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(def abar1 (abar '(5 (7 11 4 -9) 4 (8 3 2) 5 (-1 -2 -3 -4))))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 62,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"\n",
|
|
"----------------------------------------------------------------------{CMBN 13}\n",
|
|
"<-1 * <<Abar[5 (7 11 4 -9)][8 (-1 -2 -3 -4 8 3 2)]>>>\n",
|
|
"<1 * <<Abar[5 (7 11 4 -9)][8 (-1 -2 -3 8 -4 3 2)]>>>\n",
|
|
"<-1 * <<Abar[5 (7 11 4 -9)][8 (-1 -2 -3 8 3 -4 2)]>>>\n",
|
|
"<1 * <<Abar[5 (7 11 4 -9)][8 (-1 -2 -3 8 3 2 -4)]>>>\n",
|
|
"<-1 * <<Abar[5 (7 11 4 -9)][8 (-1 -2 8 -3 -4 3 2)]>>>\n",
|
|
"<1 * <<Abar[5 (7 11 4 -9)][8 (-1 -2 8 -3 3 -4 2)]>>>\n",
|
|
"<-1 * <<Abar[5 (7 11 4 -9)][8 (-1 -2 8 -3 3 2 -4)]>>>\n",
|
|
"<-1 * <<Abar[5 (7 11 4 -9)][8 (-1 -2 8 3 -3 -4 2)]>>>\n",
|
|
"<1 * <<Abar[5 (7 11 4 -9)][8 (-1 -2 8 3 -3 2 -4)]>>>\n",
|
|
"<-1 * <<Abar[5 (7 11 4 -9)][8 (-1 -2 8 3 2 -3 -4)]>>>\n",
|
|
"... ...\n",
|
|
"------------------------------------------------------------------------------\n"
|
|
]
|
|
},
|
|
"execution_count": 62,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(? bara 14 abar1)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 63,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"84"
|
|
]
|
|
},
|
|
"execution_count": 63,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(length (cmbn-list *))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 64,
|
|
"metadata": {
|
|
"collapsed": false
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"\n",
|
|
"----------------------------------------------------------------------{CMBN 12}\n",
|
|
"------------------------------------------------------------------------------\n"
|
|
]
|
|
},
|
|
"execution_count": 64,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"(? bara **)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"### Lisp files concerned in this chapter\n",
|
|
"\n",
|
|
"`simplicial-groups.lisp`, `k-pi-n.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": 0
|
|
}
|