\chapter {Simplicial Groups} \section {Representation of a simplicial group} A simplicial group\index{simplicial group} is an instance\index{class!{\tt SIMPLICIAL-GROUP}} of the class {\tt SIMPLICIAL-GROUP}, subclass of the classes {\tt KAN} and {\tt HOPF-ALGEBRA}. {\footnotesize\begin{verbatim} (DEFCLASS SIMPLICIAL-GROUP (kan hopf-algebra) ((grml :type simplicial-mrph :initarg :grml :reader grml1) (grin :type simplicial-mrph :initarg :grin :reader grin1))) \end{verbatim}} We recall that this new class (multi--) inherits from the following classes: {\tt KAN}, {\tt SIMPLICIAL-SET}, {\tt COALGEBRA}, {\tt ALGEBRA} and {\tt CHAIN-COMPLEX}. It has two slots of its own: \begin{description} \item {\tt grml}, an object of type {\tt 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. \item {\tt grin}, an object of type {\tt SIMPLICIAL-MRPH}, defining the inverse of an element of the Kan simplicial set w.r.t. the preceding group law. \end{description} A printing method has been associated to the class {\tt SIMPLICIAL GROUP} and the external representation of an instance is a string like {\tt [K{\em n} Simplicial-Group]}, where {\em n} is the number plate of the Kenzo object. \section {Representation of an Abelian simplicial group} The class of Abelian simplicial group, {\tt AB-SIMPLICIAL-GROUP}\index{class!{\tt SIMPLICIAL-GROUP}}, inherits all the properties of the class {\tt SIMPLICIAL-GROUP} and has not slots of its own, as shown by: {\footnotesize\begin{verbatim} (DEFCLASS AB-SIMPLICIAL-GROUP (simplicial-group) ()) \end{verbatim}} The difference is purely mathematical: it is up to the user to provide as slot {\em grml}, a simplicial morphism which is {\bf commutative}. As expected, the external representation of an instance of this class, is a string like {\tt [K{\em n} Abelian-Simplicial-Group]}, where {\em n} is the number plate of the Kenzo object. \section {The functions build-smgr and build-ab-smrg} To\index{function!{\tt build-smgr}} facilitate the construction of instances of the classes {\tt SIMPLICIAL-GROUP} and {\tt AB-SIMPLICIAL-GROUP} and to free the user to call the standard constructor {\tt make-instance}, the software provides the functions {\em build-smrg} and {\em build-ab-smrg}\index{function!{\tt build-ab-smgr}}. \vskip 0.35cm {\tt build-smgr}\par \hspace {0.60cm}{\tt :cmpr} {\em cmpr} {\tt basis} {\em basis} {\tt :bspn} {\em bspn} {\tt :face} {\em face} {\tt :face*} {\em face*} \par \hspace {0.60cm}{\tt :intr-bndr} {\em intr-bndr} {\tt :bndr-strt} {\em bndr-strt} {\tt :intr-dgnl} {\em intr-dgnl} \par \hspace {0.60cm}{\tt :dgnl-strt} {\em dgnl-strt} {\tt :sintr-grml} {\em sintr-grml} {\tt :sintr-grin} {\em sintr-grin} \par \hspace {0.60cm}{\tt :orgn} {\em orgn} \vskip 0.35cm defined with keyword parameters and returning an instance of the class {\tt SIMPLICIAL-GROUP}. The keyword arguments {\em cmpr}, {\em basis}, {\em bspn}, {\em face}, {\em face*}, {\em intr-bndr}, {\em bndr-strt}, {\em intr-dgnl} and {\em dgnl-strt} are the arguments provided to build the underlying simplicial set using the function {\tt build-smst}. Let us call it $S$. As usual, an adequate comment list must be provided for the parameter {\tt :orgn}. The only two new arguments are: \begin{itemize} \item[--] {\em sintr-grml}, a lisp function defining the group operation $S \times S \longrightarrow S$. The function {\tt 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 {\tt grml} of the simplicial group instance. \item[--] {\em sintr-grin}, a lisp function defining the inverse w.r.t the preceding group law of an element of $S$. The function {\tt 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 {\tt grin} of the simplicial group instance. \end{itemize} \vskip 0.30cm After a call to {\tt build-smgr}, the simplicial group instance is pushed onto the list of previously constructed ones ({\tt *smgr-list*}). The simplicial group with Kenzo identification $n$, may be retrieved in the {\tt *smgr-list*}, by a call to the function {\tt sgmr} as {\tt (sgmr {\em n})}. The list {\tt *smgr-list*} may be cleared by the function {\tt cat-init}. \vskip 0.30cm Up to now the slot {\tt 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 {\em slot-unbound} mecanism of CLOS enters in action and the filling function is defined by the system with the help of the functions {\tt face}, {\tt sintr-grml} and {\tt 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 {\tt smgr-kfll-intr}.\par For the user, the two simplicial morphisms, values of the specific slots of a {\tt SIMPLICIAL-GROUP} are applied via the two following macros: \vskip 0.30cm {\parindent=0mm {\leftskip=5mm {\tt grml} {\em smgr dmns crpr} \hfill {\em [Macro]} \par} {\leftskip=15mm Apply the simplicial morphism, value of the slot {\tt grml} of the simplicial group instance {\em smgr} to the cartesian product {\em crpr} in dimension {\em dmns}. Mathematically, this realizes the group operation. In principle, the simplicial morphism must accept the {\em crpr} argument on both forms: either a geometric cartesian product or an abstract simplex, the geometric part of which is a geometric cartesian pro\-duct (see the examples). With only one argument ({\em smgr}) the macro selects the simplicial morphism instance. \par} {\leftskip=5mm {\tt grin} {\em smgr dmns absm-or-gsm} \hfill {\em [Macro]} \par} {\leftskip=15mm Apply the simplicial morphism, value of the slot {\tt grin} of the simplicial group instance {\em smgr} to the element {\em absm-or-gsm} in dimension {\em dmns}. Mathematically this gives the inverse in the group of the e\-le\-ment. As suggested by the name of the parameter, this must work with geometric simplices as well as abstract simplices. With only one argument ({\em smgr}) the macro selects the simplicial morphism. \par} } \newpage {\tt build-ab-smgr}\par \hspace {0.60cm}{\tt :cmpr} {\em cmpr} {\tt basis} {\em basis} {\tt :bspn} {\em bspn} {\tt :face} {\em face} {\tt :face*} {\em face*} \par \hspace {0.60cm}{\tt :intr-bndr} {\em intr-bndr} {\tt :bndr-strt} {\em bndr-strt} {\tt :intr-dgnl} {\em intr-dgnl} \par \hspace {0.60cm}{\tt :dgnl-strt} {\em dgnl-strt} {\tt :sintr-grml} {\em sintr-grml} {\tt :sintr-grin} {\em sintr-grin} \par \hspace {0.60cm}{\tt :orgn} {\em orgn} \vskip 0.35cm 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 {\em sintr-grml}), must be commutative. The lisp definition of {\tt build-ab-smgr} is simply: {\footnotesize\begin{verbatim} (DEFMACRO BUILD-AB-SMGR (&rest rest) `(change-class (build-smgr ,@rest) 'ab-simplicial-group)) \end{verbatim}} \section {Two important Abelian simplicial groups: $K({\Z}, 1)$ and $K({\Z}_2, 1)$} 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 {\em bar objects} being conventionally represented as sequences of elements of $\cal G$: $$ [g_1 \mid g_2 \mid \ldots \mid g_n]. $$ The base point is the void bar object $[\ ]$. Let us note the group law multiplicatively. \par The face operators are defined as follows: \begin{eqnarray*} \partial_0 [g_1 \mid g_2 \mid \ldots \mid g_n] & = & [g_2 \mid g_3 \mid \ldots \mid g_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], \\ \partial_2 [g_1 \mid g_2 \mid \ldots \mid g_n] & = & [g_1 \mid {\bf g_2g_3} \mid \ldots \mid g_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}], \\ \partial_n [g_1 \mid g_2 \mid \ldots \mid g_n] & = & [g_1 \mid g_2 \mid \ldots \mid g_{n-1}]. \end{eqnarray*} The degeneracy operators are defined as follows: $$ \eta_i [g_1 \mid \ldots \mid g_{i-1} \mid g_i \mid g_{i+1} \mid \ldots \mid g_n] = [g_1 \mid \ldots \mid g_{i-1} \mid g_i \mid {\bf e} \mid g_{i+1} \mid \ldots \mid g_n],$$ where $e$ is the neutral element of $\cal G$. \par If, in addition $\cal G$ is abelian, then $K({\cal G}, 1)$ is itself a {\em simplicial group}, with the following group law, in dimension $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], $$ $$[a_1 \mid \cdots \mid a_n]^{-1}= [-a_1 \mid \cdots \mid -a_n],\quad a,b \in {\cal G}$$ 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)$. \par The two important simplicial groups $K({\Z}, 1)$ and $K({\Z}_2, 1)$ may be cons\-truc\-ted in {\tt Kenzo}. \vskip 0.30cm {\parindent=0mm {\leftskip=5mm {\tt k-z-1} \hfill {\em [Function]} \par} {\leftskip=15mm Build\index{$K({\Z}, 1)$} the simplicial group $K({\Z},1)$. In this simplicial group, a simplex in dimension $n$ is mathematically represented by a sequence of integers, known as a {\em bar} object: $$ [a_1 \mid a_2 \mid \ldots \mid a_n]. $$ The group operation inherits the additive law of $\Z$: $$[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]$$ and the inverse of $[a_1 \mid \ldots \mid a_n]$ is $[-a_1 \mid \ldots \mid -a_n]. $ In {\tt Kenzo}, a non-degenerate simplex of $K({\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 {\tt NIL}, i.e the void bar object $[\ ]$. To be coeherent with the general policy of {\tt Kenzo}, a degenerate simplex must be represented by an abstract simplex of the form {\tt (:absm {\em dgop} . {\em gmsm})} where {\em 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 $0$, is more natural and more convenient. Consequently, two conversion functions are provided (see below). \par} {\leftskip=5mm {\tt k-z2-1} \hfill {\em [Function]} \par} {\leftskip=15mm Build\index{$K({\Z}_2, 1)$} the simplicial group $K({\Z}_2,1)$. Mathematically, in dimension $n$, the only non-degenerate simplex is a sequence of $n$ $1$'s. But one may show that as simplicial set, $K({\Z}_2,1)$ is isomorphic to $P^\infty {\R}$ which may be built by the statement {\tt (R-proj-space)}. This is the representation adopted in {\tt Kenzo}. In dimension $n$, this simplicial set has only one non-degenerate simplex, namely the integer $n$. The formulas for the faces of this non-degenerate simplex $n$ collapse to: \begin{eqnarray*} \partial_0 n & = & n-1, \\ \partial_i n & = & \eta_{i-1} (n-2), \quad i \not= 0, i \not=n, \\ \partial_n n & = & n-1. \end{eqnarray*} 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({\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 provided. \par} {\leftskip=5mm {\tt z-bar-absm} {\em bar} \hfill {\em [Function]} \par} {\leftskip=15mm Transform a general mathematical bar object {\em bar} of $K({\Z}, 1)$, represented by a list of integers (including $0$'s), into a valid abstract simplex (an object of type {\tt ABSM}), {\tt (:absm {\em dgop} . {\em gmsm})}, where {\em gmsm} is a sequence of non-null integers representing a non-de\-ge\-ne\-ra\-te bar object of $K({\Z},1)$ and {\em dgop} a coded sequence of degeneracy operators $\eta_i$'s. \par} {\leftskip=5mm {\tt z-absm-bar} {\em absm} \hfill {\em [Function]} \par} {\leftskip=15mm Transform the abstract simplex {\em absm}, {\tt (:absm {\em dgop} . {\em gmsm})}, where {\em gmsm} is a sequence of non-null integers representing a nondegenerate bar object of $K({\Z},1)$ and {\em dgop} a coded sequence of degeneracy operators, into a list of integers representing a bar object, degenerate or not, of $K({\Z},1)$, for more convenience in the internal computations or for more clarity in external printing. \par} {\leftskip=5mm {\tt z2-bar-absm} {\em bar} \hfill {\em [Function]} \par} {\leftskip=15mm Function analogous to {\tt z-bar-absm} but for $K({\Z}_2, 1)$. \par} {\leftskip=5mm {\tt z2-absm-bar} {\em absm} \hfill {\em [Function]} \par} {\leftskip=15mm Function analogous to {\tt z-absm-bar} but for $K({\Z}_2, 1)$. \par} } \subsection* {Examples} {\footnotesize\begin{verbatim} (setf KZ1 (k-z-1)) ==> [K10 Abelian-Simplicial-Group] (setf simplex '(1 10 100)) ==> (1 10 100) (face KZ1 0 3 simplex) ==> \end{verbatim}} 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 hat (we recall that the lisp function {\tt remove}, works on a copy of the list, i.e. the argument {\tt hat} is not modified). In the forth statement, we verify the property of minimality of this special simplicial group. {\footnotesize\begin{verbatim} (setf hat (mapcar #'(lambda (i) (face KZ1 i 3 simplex)) ( 0 3))) ==> ( ) (dotimes (i 4) (check-kan k i 3 (remove (nth i hat) hat))) ==> ---done--- ---done--- ---done--- ---done--- (setf hat1 (remove (nth 1 hat) hat)) ==> ( ) (kfll KZ1 1 3 hat1) \end{verbatim}} We test now the two macros {\tt grml} and {\tt grin} related to the group operation. {\footnotesize\begin{verbatim} (grml KZ1 3 (crpr 0 simplex 0 simplex)) ==> (setf invsimplex (grin KZ1 3 simplex)) ==> (grin KZ1 3 *) ==> (grml KZ1 3 (crpr 0 simplex 0 (gmsm invsimplex)))) ==> (2absm-acrpr (absm 0 simplex ) (grin KZ1 3 simplex)) ==> > (grml KZ1 3 *) ==> (setf KZ2 (k-z2-1)) ==> [K22 Abelian-Simplicial-Group] (grml KZ2 3 (crpr 0 3 0 3)) ==> (grin KZ2 4 4) ==> (grml KZ2 4 (crpr 0 * 0 *)) ==> \end{verbatim}} Let us show some examples of conversions, between general bar objects and valid abstract simplices: {\footnotesize\begin{verbatim} (z-absm-bar (absm 0 '())) ==> NIL (z-absm-bar (absm 1 '())) ==> (0) (z-absm-bar (absm 0 '(2))) ==> (2) (z2-absm-bar (absm 7 7)) ==> (0 0 0 1 1 1 1 1 1 1) (z2-absm-bar (absm 0 7)) ==> (1 1 1 1 1 1 1) \end{verbatim}} Let us suppose that the value of the symbol {\tt labsms} is a list of abstract simplices built from the simplex {\tt (3 6))} in dimension $1$ of $K({\Z}, 1)$. The application of the function {\tt z-absm-bar} on this list gives the representation of the simplices under the classical mathematical representation. Applying then {\tt z-bar-absm} returns the original list. A similar example is given with the symbol {\tt labsm2} in dimension $0$. {\footnotesize\begin{verbatim} labsms ==> ( ) (mapcar #'z-absm-bar labsms) ==> ((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)) (mapcar #'z-bar-absm *) ==> ( ) labsms2 ==> ( ) (mapcar #'z2-absm-bar labsms2) ==> (NIL (1) (1 1) (1 1 1) (0) (0 1) (0 1 1) (0 1 1 1) (0 0) (0 0 1) (0 0 1 1) (0 0 1 1 1)) (mapcar #'z2-bar-absm *) ==> ( ) \end{verbatim}} \newpage \section{Simplicial Groups as Algebras} If we consider a simplicial group ${\cal G}$, with group operation $\tau$, there is a ca\-no\-ni\-cal product for the algebra $$\varpi : C_*({\cal G}) \otimes C_*({\cal G}) \longrightarrow C_*({\cal G}), $$ defined as the composition $\tau \circ {\cal EML}$, where ${\cal EML}$ is the Eilenberg-Mac Lane homomorphism\index{homomorphism!Eilenberg-Mac Lane} or the {\em shuffle homomorphism} (see the Eilenberg-Zilber chapter): $$C_*({\cal G}) \otimes C_*({\cal G}) \buildrel {{\cal EML}} \over \longrightarrow C_*({\cal G} \times {\cal G}) \buildrel {\tau} \over \longrightarrow C_*({\cal G}). $$ For instance let us look at the simplicial group $K({\Z}, 1)$: {\footnotesize\begin{verbatim} (setf kz1 (k-z-1)) ==> [K10 Abelian-Simplicial-Group] (inspect kz1) ==> AB-SIMPLICIAL-GROUP @ #x38c902 = [K10 Abelian-Simplicial-Group] 0 Class --------> # 1 ORGN ---------> (K-Z-1), a proper list with 1 element 2 IDNM ---------> fixnum 10 [#x00000028] 3 EFHM ---------> The symbol :--UNBOUND-- 4 GRMD ---------> [K10 Abelian-Simplicial-Group] 5 DFFR ---------> [K11 Morphism (degree -1)] 6 BSGN ---------> The symbol NIL 7 BASIS --------> The symbol :LOCALLY-EFFECTIVE 8 CMPR ---------> # -->9 APRD ---------> The symbol :--UNBOUND-- 10 CPRD ---------> [K14 Morphism (degree 0)] 11 FACE ---------> # 12 KFLL ---------> The symbol :--UNBOUND-- 13 GRIN ---------> [K21 Simplicial-Morphism] 14 GRML ---------> [K20 Simplicial-Morphism] \end{verbatim}} We see that the slot {\tt 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 {\em slot-unbound} mecanism of CLOS enters in action, the canonical algebra product morphism is defined by the system, and the slot {\tt aprd} is set.\par For instance, let us take the tensor product of two elements of $K({\Z}, 1)$ and apply the product in the algebra: {\footnotesize\begin{verbatim} (setf tnsrp (tnpr 2 '(1 2) 3 '(7 8 9))) ==> (aprd kz1 5 tnsrp) ==> ----------------------------------------------------------------------{CMBN 5} <1 * (1 2 7 8 9)> <-1 * (1 7 2 8 9)> <1 * (1 7 8 2 9)> <-1 * (1 7 8 9 2)> <1 * (7 1 2 8 9)> <-1 * (7 1 8 2 9)> <1 * (7 1 8 9 2)> <1 * (7 8 1 2 9)> <-1 * (7 8 1 9 2)> <1 * (7 8 9 1 2)> ------------------------------------------------------------------------------ \end{verbatim}} The system {\tt Kenzo} has automatically created the needed algebra product morphism and this is shown in the slot instance {\tt aprd}: {\footnotesize\begin{verbatim} (inspect kz1) ==> AB-SIMPLICIAL-GROUP @ #x419422 = [K10 Abelian-Simplicial-Group] 0 Class --------> # 1 ORGN ---------> (K-Z-1), a proper list with 1 element 2 IDNM ---------> fixnum 10 [#x00000028] 3 EFHM ---------> The symbol :--UNBOUND-- 4 GRMD ---------> [K10 Abelian-Simplicial-Group] 5 DFFR ---------> [K11 Morphism (degree -1)] 6 BSGN ---------> The symbol NIL 7 BASIS --------> The symbol :LOCALLY-EFFECTIVE 8 CMPR ---------> # -->9 APRD ---------> [K35 Morphism (degree 0)] 10 CPRD ---------> [K14 Morphism (degree 0)] 11 FACE ---------> # 12 KFLL ---------> The symbol :--UNBOUND-- 13 GRIN ---------> [K21 Simplicial-Morphism] 14 GRML ---------> [K20 Simplicial-Morphism] \end{verbatim}} An interesting example is to show the associativity of the canonical product of an algebra, by defining in {\tt 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 {\em assoc}, the morphism $$assoc: ({\cal A}\otimes {\cal A}) \otimes {\cal A} \longrightarrow {\cal A} \otimes ({\cal A}\otimes {\cal A}),$$ with: $$assoc((a\otimes b)\otimes c) = a \otimes (b \otimes c).$$ $$\diagram{ & ({\cal A}\otimes {\cal A}) \otimes {\cal A} & \buildrel {assoc} \over \longrightarrow & {\cal A} \otimes ({\cal A}\otimes {\cal A}) \cr & {\scriptstyle \nabla \otimes 1}\downarrow & & \downarrow {\scriptstyle 1 \otimes \nabla} \cr & {\cal A}\otimes {\cal A} & & {\cal A}\otimes {\cal A} \cr & {\scriptstyle \nabla}\searrow & & \swarrow {\scriptstyle \nabla} \cr & & {\cal A} & \cr }$$ Let us define two chain complexes with the two ways to compose two tensorial products: {\footnotesize\begin{verbatim} (setf kz1 (k-z-1)) ==> [K10 Abelian-Simplicial-Group] (setf 3-left (tnsr-prdc (tnsr-prdc kz1 kz1) kz1)) ==> [K13 Chain-Complex] (setf 3-right (tnsr-prdc kz1 (tnsr-prdc kz1 kz1))) ==> [K15 Chain Complex] \end{verbatim}} Then we define the morphism {\tt assoc} and test it: {\footnotesize\begin{verbatim} (setf assoc (build-mrph :sorc 3-left :trgt 3-right :degr 0 :intr #'(lambda (degr a2-a) (with-tnpr (degra2 gnrta2 degra gnrta) a2-a (with-tnpr (degr1 gnrt1 degr2 gnrt2) gnrta2 (cmbn (+ degr1 degr2 degra) 1 (tnpr degr1 gnrt1 (+ degr2 degra) (tnpr degr2 gnrt2 degra gnrta)))))) :strt :gnrt :orgn '(assoc-double-tensor-product))) ==> [K17 Morphism (degree 0)] (setf *tnpr-with-degrees* t) ==> T (? assoc 7 (tnpr 4 (tnpr 2 '(1 2) 2 '(2 3)) 3 '(4 5 6))) ==> ----------------------------------------------------------------------{CMBN 7} <1 * >> ------------------------------------------------------------------------------ \end{verbatim}} We define now the other morphisms shown in the diagram: {\footnotesize\begin{verbatim} (setf nabla (aprd kz1)) ==> [K35 Morphism (degree 0)] (setf idnt (idnt-mrph kz1) ==> [K36 Morphism (degree 0)] (setf 1-t-nabla (tnsr-prdc idnt nabla)) ==> [K39 Morphism (degree 0)] (setf nabla-t-1 (tnsr-prdc nabla idnt)) ==> [K42 Morphism (degree 0)] \end{verbatim}} Now, if the diagram is commutative, the difference morphism, noted {\tt zero}, between the following morphisms {\tt right} and {\tt left}, must give the null combination if applied to an element of $(K({\Z}, 1) \otimes K({\Z}, 1)) \otimes K({\Z}, 1).$ {\footnotesize\begin{verbatim} (setf left (cmps nabla nabla-t-1)) ==> [K43 Morphism (degree 0)] (setf right (i-cmps nabla 1-t-nabla assoc)) ==> [K45 Morphism (degree 0)] \end{verbatim}} \newpage {\footnotesize\begin{verbatim} (setf zero (sbtr left right)) ==> [K46 Morphism (degree 0)] (? zero 7 (tnpr 4 (tnpr 2 '(1 2) 2 '(2 3)) 3 '(4 5 6))) ==> ----------------------------------------------------------------------{CMBN 7} ------------------------------------------------------------------------------ (? zero 9 (tnpr 7 (tnpr 3 '(2 3 4) 4 '(5 6 7 8)) 2 '(11 12))) ----------------------------------------------------------------------{CMBN 9} ------------------------------------------------------------------------------ \end{verbatim}} The resulting combination of the rather simple double tensor product has yet 140 terms: {\footnotesize\begin{verbatim} (? right 7 (tnpr 4 (tnpr 2 '(1 2) 2 '(2 3)) 3 '(4 5 6))) ==> ----------------------------------------------------------------------{CMBN 7} <1 * (1 2 3 2 4 5 6)> <-1 * (1 2 3 4 2 5 6)> <1 * (1 2 3 4 5 2 6)> <-1 * (1 2 3 4 5 6 2)> <1 * (1 2 4 3 2 5 6)> <-1 * (1 2 4 3 5 2 6)> <1 * (1 2 4 3 5 6 2)> <1 * (1 2 4 5 3 2 6)> <-1 * (1 2 4 5 3 6 2)> <1 * (1 2 4 5 6 3 2)> <-1 * (1 4 2 3 2 5 6)> <1 * (1 4 2 3 5 2 6)> <-1 * (1 4 2 3 5 6 2)> <-1 * (1 4 2 5 3 2 6)> ... ... ... ... ------------------------------------------------------------------------------ (length (cmbn-list *)) ==> 140 \end{verbatim}} \newpage \section {Coming back to the Bar of an algebra} The\index{bar!of an algebra} 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({\Z}, 1).$ We begin to test separately the vertical and the horizontal differential. {\footnotesize\begin{verbatim} (setf kz1 (k-z-1)) ==> [K10 Abelian-Simplicial-Group] (setf d-vert (bar-intr-vrtc-dffr (dffr kz1))) (funcall d-vert 0 (abar)) ----------------------------------------------------------------------{CMBN -1} ------------------------------------------------------------------------------ (setf abar0 (abar 3 '(1 2) 3 '(-1 -2) 3 '(3 4))) ==> <> (funcall d-vert 9 abar0) ==> ----------------------------------------------------------------------{CMBN 8} <-1 * <>> <-1 * <>> <1 * <>> <1 * <>> <-1 * <>> <-1 * <>> <-1 * <>> <-1 * <>> <1 * <>> ------------------------------------------------------------------------------ (setf d-hrz (bar-intr-hrzn-dffr (aprd kz1))) (funcall d-hrz 9 abar0) ==> ----------------------------------------------------------------------{CMBN 8} <-1 * <>> <1 * <>> <-1 * <>> <-1 * <>> <1 * <>> <-1 * <>> <1 * <>> <-1 * <>> <1 * <>> <1 * <>> <-1 * <>> <1 * <>> ------------------------------------------------------------------------------ \end{verbatim}} We may now construct the bar chain complex of the algebra {\tt kz1} and test the differential, sum of both previous ones: {\footnotesize\begin{verbatim} (setf bara (bar kz1)) ==> [K18 Chain-Complex] (? bara 9 abar0) ----------------------------------------------------------------------{CMBN 8} <-1 * <>> <1 * <>> <-1 * <>> <-1 * <>> <1 * <>> <-1 * <>> <1 * <>> <-1 * <>> <1 * <>> <1 * <>> <-1 * <>> <1 * <>> <-1 * <>> <-1 * <>> <1 * <>> <1 * <>> <-1 * <>> <-1 * <>> <-1 * <>> <-1 * <>> <1 * <>> ------------------------------------------------------------------------------ (? bara *) ==> ----------------------------------------------------------------------{CMBN 7} ------------------------------------------------------------------------------ (setf abar1 (abar '(5 (7 11 4 -9) 4 (8 3 2) 5 (-1 -2 -3 -4)))) ==> <> (? bara 14 abar1) ==> ----------------------------------------------------------------------{CMBN 13} <-1 * <>> <1 * <>> <-1 * <>> <1 * <>> <-1 * <>> <1 * <>> <-1 * <>> <-1 * <>> <1 * <>> <-1 * <>> <1 * <>> <-1 * <>> <1 * <>> <1 * <>> <-1 * <>> <1 * <>> <-1 * <>> <1 * <>> <-1 * <>> <1 * <>> <-1 * <>> <1 * <>> <-1 * <>> <-1 * <>> <1 * <>> <-1 * <>> <1 * <>> <-1 * <>> <1 * <>> <-1 * <>> <-1 * <>> <1 * <>> <-1 * <>> <1 * <>> <-1 * <>> <-1 * <>> <1 * <>> <1 * <>> <-1 * <>> <-1 * <>> <-1 * <>> <1 * <>> <-1 * <>> <1 * <>> <-1 * <>> <1 * <>> <-1 * <>> <1 * <>> <-1 * <>> <1 * <>> <1 * <>> <-1 * <>> <1 * <>> <-1 * <>> <1 * <>> <1 * <>> <-1 * <>> <1 * <>> <1 * <>> <-1 * <>> <1 * <>> <-1 * <>> <-1 * <>> <1 * <>> <1 * <>> <1 * <>> <-1 * <>> <1 * <>> <-1 * <>> <1 * <>> <1 * <>> <-1 * <>> <-1 * <>> <-1 * <>> <1 * <>> <-1 * <>> <1 * <>> <-1 * <>> <1 * <>> <-1 * <>> <1 * <>> <1 * <>> <-1 * <>> <1 * <>> ------------------------------------------------------------------------------ \end{verbatim}} \newpage {\footnotesize\begin{verbatim} (? bara *) ==> ----------------------------------------------------------------------{CMBN 12} ------------------------------------------------------------------------------ \end{verbatim}} \subsection* {Lisp files concerned in this chapter} {\tt simplicial-groups.lisp}, {\tt k-pi-n.lisp}. \par [{\tt classes.lisp }, {\tt macros.lisp}, {\tt various.lisp}].