mmarco/kenzo
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
a3362c6f0b
kenzo/doc/doc_src/smgrdoc.tex
Dima Pasechnik b288a64669 added doc sources (in old LaTeX)
2015-07-01 22:46:17 +01:00

787 lines
33 KiB
TeX
Raw Blame History

\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) ==>
<AbSm - (10 100)>
\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)) (<a-b> 0 3))) ==>
(<AbSm - (10 100)> <AbSm - (11 100)> <AbSm - (1 110)> <AbSm - (1 10)>)
(dotimes (i 4)
(check-kan k i 3 (remove (nth i hat) hat))) ==>
---done---
---done---
---done---
---done---
(setf hat1 (remove (nth 1 hat) hat)) ==>
(<AbSm - (10 100)> <AbSm - (1 110)> <AbSm - (1 10)>)
(kfll KZ1 1 3 hat1)
<AbSm - (1 10 100)>
\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)) ==>
<AbSm - (2 20 200)>
(setf invsimplex (grin KZ1 3 simplex)) ==>
<Absm - (-1 -10 -100)>
(grin KZ1 3 *) ==>
<Absm - (1 10 100)>
(grml KZ1 3 (crpr 0 simplex 0 (gmsm invsimplex)))) ==>
<AbSm 2-1-0 NIL>
(2absm-acrpr (absm 0 simplex ) (grin KZ1 3 simplex)) ==>
<AbSm - <CrPr - (1 10 100) - (-1 -10 -100)>>
(grml KZ1 3 *) ==>
<AbSm 2-1-0 NIL>
(setf KZ2 (k-z2-1)) ==>
[K22 Abelian-Simplicial-Group]
(grml KZ2 3 (crpr 0 3 0 3)) ==>
<AbSm 2-1-0 0>
(grin KZ2 4 4) ==>
<AbSm - 4>
(grml KZ2 4 (crpr 0 * 0 *)) ==>
<AbSm 3-2-1-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 ==>
(<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)>)
(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 *) ==>
(<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)>)
labsms2 ==>
(<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> <AbSm 1-0 2> <AbSm 1-0 3>)
(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 *) ==>
(<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> <AbSm 1-0 2> <AbSm 1-0 3>)
\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 --------> #<STANDARD-CLASS AB-SIMPLICIAL-GROUP>
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 ---------> #<Function K-Z-1-CMPR>
-->9 APRD ---------> The symbol :--UNBOUND--
10 CPRD ---------> [K14 Morphism (degree 0)]
11 FACE ---------> #<Function K-Z-1-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))) ==>
<TnPr (1 2) (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 --------> #<STANDARD-CLASS AB-SIMPLICIAL-GROUP>
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 ---------> #<Function K-Z-1-CMPR>
-->9 APRD ---------> [K35 Morphism (degree 0)]
10 CPRD ---------> [K14 Morphism (degree 0)]
11 FACE ---------> #<Function K-Z-1-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 * <TnPr 2 (1 2) 5 <TnPr 2 (2 3) 3 (4 5 6)>>>
------------------------------------------------------------------------------
\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))) ==>
<<Abar[3 (1 2)][3 (-1 -2)][3 (3 4)]>>
(funcall d-vert 9 abar0) ==>
----------------------------------------------------------------------{CMBN 8}
<-1 * <<Abar[2 (1)][3 (-1 -2)][3 (3 4)]>>>
<-1 * <<Abar[2 (2)][3 (-1 -2)][3 (3 4)]>>>
<1 * <<Abar[2 (3)][3 (-1 -2)][3 (3 4)]>>>
<1 * <<Abar[3 (1 2)][2 (-3)][3 (3 4)]>>>
<-1 * <<Abar[3 (1 2)][2 (-2)][3 (3 4)]>>>
<-1 * <<Abar[3 (1 2)][2 (-1)][3 (3 4)]>>>
<-1 * <<Abar[3 (1 2)][3 (-1 -2)][2 (3)]>>>
<-1 * <<Abar[3 (1 2)][3 (-1 -2)][2 (4)]>>>
<1 * <<Abar[3 (1 2)][3 (-1 -2)][2 (7)]>>>
------------------------------------------------------------------------------
(setf d-hrz (bar-intr-hrzn-dffr (aprd kz1)))
(funcall d-hrz 9 abar0) ==>
----------------------------------------------------------------------{CMBN 8}
<-1 * <<Abar[3 (1 2)][5 (-1 -2 3 4)]>>>
<1 * <<Abar[3 (1 2)][5 (-1 3 -2 4)]>>>
<-1 * <<Abar[3 (1 2)][5 (-1 3 4 -2)]>>>
<-1 * <<Abar[3 (1 2)][5 (3 -1 -2 4)]>>>
<1 * <<Abar[3 (1 2)][5 (3 -1 4 -2)]>>>
<-1 * <<Abar[3 (1 2)][5 (3 4 -1 -2)]>>>
<1 * <<Abar[5 (-1 -2 1 2)][3 (3 4)]>>>
<-1 * <<Abar[5 (-1 1 -2 2)][3 (3 4)]>>>
<1 * <<Abar[5 (-1 1 2 -2)][3 (3 4)]>>>
<1 * <<Abar[5 (1 -1 -2 2)][3 (3 4)]>>>
<-1 * <<Abar[5 (1 -1 2 -2)][3 (3 4)]>>>
<1 * <<Abar[5 (1 2 -1 -2)][3 (3 4)]>>>
------------------------------------------------------------------------------
\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 * <<Abar[3 (1 2)][5 (-1 -2 3 4)]>>>
<1 * <<Abar[3 (1 2)][5 (-1 3 -2 4)]>>>
<-1 * <<Abar[3 (1 2)][5 (-1 3 4 -2)]>>>
<-1 * <<Abar[3 (1 2)][5 (3 -1 -2 4)]>>>
<1 * <<Abar[3 (1 2)][5 (3 -1 4 -2)]>>>
<-1 * <<Abar[3 (1 2)][5 (3 4 -1 -2)]>>>
<1 * <<Abar[5 (-1 -2 1 2)][3 (3 4)]>>>
<-1 * <<Abar[5 (-1 1 -2 2)][3 (3 4)]>>>
<1 * <<Abar[5 (-1 1 2 -2)][3 (3 4)]>>>
<1 * <<Abar[5 (1 -1 -2 2)][3 (3 4)]>>>
<-1 * <<Abar[5 (1 -1 2 -2)][3 (3 4)]>>>
<1 * <<Abar[5 (1 2 -1 -2)][3 (3 4)]>>>
<-1 * <<Abar[2 (1)][3 (-1 -2)][3 (3 4)]>>>
<-1 * <<Abar[2 (2)][3 (-1 -2)][3 (3 4)]>>>
<1 * <<Abar[2 (3)][3 (-1 -2)][3 (3 4)]>>>
<1 * <<Abar[3 (1 2)][2 (-3)][3 (3 4)]>>>
<-1 * <<Abar[3 (1 2)][2 (-2)][3 (3 4)]>>>
<-1 * <<Abar[3 (1 2)][2 (-1)][3 (3 4)]>>>
<-1 * <<Abar[3 (1 2)][3 (-1 -2)][2 (3)]>>>
<-1 * <<Abar[3 (1 2)][3 (-1 -2)][2 (4)]>>>
<1 * <<Abar[3 (1 2)][3 (-1 -2)][2 (7)]>>>
------------------------------------------------------------------------------
(? bara *) ==>
----------------------------------------------------------------------{CMBN 7}
------------------------------------------------------------------------------
(setf abar1 (abar '(5 (7 11 4 -9) 4 (8 3 2) 5 (-1 -2 -3 -4)))) ==>
<<Abar[5 (7 11 4 -9)][4 (8 3 2)][5 (-1 -2 -3 -4)]>>
(? bara 14 abar1) ==>
----------------------------------------------------------------------{CMBN 13}
<-1 * <<Abar[5 (7 11 4 -9)][8 (-1 -2 -3 -4 8 3 2)]>>>
<1 * <<Abar[5 (7 11 4 -9)][8 (-1 -2 -3 8 -4 3 2)]>>>
<-1 * <<Abar[5 (7 11 4 -9)][8 (-1 -2 -3 8 3 -4 2)]>>>
<1 * <<Abar[5 (7 11 4 -9)][8 (-1 -2 -3 8 3 2 -4)]>>>
<-1 * <<Abar[5 (7 11 4 -9)][8 (-1 -2 8 -3 -4 3 2)]>>>
<1 * <<Abar[5 (7 11 4 -9)][8 (-1 -2 8 -3 3 -4 2)]>>>
<-1 * <<Abar[5 (7 11 4 -9)][8 (-1 -2 8 -3 3 2 -4)]>>>
<-1 * <<Abar[5 (7 11 4 -9)][8 (-1 -2 8 3 -3 -4 2)]>>>
<1 * <<Abar[5 (7 11 4 -9)][8 (-1 -2 8 3 -3 2 -4)]>>>
<-1 * <<Abar[5 (7 11 4 -9)][8 (-1 -2 8 3 2 -3 -4)]>>>
<1 * <<Abar[5 (7 11 4 -9)][8 (-1 8 -2 -3 -4 3 2)]>>>
<-1 * <<Abar[5 (7 11 4 -9)][8 (-1 8 -2 -3 3 -4 2)]>>>
<1 * <<Abar[5 (7 11 4 -9)][8 (-1 8 -2 -3 3 2 -4)]>>>
<1 * <<Abar[5 (7 11 4 -9)][8 (-1 8 -2 3 -3 -4 2)]>>>
<-1 * <<Abar[5 (7 11 4 -9)][8 (-1 8 -2 3 -3 2 -4)]>>>
<1 * <<Abar[5 (7 11 4 -9)][8 (-1 8 -2 3 2 -3 -4)]>>>
<-1 * <<Abar[5 (7 11 4 -9)][8 (-1 8 3 -2 -3 -4 2)]>>>
<1 * <<Abar[5 (7 11 4 -9)][8 (-1 8 3 -2 -3 2 -4)]>>>
<-1 * <<Abar[5 (7 11 4 -9)][8 (-1 8 3 -2 2 -3 -4)]>>>
<1 * <<Abar[5 (7 11 4 -9)][8 (-1 8 3 2 -2 -3 -4)]>>>
<-1 * <<Abar[5 (7 11 4 -9)][8 (8 -1 -2 -3 -4 3 2)]>>>
<1 * <<Abar[5 (7 11 4 -9)][8 (8 -1 -2 -3 3 -4 2)]>>>
<-1 * <<Abar[5 (7 11 4 -9)][8 (8 -1 -2 -3 3 2 -4)]>>>
<-1 * <<Abar[5 (7 11 4 -9)][8 (8 -1 -2 3 -3 -4 2)]>>>
<1 * <<Abar[5 (7 11 4 -9)][8 (8 -1 -2 3 -3 2 -4)]>>>
<-1 * <<Abar[5 (7 11 4 -9)][8 (8 -1 -2 3 2 -3 -4)]>>>
<1 * <<Abar[5 (7 11 4 -9)][8 (8 -1 3 -2 -3 -4 2)]>>>
<-1 * <<Abar[5 (7 11 4 -9)][8 (8 -1 3 -2 -3 2 -4)]>>>
<1 * <<Abar[5 (7 11 4 -9)][8 (8 -1 3 -2 2 -3 -4)]>>>
<-1 * <<Abar[5 (7 11 4 -9)][8 (8 -1 3 2 -2 -3 -4)]>>>
<-1 * <<Abar[5 (7 11 4 -9)][8 (8 3 -1 -2 -3 -4 2)]>>>
<1 * <<Abar[5 (7 11 4 -9)][8 (8 3 -1 -2 -3 2 -4)]>>>
<-1 * <<Abar[5 (7 11 4 -9)][8 (8 3 -1 -2 2 -3 -4)]>>>
<1 * <<Abar[5 (7 11 4 -9)][8 (8 3 -1 2 -2 -3 -4)]>>>
<-1 * <<Abar[5 (7 11 4 -9)][8 (8 3 2 -1 -2 -3 -4)]>>>
<-1 * <<Abar[8 (7 8 3 2 11 4 -9)][5 (-1 -2 -3 -4)]>>>
<1 * <<Abar[8 (7 8 3 11 2 4 -9)][5 (-1 -2 -3 -4)]>>>
<1 * <<Abar[8 (7 8 3 11 4 -9 2)][5 (-1 -2 -3 -4)]>>>
<-1 * <<Abar[8 (7 8 3 11 4 2 -9)][5 (-1 -2 -3 -4)]>>>
<-1 * <<Abar[8 (7 8 11 3 2 4 -9)][5 (-1 -2 -3 -4)]>>>
<-1 * <<Abar[8 (7 8 11 3 4 -9 2)][5 (-1 -2 -3 -4)]>>>
<1 * <<Abar[8 (7 8 11 3 4 2 -9)][5 (-1 -2 -3 -4)]>>>
<-1 * <<Abar[8 (7 8 11 4 -9 3 2)][5 (-1 -2 -3 -4)]>>>
<1 * <<Abar[8 (7 8 11 4 3 -9 2)][5 (-1 -2 -3 -4)]>>>
<-1 * <<Abar[8 (7 8 11 4 3 2 -9)][5 (-1 -2 -3 -4)]>>>
<1 * <<Abar[8 (7 11 4 -9 8 3 2)][5 (-1 -2 -3 -4)]>>>
<-1 * <<Abar[8 (7 11 4 8 -9 3 2)][5 (-1 -2 -3 -4)]>>>
<1 * <<Abar[8 (7 11 4 8 3 -9 2)][5 (-1 -2 -3 -4)]>>>
<-1 * <<Abar[8 (7 11 4 8 3 2 -9)][5 (-1 -2 -3 -4)]>>>
<1 * <<Abar[8 (7 11 8 3 2 4 -9)][5 (-1 -2 -3 -4)]>>>
<1 * <<Abar[8 (7 11 8 3 4 -9 2)][5 (-1 -2 -3 -4)]>>>
<-1 * <<Abar[8 (7 11 8 3 4 2 -9)][5 (-1 -2 -3 -4)]>>>
<1 * <<Abar[8 (7 11 8 4 -9 3 2)][5 (-1 -2 -3 -4)]>>>
<-1 * <<Abar[8 (7 11 8 4 3 -9 2)][5 (-1 -2 -3 -4)]>>>
<1 * <<Abar[8 (7 11 8 4 3 2 -9)][5 (-1 -2 -3 -4)]>>>
<1 * <<Abar[8 (8 3 2 7 11 4 -9)][5 (-1 -2 -3 -4)]>>>
<-1 * <<Abar[8 (8 3 7 2 11 4 -9)][5 (-1 -2 -3 -4)]>>>
<1 * <<Abar[8 (8 3 7 11 2 4 -9)][5 (-1 -2 -3 -4)]>>>
<1 * <<Abar[8 (8 3 7 11 4 -9 2)][5 (-1 -2 -3 -4)]>>>
<-1 * <<Abar[8 (8 3 7 11 4 2 -9)][5 (-1 -2 -3 -4)]>>>
<1 * <<Abar[8 (8 7 3 2 11 4 -9)][5 (-1 -2 -3 -4)]>>>
<-1 * <<Abar[8 (8 7 3 11 2 4 -9)][5 (-1 -2 -3 -4)]>>>
<-1 * <<Abar[8 (8 7 3 11 4 -9 2)][5 (-1 -2 -3 -4)]>>>
<1 * <<Abar[8 (8 7 3 11 4 2 -9)][5 (-1 -2 -3 -4)]>>>
<1 * <<Abar[8 (8 7 11 3 2 4 -9)][5 (-1 -2 -3 -4)]>>>
<1 * <<Abar[8 (8 7 11 3 4 -9 2)][5 (-1 -2 -3 -4)]>>>
<-1 * <<Abar[8 (8 7 11 3 4 2 -9)][5 (-1 -2 -3 -4)]>>>
<1 * <<Abar[8 (8 7 11 4 -9 3 2)][5 (-1 -2 -3 -4)]>>>
<-1 * <<Abar[8 (8 7 11 4 3 -9 2)][5 (-1 -2 -3 -4)]>>>
<1 * <<Abar[8 (8 7 11 4 3 2 -9)][5 (-1 -2 -3 -4)]>>>
<1 * <<Abar[4 (7 11 -5)][4 (8 3 2)][5 (-1 -2 -3 -4)]>>>
<-1 * <<Abar[4 (7 11 4)][4 (8 3 2)][5 (-1 -2 -3 -4)]>>>
<-1 * <<Abar[4 (7 15 -9)][4 (8 3 2)][5 (-1 -2 -3 -4)]>>>
<-1 * <<Abar[4 (11 4 -9)][4 (8 3 2)][5 (-1 -2 -3 -4)]>>>
<1 * <<Abar[4 (18 4 -9)][4 (8 3 2)][5 (-1 -2 -3 -4)]>>>
<-1 * <<Abar[5 (7 11 4 -9)][3 (3 2)][5 (-1 -2 -3 -4)]>>>
<1 * <<Abar[5 (7 11 4 -9)][3 (8 3)][5 (-1 -2 -3 -4)]>>>
<-1 * <<Abar[5 (7 11 4 -9)][3 (8 5)][5 (-1 -2 -3 -4)]>>>
<1 * <<Abar[5 (7 11 4 -9)][3 (11 2)][5 (-1 -2 -3 -4)]>>>
<-1 * <<Abar[5 (7 11 4 -9)][4 (8 3 2)][4 (-3 -3 -4)]>>>
<1 * <<Abar[5 (7 11 4 -9)][4 (8 3 2)][4 (-2 -3 -4)]>>>
<1 * <<Abar[5 (7 11 4 -9)][4 (8 3 2)][4 (-1 -5 -4)]>>>
<-1 * <<Abar[5 (7 11 4 -9)][4 (8 3 2)][4 (-1 -2 -7)]>>>
<1 * <<Abar[5 (7 11 4 -9)][4 (8 3 2)][4 (-1 -2 -3)]>>>
------------------------------------------------------------------------------
\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}].
Reference in New Issue View Git Blame Copy Permalink