363 lines
13 KiB
TeX
363 lines
13 KiB
TeX
\chapter{Tensor product of chain complexes}
|
|
|
|
\section{Introduction}
|
|
|
|
One knows that the homology groups of a cartesian product of two spaces
|
|
$K$ and $L$ may be obtained by considering a chain complex derived from
|
|
respective chain complexes of $K$ and $L$ by taking their {\em tensor product}.
|
|
But this is only one of the numerous uses of tensor products of chain complexes
|
|
in algebraic topology, so the {\tt Kenzo} software provides the handling of such
|
|
an important tool.
|
|
\par
|
|
Let us recall that chain complexes are free $\Z$--modules with distinguished basis.
|
|
A tensor product\index{tensor product!of chain complexes} of chain complexes
|
|
is itself a free $\Z$--module with a natural basis
|
|
formed by the tensor product of the generators of the chain complex factors.
|
|
The program conforms to that rule.
|
|
|
|
\section{Tensor product of generators and combinations}
|
|
|
|
An elementary tensor product\index{tensor product!of generators}
|
|
of two generators is represented, in the software,
|
|
by a structured list in which we may find $4$ items for the description of the two generators
|
|
together with their respective degree. The internal representation of $gnrt1 \otimes gnrt2$ has
|
|
the form:
|
|
\begin{center}
|
|
{\tt (:tnpr ({\em degr1}.{\em gnrt1}).({\em degr2}.{\em gnrt2}))}
|
|
\end{center}
|
|
where,
|
|
\begin{enumerate}
|
|
\item {\em degr1} is an integer, the degree of the generator {\em gnrt1}.
|
|
\item {\em gnrt1} is the first generator of the pair.
|
|
\item {\em degr2} is an integer, the degree of the generator {\em gnrt2}.
|
|
\item {\em gnrt2} is the second generator of the pair.
|
|
\end{enumerate}
|
|
To construct such an object, one may use the macro {\tt tnpr}. The cor\-res\-pon\-ding type is {\tt TNPR}.
|
|
The printing method prints the tensor product under the form:
|
|
\begin{center}
|
|
{\tt <TnPr {\em gnrt1 gnrt2}>} or {\tt <TnPr {\em degr1 gnrt1 degr2 gnrt2}>}
|
|
\end{center}
|
|
according to the boolean value, {\tt NIL} (default) or {\tt T} of the system variable
|
|
{\tt *tnpr-with-degrees*} (see the examples).
|
|
|
|
\subsection {Simple functions for the tensor product}
|
|
|
|
{\parindent=0mm
|
|
{\leftskip=5mm
|
|
{\tt tnpr} {\em degr1 gnrt1 degr2 gnrt2} \hfill {\em [Macro]} \par}
|
|
{\leftskip=15mm
|
|
Build a tensor product $gnrt1 \otimes gnrt2$. \par}
|
|
{\leftskip=5mm
|
|
{\tt tnpr-p} {\em object} \hfill {\em [Predicate]} \par}
|
|
{\leftskip=15mm
|
|
Test if {\em object} is of type {\tt TNPR}. \par}
|
|
{\leftskip=5mm
|
|
{\tt degr1} {\em tnpr} \hfill {\em [Macro]} \par}
|
|
{\leftskip=15mm
|
|
Select the degree of the first generator in the tensor product {\em tnpr}. \par}
|
|
{\leftskip=5mm
|
|
{\tt gnrt1} {\em tnpr} \hfill {\em [Macro]} \par}
|
|
{\leftskip=15mm
|
|
Select the first generator from the object {\em tnpr}. \par}
|
|
{\leftskip=5mm
|
|
{\tt degr2} {\em tnpr} \hfill {\em [Macro]} \par}
|
|
{\leftskip=15mm
|
|
Select the degree of the second generator in the tensor product {\em tnpr}. \par}
|
|
{\leftskip=5mm
|
|
{\tt gnrt2} {\em tnpr} \hfill {\em [Macro]} \par}
|
|
{\leftskip=15mm
|
|
Select the second generator from the object {\em tnpr}. \par}
|
|
{\leftskip=5mm
|
|
{\tt 2cmbn-tnpr} {\em cmbn1 cmbn2} \hfill {\em [Function]} \par}
|
|
{\leftskip=15mm
|
|
Create, from two combinations {\em cmbn1} and {\em cmbn2} with respective degree {\em degr1} and {\em degr2},
|
|
a combination of degree $dgr1 + dgr2$ by applying the tensorial distributive law on the two sums of terms
|
|
of the combinations. \par}
|
|
}
|
|
|
|
\subsection* {Example}
|
|
|
|
{\footnotesize\begin{verbatim}
|
|
(tnpr 1 'a 2 'b) ==>
|
|
|
|
<TnPr A B>
|
|
|
|
(tnpr-p *) ==>
|
|
|
|
T
|
|
|
|
(tnpr-p (cmbn 0 1 'a 2 'b)) ==>
|
|
|
|
NIL
|
|
|
|
(setf *tnpr-with-degrees* t) ==>
|
|
|
|
T
|
|
|
|
(2cmbn-tnpr (cmbn 2 3 'a 4 'b -5 'c) (cmbn 3 4 'x -3 'y 2 'z)) ==>
|
|
|
|
----------------------------------------------------------------------{CMBN 5}
|
|
<12 * <TnPr 2 A 3 X>>
|
|
<-9 * <TnPr 2 A 3 Y>>
|
|
<6 * <TnPr 2 A 3 Z>>
|
|
<16 * <TnPr 2 B 3 X>>
|
|
<-12 * <TnPr 2 B 3 Y>>
|
|
<8 * <TnPr 2 B 3 Z>>
|
|
<-20 * <TnPr 2 C 3 X>>
|
|
<15 * <TnPr 2 C 3 Y>>
|
|
<-10 * <TnPr 2 C 3 Z>>
|
|
------------------------------------------------------------------------------
|
|
|
|
(setf *tnpr-with-degrees* nil) ==>
|
|
|
|
NIL
|
|
|
|
** ==> ;;; ** is the last but one result
|
|
----------------------------------------------------------------------{CMBN 5}
|
|
<12 * <TnPr A X>>
|
|
<-9 * <TnPr A Y>>
|
|
<6 * <TnPr A Z>>
|
|
<16 * <TnPr B X>>
|
|
<-12 * <TnPr B Y>>
|
|
<8 * <TnPr B Z>>
|
|
<-20 * <TnPr C X>>
|
|
<15 * <TnPr C Y>>
|
|
<-10 * <TnPr C Z>>
|
|
------------------------------------------------------------------------------
|
|
\end{verbatim}}
|
|
\newpage
|
|
|
|
\section{Tensor product of chain complexes}
|
|
|
|
The\index{tensor product!of chain complexes} software implements the tensor product of chain complexes according to
|
|
the classical following definition. Let $C$ and $C'$ two chain complexes. The
|
|
tensor product $C\otimes C'$ is the chain complex $D$ such that:
|
|
$$ D_p=\bigoplus_{m+n=p}C_m\otimes C_n',$$
|
|
$C_m\otimes C_n'$ being the tensor product of the two modules $C_m$ and $C_n'$.
|
|
A basis for $D_p$ is the union of the basis of $C_m\otimes C_n'$, with $m+n=p$.
|
|
\par
|
|
The boundary operator $d^{\otimes}$ is defined, according to the Koszul rule, by:
|
|
$$d^{\otimes}(c_m\otimes c_n')=d(c_m)\otimes c_n' +(-1)^m c_m\otimes d'(c_n'),$$
|
|
with $c_m\in C_m,\ c_n'\in C_n'$ and $d$, $d'$ being the respective boundary operators
|
|
of $C$ and $C'$.
|
|
\par
|
|
In the software, this is realized by the function {\tt tnsr-prdc}.
|
|
\vskip 0.40cm
|
|
{\parindent=0mm
|
|
{\leftskip=5mm
|
|
{\tt tnsr-prdc} {\em chcm1 chcm2} \hfill {\em [Method]} \par}
|
|
{\leftskip=15mm
|
|
Build a chain complex, tensor product of the two chain complexes {\em chcm1} and {\em chcm2}. The elements
|
|
of this new chain complex are integer combinations of generators of {\tt TNPR} type. The creation of this
|
|
new chain complex is done
|
|
by a call to the function {\tt build-chcm} with actual parameters
|
|
defined from the constituting elements of {\em chcm1} and {\em chcm2}, according to the
|
|
mathematical definitions above. If both arguments are {\em effective}, the function
|
|
constructs an {\em effective} chain complex. On the other hand, if at least one of the chain complex
|
|
is {\em locally effective}, the tensor product is also {\em locally effective}. In fact, the construction
|
|
is correct only if both chain complexes are null in negative degrees, otherwise the result
|
|
is undefined.
|
|
\par}}
|
|
|
|
\subsection* {Examples}
|
|
|
|
Let us take the standard $2$--simplex, $\Delta^2$ and let us build $C_*(\Delta^2) \otimes C_*(\Delta^2)$. To build
|
|
the corresponding chain complex, we use the function {\tt cdelta}, defined in a previous chapter.
|
|
{\footnotesize\begin{verbatim}
|
|
(setf triangle (cdelta 2)) ==>
|
|
|
|
[K1 Chain-Complex]
|
|
|
|
(basis triangle 1) ==>
|
|
|
|
((0 1) (0 2) (1 2))
|
|
|
|
(setf tpr-triangles (tnsr-prdc triangle triangle)) ==>
|
|
|
|
[K3 Chain-Complex]
|
|
\end{verbatim}}
|
|
Let us inspect some basis of this newly created chain complex.
|
|
{\footnotesize\begin{verbatim}
|
|
(basis tpr-triangles 0) ==>
|
|
|
|
(<TnPr (0) (0)> <TnPr (0) (1)> <TnPr (0) (2)> <TnPr (1) (0)> <TnPr (1) (1)>
|
|
<TnPr (1) (2)> <TnPr (2) (0)> <TnPr (2) (1)> <TnPr (2) (2)>)
|
|
|
|
(basis tpr-triangles 1) ==>
|
|
|
|
(<TnPr (0) (0 1)> <TnPr (0) (0 2)> <TnPr (0) (1 2)> <TnPr (1) (0 1)>
|
|
<TnPr (1) (0 2)> <TnPr (1) (1 2)> <TnPr (2) (0 1)> <TnPr (2) (0 2)>
|
|
<TnPr (2) (1 2)> <TnPr (0 1) (0)> <TnPr (0 1) (1)> <TnPr (0 1) (2)>
|
|
<TnPr (0 2) (0)> <TnPr (0 2) (1)> <TnPr (0 2) (2)> <TnPr (1 2) (0)>
|
|
<TnPr (1 2) (1)> <TnPr (1 2) (2)>)
|
|
|
|
(basis tpr-triangles 2) ==>
|
|
|
|
(<TnPr (0) (0 1 2)> <TnPr (1) (0 1 2)> <TnPr (2) (0 1 2)> <TnPr (0 1) (0 1)>
|
|
<TnPr (0 1) (0 2)> <TnPr (0 1) (1 2)> <TnPr (0 2) (0 1)> <TnPr (0 2) (0 2)>
|
|
<TnPr (0 2) (1 2)> <TnPr (1 2) (0 1)> <TnPr (1 2) (0 2)> <TnPr (1 2) (1 2)>
|
|
<TnPr (0 1 2) (0)> <TnPr (0 1 2) (1)> <TnPr (0 1 2) (2)>)
|
|
|
|
(basis tpr-triangles 3) ==>
|
|
|
|
(<TnPr (0 1) (0 1 2)> <TnPr (0 2) (0 1 2)> <TnPr (1 2) (0 1 2)>
|
|
<TnPr (0 1 2) (0 1)> <TnPr (0 1 2) (0 2)> <TnPr (0 1 2) (1 2)>)
|
|
|
|
(basis tpr-triangles 4) ==>
|
|
|
|
(<TnPr (0 1 2) (0 1 2)>)
|
|
\end{verbatim}}
|
|
|
|
Let us consider now the chain complex, $ccn$, that we used in the chain complex chapter.
|
|
The basis in any degree are decades produced by the function {\tt <a-b<}. We build $ccn\otimes ccn$
|
|
and we verify the fundamental property of the associated boundary operator:
|
|
$$d^\otimes \circ d^\otimes=0.$$
|
|
\newpage
|
|
{\footnotesize\begin{verbatim}
|
|
(setf ccn-boundary #'(lambda (dgr gnr)
|
|
(if (evenp (+ dgr gnr))
|
|
(cmbn (1- dgr) 1 (- gnr 10))
|
|
(cmbn (1- dgr)))))
|
|
|
|
(setf ccn (build-chcm :cmpr #'f-cmpr
|
|
:basis #'(lambda (n) (<a-b< (* 10 n) (* 10 (1+ n))))
|
|
:intr-dffr ccn-boundary
|
|
:strt :gnrt
|
|
:orgn '(ccn) )) ==>
|
|
|
|
[K5 Chain-Complex]
|
|
|
|
(basis ccn 3) ==>
|
|
|
|
(30 31 32 33 34 35 36 37 38 39)
|
|
|
|
(setf tpr-ccn-ccn (tnsr-prdc ccn ccn)) ==>
|
|
|
|
[K7 Chain-Complex]
|
|
|
|
(setf comb2 (cmbn 2 1 21 5 25 9 29)) ==>
|
|
|
|
----------------------------------------------------------------------{CMBN 2}
|
|
<1 * 21>
|
|
<5 * 25>
|
|
<9 * 29>
|
|
------------------------------------------------------------------------------
|
|
|
|
(setf comb3 (cmbn 3 2 32 3 33 -4 34 -6 36)) ==>
|
|
|
|
----------------------------------------------------------------------{CMBN 3}
|
|
<2 * 32>
|
|
<3 * 33>
|
|
<-4 * 34>
|
|
<-6 * 36>
|
|
------------------------------------------------------------------------------
|
|
|
|
(setf tcmb (2cmbn-tnpr comb2 comb3)) ==>
|
|
|
|
----------------------------------------------------------------------{CMBN 5}
|
|
<2 * <TnPr 21 32>>
|
|
<3 * <TnPr 21 33>>
|
|
<-4 * <TnPr 21 34>>
|
|
<-6 * <TnPr 21 36>>
|
|
<10 * <TnPr 25 32>>
|
|
<15 * <TnPr 25 33>>
|
|
<-20 * <TnPr 25 34>>
|
|
<-30 * <TnPr 25 36>>
|
|
<18 * <TnPr 29 32>>
|
|
<27 * <TnPr 29 33>>
|
|
<-36 * <TnPr 29 34>>
|
|
<-54 * <TnPr 29 36>>
|
|
------------------------------------------------------------------------------
|
|
|
|
(? tpr-ccn-ccn *) ==>
|
|
|
|
----------------------------------------------------------------------{CMBN 4}
|
|
<3 * <TnPr 21 23>>
|
|
<15 * <TnPr 25 23>>
|
|
<27 * <TnPr 29 23>>
|
|
------------------------------------------------------------------------------
|
|
|
|
(? tpr-ccn-ccn *) ==>
|
|
|
|
----------------------------------------------------------------------{CMBN 3}
|
|
------------------------------------------------------------------------------
|
|
\end{verbatim}}
|
|
\newpage
|
|
\section{Tensor product of morphisms, reductions, homotopy equivalences.}
|
|
|
|
Let\index{tensor product!of morphisms}
|
|
$f:A_1 \longrightarrow A_2$ and $g:B_1 \longrightarrow B_2$ two morphisms between
|
|
two chain complexes. The tensor product $f \otimes g$ is the morphism
|
|
$$f\otimes g : A_1\otimes B_1 \longrightarrow A_2\otimes B_2$$
|
|
defined by the following formula respecting the Koszul rule:
|
|
$$ (f\otimes g) (a_1 \otimes b_1)= (-1)^{deg(g)*deg(a1)}f(a_1) \otimes g(b_1).$$
|
|
|
|
The method {\tt tnsr-prdc} already defined for chain complexes, may be also used for that purpose.
|
|
\vskip 0.45cm
|
|
{\parindent=0mm
|
|
{\leftskip=5mm
|
|
{\tt tnsr-prdc} {\em mrph1 mrph2} \hfill {\em [Method]} \par}
|
|
{\leftskip=15mm
|
|
Return the morphism, tensor product of the two morphisms {\em mrph1} and {\em mrph2}. The source
|
|
and target of this new morphism are res\-pec\-ti\-ve\-ly the tensor product of the chain complexes source
|
|
and target of {\em mrph1} and {\em mrph2}. The degree is the sum of the degrees of the parameters
|
|
and the lisp function (the {\tt :pure} keyword argument of the function {\tt build-mrph})
|
|
conforms to the mathematical definition above. The strategy is by generator, i.e. the morphism
|
|
is designed to work with $2$ arguments: a degree and a generator which must be
|
|
an object of type {\tt TNPR}. \par}
|
|
{\leftskip=5mm
|
|
{\tt tnsr-prdc} {\em rdct1 rdct2} \hfill {\em [Method]} \par}
|
|
{\leftskip=15mm
|
|
Return the reduction\index{tensor product!of reductions},
|
|
tensor product of the two reductions {\em rdct1} and {\em rdct2}. The
|
|
algorithm consists essentially in defining
|
|
$$f=f1 \otimes f2,\, g=g1 \otimes g2,\, h= h1 \otimes (g2 \circ g2) + Id_{tcc1} \otimes h2,$$
|
|
where $Id_{tcc1}$ is the identity morphism in the top chain complex of the reduction {\em rdct1}.
|
|
The returned reduction is then built by a call to the method {\tt build-rdct}.
|
|
This defines completely the chain complexes involved in the reduction. \par}
|
|
{\leftskip=5mm
|
|
{\tt tnsr-prdc} {\em hmeq1 hmeq2} \hfill {\em [Method]} \par}
|
|
{\leftskip=15mm
|
|
Return\index{tensor product!of homotopy equivalence}
|
|
the homotopy equivalence, tensor product of the two homotopy equivalence {\em heqm1} and {\em heqm2}.
|
|
This is a homotopy equivalence where the new reductions are the tensor products of the arguments reductions
|
|
(See the lisp definition just below). \par}
|
|
}
|
|
|
|
\subsection {Searching homology for tensor products}
|
|
|
|
The\index{searching homology!tensor products} comment list of a tensor product of two chain complexes has the form
|
|
{\tt (TNSR-PRDC {\em chcm1} {\em chcm2})}.
|
|
The {\tt search-efhm} method applied to a tensor product, looks for the value of the
|
|
respective {\tt efhm} slots of the chain complexes {\em chcm1} and {\em chcm2}, (i.e. two homotopy equivalences) or tries
|
|
to settle these slots if they are still unbound.
|
|
Then it builds the tensor product of both homotopy equivalences, as shown in the following lisp listing. At its turn,
|
|
the resulting homotopy equivalence will become the value of the {\tt efhm} slot of the initial tensor product
|
|
chain complex.
|
|
{\footnotesize\begin{verbatim}
|
|
(defmethod SEARCH-EFHM (chcm (orgn (eql 'tnsr-prdc)))
|
|
(declare (type chain-complex chcm))
|
|
(the homotopy-equivalence
|
|
(tnsr-prdc (efhm (second (orgn chcm)))
|
|
(efhm (third (orgn chcm))))))
|
|
|
|
(defmethod TNSR-PRDC ((hmeq1 homotopy-equivalence)
|
|
(hmeq2 homotopy-equivalence))
|
|
(the homotopy-equivalence
|
|
(build-hmeq
|
|
:lrdct (tnsr-prdc (lrdct hmeq1) (lrdct hmeq2))
|
|
:rrdct (tnsr-prdc (rrdct hmeq1) (rrdct hmeq2))
|
|
:orgn `(tnsr-prdc ,hmeq1 ,hmeq2))))
|
|
\end{verbatim}}
|
|
|
|
\subsection* {Lisp file concerned in this chapter}
|
|
|
|
{\tt tensor-products.lisp}, {\tt searching-homology.lisp}.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|