mmarco/kenzo
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
87124b7468
kenzo/examples/Chapter15.ipynb
gheber 87124b7468 First draft of Chapter 15.
2016-03-16 15:54:21 -05:00

113 KiB
Raw Blame History

Loop spaces fibrations

The canonical loop space fibration

Let $X$ be a simplicial set. The software Kenzo implements the canonical twisted cartesian product of $X$ by its loop space $GX$, denoted $X \times_\tau GX$, giving the Kan (Daniel M. Kan. A combinatorial definition of homotopy groups, Ann. of Math., 1958, vol. 67, pp 282-312.) model of the contractible path space of $X$. The canonical fibration $$ GX\quad \hookrightarrow\quad X \times_\tau GX \hskip 1.2em \longrightarrow \hskip -1.2em \longrightarrow \quad X,$$ is defined by the trivial application $\tau$, where $\tau(x)$ is the letter $x$ in $GX$. This twisted cartesian product has the same simplices as the non-twisted one. So both associated chain complexes are equal as graded modules. The essential difference resides in the differential morphism. More precisely, the face operator $\partial_n$ behaves differently in the twisted cartesian product. Let $(x,g) \in X \times_\tau GX$, the rule for the face operators are: $$ \begin{aligned} \partial_i(x,g) & = & (\partial_i x, \partial_i g), \qquad i<n, \\ \partial_n(x,g) & = & (\partial_n x, \tau(x).\partial_n g), \qquad i=n, \end{aligned} $$ where $\tau(x)$ is the letter $x$ in $GX$ and '.' is the group product in $GX$. Let us recall that, from the mathematical definition of $GX$, if $x$ is $n$-degenerate, for instance $x=\eta_n x'$, the $\tau(x)$ is the null element of $GX_n$. The behaviour of $\partial_n$ induces a change in the differential morphism of the chain complex associated to the twisted cartesian product.

The associated tensor twisted product

We recall that around the cartesian product $X \times GX$, the Eilenberg-Zilber theorem allows to build the reduction (see the function ez): $$ \begin{aligned} {{\cal C}_*(X \times GX)} \quad& \stackrel{h}{\longrightarrow} & {}^s{{\cal C}_*(X \times GX)} \cr {\scriptstyle f} \downarrow \uparrow {\scriptstyle g} \qquad& & \cr \qquad{{\cal C}_*(X) \otimes {\cal C}_*(GX)} & &\cr \end{aligned} $$ On the other hand, the differential morphism $d_\tau$ of the chain complex ${\cal C}_*(X \times_\tau GX)$ may be considered as a perturbed differential morphism $d$ of the chain complex ${\cal C}_*(X \times GX)$, the perturbation $\delta$ being: $\delta= d_\tau - d$. Using the basic perturbation lemma, we may construct a new reduction: $$ \begin{aligned} {{\cal C}_*(X \times_\tau GX)} \quad& \stackrel{h}{\longrightarrow} & {}^s{{\cal C}_*(X \times_\tau GX)} \cr {\scriptstyle f} \downarrow \uparrow {\scriptstyle g} \qquad& & \cr \qquad{{\cal C}_*(X) \otimes_t {\cal C}_*(GX)} & & \cr \end{aligned} $$ In fact, the interesting object produced by this machinery is the bottom chain complex ${\cal C}_*(X) \otimes_t {\cal C}_*(GX)$ which is nothing but the twisted tensor product (Edgar H. Brown Jr. Twisted tensor products, I, Ann. of Math., 1959, vol. 69, pp. 223-246.).

Main functions for the twisted products

twisted-crts-prdc space [Function]

From the simplicial set $X$, here the argument space, return the twisted cartesian product $X \times_\tau GX$ (a simplicial set). This function calls internally the functions loop-space and crts-prdc described in preceding chapters. The slot grmd of the resulting instance is set with the ordinary cartesian product $X \times GX$.

dtau-d space [Function]

From the simplicial set $X$, here the argument space, build the morphism perturbation (degree -1) $$d_\tau-d: X \times GX \longrightarrow X \times GX.$$ The work is essentialy done by the lisp function dtau-d-intr which computes the difference between the differential morphisms taking in account the discrepancy between the last face operator ($\partial_n$) in both chain complexes, $X \times_\tau GX$ and $X \times GX$.

szczarba space [Function]

Starting from the simplicial set $X$, (the argument space), return two values:
1- The reduction $$ \begin{aligned} {{\cal C}_*(X \times_\tau GX)}\quad & \stackrel{h}{\longrightarrow} & {}^s{{\cal C}_*(X \times_\tau GX)} \cr {\scriptstyle f} \downarrow \uparrow {\scriptstyle g}\qquad \cr \quad{{\cal C}_*(X) \otimes_t {\cal C}_*(GX)} \cr \end{aligned} $$ obtained by perturbing by $d_\tau-d$ the top chain complex of the reduction $$ \begin{aligned} {{\cal C}_*(X \times GX)}\quad & \stackrel{h}{\longrightarrow} & {}^s{{\cal C}_*(X \times GX)} \cr {\scriptstyle f} \downarrow \uparrow {\scriptstyle g}\qquad \cr \quad{{\cal C}_*(X) \otimes {\cal C}_*(GX)} \cr \end{aligned} $$ 2- The morphism corresponding to the perturbation of the bottom chain complex induced by the perturbation $d_\tau-d$ upon the top chain complex of the above reduction.

This algorithm implements in particular in a very efficient way the formulas of Szczarba (R.H. Szczarba. The homology of twisted cartesian products. Transactions of the American Math. Society, 1961, vol. 100, pp. 197-216).

twisted-tnsr-prdc space [Function]

Return the twisted tensor product (a chain complex) $X \otimes_t GX$. This is done simply by extraction of the bottom chain complex from the reduction (szczarba space).

Examples

For testing the functions above, we shall use a "soft" version of $\bar{\Delta}$ analogous to soft-delta or soft-delta-infinity. The input of the simplices will be done in clear with the help of the macro code. As this version does not exists in Kenzo, we have modified some functions of soft-delta, as indicated.

In [1]:
(DEFUN SOFT-DELTAB-CMPR (gmsm1 gmsm2)
    (if (= 1 (logcount (cdr gmsm1))) 
        :EQUAL
        (f-cmpr (cdr gmsm1)(cdr gmsm2)) ))
Out[1]:
SOFT-DELTAB-CMPR
In [2]:
(DEFUN SOFT-DELTAB-BNDR (dmns gmsm)
   (declare
      (fixnum dmns)
      (type soft-dlop gmsm))
   (the cmbn
      (if (< dmns 2)
         (zero-cmbn (1- dmns))
         (make-cmbn
         :degr (1- dmns)
         :list (mapcar #'(lambda (term)
                         (with-term (cffc gmsm) term
                            (term cffc (d gmsm))))
               (cmbn-list (delta-bndr dmns (cdr gmsm))))))))
Out[2]:
SOFT-DELTAB-BNDR
In [3]:
(DEFUN SOFT-DELTAB ()
   (the simplicial-set
      (build-smst
         :cmpr #'soft-deltab-cmpr
         :basis :locally-effective
         :bspn (d 1)
         :face #'soft-delta-face
;;;      :intr-dgnl #'soft-delta-dgnl :dgnl-strt :gnrt
         :intr-bndr #'soft-deltab-bndr :bndr-strt :gnrt
         :orgn `(soft-deltab))))

SIMPLE-STYLE-WARNING: 
  #<SB-INT:SIMPLE-STYLE-WARNING "undefined ~(~A~): ~S" {1005353B63}>
Out[3]:
SOFT-DELTAB
In [4]:
(defmacro code (arg) `(d (dlop-ext-int ,arg)))
Out[4]:
CODE
In [5]:
(def db (soft-deltab))
Out[5]:
[K1 Simplicial-Set]
In [6]:
(def gdb (loop-space db))
Out[6]:
[K6 Simplicial-Group]

Let us compare the faces of a cartesian product in $\bar{\Delta} \times \Omega(\bar{\Delta})$ and the faces of the same object in $\bar{\Delta} \times_\tau \Omega(\bar{\Delta})$:

In [7]:
(def crts-pr (crts-prdc db gdb))
Out[7]:
[K18 Simplicial-Set]
In [8]:
(def tw-crts-pr (twisted-crts-prdc db))
Out[8]:
[K23 Simplicial-Set]
In [9]:
(def smpx (crpr 0 (code '(0 1 2 3 4)) 
                 0 (loop3 0 (code '(0 1 2 3 4 5)) 1)))
Out[9]:
<CrPr - (DELT . 31) - <<Loop[(DELT . 63)]>>>
In [10]:
(dotimes (j 5)
         (print (face crts-pr j 4 smpx)))

<AbSm - <CrPr - (DELT . 30) - <<Loop[(DELT . 62)]>>>> 
<AbSm - <CrPr - (DELT . 29) - <<Loop[(DELT . 61)]>>>> 
<AbSm - <CrPr - (DELT . 27) - <<Loop[(DELT . 59)]>>>> 
<AbSm - <CrPr - (DELT . 23) - <<Loop[(DELT . 55)]>>>> 
<AbSm - <CrPr - (DELT . 15) - <<Loop[(DELT . 31)\-1][(DELT . 47)]>>>>
Out[10]:
NIL
In [11]:
(dotimes (j 5)
         (print (face tw-crts-pr j 4 smpx)))

<AbSm - <CrPr - (DELT . 30) - <<Loop[(DELT . 62)]>>>> 
<AbSm - <CrPr - (DELT . 29) - <<Loop[(DELT . 61)]>>>> 
<AbSm - <CrPr - (DELT . 27) - <<Loop[(DELT . 59)]>>>> 
<AbSm - <CrPr - (DELT . 23) - <<Loop[(DELT . 55)]>>>> 
<AbSm - <CrPr - (DELT . 15) - <<Loop[(DELT . 47)]>>>>
Out[11]:
NIL
In [12]:
(def smpx2 (crpr 0 (code '(1 2 3 4 5)) 
                  0 (loop3 0 (code '(5 6 7 8 9 10)) 1)))
Out[12]:
<CrPr - (DELT . 62) - <<Loop[(DELT . 2016)]>>>
In [13]:
(dotimes (j 5)
         (print (face crts-pr j 4 smpx2)))

<AbSm - <CrPr - (DELT . 60) - <<Loop[(DELT . 1984)]>>>> 
<AbSm - <CrPr - (DELT . 58) - <<Loop[(DELT . 1952)]>>>> 
<AbSm - <CrPr - (DELT . 54) - <<Loop[(DELT . 1888)]>>>> 
<AbSm - <CrPr - (DELT . 46) - <<Loop[(DELT . 1760)]>>>> 
<AbSm - <CrPr - (DELT . 30) - <<Loop[(DELT . 992)\-1][(DELT . 1504)]>>>>
Out[13]:
NIL
In [14]:
(dotimes (j 5)
         (print (face tw-crts-pr j 4 smpx2)))

<AbSm - <CrPr - (DELT . 60) - <<Loop[(DELT . 1984)]>>>> 
<AbSm - <CrPr - (DELT . 58) - <<Loop[(DELT . 1952)]>>>> 
<AbSm - <CrPr - (DELT . 54) - <<Loop[(DELT . 1888)]>>>> 
<AbSm - <CrPr - (DELT . 46) - <<Loop[(DELT . 1760)]>>>> 
<AbSm - <CrPr - (DELT . 30) - <<Loop[(DELT . 62)][(DELT . 992)\-1][(DELT . 1504)]>>>>
Out[14]:
NIL

The user will have noted that we may obtain the same twisted cartesian product by the fibration theory. Let us define a general function loop-fbr with a reduced simplicial set, space, as argument. This function uses the function fibration-total that we have seen in the chapter about fibrations. Here, we see that the lisp function for the simplicial morphism, (keyword :sintr), implements straightforwardly the canonical twisting operator which applies a simplex of $X$ to the corresponding 1-letter word of $GX$. Note that the execution time by the fibration function is a little longer than for the direct twisted cartesian product and it requires more memory.

In [15]:
(defun loop-fbr (space)
             (fibration-total
                (build-smmr
                  :sorc space 
                  :trgt (loop-space space) 
                  :degr -1
                  :sintr #'(lambda (dmns gmsm)
                               (absm 0 (loop3 0 gmsm 1)))
                  :orgn `(total-fibration ,space))))

SIMPLE-STYLE-WARNING: 
  #<SB-INT:SIMPLE-STYLE-WARNING "The variable ~S is defined but never used." {1005C2D303}>

SIMPLE-STYLE-WARNING: 
  #<SB-INT:SIMPLE-STYLE-WARNING "undefined ~(~A~): ~S" {1005C5C533}>
Out[15]:
LOOP-FBR
In [16]:
(def fb-tt-db (loop-fbr db))
Out[16]:
[K29 Simplicial-Set]
In [17]:
(dotimes (j 5)
         (print(face fb-tt-db j 4 smpx2)))

<AbSm - <CrPr - (DELT . 60) - <<Loop[(DELT . 1984)]>>>> 
<AbSm - <CrPr - (DELT . 58) - <<Loop[(DELT . 1952)]>>>> 
<AbSm - <CrPr - (DELT . 54) - <<Loop[(DELT . 1888)]>>>> 
<AbSm - <CrPr - (DELT . 46) - <<Loop[(DELT . 1760)]>>>> 
<AbSm - <CrPr - (DELT . 30) - <<Loop[(DELT . 62)][(DELT . 992)\-1][(DELT . 1504)]>>>>
Out[17]:
NIL
In [18]:
(time (dotimes (j 1000) (face tw-crts-pr 4 4 smpx2)))
Out[18]:
NIL
In [19]:
(time (dotimes (j 1000) (face fb-tt-db 4 4 smpx2)))
Out[19]:
NIL

The four following statements show the relationship between the differentials:

In [20]:
(def perturb (dtau-d db))
Out[20]:
[K34 Morphism (degree -1): K18 -> K18]
In [21]:
(? perturb 4 smpx2)
Out[21]:
----------------------------------------------------------------------{CMBN 3}
<1 * <CrPr - (DELT . 30) - <<Loop[(DELT . 62)][(DELT . 992)\-1][(DELT . 1504)]>>>>
<-1 * <CrPr - (DELT . 30) - <<Loop[(DELT . 992)\-1][(DELT . 1504)]>>>>
------------------------------------------------------------------------------
In [22]:
(? crts-pr 4 smpx2)
Out[22]:
----------------------------------------------------------------------{CMBN 3}
<1 * <CrPr - (DELT . 30) - <<Loop[(DELT . 992)\-1][(DELT . 1504)]>>>>
<-1 * <CrPr - (DELT . 46) - <<Loop[(DELT . 1760)]>>>>
<1 * <CrPr - (DELT . 54) - <<Loop[(DELT . 1888)]>>>>
<-1 * <CrPr - (DELT . 58) - <<Loop[(DELT . 1952)]>>>>
<1 * <CrPr - (DELT . 60) - <<Loop[(DELT . 1984)]>>>>
------------------------------------------------------------------------------
In [23]:
(? tw-crts-pr 4 smpx2)
Out[23]:
----------------------------------------------------------------------{CMBN 3}
<1 * <CrPr - (DELT . 30) - <<Loop[(DELT . 62)][(DELT . 992)\-1][(DELT . 1504)]>>>>
<-1 * <CrPr - (DELT . 46) - <<Loop[(DELT . 1760)]>>>>
<1 * <CrPr - (DELT . 54) - <<Loop[(DELT . 1888)]>>>>
<-1 * <CrPr - (DELT . 58) - <<Loop[(DELT . 1952)]>>>>
<1 * <CrPr - (DELT . 60) - <<Loop[(DELT . 1984)]>>>>
------------------------------------------------------------------------------

The same type of tests may be done with another reduced simplicial set, namely $P^3\mathbb{R}$.

In [24]:
(def pri3 (R-proj-space 3))
Out[24]:
[K35 Simplicial-Set]
In [25]:
(def tw-pri3 (twisted-crts-prdc pri3))
Out[25]:
[K57 Simplicial-Set]
In [26]:
(basis tw-pri3)
Out[26]:
:LOCALLY-EFFECTIVE
In [27]:
(def crt-pri3 (crts-prdc pri3 (loop-space pri3)))
Out[27]:
[K52 Simplicial-Set]
In [28]:
(def s (crpr 0 4 0 (loop3 0 5 1)))
Out[28]:
<CrPr - 4 - <<Loop[5]>>>
In [29]:
(dotimes (i 5) (print (face crt-pri3 i 4 s)))

<AbSm - <CrPr - 3 - <<Loop[4]>>>> 
<AbSm 0 <CrPr - 2 - <<Loop[3]>>>> 
<AbSm 1 <CrPr - 2 - <<Loop[3]>>>> 
<AbSm 2 <CrPr - 2 - <<Loop[3]>>>> 
<AbSm - <CrPr - 3 - <<Loop[4\-1]>>>>
Out[29]:
NIL
In [30]:
(dotimes (i 5) (print (face tw-pri3 i 4 s)))

<AbSm - <CrPr - 3 - <<Loop[4]>>>> 
<AbSm 0 <CrPr - 2 - <<Loop[3]>>>> 
<AbSm 1 <CrPr - 2 - <<Loop[3]>>>> 
<AbSm 2 <CrPr - 2 - <<Loop[3]>>>> 
<AbSm - <CrPr - 3 2-1-0 <<Loop>>>>
Out[30]:
NIL
In [31]:
(def fb-tt-pri3 (loop-fbr pri3))
Out[31]:
[K63 Simplicial-Set]
In [32]:
(dotimes (j 5) (print (face fb-tt-pri3 j 4 s)))

<AbSm - <CrPr - 3 - <<Loop[4]>>>> 
<AbSm 0 <CrPr - 2 - <<Loop[3]>>>> 
<AbSm 1 <CrPr - 2 - <<Loop[3]>>>> 
<AbSm 2 <CrPr - 2 - <<Loop[3]>>>> 
<AbSm - <CrPr - 3 2-1-0 <<Loop>>>>
Out[32]:
NIL

Let us check now the Szczarba reduction, with the simplicial set $\bar{\Delta}$.

In [33]:
(def szc-reduc (szczarba db))
Out[33]:
[K90 Reduction K23 => K88]
In [34]:
(pre-check-rdct szc-reduc)

---done---
Out[34]:
NIL
In [35]:
(setf *tc* (cmbn 2 1 (crpr 0 (code '(0 1 2)) 
                           0 (loop3 0 (code '(5 6 7 8)) 1))))
Out[35]:
----------------------------------------------------------------------{CMBN 2}
<1 * <CrPr - (DELT . 7) - <<Loop[(DELT . 480)]>>>>
------------------------------------------------------------------------------
In [36]:
(setf *bc* (cmbn 2 1 (tnpr 0 (code '(0)) 2 (loop3 0 (code '(5 6 7 8)) 1))
                  10 (tnpr 1 (code '(10 11)) 1 (loop3 0 (code '(0 1 2)) 1))
                 100 (tnpr 2 (code '(0 1 2)) 0 (loop3 0 (code '(10 11)) 1))))
Out[36]:
----------------------------------------------------------------------{CMBN 2}
<1 * <TnPr (DELT . 1) <<Loop[(DELT . 480)]>>>>
<10 * <TnPr (DELT . 3072) <<Loop[(DELT . 7)]>>>>
<100 * <TnPr (DELT . 7) <<Loop[(DELT . 3072)]>>>>
------------------------------------------------------------------------------
In [37]:
(pre-check-rdct szc-reduc)

---done---
Out[37]:
NIL
In [38]:
(check-rdct-no-wait)

*TC* => 
----------------------------------------------------------------------{CMBN 2}
<1 * <CrPr - (DELT . 7) - <<Loop[(DELT . 480)]>>>>
------------------------------------------------------------------------------

*BC* => 
----------------------------------------------------------------------{CMBN 2}
<1 * <TnPr (DELT . 1) <<Loop[(DELT . 480)]>>>>
<10 * <TnPr (DELT . 3072) <<Loop[(DELT . 7)]>>>>
<100 * <TnPr (DELT . 7) <<Loop[(DELT . 3072)]>>>>
------------------------------------------------------------------------------

Checking *TDD* = 0
Result: 
----------------------------------------------------------------------{CMBN 0}
------------------------------------------------------------------------------

Checking *BDD* = 0
Result: 
----------------------------------------------------------------------{CMBN 0}
------------------------------------------------------------------------------

Checking *DF-FD* = 0
Result: 
----------------------------------------------------------------------{CMBN 1}
------------------------------------------------------------------------------

Checking *DG-GD* = 0
Result: 
----------------------------------------------------------------------{CMBN 1}
------------------------------------------------------------------------------

Checking *ID-FG* = 0
Result: 
----------------------------------------------------------------------{CMBN 2}
------------------------------------------------------------------------------

Checking *ID-GF-DH-HD* = 0
Result: 
----------------------------------------------------------------------{CMBN 2}
------------------------------------------------------------------------------

Checking *HH* = 0
Result: 
----------------------------------------------------------------------{CMBN 4}
------------------------------------------------------------------------------

Checking *FH* = 0
Result: 
----------------------------------------------------------------------{CMBN 3}
------------------------------------------------------------------------------

Checking *HG* = 0
Result: 
----------------------------------------------------------------------{CMBN 3}
------------------------------------------------------------------------------

---done---
Out[38]:
NIL

Exercice with the twisting cochain.

Let $B$ be a reduced simplicial set and its loop space $GB$ (a simplicial group). In the following examples, we shall use the efficient Kenzo version of the simplicial set $\bar{\Delta}$, i.e. the simplices are input and printed under their binary form coding.

The twisting cochain.

The twisting cochain $t$ is the morphism $$t: aug \circ d_{\otimes t} \circ coaug$$ where,

  • $coaug$ is the morphism $$ coaug: B \rightarrow B \otimes GB,$$ $$ coaug(b) = b \otimes 1_{GB}. $$
  • $d_{\otimes t}$ is the differential morphism of the twisted tensor product $B \otimes_t GB$.
  • $aug$ is the morphism $$aug: B \otimes GB \longrightarrow GB , $$ $$ \begin{aligned} aug(b_i \otimes g_j)& = g_j, & b_i \in B_0, \\ aug(b_i \otimes g_j)& = 0, & b_i \in B_k,\, k\not=0. \end{aligned} $$ We recall that, as graded modules, $B\otimes GB$ and $B \otimes_t GB$ are identical.

First, we create $\bar{\Delta}$ and $G\bar{\Delta}$. The function twisted-tnsr-prdc extracts the twisted tensor product $\bar{\Delta} \otimes_t G\bar{\Delta}$ from the reduction obtained by a call to the function szczarba.

In [39]:
(def d (deltab))
Out[39]:
[K112 Simplicial-Set]
In [40]:
(def gd (loop-space d))
Out[40]:
[K117 Simplicial-Group]
In [41]:
(def d-twtp-gd (twisted-tnsr-prdc d))
Out[41]:
[K160 Chain-Complex]

Let us define the coaugmentation and augmentation morphisms. As usual, it is sufficient to define the algorithm on a generator.

In [42]:
(def coaug (build-mrph 
               :sorc d 
               :trgt d-twtp-gd 
               :degr 0
               :intr #'(lambda (degr gnrt)
                         (term-cmbn degr 1 (tnpr degr gnrt 0 +null-loop+)))
               :strt :gnrt 
               :orgn '(coaug. d --> d-twtp-gd)))
Out[42]:
[K163 Morphism (degree 0): K112 -> K160]
In [43]:
(? coaug 3 15)
Out[43]:
----------------------------------------------------------------------{CMBN 3}
<1 * <TnPr 15 <<Loop>>>>
------------------------------------------------------------------------------
In [44]:
(? coaug (cmbn 4 1 31 1 62 1 124))
Out[44]:
----------------------------------------------------------------------{CMBN 4}
<1 * <TnPr 31 <<Loop>>>>
<1 * <TnPr 62 <<Loop>>>>
<1 * <TnPr 124 <<Loop>>>>
------------------------------------------------------------------------------
In [45]:
(def aug (build-mrph
             :sorc d-twtp-gd
             :trgt gd
             :degr 0
             :intr #'(lambda (degr tnpr)
                        (with-tnpr (degr1 gmsm1 degr2 loop2) tnpr
                            (if (zerop degr1)
                                (term-cmbn degr 1 loop2)
                                (zero-cmbn degr))))
             :strt :gnrt
             :orgn '(aug. of d-twtp-gd)))

SIMPLE-STYLE-WARNING: 
  #<SB-INT:SIMPLE-STYLE-WARNING "The variable ~S is defined but never used." {10070CDB13}>

SIMPLE-STYLE-WARNING: 
  #<SB-INT:SIMPLE-STYLE-WARNING "The variable ~S is defined but never used." {10070CE1E3}>
Out[45]:
[K164 Morphism (degree 0): K160 -> K117]
In [46]:
(? aug (cmbn 2 9 (tnpr 0 1 2 (loop3 0 15 1))
               3 (tnpr 1 3 1 (loop3 0 7 1))))
Out[46]:
----------------------------------------------------------------------{CMBN 2}
<9 * <<Loop[15]>>>
------------------------------------------------------------------------------

The morphism {\tt cochain} is simply a composition of morphisms. We apply it upon the simplices (0), (0 1 2), (0 1 2 3), ..., coded as the integers $1,7,15,\ldots$.

In [47]:
(def cochain (i-cmps aug (dffr d-twtp-gd) coaug))
Out[47]:
[K166 Morphism (degree -1): K112 -> K117]
In [48]:
(? cochain 0 1)
Out[48]:
----------------------------------------------------------------------{CMBN -1}
------------------------------------------------------------------------------
In [49]:
(? cochain 2 7)
Out[49]:
----------------------------------------------------------------------{CMBN 1}
<1 * <<Loop[0 3][7]>>>
------------------------------------------------------------------------------
In [50]:
(? cochain 3 15)
Out[50]:
----------------------------------------------------------------------{CMBN 2}
<1 * <<Loop[1-0 3][0 7][1 13]>>>
<-1 * <<Loop[1-0 3][1 7][15]>>>
------------------------------------------------------------------------------
In [51]:
(? cochain 4 31)
Out[51]:
----------------------------------------------------------------------{CMBN 3}
<-1 * <<Loop[2-1-0 3][1-0 7][2-0 13][2-1 25]>>>
<1 * <<Loop[2-1-0 3][1-0 7][2-1 13][2 29]>>>
<1 * <<Loop[2-1-0 3][2-0 7][0 15][2-1 25]>>>
<-1 * <<Loop[2-1-0 3][2-0 7][2-1 13][1 29]>>>
<-1 * <<Loop[2-1-0 3][2-1 7][1 15][2 27]>>>
<1 * <<Loop[2-1-0 3][2-1 7][2 15][31]>>>
------------------------------------------------------------------------------
In [52]:
(? cochain 5 63)
Out[52]:
----------------------------------------------------------------------{CMBN 4}
<-1 * <<Loop[3-2-1-0 3][2-1-0 7][3-1-0 13][3-2-0 25][3-2-1 49]>>>
<1 * <<Loop[3-2-1-0 3][2-1-0 7][3-1-0 13][3-2-1 25][3-2 57]>>>
<1 * <<Loop[3-2-1-0 3][2-1-0 7][3-2-0 13][3-0 29][3-2-1 49]>>>
<-1 * <<Loop[3-2-1-0 3][2-1-0 7][3-2-0 13][3-2-1 25][3-1 57]>>>
<-1 * <<Loop[3-2-1-0 3][2-1-0 7][3-2-1 13][3-1 29][3-2 53]>>>
<1 * <<Loop[3-2-1-0 3][2-1-0 7][3-2-1 13][3-2 29][3 61]>>>
<1 * <<Loop[3-2-1-0 3][3-1-0 7][1-0 15][3-2-0 25][3-2-1 49]>>>
<-1 * <<Loop[3-2-1-0 3][3-1-0 7][1-0 15][3-2-1 25][3-2 57]>>>
<-1 * <<Loop[3-2-1-0 3][3-1-0 7][3-2-0 13][2-0 29][3-2-1 49]>>>
<1 * <<Loop[3-2-1-0 3][3-1-0 7][3-2-0 13][3-2-1 25][2-1 57]>>>
... ...
------------------------------------------------------------------------------

We verify, that for a simplex in dimension $n$, the length of the resulting combination is $(n-1)!$.

In [53]:
(length(cmbn-list *))
Out[53]:
24
In [54]:
(? cochain 6 127)
Out[54]:
----------------------------------------------------------------------{CMBN 5}
<1 * <<Loop[4-3-2-1-0 3][3-2-1-0 7][4-2-1-0 13][4-3-1-0 25][4-3-2-0 49][4-3-2-1 97]>>>
<-1 * <<Loop[4-3-2-1-0 3][3-2-1-0 7][4-2-1-0 13][4-3-1-0 25][4-3-2-1 49][4-3-2 113]>>>
<-1 * <<Loop[4-3-2-1-0 3][3-2-1-0 7][4-2-1-0 13][4-3-2-0 25][4-3-0 57][4-3-2-1 97]>>>
<1 * <<Loop[4-3-2-1-0 3][3-2-1-0 7][4-2-1-0 13][4-3-2-0 25][4-3-2-1 49][4-3-1 113]>>>
<1 * <<Loop[4-3-2-1-0 3][3-2-1-0 7][4-2-1-0 13][4-3-2-1 25][4-3-1 57][4-3-2 105]>>>
<-1 * <<Loop[4-3-2-1-0 3][3-2-1-0 7][4-2-1-0 13][4-3-2-1 25][4-3-2 57][4-3 121]>>>
<-1 * <<Loop[4-3-2-1-0 3][3-2-1-0 7][4-3-1-0 13][4-1-0 29][4-3-2-0 49][4-3-2-1 97]>>>
<1 * <<Loop[4-3-2-1-0 3][3-2-1-0 7][4-3-1-0 13][4-1-0 29][4-3-2-1 49][4-3-2 113]>>>
<1 * <<Loop[4-3-2-1-0 3][3-2-1-0 7][4-3-1-0 13][4-3-2-0 25][4-2-0 57][4-3-2-1 97]>>>
<-1 * <<Loop[4-3-2-1-0 3][3-2-1-0 7][4-3-1-0 13][4-3-2-0 25][4-3-2-1 49][4-2-1 113]>>>
... ...
------------------------------------------------------------------------------
In [55]:
(length(cmbn-list *))
Out[55]:
120

Expression of the differential $d_{\otimes t}$

The differential $d_{\otimes t}$ of the twisted tensor product $B \otimes_t GB$ may be expressed as the sum of the differential of the simple tensor product $B \otimes GB$ and the following morphism of degree -1, $$\nabla: B \otimes GB \longrightarrow B \otimes GB,$$ where $\nabla$ is the composition of the morphisms of the following sequence: $$B\otimes GB \buildrel {\Delta\otimes 1_{GB}} \over \longrightarrow (B\otimes B) \otimes GB \buildrel {assoc} \over \longrightarrow B \otimes (B \otimes GB) \buildrel {1_B \otimes (t \otimes 1_{GB})} \over \longrightarrow B \otimes (GB \otimes GB) \buildrel {1_B \otimes \varpi} \over \longrightarrow B \otimes GB.$$ In the previous formula, $\Delta$ is the coproduct in the coalgebra $B$, $\varpi$ is the product in the algebra $GB$, $1_B$ is the identity morphism in $B$ and $1_{GB}$ the identity morphism in $GB$. We need also, as in a previous example, an "assoc" morphism for the compound tensor product. The user will note the easiness for coding in Kenzo such a long composition of morphisms.

In [56]:
(def 3-left (tnsr-prdc (tnsr-prdc d d) gd))
Out[56]:
[K167 Chain-Complex]
In [57]:
(def 3-right (tnsr-prdc d (tnsr-prdc d gd)))
Out[57]:
[K169 Chain-Complex]
In [58]:
(def assoc1 (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)))

SIMPLE-STYLE-WARNING: 
  #<SB-INT:SIMPLE-STYLE-WARNING "The variable ~S is defined but never used." {10074A1213}>

SIMPLE-STYLE-WARNING: 
  #<SB-INT:SIMPLE-STYLE-WARNING "The variable ~S is defined but never used." {10074A18E3}>
Out[58]:
[K171 Morphism (degree 0): K167 -> K169]
In [59]:
(def id-d (idnt-mrph d))
Out[59]:
[K172 Morphism (degree 0): K112 -> K112]
In [60]:
(def id-gd (idnt-mrph gd))
Out[60]:
[K173 Morphism (degree 0): K117 -> K117]
In [61]:
(def nabla 
 (add (dffr (tnsr-prdc d gd))
      (i-cmps (tnsr-prdc id-d (aprd gd))
              (tnsr-prdc id-d (tnsr-prdc cochain id-gd))
              assoc1
              (tnsr-prdc (cprd d) id-gd))))
Out[61]:
[K185 Morphism (degree -1): K139 -> K139]

We verify that the morphism nabla and the differential of the twisted tensor product (accessible through the symbol d-twtp-gd) return the same results:

In [62]:
(? (dffr d-twtp-gd) 2 (tnpr 1 3 1 (loop3 0 7 1)))
Out[62]:
----------------------------------------------------------------------{CMBN 1}
<1 * <TnPr 1 <<Loop[7]>>>>
<-1 * <TnPr 1 <<Loop[0 3][7]>>>>
<1 * <TnPr 3 <<Loop[3\-1][5]>>>>
<-1 * <TnPr 3 <<Loop[6]>>>>
------------------------------------------------------------------------------
In [63]:
(? nabla 2 (tnpr 1 3 1 (loop3 0 7 1)))
Out[63]:
----------------------------------------------------------------------{CMBN 1}
<1 * <TnPr 1 <<Loop[7]>>>>
<-1 * <TnPr 1 <<Loop[0 3][7]>>>>
<1 * <TnPr 3 <<Loop[3\-1][5]>>>>
<-1 * <TnPr 3 <<Loop[6]>>>>
------------------------------------------------------------------------------
In [64]:
(def zero (sbtr nabla (dffr d-twtp-gd)))
Out[64]:
[K186 Morphism (degree -1): K139 -> K139]
In [65]:
(? zero 2 (tnpr 1 3 1 (loop3 0 7 1)))
Out[65]:
----------------------------------------------------------------------{CMBN 1}
------------------------------------------------------------------------------
In [66]:
(? zero 5 (tnpr  3 15 2 (loop3 0 15 1)))
Out[66]:
----------------------------------------------------------------------{CMBN 4}
------------------------------------------------------------------------------

The cup product of the twisting cochain

The cup product $t \sqcup t$ of the twisting cochain $t$, $$t\sqcup t: B \longrightarrow GB$$ is defined by the following composition of morphisms: $$B \buildrel {\Delta} \over \longrightarrow B \otimes B \buildrel {t \otimes t} \over \longrightarrow GB \otimes GB \buildrel {\varpi} \over \longrightarrow GB.$$ We may now verify the formula $$ d_{GB} \circ t + t \circ d_B + t\sqcup t =0,$$ where $d_B$ and $d_{GB}$ are the respective differential morphisms in $B$ and $GB$.

In [67]:
(def t-cup-t (i-cmps (aprd gd) (tnsr-prdc cochain cochain) (cprd d)))
Out[67]:
[K189 Morphism (degree -2): K112 -> K117]
In [68]:
(def dt (cmps (dffr gd) cochain))
Out[68]:
[K190 Morphism (degree -2): K112 -> K117]
In [69]:
(def td (cmps cochain (dffr d)))
Out[69]:
[K191 Morphism (degree -2): K112 -> K117]
In [70]:
(def zero-2 (i-add dt td t-cup-t))
Out[70]:
[K193 Morphism (degree -2): K112 -> K117]
In [71]:
(? zero-2 3 15)
Out[71]:
----------------------------------------------------------------------{CMBN 1}
------------------------------------------------------------------------------
In [72]:
(? zero-2 4 31)
Out[72]:
----------------------------------------------------------------------{CMBN 2}
------------------------------------------------------------------------------
In [73]:
(? zero-2 5 63)
Out[73]:
----------------------------------------------------------------------{CMBN 3}
------------------------------------------------------------------------------
In [74]:
(? zero-2 6 127)
Out[74]:
----------------------------------------------------------------------{CMBN 4}
------------------------------------------------------------------------------

So the user has easily verified the cochain condition for the twisting cochain $t$.

The essential contraction

It is known that if $B$ is a reduced simplicial set, the space $B \times_\tau GB$ is contractible. So it is possible to build a reduction of this space over $\mathbb{Z}$. This reduction depends of the important contraction $$\chi_{\times\tau}: {{\cal C}_*(B) \times_\tau {\cal C}_*(GB)} \longrightarrow {{\cal C}_*(B) \times_\tau {\cal C}_*(GB)}, $$ which is a homotopy operator (degree: $+1$) satisfying the relation $$d \circ \chi_{\times\tau} + \chi_{\times\tau} \circ d =1.$$ Now, from the reduction $$ \begin{aligned} {{\cal C}_*(X \times_\tau GX)} \quad& \stackrel{h}{\longrightarrow} & {}^s{{\cal C}_*(X \times_\tau GX)} \cr {\scriptstyle f} \downarrow \uparrow {\scriptstyle g} \qquad \cr {{\cal C}_*(X) \otimes_t {\cal C}_*(GX)} \cr \end{aligned} $$ there is also an induced contraction $$\chi_{\otimes t}: {{\cal C}_*(B) \otimes_t {\cal C}_*(GB)} \longrightarrow {{\cal C}_*(B) \otimes_t {\cal C}_*(GB)}, $$ defined by $\chi_{\otimes t}= f \circ \chi_{\times\tau} \circ g$. This implies that the twisted tensor product is also contractible over $\mathbb{Z}$.

The two functions of Kenzo for this construction are:

crts-contraction space [Function]

Return the homotopy morphism corresponding to the contraction $\chi_{\times\tau}$. The lisp definition is:

commonlisp
          (defun CRTS-CONTRACTION 
             (space
                &aux (twisted-crts-prdc (twisted-crts-prdc space)))
             (the morphism
                (build-mrph
                   :sorc twisted-crts-prdc 
                   :trgt twisted-crts-prdc 
                   :degr +1
                   :intr (crts-contraction-intr 
                               (cmpr space)
                               (bspn space) 
                               (face space) 
                               (cmpr twisted-crts-prdc))
                   :strt :gnrt
                   :orgn `(crts-contraction ,space))))

At execution time, the work is essentialy done by the function put in the slot :intr.

tnpr-contraction space [Function]

Return the induced morphism $\chi_{\otimes t}= f \circ \chi_{\times\tau} \circ g$, as shown by the lisp definition:

commonlisp
          (defun TNPR-CONTRACTION 
             (space
                &aux (szczarba (szczarba space))
                     (f (f szczarba))
                     (g (g szczarba))
                     (crts-contraction (crts-contraction space)))
             (the morphism
                (i-cmps f crts-contraction g)))

Examples

Let us use again our familiar simplicial set $\bar\Delta$. First we apply the homotopy operator $\chi_{\times t}$ upon various generators. Note that the binary coding of the simplices allows normal arithmetic operators to generate them.

In [75]:
(def delta (deltab))
Out[75]:
[K112 Simplicial-Set]
In [76]:
(def chi-x (crts-contraction delta))
Out[76]:
[K194 Morphism (degree 1): K134 -> K134]
In [77]:
(? chi-x 0 (crpr 0 1 0 +null-loop+))
Out[77]:
----------------------------------------------------------------------{CMBN 1}
------------------------------------------------------------------------------
In [78]:
(? chi-x 0 (crpr 0 1 0 (loop3 0 96 1)))
Out[78]:
----------------------------------------------------------------------{CMBN 1}
<-1 * <CrPr - 96 0 <<Loop>>>>
------------------------------------------------------------------------------
In [79]:
(? chi-x 0 (crpr 0 1 0 (loop3 0 96 1 0 (+ 256 128) 1)))
Out[79]:
----------------------------------------------------------------------{CMBN 1}
<-1 * <CrPr - 96 0 <<Loop[384]>>>>
<-1 * <CrPr - 384 0 <<Loop>>>>
------------------------------------------------------------------------------
In [80]:
(? chi-x 0 (crpr 0 1 0 (loop3 0 96 1 0 (+ 256 128) 1 0 (+ 512 1024) 1)))
Out[80]:
----------------------------------------------------------------------{CMBN 1}
<-1 * <CrPr - 96 0 <<Loop[384][1536]>>>>
<-1 * <CrPr - 384 0 <<Loop[1536]>>>>
<-1 * <CrPr - 1536 0 <<Loop>>>>
------------------------------------------------------------------------------
In [81]:
(? chi-x 0 (crpr 0 1 0 (loop3 0 96 2)))
Out[81]:
----------------------------------------------------------------------{CMBN 1}
<-1 * <CrPr - 96 0 <<Loop>>>>
<-1 * <CrPr - 96 0 <<Loop[96]>>>>
------------------------------------------------------------------------------
In [82]:
(? chi-x 1 (crpr 0 3 0 (loop3 0 (+ 32 64 128) 1)))
Out[82]:
----------------------------------------------------------------------{CMBN 2}
<1 * <CrPr - 224 1-0 <<Loop>>>>
<-1 * <CrPr 1 3 0 <<Loop[224]>>>>
<1 * <CrPr 1 96 0 <<Loop[224]>>>>
------------------------------------------------------------------------------
In [83]:
(? chi-x 2 (crpr 0 7 0 (loop3 0 (+ 32 64 128 256) 1)))
Out[83]:
----------------------------------------------------------------------{CMBN 3}
<-1 * <CrPr - 480 2-1-0 <<Loop>>>>
<1 * <CrPr 2 7 1 <<Loop[480]>>>>
<-1 * <CrPr 2 224 1 <<Loop[480]>>>>
<-1 * <CrPr 2-1 5 0 <<Loop[480]>>>>
<1 * <CrPr 2-1 160 0 <<Loop[480]>>>>
------------------------------------------------------------------------------
In [84]:
(? chi-x 3 (crpr 2 7 1 (loop3 2 (+ 32 64 128) 2 4 (+ 32 64 128) -2)))
Out[84]:
----------------------------------------------------------------------{CMBN 4}
<-1 * <CrPr 3-1 7 2-0 <<Loop[1 224\2][2 224\-2]>>>>
<1 * <CrPr 3-2 7 1-0 <<Loop[1 224\2][2 224\-2]>>>>
------------------------------------------------------------------------------
In [85]:
(? chi-x 3 (crpr 2 7 4 (loop3 2 (+ 32 64 128) 2 1 (+ 32 64 128) -2)))
Out[85]:
----------------------------------------------------------------------{CMBN 4}
------------------------------------------------------------------------------
In [86]:
(? chi-x 3 (crpr 2 7 1 (loop3 2 (+ 32 64 128) -2 4 (+ 32 64 128) 2)))
Out[86]:
----------------------------------------------------------------------{CMBN 4}
<-1 * <CrPr 3-1 7 2-0 <<Loop[1 224\-2][2 224\2]>>>>
<1 * <CrPr 3-2 7 1-0 <<Loop[1 224\-2][2 224\2]>>>>
------------------------------------------------------------------------------
In [87]:
(? chi-x 3 (crpr 2 7 4 (loop3 2 (+ 32 64 128) -2 1 (+ 32 64 128) 2)))
Out[87]:
----------------------------------------------------------------------{CMBN 4}
------------------------------------------------------------------------------
In [88]:
(? chi-x 3 (crpr 1 7 2 (loop3 2 (+ 32 64 128) 2 4 (+ 32 64 128) -2)))
Out[88]:
----------------------------------------------------------------------{CMBN 4}
<-1 * <CrPr 3-0 7 2-1 <<Loop[1 224\2][2 224\-2]>>>>
------------------------------------------------------------------------------
In [89]:
(? chi-x 3 (crpr 4 7 2 (loop3 2 (+ 32 64 128) 2 1 (+ 32 64 128) -2)))
Out[89]:
----------------------------------------------------------------------{CMBN 4}
------------------------------------------------------------------------------
In [90]:
(? chi-x 3 (crpr 1 7 2 (loop3 2 (+ 32 64 128) -2 4 (+ 32 64 128) 2)))
Out[90]:
----------------------------------------------------------------------{CMBN 4}
<-1 * <CrPr 3-0 7 2-1 <<Loop[1 224\-2][2 224\2]>>>>
------------------------------------------------------------------------------
In [91]:
(? chi-x 3 (crpr 4 7 2 (loop3 2 (+ 32 64 128) -2 1 (+ 32 64 128) 2)))
Out[91]:
----------------------------------------------------------------------{CMBN 4}
------------------------------------------------------------------------------

Then, for testing $\chi_{\otimes t}$ we use the image of all those generators by the function f of the Brown reduction. $$ \begin{aligned} {{\cal C}_*(X \times_\tau GX)} \quad& \stackrel{h}{\longrightarrow} & {}^s{{\cal C}_*(X \times_\tau GX)} \cr {\scriptstyle f} \downarrow \uparrow {\scriptstyle g}\qquad \cr {{\cal C}_*(X) \otimes_t {\cal C}_*(GX)} \cr \end{aligned} $$

In [92]:
(setf *tnpr-with-degrees* t)
Out[92]:
T
In [93]:
(def chi-t (tnpr-contraction delta))
Out[93]:
[K196 Morphism (degree 1): K160 -> K160]
In [94]:
(def reduc (szczarba delta))
Out[94]:
[K162 Reduction K134 => K160]
In [95]:
(def f (f reduc))
Out[95]:
[K152 Morphism (degree 0): K134 -> K160]
In [96]:
(? f 0 (crpr 0 1 0 +null-loop+))
Out[96]:
----------------------------------------------------------------------{CMBN 0}
<1 * <TnPr 0 1 0 <<Loop>>>>
------------------------------------------------------------------------------
In [97]:
(? chi-t *)
Out[97]:
----------------------------------------------------------------------{CMBN 1}
------------------------------------------------------------------------------
In [98]:
(? f 0 (crpr 0 1 0 (loop3 0 96 1)))
Out[98]:
----------------------------------------------------------------------{CMBN 0}
<1 * <TnPr 0 32 0 <<Loop[96]>>>>
------------------------------------------------------------------------------
In [99]:
(? chi-t *)
Out[99]:
----------------------------------------------------------------------{CMBN 1}
<-1 * <TnPr 1 96 0 <<Loop>>>>
------------------------------------------------------------------------------
In [100]:
(? f 0 (crpr 0 1 0 (loop3 0 96 1 0 (+ 256 128) 1)))
Out[100]:
----------------------------------------------------------------------{CMBN 0}
<1 * <TnPr 0 1 0 <<Loop[96][384]>>>>
------------------------------------------------------------------------------
In [101]:
(? chi-t *)
Out[101]:
----------------------------------------------------------------------{CMBN 1}
<-1 * <TnPr 1 96 0 <<Loop[384]>>>>
<-1 * <TnPr 1 384 0 <<Loop>>>>
------------------------------------------------------------------------------
In [102]:
(? f 0 (crpr 0 1 0 (loop3 0 96 1 0 (+ 256 128) 1 0 (+ 512 1024) 1)))
Out[102]:
----------------------------------------------------------------------{CMBN 0}
<1 * <TnPr 0 1 0 <<Loop[96][384][1536]>>>>
------------------------------------------------------------------------------
In [103]:
(? chi-t *)
Out[103]:
----------------------------------------------------------------------{CMBN 1}
<-1 * <TnPr 1 96 0 <<Loop[384][1536]>>>>
<-1 * <TnPr 1 384 0 <<Loop[1536]>>>>
<-1 * <TnPr 1 1536 0 <<Loop>>>>
------------------------------------------------------------------------------
In [104]:
(? f 0 (crpr 0 1 0 (loop3 0 96 2)))
Out[104]:
----------------------------------------------------------------------{CMBN 0}
<1 * <TnPr 0 1 0 <<Loop[96\2]>>>>
------------------------------------------------------------------------------
In [105]:
(? chi-t *)
Out[105]:
----------------------------------------------------------------------{CMBN 1}
<-1 * <TnPr 1 96 0 <<Loop>>>>
<-1 * <TnPr 1 96 0 <<Loop[96]>>>>
------------------------------------------------------------------------------
In [106]:
(? f 1 (crpr 0 3 0 (loop3 0 (+ 32 64 128) 1)))
Out[106]:
----------------------------------------------------------------------{CMBN 1}
<1 * <TnPr 0 1 1 <<Loop[0 3][224]>>>>
<1 * <TnPr 1 3 0 <<Loop[192]>>>>
------------------------------------------------------------------------------
In [107]:
(? chi-t *)
Out[107]:
----------------------------------------------------------------------{CMBN 2}
<-1 * <TnPr 1 3 1 <<Loop[224]>>>>
<1 * <TnPr 1 96 1 <<Loop[224]>>>>
<1 * <TnPr 2 224 0 <<Loop>>>>
------------------------------------------------------------------------------
In [108]:
(? f 2 (crpr 0 7 0 (loop3 0 (+ 32 64 128 256) 1)))
Out[108]:
----------------------------------------------------------------------{CMBN 2}
<-1 * <TnPr 0 1 2 <<Loop[1-0 3][0 7][1 416]>>>>
<1 * <TnPr 0 1 2 <<Loop[1-0 3][1 7][480]>>>>
<1 * <TnPr 1 3 1 <<Loop[0 6][448]>>>>
<1 * <TnPr 2 7 0 <<Loop[384]>>>>
------------------------------------------------------------------------------
In [109]:
(? chi-t *)
Out[109]:
----------------------------------------------------------------------{CMBN 3}
<1 * <TnPr 0 1 3 <<Loop[2-1-0 3][1-0 7][2 480]>>>>
<-1 * <TnPr 0 1 3 <<Loop[2-1-0 3][2-0 7][1 480]>>>>
<-1 * <TnPr 0 32 3 <<Loop[2-1-0 96][1-0 224][2 480]>>>>
<1 * <TnPr 0 32 3 <<Loop[2-1-0 96][2-0 224][1 480]>>>>
<-1 * <TnPr 1 5 2 <<Loop[480]>>>>
<1 * <TnPr 1 160 2 <<Loop[480]>>>>
<1 * <TnPr 2 7 1 <<Loop[448]>>>>
<-1 * <TnPr 2 224 1 <<Loop[448]>>>>
<-1 * <TnPr 3 480 0 <<Loop>>>>
------------------------------------------------------------------------------
In [110]:
(? f 3 (crpr 2 7 1 (loop3 2 (+ 32 64 128) 2 4 (+ 32 64 128) -2)))
Out[110]:
----------------------------------------------------------------------{CMBN 3}
<1 * <TnPr 0 1 3 <<Loop[2-1-0 3][2-1 7][2-0 224\2][3-0 224\-2]>>>>
------------------------------------------------------------------------------
In [111]:
(? chi-t *)
Out[111]:
----------------------------------------------------------------------{CMBN 4}
<1 * <TnPr 2 7 2 <<Loop[1 224\2][2 224\-2]>>>>
------------------------------------------------------------------------------
In [112]:
(? f 3 (crpr 2 7 4 (loop3 2 (+ 32 64 128) 2 1 (+ 32 64 128) -2)))
Out[112]:
----------------------------------------------------------------------{CMBN 3}
------------------------------------------------------------------------------
In [113]:
(? chi-t *)
Out[113]:
----------------------------------------------------------------------{CMBN 4}
------------------------------------------------------------------------------
In [114]:
(? f 3 (crpr 2 7 1 (loop3 2 (+ 32 64 128) -2 4 (+ 32 64 128) 2)))
Out[114]:
----------------------------------------------------------------------{CMBN 3}
<1 * <TnPr 0 1 3 <<Loop[2-1-0 3][2-1 7][2-0 224\-2][3-0 224\2]>>>>
------------------------------------------------------------------------------
In [115]:
(? chi-t *)
Out[115]:
----------------------------------------------------------------------{CMBN 4}
<1 * <TnPr 2 7 2 <<Loop[1 224\-2][2 224\2]>>>>
------------------------------------------------------------------------------
In [116]:
(? f 3 (crpr 2 7 4 (loop3 2 (+ 32 64 128) -2 1 (+ 32 64 128) 2)))
Out[116]:
----------------------------------------------------------------------{CMBN 3}
------------------------------------------------------------------------------
In [117]:
(? chi-t *)
Out[117]:
----------------------------------------------------------------------{CMBN 4}
------------------------------------------------------------------------------
In [118]:
(? f 3 (crpr 1 7 2 (loop3 2 (+ 32 64 128) 2 4 (+ 32 64 128) -2)))
Out[118]:
----------------------------------------------------------------------{CMBN 3}
<-1 * <TnPr 0 1 3 <<Loop[2-1-0 3][1-0 7][2-1 224\2][3-2 224\-2]>>>>
<1 * <TnPr 0 1 3 <<Loop[2-1-0 3][2-0 7][2-1 224\2][3-1 224\-2]>>>>
------------------------------------------------------------------------------
In [119]:
(? chi-t *)
Out[119]:
----------------------------------------------------------------------{CMBN 4}
------------------------------------------------------------------------------
In [120]:
(? f 3 (crpr 4 7 2 (loop3 2 (+ 32 64 128) 2 1 (+ 32 64 128) -2)))
Out[120]:
----------------------------------------------------------------------{CMBN 3}
<1 * <TnPr 0 1 3 <<Loop[2-1-0 3][1-0 7][2-1 224\2][2-0 224\-2]>>>>
<-1 * <TnPr 0 1 3 <<Loop[2-1-0 3][2-0 7][2-1 224\2][1-0 224\-2]>>>>
<1 * <TnPr 2 7 1 <<Loop[0 192\2][224\-2]>>>>
------------------------------------------------------------------------------
In [121]:
(? chi-t *)
Out[121]:
----------------------------------------------------------------------{CMBN 4}
------------------------------------------------------------------------------
In [122]:
(? f 3 (crpr 1 7 2 (loop3 2 (+ 32 64 128) -2 4 (+ 32 64 128) 2)))
Out[122]:
----------------------------------------------------------------------{CMBN 3}
<-1 * <TnPr 0 1 3 <<Loop[2-1-0 3][1-0 7][2-1 224\-2][3-2 224\2]>>>>
<1 * <TnPr 0 1 3 <<Loop[2-1-0 3][2-0 7][2-1 224\-2][3-1 224\2]>>>>
------------------------------------------------------------------------------
In [123]:
(? chi-t *)
Out[123]:
----------------------------------------------------------------------{CMBN 4}
------------------------------------------------------------------------------
In [124]:
(? f 3 (crpr 4 7 2 (loop3 2 (+ 32 64 128) -2 1 (+ 32 64 128) 2)))
Out[124]:
----------------------------------------------------------------------{CMBN 3}
<1 * <TnPr 0 1 3 <<Loop[2-1-0 3][1-0 7][2-1 224\-2][2-0 224\2]>>>>
<-1 * <TnPr 0 1 3 <<Loop[2-1-0 3][2-0 7][2-1 224\-2][1-0 224\2]>>>>
<1 * <TnPr 2 7 1 <<Loop[0 192\-2][224\2]>>>>
------------------------------------------------------------------------------
In [125]:
(? chi-t *)
Out[125]:
----------------------------------------------------------------------{CMBN 4}
------------------------------------------------------------------------------

We verify now the required property of the homotopy operator $\chi_{\times\tau}$. As usual, we build by composition a morphism zero.

In [126]:
(def dfr (bndr (twisted-crts-prdc delta)))
Out[126]:
[K135 Morphism (degree -1): K134 -> K134]
In [127]:
(def zero (i-sbtr (idnt-mrph (sorc dfr)) (cmps dfr chi-x) 
                   (cmps chi-x dfr)))
Out[127]:
[K201 Morphism (degree 0): K134 -> K134]
In [128]:
(def simplx (crpr 4 7 2 (loop3 2 (+ 32 64 128) -2 1 (+ 32 64 128) 2)))
Out[128]:
<CrPr 2 7 1 <<Loop[1 224\-2][0 224\2]>>>
In [129]:
(? zero 3 simplx)
Out[129]:
----------------------------------------------------------------------{CMBN 3}
------------------------------------------------------------------------------

Then, we do the same test for the homotopy operator $\chi_{\otimes t}$.

In [130]:
(def tw (twisted-tnsr-prdc d))
Out[130]:
[K160 Chain-Complex]
In [131]:
(def zero-2  (i-sbtr (idnt-mrph tw) (cmps tw chi-t) (cmps chi-t tw)))
Out[131]:
[K206 Morphism (degree 0): K160 -> K160]
In [132]:
(def simpx2 (tnpr 0 1 3 (loop3 0 (mask 5) 2 0 (* 32 (mask 5)) -1)))
Out[132]:
<TnPr 0 1 3 <<Loop[31\2][992\-1]>>>
In [133]:
(time (? zero-2 3 simpx2))
Out[133]:
----------------------------------------------------------------------{CMBN 3}
------------------------------------------------------------------------------

Note nevertheless that the relation is not satisfied for the base generator $*\otimes *$, namely the tensor product of both base generators. This is due to the fact that both contractions, $\chi_{\times t}$ and $\chi_{\otimes t}$, correspond to reductions over $\mathbb{Z}$ and not on 0.

In [134]:
(def gnrt-0 (tnpr 0 1 0 +null-loop+))
Out[134]:
<TnPr 0 1 0 <<Loop>>>
In [135]:
(? zero-2 0 gnrt-0)
Out[135]:
----------------------------------------------------------------------{CMBN 0}
<1 * <TnPr 0 1 0 <<Loop>>>>
------------------------------------------------------------------------------

Let us build, for instance, the reduction of the twisted tensor product over $\mathbb{Z}$ and check it. In that case, the two homomorphisms $f$ and $g$ are respectively the augmentation and coaugmentation morphisms. $$ \begin{aligned} {{\cal C}_*(B) \otimes_t {\cal C}_*(GB)} & \qquad\stackrel{\chi_{\otimes t}}{\longrightarrow} & {}^s{{\cal C}_*(B) \otimes_t {\cal C}_*(GB)} \cr {\scriptstyle aug} \downarrow \uparrow {\scriptstyle coaug}\quad & & \cr {{\cal C}_*(\mathbb{Z})} \qquad& & \cr \end{aligned} $$ We recall that, the unit chain complex corresponding to $\mathbb{Z}$ is built by the function z-chcm. The unique generator in degree 0 is :z-gnrt.

In [136]:
(def aug (build-mrph
            :sorc tw 
            :trgt (z-chcm) 
            :degr 0
            :intr #'(lambda (degr gnrt)
                       (if (zerop degr)
                           (term-cmbn 0 1 :z-gnrt)
                           (zero-cmbn degr)))
            :strt :gnrt 
            :orgn '(aug tw)))

SIMPLE-STYLE-WARNING: 
  #<SB-INT:SIMPLE-STYLE-WARNING "The variable ~S is defined but never used." {10052B6D53}>
Out[136]:
[K209 Cohomology-Class on K160 of degree 0]
In [137]:
(def coaug (build-mrph
              :sorc (z-chcm) 
              :trgt tw 
              :degr 0
              :intr #'(lambda (degr gnrt)
                         (if (zerop degr)
                             (term-cmbn 0 1 (tnpr 0 1 0 +null-loop+))
                             (zero-cmbn degr)))
              :strt :gnrt
              :orgn '(coaug tw)))

SIMPLE-STYLE-WARNING: 
  #<SB-INT:SIMPLE-STYLE-WARNING "The variable ~S is defined but never used." {10053C9373}>
Out[137]:
[K210 Morphism (degree 0): K207 -> K160]
In [138]:
(def rdct (build-rdct :f aug 
                       :g coaug 
                       :h Chi-t 
                       :orgn '(reduction-tw-Z)))
Out[138]:
[K211 Reduction K160 => K207]
In [139]:
(pre-check-rdct rdct)

---done---
Out[139]:
NIL
In [140]:
(setf *tc* (cmbn 3 1 (tnpr 1 3 2 (loop3 0 15 2))))
Out[140]:
----------------------------------------------------------------------{CMBN 3}
<1 * <TnPr 1 3 2 <<Loop[15\2]>>>>
------------------------------------------------------------------------------
In [141]:
(setf *bc* (cmbn 0 1 :z-gnrt))
Out[141]:
----------------------------------------------------------------------{CMBN 0}
<1 * Z-GNRT>
------------------------------------------------------------------------------
In [142]:
(check-rdct-no-wait)

*TC* => 
----------------------------------------------------------------------{CMBN 3}
<1 * <TnPr 1 3 2 <<Loop[15\2]>>>>
------------------------------------------------------------------------------

*BC* => 
----------------------------------------------------------------------{CMBN 0}
<1 * Z-GNRT>
------------------------------------------------------------------------------

Checking *TDD* = 0
Result: 
----------------------------------------------------------------------{CMBN 1}
------------------------------------------------------------------------------

Checking *BDD* = 0
Result: 
----------------------------------------------------------------------{CMBN -2}
------------------------------------------------------------------------------

Checking *DF-FD* = 0
Result: 
----------------------------------------------------------------------{CMBN 2}
------------------------------------------------------------------------------

Checking *DG-GD* = 0
Result: 
----------------------------------------------------------------------{CMBN -1}
------------------------------------------------------------------------------

Checking *ID-FG* = 0
Result: 
----------------------------------------------------------------------{CMBN 0}
------------------------------------------------------------------------------

Checking *ID-GF-DH-HD* = 0
Result: 
----------------------------------------------------------------------{CMBN 3}
------------------------------------------------------------------------------

Checking *HH* = 0
Result: 
----------------------------------------------------------------------{CMBN 5}
------------------------------------------------------------------------------

Checking *FH* = 0
Result: 
----------------------------------------------------------------------{CMBN 4}
------------------------------------------------------------------------------

Checking *HG* = 0
Result: 
----------------------------------------------------------------------{CMBN 1}
------------------------------------------------------------------------------

---done---
Out[142]:
NIL

An unproved property of the algebraic Kan contraction

Since the early version of the software (1990), and through a host of examples, an amazing algebraic property of the Kan contraction $\chi_{\otimes t}$ has been experimentally discovered. Many computations have been done of $\chi_{\otimes t}(b \otimes g)$, for various choices of $b \otimes g$ and in all these cases, as soon as $degree(b) > 0$, then the result is null. In other words, $\chi_{\otimes t}$ is null outside the base fiber. Up to now, no actual proof of this result has yet been given.

We show that, using the "soft" version of $\bar{\Delta}$.

In [143]:
(def db (soft-deltab))
Out[143]:
[K1 Simplicial-Set]
In [144]:
(def tt (tnpr-contraction db))
Out[144]:
[K231 Morphism (degree 1): K88 -> K88]
In [145]:
(def gnrt1 (tnpr 3 (code '(0 1 2 3 4)) 
                 4 (loop3 0 (code '(0 1 2 3 4 5)) 2)))
Out[145]:
<TnPr 3 (DELT . 31) 4 <<Loop[(DELT . 63)\2]>>>
In [146]:
(? tt 7 gnrt1)
Out[146]:
----------------------------------------------------------------------{CMBN 8}
------------------------------------------------------------------------------
In [147]:
(def gnrt2 (tnpr 4 (code '(2 4 6 8 10 12))  
                  5 (loop3 0 (code '(1 3 5 7 9 11 13)) 5)))
Out[147]:
<TnPr 4 (DELT . 5460) 5 <<Loop[(DELT . 10922)\5]>>>
In [148]:
(? tt 9 gnrt2)
Out[148]:
----------------------------------------------------------------------{CMBN 10}
------------------------------------------------------------------------------

But if $degree(b) = 0$, then the result is non-null in general.

In [149]:
(? tt 2 (tnpr 0 (code '(0)) 2 (loop3 0 (code '(0 1 2 3)) 1)))
Out[149]:
----------------------------------------------------------------------{CMBN 3}
<-1 * <TnPr 0 (DELT . 1) 3 <<Loop[2-1-0 (DELT . 3)][1-0 (DELT . 7)][2 (DELT . 15)]>>>>
<1 * <TnPr 0 (DELT . 1) 3 <<Loop[2-1-0 (DELT . 3)][2-0 (DELT . 7)][1 (DELT . 15)]>>>>
<1 * <TnPr 1 (DELT . 5) 2 <<Loop[(DELT . 15)]>>>>
<-1 * <TnPr 2 (DELT . 7) 1 <<Loop[(DELT . 14)]>>>>
<-1 * <TnPr 3 (DELT . 15) 0 <<Loop>>>>
------------------------------------------------------------------------------
In [150]:
(? tt 4 (tnpr 0 (code '(0)) 4 (loop3 0 (code '(1 2 3 4 5 6)) 3)))
Out[150]:
----------------------------------------------------------------------{CMBN 5}
<1 * <TnPr 0 (DELT . 2) 5 <<Loop[4-3-2-1-0 (DELT . 6)][3-2-1-0 (DELT . 14)][4-2-1-0 (DELT . 26)][4-3-1-0 (DELT . 50)][4-3-2 (DELT . 114)]>>>>
<1 * <TnPr 0 (DELT . 2) 5 <<Loop[4-3-2-1-0 (DELT . 6)][3-2-1-0 (DELT . 14)][4-2-1-0 (DELT . 26)][4-3-1-0 (DELT . 50)][4-3-2 (DELT . 114)\2]>>>>
<1 * <TnPr 0 (DELT . 2) 5 <<Loop[4-3-2-1-0 (DELT . 6)][3-2-1-0 (DELT . 14)][4-2-1-0 (DELT . 26)][4-3-1-0 (DELT . 50)][4-3-2 (DELT . 114)\3]>>>>
<-1 * <TnPr 0 (DELT . 2) 5 <<Loop[4-3-2-1-0 (DELT . 6)][3-2-1-0 (DELT . 14)][4-2-1-0 (DELT . 26)][4-3-1-0 (DELT . 50)][4-3-2-0 (DELT . 98)][4-3-2-1 (DELT . 98)]>>>>
<-1 * <TnPr 0 (DELT . 2) 5 <<Loop[4-3-2-1-0 (DELT . 6)][3-2-1-0 (DELT . 14)][4-2-1-0 (DELT . 26)][4-3-1-0 (DELT . 50)][4-3-2-0 (DELT . 98)][4-3-2-1 (DELT . 98)\2]>>>>
<-1 * <TnPr 0 (DELT . 2) 5 <<Loop[4-3-2-1-0 (DELT . 6)][3-2-1-0 (DELT . 14)][4-2-1-0 (DELT . 26)][4-3-1-0 (DELT . 82)][4-3-2 (DELT . 114)]>>>>
<-1 * <TnPr 0 (DELT . 2) 5 <<Loop[4-3-2-1-0 (DELT . 6)][3-2-1-0 (DELT . 14)][4-2-1-0 (DELT . 26)][4-3-1-0 (DELT . 82)][4-3-2 (DELT . 114)\2]>>>>
<1 * <TnPr 0 (DELT . 2) 5 <<Loop[4-3-2-1-0 (DELT . 6)][3-2-1-0 (DELT . 14)][4-2-1-0 (DELT . 26)][4-3-2-0 (DELT . 50)][4-3-0 (DELT . 114)][4-3-2-1 (DELT . 98)]>>>>
<1 * <TnPr 0 (DELT . 2) 5 <<Loop[4-3-2-1-0 (DELT . 6)][3-2-1-0 (DELT . 14)][4-2-1-0 (DELT . 26)][4-3-2-0 (DELT . 50)][4-3-0 (DELT . 114)][4-3-2-1 (DELT . 98)\2]>>>>
<-1 * <TnPr 0 (DELT . 2) 5 <<Loop[4-3-2-1-0 (DELT . 6)][3-2-1-0 (DELT . 14)][4-2-1-0 (DELT . 26)][4-3-2-0 (DELT . 50)][4-3-1 (DELT . 114)]>>>>
... ...
------------------------------------------------------------------------------
In [151]:
(length *)

TYPE-ERROR: 
  #<TYPE-ERROR expected-type: SEQUENCE datum: 
----------------------------------------------------------------------{CMBN 5}
<1 * <TnPr 0 (DELT . 2) 5 <<Loop[4-3-2-1-0 (DELT . 6)][3-2-1-0 (DELT . 14)][4-2-1-0 (DELT ..)][4-3-1-0 (DELT ..)][4-3-2 (DELT ..)]>>>>
<1 * <TnPr 0 (DELT . 2) 5 <<Loop[4-3-2-1-0 (DELT . 6)][3-2-1-0 (DELT . 14)][4-2-1-0 (DELT ..)][4-3-1-0 (DELT ..)][4-3-2 (DELT ..)\2]>>>>
<1 * <TnPr 0 (DELT . 2) 5 <<Loop[4-3-2-1-0 (DELT . 6)][3-2-1-0 (DELT . 14)][4-2-1-0 (DELT ..)][4-3-1-0 (DELT ..)][4-3-2 (DELT ..)\3]>>>>
<-1 * <TnPr 0 (DELT . 2) 5 <<Loop[4-3-2-1-0 (DELT . 6)][3-2-1-0 (DELT . 14)][4-2-1-0 (DELT ..)][4-3-1-0 (DELT ..)][4-3-2-0 (DELT ..)][4-3-2-1 (DELT ..)]>>>>
<-1 * <TnPr 0 (DELT . 2) 5 <<Loop[4-3-2-1-0 (DELT . 6)][3-2-1-0 (DELT . 14)][4-2-1-0 (DELT ..)][4-3-1-0 (DELT ..)][4-3-2-0 (DELT ..)][4-3-2-1 (DELT ..)\2]>>>>
<-1 * <TnPr 0 (DELT . 2) 5 <<Loop[4-3-2-1-0 (DELT . 6)][3-2-1-0 (DELT . 14)][4-2-1-0 (DELT ..)][4-3-1-0 (DELT ..)][4-3-2 (DELT ..)]>>>>
<-1 * <TnPr 0 (DELT . 2) 5 <<Loop[4-3-2-1-0 (DELT . 6)][3-2-1-0 (DELT . 14)][4-2-1-0 (DELT ..)][4-3-1-0 (DELT ..)][4-3-2 (DELT ..)\2]>>>>
<1 * <TnPr 0 (DELT . 2) 5 <<Loop[4-3-2-1-0 (DELT . 6)][3-2-1-0 (DELT . 14)][4-2-1-0 (DELT ..)][4-3-2-0 (DELT ..)][4-3-0 (DELT ..)][4-3-2-1 (DELT ..)]>>>>
<1 * <TnPr 0 (DELT . 2) 5 <<Loop[4-3-2-1-0 (DELT . 6)][3-2-1-0 (DELT . 14)][4-2-1-0 (DELT ..)][4-3-2-0 (DELT ..)][4-3-0 (DELT ..)][4-3-2-1 (DELT ..)\2]>>>>
<-1 * <TnPr 0 (DELT . 2) 5 <<Loop[4-3-2-1-0 (DELT . 6)][3-2-1-0 (DELT . 14)][4-2-1-0 (DELT ..)][4-3-2-0 (DELT ..)][4-3-1 (DELT ..)]>>>>
... ...
------------------------------------------------------------------------------
>
Out[151]:
NIL

Lisp file concerned in this chapter

ls-twisted-products.lisp.