diff --git a/examples/anromero/bousfield-kan/gamma.lsp b/examples/anromero/bousfield-kan/gamma.lsp
new file mode 100644
index 0000000..2d1b67e
--- /dev/null
+++ b/examples/anromero/bousfield-kan/gamma.lsp
@@ -0,0 +1,1107 @@
+;; GAMMA GAMMA GAMMA GAMMA GAMMA GAMMA GAMMA
+;; GAMMA GAMMA GAMMA GAMMA GAMMA GAMMA GAMMA
+;; GAMMA GAMMA GAMMA GAMMA GAMMA GAMMA GAMMA
+
+(IN-PACKAGE "COMMON-LISP-USER")
+
+(provide "gamma")
+
+
+;; TYPES
+
+(DEFUN SGM-P (object)
+   ;; SGM = SiGMa   
+   (declare (type any object))
+   (the boolean
+     (and (consp object)
+          (typep (car object) 'fixnum)
+          (typep (cdr object) 'cmbn))))
+
+(DEFTYPE SGM () '(satisfies sgm-p))
+
+(DEFUN IGAMMA-P (object)
+   ;; IGAMMA = Internal GAMMA,
+   ;;   without the keyword and the degree
+   (declare (type any object))
+   (the boolean
+     (and (listp object)
+          (every #'sgm-p object)))) 
+
+(DEFTYPE IGAMMA () '(satisfies igamma-p))
+
+(DEFUN GAMMA-P (object)
+   (declare (type any object))
+   (the boolean
+     (and (consp object)
+          (eql (car object) :gamma)
+          (consp (cdr object))
+          (typep (second object) 'fixnum)
+          (typep (cddr object) 'igamma))))
+
+(DEFTYPE GAMMA () '(satisfies gamma-p))
+
+
+
+;; MACROS
+
+(DEFMACRO SGM (sgop cmbn)
+   `(cons ,sgop ,cmbn))
+
+(DEFMACRO -SGM (mark)
+   `(car ,mark))
+
+(DEFMACRO SGOP (sgm)
+   `(car ,sgm))
+
+(DEFMACRO -SGOP (mark)
+   `(caar ,mark))
+
+(DEFMACRO SGCM (sgm)
+   `(cdr ,sgm))
+
+(DEFMACRO -SGCM (mark)
+   `(cdar ,mark))
+
+(DEFMACRO WITH-SGM ((sgop-var sgcm-var) sgm . body)
+   `(let ((,sgop-var (sgop ,sgm))
+          (,sgcm-var (sgcm ,sgm)))
+       (declare
+          (fixnum ,sgop-var)
+          (type cmbn ,sgcm-var))
+       ,@body))
+
+(DEFMACRO WITH--SGM ((sgop-var sgcm-var) mark . body)
+   `(let ((,sgop-var (-sgop ,mark))
+          (,sgcm-var (-sgcm ,mark)))
+       (declare
+          (fixnum ,sgop-var)
+          (type cmbn ,sgcm-var))
+       ,@body))
+
+(DEFMACRO SGM-NON-ZERO-P (sgm)
+   `(cmbn-non-zero-p (sgcm ,sgm)))
+
+(DEFMACRO SGM-ZERO-P (sgm)
+  `(cmbn-zero-p (sgcm ,sgm)))
+
+(DEFMACRO MAKE-GAMMA (&key degr list)
+   `(cons :gamma
+       (cons ,degr ,list)))
+
+(DEFMACRO GAMMA-DEGR (gmm)
+   `(cadr ,gmm))
+
+(DEFMACRO GAMMA-LIST (gmm)
+   `(cddr ,gmm))
+
+(DEFMACRO WITH-GAMMA ((degr list) gmm . body)
+   `(let ((,degr (gamma-degr ,gmm))
+          (,list (gamma-list ,gmm)))
+       (declare
+          (fixnum ,degr)
+          (list ,list))
+       ,@body))
+
+(DEFMACRO SGM-GAMMA (degr sgop sgcm)
+   `(cons :gamma (cons ,degr (cons (cons ,sgop ,sgcm) nil))))
+
+(DEFMACRO GAMMA-NON-ZERO-P (gmm)
+   `(gamma-list ,gmm)) 
+
+(DEFMACRO GAMMA-ZERO-P (gmm)
+  `(null (gamma-list ,gmm)))
+
+
+#|(DEFMETHOD PRINT-KEYCONS ((key (eql :sgm)) cdr stream)
+   (setf cdr (cons :sgm cdr))
+   (format stream
+      "<Sgm ~A ~A>"
+      (hyphenize-list (dgop-int-ext (sgop cdr)))
+      (sgcm cdr))
+   cdr)
+|#
+
+
+;; METHODS
+
+(DEFMETHOD PRINT-KEYCONS ((key (eql :gamma)) cdr stream)
+   (declare
+    (list cdr)
+    (stream stream))
+   (the (eql t)
+     (let ((degr (first cdr))
+           (list (rest cdr)))
+        (declare
+         (fixnum degr)
+         (list list))
+        (format stream "<GAMMA ~D" degr)
+        (do ((mark list (cdr mark))
+             (nth 0 (1+ nth)))
+            ((endp mark))
+           (declare
+            (list mark)
+            (fixnum nth))
+           (when (and *print-length* (= nth *print-length*))
+              (format stream "~%... ...")
+              (return))
+           (format stream "~%  <~D  ~A  >" (hyphenize-list (dgop-int-ext (sgop (car mark)))) (sgcm (car mark))))
+        (format stream "~%>" )
+        t)))
+
+
+;; ELEMENTARY OPERATIONS WITH GAMMA ELEMENTS
+ 
+(DEFUN GAMMA-ELT (degr &rest rest)
+   (declare (fixnum degr))
+   (the gamma
+     (let ((rslt (list degr :gamma)))
+        (do ((mark rest (cddr mark)))
+            ((endp mark) (nreverse rslt))
+           (declare (list mark))
+           (push (sgm (car mark) (cadr mark)) rslt)))))
+
+(DEFUN CHECK-GAMMA (gmm)
+  (declare
+   (type gamma gmm))
+  (the boolean
+    (with-gamma (degr glist) gmm
+      (declare
+       (fixnum degr)
+       (list glist))
+      (do ((mark2 glist mark1)
+           (mark1 (rest glist) (cdr mark1)))
+          ((endp mark1) t)
+         (declare
+          (list mark1 mark2))
+         (unless (= degr (+ (length (dgop-int-ext (-sgop mark2))) (cmbn-degr (-sgcm mark2))))
+            (error "In CHECK-GAMMA, bad degre; the element:~@
+                ~A~@
+                has a degree different to:~@
+                ~A."
+	       (-sgm mark2) degr))
+         (unless (< (-sgop mark2) (-sgop mark1))
+            (error "In CHECK-GAMMA, bad order; the degeneracy operator:~@
+                ~A~@
+                is not less than the degeneracy operator:~@
+                ~A."
+              (dgop-int-ext (-sgop mark2)) (dgop-int-ext (-sgop mark1))))))))
+
+#|
+(setf g1 (gamma-elt 5 3 (cmbn 3 8 'a) 1 (cmbn 4 3 'b)))
+(check-gamma g1)
+(setf g2 (gamma-elt 5 3 (cmbn 4 3 'b) 1 (cmbn 3 8 'a)))
+(check-gamma g2)
+(setf g3 (gamma-elt 5 1 (cmbn 4 3 'b) 3 (cmbn 3 8 'a)))
+(check-gamma g3)
+(setf g4 (gamma-elt 5))
+(check-gamma g4)
+|#
+
+(DEFUN ZERO-GAMMA (degr)
+   (declare (fixnum degr))
+   (the gamma
+     (make-gamma
+      :degr degr
+      :list +empty-list+)))
+
+#|
+(setf g0 (zero-gamma 3))
+(check-gamma g0) 
+|#
+
+(DEFUN GAMMA-OPPS (gmm)
+   (declare (type gamma gmm))
+   (the gamma
+      (with-gamma (degr glist) gmm
+         (make-gamma
+            :degr degr
+            :list (mapcar #'(lambda (sgm)
+                               (declare (type sgm sgm))
+                               (with-sgm (sgop cmbn) sgm
+                                  (sgm sgop (cmbn-opps cmbn))))
+                     glist)))))
+
+#|
+(setf g (gamma-elt 5 1 (cmbn 4 3 'b 8 'c) 3 (cmbn 3 8 'a -9 'b)))
+(gamma-opps g)
+|# 
+
+(DEFUN 2GAMMA-ADD (cmpr gmm1 gmm2)
+   (declare
+    (type cmprf cmpr)
+    (type gamma gmm1 gmm2))
+   (the gamma
+     (with-gamma (degr1 list1) gmm1
+       (with-gamma (degr2 list2) gmm2
+         (declare
+          (fixnum degr1 degr2)
+          (list list1 list2))
+         (unless (= degr1 degr2)
+            (error "In 2GAMMA-ADD, the gamma elements have different degrees ~D and ~D."
+              degr1 degr2))
+         (unless list1
+            (return-from 2gamma-add gmm2))
+         (unless list2
+            (return-from 2gamma-add gmm1))
+         (let ((pre-rslt +empty-list+))
+            (declare (list pre-rslt))
+            (do ((mark1 list1)
+                 (mark2 list2))
+                ((or (endp mark1) (endp mark2))
+                 (if mark1
+                    (setf pre-rslt (nreconc pre-rslt mark1))
+                    (if mark2
+                       (setf pre-rslt (nreconc pre-rslt mark2))
+                       (setf pre-rslt (nreverse pre-rslt)))))
+               (declare (list mark1 mark2))
+               (with--sgm (sgop1 cmbn1) mark1
+                 (with--sgm (sgop2 cmbn2) mark2
+                   (declare 
+                     (fixnum sgop1 sgop2)
+                     (type cmbn cmbn1 cmbn2))
+                   (if (= sgop1 sgop2)
+                      (let ((cmbn (2cmbn-add cmpr cmbn1 cmbn2)))
+                         (declare (type cmbn cmbn))
+                         (unless (cmbn-zero-p cmbn)
+                            (push (sgm sgop1 cmbn) pre-rslt))
+                         (setf mark1 (cdr mark1)
+                               mark2 (cdr mark2)))
+                      (if (< sgop1 sgop2)
+                         (progn
+                          (push (-sgm mark1) pre-rslt)
+                          (setf mark1 (cdr mark1)))
+                         (progn
+                          (push (-sgm mark2) pre-rslt)
+                          (setf mark2 (cdr mark2))))))))
+            (make-gamma :degr degr1 :list pre-rslt))))))
+
+#|
+(setf g1 (gamma-elt 5 1 (cmbn 4 3 'b -5 'd) 3 (cmbn 3 8 'a -7 'c)))
+(setf g2 (gamma-elt 5 0 (cmbn 5 3 'a 8 'c) 1 (cmbn 4 2 'b 9 'c) 
+           2 (cmbn 4 -5 'a) 3 (cmbn 3 -4 'a 8 'b)))
+(setf g3 (2GAMMA-ADD #'s-cmpr g1 g2))
+(setf g4 (gamma-elt 5 0 (cmbn 5 -3 'a -8 'c) 1 (cmbn 4 -2 'b 8 'c)
+           3 (cmbn 3 5 'a -8 'b 7 'c)))
+(setf g5 (2GAMMA-ADD #'s-cmpr g3 g4))
+(setf g6 (gamma-elt 5 1 (cmbn 4 -3 'b -17 'c 5 'd) 2 (cmbn 4 5 'a) 3 (cmbn 3 -9 'a)))
+(2GAMMA-ADD #'s-cmpr g5 g6)
+|#  
+
+(defun ADD-SGM-TO-GAMMA (cmpr sgm gmm)
+   (declare
+    (type cmprf cmpr)
+    (type sgm sgm)
+    (type gamma gmm))
+   (the gamma
+     (with-sgm (sgop sgcm) sgm
+       (declare 
+         (fixnum sgop)
+         (type cmbn sgcm))
+       (with-gamma (degr glist) gmm
+         (declare 
+           (fixnum degr)
+           (list glist))
+         (let ((pre-rslt +empty-list+))
+            (declare (list pre-rslt))
+            (do ((mark glist (cdr mark)))
+                ((or (endp mark) (equal nil sgop))
+                 (if sgop
+                  (progn
+                   (push sgm pre-rslt)
+                   (setf pre-rslt (nreverse pre-rslt)))
+                    (setf pre-rslt (nreconc pre-rslt mark))))
+               (declare (list mark))
+               (with--sgm (sgop2 sgcm2) mark
+                 (declare 
+                   (fixnum sgop2)
+                   (type cmbn sgcm2))
+                 (if (= sgop sgop2)
+                    (let ((cmbn (2cmbn-add cmpr sgcm sgcm2)))
+                       (declare (type cmbn cmbn))
+                       (unless (cmbn-zero-p cmbn)
+                          (push (sgm sgop cmbn) pre-rslt))
+                       (setf sgop nil))
+                    (if (< sgop sgop2)
+                       (progn 
+                         (push sgm pre-rslt)
+                         (setf sgop nil)
+                         (push (-sgm mark) pre-rslt))
+                       (push (-sgm mark) pre-rslt)))))
+            (make-gamma :degr degr :list pre-rslt))))))
+
+ #|
+(setf g1 (gamma-elt 5 1 (cmbn 4 3 'b -5 'd) 3 (cmbn 3 8 'a -7 'c)))
+(setf g2 (add-sgm-to-gamma cmpr (sgm 7 (cmbn 2 -8 'd)) g1))
+(setf g3 (add-sgm-to-gamma cmpr (sgm 7 (cmbn 2 8 'd)) g2))
+(setf g4 (add-sgm-to-gamma cmpr (sgm 3 (cmbn 3 -8 'a 7 'c 8 'd)) g2))
+(setf g5 (add-sgm-to-gamma cmpr (sgm 11 (cmbn 2 9 'a )) g4))
+(setf g6 (add-sgm-to-gamma cmpr (sgm 9 (cmbn 3 8 'b)) g5))
+(setf g7 (add-sgm-to-gamma cmpr (sgm 9 (cmbn 3 -8 'b 8 'c)) g6))
+(setf g8 (add-sgm-to-gamma cmpr (sgm 9 (cmbn 3 -8 'b )) g6))
+|# 
+
+(DEFUN NSGM-ADD (cmpr degr &rest rest)
+   (declare
+      (type cmprf cmpr)
+      (fixnum degr)
+      (list rest))
+   (unless rest
+      (return-from nsgm-add (zero-gamma degr)))
+   (the gamma
+      (let ((rslt (list (first rest))))
+         (declare (list rslt))
+         (dolist (sgm (rest rest))
+            (declare (type sgm sgm))
+            (with-sgm  (sgop sgcm) sgm
+               (do ((mark1 rslt (cdr mark1))
+                    (mark2 nil mark1))
+                   ((endp mark1) 
+                    (setf (cdr mark2) (list sgm)))
+                  (ecase (funcall #'f-cmpr sgop (-sgop mark1))
+                     (:less
+                      (if mark2
+                         (push sgm (cdr mark2))
+                         (push sgm rslt))
+                      (return))                     
+                     (:equal
+                      (let ((cmbn2 (2cmbn-add cmpr (-sgcm mark1) sgcm)))
+                         (setf (-sgcm mark1) cmbn2))
+                      (return))                     
+                     (:greater )))))
+         (make-gamma
+          :degr degr
+          :list (flet ((sgm-zero-p (sgm)
+                        (let ((sgcm (sgcm sgm)))
+                           (cmbn-zero-p sgcm))))
+                  (remove-if #'sgm-zero-p rslt))))))
+
+ #|
+(setf cmpr #'s-cmpr)
+(setf degr 5)
+(progn 
+  (setf sgm1 (sgm 7 (cmbn 2 3 'a 5 'b)))
+  (setf sgm2 (sgm 4 (cmbn 4 7 'a 8 'c)))
+  (setf sgm3 (sgm 12 (cmbn 3 -5 'a 8 'b)))
+  (setf sgm4 (sgm 4 (cmbn 4 -7 'a 9 'c 12 'd)))
+  (setf sgm5 (sgm 6 (cmbn 3 8 'a)))
+  (setf sgm6 (sgm 12 (cmbn 3 6 'a)))
+  (nsgm-add cmpr degr sgm1 sgm2 sgm3 sgm4 sgm5 sgm6))
+
+(progn 
+  (setf sgm1 (sgm 7 (cmbn 2 3 'a 5 'b)))
+  (setf sgm2 (sgm 4 (cmbn 4 7 'a 8 'c)))
+  (setf sgm3 (sgm 12 (cmbn 3 -5 'a 8 'b)))
+  (setf sgm4 (sgm 4 (cmbn 4 -7 'a 9 'c 12 'd)))
+  (setf sgm5 (sgm 6 (cmbn 3 8 'a)))
+  (setf sgm6 (sgm 12 (cmbn 3 6 'a)))
+  (setf sgm7 (sgm 12 (cmbn 3 -6 'a)))
+  (nsgm-add cmpr degr sgm1 sgm2 sgm3 sgm4 sgm5 sgm6 sgm7))
+
+(progn 
+  (setf sgm1 (sgm 7 (cmbn 2 3 'a 5 'b)))
+  (setf sgm2 (sgm 4 (cmbn 4 7 'a 8 'c)))
+  (setf sgm3 (sgm 12 (cmbn 3 -5 'a 8 'b)))
+  (setf sgm4 (sgm 4 (cmbn 4 -7 'a 9 'c 12 'd)))
+  (setf sgm5 (sgm 6 (cmbn 3 8 'a)))
+  (setf sgm6 (sgm 12 (cmbn 3 6 'a)))
+  (setf sgm7 (sgm 7 (cmbn 2 -3 'a -5 'b)))
+  (nsgm-add cmpr degr sgm1 sgm2 sgm3 sgm4 sgm5 sgm6 sgm7))
+
+(progn 
+  (setf sgm1 (sgm 7 (cmbn 2 3 'a 5 'b)))
+  (setf sgm2 (sgm 7 (cmbn 2 -3 'a -5 'b)))
+  (nsgm-add cmpr degr sgm1 sgm2))
+
+|#  
+
+
+(DEFUN SGM-NDGNR (dgop sgm)
+   (declare
+      (fixnum dgop)
+      (type sgm sgm))
+   (the sgm
+      (with-sgm (sgop sgcm) sgm
+         (sgm (dgop*dgop dgop sgop) sgcm)))) 
+
+#|
+(setf sgm (sgm 5 (cmbn 2 5 'a)))
+(sgm-ndgnr 2 sgm)
+(sgm-ndgnr 1 sgm)
+(sgm-ndgnr 5 sgm)
+|# 
+
+(DEFUN GAMMA-NDGNR (dgop gmm)
+   (declare
+      (fixnum dgop)
+      (type gamma gmm))
+   (the gamma
+      (with-gamma (degr glist) gmm
+        (let ((pre-rslt (mapcar #'(lambda (sgm)
+                          (sgm-ndgnr dgop sgm))
+                          glist))
+              (degr2 (+ degr (length (dgop-int-ext dgop)))))
+           (make-gamma :degr degr2 :list pre-rslt)))))
+
+#|
+(setf g (gamma-elt 5 3 (cmbn 3 7 'a) 11 (cmbn 2 -4 'b)))
+(gamma-ndgnr 2 g)
+(gamma-ndgnr 8 g)
+(gamma-ndgnr 3 g)
+
+|# 
+        
+
+
+ 
+;; FUNCTIONS FOR THE CONSTRUCTION OF THE SIMPLICIAL ABELIAN GROUP
+;; \GAMMA(C) 
+ 
+(DEFUN GAMMA-TO-ABSM (gmm)
+   (declare (type gamma gmm))
+   (the absm
+     (with-gamma (degr glist) gmm
+       (declare (fixnum degr)
+         (list glist))
+       (if (endp glist)
+          (let ((dgop (dgop-ext-int (reverse (<a-b< 0 degr)))))
+             (declare (fixnum dgop))
+             (absm dgop (gamma-elt 0)))
+          (let* ((sgop-list (mapcar #'(lambda (sgm)
+                                        (sgop sgm))
+                              glist))
+                 (dgop (first sgop-list)))
+             (declare
+              (type list sgop-list)
+              (fixnum dgop))
+             (progn
+              (do ((mark1 (cdr sgop-list) (cdr mark1)))
+                  ((endp mark1))
+                 (declare (list mark1))
+                 (setf dgop (logand dgop (car mark1))))
+              (let* ((degr2 (- degr (length (dgop-int-ext dgop))))
+                     (pre-rslt +empty-list+))
+                 (declare (fixnum degr2)
+                   (type list pre-rslt))
+                 (do ((mark2 glist (cdr mark2)))
+                     ((endp mark2))
+                    (declare (list mark2))
+                    (with--sgm (sgop sgcm) mark2
+                      (declare (fixnum sgop)
+                        (type cmbn sgcm))
+                      (let ((sgop2 sgop))
+                          (declare (fixnum sgop2))
+                         (progn
+                          (do ((indx (1- (integer-length dgop)) (1- indx)))
+                              ((minusp indx))
+                             (declare (fixnum indx))
+                              (when (logbitp indx dgop)
+                                 (setf sgop2 (remove-bit sgop2 indx))))
+                          (push (sgm sgop2 sgcm) pre-rslt)))))
+                 (absm dgop (make-gamma :degr degr2
+                              :list (nreverse pre-rslt))))))))))
+
+
+
+#|
+ (setf gmm (gamma-elt 5 3 (cmbn 3 6 'a) 7 (cmbn 2 -8 'c)))
+(gamma-to-absm gmm)
+
+(setf gmm2 (gamma-elt 5 3 (cmbn 3 6 'a) 7 (cmbn 2 -8 'c) 11 (cmbn 2 6 'a)))
+(gamma-to-absm gmm2)
+|#
+     
+
+(DEFUN CMBN-CMPR (cmpr)
+   (declare (type cmprf cmpr))
+   (flet ((rslt (cmbn1 cmbn2)
+            (declare (type cmbn cmbn1 cmbn2))
+            (let ((degr1 (cmbn-degr cmbn1))
+                  (degr2 (cmbn-degr cmbn2)))
+               (declare (fixnum degr1 degr2))
+               (unless (= degr1 degr2)
+                  (error "In CMBN-CMPR, the two combinations have different degrees ~D and ~D."
+                    degr1 degr2))
+               (flet ((term-cmpr (term1 term2)
+                        (with-term (cffc1 gnrt1) term1
+                          (with-term (cffc2 gnrt2) term2
+                            (declare (fixnum cffc1 cffc2)
+                              (type gnrt gnrt1 gnrt2))
+                            (lexico
+                             (f-cmpr cffc1 cffc2)
+                             (funcall cmpr gnrt1 gnrt2))))))
+                 (maplexico #'term-cmpr (cmbn-list cmbn1) (cmbn-list cmbn2))))))
+     (the cmprf #'rslt)))
+ 
+(DEFUN GAMMA-CMPR (cmpr)
+   (declare (type cmprf cmpr))
+   (let ((c-cmpr (cmbn-cmpr cmpr)))
+      (declare (type cmprf c-cmpr))
+      (flet ((rslt (gmm1 gmm2)
+               (declare (type gamma gmm1 gmm2))
+               (flet ((sgm-cmpr (sgm1 sgm2)
+                       (declare (type sgm sgm1 sgm2))
+                       (with-sgm (sgop1 cmbn1) sgm1
+                         (with-sgm (sgop2 cmbn2) sgm2
+                           (declare
+                            (fixnum sgop1 sgop2)
+                            (type cmbn cmbn1 cmbn2))
+                           (lexico
+                            (f-cmpr sgop1 sgop2)
+                            (funcall c-cmpr cmbn1 cmbn2))))))
+                 (maplexico #'sgm-cmpr (gamma-list gmm1) (gamma-list gmm2)))))
+     (the cmprf #'rslt))))   
+
+#|
+(setf g-cmpr (gamma-cmpr #'s-cmpr))
+(setf g1 (gamma-elt 3 1 (cmbn 2 3 'a) 3 (cmbn 1 5 'b)))
+(setf g2 (gamma-elt 3 1 (cmbn 2 3 'a) 3 (cmbn 1 8 'b)))
+(funcall g-cmpr g1 g2)
+(funcall g-cmpr g2 g1)
+(setf g3 (gamma-elt 3 2 (cmbn 2 3 'a) 3 (cmbn 1 5 'b)))
+(funcall g-cmpr g1 g3)
+(funcall g-cmpr g2 g3)
+(funcall g-cmpr g2 g2)
+(setf g4 (gamma-elt 3 2 (cmbn 2 3 'b) 3 (cmbn 1 5 'b)))
+(funcall g-cmpr g4 g3)
+(setf g5 (gamma-elt 3 2 (cmbn 2 3 'b)))
+(funcall g-cmpr g5 g3)
+(funcall g-cmpr g5 g4)
+|# 
+
+
+
+(defun sgm-face (dffr)
+   (declare (type morphism dffr))
+   (flet ((rslt (indx dmns sgm)
+            (declare 
+              (fixnum indx dmns)
+              (type sgm sgm))
+            (the sgm 
+              (with-sgm (sgop sgcm) sgm
+                (declare 
+                  (fixnum sgop)
+                  (type cmbn sgcm))
+                (let* ((ext-sgop (dgop-int-ext sgop))
+                       (k (length ext-sgop))
+                       (r (- dmns k))
+                       (c-degr (cmbn-degr sgcm)))
+                   (declare
+                    (type list ext-sgop)
+                    (fixnum k r c-degr))
+                   (unless (= r c-degr)
+                      (error "In SGM-FACE, the degree of the Sigma element ~D is different to the degree introduced ~D."
+                        (+ c-degr k) dmns))
+                   (multiple-value-bind (dgop 1dlop) (1dlop-dgop indx sgop)
+                      (declare (fixnum dgop 1dlop))                     
+                      (if (not 1dlop)
+                         (SGM dgop sgcm)
+                         (if (= r 1dlop)
+                          (let ((cmbn (? dffr sgcm)))
+                             (declare (type cmbn cmbn))
+                             (SGM dgop cmbn))
+                            (sgm dgop (cmbn (1- r)))
+                            ))))))))
+     (the face #'rslt)))
+
+
+ 
+(DEFUN GAMMA-FACE (cmpr dffr)
+   (declare 
+     (type cmprf cmpr)
+     (type morphism dffr))
+   (let ((sgm-f (sgm-face dffr)))
+      (flet ((rslt (indx dmns gmsm)
+               (declare
+                (fixnum indx dmns)
+                (type gamma gmsm))
+               (the absm
+                 (let ((pre-rslt nil))
+                    (do ((mark (gamma-list gmsm) (cdr mark)))
+                        ((endp mark) (setf pre-rslt (nreverse pre-rslt)))
+                       (declare 
+                         (type list mark))
+                       (let ((sgm (-sgm mark)))
+                          (let ((sface (funcall sgm-f indx dmns sgm)))
+                             (if (sgm-non-zero-p sface)
+                                (push sface pre-rslt)))))
+                    (gamma-to-absm (apply #'nsgm-add cmpr (1- dmns) pre-rslt))))))
+        (the face #'rslt))))
+
+
+#|
+(setf d3 (delta 3))
+(setf cmpr (cmpr d3))
+(setf dffr (dffr d3))
+
+(setf sface (sgm-face dffr))
+(setf s1 (sgm 3 (cmbn 2 5 7 -8 13)))
+(dotimes (i 5)
+   (print (funcall sface i 4 s1)))
+
+(setf s2 (sgm 23 (cmbn 3 -7 15)))
+(dotimes (i 8)
+   (print (funcall sface i 7 s2)))
+
+(setf gface (gamma-face cmpr dffr))
+(setf g1 (sgm-gamma 4 3 (cmbn 2 5 7 -8 13)))
+(dotimes (i 5)
+   (print i)
+   (print (funcall gface i 4 g1)))
+
+(setf g2 (sgm-gamma 7 23 (cmbn 3 -7 15)))
+(dotimes (i 8)
+   (print i)
+   (print (funcall gface i 7 g2)))
+
+(setf g3 (sgm-gamma 7 59 (cmbn 2 1 7 -5 13 6 14)))
+(setf g4 (2gamma-add cmpr g2 g3))
+
+(dotimes (i 8)
+   (print i)
+   (print (funcall gface i 7 g3)))
+
+(setf g5 (sgm-gamma 7 27 (cmbn 3 1 15)))
+(setf g6 (2gamma-add cmpr g2 g5))
+(dotimes (i 8)
+   (print i)
+   (print (funcall gface i 7 g6)))
+|# 
+
+(defun gamma-grml (cmpr)
+   (flet ((rslt (dmns crpr)
+            (the absm
+              (with-crpr (dgop1 gmm1 dgop2 gmm2) crpr
+                (let ((sgm-list1 +empty-list+)
+                      (sgm-list2 +empty-list+)
+                      (k1 (length (dgop-int-ext dgop1)))
+                      (k2 (length (dgop-int-ext dgop2)))
+                      (g1 (gamma-elt 0))
+                      (g2 (gamma-elt 0)))
+                   (with-gamma (degr1 glist1) gmm1
+                     (do ((mark1 glist1 (cdr mark1)))
+                         ((endp mark1))
+                        (with--sgm (sgop1 sgcm1) mark1 
+                          (push (sgm (dgop*dgop dgop1 sgop1) sgcm1) sgm-list1)))
+                     (setf g1 (make-gamma :degr (+ degr1 k1)
+                                :list (nreverse sgm-list1))))
+                   (with-gamma (degr2 glist2) gmm2
+                     (do ((mark2 glist2 (cdr mark2)))
+                         ((endp mark2))
+                        (with--sgm (sgop2 sgcm2) mark2 
+                          (push (sgm (dgop*dgop dgop2 sgop2) sgcm2) sgm-list2)))
+                     (setf g2 (make-gamma :degr (+ degr2 k2)
+                                :list (nreverse sgm-list2))))
+                   (gamma-to-absm (2gamma-add cmpr g1 g2)))))))
+     #'rslt))
+
+#|
+(setf ggrml (gamma-grml cmpr))
+(funcall ggrml 9 (crpr 136 g3 9 g4))
+
+(funcall ggrml 7 (crpr 0 g3 0 g4))
+(funcall ggrml 7 (crpr 0 g3 0 (gamma-opps g4)))
+|# 
+
+(defun gamma-grin (dmns gmm)
+   (the absm
+     (absm 0 (gamma-opps gmm))))
+
+
+#|
+(gamma-grin 7 g3)
+(gamma-grin 7 g4)
+|# 
+ 
+  
+(defun gamma-chcm (x)
+   (declare (type simplicial-set x))
+   (the ab-simplicial-group
+     (let* ((x-cmpr (cmpr x))
+            (x-dffr (dffr x))
+            (x-orgn (orgn x))
+            (cmpr (gamma-cmpr x-cmpr))
+            (bspn (gamma-elt 0))
+            (face (gamma-face x-cmpr x-dffr))
+            (sintr-grml (gamma-grml x-cmpr)))
+        (build-ab-smgr
+         :cmpr cmpr
+         :basis :locally-effective
+         :bspn bspn
+         :face face
+         :bndr-strt :gnrt
+         :dgnl-strt :gnrt
+         :sintr-grml sintr-grml
+         :sintr-grin #'gamma-grin
+         :orgn `(GAMMA ,x)
+         ))))
+
+
+#|
+(setf d2 (delta 2)) 
+(setf gamma-d2 (gamma-chcm d2))
+(basis gamma-d2 2)
+(orgn gamma-d2)
+(setf g1 (gamma-elt 5 7 (cmbn 2 3 7) 11 (cmbn 2 -9 13)))
+(setf g2 (gamma-elt 5 7 (cmbn 2 -3 7) 9 (cmbn 3 -5 15)))
+(cmpr gamma-d2 g1 g2)
+(cmpr gamma-d2 g2 g1)
+(setf g3 (2gamma-add (cmpr d2) g1 g2))
+(cmpr gamma-d2 g1 g3)
+(cmpr gamma-d2 g2 g3)
+(bspn gamma-d2)
+(dotimes (i 6)
+   (print i)
+   (print (face gamma-d2 i 5 g3)))
+(grml gamma-d2 5 (crpr 0 g2 0 (gamma-opps g3)))
+(grin gamma-d2 5 g1)
+
+|# 
+
+
+
+;; GAMMA APPLIED TO A MORPHISM
+
+(defun gamma-sintr (f)
+   (declare (type morphism f))
+   (flet ((rslt (dmns gmm)
+            (declare 
+              (fixnum dmns)
+              (type gamma gmm))
+            (the absm
+              (with-gamma (degr glist) gmm
+                (declare 
+                  (fixnum degr)
+                  (list glist))
+                (let ((pre-rslt +empty-list+))
+                   (declare (list pre-rslt))
+                   (do ((mark glist (cdr mark)))
+                       ((endp mark))
+                      (declare (list mark))
+                      (with--sgm (sgop sgcm) mark
+                        (declare
+                         (fixnum sgop)
+                         (type cmbn sgcm))
+                        (let ((sgm2 (sgm sgop (? f sgcm))))
+                           (declare (type sgm sgm2))
+                           (if (sgm-non-zero-p sgm2)
+                              (push sgm2 pre-rslt)))))
+                   (gamma-to-absm (make-gamma :degr degr :list (nreverse pre-rslt))))))))
+     #'rslt))
+                    
+#|
+(setf d3 (delta 3))
+(setf f (idnt-mrph d3))
+(setf gamma-f (gamma-sintr f))
+(setf gmm1 (gamma-elt 5 5 (cmbn 3 7 15) 26 (cmbn 2 -3 11)))
+(funcall gamma-f 5 gmm1)
+
+(setf g (opps f))
+(setf gamma-g (gamma-sintr g))
+(funcall gamma-g 5 g1)
+
+(setf f+g (add f g))
+(setf gamma-fg (gamma-sintr f+g))
+(funcall gamma-fg 5 g1)
+
+|#  
+
+(defun gamma-mrph (f)
+   (declare (type morphism f))
+   (the simplicial-mrph
+     (let ((sorc (sorc f))
+           (trgt (trgt f))
+           (degr (degr f)))
+        (unless (= degr 0)
+           (error "In GAMMA-MRPH, the morphism has degree ~D different to zero."
+             degr))
+        (build-smmr
+         :sorc (gamma-chcm sorc)
+         :trgt (gamma-chcm trgt)
+         :degr degr
+         :sintr (gamma-sintr f)
+         :orgn `(GAMMA ,f)))))
+
+#|
+(setf gamma-f (gamma-mrph f))
+(? gamma-f 5 g1)
+(setf g2 (gamma-elt 5 5 (cmbn 3 -7 15) 10 (cmbn 3 7 15)))
+(? gamma-f 5 g2)
+(? gamma-f 5 (2gamma-add (cmpr d3) g1 g2))
+(? gamma-f (cmbn 5 1 g2 1 g1))
+|#
+
+
+(defun sgm-hintr (cmpr h d)
+   (declare 
+     (type cmprf cmpr)
+     (type morphism h d))
+   (labels ((rslt (indx dmns sgm)
+            (declare 
+              (fixnum indx dmns)
+              (type sgm sgm))
+            (the gamma
+              (with-sgm (sgop sgcm) sgm
+                (declare 
+                  (fixnum sgop)
+                  (type cmbn sgcm))
+                (if (= 0 sgop)
+                   (let ((degr (cmbn-degr sgcm)))
+                      (declare (fixnum degr))
+                      (if (= degr indx)
+                         (let* ((sgm1 (sgm 0 (cmbn-opps (? h sgcm))))
+                                (sgm2 (sgm (dgop-ext-int (list indx)) (2cmbn-add cmpr sgcm (cmbn-opps (? h (? d sgcm))))))
+                                (glist +empty-list+))
+                            (declare 
+                              (type sgm sgm1 sgm2)
+                              (list glist))
+                            (if (sgm-non-zero-p sgm2)
+                               (push sgm2 glist))
+                            (if (sgm-non-zero-p sgm1)
+                               (push sgm1 glist))
+                            (make-gamma :degr (1+ dmns)
+                              :list glist))
+                         (if (= (1- degr) indx)
+                            (let* ((sgm1 (sgm (dgop-ext-int (list indx)) sgcm))
+                                   (sgm2 (sgm (dgop-ext-int (list degr)) (cmbn-opps (? h (? d sgcm)))))
+                                   (glist +empty-list+))
+                               (declare 
+                                 (type sgm sgm1 sgm2)
+                                 (list glist))
+                               (if (sgm-non-zero-p sgm2)
+                                  (push sgm2 glist))
+                               (if (sgm-non-zero-p sgm1)
+                                  (push sgm1 glist))
+                               (make-gamma :degr (1+ dmns)
+                                 :list glist))
+                            (sgm-gamma (1+ dmns) (dgop-ext-int (list indx)) sgcm))))
+                   (let* ((dgop1-ext (first (dgop-int-ext sgop)))
+                          (dgop2 (remove-bit sgop dgop1-ext))
+                          (sgm2 (sgm dgop2 sgcm)))
+                      (declare
+                       (fixnum dgop1-ext dgop2)
+                       (type sgm sgm2))
+                      (if (>= dgop1-ext indx)
+                         (let ((smhmt-i (rslt indx (1- dmns)  (sgm dgop2 sgcm))))
+                            (declare (type gamma smhmt-i))
+                            (gamma-ndgnr (dgop-ext-int (list (1+ dgop1-ext))) smhmt-i))
+                         (let ((smhmt-i-1 (rslt (1- indx) (1- dmns)  sgm2)))
+                            (declare (type gamma smhmt-i-1))
+                            (gamma-ndgnr (dgop-ext-int (list dgop1-ext)) smhmt-i-1)))))))))
+     (the hintr #'rslt)))
+     
+#|
+(setf d3 (delta 3))
+(setf d (dffr d3))
+(setf h (lh (efhm d3)))
+(setf cmpr #'f-cmpr)
+
+(setf sgm-smhmt (sgm-hintr cmpr h d))
+(setf sgm (sgm 5 (cmbn 3 -7 15)))
+(dotimes (indx 6)
+   (print (funcall sgm-smhmt indx 5 sgm)))
+
+(setf sgm2 (sgm 11 (cmbn 2 7 7)))
+(dotimes (indx 6)
+   (print (funcall sgm-smhmt indx 5 sgm2)))
+
+
+|# 
+
+
+(defun gamma-hintr (cmpr h d)
+   (declare 
+     (type morphism h d)
+     (type cmprf cmpr))
+   (let ((s-hintr (sgm-hintr cmpr h d)))
+      (flet ((rslt (indx dmns gmsm)
+               (declare 
+                 (type fixnum indx dmns)
+                 (type gamma gmsm))
+               (let ((rslt (gamma-elt (1+ dmns))))
+                  (do ((mark (gamma-list gmsm) (cdr mark)))
+                      ((endp mark) (gamma-to-absm rslt))
+                     (setf rslt (2gamma-add cmpr rslt (funcall s-hintr indx dmns (-sgm mark))))))))
+      (the hintr #'rslt))))
+             
+
+#|
+(setf d3 (delta 3))
+(setf d (dffr d3))
+(setf h (lh (efhm d3)))
+
+(setf gmm (gamma-elt 5 5 (cmbn 3 -7 15) 11 (cmbn 2 7 7)))
+(setf cmpr #'f-cmpr)
+
+(setf g-hintr (gamma-hintr cmpr h d))
+(dotimes (indx 6)
+   (print (funcall g-hintr indx 5 gmm)))
+
+|# 
+           
+
+(defun gamma-hmtp (h)
+   (declare (type morphism h))
+   (the simplicial-hmtp
+     (let* ((cc (sorc h))
+            (gamma-cc (gamma-chcm cc))
+            (degr (degr h))
+            (cmpr (cmpr cc))
+            (dffr (dffr cc))
+            (orgn (orgn cc)))
+        (declare
+         (type chain-complex cc)
+         (type ab-simplicial-group gamma-cc)
+         (fixnum degr)
+         (type cmprf cmpr)
+         (type morphism dffr))
+        (unless (= degr 1)
+           (error "In GAMMA-HMTP, the morphism has degree ~D different to +1."
+             degr))
+        (build-smhmt
+         :sorc gamma-cc
+         :trgt gamma-cc
+         :degr 1
+         :hintr (gamma-hintr cmpr h dffr)
+         :orgn `(GAMMA ,orgn)))))
+
+#|
+(setf d3 (delta 3))
+(setf h (lh (efhm d3)))
+(setf gamma-h (gamma-hmtp h))
+(setf gmm (gamma-elt 5 5 (cmbn 3 -7 15) 11 (cmbn 2 7 7)))
+(dotimes (i 6)
+  (print (? gamma-h i 5 gmm)) )
+
+(setf i 0)
+(? gamma-h i 5 gmm)
+
+(? gamma-h 5 gmm)
+
+|# 
+ 
+#|
+(defun deltan-h (n)
+   (the morphism
+     (let ((delta-n (delta n)))
+        (build-mrph
+         :sorc delta-n
+         :trgt delta-n
+         :degr +1
+         :intr #'(lambda (degr gmsm)
+                   (if (oddp gmsm)
+                      (zero-cmbn (1+ degr))
+                      (term-cmbn (1+ degr) 1 (1+ gmsm))))
+                   :strt :gnrt
+                   :orgn `(homotopy for delta ,n)))))
+
+(setf h5 (deltan-h 5))
+(? h5 3 15)
+(? h5 3 30)
+(? h5 3 39)
+
+(setf gmm-d5-h (gamma-hmtp h5))
+
+(setf g1 (gamma-elt 3 0 (cmbn 3 1 15)))
+(dotimes (indx 4)
+   (print (? gmm-d5-h indx 3 g1)))
+
+(setf g2 (gamma-elt 3 0 (cmbn 3 1 46)))
+(dotimes (indx 4)
+   (print (? gmm-d5-h indx 3 g2)))
+
+(setf g3 (gamma-elt 5 5 (cmbn 3 -7 15)))
+(dotimes (indx 6)
+   (print (? gmm-d5-h indx 5 g3)))
+
+(dotimes (i 6)
+   (dotimes (j 7)
+      (format t "i= ~D, j= ~D" i j)
+      (print (? gmm-d5-h j 6 (? gmm-d3-h i 5 g3)))))
+
+(setf g4 (gamma-elt 5 11 (cmbn 2 1 14)))
+(dotimes (indx 6)
+   (print (? gmm-d5-h indx 5 g4)))
+
+(setf g5 (2gamma-add #'f-cmpr g3 g4))
+(dotimes (indx 6)
+   (print (? gmm-d5-h indx 5 g5)))
+
+(setf g6 (2gamma-add #'f-cmpr g5 (gamma-elt 5 0 (cmbn 5 2 63))))
+(dotimes (indx 6)
+   (print (? gmm-d5-h indx 5 g6)))
+|#
+
+
+(defun gamma-rdct (rdct)
+   (declare (type reduction rdct))
+   (the reduction
+     (let ((f (f rdct))
+           (g (g rdct))
+           (h (h rdct))
+           (orgn (orgn rdct)))
+        (declare
+         (type morphism f g h)
+         (list orgn))
+        (build-rdct
+         :f (gamma-mrph f)
+         :g (gamma-mrph g)
+         :h (gamma-hmtp h)
+         :orgn `(gamma ,orgn)))))
+
+#|
+(setf d3 (delta 3))
+(setf rdct (lrdct (efhm d3)))
+(setf grdct (gamma-rdct rdct))
+
+(setf d5 (delta 5))
+(setf z (z-chcm))
+(setf f (build-mrph
+         :sorc d5
+         :trgt z
+         :degr 0
+         :intr #'(lambda (dmns gnrt)
+                   (if (and (= dmns 0) (= gnrt 1))
+                      (cmbn 0 1 :zgnrt)
+                      (cmbn dmns)))
+         :strt :gnrt
+         :orgn `(trivial-morphism from ,d5 to ,z)))
+      
+(setf g (build-mrph
+         :sorc z
+         :trgt d5
+         :degr 0
+         :intr #'(lambda (dmns gnrt)
+                   (if (equal gnrt :z-gnrt)
+                      (cmbn 0 1 1)
+                      (cmbn dmns)))
+         :strt :gnrt
+         :orgn `(trivial-morphism from ,z to ,d5)))
+
+(setf h (deltan-h 5))
+(setf rdct5 (build-rdct :f f :g g :h h :orgn `(contraction-homotopy ,d5)))
+(setf grdct5 (gamma-rdct rdct5))
+
+(pre-check-rdct grdct5)
+(setf *tc* (cmbn 5 1 (gamma-elt 5 0 (cmbn 5 2 63) 5 (cmbn 3 -7 15) 11 (cmbn 2 1 14)))) 
+(setf *bc* (cmbn 0 1 (gamma-elt 0 0 (cmbn 0 1 :z-gnrt))))
+(check-rdct)
+
+(setf *tc* (cmbn 3 1 (gamma-elt 3 0 (cmbn 3 -6 27 2 43) 5 (cmbn 1 8 9) 7 (cmbn 0 7 8 1 32)) 6 
+             (gamma-elt 3 0 (cmbn 3 1 15) 5 (cmbn 1 -7 5 6 18) 6 (cmbn 1 6 12 -3 18 4 20) 7 (cmbn 0 8 16 -3 32))
+))
+
+(check-rdct)
+
+
+
+
+|# 
+   
+
+(DEFMETHOD GAMMA ((chcm chain-complex))
+   (gamma-chcm chcm))
+
+(DEFMETHOD GAMMA ((rdct reduction))
+   (gamma-rdct rdct))
+ 
+   
\ No newline at end of file
diff --git a/examples/anromero/bousfield-kan/simplicial-hmtps.lsp b/examples/anromero/bousfield-kan/simplicial-hmtps.lsp
new file mode 100644
index 0000000..81f4c75
--- /dev/null
+++ b/examples/anromero/bousfield-kan/simplicial-hmtps.lsp
@@ -0,0 +1,153 @@
+;;;  SIMPLICIAL-HMTPS  SIMPLICIAL-HMTPS  SIMPLICIAL-HMTPS
+;;;  SIMPLICIAL-HMTPS  SIMPLICIAL-HMTPS  SIMPLICIAL-HMTPS
+;;;  SIMPLICIAL-HMTPS  SIMPLICIAL-HMTPS  SIMPLICIAL-HMTPS
+
+(IN-PACKAGE "COMMON-LISP-USER")
+
+(PROVIDE "simplicial-hmtps")
+
+(DEFTYPE HINTR () 'function)
+;; (function (indx dmns gmsm) absm)
+ 
+(DEFCLASS SIMPLICIAL-HMTP (morphism)
+    ((hintr :type hintr :initarg :hintr :reader hintr)))
+
+
+(DEFVAR *SMHMT-LIST*)
+(SETF *SMHMT-LIST* +empty-list+)
+(PUSHNEW '*SMHMT-LIST* *LIST-LIST*)
+
+(DEFMETHOD PRINT-OBJECT ((smhmt simplicial-hmtp) stream)
+  (the simplicial-hmtp
+     (progn
+      (format stream "[K~D Simplicial-Homotopy K~D -> K~D]"
+        (idnm smhmt) (idnm (sorc smhmt)) (idnm (trgt smhmt)))
+      smhmt)))
+
+(DEFUN SMHMT (idnm)
+  (declare (fixnum idnm))
+  (the (or null simplicial-hmtp)
+     (find idnm *smhmt-list* :key #'idnm)))
+
+(DEFUN HINTR-INTR (cmpr hintr)
+   (declare (type hintr hintr)
+     (type cmprf cmpr))
+   (flet ((rslt (dmns gmsm)
+            (declare
+             (fixnum dmns)
+             (type gmsm gmsm))
+            (when (minusp dmns) 
+               (return-from rslt (zero-cmbn (1+ dmns))))
+            (let ((cmbn (zero-cmbn (1+ dmns))))
+               (declare (type cmbn cmbn))
+               (do ((indx 0 (1+ indx)))
+                   ((> indx dmns) cmbn)
+                  (declare (fixnum indx))
+                  (let ((hmtp-i (funcall hintr indx dmns gmsm)))
+                     (declare (type absm hmtp-i))
+                     (if (non-degenerate-p hmtp-i)
+                        (setf cmbn (2cmbn-add cmpr cmbn (term-cmbn (1+ dmns) (-1-expt-n indx) (gmsm hmtp-i))))))))))
+     (the intr-mrph #'rslt)))
+
+(DEFUN BUILD-SMHMT (&key sorc trgt degr hintr intr strt orgn)
+   (declare
+      (type simplicial-set sorc trgt)
+      (fixnum degr)
+      (type hintr hint)
+      (type (or intr-mrph null) intr)
+      (type (or strt null) strt)
+      (list orgn))
+   (the simplicial-hmtp
+      (progn
+	 (let ((already (find orgn *smhmt-list* :test #'equal :key #'orgn)))
+	    (declare (type (or simplicial-hmtp null) already))
+	    (when already
+	       (return-from build-smhmt already)))
+       (unless (= 1 degr)
+          (error "In BUILD-SMHMT, the degree ~D is different to +1."
+            degr))
+       (if intr
+          (unless strt
+             (error "In BUILD-SMMR, an intr is given but not its strt"))
+          (let ((cmpr (cmpr sorc)))
+             (declare (type cmprf cmpr))
+             (setf strt :gnrt
+                   intr (hintr-intr cmpr hintr))))
+          (let ((rslt (build-mrph
+		        :sorc sorc :trgt trgt :degr degr
+			:intr intr :strt strt
+			:orgn orgn)))
+          (declare (type morphism rslt))
+          (change-class rslt 'simplicial-hmtp)
+          (setf (slot-value rslt 'hintr) hintr)
+          (push rslt *smhmt-list*)
+	   rslt))))
+
+
+#|
+(setf d (delta 3))
+(setf h (build-smhmt
+         :sorc d :trgt d :degr 1
+         :hintr #'(lambda (indx dmns gmsm)
+                    (absm (dgop-ext-int (list indx)) gmsm))
+         :orgn '(simplicial-homotopy delta-3)))
+(dotimes (indx 5)
+     (print (? h indx 4 (absm 8 15))))
+(dotimes (indx 7)
+     (print (? h indx 6 (absm 45 11))))
+(? h 2 11)
+|#
+
+
+
+(DEFMETHOD ?4 ((smhmt simplicial-hmtp) indx dmns absm-or-gmsm)
+  (declare
+     (fixnum indx dmns)
+     (type (or absm gmsm) absm-or-gmsm))
+   (the absm
+     (typecase absm-or-gmsm
+       (absm
+        (with-absm (dgop gmsm) absm-or-gmsm
+          (declare 
+            (fixnum dgop)
+          (type gmsm gmsm))
+          (if (= 0 dgop) 
+             (funcall (hintr smhmt) indx dmns gmsm)
+             (let* ((dgop1-ext (first (dgop-int-ext dgop)))
+                    (dgop2 (remove-bit dgop dgop1-ext))
+                    (absm2 (absm dgop2 gmsm)))
+                (declare
+                 (fixnum dgop1-ext dgop2)
+                 (type absm sbsm2))
+                (if (>= dgop1-ext indx)
+                   (let ((smhmt-i (?4 smhmt indx (1- dmns)  absm2)))
+                      (declare (type absm smhmt-i))
+                      (ndgnr (dgop-ext-int (list (1+ dgop1-ext))) smhmt-i))
+                   (let ((smhmt-i-1 (?4 smhmt (1- indx) (1- dmns)  absm2)))
+                      (declare (type absm smhmt-i-1))
+                      (ndgnr (dgop-ext-int (list dgop1-ext)) smhmt-i-1)))))))
+       (otherwise
+        (funcall (hintr smhmt) indx dmns absm-or-gmsm)))))
+
+
+;; This macro definition changes the definition of the macro ? in the file macro.lsp
+(DEFMACRO ? (&rest rest)
+   (ecase (length rest)
+     (2 `(?2 ,@rest))
+     (3 `(?3 ,@rest))
+     (4 `(?4 ,@rest))))
+
+
+
+
+
+
+
+             
+      
+   
+   
+    
+
+   
+
diff --git a/examples/anromero/filtered-complexes/bicomplexes.lsp b/examples/anromero/filtered-complexes/bicomplexes.lsp
new file mode 100644
index 0000000..6ab13a1
--- /dev/null
+++ b/examples/anromero/filtered-complexes/bicomplexes.lsp
@@ -0,0 +1,270 @@
+;; BICOMPLEXES   BICOMPLEXES   BICOMPLEXES   BICOMPLEXES   BICOMPLEXES   BICOMPLEXES  
+;; BICOMPLEXES   BICOMPLEXES   BICOMPLEXES   BICOMPLEXES   BICOMPLEXES   BICOMPLEXES
+;; BICOMPLEXES   BICOMPLEXES   BICOMPLEXES   BICOMPLEXES   BICOMPLEXES   BICOMPLEXES
+
+
+(IN-PACKAGE "COMMON-LISP-USER")
+
+(PROVIDE "bicomplexes")
+
+(DEFMETHOD PRINT-KEYCONS ((car (eql :BcGnrt)) cdr stream)
+   (declare
+      (cons cdr)
+      (stream stream))
+   (the (eql t)
+       (let* 
+            ((cdr (cons car cdr))
+             (degr1 (BcGnrt-Degr1 cdr))
+             (degr2 (BcGnrt-Degr2 cdr))
+             (gnrt (BcGnrt-gnrt cdr)))
+          (progn
+            (format stream "<BcGnrt ")
+            (format stream "[~D ~D] ~A" degr1 degr2 gnrt)
+            (format stream ">"))
+         t)))
+
+
+
+        ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+        ;;; TYPES FOR BICOMPLEXES ;;;
+        ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; TYPE BcGnrt (a generator in a Bicomplex)
+(DEFUN BcGnrt-p (object)
+   (declare (type any object))
+   (the boolean
+     (and (consp object)
+          (eql :BcGnrt (car object))
+          (consp (cdr object))
+          (consp (cadr object))
+          (typep (caadr object) 'fixnum)
+          (typep (cdadr object) 'fixnum))))
+(DEFTYPE BcGnrt () '(satisfies BcGnrt-p))
+
+#|
+(typep  `(:BcGnrt ,(cons 5 6) u) 'BcGnrt)
+(typep `(:BcGnrt ,(cons 3 2) '(f g)) 'BcGnrt)
+(typep `(:BcGnrt ,(cons 4 5.4) u) 'BcGnrt)
+|#
+
+ 
+;; TYPE BcBasis (basis of a Bicomplex, function of the variables p and q or
+;; ":locally-effective")
+(DEFTYPE BcBASIS () '(or function (eql :locally-effective))) 
+                     ;; (function (degr degr) (list gnrt)) 
+
+
+;; TYPE Bicomplex
+(DEFUN OrgnBiCmpl-p (object)
+   (declare (type chain-complex object))
+     (let* ((orgn (orgn object)))
+        (the boolean
+          (and (consp orgn)
+             (eql (car orgn) 'BiCmpl)))))
+(DEFTYPE Bicomplex () '(satisfies OrgnBiCmpl-p))
+
+
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+ ;;; FUCTIONS FOR THE REPRESENTATION OF (GENERAL) BICOMPLEXES ;;;
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+;; Function that builds a generator of a Bicomplex from two degrees and 
+;; a simple generator.
+(DEFUN build-BcGnrt (degr1 degr2 gnrt)
+   (declare 
+     (type fixnum degr1 degr2)
+     (type any gnrt))
+   (list :BcGnrt (cons degr1 degr2) gnrt))
+
+#|
+(build-BcGnrt 2 3 'c)
+(typep  (build-BcGnrt 2 2 'd) 'BcGnrt)
+|#
+ 
+
+;; Function that returns the first degree from a bicomplex' generator.
+(DEFUN BcGnrt-Degr1 (BcGnrt)
+   (declare (type BcGnrt BcGnrt))
+   (caadr BcGnrt))
+
+;; Function that returns the second degree from a bicomplex' generator.
+(DEFUN BcGnrt-Degr2 (BcGnrt)
+   (declare (type BcGnrt BcGnrt))
+   (cdadr BcGnrt))
+
+;; Function that returns the original generator from a bicomplex' generator.
+(DEFUN BcGnrt-Gnrt (BcGnrt)
+   (declare (type BcGnrt BcGnrt))
+   (caddr BcGnrt))
+
+#|
+(build-BcGnrt 5 6 8)
+(BcGnrt-Degr1 (build-BcGnrt 5 6 8))
+(BcGnrt-Degr2 (build-BcGnrt 6 4 '(4 6)))
+(BcGnrt-Gnrt (build-BcGnrt 6 4 '(4 6)))
+(BcGnrt-Gnrt (build-BcGnrt 2 8 'u))
+|# 
+
+ 
+;; Comparison function of a bicomplex. 
+(defun BC-CMPR (cmpr)
+   (declare (type cmprf cmpr))
+   (flet ((comp (bc1 bc2)
+            (declare (type BcGnrt bc1 bc2))
+            (let ((degr11 (BcGnrt-Degr1 bc1))
+                  (degr21 (BcGnrt-Degr2 bc1))
+                  (degr12 (BcGnrt-Degr1 bc2))
+                  (degr22 (BcGnrt-Degr2 bc2))
+                  (gnrt1 (BcGnrt-Gnrt bc1))
+                  (gnrt2 (BcGnrt-Gnrt bc2)))
+               (declare 
+                 (type fixnum degr11 degr21 degr12 degr22)
+                 (type any gnrt1 gnrt2))
+               (lexico
+                (f-cmpr degr11 degr12)
+                (f-cmpr degr21 degr22)
+                (funcall cmpr gnrt1 gnrt2)))))
+     (the cmprf #'comp)))
+
+#|
+(setf cmpr (BC-CMPR #'s-cmpr)) 
+(funcall cmpr (build-BcGnrt 5 6 'a) (build-BcGnrt 7 8 'b))
+(funcall cmpr (build-BcGnrt 8 6 'a) (build-BcGnrt 7 8 'b))
+(funcall cmpr (build-BcGnrt 8 5 'c) (build-BcGnrt 8 6 'b))
+(funcall cmpr (build-BcGnrt 8 5 'c) (build-BcGnrt 8 5 'b))
+|# 
+      
+;; Basis of a bicomplex (from a function of type BcBasis).
+(DEFUN BC-BASIS (bcbasis)
+   (declare (type BcBasis bcbasis))
+   (when (eq bcbasis :locally-effective)
+      (return-from bc-basis :locally-effective))
+   (flet ((bas (degr)
+            (declare (type fixnum degr))
+            (the list
+              (progn
+               (when (minusp degr)
+                  (return-from bas +empty-list+))
+               (mapcan
+                #'(lambda (degr1)
+                    (declare (type fixnum degr1))
+                    (let* ((degr2 (- degr degr1))
+                           (basis (funcall bcbasis degr1 degr2)))
+                       (declare
+                        (fixnum degr2)
+                        (list basis))
+                       (the list
+                         (mapcar
+                          #'(lambda (gnrt)
+                              (declare (type gnrt gnrt))
+                              (the BcGnrt
+                                (build-BcGnrt degr1 degr2 gnrt)))
+                          basis)))
+                    )
+                (<a-b> 0 degr))))))
+     (the basis #'bas)))
+
+#|
+(defun bas (degr1 degr2)
+   (if (and (= degr1 0) (= degr2 1)) (return-from bas '(a)))
+   (if (and (= degr1 1) (= degr2 0)) (return-from bas '(b)))
+   (if (and (= degr1 1) (= degr2 1)) (return-from bas '(c)))
+   (if (and (= degr1 2) (= degr2 0))  (return-from bas '(d)))
+   (return-from bas nil))
+(setf basis (BC-BASIS #'bas))
+(dotimes (i 5)
+   (print (funcall basis i)))
+|#
+
+;; Differential function of a Bicomplex (from the differential functions,
+;; dffr1=horizontal dffr, dffr2=vertical dffr). 
+(DEFUN BC-INTR-DFFR (dffr1 dffr2)
+   (declare (type function dffr1 dffr2))
+   (flet ((dif (degr bc)
+            (declare
+             (fixnum degr)
+             (type BcGnrt bc))
+            (the cmbn
+              (let* ((degr1 (BcGnrt-Degr1 bc))
+                     (degr2 (BcGnrt-Degr2 bc))
+                     (gnrt (BcGnrt-Gnrt bc))
+                     (degr1-1 (1- degr1))
+                     (degr2-1 (1- degr2))
+                     (list1 (funcall dffr1 degr1 degr2 gnrt))
+                     (list2 (funcall dffr2 degr1 degr2 gnrt)))
+                 (declare (type fixnum degr1 degr2 degr1-1 gegr2-1)
+                   (list list1 list2))
+                 (make-cmbn
+                  :degr (1- degr)
+                  :list (nconc
+                         (mapcar
+                          #'(lambda (term1)
+                              (declare (type term term1))
+                              (let* ((cffc1 (cffc term1))
+                                     (gnrt1 (gnrt term1)))
+                                 (declare (type fixnum cffc1)
+                                   (type gnrt gnrt1))
+                                 (term cffc1 (build-BcGnrt degr1-1 degr2 gnrt1))))
+                          list1)
+                         (mapcar 
+                           #'(lambda (term2)
+                               (declare (type term term2))
+                               (let* ((cffc2 (cffc term2))
+                                      (gnrt2 (gnrt term2)))
+                                  (declare (type fixnum cffc2)
+                                    (type gnrt gnrt2))
+                                  (term cffc2 (build-BcGnrt degr1 degr2-1 gnrt2))))
+                           list2)))))))
+     (the intr-mrph #'dif)))
+
+#|
+(defun dif1 (degr1 degr2 gnrt)
+   (if (and (= degr1 1) (= degr2 1) (eql gnrt 'c)) (return-from dif1 (list (cons 2 'a))))
+   (if (and (= degr1 2) (= degr2 0) (eql gnrt 'd)) (return-from dif1 (list (cons 2 'b))))
+   (return-from dif1 nil))
+(defun dif2 (degr1 degr2 gnrt)
+   (if (and (= degr1 1) (= degr2 1) (eql gnrt 'c)) (return-from dif2 (list (cons 1 'b))))
+   (return-from dif2 nil))
+(setf dif (BC-INTR-DFFR #'dif1 #'dif2))
+(funcall dif 2 (build-BcGnrt 1 1 'c))
+|#
+
+;; Function that builds a bicomplex from a basis function, the two differential
+;; functions and the original comparison. 
+(DEFUN BUILD-BICM (&key bcbasis dffr1 dffr2 cmpr orgn)
+   (declare 
+     (type BCbasis bcbasis)
+     (type function dffr1 dffr2)
+     (type cmprf cmpr)
+     (list (orgn)))
+   (the chain-complex
+     (let ((chcm
+            (build-chcm
+             :cmpr (BC-CMPR cmpr)
+             :basis (BC-BASIS bcbasis)
+             :intr-dffr (BC-INTR-DFFR dffr1 dffr2)
+             :strt :gnrt
+             :orgn orgn)))
+        (declare (type chain-complex chcm))
+        (slot-makunbound chcm 'bsgn)
+        chcm)))
+
+#|
+(setf bc (Build-Bicm :bcbasis #'bas :dffr1 #'dif1 :dffr2 #'dif2 :cmpr 's-cmpr 
+          :orgn '(BC-test)))
+(dotimes (i 5)
+   (print (basis bc i)))
+(cmpr bc (build-BcGnrt 0 1 'a) (build-BcGnrt 1 1 'c))
+
+(? bc (? bc 2 (build-BcGnrt 1 1 'c))) 
+(? bc 2 (build-BcGnrt 2 0 'd))
+(? bc 2 '(:BcGnrt (1 . 1) c))
+(? bc (cmbn 2 3 '(:BcGnrt (1 . 1) c)))
+(? bc 1 (build-bicm 0  1 'a))
+|#
+
+
+
+
+
diff --git a/examples/anromero/filtered-complexes/filtered-complexes.lsp b/examples/anromero/filtered-complexes/filtered-complexes.lsp
new file mode 100644
index 0000000..ab665f7
--- /dev/null
+++ b/examples/anromero/filtered-complexes/filtered-complexes.lsp
@@ -0,0 +1,843 @@
+;; FILTERED-COMPLEXES   FILTERED-COMPLEXES   FILTERED-COMPLEXES   FILTERED-COMPLEXES
+;; FILTERED-COMPLEXES   FILTERED-COMPLEXES   FILTERED-COMPLEXES   FILTERED-COMPLEXES
+;; FILTERED-COMPLEXES   FILTERED-COMPLEXES   FILTERED-COMPLEXES   FILTERED-COMPLEXES
+
+(IN-PACKAGE "COMMON-LISP-USER")
+
+(provide "filtered-complexes")
+
+(DEFTYPE degr () 'fixnum)
+
+(DEFTYPE CHCM-FLIN () 'function) 
+                     ;; '(function (degr gnrt) degr)
+
+
+(DEFCLASS FILTERED-CHAIN-COMPLEX (chain-complex)
+    ((flin :type chcm-flin :initarg :flin :reader flin1)))
+
+(DEFVAR *flcc-list*)
+(SETF *flcc-list* +empty-list+)
+(PUSHNEW '*flcc-list* *list-list*)
+
+(DEFMETHOD PRINT-OBJECT ((flcm FILTERED-CHAIN-COMPLEX) stream)
+(the FILTERED-CHAIN-COMPLEX
+   (progn
+      (format stream "[K~D Filtered-Chain-Complex]" (idnm flcm))
+     flcm)))
+
+(DEFUN FLCC (idnm)
+   (declare (type fixnum idnm))
+   (the (or FILTERED-CHAIN-COMPLEX null)
+      (find idnm *flcc-list* :key #'idnm)))
+
+
+;; Function that builds a filtered chain complex. 
+(DEFUN BUILD-FLCC
+    (&key cmpr basis bsgn intr-dffr dffr-strt flin orgn)
+   (declare
+      (type cmprf cmpr)
+      (type intr-mrph intr-dffr)
+      (type basis basis)
+      (type gnrt bsgn)
+      (type strt dffr-strt)
+      (type Chcm-Flin flin)
+      (list orgn))
+   (the FILTERED-CHAIN-COMPLEX
+     (progn
+         (let ((already (find orgn *flcc-list* :key #'orgn :test #'equal)))
+            (declare (type (or null FILTERED-CHAIN-COMPLEX) already))
+            (when already
+               (return-from build-flcc already)))
+         (let ((rslt (build-chcm :cmpr cmpr :basis basis :bsgn bsgn
+                        :intr-dffr intr-dffr :strt dffr-strt
+                        :orgn orgn)))
+            (declare (type chain-complex rslt))
+            (change-class rslt 'FILTERED-CHAIN-COMPLEX)
+            (setf (slot-value rslt 'flin) flin)
+            (push rslt *flcc-list*)
+               rslt))))
+
+
+;; Function that changes a chain complex chcm to a filtered complex, with filtration
+;; index of a generator defined by the function flin, and origin orgn. 
+#|(DEFUN CHANGE-CHCM-TO-FLCC (chcm &key flin orgn)
+   (declare
+      (type chain-complex chcm)
+      (type chcm-flin flin)
+      (list orgn))
+   (the FILTERED-CHAIN-COMPLEX
+      (progn
+         (change-class chcm 'FILTERED-CHAIN-COMPLEX)
+         ;;(setf orgn (list (orgn chcm) 'then orgn))
+         (let ((already (find orgn *flcc-list* :key #'orgn :test #'equal)))
+            (declare (type (or null FILTERED-CHAIN-COMPLEX) already))
+            (when already
+               (return-from change-chcm-to-flcc already)))
+         (setf (slot-value chcm 'flin) flin)
+         ;;(setf (slot-value chcm 'orgn) orgn)
+         (push chcm *flcc-list*)
+         chcm)))
+|#
+
+
+(DEFMETHOD CHANGE-CHCM-TO-FLCC ((chcm chain-complex) flin flin-orgn)
+   (declare
+      (type chain-complex chcm)
+      (type chcm-flin flin)
+      (list flin-orgn))
+   (the FILTERED-CHAIN-COMPLEX
+      (progn
+         (change-class chcm 'FILTERED-CHAIN-COMPLEX)
+         (setf orgn (append (orgn chcm) (list 'FILTERED-WITH) flin-orgn))
+         (let ((already (find orgn *flcc-list* :key #'orgn :test #'equal)))
+            (declare (type (or null FILTERED-CHAIN-COMPLEX) already))
+            (when already
+               (return-from change-chcm-to-flcc already)))
+         (setf (slot-value chcm 'flin) flin)
+         (setf (slot-value chcm 'orgn) orgn)
+         (push chcm *flcc-list*)
+         chcm)))
+
+
+(DEFMACRO FLIN (&rest rest)
+   (ecase (length rest)
+      (1 `(flin1 ,@rest))
+      (2 `(flin2 ,@rest))
+      (3 `(flin3 ,@rest))))
+
+(DEFUN FLIN3 (object degr gnrt)         
+   (declare
+      (type FILTERED-CHAIN-COMPLEX object)
+      (fixnum degr)
+      (type gnrt gnrt))
+   (the fixnum
+      (with-slots (flin) object
+         (declare (type chcm-flin flin))
+         (funcall flin degr gnrt))))
+
+(DEFUN FLIN2 (object cmbn)
+   (declare
+    (type FILTERED-CHAIN-COMPLEX object)
+    (type cmbn cmbn))
+   (the fixnum
+      (with-slots (flin) object
+         (declare (type chcm-flin flin))
+        (with-cmbn (degr cmbn-list) cmbn
+          (declare
+           (fixnum degr)
+           (list cmbn-list))
+          (labels ((list-max (list)
+                     (declare (type list list))
+                     (let* ((max-int (car list)))
+                        (do ((mark1 list (cdr mark1)))
+                            ((endp mark1))
+                           (setq max-int (max max-int (car mark1))))
+                        max-int)))
+         (if (endp cmbn-list)
+            0
+            (list-max 
+              (mapcar 
+                #'(lambda (term)
+                    (flin3 object degr (gnrt term)))
+                cmbn-list))))))))
+   
+
+
+;; Function that returns the min and max of the filtration index of the elements of the basis
+;; for degree degr
+(DEFUN FLIN-MIN-MAX (fltrcm degr)
+   (declare (type FILTERED-CHAIN-COMPLEX fltrcm)
+            (type fixnum degr))
+   (when (eq (basis fltrcm) :locally-effective)
+    (error "flin-min-max cannot work with a LOCALLY-EFFECTIVE chain complex."))
+   (the list
+     (let* ((basis (basis fltrcm degr)))
+        (declare (list basis))
+        (if (endp basis)
+           (list 0 0)
+           (let* ((min (flin fltrcm degr (first basis)))
+                  (max min))
+              (declare (type fixnum min max))
+              (dolist (gnrt (cdr basis))
+                 (let ((aux (flin fltrcm degr gnrt)))
+                    (declare (type fixnum aux))
+                    (if (< aux min)
+                       (setf min aux)
+                       (if (> aux max)
+                          (setf max aux)))))
+              (list min max))))))
+           
+ 
+   
+;; Function that returns the elements of the basis that have bidegree (p,q).
+(DEFUN BIGRD-BASIS (fltrcm p q)
+   (declare (type FILTERED-CHAIN-COMPLEX fltrcm)
+            (type fixnum p q))
+   (when (eq (basis fltrcm) :locally-effective)
+    (error "Bigrd-Basis cannot work with a LOCALLY-EFFECTIVE chain complex."))
+   (the list
+     (let* ((degr (+ p q))
+            (basis (basis fltrcm degr)))
+        (declare 
+          (type list basis)
+          (fixnum degr))
+        (mapcan 
+          #'(lambda (gnrt)
+              (declare (type gnrt gnrt))
+              (if (= (flin fltrcm degr gnrt) p)
+                 (list gnrt)
+                 nil))
+          basis))))
+
+;; Function that returns the elements of the basis of degree "degr" that have
+;; filtration index <= "fltr-index".
+(DEFUN FLTRD-BASIS (fltrcm degr fltr-index)
+   (declare (type FILTERED-CHAIN-COMPLEX fltrcm)
+            (type fixnum degr fltr-index))
+   (when (eq (basis fltrcm) :locally-effective)
+    (error "Fltrd-Basis cannot work with a LOCALLY-EFFECTIVE chain complex."))
+   (let ((min (first (flin-min-max fltrcm degr))))
+      (declare (type fixnum min))
+      (the list
+        (mapcan
+          #'(lambda (i)
+              (bigrd-basis fltrcm i (- degr i)))
+          (<a-b> min fltr-index)))))
+
+;; Function that returns the elements of the basis with degree "degr",
+;; ordered by the filtration index.
+(DEFUN ORDERED-BASIS (fltrcm degr)
+   (declare
+    (type FILTERED-CHAIN-COMPLEX fltrcm)
+    (fixnum degr))
+   (when (eq (basis fltrcm) :locally-effective)
+    (error "Ordered-Basis cannot work with a LOCALLY-EFFECTIVE chain complex."))
+   (the list
+     (let ((max (second (flin-min-max fltrcm degr))))
+        (declare (type fixnum max))
+        (fltrd-basis fltrcm degr max))))  
+
+;; Matrix of the differential application of degree "degr" of the subcomplex
+;; F_pX, where p=fltr-index and X=fltrcm.
+(defun FLCC-DFFR-MTRX (fltrcm degr fltr-index)
+  (declare
+    (type FILTERED-CHAIN-COMPLEX fltrcm)
+    (fixnum degr fltr-index))
+   (when (eq (basis fltrcm) :locally-effective)
+    (error "flcc-dffr-mtrx cannot work with a LOCALLY-EFFECTIVE chain complex."))
+  (the matrix
+    (let* ((cmpr (cmpr1 fltrcm))
+	     (dffr (dffr fltrcm))
+	     (sbasis (fltrd-basis fltrcm degr fltr-index))
+           (tbasis (ordered-basis fltrcm (1- degr)))
+           ;; If the differential application in the filtered complex respects the filtration,
+           ;; i.e., d(F_pA_n) \in (F_pA)_{n-1}, the target basis is (fltrd-basis fltrcm (1- degr) fltr-index)
+           (srank (length sbasis))
+	     (trank (length tbasis)))
+       (declare
+        (type cmprf cmpr)
+        (type morphism dffr)
+        (fixnum degr)
+        (list sbasis tbasis)
+        (fixnum srank trank))
+       (let ((rslt 
+               #-ACLPC
+                    (make-array (list trank srank)
+				:element-type 'fixnum
+				:initial-element 0)
+               #+ACLPC
+                    (if (or (zerop srank) (zerop trank))
+                       (make-array (list trank srank)
+                          :element-type 'fixnum)
+                       (make-array (list trank srank)
+                          :element-type 'fixnum
+                          :initial-element 0))
+               ))               
+            (declare (type matrix rslt))
+            (do ((j 0 (1+ j))
+	           (mark sbasis (cdr mark)))
+                ((endp mark))
+               (declare
+                (fixnum j)
+                (list mark))
+               (let ((cmbn (gnrt-? dffr degr (car mark))))
+                  (declare (type cmbn cmbn))
+                  (do ((mark1 (cmbn-list cmbn) (cdr mark1)))
+                      ((endp mark1))
+                     (declare (list mark1))
+                     (with--term (cffc gnrt) mark1
+                       (declare 
+                         (fixnum cffc)
+                         (type gnrt gnrt))
+                       (do ((mark2 tbasis (cdr mark2))
+                            (i 0 (1+ i))
+                            (found nil))
+                           ((or (endp mark2) found))
+                          (declare 
+                            (list mark2)
+                            (fixnum i found))
+                          (if (eq :equal (funcall cmpr gnrt (car mark2)))
+                             (progn
+                              (setq found 1)
+                              (setf (aref rslt i j) cffc))))))))
+               rslt))))
+
+
+;; OTHER CLASSES THAT INHERIT FROM FILTERED-CHAIN-COMPLEX
+
+
+(DEFCLASS FILTERED-COALGEBRA (filtered-chain-complex coalgebra)
+    ())
+
+(DEFVAR *FLCLGB-LIST*)
+(SETF *FLCLGB-LIST* +empty-list+)
+(PUSHNEW '*FLCLGB-LIST* *list-list*)
+
+(DEFMETHOD PRINT-OBJECT ((flclgb FILTERED-COALGEBRA) stream)
+(the FILTERED-COALGEBRA
+   (progn
+      (format stream "[K~D FILTERED-COALGEBRA]" (idnm flclgb))
+     flclgb)))
+
+(DEFUN FltrClgb (idnm)
+   (declare (type fixnum idnm))
+   (the (or FILTERED-COALGEBRA null)
+      (find idnm *flclgb-list* :key #'idnm)))
+
+;; Function that builds a filtered coalgebra. 
+(DEFUN BUILD-FltrClgb
+    (&key cmpr basis bsgn intr-dffr dffr-strt intr-cprd cprd-strt flin orgn)
+   (declare
+     (type cmprf cmpr)
+     (type intr-mrph intr-dffr intr-cprd)
+     (type basis basis)
+     (type gnrt bsgn)
+     (type strt dffr-strt cprd-strt)
+     (type chcm-flin flin)
+     (list orgn))
+   (the FILTERED-COALGEBRA
+     (progn
+         (let ((already (find orgn *flclgb-list* :key #'orgn :test #'equal)))
+            (declare (type (or null FILTERED-COALGEBRA) already))
+            (when already
+               (return-from build-FltrClgb already)))
+         (let ((rslt (build-clgb :cmpr cmpr :basis basis :bsgn bsgn
+                        :intr-dffr intr-dffr :dffr-strt dffr-strt
+                       :intr-cprd intr-cprf :cprd-strt cprd-strt
+                        :orgn orgn)))
+            (declare (type coalgebra rslt))
+            (change-class rslt 'FILTERED-COALGEBRA)
+            (setf (slot-value rslt 'flin) flin)
+            (push rslt *flclgb-list*)
+               rslt))))
+
+(defmethod change-chcm-to-flcc ((chcm coalgebra) flin flin-orgn )
+   (declare
+      
+      (type chcm-flin flin)
+      (list flin-orgn))
+   (the FILTERED-COALGEBRA
+      (progn
+         (change-class chcm 'FILTERED-COALGEBRA)
+         (setf orgn (append (orgn chcm) (list 'FILTERED-WITH) flin-orgn))
+         (let ((already (find orgn *flclgb-list* :key #'orgn :test #'equal)))
+            (declare (type (or null FILTERED-COALGEBRA) already))
+            (when already
+               (return-from change-chcm-to-flcc already)))
+         (setf (slot-value chcm 'flin) flin)
+         (setf (slot-value chcm 'orgn) orgn)
+         (push chcm *flCLGB-list*)
+         chcm)))
+
+
+(DEFCLASS FILTERED-ALGEBRA (filtered-chain-complex algebra)
+    ())
+
+(DEFVAR *FLALGB-LIST*)
+(SETF *FLALGB-LIST* +empty-list+)
+(PUSHNEW '*FLALGB-LIST* *list-list*)
+
+(DEFMETHOD PRINT-OBJECT ((flalgb FILTERED-ALGEBRA) stream)
+(the FILTERED-ALGEBRA
+   (progn
+      (format stream "[K~D FILTERED-ALGEBRA]" (idnm flalgb))
+     flalgb)))
+
+(DEFUN FltrAlgb (idnm)
+   (declare (type fixnum idnm))
+   (the (or FILTERED-ALGEBRA null)
+      (find idnm *flalgb-list* :key #'idnm)))
+
+;; Function that builds a filtered algebra. 
+(DEFUN BUILD-FltrAlgb
+    (&key cmpr basis bsgn intr-dffr dffr-strt intr-aprd aprd-strt flin orgn)
+   (declare
+     (type cmprf cmpr)
+     (type intr-mrph intr-dffr intr-aprd)
+     (type basis basis)
+     (type gnrt bsgn)
+     (type strt dffr-strt aprd-strt)
+     (type chcm-flin flin)
+     (list orgn))
+   (the FILTERED-ALGEBRA
+     (progn
+         (let ((already (find orgn *flalgb-list* :key #'orgn :test #'equal)))
+            (declare (type (or null FILTERED-ALGEBRA) already))
+            (when already
+               (return-from build-FltrAlgb already)))
+         (let ((rslt (build-algb :cmpr cmpr :basis basis :bsgn bsgn
+                        :intr-dffr intr-dffr :dffr-strt dffr-strt
+                       :intr-aprd intr-aprf :aprd-strt aprd-strt
+                        :orgn orgn)))
+            (declare (type algebra rslt))
+            (change-class rslt 'FILTERED-ALGEBRA)
+            (setf (slot-value rslt 'flin) flin)
+            (push rslt *flalgb-list*)
+               rslt))))
+
+(defmethod change-chcm-to-flcc ((chcm algebra) flin flin-orgn )
+   (declare
+      
+      (type chcm-flin flin)
+      (list flin-orgn))
+   (the FILTERED-ALGEBRA
+      (progn
+         (change-class chcm 'FILTERED-ALGEBRA)
+         (setf orgn (append (orgn chcm) (list 'FILTERED-WITH) flin-orgn))
+         (let ((already (find orgn *flalgb-list* :key #'orgn :test #'equal)))
+            (declare (type (or null FILTERED-ALGEBRA) already))
+            (when already
+               (return-from change-chcm-to-flcc already)))
+         (setf (slot-value chcm 'flin) flin)
+         (setf (slot-value chcm 'orgn) orgn)
+         (push chcm *flaLGB-list*)
+         chcm)))
+
+
+(DEFCLASS FILTERED-HOPF-ALGEBRA (filtered-chain-complex hopf-algebra)
+    ())
+
+(DEFVAR *FLHOPF-LIST*)
+(SETF *FLHOPF-LIST* +empty-list+)
+(PUSHNEW '*FLHOPF-LIST* *list-list*)
+
+(DEFMETHOD PRINT-OBJECT ((flhopf FILTERED-HOPF-ALGEBRA) stream)
+(the FILTERED-HOPF-ALGEBRA
+   (progn
+      (format stream "[K~D FILTERED-HOPF-ALGEBRA]" (idnm flhopf))
+     flhopf)))
+
+(DEFUN FltrHopf (idnm)
+   (declare (type fixnum idnm))
+   (the (or FILTERED-HOPF-ALGEBRA null)
+      (find idnm *flhopf-list* :key #'idnm)))
+
+(defmethod change-chcm-to-flcc ((chcm hopf-algebra) flin flin-orgn )
+   (declare
+      
+      (type chcm-flin flin)
+      (list flin-orgn))
+   (the FILTERED-hofp-algebra
+      (progn
+         (change-class chcm 'FILTERED-hopf-COALGEBRA)
+        (setf orgn (append (orgn chcm) (list 'FILTERED-WITH) flin-orgn))
+         (let ((already (find orgn *flhopf-list* :key #'orgn :test #'equal)))
+            (declare (type (or null FILTERED-HOPF-COALGEBRA) already))
+            (when already
+               (return-from change-chcm-to-flcc already)))
+         (setf (slot-value chcm 'flin) flin)
+         (setf (slot-value chcm 'orgn) orgn)
+         (push chcm *flhopf-list*)
+         chcm)))
+
+
+(DEFCLASS FILTERED-SIMPLICIAL-SET (FILTERED-CHAIN-COMPLEX simplicial-set )
+    ())
+
+(DEFVAR *FLSMST-LIST*)
+(SETF *FLSMST-LIST* +empty-list+)
+(PUSHNEW '*FLSMST-LIST* *list-list*)
+
+(DEFMETHOD PRINT-OBJECT ((flsmst filtered-simplicial-set) stream)
+ (the filtered-simplicial-set
+   (progn
+      (format stream "[K~D Filtered-Simplicial-Set]" (idnm flsmst))
+      flsmst)))
+
+(DEFUN FltrSmSet (idnm)
+   (declare (type fixnum idnm))
+   (the (or filtered-simplicial-set null)
+      (find idnm *flsmst-list* :key #'idnm)))
+
+
+
+;; Function that builds a filtered simplicial set 
+(DEFUN BUILD-FltrSmSt
+    (&key cmpr basis bspn face face* intr-bndr bndr-strt intr-dgnl dgnl-strt flin orgn)
+   (declare
+     (type cmprf cmpr)
+     (type basis basis)
+     (type gmsm bspn)
+     (type face face)
+     (type (or null face*) face*)
+     (type (or intr-mrph null) intr-bndr intr-dgnl)
+        (type (or strt null) bndr-strt dgnl-strt)
+     (type chcm-flin flin)
+     (list orgn))
+   (the FILTERED-SIMPLICIAL-SET
+     (progn
+         (let ((already (find orgn *flsmst-list* :key #'orgn :test #'equal)))
+            (declare (type (or null FILTERED-SIMPLICIAL-SET) already))
+            (when already
+               (return-from build-FltrSmst already)))
+         (let ((rslt (build-smst :cmpr cmpr :basis basis :bspn bspn
+                       :face face :face* face* :intr-bndr intr-bndr 
+                       :bndr-strt bndr-strt :intr-dgnl intr-dgnl 
+                       :dgnl-strt dgnl :orgn orgn)))
+            (declare (type simplicial-set rslt))
+            (change-class rslt 'FILTERED-SIMPLICIAL-SET)
+            (setf (slot-value rslt 'flin) flin)
+            (push rslt *flsmst-list*)
+               rslt))))
+
+(defmethod change-chcm-to-flcc ((chcm simplicial-set) flin flin-orgn )
+   (declare
+      
+      (type chcm-flin flin)
+      (list flin-orgn))
+   (the FILTERED-SIMPLICIAL-SET
+      (progn
+         (change-class chcm 'FILTERED-SIMPLICIAL-SET)
+         (setf orgn (append (orgn chcm) (list 'FILTERED-WITH) flin-orgn))
+         (let ((already (find orgn *flsmst-list* :key #'orgn :test #'equal)))
+            (declare (type (or null FILTERED-SIMPLICIAL-SET) already))
+            (when already
+               (return-from change-chcm-to-flcc already)))
+         (setf (slot-value chcm 'flin) flin)
+         (setf (slot-value chcm 'orgn) orgn)
+         (push chcm *flsmst-list*)
+         chcm)))
+
+
+(DEFCLASS FILTERED-KAN (FILTERED-CHAIN-COMPLEX KAN )
+    ())
+
+(DEFVAR *FLKAN-LIST*)
+(SETF *FLKAN-LIST* +empty-list+)
+(PUSHNEW '*FLKAN-LIST* *list-list*)
+
+(DEFMETHOD PRINT-OBJECT ((flkan filtered-kan) stream)
+ (the filtered-kan
+   (progn
+      (format stream "[K~D Filtered-Kan-Simplicial-Set]" (idnm flkan))
+      flkan)))
+
+(DEFUN FltrKan (idnm)
+   (declare (type fixnum idnm))
+   (the (or filtered-kan null)
+      (find idnm *flkan-list* :key #'idnm)))
+
+(defmethod change-chcm-to-flcc ((chcm kan) flin flin-orgn )
+   (declare
+      
+      (type chcm-flin flin)
+      (list flin-orgn))
+   (the FILTERED-KAN
+      (progn
+         (change-class chcm 'FILTERED-KAN)
+         (setf orgn (append (orgn chcm) (list 'FILTERED-WITH) flin-orgn))
+         (let ((already (find orgn *flkan-list* :key #'orgn :test #'equal)))
+            (declare (type (or null FILTERED-KAN) already))
+            (when already
+               (return-from change-chcm-to-flcc already)))
+         (setf (slot-value chcm 'flin) flin)
+         (setf (slot-value chcm 'orgn) orgn)
+         (push chcm *flkan-list*)
+         chcm)))
+
+
+(DEFCLASS FILTERED-SIMPLICIAL-GROUP (FILTERED-CHAIN-COMPLEX SIMPLICIAL-GROUP )
+    ())
+
+(DEFCLASS FILTERED-AB-SIMPLICIAL-GROUP (FILTERED-CHAIN-COMPLEX AB-SIMPLICIAL-GROUP )
+    ())
+
+(DEFVAR *FLSMGR-LIST*)
+(SETF *FLSMGR-LIST* +empty-list+)
+(PUSHNEW '*FLSMGR-LIST* *list-list*)
+
+(DEFMETHOD PRINT-OBJECT ((flsmgr filtered-simplicial-group) stream)
+ (the filtered-simplicial-group
+   (progn
+      (format stream "[K~D Filtered-Simplicial-Group]" (idnm flsmgr))
+      flsmgr)))
+
+(DEFMETHOD PRINT-OBJECT ((flsmgr filtered-ab-simplicial-group) stream)
+ (the filtered-simplicial-group
+   (progn
+      (format stream "[K~D Filtered-Abelian-Simplicial-Group]" (idnm flsmgr))
+      flsmgr)))
+
+(DEFUN FltrSmgr (idnm)
+   (declare (type fixnum idnm))
+   (the (or filtered-simplicial-group null)
+      (find idnm *flsmgr-list* :key #'idnm)))
+
+(DEFUN BUILD-FltrSmGr
+    (&key cmpr basis bspn face face* intr-bndr bndr-strt intr-dgnl dgnl-strt 
+      sintr-grml sintr-grin flin orgn)
+   (declare
+     (type cmprf cmpr)
+     (type basis basis)
+     (type gmsm bspn)
+     (type face face)
+     (type (or null face*) face*)
+     (type (or intr-mrph null) intr-bndr intr-dgnl)
+        (type (or strt null) bndr-strt dgnl-strt)
+     (type sintr sintr-grml sintr-grin)
+     (type chcm-flin flin)
+     (list orgn))
+   (the FILTERED-SIMPLICIAL-GROUP
+     (progn
+         (let ((already (find orgn *flsmgr-list* :key #'orgn :test #'equal)))
+            (declare (type (or null FILTERED-SIMPLICIAL-GROUP) already))
+            (when already
+               (return-from build-FltrSmgr already)))
+         (let ((rslt (build-smgr :cmpr cmpr :basis basis :bspn bspn
+                       :face face :face* face* :intr-bndr intr-bndr 
+                       :bndr-strt bndr-strt :intr-dgnl intr-dgnl 
+                       :dgnl-strt dgnl :sintr-grml sintr-grml
+                       :sintr-grin sintr-grin :orgn orgn)))
+            (declare (type simplicial-group rslt))
+            (change-class rslt 'FILTERED-SIMPLICIAL-GROUP)
+            (setf (slot-value rslt 'flin) flin)
+            (push rslt *flsmgr-list*)
+               rslt))))
+
+(DEFMACRO BUILD-FlABSMGR (&rest rest)
+  `(change-class (build-flsmgr ,@rest) 'filtered-ab-simplicial-group))
+
+(defmethod change-chcm-to-flcc ((chcm simplicial-group) flin flin-orgn )
+   (declare
+      
+      (type chcm-flin flin)
+      (list flin-orgn))
+   (the FILTERED-SIMPLICIAL-GROUP
+      (progn
+         (change-class chcm 'FILTERED-SIMPLICIAL-GROUP)
+         (setf orgn (append (orgn chcm) (list 'FILTERED-WITH) flin-orgn))
+         (let ((already (find orgn *flsmgr-list* :key #'orgn :test #'equal)))
+            (declare (type (or null FILTERED-SIMPLICIAL-GROUP) already))
+            (when already
+               (return-from change-chcm-to-flcc already)))
+         (setf (slot-value chcm 'flin) flin)
+         (setf (slot-value chcm 'orgn) orgn)
+         (push chcm *flsmgr-list*)
+         chcm)))
+
+(defmethod change-chcm-to-flcc ((chcm ab-simplicial-group) flin flin-orgn )
+   (declare
+      
+      (type chcm-flin flin)
+      (list flin-orgn))
+   (the FILTERED-AB-SIMPLICIAL-GROUP
+      (progn
+         (change-class chcm 'AB-FILTERED-SIMPLICIAL-GROUP)
+         (setf orgn (append (orgn chcm) (list 'FILTERED-WITH) flin-orgn))
+         (let ((already (find orgn *flabsmgr-list* :key #'orgn :test #'equal)))
+            (declare (type (or null FILTERED-AB-SIMPLICIAL-GROUP) already))
+            (when already
+               (return-from change-chcm-to-flcc already)))
+         (setf (slot-value chcm 'flin) flin)
+         (setf (slot-value chcm 'orgn) orgn)
+         (push chcm *flabsmgr-list*)
+         chcm)))
+
+        
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;    EXAMPLES    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+;; BICOMPLEXES
+
+;; Filtration index function of a Bicomplex (first degree of a generator).
+(setf BCflin 
+      #'(lambda (degr gnrt)
+       (declare 
+         (type fixnum degr)
+         (type gnrt gnrt))
+       (let* ((degr1 (BcGnrt-Degr1 gnrt))
+              (degr2 (BcGnrt-Degr2 gnrt)))
+          (declare (type fixnum degr1 degr2))
+          (if (=  degr (+ degr1 degr2))
+             degr1
+             0))))
+
+#|
+(funcall BCflin 5 (build-bcgnrt 2 3 'a))
+(funcall BCflin 7 (build-bcgnrt 6 1 'c))
+|# 
+
+;; Function that changes the bicomplex bc to a filtered complex, with filtration
+;; index of a generator defined as its first degree. 
+(defun CHANGE-BICM-TO-FLCC (bc)
+   (declare 
+     (type bicomplex bc))
+   (let* ((orgn (orgn bc))
+          (flin BCflin))
+      (declare
+       (type list orgn)
+       (type chcm-flin flin))
+      (the FILTERED-CHAIN-COMPLEX
+        (change-chcm-to-flcc bc flin '(Bicomplex-Flin)))))
+
+#|
+(defun bas (degr1 degr2)
+   (if (and (= degr1 0) (= degr2 1)) (return-from bas '(a)))
+   (if (and (= degr1 1) (= degr2 0)) (return-from bas '(b)))
+   (if (and (= degr1 1) (= degr2 1)) (return-from bas '(c)))
+   (if (and (= degr1 2) (= degr2 0))  (return-from bas '(d)))
+   (return-from bas nil))
+ 
+(defun dif1 (degr1 degr2 gnrt)
+   (if (and (= degr1 1) (= degr2 1) (eql gnrt 'c)) (return-from dif1 (list (cons 2 'a))))
+   (if (and (= degr1 2) (= degr2 0) (eql gnrt 'd)) (return-from dif1 (list (cons 2 'b))))
+   (return-from dif1 nil))
+(defun dif2 (degr1 degr2 gnrt)
+   (if (and (= degr1 1) (= degr2 1) (eql gnrt 'c)) (return-from dif2 (list (cons 1 'b))))
+   (return-from dif2 nil))
+
+(setf bc (Build-Bicm :bcbasis #'bas :dffr1 #'dif1 :dffr2 #'dif2 :cmpr 's-cmpr 
+          :orgn '(BC-test)))
+
+(change-bicm-to-flcc bc)
+(flin bc 1 (build-bcgnrt 0 1 'a))
+(flin bc (cmbn 2 4 (build-bcgnrt 1 1 'c)))
+(flin bc (cmbn 2 4 (build-bcgnrt 1 1 'c) 2 (build-bcgnrt 2 0 'd)))
+(bigrd-basis bc 1 1)
+(bigrd-basis bc 2 0)
+(fltrd-basis bc 2 1)
+(ordered-basis bc 2)
+(flcc-dffr-mtrx bc 2 1)
+(flcc-dffr-mtrx bc 2 2)
+|#
+
+
+;; BARS
+
+(defun abar-bidegree (abar)
+    (declare (type abar abar))
+    (the list
+      (let ((p (1- (length abar)))
+            (q 0))
+        (declare (type fixnum p q))
+        (setf q (apply #'+ (mapcar #'car (rest abar))))
+        (decf q p)
+        (return-from abar-bidegree (list p q)))))
+
+
+(setf abar-flin 
+      #'(lambda (degr abar)
+       (declare (type fixnum degr)
+         (type abar abar))
+       (let* ((abar-bidgr (abar-bidegree abar))
+              (degr1 (first abar-bidgr))
+             (degr2 (second abar-bidgr)))
+         (if (=  degr (+ degr1 degr2))
+           degr1
+          0))))
+
+#|
+(setq kz2 (k-z2-1))
+(setq bar2 (bar kz2))
+
+(change-chcm-to-flcc bar2 abar-flin '(abar-flin))
+
+
+(setf basis7 (basis bar2 7))
+
+(mapcar
+ #'(lambda (gnrt)
+     (flin bar2 7 gnrt))
+ basis7)
+
+(flin bar2 (cmbn 7 (first basis7) (second basis7))) 
+
+(bigrd-basis bar2 2 5)
+(bigrd-basis bar2 3 4)
+(fltrd-basis bar2 7 2)
+(ordered-basis bar2 7)
+(flcc-dffr-mtrx bar2 7 2)
+(flcc-dffr-mtrx bar2 7 3)
+|#
+
+;; COBAR
+
+(defun allp-bidegree (allp)
+    (declare (type allp allp))
+    (the list
+      (let ((p (1- (length allp)))
+            (q 0))
+        (declare (type fixnum p q))
+        (setf q (apply #'+ (mapcar #'car (rest allp))))
+        (incf q p)
+        (return-from allp-bidegree (list (- p) q)))))
+
+(setf cobar-flin 
+      #'(lambda (degr allp)
+       (declare (type fixnum degr)
+         (type allp allp))
+       (let* ((allp-bidgr (allp-bidegree allp))
+              (degr1 (first allp-bidgr))
+             (degr2 (second allp-bidgr)))
+         (if (=  degr (+ degr1 degr2))
+           degr1
+          0))))
+
+;; TENSOR PRODUCTS 
+ 
+(setf tnpr-flin 
+      #'(lambda (degr tnpr)
+       (declare 
+         (type fixnum degr)
+         (type tnpr tnpr))
+       (the fixnum
+          (degr1 tnpr))))
+
+
+;; FIBRATIONS (CARTESIAN PRODUCTS AND TWISTED PRODUCTS)
+
+(setf crpr-flin 
+      #'(lambda (degr crpr)
+          (declare
+           (type fixnum degr)
+           (type crpr crpr))
+          (let* ((b (cadr crpr))
+                 (dgop (car b)))
+             (declare
+              (type iabsm b)
+              (type fixnum dgop))
+             (the fixnum
+               (- degr (length (dgop-int-ext dgop)))))))
+
+#|
+(funcall fbrt-flin 3 '(:crpr (1 . s2) 0 . 3))
+(funcall fbrt-flin 4 '(:crpr (5 . s2) 0 . 3))
+|# 
+ 
+
+;; BICONES
+ 
+(defun bicone-flin (flinb flinc flind)
+   (declare (type chcm-flin flinb flinc flind))
+   (flet ((rslt (degr bicn)
+            (declare 
+              (type bicn bicn)
+              (type degr degr))
+            (let ((bcnx (bcnx bicn)))
+               (declare (type (member :bcnb :bcnc :bcnd) bcnx))
+               (if (eql :bcnb bcnx)
+                  (funcall flinb degr (ibicn bicn))
+                  (if (eql :bcnc bcnx)
+                     (funcall flinc degr (ibicn bicn))
+                     (funcall flind degr (ibicn bicn)))))))
+     (the chcm-flin #'rslt))) 
\ No newline at end of file
diff --git a/examples/anromero/filtered-complexes/spectral-sequences.lsp b/examples/anromero/filtered-complexes/spectral-sequences.lsp
new file mode 100644
index 0000000..4b55947
--- /dev/null
+++ b/examples/anromero/filtered-complexes/spectral-sequences.lsp
@@ -0,0 +1,1359 @@
+;; SPECTRAL-SEQUENCES   SPECTRAL-SEQUENCES   SPECTRAL-SEQUENCES   SPECTRAL-SEQUENCES
+;; SPECTRAL-SEQUENCES   SPECTRAL-SEQUENCES   SPECTRAL-SEQUENCES   SPECTRAL-SEQUENCES
+;; SPECTRAL-SEQUENCES   SPECTRAL-SEQUENCES   SPECTRAL-SEQUENCES   SPECTRAL-SEQUENCES
+
+
+(IN-PACKAGE "COMMON-LISP-USER")
+
+(provide "spectral-sequences")
+
+
+
+;; Auxiliary functions to deal with matrices
+
+(defun submatrix (mtrx first-line last-line first-col last-col)
+   (declare (type matrix mtrx)
+            (type fixnum first-line last-line first-col last-col))
+  (the matrix
+    (let ((line-n (line-number mtrx))
+	  (column-n (column-number mtrx)))
+      (declare (type fixnum line-n column-n))
+      (assert (<= first-line last-line (1- line-n)))
+      (assert (<= first-col last-col (1- column-n)))
+      (let* ((line-num (+ (- last-line first-line) 1))
+             (column-num (+ (- last-col first-col) 1))
+             (rslt (make-array (list line-num column-num)
+			      :element-type 'fixnum)))
+         (declare (type fixnum line-num column-num) 
+                  (type matrix rslt))
+         (dotimes (il line-num)
+            (declare (type fixnum il))
+            (dotimes (ic column-num)
+               (declare (type fixnum ic))
+               (setf (aref rslt il ic)
+                     (aref mtrx (+ il first-line) (+ ic first-col)))))
+         rslt))))
+
+#|
+(setf m (random-matrix 4 6 10))
+(submatrix m 1 3 2 4)
+|#
+
+
+(Defun column-j (mtrx j)
+   (declare (type matrix mtrx)
+            (type fixnum j))
+   (assert (< j (column-number mtrx)))
+   (the list
+     (let ((line-n (line-number mtrx)))
+        (declare (type fixnum line-n))
+        (mapcar
+         #'(lambda (i)
+             (declare (type fixnum i))
+             (aref mtrx i j))
+         (<a-b> 0 (1- line-n))))))
+
+#|
+(setf m (random-matrix 4 6 10))
+(column-j m 2)
+|#
+
+;; Function that concatenates two matrices (if their line number is different, the 
+;; needed zeros are added. 
+(defun mtrx-conc (mtrx1 mtrx2)
+   (declare (type matrix mtrx1 mtrx2))
+   (the matrix
+     (let* ((line-n-1 (line-number mtrx1))
+            (column-n-1 (column-number mtrx1))
+            (line-n-2 (line-number mtrx2))
+            (column-n-2 (column-number mtrx2))
+            (line-n (max line-n-1 line-n-2))
+            (column-n (+ column-n-1 column-n-2)))
+        (declare (type fixnum line-n-1 column-n-1 line-n-2
+                   column-n-2 line-n column-n))
+        (let ((rslt 
+                #-ACLPC
+                (make-array (list line-n column-n)
+                  :element-type 'fixnum
+                  :initial-element 0)
+                #+ACLPC
+                (if (or (zerop line-n) (zerop column-n))
+                   (make-array (list line-n column-n)
+                     :element-type 'fixnum)
+                   (make-array (list line-n column-n)
+                     :element-type 'fixnum
+                     :initial-element 0))))
+           (declare (type matrix rslt))
+           (do ((j 0 (1+ j)))
+               ((>= j column-n-1))
+              (declare (type fixnum j))
+              (do ((i 0 (1+ i)))
+                   ((>= i line-n-1))
+                 (declare (type fixnum i))
+                 (Setf (aref rslt i j) (aref mtrx1 i j))))
+           (do ((j 0 (1+ j)))
+                ((>= j column-n-2))
+              (declare (type fixnum j))
+              (do ((i 0 (1+ i)))
+                   ((>= i line-n-2))
+                 (declare (type fixnum i))
+                 (Setf (aref rslt i (+ column-n-1 j)) (aref mtrx2 i j))))
+            rslt))))
+
+#|
+(setf m1 (random-matrix 3 4 10))
+(setf m2 (random-matrix 4 2 10))
+(mtrx-conc m1 m2)
+(mtrx-conc m2 m1)
+|#
+
+ 
+;; Functions related with submodules and matrices
+
+;; Function that returns a list of generators of the kernel of a matrix.
+;; Each generator is a list of integers which represent its coordinates
+;; in the initial basis.
+(defun kernel (mtrx)
+   (declare (type matrix mtrx))
+   (the list
+     (let* ((smith-list (smith mtrx))
+            (m (third smith-list))
+            (q (fourth smith-list))
+            (min (min (line-number mtrx) (column-number mtrx)))
+            (rslt nil))
+        (declare 
+          (type list smith-list rslt)
+          (type matrix m q)
+          (type fixnum min))
+        (progn
+         (do ((j (1- (column-number mtrx)) (1- j)))
+             ((< j min))
+            (declare (type fixnum j))
+            (setq rslt (nconc (list (column-j q j)) rslt)))
+         (do ((i (1- min) (1- i)))
+             ((or (< i 0) (not (eql  0 (aref m i i)))))
+            (declare (type fixnum i))
+            (setq rslt (nconc (list (column-j q i)) rslt)))
+         rslt))))
+
+#|
+(setf m (random-matrix 3 4 10))
+(kernel m)
+|#
+
+
+;; Returns a matrix which has as columns the elements of the list.
+;; (Each element in the list is a list of integers).
+(defun Gnrt-List-to-Mtrx (gnrt-list)
+   (declare (type list gnrt-list))
+   (the matrix
+     (let* ((column-n (length gnrt-list))
+            (line-n (length (car gnrt-list)))
+            (rslt 
+              #-ACLPC
+              (make-array (list line-n column-n)
+                :element-type 'fixnum
+                :initial-element 0)
+              #+ACLPC
+              (if (or (zerop line-n) (zerop column-n))
+                 (make-array (list line-n column-n)
+                   :element-type 'fixnum)
+                 (make-array (list line-n column-n)
+                   :element-type 'fixnum
+                   :initial-element 0))))
+        (declare 
+          (type fixnum column-n line-n)
+          (type matrix rslt))
+        (do ((j 0 (1+ j))
+             (mark2 gnrt-list (cdr mark2)))
+            ((endp mark2))
+           (declare
+            (type fixnum j)
+            (list mark2)) 
+           (if (eql line-n (length (car mark2)))
+              (do ((i 0 (1+ i))
+                   (mark1 (car mark2) (cdr mark1)))
+                  ((endp mark1))
+                 (declare 
+                   (type fixnum i)
+                   (list mark1))
+                 (setf (aref rslt i j) (car mark1)))))
+        rslt)))
+
+#|
+(setq gnrt-list (list '(2 4 6 8) '(0 1 0 0) '(0 3 3 3)))
+(Gnrt-List-to-Mtrx gnrt-list)
+|# 
+
+;; Returns the list of columns of the matrix mtrx.
+(defun gnrt-mtrx-to-list (mtrx)
+   (declare (type matrix mtrx))
+   (the list
+     (let* ((column-n (column-number mtrx)))
+        (declare (type fixnum column-n))
+        (mapcar
+         #'(lambda (j)
+             (declare (type fixnum j))
+             (column-j mtrx j))
+       (<a-b> 0 (1- column-n))))))
+
+#|
+(setf m (random-matrix 3 4 10))
+(gnrt-mtrx-to-list m)
+|#
+
+;; Returns the representation basis-divisors of a quotient of submodules B/C
+;; which are the images of the matrices mtrx1 and mtrx2, where basis=list
+;; of combinations (c_1...c_m) that forms a basis for B and divisors=list of
+;; integers (n_1....n_m) such that (n_1*c_1,...,n_m*c_m) forms a basis for C. 
+(defun mtrx-quotient (mtrx1 mtrx2)
+   (declare (type matrix mtrx1 mtrx2))
+   (the list
+     (let* ((smith-list-1 (smith mtrx1))
+            (p1 (first smith-list-1))
+            (p1-1 (second smith-list-1))
+            (d1 (third smith-list-1))
+            (p1-1Xmtrx2 (mtrx-prdc p1-1 mtrx2))
+            (p1Xd1 (copy-mtrx p1))
+            (d1-1Xp1-1Xmtrx2 (copy-mtrx p1-1Xmtrx2)))
+        (declare
+         (list smith-list-1)
+         (type matrix p1 p1-1 s1 p1-1Xmtrx2 p1Xd1 d1-1Xp1))
+        (progn
+         (let* ((line-n-1 (line-number p1))
+                (column-n-1 (column-number p1)))
+            (declare (type fixnum line-n-1 column-n-1))
+            (dotimes (ic column-n-1)
+               (declare (type fixnum ic))
+               (if (and (< ic (line-number d1)) (< ic (column-number d1)))
+                  (let ((d (aref d1 ic ic)))
+                     (declare (type fixnum d))
+                     (dotimes (il line-n-1)
+                        (declare (type fixnum il))
+                        (if (and (not (eql 1 d)) (not (eql 0 d)))
+                           (setf (aref p1Xd1 il ic) (* d (aref p1Xd1 il ic)))))))))
+         (let* ((line-n-2 (line-number p1-1Xmtrx2))
+                (column-n-2 (column-number p1-1Xmtrx2)))
+            (declare (type fixnum line-n-2 column-n-2))    
+            (dotimes (il line-n-2)
+               (declare (type fixnum il))
+               (if (and (< il (line-number d1)) (< il (column-number d1)))
+                  (let ((d (aref d1 il il)))
+                     (if (and (not (eql 1 d)) (not (eql 0 d)))
+                        (dotimes (ic column-n-2)
+                           (declare (type fixnum ic))
+                           (setf (aref d1-1Xp1-1Xmtrx2 il ic) 
+                                 (floor (aref d1-1Xp1-1Xmtrx2 il ic) d))))))))
+         (let* ((smith-list-2 (smith d1-1Xp1-1Xmtrx2))
+                (p2 (first smith-list-2))
+                (basis-mtrx (mtrx-prdc p1Xd1 p2))
+                (div-mtrx (third smith-list-2))
+                (cmbns nil)
+                (divs nil))
+            (declare 
+              (list smith-list-2 cmbns divs)
+              (type matrix p2 basis-mtrx div-mtrx))
+            (do ((i 0 (1+ i)))
+                ((or (>= i (line-number d1)) (>= i (column-number d1))
+                     (eql 0 (aref d1 i i))))
+               (declare (type fixnum i))
+               (progn
+                (setq cmbns (nconc cmbns (list (column-j basis-mtrx i))))
+                (if (and (< i (line-number div-mtrx)) (< i (column-number div-mtrx))) 
+                   (setq divs (nconc divs (list (aref div-mtrx i i))))
+                   (setq divs (nconc divs (list 0))))))
+            (list cmbns divs))))))
+
+#|
+(setf m1 (gnrt-list-to-mtrx '((1 1 1 1) (0 2 0 3) (1 0 0 0))))
+(setf m2 (gnrt-list-to-mtrx '((2 3 1 4) (0 1 1 1))))
+(mtrx-quotient m1 m2)
+|#
+
+
+
+;; SPECIFIC FUNCTIONS FOR THE COMPUTATION OF SPECTRAL SEQUENCES 
+;; OF EFFECTIVE FILTERED COMPLEXES.
+
+
+;; GROUPS
+
+;; Returns the matrix that defines Z^r_{p,q} (a submatrix of the 
+;; differential matrix M, such that the elements of Z^r_{p,q} are those that
+;; when we apply M to them we obtain zero, i.e. Z^r_{p,q}=Ker M). Only can be applied
+;; to a finitely generated complex. 
+(defun FLTR-CHCM-Z-MTRX (fltrcm r p q)
+  (declare
+    (type filtered-chain-complex fltrcm)
+    (type fixnum r p q))
+  (the matrix
+    (let* ((cmpr (cmpr1 fltrcm))
+	     (dffr (dffr fltrcm))
+	     (degr (+ p q))
+           (sbasis (fltrd-basis fltrcm degr p))
+           (tbasis 
+             (mapcan 
+              #'(lambda (i)
+                  (declare (type fixnum i))
+                  (bigrd-basis fltrcm i (- (1- degr) i)))
+              (<a-b> (1+ (- p r)) p)))) ;; We suppose that the differential
+                                        ;; respects the filtration, i.e., 
+                                        ;; d(F_pX) \in F_p(dX). If not, we must
+                                        ;; consider (<a-b> (1+ (-p r)) t(degr),
+                                        ;; where t(degr)=max{flin(x), x \in X_degr}.
+       (declare
+        (type cmprf cmpr)
+        (type morphism dffr)
+        (type fixnum degr)
+        (list sbasis tbasis))
+      (let ((srank (length sbasis))
+	      (trank (length tbasis)))
+         (declare (type fixnum srank trank))
+         (let ((rslt 
+               #-ACLPC
+                    (make-array (list trank srank)
+				:element-type 'fixnum
+				:initial-element 0)
+               #+ACLPC
+                    (if (or (zerop srank) (zerop trank))
+                       (make-array (list trank srank)
+                          :element-type 'fixnum)
+                       (make-array (list trank srank)
+                          :element-type 'fixnum
+                          :initial-element 0))))               
+            (declare (type matrix rslt))
+            (do ((j 0 (1+ j))
+	           (mark sbasis (cdr mark)))
+                ((endp mark))
+               (declare
+                (type fixnum j)
+                (list mark))
+               (let ((cmbn (gnrt-? dffr degr (car mark))))
+                  (declare (type cmbn cmbn))
+                  (do ((mark1 (cmbn-list cmbn) (cdr mark1)))
+                      ((endp mark1))
+                     (declare (list mark1))
+                     (with--term (cffc gnrt) mark1
+                       (declare 
+                         (type fixnum cffc)
+                         (type gnrt gnrt))
+                       (do ((mark2 tbasis (cdr mark2))
+                            (i 0 (1+ i))
+                            (found nil))
+                           ((or (endp mark2) found))
+                          (declare 
+                            (list mark2)
+                            (type fixnum i found))
+                          (if (eq :equal (funcall cmpr gnrt (car mark2)))
+                             (progn
+                              (setq found 1)
+                              (setf (aref rslt i j) cffc))))))))
+               rslt)))))
+
+#|
+(cat-init)
+(setq kz2 (k-z2-1))
+(setq fcc (bar kz2))
+(Change-Chcm-TO-Flcc fcc abar-flin `(abar-flin))
+(FLTR-CHCM-Z-MTRX fcc 2 3 2)
+(FLTR-CHCM-Z-MTRX fcc 1 2 4)
+|#
+ 
+
+;; Returns a list of generators (list of coordinates) of Z^r_{p,q}
+;; (only for finitely generated complexes)
+(defun Fltr-Chcm-Z-Gnrt-List (FltrCm r p q)
+   (declare (type filtered-chain-complex fltrcm)
+     (type fixnum r p q))
+   (the list
+         (let* ((degr (+ p q))
+                (all-basis-gnrt-list (fltr-basis-gnrt-list fltrcm degr p)))
+            (declare
+             (type fixnum degr)
+             (list all-basis-gnrt-list))
+            (if (= 0 r)
+               all-basis-gnrt-list
+               (let* ((mat (FLTR-CHCM-Z-MTRX fltrcm r p q))
+                   (line-n (line-number mat))
+                   (column-n (column-number mat)))
+                  (declare 
+                    (type matrix mat)
+                    (type fixnum line-n column-n))
+                  (if (= 0 column-n) nil
+                     (if (= 0 line-n)
+                     all-basis-gnrt-list
+                     (kernel mat))))))))
+#|
+(Fltr-Chcm-Z-Gnrt-List fcc 2 3 2)
+(Fltr-Chcm-Z-Gnrt-List fcc 1 2 4)
+|# 
+
+;; Returns a list of lists with the coordinates of the elements of
+;; the basis of F_pX_n (with p=fltr-index, n=degr), that are lists with
+;; the form (0...0 i 0...0) (only for finitely generated complexes)
+(defun fltr-basis-gnrt-list (FltrCm degr fltr-index)
+   (declare 
+     (type filtered-chain-complex fltrcm)
+     (type fixnum degr fltr-index))
+   (the list
+     (let* ((all-basis (fltrd-basis fltrcm degr fltr-index))
+            (basis-l (length all-basis))
+            (rslt 
+              (the list
+                (mapcar
+                 #'(lambda (i)
+                     (nconc (make-list (1- i) :initial-element 0) 
+                       (list 1) (make-list (- basis-l i) :initial-element 0)))
+                 (<a-b> 1 basis-l)))))
+        rslt)))
+
+#|
+(fltr-basis-gnrt-list fcc 6 2)
+|#
+ 
+
+;; Returns the matrix of the generators of the numerator in E^r_{p,q}
+;; (Only for finitely generated complexes)
+(defun spsq-num-mtrx (FltrCm r p q)
+  (the matrix
+    (let* ((degr (+ p q))
+           (fltr-p-basis (fltrd-basis fltrcm degr p))
+           (p-basis-l (length fltr-p-basis))
+           (z1-list (fltr-chcm-z-gnrt-list fltrcm r p q))
+           (fltr-p-1-list (fltr-basis-gnrt-list fltrcm degr (1- p)))
+           (z1-mtrx (gnrt-list-to-mtrx z1-list))
+           (fltr-p-1-mtrx (gnrt-list-to-mtrx fltr-p-1-list))
+           (num1-mtrx (mtrx-conc z1-mtrx fltr-p-1-mtrx))
+           (num1-line-n (line-number num1-mtrx)))
+       (declare
+        (type fixnum degr num1-line-n)
+        (type list fltr-p-basis p-basis-l z1-list fltr-p-1-list)
+        (type matrix z1-mtrx fltr-p-1-mtrx num1-mtrx))
+       (if (eql num1-line-n p-basis-l)
+          num1-mtrx 
+          (let* ((num-line-n p-basis-l)
+                 (num-column-n (column-number num1-mtrx))
+                 (rslt  
+                   #-ACLPC (make-array (list num-line-n num-column-n)
+                             :element-type 'fixnum
+                             :initial-element 0)
+                   #+ACLPC
+                   (if (or (zerop num-line-n) (zerop num-column-n))
+                      (make-array (list num-line-n num-column-n)
+                        :element-type 'fixnum)
+                      (make-array (list num-line-n num-column-n)
+                        :element-type 'fixnum
+                        :initial-element 0))))
+             (declare
+              (type fixnum num-lin-n num-column-n)
+              (type matrix rslt))
+             (do ((j 0 (1+ j)))
+                 ((>= j num-column-n))
+                (declare (type fixnum j))
+                (do ((i 0 (1+ i)))
+                    ((>= i num1-line-n))
+                   (declare (type fixnum i))
+                   (Setf (aref rslt i j) (aref num1-mtrx i j))))
+             rslt)))))
+
+#|
+(spsq-num-mtrx fcc 2 3 2)
+(spsq-num-mtrx fcc 1 2 4)
+|# 
+
+;; Returns the matrix of the generators of the denominator in E^r_{p,q}
+;; (Only for finitely generated complexes) 
+(defun spsq-den-mtrx (FltrCm r p q)
+   (the matrix
+     (let* ((degr (+ p q))
+            (fltr-p-basis (fltrd-basis fltrcm degr p))
+            (p-basis-l (length fltr-p-basis))
+            (fltr-p-1-list (fltr-basis-gnrt-list fltrcm degr (1- p)))
+            (z2-list (fltr-chcm-z-gnrt-list fltrcm (1- r) (1- (+ p r)) (+ 2 (- q r))))
+            (z2-mtrx (gnrt-list-to-mtrx z2-list))
+            (fltr-p-1-mtrx (gnrt-list-to-mtrx fltr-p-1-list))
+            (dffr-mtrx (flcc-dffr-mtrx fltrcm (1+ degr) (1- (+ p r))))
+            (nil-mtrx 
+              #-ACLPC (make-array (list 0 0)
+                        :element-type 'fixnum
+                        :initial-element 0)
+              #+ACLPC (make-array (list 0 0)
+                        :element-type 'fixnum))
+            (dffr-z2-mtrx 
+              (if (or (= 0 (array-total-size z2-mtrx)) (= 0 (array-total-size dffr-mtrx)))
+                 nil-mtrx
+                 (mtrx-prdc dffr-mtrx z2-mtrx)))
+            (bnd-z2-line-n p-basis-l)
+            (bnd-z2-column-n (column-number dffr-z2-mtrx))
+            (bnd-z2-mtrx
+             (if (or (= 0 bnd-z2-line-n) (= 0 bnd-z2-column-n))
+                nil-mtrx
+                (submatrix dffr-z2-mtrx 0 (1- bnd-z2-line-n) 0 (1- bnd-z2-column-n))))
+            (den1-mtrx (mtrx-conc bnd-z2-mtrx fltr-p-1-mtrx))
+            (den-column-n (column-number den1-mtrx))
+            (den-line-n p-basis-l)
+            (rslt  
+              #-ACLPC (make-array (list den-line-n den-column-n)
+                        :element-type 'fixnum
+                        :initial-element 0)
+              #+ACLPC
+              (if (or (zerop den-line-n) (zerop den-column-n))
+                 (make-array (list den-line-n den-column-n)
+                   :element-type 'fixnum)
+                 (make-array (list den-line-n den-column-n)
+                   :element-type 'fixnum
+                   :initial-element 0))))
+        (declare
+             (list fltr-p-basis fltr-p-1-list z2-list)
+             (type fixnum degr p-basis-l bnd-z2-line-n bnd-z2-column-n den-column-n den-line-n)
+             (type matrix z2-mtrx fltr-p-1-mtrx dffr-mtrx nil-mtrx 
+               dffr-z2-mtrx bnd-z2-mtrx den1-mtrx rslt))
+        (do ((j 0 (1+ j)))
+            ((>= j den-column-n))
+           (declare (type fixnum j))
+           (do ((i 0 (1+ i)))
+               ((>= i (min den-line-n (line-number den1-mtrx))))
+              (declare (type fixnum i))
+              (Setf (aref rslt i j) (aref den1-mtrx i j))))
+        rslt)))
+                   
+#|
+(spsq-den-mtrx fcc 2 3 2)
+(spsq-den-mtrx fcc 1 2 4)
+|#   
+
+;; Function that returns the representation basis-divisors of E^r_{p,q} of a
+;; finitely generated complex. 
+(defun eff-spsq-basis-dvs (FltrCm r p q)
+   (declare 
+     (type filtered-chain-complex fltrcm)
+     (type fixnum r p q))
+   (the list
+     (let* ((degr (+ p q))
+            (fltr-p-basis (fltrd-basis fltrcm degr p))
+            (p-basis-l (length fltr-p-basis))
+            (num-mtrx (spsq-num-mtrx fltrcm r p q))
+            (den-mtrx (spsq-den-mtrx fltrcm r p q)) 
+            (cmbn-list nil)
+            (divs nil))
+        (declare
+         (list fltr-p-basis cmbn-list divs)
+         (type fixnum degr p-basis-l)
+         (type matrix num-mtrx den-mtrx))
+        (progn
+         (if (= 0 (array-total-size num-mtrx))
+            (progn
+             (setq cmbn-list nil)
+             (setq divs nil))
+            (if (= 0 (array-total-size den-mtrx))
+               (progn
+                (setq cmbn-list (gnrt-mtrx-to-list num-mtrx))
+                (setq divs (make-list (length cmbn-list) :initial-element 0)))
+               (let ((quotient-list (mtrx-quotient num-mtrx den-mtrx)))
+                  (declare (list quotient-list))
+                  (setq cmbn-list (first quotient-list)
+                    divs (second quotient-list)))))
+         (list
+          (mapcar 
+            #'(lambda (int-list)
+                (declare (list int-list))
+                (the cmbn
+                  (let* ((cmbn (cmbn degr))
+                         (cmpr (cmpr fltrcm)))
+                     (declare 
+                       (type cmbn cmbn)
+                       (type cmprf cmpr))
+                     (do ((mark1 int-list (cdr mark1))
+                          (mark2 fltr-p-basis (cdr mark2)))
+                         ((or (endp mark1) (endp mark2)))
+                        (declare (type list mark1 mark2))
+                        (if (not (= 0 (car mark1)))
+                           (setq cmbn (2cmbn-add cmpr cmbn 
+                                        (cmbn degr (car mark1) (car mark2))))))
+                     cmbn))) 
+            cmbn-list)
+          divs)))))
+
+#|
+(do ((r 1 (1+ r)))
+    ((> r 3))
+   (dotimes (n 8)
+      (dotimes (p (+ n 1))
+         (let ((q (- n p)))
+            (print (list r p q))
+            (princ (eff-spsq-basis-dvs fcc r p q))
+            ))))
+|# 
+
+
+(defun eff-spsq-gnrts (FltrCm r p q)
+   (declare 
+     (type filtered-chain-complex fltrcm)
+     (type fixnum r p q))
+   (let* ((basis-dvs (eff-spsq-basis-dvs fltrcm r p q))
+         (basis (first basis-dvs))
+         (dvs (second basis-dvs))
+         (rslt nil))
+      (declare (type list basis-dvs basis dvs rslt))
+      (do ((mark1 basis (cdr mark1))
+           (mark2 dvs (cdr mark2)))
+          ((endp mark1))
+         (if (not (eql 1 (car mark2)))
+            (setf rslt (append rslt (list (car mark1))))))
+      rslt))
+      
+ 
+;; Function that presents on the screen the components of the E^r_{p,q}
+;; of the spectral sequence of a filtered complex.
+(defun eff-spsq-group (fltrcm r p q)
+   (declare 
+     (type filtered-chain-complex fltrcm)
+     (type fixnum r p q))  
+   (let* ((basis-dvs (eff-spsq-basis-dvs fltrcm r p q))
+          (cmbns (first basis-dvs))
+          (divs (second basis-dvs)))
+      (declare (list basis-dvs cmbns divs))
+      (format t "Spectral sequence E^~D_{~D,~D}" r p q)
+      (dolist (item divs)
+         (declare (type fixnum item))
+         (if (not (eql 1 item))
+            (progn
+             (format t "~2%Component Z")
+             (unless (zerop item) 
+                (format t "/~DZ" item))
+             )))
+      (terpri)))
+
+#|
+(do ((r 1 (1+ r)))
+    ((> r 3))
+   (dotimes (n 8)
+      (dotimes (p (+ n 1))
+         (let ((q (- n p)))
+            (eff-spsq-group fcc r p q)
+            (terpri)
+            (terpri)
+            ))))
+|# 
+
+
+
+;; DIFFERENTIAL FUNCTIONS
+
+;; Auxiliary functions to deal with coefficients of elements with regard to 
+;; some generators or elements of a basis. 
+
+
+;; Function that returns the coordinates of a vector vctr with regard to
+;; the basis whose elements are the columns of the matrix gnrt-mtrx.
+(defun vctr-coordinates (vctr gnrt-mtrx)
+   (declare 
+     (type list vctr)
+     (type matrix gnrt-mtrx))
+   (the list
+     (let* ((C (gnrt-list-to-mtrx (list vctr)))
+            (B (copy-mtrx gnrt-mtrx))
+            (smith-list (smith B))
+            (p-1 (second smith-list))
+            (D (third smith-list))
+            (q (fourth smith-list))
+            (q-1 (fifth smith-list))
+            (C2 (mtrx-prdc p-1 C))
+            (line-n (column-number B))
+            (A2 
+             #-ACLPC
+             (make-array (list line-n 1)
+               :element-type 'fixnum
+               :initial-element 0)
+             #+ACLPC
+             (if (zerop line-n)
+                (make-array (list line-n 1)
+                  :element-type 'fixnum)
+                (make-array (list line-n 1)
+                  :element-type 'fixnum
+                  :initial-element 0)))
+            (end nil))
+        (declare 
+          (type matrix C B p-1 D q q-1 C2 A2)
+          (type list smith-list)
+          (type fixnum line-n end))
+        (do ((i 0 (1+ i)))
+            ((or (>= i (column-number D)) (>= i (line-number D)) end))
+           (declare (type fixnum i))
+           (let* ((di (aref D i i)))
+              (declare (type fixnum di))
+              (if (eql 0 di)
+                 (setq found 1)
+                 (progn
+                  (setf (aref A2 i 0) (floor (aref C2 i 0) di))))))
+        (let* ((A (mtrx-prdc Q A2)))
+           (declare (type matrix A))
+           (column-j A 0)))))
+
+#|
+(setf m (gnrt-list-to-mtrx '((1 0 0 0) (2 3 4 5) (0 1 0 3))))
+(setq vctr '(5 9 8 19))
+(vctr-coordinates vctr m)
+|# 
+
+;; Function that returns the list of coefficients of the combination "cmbn"
+;; in the basis (list of generators) "basis" (with comparison function "cmpr").
+(defun cmbn-cffc-list (cmbn basis cmpr)
+   (declare 
+     (type cmbn cmbn)
+     (type list basis)
+     (type cmprf cmpr))
+   (the list
+     (let* ((rslt nil)
+            (mark1 (cmbn-list cmbn))
+            (term (car mark1))
+            (cffc (cffc term))
+            (gnrt (gnrt term)))
+        (declare
+         (type list rslt mark1)
+         (type term term)
+         (type cffc cffc)
+         (type gnrt gnrt))
+        (do ((mark2 basis (cdr mark2)))
+            ((endp mark2))
+           (declare 
+             (type list mark2))
+           (if (endp mark1)
+              (setq rslt (nconc rslt (list 0)))
+           (if (eq :equal (funcall cmpr gnrt (car mark2)))
+              (progn
+               (setq rslt (nconc rslt (list cffc)))
+               (pop mark1)
+               (setq term (car mark1))
+               (setq cffc (cffc term) gnrt (gnrt term)))
+              (setq rslt (nconc rslt (list 0))))))
+        rslt)))
+
+#|
+(setf basis (list 'a 'b 'c 'd 'e 'f))
+(setq cmbn (cmbn 2 3 'a 5 'c 8 'f))
+(cmbn-cffc-list cmbn basis #'s-cmpr)
+|# 
+
+;; Function that returns the list of coordinates of the combination "cmbn" in the basis
+;; formed by the combinations in the list "gnrt-list". All these combinations are combinations
+;; of the generators in "basis" ("cmpr" is the comparison function). 
+(defun cmbn-coordinates (cmbn gnrt-list basis cmpr)
+   (declare 
+     (type cmbn cmbn)
+     (type list gnrt-list basis)
+     (type cmprf cmpr))
+   (the list
+     (let* ((vctr (cmbn-cffc-list cmbn basis cmpr))
+            (B (gnrt-list-to-mtrx
+                (mapcar
+                 #'(lambda (cmbn2)
+                     (declare (type cmbn cmbn2))
+                     (cmbn-cffc-list cmbn2 basis cmpr))
+                 gnrt-list))))
+        (declare
+         (type list vctr)
+         (type matrix B))
+        (vctr-coordinates vctr B))))
+
+#|
+(setf basis (list 'a 'b 'c 'd 'e 'f))
+(setq cmbn (cmbn 2 3 'a 5 'c 6 'f))
+(setq gnrt-list (list (cmbn 2 1 'a 2 'd 2 'f) (cmbn 2 5 'c -6 'd)))
+(cmbn-coordinates cmbn gnrt-list basis #'s-cmpr)
+|# 
+    
+         
+;; Main function to compute the differential of an element in the spectral sequence          
+
+
+;; Function that returns the list of integers which correspond to the coordinates
+;; on each of the components of E^r_{p-r,q+r-1} of the differential 
+;; d: E^r_{p,q} --> E^r_{p-r,q+r-1} applied to the element of E^r_{p,q}
+;; which has as coordinates the list int-list. (Only for finitely generated complexes)
+(defun eff-spsq-dffr (fltrcm r p q int-list)
+   (declare
+    (type filtered-chain-complex fltrcm)
+    (type fixnum r p q)
+    (list int-list))
+   (the list
+     (let* ((cmpr (cmpr1 fltrcm))
+            (degr (+ p q))
+            (sbasis (fltrd-basis fltrcm degr p))
+            (tbasis (fltrd-basis fltrcm (1- degr) (- p r)))
+            (num-mtrx (spsq-num-mtrx fltrcm r p q))
+            (den-mtrx (spsq-den-mtrx fltrcm r p q))
+            (Z-gnrt-list (Fltr-Chcm-Z-Gnrt-List fltrcm r p q))
+            (s-basis-dvs (mtrx-quotient (copy-mtrx num-mtrx) den-mtrx))
+            (s-gnrt-list (first s-basis-dvs))
+            (s-dvs (second s-basis-dvs))
+            (t-basis-dvs (spsq-basis-dvs fltrcm r (- p r) (1- (+ q r))))
+            (t-gnrt-list (first t-basis-dvs))
+            (t-dvs (second t-basis-dvs))
+            (selement (make-list (length sbasis) :initial-element 0))
+            (cmbn (cmbn degr)))
+        (declare 
+          (type fcmpr cmpr)
+          (type fixnum degr)
+          (type list sbasis tbasis z-gnrt-list s-basis-dvs s-gnrt-list s-dvs
+            t-basis-dvs t-gnrt-list t-dvs selement)
+          (type matrix num-mtrx den-mtrx)
+          (type cmbn cmbn))
+        (progn
+         (labels ((2list-add (list1 list2)
+                    (declare (type list list1 list2))
+                    (the list
+                      (mapcar #'+ list1 list2)))
+                  (n-list (n list)
+                    (declare
+                     (type list list)
+                     (type fixnum n))
+                    (the list
+                      (mapcar #'(lambda (i)
+                                  (* n i))
+                        list))))
+           (do ((mark1 s-gnrt-list (cdr mark1))
+                (mark2 s-dvs (cdr mark2))
+                (mark3 int-list))
+               ((endp mark1))
+              (declare (list mark1 mark2 mark3))
+              (if (not (eql 1 (car mark2)))
+                 (progn
+                  (setq selement (2list-add selement (n-list (car mark3) (car mark1))))
+                  (pop mark3)))))
+         (let* ((selt-coord (vctr-coordinates selement num-mtrx)))
+            (declare (list selt-coord))
+            (do ((mark1 z-gnrt-list (cdr mark1))
+                 (mark2 selt-coord (cdr mark2)))
+                ((endp mark1))
+               (declare (list mark1 mark2))
+               (if (not (eql 0 (car mark2)))
+                  (setq cmbn (2cmbn-add cmpr cmbn (n-cmbn (car mark2)
+                                                    (funcall 
+                                                      #'(lambda (int-list)
+                                                          (declare (list int-list))
+                                                          (the cmbn
+                                                            (let* ((cmbn2 (cmbn degr)))
+                                                               (declare 
+                                                                 (type cmbn cmbn))
+                                                               (do ((mark3 int-list (cdr mark3))
+                                                                    (mark4 sbasis (cdr mark4)))
+                                                                   ((or (endp mark3) (endp mark4)))
+                                                                  (declare (type list mark3 mark4))
+                                                                  (if (not (= 0 (car mark3)))
+                                                                     (setq cmbn2 (2cmbn-add cmpr cmbn2 
+                                                                                   (cmbn degr (car mark3) (car mark4))))))
+                                                               cmbn2)))
+                                                      (car mark1))))))))
+         (let* ((dffr-cmbn (dffr fltrcm cmbn))
+                (crdnt (cmbn-coordinates dffr-cmbn t-gnrt-list tbasis cmpr))
+                (rslt nil))
+            (declare
+             (type cmbn dffr-cmbn)
+             (type list crdnt rslt))
+            (do ((mark1 t-dvs (cdr mark1))
+                 (mark2 crdnt (cdr mark2)))
+                ((endp mark1))
+               (declare (list mark1 mark2))
+               (if (not (eql 1 (car mark1)))
+                  (if (eql 0 (car mark1))
+                     (setq rslt (nconc rslt (list (car mark2))))
+                     (setq rslt (nconc rslt (list (mod (car mark2) (car mark1))))))))
+            rslt)))))          
+                           
+#|
+(eff-spsq-dffr fcc 1 2 3 '(1))
+(eff-spsq-dffr fcc 1 2 5 '(0 1))
+(eff-spsq-dffr fcc 1 2 5 '(1 0))
+(eff-spsq-dffr fcc 1 3 4 '(1 0))
+(eff-spsq-dffr fcc 1 3 4 '(0 1))
+|# 
+
+;; CONVERGENCE OF THE SPECTRAL SEQUENCE            
+
+;; Function that determines if at level r and for degree n the E^r_{p,q} of the
+;; filtered complex fltrcm with p+q=degr are equal to E^\infty_{p,q} (i.e., it 
+;; determines if the convergence of the spectral sequence has been reached at 
+;; level r for the degree n). The list hmlg-cmpns contains the "components" of
+;; the homology group of the complex. It begins with m zeros if the free part of the
+;; group is Z^m and the rest of the list contains the torsion coefficients.
+;; (only for finitely generated complexes). 
+(defun eff-compare-spsq-with-homology (fltrcm r degr hmlg-cmpns)
+   (declare
+    (type filtered-chain-complex fltrcm)
+    (type fixnum r degr)
+    (type list hmlg-cmpns))
+   (let* ((min-max (flin-min-max fltrcm degr))
+          (min (first min-max))
+          (max (second min-max))
+          (spsq-cmpns
+           (mapcan
+           #'(lambda (p)
+               (declare (type fixnum p))
+               (let* ((q (- degr p)))
+                  (declare (type fixnum q))
+                  (second (eff-spsq-basis-dvs fltrcm r p q))))
+            (<a-b> min max)))
+          (mark2 hmlg-cmpns)
+          (hmlg-prdc 1)
+          (spsq-prdc 1))
+      (declare 
+        (type function spsq)
+        (type list spsq-cmpns mark2)
+        (type fixnum hmlg-prdc spsq-prdc))
+      (progn
+       (do ((mark1 spsq-cmpns (cdr mark1)))
+           ((endp mark1))
+          (declare (type list mark1))
+          (if (eql 0 (car mark1))
+             (if (not (eql 0 (car mark2)))
+                (return-from eff-compare-spsq-with-homology nil)
+                (pop mark2))
+             (setq spsq-prdc (* spsq-prdc (car mark1)))))
+       (do ((mark3 mark2 (cdr mark3)))
+           ((endp mark3))
+          (declare (type list mark3))
+          (setq hmlg-prdc (* hmlg-prdc (car mark3))))
+       (if (eql hmlg-prdc spsq-prdc)
+          't
+          nil))))
+   
+#|
+(homology fcc 5) 
+(eff-compare-spsq-with-homology fcc  1 5 '(2))
+(homology fcc 6)
+(eff-compare-spsq-with-homology fcc  1 6 '(2))
+|# 
+
+;; Function that determines the level r at which for degree n the E^r_{p,q} of the
+;; filtered complex fltrcm with p+q=degr are equal to E^\infty_{p,q} (i.e., it 
+;; determines the level r which the convergence of the spectral sequence has been 
+;; reached at for the degree n).            
+(defun eff-spsq-cnvg (fltrcm degr)
+   (declare 
+     (type filtered-chain-complex fltrcm)
+     (type fixnum degr))
+   (the fixnum
+     (let* ((hmlg-dvs-gnrs (homologie (chcm-mat fltrcm degr) (chcm-mat fltrcm (1+ degr))))
+            (hmlg-cmpns (reverse
+                         (mapcar
+                          #'(lambda (l)
+                              (first l))
+                          hmlg-dvs-gnrs)))
+            (cnvg-r 0))
+        (declare 
+          (list hmlg-dvs-gnrs hmlg-cmpns)
+          (type fixnum cnvg-r))
+        (do ((r 1 (1+ r)))
+            ((> cnvg-r 0))
+           (declare (type fixnum r))
+           (if (eff-compare-spsq-with-homology fltrcm r degr hmlg-cmpns)
+              (setq cnvg-r r)))
+        cnvg-r)))
+
+#|
+(eff-spsq-cnvg fcc 5)
+(eff-spsq-cnvg fcc 6)
+|# 
+
+;; EFFECTIVE HOMOLOGY
+
+
+;; Function that returns the order of filtration t (with regard to the filtration in the
+;; left complex, which is translated to the top and right ones) of the homotopy in the right reduction,
+;; which will determine the level r (=t+1) up to which the spectral sequences E^r_p,q 
+;; (with p+q=n) of the left and right complexes are isomorphic. This function can only be used
+;; when the top complex is effective (we need to obtain the elements in the basis of this complex). 
+(defun hmtp-eq-fltr-order (hmtp-eq degr)
+   (declare 
+     (type HOMOTOPY-EQUIVALENCE hmtp-eq)
+     (type fixnum degr))
+   (let* ((lcc (lbcc hmtp-eq))
+          (tcc (tcc hmtp-eq))
+          (lf (lf hmtp-eq))
+          (rh (rh hmtp-eq))
+          (max 0))
+      (declare
+       (type chain-complex lcc tcc)
+       (type morphism lf rh)
+       (type fixnum max))
+      (when (eq (basis tcc) :locally-effective)
+         (error "Hmtp-eq-fltr-order cannot work when the top complex of the homotopy equivalence
+             is a LOCALLY-EFFECTIVE chain complex."))
+      (mapcar 
+        #'(lambda (gnrt)
+            (declare (type gnrt gnrt))
+            (setq max (max max (- (flin lcc (lf hmtp-eq (rh hmtp-eq degr gnrt)))
+                        (flin lcc (lf hmtp-eq degr gnrt))))))
+        (basis tcc degr))
+      max))
+
+#|
+(setf hmtp-eq (efhm fcc)) ;; Trivial homotopy equivalence
+(hmtp-eq-fltr-order hmtp-eq 3)
+
+(setq k3 (k-z2 3))
+(Setq hmtp-eq3 (efhm k3))
+(setq ek3 (rbcc hmtp-eq3))
+(Change-Chcm-TO-Flcc ek3 :flin abar-flin :orgn `(filtered-chain-complex ,ek3))
+(setf k3-flin
+        #'(lambda (degr gnrt)
+            (flin ek3 (rf hmtp-eq3 (lg hmtp-eq3 degr gnrt)))))
+(Change-Chcm-TO-Flcc k3 :flin k3-flin :orgn `(filtered-chain-complex ,k3))
+(hmtp-eq-fltr-order hmtp-eq3 3)
+(hmtp-eq-fltr-order hmtp-eq3 5)
+|#
+
+;; Function that changes the right bottom chain complex in a homotopy equivalence into 
+;; a filtered complex, with a filtration defined translating the filtration in the left complex 
+;; (which must be a filtered complex). 
+(defun translate-filtration (hmtp-eq)
+   (declare
+    (type homotopy-equivalence hmtp-eq))
+   (let ((fltrcm (lbcc hmtp-eq))
+         (eff-chcm (rbcc hmtp-eq)))
+      (declare (type chain-complex fltrcm eff-chcm))
+      (Change-Chcm-TO-Flcc eff-chcm :flin
+                                 #'(lambda (degr gnrt)
+                                     (flin fltrcm (lf hmtp-eq (rg hmtp-eq degr gnrt))))
+                                 :orgn (orgn eff-chcm))))
+     
+  
+ 
+;; Function that returns the representation basis-divisors of E^r_{p,q} for a filtered
+;; complex fltrcm with effective homology, computing the E^r_{p,q} of the effective complex
+;; in the right side of the homotopy equivalence. 
+;; If the effective complex is a filtered complex, we supose that both reductions in the equi-
+;; valence are compatible with the filtrations (f and g respect the filtration index and h has
+;; filtration order < r). If not, we define the filtration in the effective
+;; complex translating the filtration in the original filtered complex FltrCm, suposing that the 
+;; homotopy in the right side is compatible with the filtration in the left complex for such r (we 
+;; supose that flin(rh(lf(y)))-flin(lf(y))<r for every y in the top complex). 
+(defun spsq-basis-dvs (FltrCm r p q)
+   (declare 
+     (type filtered-chain-complex fltrcm)
+     (type fixnum r p q))
+   (let* ((hmtp-eq (efhm fltrcm))
+          (eff-chcm (rbcc hmtp-eq))
+          (degr (+ p q)))
+      (declare 
+        (type homotopy-equivalence hmtp-eq)
+        (type chain-complex eff-chcm)
+        (type fixnum degr))
+      (progn
+       (if (not (typep eff-chcm 'filtered-chain-complex))
+          (translate-filtration hmtp-eq))
+       (let ((spsq-list (eff-spsq-basis-dvs eff-chcm r p q)))
+          (declare (list spsq-list))
+          (if (eql fltrcm eff-chcm) spsq-list
+             (list
+              (mapcar
+               #'(lambda (cmbn)
+                   (lf hmtp-eq (rg hmtp-eq cmbn)))
+               (first spsq-list))
+              (second spsq-list)))))))
+
+#|
+(spsq-basis-dvs k3 2 2 2)
+|# 
+
+
+(defun spsq-gnrts (fltrcm r p q)
+   (declare
+    (type filtered-chain-complex fltrcm)
+    (type fixnum r p q))
+   (let* ((hmtp-eq (efhm fltrcm))
+          (eff-chcm (rbcc hmtp-eq))
+          (degr (+ p q)))
+      (declare
+       (type homotopy-equivalence hmtp-eq)
+       (type chain-complex eff-chcm)
+       (type fixnum degr))
+      (progn
+       (if (not (typep eff-chcm 'filtered-chain-complex))
+          (translate-filtration hmtp-eq))
+       (eff-spsq-gnrts eff-chcm r p q))))
+
+;; Function that presents on the screen the components of the E^r_{p,q}
+;; of the spectral sequence of a filtered complex fltrcm with effective homology.
+;; If the effective complex is a filtered complex, we supose that both reductions in the equi-
+;; valence are compatible with the filtrations (f and g respect the filtration index and h has
+;; filtration order < r). If not, we define the filtration in the effective
+;; complex translating the filtration in the original filtered complex FltrCm, suposing that the 
+;; homotopy in the right side is compatible with the filtration in the left complex for such r (we 
+;; supose that flin(rh(lf(y)))-flin(lf(y))<r for every y in the top complex). 
+(defun spsq-group (fltrcm r p q)
+   (declare
+    (type filtered-chain-complex fltrcm)
+    (type fixnum r p q))
+   (let* ((hmtp-eq (efhm fltrcm))
+          (eff-chcm (rbcc hmtp-eq))
+          (degr (+ p q)))
+      (declare
+       (type homotopy-equivalence hmtp-eq)
+       (type chain-complex eff-chcm)
+       (type fixnum degr))
+      (progn
+       (if (not (typep eff-chcm 'filtered-chain-complex))
+          (translate-filtration hmtp-eq))
+       (eff-spsq-group eff-chcm r p q))))
+
+;; Function that returns the list of integers which correspond to the coordinates
+;; on each of the components of E^r_{p-r,q+r-1} of the differential 
+;; d: E^r_{p,q} --> E^r_{p-r,q+r-1} applied to the element of E^r_{p,q}
+;; which has as coordinates the list int-list.
+(defun spsq-dffr (fltrcm r p q int-list)
+   (declare
+    (type filtered-chain-complex fltrcm)
+    (type fixnum p q r)
+    (type list int-list))
+   (let* ((hmtp-eq (efhm fltrcm))
+          (eff-chcm (rbcc hmtp-eq))
+          (degr (+ p q)))
+      (declare
+       (type homotopy-equivalence hmtp-eq)
+       (type chain-complex eff-chcm)
+       (type fixnum degr))
+      (progn
+       (if (not (typep eff-chcm 'filtered-chain-complex))
+          (translate-filtration hmtp-eq))
+       (eff-spsq-dffr eff-chcm r p q int-list))))
+   
+;; Function that determines the level r at which for degree n the E^r_{p,q} (with p+q=degr)
+;; of the filtered complex fltrcm (with effective homology) are equal to E^\infty_{p,q} (i.e., it 
+;; determines the level r which the convergence of the spectral sequence has been 
+;; reached at for the degree n).
+(defun spsq-cnvg (fltrcm degr)
+   (declare
+    (type filtered-chain-complex fltrcm)
+    (type fixnum degr))
+   (let* ((hmtp-eq (efhm fltrcm))
+          (eff-chcm (rbcc hmtp-eq)))
+      (declare
+       (type homotopy-equivalence hmtp-eq)
+       (type chain-complex eff-chcm)
+       (type fixnum degr))
+      (progn
+       (if (not (typep eff-chcm 'filtered-chain-complex))
+          (translate-filtration hmtp-eq))
+       (eff-spsq-cnvg eff-chcm degr))))
+
+
+ 
+       
+          
+;; Homology filtration
+
+
+(defun homology-gnrt-list (chcm degr)
+     (declare (type cc chcm) (type fixnum degr))
+     (let ((src (cons :unused (basis chcm degr)))
+           (hom-dvs-gnrts (homologie (chcm-mat chcm degr) (chcm-mat chcm (1+ degr))))
+           (rslt nil))
+        (declare (type list src hom-dvs-gnrts rslt))
+        (mapcar #'(lambda (item)
+                    (declare (type list item))
+                    (let ((cmbn (cmbn degr))
+                          (cmpr (cmpr chcm)))
+                       (dolist (item2 (rest item))
+                          (declare (type cons item2))
+                          (setf cmbn (2cmbn-add cmpr cmbn (cmbn degr (car item2) (nth (cdr item2) src)))))
+                       cmbn))
+          hom-dvs-gnrts)))
+
+
+
+
+(defun homology-fltr1 (fltrcm degr fltr-index)
+   (declare
+    (type filtered-chain-complex fltrcm)
+    (type fixnum degr fltr-index))
+   (let* ((r (spsq-cnvg fltrcm degr))
+          (cmpr (cmpr1 fltrcm))
+          (total-basis (fltrd-basis fltrcm degr fltr-index))
+          (dffr-mtrx (FLTR-CHCM-Z-MTRX fltrcm r fltr-index (- degr fltr-index)))
+          (fltrt-basis 
+           (mapcan #'(lambda (p)
+                       (let* ((q (- degr p))
+                              (num-mtrx (spsq-num-mtrx fltrcm r p q))
+                              (den-mtrx (spsq-den-mtrx fltrcm r p q))
+                              (Z-gnrt-list (Fltr-Chcm-Z-Gnrt-List fltrcm r p q))
+                              (ss-basis-dvs (mtrx-quotient (copy-mtrx num-mtrx) den-mtrx))
+                              (ss-gnrt-list (first ss-basis-dvs))
+                              (ss-dvs (second ss-basis-dvs))
+                              (rslt nil))
+                          (declare 
+                            (type fcmpr cmpr)
+                            (type fixnum r q)
+                            (type list total-basis z-gnrt-list ss-basis-dvs ss-gnrt-list ss-dvs rslt)
+                            (type matrix num-mtrx den-mtrx))
+                          (labels ((2list-add (list1 list2)
+                                     (declare (type list list1 list2))
+                                     (the list
+                                       (mapcar #'+ list1 list2)))
+                                   (n-list (n list)
+                                     (declare
+                                       (type list list)
+                                       (type fixnum n))
+                                     (the list
+                                       (mapcar #'(lambda (i)
+                                                   (* n i))
+                                         list))))
+                            (do ((mark1 ss-gnrt-list (cdr mark1))
+                                 (mark2 ss-dvs (cdr mark2)))
+                                ((endp mark1))
+                               (declare (type list mark1 mark2))
+                               (if (not (eql 1 (car mark2)))
+                                  (let* ((selt (first mark1))
+                                         ;;(coord (cmbn-cffc-list selt total-basis cmpr))
+                                         (cmbn (cmbn degr)))
+                                     (progn
+                                       (let* ((selt-coord (vctr-coordinates selt num-mtrx)))
+                                          (declare (list selt-coord))
+                                          (do ((mark3 z-gnrt-list (cdr mark3))
+                                               (mark4 selt-coord (cdr mark4)))
+                                              ((endp mark3))
+                                             (declare (list mark3 mark4))
+                                             (if (not (eql 0 (car mark4)))
+                                                (setq cmbn (2cmbn-add cmpr cmbn (n-cmbn (car mark4)
+                                                                                  (funcall 
+                                                                                    #'(lambda (int-list)
+                                                                                        (declare (list int-list))
+                                                                                        (the cmbn
+                                                                                          (let* ((cmbn2 (cmbn degr)))
+                                                                                             (declare 
+                                                                                               (type cmbn 
+                                                                                                 cmbn2))
+                                                                                             (do ((
+                                                                                                   mark5 int-list (cdr 
+                                                                                                                    mark5))
+                                                                                                  (mark6 total-basis (cdr mark6)))
+                                                                                                 ((or (endp mark5) (endp mark6)))
+                                                                                                (declare (type list mark5 mark6))
+                                                                                                (if (not (= 0 (car mark5)))
+                                                                                                   (setq cmbn2 (2cmbn-add cmpr cmbn2 
+                                                                                                                 (cmbn degr (car 
+                                                                                                                              mark5) (car 
+                                                                                                                                       mark6))))))
+                                                               cmbn2)))
+                                                      (car mark3))))))))
+                                       (setf rslt (nconc rslt (list cmbn)))
+                                       rslt)))))))
+                          (<a-b> 0 fltr-index))))
+      (if (not (endp fltrt-basis))
+          (let ((fltrt-mtrx
+                  (gnrt-list-to-mtrx
+                    (mapcar #'(lambda (cmbn)
+                                (cmbn-cff-list cmbn total-basis cmpr))
+                      (fltrt-basis))))
+                (num-mtrx (mtrx-conc fltrt-mtrx dffr-mtrx)))
+             (mtrx-quotient num-mtrx dffr-mtrx))
+         nil)))
+
+
+
+(defun eff-hmlg-fltr (fltrcm degr p)
+   (declare
+     (type filtered-chain-complex fltrcm)
+     (type fixnum degr p))
+   (let* ((min-max-1 (flin-min-max fltrcm (1- degr)))
+          (min-1 (first min-max-1))
+          (max-1 (second min-max-1))
+          (min-max+1 (flin-min-max fltrcm (1+ degr)))
+          (min+1 (first min-max+1))
+          (max+1 (second min-max+1))
+          (r (1+ (- p min-1)))
+          (q (- degr p))
+          (Z-gnrts (Fltr-Chcm-Z-Gnrt-List FltrCm r p q))
+          (dffr-mtrx (FLTR-CHCM-Z-MTRX fltrcm (+ 2 (- degr min+1)) (1+ degr) 0))
+          (num-mtrx (mtrx-conc (gnrt-list-to-mtrx z-gnrts) dffr-mtrx))
+          (basis-divs (mtrx-quotient num-mtrx dffr-mtrx))
+          (divs (second basis-divs)))
+      (format t "Filtration F_~D H_~D" p degr)
+      (dolist (item divs)
+         (declare (type fixnum item))
+         (if (not (eql 1 item))
+            (progn
+             (format t "~2%Component Z")
+             (unless (zerop item) 
+                (format t "/~DZ" item))
+             )))))
+     
+
+(defun hmlg-fltr (fltrcm degr p)
+   (declare
+    (type filtered-chain-complex fltrcm)
+    (type fixnum degr))
+   (let* ((hmtp-eq (efhm fltrcm))
+          (eff-chcm (rbcc hmtp-eq)))
+      (declare
+       (type homotopy-equivalence hmtp-eq)
+       (type chain-complex eff-chcm)
+       (type fixnum degr))
+      (progn
+       (if (not (typep eff-chcm 'filtered-chain-complex))
+          (translate-filtration hmtp-eq))
+       (eff-hmlg-fltr eff-chcm degr p))))
+
+
+
+
+(DEFTYPE ss-type () '(member :serre :eilenberg-moore :filtration))
+         
+   
+
+(defclass OUTPUT-SPECTRAL-SEQUENCE ()
+    ((hmeq :type homotopy-equivalence :initarg hmeq :reader hmeq)
+     (eff-flin :type chcm-fltrindex :initarg eff-flin :reader eff-flin)
+     (bgn :type fixnum :initarg bgn :reader bgn)
+     ;; IDentification NuMber

+     (idnm :type fixnum :initform (incf *idnm-counter*) :reader idnm)

+     ;; ORiGiN

+     (orgn :type list :initarg :orgn :reader orgn)))
+
+
+(DEFVAR *oss-list*)
+(SETF *oss-list* +empty-list+)
+(PUSHNEW '*oss-list* *list-list*)
+
+(DEFMETHOD PRINT-OBJECT ((oss OUTPUT-SPECTRAL-SEQUENCE) stream)
+(the output-spectral-sequence
+   (progn
+      (format stream "[K~D output-spectral-sequence]" (idnm oss))
+     oss)))
+
+(DEFUN Oss (idnm)
+   (declare (type fixnum idnm))
+   (the (or OUTPUT-SPECTRAL-SEQUENCE null)
+      (find idnm *oss-list* :key #'idnm)))
+
+
+(DEFUN BUILD-oss (&key hmeq eff-flin bgn orgn)
+   (declare
+      (type homotopy-equivalence hmeq)
+      (type chcm-fltrindex eff-flin)
+      (type fixnum bgn)
+      (type list orgn))
+   (the output-spectral-sequence
+      (progn
+         (let ((already (find orgn *oss-list* :test #'equal :key #'orgn)))
+            (declare (type (or output-spectral-sequence null) already))
+            (when already
+               (return-from build-oss already)))
+         (let ((oss (make-instance 'output-spectral-sequence
+                        :hmeq hmeq
+                        :eff-flin eff-flin
+                        :bgn bgn
+                        :orgn orgn)))
+            (declare (type output-spectral-sequence oss))
+            (push oss *oss-list*)
+            oss))))
+     
+;;(defun serre-ss (fibration)
+
+#|(defun serre-ss (f)
+   (declare (type fibration f))
+   (let* ((X (fibration-total f))
+          (hmeq (efhm X))
+          (eX (rbcc efhm))
+|#
\ No newline at end of file
diff --git a/examples/anromero/homology-of-groups/OMparsers.lisp b/examples/anromero/homology-of-groups/OMparsers.lisp
new file mode 100644
index 0000000..3467726
--- /dev/null
+++ b/examples/anromero/homology-of-groups/OMparsers.lisp
@@ -0,0 +1,464 @@
+(in-package :user)
+
+
+
+
+(defun OMgetNextLabel (s)
+   (let* ((p1 (search "<" s)))
+      (delete-if #'(lambda (item) t) s :start 0 :end p1)
+          (let ((p1 (search "<" s))
+                (p2 (if (search " " s) (min (search ">" s) (search " " s))
+                      (search ">" s) )))
+      (subseq s (1+ p1) p2))))
+
+(defun OMgetNextSymbol (s)
+   (let* ((p1 (search "cd=" s))
+          (p2 (search "name=" s))
+          (p3 (search "/>" s))
+          (rslt1 (subseq s (+ 3 p1) p2))
+          (rslt2 (subseq s (+ 5 p2) p3))
+          )
+         (OMLispSymbol (list (delete #\" (delete #\space rslt1)) (delete #\" (delete #\space rslt2))))
+         ))
+
+(defun OMparseNextInteger (s)
+   (if (not (equal (OMgetNextLabel s) "OMI"))
+      (error "The next token is not an integer")
+      (let* ((p1 (search "<OMI>" s))
+             (p2 (search "</OMI>" s))
+             (rslt (parse-integer (subseq s (+ 5 p1) p2))))
+         (delete-if #'(lambda (item) t) s :start 0 :end (+ 6 p2))
+         rslt
+         )))
+
+(defun OMparseNextString (s)
+   (if (not (equal (OMgetNextLabel s) "OMSTR"))
+      (error "The next token is not a string")
+      (let* ((p1 (search "<OMSTR>" s))
+             (p2 (search "</OMSTR>" s))
+             (rslt (subseq s (+ 7 p1) p2)))
+         (delete-if #'(lambda (item) t) s :start 0 :end (+ 8 p2))
+         rslt
+         )))
+
+(defun OMparseNextVar (s)
+   (if (not (equal (OMgetNextLabel s) "OMV"))
+      (error "The next token is not a variable")
+      (let* ((p1 (search "<OMV>" s))
+             (p2 (search "</OMV>" s))
+             (rslt (intern (subseq s (+ 5 p1) p2))))
+         (delete-if #'(lambda (item) t) s :start 0 :end (+ 6 p2))
+         rslt
+         )))
+
+(defun OMparseNextSymbol (s)
+   (if (not (equal (OMgetNextLabel s) "OMS"))
+      (error "The next token is not a symbol")
+      (let* ((rslt (OMgetNextSymbol s))
+             (p (search "/>" s))
+             )
+         (delete-if #'(lambda (item) t) s :start 0 :end (+ 2 p))
+         rslt
+         )))
+  
+(DEFTYPE direct-symbol () '(member list cyclicgroup))
+
+
+(defun OMLispSymbol (list)
+   (let ((cd (first list))
+         (name (second list)))
+      (if (equal cd "list1")
+         (if (equal name "list")
+            'list)
+         (if (equal cd "resolutions")
+            (if (equal name "zgcombination")
+               "zgcombination"
+               (if (equal name "zgterm")
+                  "zgterm"
+                  (if (equal name "zggnrt")
+                     "zggnrt"
+                     (if (equal name "resolution")
+                        "resolution"))))
+            (if (equal cd "group1")
+               (if (equal name "cyclic_group")
+                  'cyclicgroup))))))
+
+(defun OMparseNextApplication (s)
+   (if (not (equal (OMgetNextLabel s) "OMA"))
+      (error "The next token is not an application")
+      (let* ((p1 (search "<OMA>" s)))
+         (delete-if #'(lambda (item) t) s :start 0 :end (+ 5 p1))
+         (let ((head (if (equal (OMgetNextLabel s) "OMS")
+                        (OMparseNextSymbol s)
+                        (OMparseNextObject s)))
+               (rest nil))
+            (if (typep head 'direct-symbol)
+               (do ((rest nil  (append rest (list nextobj))))
+                   ((equal (OMgetNextLabel s) "/OMA") (let ((p (search "</OMA>" s)))
+                                                         (delete-if #'(lambda (item) t) s :start 0 :end (+ 6 p1))
+                                                         (eval (append (list head) rest))))
+                  (setf nextobj (OMparseNextObject s))
+                  )
+               (if (equal head "resolution")
+                  (OMparseResolution s)
+                  (error "imposible to parse")
+            ))))))
+         
+         
+         
+           
+(defun OMparseNextObject (s)
+   (progn 
+     (if (equal (OMgetNextLabel s) "OMOBJ")
+        (delete-if #'(lambda (item) t) s :start 0 :end (+ 7 (search "<OMOBJ>" s))))
+   
+     (if (equal (subseq (OMgetNextLabel s) 0 3) "!--")
+        (delete-if #'(lambda (item) t) s :start 0 :end (+ 4 (search "--/>" s))))
+      
+     (let ((rslt
+            (if (equal (OMgetNextLabel s) "OMI")
+               (OMparseNextInteger s)
+               (if (equal (OMgetNextLabel s) "OMSTR")
+                  (OMparseNextString s)
+                  (if (equal (OMgetNextLabel s) "OMV")
+                     (OMparseNextVar s)
+                     (if (equal (OMgetNextLabel s) "OMS")
+                        (OMLispSymbol(OMparseNextSymbol s))
+                        (if (equal (OMgetNextLabel s) "OMA")
+                           (OMparseNextApplication s)
+                           (error "imposible to parse"))))))))
+        (progn
+         (if (equal (OMgetNextLabel s) "/OMOBJ")
+            (delete-if #'(lambda (item) t) s :start 0 :end (+ 8 (search "</OMOBJ>" s))))
+         rslt))))
+
+
+
+   
+
+
+(defun OMparseZggnrt (s grbasis zgbasis-degr)
+   (if (not (equal (OMgetNextLabel s) "OMA"))
+      (error "The next label is not an application")
+      (progn 
+        (delete-if #'(lambda (item) t) s :start 0 :end (+ 5 (search "<OMA>" s)))
+        (if (not (equal (OMgetNextSymbol s) "zggnrt"))
+           (error "This is not specified as a zggnrt")
+           (progn 
+             (OMparseNextSymbol s)
+             (let* ((i1 (OMparseNextInteger s))
+                    (i2 (OMparseNextInteger s)))
+                (delete-if #'(lambda (item) t) s :start 0 :end (+ 6 (search "</OMA>" s)))
+                (zggnrt (nth (1- i1) grbasis) (nth (1- i2) zgbasis-degr))))))))
+
+
+(defun OMparseZgterm (s degr grbasis zgbasis)
+   (if (not (equal (OMgetNextLabel s) "OMA"))
+      (error "The next label is not an application")
+      (progn 
+        (delete-if #'(lambda (item) t) s :start 0 :end (+ 5 (search "<OMA>" s)))
+        (if (not (equal (OMgetNextSymbol s) "zgterm"))
+           (error "This is not specified as a zgterm")
+           (progn 
+             (OMparseNextSymbol s)
+             (let* ((coeff (OMparseNextInteger s))
+                    (zggnrt (OMparseZggnrt s grbasis (funcall zgbasis degr))))
+                (delete-if #'(lambda (item) t) s :start 0 :end (+ 6 (search "</OMA>" s)))
+                (term-cmbn degr coeff zggnrt )))))))
+
+(defun OMparseZgcmbn (s degr grbasis grcmpr zgbasis zgcmpr)
+   (if (equal (subseq (OMgetNextLabel s) 0 3) "!--")
+      (delete-if #'(lambda (item) t) s :start 0 :end (+ 4 (search "--/>" s))))
+   (if (not (equal (OMgetNextLabel s) "OMA"))
+      (error "The next label is not an application")
+      (progn 
+        (delete-if #'(lambda (item) t) s :start 0 :end (+ 5 (search "<OMA>" s)))
+        (if (not (equal (OMgetNextSymbol s) "zgcombination"))
+           (error "This is not specified as a zgcombination")
+           (progn 
+             (OMparseNextSymbol s)
+             (let ((cmbn-list nil))
+                (do ((term-list nil  (push  (cons 1 nexttermcmbn) term-list)))
+                   ((equal (OMgetNextLabel s) "/OMA") (setf cmbn-list term-list) )
+                  (setf nexttermcmbn (OMparseZgterm s degr grbasis zgbasis))
+                  )
+                (delete-if #'(lambda (item) t) s :start 0 :end (+ 6 (search "</OMA>" s)))
+                (if cmbn-list
+                   (cmbn-cmbn (zggnrt-cmpr grcmpr zgcmpr) cmbn-list)
+                   (zero-cmbn degr))))))))
+
+(defun OMparseZgboundaryList (s grbasis grcmpr zgbasis zgcmpr maxdegr)
+   (if (equal (subseq (OMgetNextLabel s) 0 3) "!--")
+      (delete-if #'(lambda (item) t) s :start 0 :end (+ 4 (search "--/>" s))))
+   (if (not (equal (OMgetNextLabel s) "OMA"))
+      (error "The next label is not an application")
+      (progn 
+        (delete-if #'(lambda (item) t) s :start 0 :end (+ 5 (search "<OMA>" s)))
+        (if (not (equal (OMgetNextSymbol s) 'list))
+           (error "This is not specified as a list")
+           (progn 
+             (OMparseNextSymbol s)
+             (let ((rslt nil))
+                (dotimes (i maxdegr)
+                   (if (equal (subseq (OMgetNextLabel s) 0 3) "!--")
+                      (delete-if #'(lambda (item) t) s :start 0 :end (+ 4 (search "--/>" s))))
+                   (if (not (equal (OMgetNextLabel s) "OMA"))
+                      (error "The next label is not an application")
+                      (progn 
+                        (delete-if #'(lambda (item) t) s :start 0 :end (+ 5 (search "<OMA>" s)))
+                        (if (not (equal (OMgetNextSymbol s) 'list))
+                           (error "This is not specified as a list")
+                           (progn 
+                             (OMparseNextSymbol s)
+                             (let ((rslt-i nil))
+                                (do ((aux nil (push cmbn aux)))
+                                    ((equal (OMgetNextLabel s) "/OMA") (setf rslt-i aux))
+                                   (setf cmbn (OMparseZgcmbn s i grbasis grcmpr zgbasis zgcmpr)))
+                                (delete-if #'(lambda (item) t) s :start 0 :end (+ 6 (search "</OMA>" s)))
+                                (push (nreverse rslt-i) rslt)))))))
+                (delete-if #'(lambda (item) t) s :start 0 :end (+ 6 (search "</OMA>" s)))
+                (nreverse rslt)))))))
+                   
+
+(defun OMparseContractinghmtpList (s grbasis grcmpr zgbasis zgcmpr maxdegr)
+   (if (equal (subseq (OMgetNextLabel s) 0 3) "!--")
+      (delete-if #'(lambda (item) t) s :start 0 :end (+ 4 (search "--/>" s))))
+   (if (not (equal (OMgetNextLabel s) "OMA"))
+      (error "The next label is not an application")
+      (progn 
+        (delete-if #'(lambda (item) t) s :start 0 :end (+ 5 (search "<OMA>" s)))
+        (if (not (equal (OMgetNextSymbol s) 'list))
+           (error "This is not specified as a list")
+           (progn 
+             (OMparseNextSymbol s)
+             (let ((rslt nil))
+                (dotimes (i (1- maxdegr))
+                   (if (equal (subseq (OMgetNextLabel s) 0 3) "!--")
+                      (delete-if #'(lambda (item) t) s :start 0 :end (+ 4 (search "--/>" s))))
+                   (if (not (equal (OMgetNextLabel s) "OMA"))
+                      (error "The next label is not an application")
+                      (progn 
+                        (delete-if #'(lambda (item) t) s :start 0 :end (+ 5 (search "<OMA>" s)))
+                        (if (not (equal (OMgetNextSymbol s) 'list))
+                           (error "This is not specified as a list")
+                           (progn 
+                             (OMparseNextSymbol s)
+                             (let ((rslt-i nil))
+                                (do ((mark1 (funcall zgbasis (1+ i)) (cdr mark1)))
+                                    ((endp mark1) (push (nreverse rslt-i) rslt))
+                                    (if (equal (subseq (OMgetNextLabel s) 0 3) "!--")
+                                       (delete-if #'(lambda (item) t) s :start 0 :end (+ 4 (search "--/>" s))))
+                                   (if (not (equal (OMgetNextLabel s) "OMA"))
+                                      (error "The next label is not an application")
+                                      (progn 
+                                        (delete-if #'(lambda (item) t) s :start 0 :end (+ 5 (search "<OMA>" s)))
+                                        (if (not (equal (OMgetNextSymbol s) 'list))
+                                           (error "This is not specified as a list")
+                                           (progn 
+                                             (OMparseNextSymbol s)
+                                             (let ((rslt-i-g nil))
+                                                
+                                                (do ((mark2 grbasis (cdr mark2)))
+                                                    ((endp mark2) (push (nreverse rslt-i-g) rslt-i))
+                                                   (setf cmbn (OMparseZgcmbn s (1+ i) grbasis grcmpr zgbasis zgcmpr))
+                                                   (push cmbn rslt-i-g))
+                                                (delete-if #'(lambda (item) t) s :start 0 :end (+ 6 (search "</OMA>" s)))
+                                                ))))))
+                                (delete-if #'(lambda (item) t) s :start 0 :end (+ 6 (search "</OMA>" s)))
+                                ))))))
+                (delete-if #'(lambda (item) t) s :start 0 :end (+ 6 (search "</OMA>" s)))
+                (nreverse rslt)))))))
+
+
+
+(defun OMrsltnZgbasis (rank-list maxdegr)
+   (flet ((rslt (degr)
+            (declare (fixnum degr))
+            (if (> degr maxdegr) (error "unknown basis for this degree")
+               (if (< degr 0) nil
+                  (let ((rank (nth degr rank-list))
+                        (list nil))
+                     (dotimes (i rank)
+                        (push (concatenate 'string "g" (Write-to-string degr) (Write-to-string (1+ i))) list))
+                     (nreverse list))))))
+     
+     (the basis #'rslt)))
+
+(defun OMrsltnZgboundary-intr (Zgboundary-list zgbasis maxdegr)
+   (flet ((rslt (degr gnrt)
+            (declare (fixnum degr) (type gnrt gnrt))
+            (if (> degr maxdegr) (error "unknown basis for this degree")
+               (if (< degr 1) (zero-cmbn (1- degr))
+                  (nth (position gnrt (funcall zgbasis degr)  :test #'equal) (nth (1- degr) Zgboundary-list))))))
+          (the intr-mrph #'rslt)))
+
+(defun OMrsltnCntrHmtp-intr (Zgcontractinghmtp-list zgbasis grbasis maxdegr)
+   (flet ((rslt (degr zggnrt)
+            (declare (fixnum degr) (type zggnrt zggnrt))
+            (if (> degr (1- maxdegr)) (error "unknown basis for this degree")
+               (with-zggnrt (gnrt1 gnrt2) zggnrt
+                 (let ((gnrt1-pos (position gnrt1 grbasis :test #'equal))
+                       (gnrt2-pos (position gnrt2 (funcall zgbasis degr) :test #'equal)))
+                    (nth gnrt1-pos (nth gnrt2-pos (nth degr Zgcontractinghmtp-list))))))))
+               (the intr-mrph #'rslt)))
+
+
+
+                             
+                             
+(defun OMparseResolution (s)
+   ;;(if (not (equal (OMgetNextLabel s) "OMA"))
+    ;;  (error "The next label is not an application")
+    ;;  (progn 
+    ;;    (delete-if #'(lambda (item) t) s :start 0 :end (+ 5 (search "<OMA>" s)))
+    ;;    (if (not (equal (OMgetNextSymbol s) "resolution"))
+    ;;       (error "This is not specified as a resolution")
+    ;;       (progn 
+    ;;         (OMparseNextSymbol s)
+             (let* ((group (OMparseNextObject s))
+                    (maxdegr (OMparseNextObject s))
+                    (rank-list (OMparseNextObject s))
+                    (zgbasis (OMrsltnZgbasis rank-list maxdegr)))
+                (with-slots ((grcmpr cmpr) (grbasis elements) nullel) group
+                  (let* ((zgboundary-list (OMparseZgboundaryList s grbasis grcmpr zgbasis #'s-cmpr maxdegr))
+                         (cntrchmtp-list (OMparseContractinghmtpList s grbasis grcmpr zgbasis #'s-cmpr maxdegr))
+                         (zgchcm (BUILD-ZGCHCM :group group :zgcmpr #'s-cmpr :zgbasis zgbasis :zgbsgn "g00" 
+                                   :intr-zgbndr (OMrsltnZgboundary-intr Zgboundary-list zgbasis maxdegr)
+                                   :zgbndr-strt :gnrt :orgn  `(ZG-Chain complex for ,group obtained from HAP)))
+                         (cmpr (cmpr1 zgchcm))
+                         (f-intr #'(lambda (degr zggnrt)
+                                     (if (zerop degr) (cmbn degr 1 :zgnrt) (zero-cmbn degr))))
+                         (g-intr #'(lambda (degr gnrt)
+                                     (if (zerop degr) (cmbn degr 1 (zggnrt nullel "g01")) (zero-cmbn degr))))
+                         (h-intr (OMrsltnCntrHmtp-intr cntrchmtp-list zgbasis grbasis maxdegr))
+
+                         (f (build-mrph :sorc zgchcm :trgt (z-chcm) :degr 0 :intr f-intr :strt :gnrt :orgn `(f-mrph for ,group obtained from HAP)))
+                         (g (build-mrph :sorc (z-chcm) :trgt zgchcm :degr 0 :intr g-intr :strt :gnrt :orgn  `(g-mrph for ,group obtained from HAP)))
+                         (h (build-mrph :sorc zgchcm :trgt zgchcm :degr 1 :intr h-intr :strt :gnrt :orgn `(h-mrph for ,group obtained from HAP))))
+                     (delete-if #'(lambda (item) t) s :start 0 :end (+ 6 (search "</OMA>" s)))
+                     (build-rdct :f f :g g :h h :orgn `(Resolution of ,group obtained from HAP))))))
+;;;))))
+                       
+(defun FileToString (FileName)
+     (with-open-file (f FileName :direction :input)
+       (labels ((getString (f s)
+                 (let* ((aux (read-line f nil 'EOF)))
+                    (if (not (string= aux 'EOF))
+                       (getString f (concatenate 'string s (if (not (string= s "")) (format nil "~%")) aux)) 
+                       s))))
+       (getString f ""))))
+
+                             
+
+#|
+
+
+
+   
+
+(cat-init)
+(load "omparsers.lisp")
+(setf s (filetostring "resolution.log")) 
+(setf rsltn1 (OmparseNextObject s))
+(setf group (group1 (tcc rsltn1)))
+(setf (slot-value group 'resolution) rsltn1)
+(setf k-g-1 (k-g-1 group))
+(setf k-g-2 (k-g group 2))
+(setf k-g-3 (k-g group 3))
+
+(homology k-g-1 0 6)
+(homology k-g-2 0 6)
+(homology k-g-3 0 6)
+
+
+
+(if (equal (OMgetNextLabel s) "OMOBJ")
+        (delete-if #'(lambda (item) t) s :start 0 :end (+ 7 (search "<OMOBJ>" s))))
+   
+     (if (equal (subseq (OMgetNextLabel s) 0 3) "!--")
+        (delete-if #'(lambda (item) t) s :start 0 :end (+ 4 (search "--/>" s))))
+
+
+(if (not (equal (OMgetNextLabel s) "OMA"))
+      (error "The next label is not an application"))
+(delete-if #'(lambda (item) t) s :start 0 :end (+ 5 (search "<OMA>" s)))
+(if (not (equal (OMgetNextSymbol s) "resolution"))
+   (error "This is not specified as a resolution"))
+
+(OMparseNextSymbol s)
+
+(setf group (OMparseNextObject s))
+(setf maxdegr (OMparseNextObject s))
+(setf rank-list (OMparseNextObject s))
+(setf zgbasis (OMrsltnZgbasis rank-list maxdegr))
+
+(setf grcmpr (cmpr1 group) grbasis (elements group) nullel (nullel group))
+(setf zgcmpr #'s-cmpr)
+(setf zgboundary-list (OMparseZgboundaryList s grbasis grcmpr zgbasis #'s-cmpr maxdegr))
+;;(setf cntrchmtp-list (OMparseContractinghmtpList s grbasis grcmpr zgbasis #'s-cmpr maxdegr))                                  
+                         
+(if (not (equal (OMgetNextLabel s) "OMA"))
+      (error "The next label is not an application"))
+
+(delete-if #'(lambda (item) t) s :start 0 :end (+ 5 (search "<OMA>" s)))
+
+(if (not (equal (OMgetNextSymbol s) 'list))
+           (error "This is not specified as a list"))
+(OMparseNextSymbol s)
+
+(setf rslt nil)
+
+(setf i 0)
+(if (not (equal (OMgetNextLabel s) "OMA"))
+                      (error "The next label is not an application"))
+(delete-if #'(lambda (item) t) s :start 0 :end (+ 5 (search "<OMA>" s)))
+(OMparseNextSymbol s)
+(setf rslt-i nil)  
+
+(setf mark1 zgbasis)
+
+
+                (dotimes (i maxdegr)
+                   (if (not (equal (OMgetNextLabel s) "OMA"))
+                      (error "The next label is not an application")
+                      (progn 
+                        (delete-if #'(lambda (item) t) s :start 0 :end (+ 5 (search "<OMA>" s)))
+                        (if (not (equal (OMgetNextSymbol s) 'list))
+                           (error "This is not specified as a list")
+                           (progn 
+                             (OMparseNextSymbol s)
+                             (let ((rslt-i nil))
+                                (do ((mark1 (funcall zgbasis (1+ i)) (cdr mark1)))
+                                    ((endp mark1) (push rslt-i rslt))
+                                    
+                                   (if (not (equal (OMgetNextLabel s) "OMA"))
+                                      (error "The next label is not an application")
+                                      (progn 
+                                        (delete-if #'(lambda (item) t) s :start 0 :end (+ 5 (search "<OMA>" s)))
+                                        (if (not (equal (OMgetNextSymbol s) 'list))
+                                           (error "This is not specified as a list")
+                                           (progn 
+                                             (OMparseNextSymbol s)
+                                             (let ((rslt-i-g nil))
+                                                
+                                                (do ((mark2 grbasis (cdr mark2)))
+                                                    ((endp mark2) (push rslt-i-g rslt-i))
+                                                   (setf cmbn (OMparseZgcmbn s (1+ i) grbasis grcmpr zgbasis zgcmpr))
+                                                   (push cmbn rslt-i-g))
+                                                (delete-if #'(lambda (item) t) s :start 0 :end (+ 6 (search "</OMA>" s)))
+                                                ))))))
+                                (delete-if #'(lambda (item) t) s :start 0 :end (+ 6 (search "</OMA>" s)))
+                                ))))))
+                (delete-if #'(lambda (item) t) s :start 0 :end (+ 6 (search "</OMA>" s)))
+                rslt)))))
+
+
+
+|# 
+
+
+
+
+
+
+
diff --git a/examples/anromero/homology-of-groups/cylinders.lisp b/examples/anromero/homology-of-groups/cylinders.lisp
new file mode 100644
index 0000000..2f3d3a3
--- /dev/null
+++ b/examples/anromero/homology-of-groups/cylinders.lisp
@@ -0,0 +1,462 @@
+;;;  CYLIDERS  CYLIDERS  CYLIDERS  CYLIDERS  CYLIDERS  CYLIDERS  CYLIDERS  
+;;;  CYLIDERS  CYLIDERS  CYLIDERS  CYLIDERS  CYLIDERS  CYLIDERS  CYLIDERS 
+;;;  CYLIDERS  CYLIDERS  CYLIDERS  CYLIDERS  CYLIDERS  CYLIDERS  CYLIDERS 
+
+(IN-PACKAGE "COMMON-LISP-USER")
+
+(PROVIDE "CYCLINDERS")
+
+
+(DEFUN CYLN-P (object)
+   (declare (type any object))
+   (the boolean       
+     (and (consp object)            
+          (typep (car object) '(member :CYLNA1 :CYLNB :CYLNA2))
+          (typep (cdr object) 'gnrt))))
+
+(DEFTYPE CYLN () '(satisfies CYLN-P))  
+
+;; MACROS
+
+(DEFMACRO CYLNX (CYLN)
+   `(car ,CYLN))
+
+(DEFMACRO ICYLN (CYLN)
+   `(cdr ,CYLN))
+
+(DEFMACRO CYLNA1 (gnrt)
+   `(cons :CYLNA1 ,gnrt))
+
+(DEFMACRO CYLNB (gnrt)
+   `(cons :CYLNB ,gnrt))
+
+(DEFMACRO CYLNA2 (gnrt)
+   `(cons :CYLNA2 ,gnrt))
+
+(DEFMACRO WITH-CYLN ((CYLNx iCYLN) CYLN . body)
+   `(let ((,CYLNx (CYLNx ,CYLN))
+          (,iCYLN (iCYLN ,CYLN)))
+       (declare
+          (type (member :CYLNA1 :CYLNB :CYLNA2) ,CYLNx)
+          (type gnrt ,iCYLN))
+       ,@body))
+
+
+(DEFUN DISPATCH-CYLN-CMBN (cmbn)
+   (declare (type cmbn cmbn))
+   (the (values cmbn cmbn cmbn)
+      (with-cmbn (degr list) cmbn
+         (let ((listA1 +empty-list+)
+               (listB +empty-list+)
+               (listA2 +empty-list+))
+            (declare (list listA1 listB listA2))
+            (dolist (term list)
+               (declare (type term term))
+               (with-term (cffc cyln) term
+                  (with-cyln (cylnx icyln) cyln
+                     (ecase cylnx
+                        (:cylnA1 (push (term cffc icyln) listA1))
+                        (:cylnB (push (term cffc icyln) listB))
+                        (:cylnA2 (push (term cffc icyln) listA2))))))
+            (values
+               (make-cmbn :degr (1- degr) :list (nreverse listA1))
+               (make-cmbn :degr degr :list (nreverse listB))
+               (make-cmbn :degr degr :list (nreverse listA2)))))))
+
+#|
+  (dispatch-CYLN-cmbn (cmbn 3 3 (cylnA1 'a11) 4 (cylnA1 'a12) 33 (cylnB 'b) 333 (cylnA2 'a2)))
+|#
+
+(DEFUN CYLN-CMBN-CMBNA1 (cmbn)
+   (declare (type cmbn cmbn))
+   (the cmbn
+      (with-cmbn (degr list) cmbn
+         (make-cmbn :degr (1- degr)
+            :list (do ((rslt +empty-list+)
+                       (mark list (cdr mark)))
+                      ((endp mark) (nreverse rslt))
+                     (declare (list rslt mark))
+                     (with--term (cffc CYLN) mark
+                     (with-CYLN (CYLNx gnrtA1) CYLN
+                        (if (eq CYLNx :CYLNA1)
+                           (push (term cffc gnrtA1) rslt)
+                           (return (nreverse rslt))))))))))
+
+(DEFUN CYLN-CMBN-CMBNB (cmbn)
+   (declare (type cmbn cmbn))
+   (the cmbn
+      (with-cmbn (degr list) cmbn
+         (make-cmbn :degr degr
+            :list (do ((rslt +empty-list+)
+                       (mark (member :CYLNb list :key #'cadr) (cdr mark)))
+                      ((endp mark) (nreverse rslt))
+                     (declare (list rslt mark))
+                     (with--term (cffc CYLN) mark
+                     (with-CYLN (CYLNx gnrtB) CYLN
+                        (if (eq CYLNx :CYLNB)
+                           (push (term cffc gnrtB) rslt)
+                           (return (nreverse rslt))))))))))
+
+(DEFUN CYLN-CMBN-CMBNA2 (cmbn)
+   (declare (type cmbn cmbn))
+   (the cmbn
+      (with-cmbn (degr list) cmbn
+         (make-cmbn :degr degr
+            :list (mapcar
+                     #'(lambda (term)
+                          (declare (type term term))
+                          (with-term (cffc CYLN) term
+                             (term cffc (iCYLN CYLN))))
+                     (member :CYLNA2 list :key #'cadr))))))
+
+#|
+ 
+  (CYLN-cmbn-cmbnA1 (cmbn 3 1 (CYLNA1 'a) 2 (CYLNB 'b)))
+  (CYLN-cmbn-cmbnA1 (cmbn 3 2 (CYLNB 'b)))
+  (CYLN-cmbn-cmbnB (cmbn 3 1 (CYLNA1 'a) 2 (CYLNB 'b) 3 (CYLNA2 'c)))
+  (CYLN-cmbn-cmbnB (cmbn 3 1 (CYLNA1 'a) 3 (CYLNA2 'c)))
+  (CYLN-cmbn-cmbnA2 (cmbn 3 1 (CYLNA1 'a) 2 (CYLNB 'b) 3 (CYLNA2 'c)))
+  (CYLN-cmbn-cmbnA2 (cmbn 3 2 (CYLNA1 'b)))
+|#
+
+(DEFUN MAKE-CYLN-CMBN (cmbnA1 cmbnB cmbnA2)
+   (declare (type cmbn cmbnA1 cmbnB cmbnA2))
+   (the cmbn
+      (with-cmbn (degrA1 listA1) cmbnA1
+      (with-cmbn (degrB listB) cmbnB
+      (with-cmbn (degrA2 listA2) cmbnA2
+         (unless (= (1+ degrA1) degrB degrA2)
+            (error "In MAKE-CYLN-CMBN, the degrees are not coherent."))
+         (make-cmbn :degr degrB
+            :list (nconc
+                     (mapcar #'(lambda (termA1)
+                                  (declare (type term termA1))
+                                  (with-term (cffc gnrtA1) termA1
+                                     (term cffc (CYLNA1 gnrtA1))))
+                        listA1)
+                     (mapcar #'(lambda (termB)
+                                  (declare (type term termB))
+                                  (with-term (cffc gnrtB) termB
+                                     (term cffc (CYLNB gnrtB))))
+                        listB)
+                     (mapcar #'(lambda (termA2)
+                                  (declare (type term termA2))
+                                  (with-term (cffc gnrtA2) termA2
+                                     (term cffc (CYLNA2 gnrtA2))))
+                        listA2))))))))
+
+#|
+  (multiple-value-call #'make-CYLN-cmbn 
+     (dispatch-CYLN-cmbn (cmbn 3 3 (CYLNA1 'A11) 4 (CYLNA1 'A12) 33 (CYLNB 'B) 333 (CYLNA2 'A2))))
+|#
+
+(DEFMETHOD PRINT-KEYCONS ((car (eql :CYLNA1)) cdr stream)
+   (declare
+      (type gnrt cdr)
+      (stream stream))
+   (the (eql t)
+      (progn
+         (format stream "<CylnA1 ~A>" cdr)
+         t)))
+
+(DEFMETHOD PRINT-KEYCONS ((car (eql :CYLNB)) cdr stream)
+   (declare
+      (type gnrt cdr)
+      (stream stream))
+   (the (eql t)
+      (progn
+         (format stream "<CylnB ~A>" cdr)
+         t)))
+
+(DEFMETHOD PRINT-KEYCONS ((car (eql :CYLNA2)) cdr stream)
+   (declare
+      (type gnrt cdr)
+      (stream stream))
+   (the (eql t)
+      (progn
+         (format stream "<CylnA2 ~A>" cdr)
+         t)))
+
+#|
+  (CYLNa1 'a)
+  (CYLNB 'b)
+  (CYLNA2 'c)
+|#
+
+(DEFUN cylnX-CMPR (s1 s2)
+   (declare (symbol s1 s2))
+   (the cmpr
+      (if (string= s1 s2) :equal
+         (if (string= s1 :cylnA1) :less
+            (if (string= s2 :cylnA1) :greater
+               (if (string= s1 :cylnB) :less
+                  :greater))))))
+         
+
+(DEFUN CYLINDER-CMPR (cmprA cmprB)
+   (declare (type cmprf cmpra cmprb))
+   (flet ((rslt (cyln1 cyln2)
+             (declare (type cyln cyln1 cyln2))
+             (let ((cylnx1 (cylnx cyln1)))
+                (declare (type (member :cylnA1 :cylnB :cylnA2) cylnx))
+                (lexico
+                   (cylnX-CMPR cylnx1 (cylnx cyln2))
+                   (case cylnx1
+                      (:cylnA1 (funcall cmprA (icyln cyln1) (icyln cyln2)))
+                      (:cylnB (funcall cmprB (icyln cyln1) (icyln cyln2)))
+                      (:cylnA2 (funcall cmprA (icyln cyln1) (icyln cyln2))))))))
+      (the cmprf #'rslt)))
+
+#|
+  (setf r (cylinder-cmpr #'f-cmpr #'f-cmpr ))
+  (funcall r (cylnA1 1) (cylnB 0))
+  (funcall r (cylnA1 1) (cylnA1 2))
+  (funcall r (cylnB 0) (cylnA1 1))
+  (funcall r (cylnA1 2) (cylnA1 1)) 
+|#
+
+(DEFUN CYLINDER-BASIS (basisA basisB)
+   (declare (type basis basisA basisB))
+   (the basis
+      (if (or (eq :locally-effective basisA)
+              (eq :locally-effective basisB)
+              )
+         :locally-effective
+         (flet ((rslt (degr)
+                   (declare (fixnum degr))
+                   (append
+                      (mapcar #'(lambda (item)
+                                   (declare (type gnrt item))
+                                   (cylnA1 item))
+                         (funcall basisA (1- degr)))
+                      (mapcar #'(lambda (item)
+                                   (declare (type gnrt item))
+                                   (cylnB item))
+                         (funcall basisB degr))
+                      (mapcar #'(lambda (item)
+                                   (declare (type gnrt item))
+                                   (cylnA2 item))
+                         (funcall basisA degr)))))
+            (the basis #'rslt)))))
+
+#|
+  (CYLINDER-basis :locally-effective :locally-effective )
+  (setf b #'(lambda (degr) (mapcar #'(lambda (item) (cons degr item)) (<a-b> 0 degr))))
+  (setf r (CYLINDER-basis b b))
+  (funcall r 3)
+|#
+
+(DEFUN CYLINDER-INTR-DFFR (cmprA cmprB dffrA dffrB f)
+   (declare
+      (type cmprf cmprA cmprB)
+      (type morphism dffrA dffrB f))
+   (flet ((rslt (cmbn)
+             (declare (type cmbn cmbn))
+             (the cmbn
+                (multiple-value-bind (cmbnA1 cmbnB cmbnA2) (dispatch-cyln-cmbn cmbn)
+                   (declare (type cmbn cmbnA1 cmbnB cmbnA2))
+                   (let ((dffrA1-cmbn (cmbn-? dffrA cmbnA1))
+                         (dffrB-cmbn (cmbn-? dffrB cmbnB))
+                         (dffrA2-cmbn (cmbn-? dffrA cmbnA2))
+                         (f-cmbn (cmbn-? f cmbnA1))
+                         )
+                      (declare (type cmbn dffrA1-cmbn dffrB-cmbn dffrA2-cmbn f-cmbn))
+                      (let ((cmbnB (2cmbn-add cmprB f-cmbn dffrB-cmbn))
+                            (cmbnA2 (2cmbn-sbtr cmprA dffrA2-cmbn cmbnA1)))
+                         (declare (type cmbn cmbnB cmbnA2))
+                         (make-cyln-cmbn (cmbn-opps dffrA1-cmbn) cmbnB cmbnA2)))))))
+      (the intr-mrph #'rslt)))
+
+
+(DEFUN CYLINDER (f)
+   (declare (type morphism f))
+   (the chain-complex
+     (with-slots (sorc trgt) f
+       (declare
+        (type chain-complex sorc trgt ))
+       (let ((rslt (build-chcm
+                    :cmpr (cylinder-cmpr (cmpr sorc) (cmpr trgt))
+                    :basis (cylinder-basis (basis sorc) (basis trgt))
+                    :bsgn :undefined
+                    :intr-dffr (cylinder-intr-dffr (cmpr sorc) (cmpr trgt)
+                                     (dffr sorc) (dffr trgt) f)
+                    :strt :cmbn
+                    :orgn `(cylinder ,f))))
+          (declare (type chain-complex rslt))
+          (slot-makunbound rslt 'bsgn)
+          rslt))))
+
+
+
+
+
+(defun cylinder-rrdct (f)
+   (declare (type morphism f))
+   (the reduction
+     (with-slots (sorc (Bcc trgt)) f
+       (with-slots ((cmprb cmpr)) Bcc
+         (let ((cylinder (cylinder f)))
+            (let ((rf (build-mrph
+                       :sorc cylinder :trgt Bcc :degr 0
+                       :intr #'(lambda (cmbn)
+                                 (declare (type cmbn cmbn))
+                                 (2cmbn-add cmprB (cyln-cmbn-cmbnB cmbn) (cmbn-? f (cyln-cmbn-cmbnA2 cmbn))))
+                       :strt :cmbn
+                       :orgn `(cylinder ,f rf)))
+                  (rg (build-mrph
+                       :sorc Bcc :trgt cylinder :degr 0
+                       :intr #'(lambda (cmbn)
+                                 (declare (type cmbn cmbn))
+                                 (let* ((cmbnA1 (zero-cmbn (1- (cmbn-degr cmbn))))
+                                        (cmbnA2 (zero-cmbn (cmbn-degr cmbn))))
+                                    (declare (type cmbn cmbnA1 cmbnA2))
+                                    (make-cyln-cmbn cmbnA1 cmbn cmbnA2)))
+                       :strt :cmbn
+                       :orgn `(cylinder ,f rg)))
+                  (rh (build-mrph
+                       :sorc cylinder :trgt cylinder :degr +1
+                       :intr #'(lambda (cmbn)
+                                 (declare (type cmbn cmbn))
+                                 (let* ((cmbnA1 (cmbn-opps (cyln-cmbn-cmbnA2 cmbn)))
+                                        (cmbnB (zero-cmbn (1+ (cmbn-degr cmbn))))
+                                        (cmbnA2 (zero-cmbn (1+ (cmbn-degr cmbn)))))
+                                    (declare (type cmbn cmbnA1 cmbnB cmbnA2))
+                                    (make-cyln-cmbn cmbnA1 cmbnB cmbnA2)))
+                       :strt :cmbn
+                       :orgn `(cylinder ,f rh))))
+               (declare
+                (type chain-complex cylinder)
+                (type morphism rf rg rh))
+               (build-rdct :f rf :g rg :h rh :orgn `(cylinder right reduction ,f))))))))
+
+
+(defun cylinder-lrdct (f g h k)
+   (declare (type morphism f g h k))
+   (the reduction
+     (with-slots ((Acc sorc) (Bcc trgt)) f
+       (with-slots ((cmprA cmpr)) Acc
+         (with-slots ((cmprb cmpr)) Bcc
+           (let ((cylinder (cylinder f)))
+              (let ((lf (build-mrph
+                         :sorc cylinder :trgt Acc :degr 0
+                         :intr #'(lambda (cmbn)
+                                   (declare (type cmbn cmbn))
+                                   (2cmbn-sbtr cmprA 
+                                     (2cmbn-add cmpra (cyln-cmbn-cmbnA2 cmbn) (cmbn-? g (cyln-cmbn-cmbnB cmbn)))
+                                     (cmbn-? h (cyln-cmbn-cmbnA1 cmbn))))
+                         :strt :cmbn
+                         :orgn `(cylinder hmtpeq ,f lf)))
+                    (lg (build-mrph
+                         :sorc Acc :trgt cylinder :degr 0
+                         :intr #'(lambda (cmbn)
+                                   (declare (type cmbn cmbn))
+                                   (let* ((cmbnA1 (zero-cmbn (1- (cmbn-degr cmbn))))
+                                          (cmbnB (zero-cmbn (cmbn-degr cmbn)))
+                                          )
+                                      (declare (type cmbn cmbnA1 cmbnB ))
+                                      (make-cyln-cmbn cmbnA1 cmbnB cmbn)))
+                         :strt :cmbn
+                         :orgn `(cylinder hmtpeq ,f lg)))
+                    (lh (build-mrph
+                         :sorc cylinder :trgt cylinder :degr +1
+                         :intr #'(lambda (cmbn)
+                                   (declare (type cmbn cmbn))
+                                   (multiple-value-bind (cmbnA1 cmbnB cmbnA2) 
+                                       (dispatch-cyln-cmbn cmbn)
+                                      (let* ((cmbnA11 (cmbn-opps (cmbn-? h cmbnA1)))
+                                             (cmbnA12 (cmbn-opps (cmbn-? g (cmbn-? k (cmbn-? f cmbnA1)))))
+                                             (cmbnA13 (cmbn-? g (cmbn-? f (cmbn-? h cmbnA1))))
+                                             (cmbnA14 (cmbn-? g cmbnB))
+                                             (cmbnB1 (cmbn-opps (cmbn-? k (cmbn-? k (cmbn-? f cmbnA1)))))
+                                             (cmbnB2 (cmbn-? k (cmbn-? f (cmbn-? h cmbnA1))))
+                                             (cmbnB3 (cmbn-? k cmbnB))
+                                             (cmbnA21 (cmbn-opps (cmbn-? h (cmbn-? h cmbnA1))))
+                                             (cmbnA22 (cmbn-opps (cmbn-? h (cmbn-? g (cmbn-? k (cmbn-? f cmbnA1))))))
+                                             (cmbnA23 (cmbn-? h (cmbn-? g (cmbn-? f (cmbn-? h cmbnA1)))))
+                                             (cmbnA24 (cmbn-? g (cmbn-? k (cmbn-? k (cmbn-? f cmbnA1)))))
+                                             (cmbnA25 (cmbn-opps (cmbn-? g (cmbn-? k (cmbn-? f (cmbn-? h cmbnA1))))))
+                                             (cmbnA26 (cmbn-? h (cmbn-? g cmbnB)))
+                                             (cmbnA27 (cmbn-opps (cmbn-? g (cmbn-? k cmbnB)))))
+                                         (declare (type cmbn cmbnA11 cmbnA12 cmbnA13 cmbnA14
+                                                    cmbnB1 cmbnB2 cmbnB3 
+                                                    cmbnA21 cmbnA22 cmbnA23 cmbnA24 cmbnA25 cmbnA26 cmbnA27))
+                                         (make-cyln-cmbn (ncmbn-add cmprA cmbnA11 cmbnA12 cmbnA13 cmbnA14)
+                                     (ncmbn-add cmprB cmbnB1 cmbnB2 cmbnB3)
+                                     (ncmbn-add cmprA cmbnA21 cmbnA22 cmbnA23 cmbnA24 cmbnA25 cmbnA26 cmbnA27)))))
+                                     
+                         :strt :cmbn
+                         :orgn `(cylinder hmtpeq ,f lh))))
+            (declare
+                     (type chain-complex cylinder)
+                     (type morphism lf lg lh))
+            (build-rdct :f lf :g lg :h lh :orgn `(cylinder left reduction ,f ,g ,h ,k)))))))))
+
+
+#|
+ (cat-init) 
+ (setf z3 (cyclicgroup 3))
+ (setf rsltn1 (cyclicgroup-rsltn 3))
+ (setf rsltn2 (bar-rsltn z3))
+ (setf f (zgmrph-twi (2rsltn-zgmrph rsltn1 rsltn2)))
+ (setf g (zgmrph-twi (2rsltn-zgmrph rsltn2 rsltn1)))
+ (setf h (zgmrph-twi (2rsltn-hmtpop rsltn1 rsltn2)))
+ (setf k (zgmrph-twi (2rsltn-hmtpop rsltn2 rsltn1)))
+ (setf Acc (sorc f) Bcc (trgt f))
+
+
+ (setf rrdct (cylinder-rrdct f))
+ (setf lrdct (cylinder-lrdct f g h k))
+
+ (setf lf (f lrdct) lg (g lrdct) lh (h lrdct))
+ (setf rf (f rrdct) rg (g rrdct) rh (h rrdct))
+
+ (pre-check-rdct rrdct)
+ (setf *tc* (cmbn 3 1 (cylnA1 2) 10 (cylnB '(1 2 1)) 100 (cylnA2 3)))
+ (setf *bc* (cmbn 3 1 '(1 1 2)))
+ (check-rdct)
+ (setf *tc* (cmbn 4 10 (cylnB '(1 2 1 1)) 5 (cylnB '(1 2 2 1)) 100 (cylnA2 4)))
+ (setf *bc* (cmbn 2 5 '(1 1) 7 '(2 1) -4 '(2 2)))
+ (check-rdct)
+
+
+ (pre-check-rdct lrdct)
+
+ (setf *tc* (cmbn 3 1 (cylnA1 2) 10 (cylnB '(1 2 1)) 100 (cylnA2 3)))
+ (setf *bc* (cmbn 3 1 3))
+ (check-rdct)
+
+ (setf *tc* (cmbn 4 10 (cylnB '(1 2 1 1)) 5 (cylnB '(1 2 2 1)) 100 (cylnA2 4)))
+ (setf *bc* (cmbn 2 1 2))
+ (check-rdct)
+|#
+
+
+ (DEFMETHOD SEARCH-EFHM (smst (orgn (eql 'k-g-1)))
+   (declare (type simplicial-group smst))
+   (the homotopy-equivalence
+    (let* ((group (second (orgn smst)))
+           (rsltn1 (bar-rsltn group))
+           (rsltn2 (resolution group))
+           (f (zgmrph-twi (2rsltn-zgmrph rsltn1 rsltn2)))
+           (g (zgmrph-twi (2rsltn-zgmrph rsltn2 rsltn1)))
+           (h (zgmrph-twi (2rsltn-hmtpop rsltn1 rsltn2)))
+           (k (zgmrph-twi (2rsltn-hmtpop rsltn2 rsltn1)))
+           (rrdct (cylinder-rrdct f))
+           (lrdct (cylinder-lrdct f g h k)))
+       (build-hmeq :lrdct lrdct :rrdct rrdct :orgn  `(cylinder-hmeq ,f ,g ,h ,k )))))
+
+ #|
+ (setf z3 (cyclicgroup 3))
+ (setf k-z3-1 (k-g-1 z3))
+
+ (cat-init)
+ (setf z4 (cyclicgroup 4))
+ (setf k-z4-1 (k-g-1 z4))
+ (setf k-z4-2 (classifying-space k-z4-1))
+
+ (cat-init)
+ (setf z2 (cyclicgroup 2))
+ (setf k-z2-1 (k-g-1 z2))
+ (setf k-z2-2 (classifying-space k-z2-1))
+ |#
+        
diff --git a/examples/anromero/homology-of-groups/kzs.LSP b/examples/anromero/homology-of-groups/kzs.LSP
new file mode 100644
index 0000000..9553b29
--- /dev/null
+++ b/examples/anromero/homology-of-groups/kzs.LSP
@@ -0,0 +1,52 @@
+
+(load "file-list.lisp")
+
+(load-cfiles)
+
+(load "resolutions.lisp")
+
+(load "cylinders.lisp")
+
+
+;;
+
+
+(setf kz22 (k-zp 2 2))
+(setf kz23 (k-zp 2 3))
+(setf kz32 (k-zp 3 2))
+(setf kz33 (k-zp 3 3))
+(setf kz42 (k-zp 4 2))
+(setf kz43 (k-zp 4 3))
+(setf kz52 (k-zp 5 2))
+(setf kz53 (k-zp 5 3))
+
+
+(print "homology of kz22")
+(time (homology kz22 0 7))
+
+(print "homology of kz23")
+(time (homology kz23 0 7))
+
+(print "homology of kz32")
+(time (homology kz32 0 7))
+
+(print "homology of kz33")
+(time (homology kz33 0 7))
+
+(print "homology of kz42")
+(time (homology kz42 0 7))
+
+(print "homology of kz43")
+(time (homology kz43 0 7))
+
+(print "homology of kz52")
+(time (homology kz52 0 7))
+
+(print "homology of kz53")
+(time (homology kz53 0 7))
+
+
+
+
+
+
diff --git a/examples/anromero/homology-of-groups/resolutions.lisp b/examples/anromero/homology-of-groups/resolutions.lisp
new file mode 100644
index 0000000..418bf31
--- /dev/null
+++ b/examples/anromero/homology-of-groups/resolutions.lisp
@@ -0,0 +1,1600 @@
+
+
+;; RESOLUTIONS   RESOLUTIONS   RESOLUTIONS   RESOLUTIONS   RESOLUTIONS   RESOLUTIONS   
+;; RESOLUTIONS   RESOLUTIONS   RESOLUTIONS   RESOLUTIONS   RESOLUTIONS   RESOLUTIONS   
+;; RESOLUTIONS   RESOLUTIONS   RESOLUTIONS   RESOLUTIONS   RESOLUTIONS   RESOLUTIONS   
+
+(IN-PACKAGE "COMMON-LISP-USER")
+
+(provide "resolutions")
+
+
+;;;;;;;;;;;;;;;;;;;;;
+;;;;; clases y tipos
+;;;;;;;;;;;;;;;;;;;;;
+
+(DEFUN ZGgnrt-P (object)
+   (declare (type any object))
+   (the boolean
+     (and (consp object)
+          (eql :ZGgnrt (car object))
+          (consp (cdr object))
+          ;;(consp (cadr object))
+          ;;(consp (cddr object))
+          (typep (cadr object) 'gnrt)
+          (typep (cddr object) 'gnrt)
+          )))
+
+(DEFTYPE ZGgnrt () '(satisfies ZGgnrt-p)) 
+
+(DEFUN ZGTERM-P (object)
+   (declare (type any object))
+   (the boolean
+     (and (consp object)
+          (typep (car object) 'fixnum)
+          (typep (cdr object) 'ZGgnrt))))
+
+(DEFTYPE ZGTERM () '(satisfies zgterm-p))
+
+;; IZGCMBN = Internal-ZGCoMBiNation 
+(DEFUN IZGCMBN-P (object)
+;; IZGCMBN = Internal ZGCoMBiNation,    
+;; without the keyword and the degree
+   (declare (type any object))
+   (the boolean
+     (and (listp object)
+          (every #'zgterm-p object))))
+
+(DEFTYPE IZGCMBN () '(satisfies izgcmbn-p)) 
+
+;; ZGCMBN = ZGCoMBiNation 
+(DEFUN ZGCMBN-P (object)
+   (declare (type any object))
+   (the boolean
+     (and (consp object)
+          (eql (car object) :cmbn)
+          (consp (cdr object))
+          (typep (second object) 'fixnum)
+          (typep (cddr object) 'iZGcmbn))))
+
+(DEFTYPE ZGCMBN () '(satisfies ZGcmbn-p)) 
+
+
+
+(DEFTYPE GROUP-BASIS () '(or list (eql :locally-effective))) 
+  
+(DEFCLASS GROUP ()
+   ((elements :type group-basis :initarg :elements :reader elements)
+   (cmpr :type cmprf :initarg :cmpr :reader cmpr1)
+   (mult :type function :initarg :mult :reader mult1)
+   (inv :type function :initarg :inv :reader inv1)
+   (nullel :type gnrt :initarg :nullel :reader nullel)
+   (idnm :type fixnum :initform (incf *idnm-counter*) :reader idnm)
+   (orgn :type list :initarg :orgn :reader orgn)
+   (resolution :type reduction :initarg :resolution :reader resolution))
+  )
+
+(DEFCLASS AB-GROUP (GROUP)
+    ())
+
+
+(DEFTYPE GROUP-MORPHISM () 'function)
+
+(DEFVAR *group-list*)
+(SETF *group-list* +empty-list+)
+(PUSHNEW '*group-list* *list-list*)
+
+(DEFVAR *ab-group-list*)
+(SETF *ab-group-list* +empty-list+)
+(PUSHNEW '*ab-group-list* *list-list*)
+
+(DEFMETHOD PRINT-OBJECT ((group GROUP) stream)
+   (the GROUP
+     (progn
+      (format stream "[K~D Group]" (idnm group))
+      group)))
+
+(DEFMETHOD PRINT-OBJECT ((group ab-GROUP) stream)
+   (the ab-GROUP
+     (progn
+      (format stream "[K~D Abelian-Group]" (idnm group))
+      group)))
+
+(DEFUN GROUP (idnm)
+   (declare (type fixnum idnm))
+   (the (or GROUP null)
+      (find idnm *group-list* :key #'idnm)))
+
+(DEFUN AB-GROUP (idnm)
+   (declare (type fixnum idnm))
+   (the (or AB-GROUP null)
+      (find idnm *ab-group-list* :key #'idnm)))
+
+
+#|
+(DEFCLASS GROUP-WITH-RESOLUTION (GROUP)
+    ((resolution :type reduction :initarg :resolution :reader resolution)))
+
+(DEFVAR *group+res-list*)
+(SETF *group+res-list* +empty-list+)
+(PUSHNEW '*group+res-list* *list-list*)
+
+(DEFMETHOD PRINT-OBJECT ((group GROUP-WITH-RESOLUTION) stream)
+   (the GROUP-WITH-RESOLUTION
+     (progn
+      (format stream "[K~D Group with resolution]" (idnm group))
+      group)))
+
+(DEFUN GROUP-WITH-RESOLUTION (idnm)
+   (declare (type fixnum idnm))
+   (the (or GROUP-WITH-RESOLUTION null)
+      (find idnm *group+res-list* :key #'idnm)))
+|#
+   
+
+;;(DEFCLASS ZG-MORPHISM () ())  ;; will be redefined later.
+
+
+(DEFCLASS ZG-CHAIN-COMPLEX (chain-complex)
+    (
+     (group :type group :initarg :group :reader group1)
+     (zgcmpr :type cmprf :initarg :zgcmpr :reader zgcmpr1)
+     (zgbasis :type basis :initarg :zgbasis :reader zgbasis1)
+     (zgbsgn :type gnrt :initarg :zgbsgn :reader zgbsgn)
+     (zgbndr :type ZG-morphism :initarg :zgbndr :reader zgbndr1)
+     ))
+
+(DEFVAR *zgcc-list*)
+(SETF *zgcc-list* +empty-list+)
+(PUSHNEW '*zgcc-list* *list-list*)
+
+(DEFMETHOD PRINT-OBJECT ((zgcm ZG-CHAIN-COMPLEX) stream)
+   (the ZG-CHAIN-COMPLEX
+     (progn
+      (format stream "[K~D ZG-Chain-Complex]" (idnm zgcm))
+      zgcm)))
+
+(DEFUN ZGCC (idnm)
+   (declare (type fixnum idnm))
+   (the (or ZG-CHAIN-COMPLEX null)
+      (find idnm *zgcc-list* :key #'idnm)))
+
+
+
+
+;; ZGSTRT = ZGSTRaTegy 
+(DEFTYPE ZGSTRT () '(member :gnrt :zggnrt :zgcmbn))
+
+;; INTR-ZGMRPH = INTeRnal-ZGMoRPHism 
+(DEFTYPE INTR-ZGMRPH () 'function)                
+;; (or (function (degr gnrt) zgcmbn)    ;; if :gnrt strategy
+;;     (function (degr zggnrt) zgcmbn)  ;; if :zggnrt strategy                
+;;     (function (zgcmbn) zgcmbn)     ;; if :zgcmbn strategy 
+
+(DEFCLASS ZG-MORPHISM (morphism)
+    (
+     (zgintr :type intr-zgmrph :initarg :zg-intr :reader intr-zgmrph)
+     (zgstrt :type zgstrt :initarg :zgstrt :reader zgstrt) 
+    ))
+
+(DEFVAR *zgmrph-list*)
+(SETF *zgmrph-list* +empty-list+)
+(PUSHNEW '*zgmrph-list* *list-list*)
+
+
+(DEFMETHOD PRINT-OBJECT ((mrph ZG-MORPHISM) stream)
+   (the ZG-MORPHISM
+      (progn
+	(format stream "[K~D ZG-Morphism (degree ~D): K~D -> K~D]"
+		  (idnm mrph) (degr mrph)
+		  (idnm (sorc mrph)) (idnm (trgt mrph)))
+         mrph)))
+
+
+(DEFUN zgmrph (idnm)
+   (declare (type fixnum idnm))
+   (the (or ZG-MORPHISM null)
+      (find idnm *zgmrph-list* :key #'idnm)))
+
+
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;;; macros
+;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+(DEFMACRO ZGgnrt (gnrt1 gnrt2)
+  `(cons  :zggnrt
+     (cons ,gnrt1 ,gnrt2)))
+
+
+(DEFMACRO zggnrt1 (ZGgnrt)
+   `(car (cdr ,ZGgnrt)))
+
+(DEFMACRO zggnrt2 (ZGgnrt)
+  `(cddr ,ZGgnrt))
+
+;; (setf gn1 (zggnrt 'g1 'b1))
+;; (setf gn2 (zggnrt 'g2 'b1))
+;; (setf gn3 (zggnrt 'g1 'b2))
+;; (setf gn4 (zggnrt 'g2 'b2))
+
+(DEFMACRO WITH-ZGgnrt ((zggnrt1 zggnrt2) zggnrt . body)
+   `(let (,@(if zggnrt1 `((,zggnrt1 (zggnrt1 ,zggnrt))) nil)
+          ,@(if zggnrt2 `((,zggnrt2 (zggnrt2 ,zggnrt))) nil))
+       (declare
+         (type gnrt ,@(if zggnrt1 `(,zggnrt1) nil) ,@(if zggnrt2 `(,zggnrt2) nil)))
+       ,@body))
+
+;;(with-zggnrt (gnrt1 gnrt2) gn3
+;;     (progn
+;;      (format t "~D" gnrt1)
+;;      (format t "~D" gnrt2))) 
+
+
+;; Sobra??? podemos usar directamente el macro term
+(DEFMACRO ZGTERM (cffc zggnrt)
+  `(cons ,cffc ,zggnrt))
+
+
+;; Sobra??? podemos usar directamente el macro with-term
+(DEFMACRO WITH-zgTERM ((cffc zggnrt) zgterm . body)
+   `(let (,@(if cffc `((,cffc (cffc ,zgterm))) nil)
+          ,@(if zggnrt `((,zggnrt (gnrt ,zgterm))) nil))
+       (declare
+          (fixnum ,@(if cffc `(,cffc) nil))
+          (type zggnrt ,@(if zggnrt `(,zggnrt) nil)))
+       ,@body))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+(defun build-group 
+    (&key elements cmpr mult inv nullel orgn)
+   (declare 
+     (type group-basis elements)
+     (type cmprf cmpr)
+     (type group-morphism mult)
+     (type function inv)
+     (type gnrt nullel)
+     (list orgn))
+   (the group
+     (progn
+      (let ((already (find orgn *group-list* :test #'equal :key #'orgn)))
+         (declare (type (or group null) already))
+         (when already
+            (return-from build-group already)))
+      (unless elements
+         (setf elements :locally-effective))
+      (let ((group (make-instance 'group
+                     :cmpr cmpr
+                     :elements elements
+                     :mult mult
+                     :inv inv
+                     :nullel nullel
+                     :orgn orgn)))
+         (declare (type group group))   
+         (push group *group-list*)
+         group))))
+
+#|
+(setf elements '(0 1 2 3 4))
+(setf cmpr #'f-cmpr)
+(setf grmult #'(lambda (g1 g2)
+                  (mod (+ g1 g2) 5)))
+(setf inv #'(lambda (g)
+                 (mod (- 5 g) 5)))
+(setf nullel 0)
+(setf orgn '(Z_5))
+(setf gr (build-group :elements elements :cmpr cmpr :mult grmult :inv inv :nullel 0 :orgn orgn))
+|#
+
+(DEFMACRO BUILD-AB-GROUP (&rest rest)
+  `(change-class (build-group ,@rest) 'ab-group))
+ 
+#| 
+
+(defun build-group-with-resolution 
+    (&key elements cmpr mult inv nullel resolution orgn)
+   (the group-with-resolution
+     (progn
+         (let ((already (find orgn *group+res-list* :key #'orgn :test #'equal)))
+            (declare (type (or null group-with-resolution) already))
+            (when already
+               (return-from build-group-with-resolution already)))
+         (let ((rslt (build-group :elements elements :cmpr cmpr :mult mult :inv inv :nullel nullel 
+                      :orgn orgn)))
+            (declare (type group rslt))
+            (change-class rslt 'GROUP-WITH-RESOLUTION)
+            (setf (slot-value rslt 'resolution) resolution)
+            (push rslt *group+res-list*)
+               rslt))))
+
+|#
+
+
+
+        
+(DEFUN ZGGNRT-CMPR (grcmpr zgcmpr)
+   (declare (type cmprf grcmpr zgcmpr))
+   (flet ((rslt (gnrt1 gnrt2)
+            (declare (type zggnrt gnrt1 gnrt2))
+            (the cmpr
+              (let ((gnrt12 (zggnrt2 gnrt1))
+                    (gnrt22 (zggnrt2 gnrt2)))
+                 (declare (type gnrt gnrt12 gnrt22))
+                 (lexico
+                  (funcall zgcmpr gnrt12 gnrt22)
+                  (let ((gnrt11 (zggnrt1 gnrt1))
+                        (gnrt21 (zggnrt1 gnrt2)))
+                     (declare (type gnrt gnrt11 gnrt21))
+                     (funcall grcmpr gnrt11 gnrt21)))))))
+     (the cmprf #'rslt)))
+
+
+;;(setf cmpr (zggnrt-cmpr #'s-cmpr #'s-cmpr))
+;;(funcall cmpr gn1 gn2)
+
+(DEFUN ZGCHCM-BASIS (grbasis zgbasis)
+   (declare (type group-basis grbasis)
+            (type basis zgbasis))
+   (when (or (eq grbasis :locally-effective)
+             (eq zgbasis :locally-effective))
+      (return-from ZGCHCM-BASIS :locally-effective))
+   (flet ((rslt (degr)
+             (declare (fixnum degr))
+             (the list
+                (progn
+                   (when (minusp degr)
+                      (return-from rslt +empty-list+))
+                   (the list
+                     (mapcan
+                      #'(lambda (gnrt2)
+                          (declare (type gnrt gnrt2))
+                          (the list
+                            (mapcar
+                             #'(lambda (gnrt1)
+                                 (declare (type gnrt gnrt1))
+                                 (the zggnrt
+                                   (zggnrt gnrt1 gnrt2)))
+                             grbasis)))
+                       (funcall zgbasis degr)))
+                      ))
+                      ))
+      (the basis #'rslt)))
+
+;; (setf basis1 '(0 1 2 3 4))
+;; (setf basis2 
+;;       #'(lambda (degr)
+;;           (<a-b> 0 degr)))
+;; (setf zgbasis (ZGCHCM-BASIS basis1 basis2))
+   
+
+
+(DEFUN ZGMRPH-GNRT-GNRT (intr degr gnrt)
+   (declare
+    (type intr-zgmrph intr)
+    (fixnum degr)
+    (type gnrt gnrt))
+   (funcall intr degr gnrt))
+
+(DEFUN ZGMRPH-GNRT-ZGGNRT (grcmpr zgcmpr grmult intr degr zggnrt)
+   (declare
+    (type cmprf grcmpr zgcmpr)
+    (type group-morphism grmult)
+    (type intr-zgmrph intr)
+    (fixnum degr)
+    (type zggnrt zggnrt))
+   (let* ((zggnrt1 (zggnrt1 zggnrt))
+          (zggnrt2 (zggnrt2 zggnrt))
+          (zgcmbn (ZGMRPH-GNRT-GNRT intr degr zggnrt2))
+          (degr (cmbn-degr zgcmbn))
+          (list (cmbn-list zgcmbn))
+          (n-cmbn-list +empty-list+))
+      (declare (list n-cmbn-list))
+      (if list 
+         (progn 
+           (mapcar #'(lambda (zgterm)
+                  (declare (type zgterm zgterm))
+                  (with-zgterm (cffc gnrt) zgterm
+                   (declare (type fixnum cffc)
+                     (type zggnrt gnrt))
+                   (with-zggnrt (gnrt1 gnrt2) gnrt
+                    (declare (type gnrt gnrt1 gnrt2))
+                    (push (cons 1
+                      (term-cmbn degr cffc (zggnrt (funcall grmult zggnrt1 gnrt1) gnrt2)))
+                      n-cmbn-list))))
+             list)
+           (cmbn-cmbn (zggnrt-cmpr grcmpr zgcmpr) n-cmbn-list))
+         (zero-cmbn degr))))
+
+;; (setf grbasis '(0 1 2 3 4))
+;; (setf zgbasis 
+;;      #'(lambda (degr)
+;;           (<a-b> 0 degr)))
+;; (setf grmult #'(lambda (g1 g2)
+;;                  (mod (+ g1 g2) 5)))
+;; (setf grcmpr #'f-cmpr zgcmpr #'f-cmpr)
+;;(setf intr #'(lambda (degr gnrt)
+;;               (declare
+;;                (fixnum degr)
+;;                (type gnrt gnrt))
+;;               (let ((cmbn (cmbn degr)))
+;;                  (declare (type cmbn cmbn))
+;;                  (mapcar #'(lambda (i)
+;;                              (declare (fixnum i))
+;;                              (setf cmbn
+;;                               (2cmbn-add (zggnrt-cmpr #'f-cmpr #'f-cmpr) cmbn (term-cmbn degr i (zggnrt i gnrt))
+;;                               )))
+;;                    (<a-b> 1 4))
+;;                  cmbn)))
+
+;;(ZGMRPH-GNRT-ZGGNRT grcmpr zgcmpr grmult intr 5 (zggnrt 1 3))
+
+(DEFUN ZGMRPH-GNRT-ZGCMBN (grcmpr zgcmpr grmult intr zgcmbn)
+   (declare
+    (type cmprf grcmpr zgcmpr)
+    (type group-morphism grmult)
+    (type intr-zgmrph intr)
+    (type zgcmbn zgcmbn))
+      (the cmbn
+        (with-cmbn (degr list) zgcmbn
+          (if list
+             (let ((n-cmbn-list +empty-list+))
+                (declare (list n-cmbn-list))
+                (do ((mark list (cdr mark))
+                     )
+                    ((endp mark))
+                   (declare (list mark))
+                   (with-term (cffc gnrt) (car mark) 
+                   (push 
+                     (cons cffc 
+                       (zgmrph-gnrt-zggnrt grcmpr zgcmpr grmult intr degr gnrt))
+                     n-cmbn-list)))
+                (cmbn-cmbn (zggnrt-cmpr grcmpr zgcmpr) n-cmbn-list))
+             (cmbn degr)))))
+
+;;(ZGMRPH-GNRT-ZGCMBN grcmpr zgcmpr grmult intr (cmbn 5 2 (zggnrt 1 3) 3 (zggnrt 2 4)))
+
+
+(DEFUN ZGMRPH-ZGGNRT-ZGGNRT (intr degr zggnrt)
+   (declare
+    (type intr-zgmrph intr)
+    (fixnum degr)
+    (type zggnrt zggnrt))
+   (funcall intr degr zggnrt))
+
+
+
+(DEFUN ZGMRPH-ZGGNRT-ZGCMBN (grcmpr zgcmpr intr zgcmbn)
+   (declare
+    (type intr-zgmrph intr)
+    (type cmprf grcmpr zgcmpr)
+    (type zgcmbn zgcmbn))
+   
+      (the cmbn
+      (with-cmbn (degr list) zgcmbn
+         (let ((n-cmbn-list +empty-list+))
+            (declare (list n-cmbn-list))
+            (do ((mark list (cdr mark))
+                 )
+                ((endp mark))
+               (declare (list mark))
+               (with-term (cffc gnrt) (car mark) 
+                   (push 
+                     (cons cffc 
+                       (zgmrph-zggnrt-zggnrt intr degr gnrt))
+                     n-cmbn-list)))
+	    (cmbn-cmbn (zggnrt-cmpr grcmpr zgcmpr) n-cmbn-list)))))
+
+
+
+(DEFUN ZGmrph-GNRT-? (ZGmrph degr gnrt)
+   (declare
+      (type zg-morphism ZGmrph)
+      (fixnum degr)
+      (type gnrt gnrt))
+   (the cmbn
+     (with-slots (zgintr zgstrt trgt) zgmrph
+       (declare (type ZG-CHAIN-COMPLEX trgt)
+         (type intr-zgmrph zgintr)
+         (type zgstrt zgstr))
+       (with-slots (group) trgt
+            (declare
+             (type group group))
+
+       (with-slots (nullel) group
+         (declare (type gnrt nullel))
+         (prog1
+          (ecase zgstrt
+            (:gnrt
+             (zgmrph-gnrt-gnrt zgintr degr gnrt))
+            (:zggnrt
+             (funcall zgintr degr (zggnrt nullel gnrt)))
+            (:cmbn
+             (funcall zgintr (term-cmbn degr 1 (zggnrt nullel gnrt)))))
+          ))))))
+
+
+(DEFUN ZGmrph-ZGGNRT-? (ZGmrph degr zggnrt)
+   (declare
+      (type ZG-morphism ZGmrph)
+      (fixnum degr)
+      (type zggnrt zggnrt))
+   (the cmbn
+     (with-slots (trgt zgintr zgstrt ) zgmrph
+       (declare (type ZG-CHAIN-COMPLEX trgt)
+         (type intr-zgmrph zgintr)
+         (type zgstrt zgstr))
+       (with-slots (group) trgt
+            (declare
+             (type group group))
+       (with-slots ((grcmpr cmpr) mult nullel) group
+         (declare (type cmprf grcmpr)
+           (type group-morphism mult)
+           (type gnrt nullel))
+         (with-slots (zgcmpr)  trgt
+           (declare (type cmprf zgcmpr ))
+           (prog1
+                     (ecase zgstrt
+                        (:gnrt
+                         (zgmrph-gnrt-zggnrt grcmpr zgcmpr mult zgintr degr zggnrt))
+                        (:zggnrt
+                         (funcall zgintr degr zggnrt))
+                        (:cmbn
+                         (funcall zgintr (term-cmbn degr 1 zggnrt))))
+            )))))))
+
+
+(DEFUN ZGmrph-ZGCMBN-? (ZGmrph zgcmbn)
+   (declare
+      (type ZG-morphism ZGmrph)
+      (fixnum degr)
+      (type zggnrt zggnrt))
+   (the cmbn
+     (with-slots (trgt zgintr zgstrt ) zgmrph
+       (declare
+             (type zg-chain-complex trgt)
+             (type intr-zgmrph zgintr)
+             (type zgstrt zgstrt)
+        )
+       (with-slots (group zgcmpr) trgt
+            (declare (type group group)
+              (type cmprf zgcmpr))
+       (with-slots ((grcmpr cmpr) mult nullel) group
+         (declare
+          (type cmprf grcmpr)
+          (type group-morphism mult)
+          (type gnrt nullel))
+         (prog1
+          (ecase zgstrt
+            (:gnrt
+             (zgmrph-gnrt-zgcmbn grcmpr zgcmpr mult zgintr zgcmbn))
+            (:zggnrt
+             (zgmrph-zggnrt-zgcmbn grcmpr zgcmpr zgintr zgcmbn))
+            (:cmbn
+             (funcall zgintr zgcmbn)))
+            ))))))
+
+(Defun izgmrph-imrph (grcmpr zgcmpr mult intr strt)
+   (declare (type intr-zgmrph intr)
+     (type zgstrt strt)
+     (type group-morphism mult)
+     (type cmprf grcmpr zgcmpr))
+   (flet ((rslt (degr zggnrt)
+             (declare
+                (fixnum degr)
+                (type zggnrt zggnrt))
+             (ecase strt
+                        (:gnrt
+                         (zgmrph-gnrt-zggnrt grcmpr zgcmpr mult intr degr zggnrt))
+                        (:zggnrt
+                         (funcall intr degr zggnrt))
+                        (:cmbn
+                         (funcall intr (term-cmbn degr 1 zggnrt))))))
+     (the intr-mrph #'rslt)))
+
+
+(DEFUN INTR-ZGCHCM-MRPH (zgmrph)
+   (declare (type zg-morphism zgmrph))
+   (flet ((rslt (degr zggnrt)
+             (declare
+                (fixnum degr)
+                (type zggnrt zggnrt))
+             (zgmrph-zggnrt-? zgmrph degr zggnrt)))
+     (the intr-mrph #'rslt)))
+                
+               
+(DEFUN BUILD-ZGCHCM
+    (&key group zgcmpr zgbasis zgbsgn intr-zgbndr zgbndr-strt orgn)
+   (declare
+    (type group group)
+    (type cmprf zgcmpr)
+    (type basis zgbasis)
+    (type gnrt zgbsgn)
+    (type intr-zgmrph intr-zgbndr)
+    (type zgstrt zgbndr-strt)
+    (list orgn))
+   (let ((already (find orgn *zgcc-list* :test #'equal :key #'orgn)))
+      (declare (type (or zg-chain-complex null) already))
+      (when already
+         (return-from build-zgchcm already)))
+   (if intr-zgbndr
+      (unless zgbndr-strt
+            (error "In BUILD-ZGCHCM, an intr-zgbndr is given but not its strategy."))
+      )
+   (the zg-chain-complex
+     (with-slots ((grcmpr cmpr) (grbasis elements) mult nullel) group
+       (declare 
+         (type cmprf grcmpr)
+         (type list grbasis)
+         (type group-morphism mult)
+         (type gnrt nullel))
+       (let* ((cmpr (zggnrt-cmpr grcmpr zgcmpr))
+              (basis (ZGCHCM-BASIS grbasis zgbasis))
+              (bsgn (zggnrt nullel zgbsgn))
+              (intr-dffr (izgmrph-imrph grcmpr zgcmpr mult intr-zgbndr zgbndr-strt))
+              (rslt (build-chcm :cmpr cmpr :basis basis :bsgn bsgn
+                     :intr-dffr intr-dffr :strt :gnrt :orgn orgn)))
+         (change-class rslt 'zg-chain-complex)
+         (setf (slot-value rslt 'group) group)
+         (setf (slot-value rslt 'zgcmpr) zgcmpr)
+         (setf (slot-value rslt 'zgbasis) zgbasis)
+         (setf (slot-value rslt 'zgbsgn) zgbsgn)
+         (setf (slot-value rslt 'zgbndr) (build-zgmrph :sorc rslt :trgt rslt :degr -1
+                                          :zgintr intr-zgbndr :zgstrt zgbndr-strt :orgn `(zgbndr ,rslt)))
+         (push rslt *zgcc-list*)
+         rslt))))
+
+
+(DEFUN BUILD-ZGMRPH (&key sorc trgt degr zgintr zgstrt orgn)
+   (declare
+    (type zg-chain-complex sorc trgt)
+    (fixnum degr)
+    (type intr-zgmrph intr)
+    (type zgstrt strt)
+    (list orgn))
+   (the zg-morphism
+     (with-slots (group zgcmpr) trgt
+       (declare
+        (type group group)
+        (type cmprf zgcmpr))
+       (with-slots ((grcmpr cmpr) (grbasis elements) mult nullel ) group
+         (declare 
+           (type cmprf grcmpr)
+           (type list grbasis)
+           (type group-morphism mult)
+           (type gnrt nullel))
+         (let* ((intr (izgmrph-imrph grcmpr zgcmpr mult zgintr zgstrt))
+                (rslt (build-mrph :sorc sorc :trgt trgt :degr degr
+                        :intr intr :strt :gnrt :orgn orgn)))
+            (change-class rslt 'zg-morphism)
+            (setf (slot-value rslt 'zgintr) zgintr)
+            (setf (slot-value rslt 'zgstrt) zgstrt)
+            (push rslt *zgcc-list*)
+            rslt)))))
+
+
+
+
+
+;;(DEFMETHOD zg-?2 ((zgmrph zg-morphism) zgcmbn)
+;;   (declare (type zgcmbn zgcmbn))
+;;   (the zgcmbn
+;;      (zgmrph-zgcmbn-? zgmrph zgcmbn)))
+
+
+
+;;(DEFMETHOD zg-?3 ((zgmrph zg-morphism) degr gnrt)
+;;   (declare
+;;      (fixnum degr)
+;;      (type gnrt gnrt))
+;;   (the zgcmbn
+;;      (zgmrph-gnrt-? zgmrph degr gnrt)))
+
+
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;TENSOR WITH INTEGERS
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+(DEFUN zgcmbn-twi (zgcmpr zgcmbn)
+   (declare (type zgcmbn zgcmbn))
+   (with-cmbn (degr list) zgcmbn
+    (declare (fixnum degr)
+      (type list list))
+     (if list
+        (let* ((cmbn-list +empty-list+))
+           (mapcar #'(lambda (zgterm)
+                       (with-zgterm (cffc zggnrt) zgterm
+                         (let ((gnrt2 (zggnrt2 zggnrt)))
+                            (push (cons 1
+                                    (term-cmbn degr cffc gnrt2))
+                              cmbn-list))))
+             list)
+           (cmbn-cmbn zgcmpr cmbn-list))
+     (zero-cmbn degr))))
+
+;; (setf zgcmbn (cmbn 5 2 (zggnrt 1 3) 3 (zggnrt 2 4)))
+;; (zgcmbn-twi #'f-cmpr zgcmbn)
+;; (setf zgcmbn2 (cmbn 5 2 (zggnrt 1 3) 3 (zggnrt 2 4) -8 (zggnrt 6 3)))
+;; (zgcmbn-twi #'f-cmpr zgcmbn2)
+
+
+(Defun zgmrph-twi-intr (mrph)
+   (declare (type zg-morphism mrph))     
+   (flet ((rslt (degr gnrt)
+             (declare
+                (fixnum degr)
+                (type zggnrt zggnrt))
+            (with-slots (trgt) mrph
+              (with-slots (zgcmpr) trgt
+             (zgcmbn-twi zgcmpr (zgmrph-gnrt-? mrph degr gnrt))))))
+     (the intr-mrph #'rslt)))
+
+(defun zgmrph-twi (mrph)
+   (declare (type zg-morphism mrph))
+   (the morphism
+     (with-slots (sorc trgt degr orgn) mrph
+       (build-mrph :sorc (chcm-twi sorc) :trgt (chcm-twi trgt) :degr degr
+                     :intr (zgmrph-twi-intr mrph) :strt :gnrt :orgn `(tensor-with-integers ,orgn))
+                    )))
+
+(defun chcm-twi (chcm)
+   (declare (type zg-chain-complex chcm))
+   (the chain-complex
+     (if (string= (car (orgn chcm)) 'bar-zgchcm) 
+        (with-slots (group) chcm
+          (k-g-1 group))
+     (with-slots (zgcmpr zgbasis zgbsgn zgbndr orgn) chcm
+       (build-chcm :cmpr zgcmpr :basis zgbasis :bsgn zgbsgn :intr-dffr (zgmrph-twi-intr zgbndr) 
+        :strt :gnrt :orgn `(tensor-with-integers ,orgn))))))
+
+
+
+
+
+
+
+
+
+;;;;; EJEMPLOS
+
+
+#|
+(cat-init) 
+(setf Z3 (build-group :elements '(0 1 2) :cmpr #'f-cmpr :mult #'(lambda (g1 g2)
+                                                                  (mod (+ g1 g2) 3))
+          :inv #'(lambda (g)
+                 (mod (- 3 g) 3)) :nullel 0 :orgn '(Cyclic Group order 3)))
+
+(setf zgbasis #'(lambda (degr) (list degr)))
+(setf zgbspn 0)
+(setf zgcmpr #'f-cmpr)
+(setf intr #'(lambda(degr gnrt)
+               (let ((degr- (1- degr)))
+                  (if (oddp degr)
+                     (cmbn degr- -1 (zggnrt 0 degr-)  1 (zggnrt 1 degr-))
+                     (cmbn degr- 1 (zggnrt 0 degr-)  1 (zggnrt 1 degr-)  1 (zggnrt 2 degr-))))))
+
+(setf zgchcm (BUILD-ZGCHCM
+    :group Z3 :zgcmpr zgcmpr :zgbasis zgbasis :zgbsgn 0 :intr-zgbndr intr :zgbndr-strt :gnrt :orgn '(prueba)
+))
+
+(setf zgmrph (zgbndr1 zgchcm))
+(ZGmrph-GNRT-? zgmrph 4 4)
+(ZGmrph-zgGNRT-? zgmrph 4 (zggnrt 2 4))
+(ZGmrph-zgGNRT-? zgmrph 3 (zggnrt 0 3))
+(ZGmrph-zgGNRT-? zgmrph 3 (zggnrt 1 3))
+(ZGmrph-zgGNRT-? zgmrph 3 (zggnrt 2 3))
+(ZGmrph-zgGNRT-? zgmrph 4 (zggnrt 0 4))
+
+(ZGmrph-zgcmbn-? zgmrph (cmbn 4 1 (zggnrt 2 4) -3 (zggnrt 3 4)))
+(ZGmrph-zgcmbn-? zgmrph (cmbn 4 2 (zggnrt 2 4) -5 (zggnrt 3 4)))
+(ZGmrph-zgcmbn-? zgmrph (cmbn 3 1 (zggnrt 2 3) -3 (zggnrt 3 3)))
+(ZGmrph-zgGNRT-? zgmrph 3 (zggnrt 2 3))
+(ZGmrph-zgGNRT-? zgmrph 3 (zggnrt 3 3))
+
+
+(setf chcm (chcm-twi zgchcm))
+(? chcm 3 3)
+(? chcm 4 4)
+(? chcm 5 5 ))
+
+(homology chcm 0 10)
+
+|#
+
+
+#| 
+(setf ZCC
+      (the chain-complex
+        (build-chcm
+         :cmpr #'(lambda (gnrt1 gnrt2) (the cmpr :equal))
+         :basis #'(lambda (n)
+                    (the list
+                      (if (zerop n) '(:Z-gnrt) +empty-list+)))
+         :bsgn :Z-gnrt
+         :intr-dffr #'(lambda (cmbn)
+                        (the cmbn (zero-cmbn (1- (cmbn-degr cmbn)))))
+         :strt :cmbn
+         :orgn '(zcc-constant))))
+|#
+;; ya está definido con la función (z-chcm) 
+
+(defun cyclicgroup (n)
+   (declare (fixnum n))
+   (build-ab-group :elements (<a-b> 0 (1- n)) :cmpr #'f-cmpr :mult #'(lambda (g1 g2)
+                                                                  (mod (+ g1 g2) n))
+           :inv #'(lambda (g)
+                 (mod (- n g) n)) :nullel 0 :orgn `(Cyclic-group of order ,n)))
+
+(DEFMETHOD SLOT-UNBOUND (class (group group) (slot-name (eql 'resolution)))
+   (declare (ignore class))
+   (the reduction
+     (let ((rsltn (search-resolution group (first (orgn group)))))
+       (setf (slot-value group 'resolution)
+	     (or rsltn
+          (error "I don't know how to determine ~
+                         a resolution for 
+                         ~A (Origin: ~A)." group (orgn group)))))))
+
+(DEFGENERIC SEARCH-resolution (group orgn))
+
+(DEFMETHOD SEARCH-RESOLUTION (group orgn)
+  (declare (ignore group orgn))
+  nil)
+
+
+
+      
+
+(defun cyclicgroup-zgchcm (n)
+   (let* ((group (cyclicgroup n))
+          (zgbasis #'(lambda (degr) (list degr)))
+          (zgcmpr #'f-cmpr)
+          (intr #'(lambda(degr gnrt)
+               (let ((degr- (1- degr)))
+                  (if (zerop degr) (zero-cmbn -1)
+                     (if (oddp degr)
+                        (cmbn degr- -1 (zggnrt 0 degr-)  1 (zggnrt 1 degr-))
+                        (let ((list +empty-list+))
+                           (mapcar #'(lambda (i)
+                                       (push (cons 1 (zggnrt (- n i) degr-)) list))
+                             (<a-b> 1  n))
+                           (make-cmbn :degr degr- :list list))))))))
+          (BUILD-ZGCHCM
+    :group group :zgcmpr zgcmpr :zgbasis zgbasis :zgbsgn 0 
+           :intr-zgbndr intr :zgbndr-strt :gnrt :orgn  `(ZG-Chain complex for ,group)
+)))
+                     
+#|
+(setf z5 (cyclicgroup 5))
+(setf z5-zgchcm (cyclicgroup-zgchcm 5))
+(? z5-zgchcm 3 (zggnrt 2 3))
+(? z5-zgchcm 4 (zggnrt 2 4))
+|#   
+
+
+(defun cyclicgroup-rsltn (n)
+   (let* ((group (cyclicgroup n))
+          (zgchcm (cyclicgroup-zgchcm n))
+          (cmpr (cmpr1 zgchcm))
+          (f-intr #'(lambda (degr zggnrt)
+                      (if (zerop degr) (cmbn degr 1 :zgnrt) (zero-cmbn degr))))
+          (g-intr #'(lambda (degr gnrt)
+                      (if (zerop degr) (cmbn degr 1 (zggnrt 0 0)) (zero-cmbn degr))))
+          (h-intr #'(lambda (degr zggnrt)
+                      (with-zggnrt (gnrt1 gnrt2) zggnrt
+                        (if (oddp degr)
+                           (if (= gnrt1 (1- n)) (cmbn (1+ degr) 1 (zggnrt 0 (1+ degr)))
+                              (zero-cmbn (1+ degr)))
+                           (let ((list +empty-list+))
+                              (dotimes (i gnrt1)
+                                 (push (cons 1 (zggnrt i (1+ degr))) list ))
+                              (make-cmbn :degr (1+ degr) :list (nreverse list)))))))
+          (f (build-mrph :sorc zgchcm :trgt (z-chcm) :degr 0 :intr f-intr :strt :gnrt :orgn `(f-mrph for ,group)))
+          (g (build-mrph :sorc (z-chcm) :trgt zgchcm :degr 0 :intr g-intr :strt :gnrt :orgn  `(g-mrph for ,group)))
+          (h (build-mrph :sorc zgchcm :trgt zgchcm :degr 1 :intr h-intr :strt :gnrt :orgn `(h-mrph for ,group))))
+      (build-rdct :f f :g g :h h :orgn `(Resolution of ,group)))) 
+                     
+
+(DEFMETHOD SEARCH-RESOLUTION (group (orgn (eql 'Cyclic-group)))
+  (declare
+     (type group group))
+  (the reduction
+    (with-slots (elements) group
+      (let ((n (length elements)))
+         (cyclicgroup-rsltn n)))))
+
+
+
+
+(DEFMETHOD HOMOLOGY ((group group) degr1 &optional (degr2 (1+ degr1)))
+   (declare (fixnum degr1 degr2))
+   (with-slots (resolution) group 
+     (let ((chcm (chcm-twi (tcc resolution))))
+        (homology chcm degr1 degr2))))
+            
+#|
+(setf z3 (cyclicgroup 3))
+(homology z3 0 6)
+(setf g (build-group :elements '(0 1 2) :cmpr #'f-cmpr :mult #'(lambda (g1 g2)
+                                                                  (mod (+ g1 g2) 3))
+          :inv #'(lambda (g)
+                 (mod (- 3 g) 3)) :nullel 0 :orgn '(hola)))
+(homology g 0 6) 
+|#
+
+
+
+;;;; BAR RESOLUTION
+
+
+(defun bar-zgcmpr (grcmpr)
+   (declare (type cmprf grcmpr))
+   (labels ((rslt (gnrt1 gnrt2)
+           (declare (list gnrt1 gnrt2))
+           (unless gnrt1
+              (return-from rslt (if gnrt2 :less :equal)))
+           (unless gnrt2
+              (return-from rslt :greater))
+           (lexico
+            (funcall grcmpr (first gnrt1) (first gnrt2))
+            (rslt (rest gnrt1) (rest gnrt2)))
+         ))
+      (the cmprf #'rslt)))
+
+(defun bar-zgbasis (elements nullel)
+   (declare (type group-basis elements)
+     (type gnrt nullel))
+   (when (eq elements :locally-effective)
+      (return-from bar-zgbasis :locally-effective))
+   (labels ((rslt (degr)
+            (declare (fixnum degr))
+            ;;(the list
+              (progn
+               (when (minusp degr)
+                  (return-from rslt +empty-list+))
+               (when (zerop degr)
+                  (return-from rslt (list (list))))
+               (let ((basis-1 (rslt (1- degr)))
+                     (elements-0 (remove nullel elements)))
+                    (mapcan #'(lambda (gbar)
+                                (mapcar #'(lambda (g)
+                                            (append gbar (list g)))
+                                  elements-0)
+                                )
+                      basis-1)))))
+     ;;)
+     (the basis #'rslt)))
+                    
+                    
+
+(DEFUN bar-bndr-i (grmult nullel indx degr gnrt)
+   (declare
+    (fixnum indx degr)
+    (list gnrt))
+   (the cmbn
+     (cond ((zerop indx) (cmbn (1- degr) 1 (zggnrt (car gnrt) (rest gnrt))))
+           ((= indx degr) (cmbn (1- degr) 1 (zggnrt nullel (butlast gnrt))))
+           (t
+            (do ((rslt +empty-list+ (cons (car mark) rslt))
+                 (mark gnrt (cdr mark))
+                 (i 1 (1+ i)))
+                ((= i indx) (let ((new-k (funcall grmult (car mark) (cadr mark))))
+                                        (declare (type gnrt new-k))
+                               (if (eq nullel new-k)
+                                  (zero-cmbn (1- degr)) 
+                                  (cmbn (1- degr) 1 (zggnrt nullel (nreconc rslt (cons new-k (cddr mark))))))))
+               (declare
+                (list rslt mark)
+                (fixnum i)))))))
+
+
+(defun bar-bndr-intr (grcmpr grmult nullel)
+    #'(lambda (degr gnrt)
+        (if (zerop degr)
+           (zero-cmbn -1)
+           (let ((cmbn-list
+                  (mapcar #'(lambda (indx)
+                              (let ((cmbn (bar-bndr-i grmult nullel indx degr gnrt)))
+                                 (if (oddp indx)
+                                    (cons -1 cmbn)
+                                    (cons 1 cmbn))))
+                    (<a-b> 0 degr))))
+              (cmbn-cmbn (zggnrt-cmpr grcmpr (bar-zgcmpr grcmpr)) cmbn-list)))))
+     
+
+
+(defun bar-zgchcm (group)
+   (declare (type group group))
+  (the zg-chain-complex
+    (with-slots (elements cmpr mult nullel) group
+     (build-zgchcm
+      :group group
+      :zgcmpr (bar-zgcmpr cmpr)
+	:zgbasis (bar-zgbasis elements nullel)
+	:zgbsgn +empty-list+
+	:intr-zgbndr (bar-bndr-intr cmpr mult nullel)
+      :zgbndr-strt :gnrt
+	:orgn  `(bar-zgchcm ,group)))))
+
+(defun bar-cntrhmtp-intr (grcmpr grmult nullel)
+   #'(lambda (degr zggnrt)
+                      (with-zggnrt (gnrt1 gnrt2) zggnrt
+                        (if (eq nullel gnrt1)
+                           (zero-cmbn (1+ degr))
+                           (if (zerop degr)
+                              (cmbn 1 1 (zggnrt nullel (list gnrt1)))
+                              (cmbn (1+ degr) 1 (zggnrt nullel (cons gnrt1 gnrt2))))))))
+   
+
+(defun bar-f-intr ()
+   #'(lambda (degr zggnrt)
+       (if (zerop degr) (cmbn degr 1 :zgnrt) (zero-cmbn degr))))
+
+
+(defun bar-g-intr (nullel)
+   #'(lambda (degr gnrt)
+         (if (zerop degr) (cmbn degr 1 (zggnrt nullel +empty-list+)) (zero-cmbn degr))))
+
+(defun bar-rsltn (group)
+   (declare (type group group))
+   (the reduction
+    (with-slots (cmpr mult nullel) group
+      (let* ((zgchcm (bar-zgchcm group))
+             (f (build-mrph :sorc zgchcm :trgt (z-chcm) :degr 0 :intr (bar-f-intr) :strt :gnrt :orgn `(f-mrph in bar-resolution for ,group)))
+             (g (build-mrph :sorc (z-chcm) :trgt zgchcm :degr 0 :intr (bar-g-intr nullel) :strt :gnrt :orgn  `(g-mrph in bar-resolution for ,group)))
+             (h (build-mrph :sorc zgchcm :trgt zgchcm :degr 1 :intr (bar-cntrhmtp-intr cmpr mult nullel)
+                  :strt :gnrt :orgn `(h-mrph in bar-resolution for ,group))))
+         (build-rdct :f f :g g :h h :orgn `(Bar-resolution of ,group)))))) 
+
+
+                   
+;;; EJEMPLOS
+
+#|
+(setf z5 (cyclicgroup 5))
+(setf bar-chcm-z5 (bar-zgchcm z5))
+
+(setf zgbasis (zgbasis1 bar-chcm-z5))
+(funcall zgbasis 2)
+
+(setf zgmrph (zgbndr1 bar-chcm-z5))
+(ZGmrph-GNRT-? zgmrph 4 '(1 2 3 4))
+(ZGmrph-zgGNRT-? zgmrph 4 (zggnrt 2 '(1 2 3 4)))
+(ZGmrph-zgGNRT-? zgmrph 4 (zggnrt 1 '(1 1 4 4)))
+(ZGmrph-zgcmbn-? zgmrph (cmbn 4 1 (zggnrt 2 '(1 2 3 4)) -3 (zggnrt 1 '(1 1 4 4))))
+
+(setf chcm (chcm-twi bar-chcm-z5))
+(? chcm 4 '(1 2 3 4))
+(? chcm 5 '(1 1 2 3 4))
+
+
+(homology chcm 3)
+
+
+(setf bar-rsltn-z5 (bar-rsltn z5))
+(pre-check-rdct bar-rsltn-z5)
+
+(setf *tc* (cmbn 4 3 (zggnrt 4 '(1 2 1 4)) -3 (zggnrt 2 '(3 1 2 3)) 8 (zggnrt 1 '(4 4 3 2))))
+
+(setf *bc* (cmbn 0 1 :zgnrt))
+
+(check-rdct)
+
+
+
+|# 
+
+
+
+
+
+
+
+
+(defun K-G-1-cmpr (grcmpr)
+   (declare (type cmprf grcmpr))
+   (labels ((rslt (gnrt1 gnrt2)
+           (declare (list gnrt1 gnrt2))
+           (unless gnrt1
+              (return-from rslt (if gnrt2 :less :equal)))
+           (unless gnrt2
+              (return-from rslt :greater))
+           (lexico
+            (funcall grcmpr (first gnrt1) (first gnrt2))
+            (rslt (rest gnrt1) (rest gnrt2)))
+         ))
+      (the cmprf #'rslt)))
+
+(defun K-G-1-basis (elements nullel)
+   (declare (type group-basis elements)
+     (type gnrt nullel))
+   (when (eq elements :locally-effective)
+      (return-from K-G-1-basis :locally-effective))
+   (labels ((rslt (degr)
+            (declare (fixnum degr))
+            ;;(the list
+              (progn
+               (when (minusp degr)
+                  (return-from rslt +empty-list+))
+               (when (zerop degr)
+                  (return-from rslt (list (list))))
+               (let ((basis-1 (rslt (1- degr)))
+                     (elements-0 (remove nullel elements)))
+                    (mapcan #'(lambda (gbar)
+                                (mapcar #'(lambda (g)
+                                            (append gbar (list g)))
+                                  elements-0)
+                                )
+                      basis-1)))))
+     ;;)
+     (the basis #'rslt)))
+                    
+                    
+
+(DEFUN K-G-1-FACE (grmult nullel)
+   (flet ((face (indx dmns gmsm)
+            (declare
+             (fixnum indx dmns)
+             (list gmsm))
+            (the absm
+              (cond ((zerop indx) (absm 0 (rest gmsm)))
+                    ((= indx dmns) (absm 0 (butlast gmsm)))
+                    (t
+                     (do ((rslt +empty-list+ (cons (car mark) rslt))
+                          (mark gmsm (cdr mark))
+                          (i 1 (1+ i)))
+                         ((= i indx) (let ((new-k (funcall grmult (car mark) (cadr mark))))
+                                        (declare (type gnrt new-k))
+                                        (if (eq nullel new-k)
+                                           (absm (2-exp (1- indx)) (nreconc rslt (cddr mark)))
+                                           (absm 0 (nreconc rslt (cons new-k (cddr mark)))))))
+                        (declare
+                         (list rslt mark)
+                         (fixnum i))))))))
+     (the face #'face)))
+         
+   
+(DEFUN G-ABSM-BAR (nullel absm)
+  (declare (type absm absm))
+  (the list
+    (with-absm (dgop bar1) absm
+      (do ((dgop dgop (ash dgop -1))
+	   (rslt +empty-list+))
+	  ((and (zerop dgop) (endp bar1)) (nreverse rslt))
+	  (declare
+	     (fixnum dgop)
+	     (list rslt))
+	  (push (if (oddp dgop)
+		    nullel
+		  (pop bar1))
+		rslt)))))
+
+
+(DEFUN G-BAR-ABSM (nullel bar)
+  (declare (list bar))
+  (the absm
+     (do ((rslt-dgop 0)
+	  (rslt-bar +empty-list+)
+	  (mark bar (cdr mark))
+	  (bark 1 (+ bark bark)))
+	 ((endp mark) (absm rslt-dgop (nreverse rslt-bar)))
+	(declare
+	   (fixnum rslt-dgop bark)
+	   (list rslt-bar mark))
+	(let ((k-i (car mark)))
+	  (declare (fixnum k-i))
+	  (if (eq nullel k-i)
+	     (incf rslt-dgop bark)
+	     (push k-i rslt-bar))))))
+
+ 
+
+(DEFUN K-G-1-GRML (grmult nullel)
+   (flet ((grml (dmns crpr)
+            (declare
+             (fixnum dmns)
+             (type crpr crpr))
+            (the absm
+              (with-crpr (dgop1 bar1 dgop2 bar2) crpr
+                (do ((indx 1 (1+ indx))
+                     (dgop1 dgop1 (ash dgop1 -1))
+                     (dgop2 dgop2 (ash dgop2 -1))
+                     (bark 1 (ash bark +1))
+                     (rslt-dgop 0)
+                     (rslt-bar +empty-list+))
+                    ((> indx dmns) (absm rslt-dgop (nreverse rslt-bar)))
+                   (declare
+                    (fixnum indx dgop1 dgop2 bark rslt-dgop)
+		(list rslt-bar))
+                   (let ((item (if (evenp dgop1)
+                                  (if (evenp dgop2)
+                                     (funcall grmult (pop bar1) (pop bar2))
+                                     (pop bar1))
+                                  (if (evenp dgop2)
+                                     (pop bar2)
+                                     nullel))))
+                      (declare (type gnrt item))
+                      (if (eq nullel item)
+                         (incf rslt-dgop bark)
+                         (push item rslt-bar))))))))
+     (the intr-mrph #'grml)))
+
+
+(DEFUN K-G-1-GRIN (grin)
+   (flet ((grin (dmns bar)
+            (declare
+             (ignore dmns)
+             (list bar))
+            (the absm
+              (absm 0 (mapcar #'grin bar)))))
+     (the intr-mrph #'grin)))
+          
+
+
+(DEFMETHOD K-G-1 ((group GROUP))
+   (declare (type group group))
+  (the simplicial-group
+    (with-slots (elements cmpr mult nullel inv) group
+     (build-smgr
+      :cmpr (k-g-1-cmpr cmpr)
+	:basis (k-g-1-basis elements nullel)
+	:bspn +empty-list+
+	:face (k-g-1-face mult nullel)
+	:sintr-grml (k-g-1-grml mult nullel)
+	:sintr-grin (k-g-1-grin inv)
+	:orgn  `(k-g-1 ,group)))
+    ))
+
+(DEFMETHOD K-G-1 ((group AB-GROUP))
+   (declare (type AB-group group))
+  (the AB-simplicial-group
+    (with-slots (elements cmpr mult nullel inv) group
+     (build-AB-smgr
+      :cmpr (k-g-1-cmpr cmpr)
+	:basis (k-g-1-basis elements nullel)
+	:bspn +empty-list+
+	:face (k-g-1-face mult nullel)
+	:sintr-grml (k-g-1-grml mult nullel)
+	:sintr-grin (k-g-1-grin inv)
+	:orgn  `(k-g-1 ,group)))
+    ))
+
+(DEFUN K-G (gROUP n)
+   (declare (fixnum n)
+     (type group group))
+   (the ab-simplicial-group
+      (if (= n 1)
+         (k-g-1 group)
+         (classifying-space (k-g group (1- n))))))
+
+(DEFUN K-ZP-1 (p)
+   (k-g-1 (cyclicgroup p)))
+
+(DEFUN K-Zp (p n)
+   (declare (fixnum p n)
+     )
+   (the ab-simplicial-group
+      (if (= n 1)
+         (k-Zp-1 p)
+         (classifying-space (k-Zp p (1- n))))))
+  
+
+(defun rsltn-zgchcm (rsltn)
+   (declare (type reduction rsltn))
+   (tcc rsltn))
+
+(defun rsltn-cntrhmtp (rsltn)
+   (declare (type reduction rsltn))
+   (h rsltn))
+   
+(defun 2rsltn-zgmrph-intr (rsltn1 rsltn2)
+   (let ((zgchcm1 (rsltn-zgchcm rsltn1))
+         (zgchcm2 (rsltn-zgchcm rsltn2))
+         (h2 (rsltn-cntrhmtp rsltn2))
+         (f1 (f rsltn1))
+         (g2 (g rsltn2))
+         (d1 (zgbndr1 (rsltn-zgchcm rsltn1))))
+      
+      (with-slots (group (zgcmpr2 zgcmpr)) zgchcm2
+        (with-slots ((grcmpr cmpr) mult nullel) group
+          (labels ((rslt (degr gnrt)
+                     (if (zerop degr)
+                        (? g2 (? f1 degr (zggnrt nullel gnrt)))
+                        (? h2 
+                          
+                          (with-cmbn (degr- list) (zgmrph-gnrt-? d1 degr gnrt)
+                            (let ((n-cmbn-list +empty-list+))
+                               (declare (list n-cmbn-list))
+                               (do ((mark list (cdr mark))
+                                    )
+                                   ((endp mark))
+                                  (declare (list mark))
+                                  (with-term (cffc ZGgnrt) (car mark) 
+                                    (push 
+                                      (cons cffc 
+                                        
+                                        (let* ((gnrt1 (zggnrt1 zggnrt))
+                                               (gnrt2 (zggnrt2 zggnrt))
+                                               (zgcmbn (rslt degr- gnrt2))
+                                               (list (cmbn-list zgcmbn))
+                                               (n-cmbn-list2 +empty-list+))
+                                           (declare (list n-cmbn-list2))
+                                           (if list 
+                                              (progn 
+                                                (mapcar #'(lambda (zgterm)
+                                                            (declare (type zgterm zgterm))
+                                                            (with-zgterm (cffc2 zggnrt2) zgterm
+                                                             (declare (type fixnum cffc2)
+                                                               (type zggnrt zggnrt2))
+                                                             (with-zggnrt (gnrt21 gnrt22) zggnrt2
+                                                              (declare (type gnrt gnrt21 gnrt22))
+                                                              (push (cons 1
+                                                                      (term-cmbn degr- cffc2 (zggnrt (funcall mult gnrt1 gnrt21) gnrt22)))
+                                                                n-cmbn-list2))))
+                                                  list)
+                                                (cmbn-cmbn (zggnrt-cmpr grcmpr zgcmpr2) n-cmbn-list2))
+                                              (zero-cmbn degr-))))
+                                        
+
+                                        n-cmbn-list)))
+                               (cmbn-cmbn (zggnrt-cmpr grcmpr zgcmpr2) n-cmbn-list)))))))
+            #'rslt)))))
+                          
+
+
+
+                    
+
+
+(defun 2rsltn-zgmrph (rsltn1 rsltn2)
+   (let ((zgchcm1 (rsltn-zgchcm rsltn1))
+         (zgchcm2 (rsltn-zgchcm rsltn2)))
+      (build-zgmrph :sorc zgchcm1 :trgt zgchcm2 :degr 0 :zgintr (2rsltn-zgmrph-intr rsltn1 rsltn2)
+       :zgstrt :gnrt :orgn `(ZG-morphism from ,rsltn1 to ,rsltn2))))
+
+
+#|
+
+(cat-init) 
+(setf z3 (cyclicgroup 3))
+(setf rsltn1 (cyclicgroup-rsltn 3))
+(setf rsltn2 (bar-rsltn z3))
+(setf f (2rsltn-zgmrph rsltn1 rsltn2))
+(setf g (2rsltn-zgmrph rsltn2 rsltn1))
+
+(setf zgchcm1 (rsltn-zgchcm rsltn1))
+(setf zgchcm2 (rsltn-zgchcm rsltn2))
+(setf f1 (f rsltn1)
+         g2 (g rsltn2))
+(setf d1 (zgbndr1 (rsltn-zgchcm rsltn1)))
+(setf h2 (rsltn-cntrhmtp rsltn2))
+(setf group (group1 zgchcm2) zgcmpr2 (zgcmpr1 zgchcm2))
+(setf grcmpr (cmpr1 group) mult (mult1 group) nullel (nullel group))
+
+(ZGmrph-GNRT-? f 0 0)
+(ZGmrph-zgGNRT-? f 0 (zggnrt 0 0))
+(ZGmrph-zgGNRT-? f 0 (zggnrt 1 0))
+(ZGmrph-zgGNRT-? f 0 (zggnrt 2 0))
+(ZGmrph-zgGNRT-? f 1 (zggnrt 0 1))
+(ZGmrph-zgGNRT-? f 1 (zggnrt 1 1))
+(ZGmrph-zgGNRT-? f 1 (zggnrt 2 1))
+
+(ZGmrph-zgGNRT-? f 2 (zggnrt 2 2))
+(? f 2 (zggnrt 2 2))
+
+
+(zgmrph-gnrt-? f 1 1)
+(setf f-intr (2rsltn-zgmrph-intr rsltn1 rsltn2))
+(funcall f-intr 1 1)
+
+     
+|#
+
+
+
+(defun 2rsltn-hmtpop-intr (rsltn1 rsltn2)
+   (let ((zgchcm1 (rsltn-zgchcm rsltn1))
+         (h1 (rsltn-cntrhmtp rsltn1))
+         (m (2rsltn-zgmrph rsltn1 rsltn2))
+         (n (2rsltn-zgmrph rsltn2 rsltn1))
+         (d1 (zgbndr1 (rsltn-zgchcm rsltn1))))
+      
+      
+      (with-slots (group (zgcmpr1 zgcmpr)) zgchcm1
+        (with-slots ((grcmpr cmpr) mult nullel) group
+          (let ((cmpr (zggnrt-cmpr grcmpr zgcmpr1)))
+             
+             (labels ((rslt (degr gnrt)
+                       (if (zerop degr)
+                        (2cmbn-sbtr cmpr (? h1 degr (zggnrt nullel gnrt)) 
+                                         (? h1 (zgmrph-zgcmbn-? n (zgmrph-gnrt-? m degr gnrt))))
+                          (2cmbn-sbtr cmpr (2cmbn-sbtr cmpr (? h1 degr (zggnrt nullel gnrt)) 
+                                         (? h1 (zgmrph-zgcmbn-? n (zgmrph-gnrt-? m degr gnrt))))
+                           (? h1 
+                             (with-cmbn (degr- list) (zgmrph-gnrt-? d1 degr gnrt)
+                            (let ((n-cmbn-list +empty-list+))
+                               (declare (list n-cmbn-list))
+                               (do ((mark list (cdr mark))
+                                    )
+                                   ((endp mark))
+                                  (declare (list mark))
+                                  (with-term (cffc ZGgnrt) (car mark) 
+                                    (push 
+                                      (cons cffc 
+                                        
+                                        (let* ((gnrt1 (zggnrt1 zggnrt))
+                                               (gnrt2 (zggnrt2 zggnrt))
+                                               (zgcmbn (rslt degr- gnrt2))
+                                               (list (cmbn-list zgcmbn))
+                                               (n-cmbn-list2 +empty-list+))
+                                           (declare (list n-cmbn-list2))
+                                           (if list 
+                                              (progn 
+                                                (mapcar #'(lambda (zgterm)
+                                                            (declare (type zgterm zgterm))
+                                                            (with-zgterm (cffc2 zggnrt2) zgterm
+                                                             (declare (type fixnum cffc2)
+                                                               (type zggnrt zggnrt2))
+                                                             (with-zggnrt (gnrt21 gnrt22) zggnrt2
+                                                              (declare (type gnrt gnrt21 gnrt22))
+                                                              (push (cons 1
+                                                                      (term-cmbn degr cffc2 (zggnrt (funcall mult gnrt1 gnrt21) gnrt22)))
+                                                                n-cmbn-list2))))
+                                                  list)
+                                                (cmbn-cmbn cmpr n-cmbn-list2))
+                                              (zero-cmbn degr))))
+                                        
+
+                                        n-cmbn-list)))
+                               (cmbn-cmbn cmpr n-cmbn-list)))
+                             
+                             
+                             
+                             
+                             
+                             
+                             
+                             
+                             )))))
+                          
+                          
+            #'rslt))))))
+
+(defun 2rsltn-hmtpop (rsltn1 rsltn2)
+   (let ((zgchcm1 (rsltn-zgchcm rsltn1))
+         )
+      (build-zgmrph :sorc zgchcm1 :trgt zgchcm1 :degr 1 :zgintr (2rsltn-hmtpop-intr rsltn1 rsltn2)
+       :zgstrt :gnrt :orgn `(ZG-homotopy-operator from ,rsltn1 to ,rsltn2))))
+
+
+
+#|
+
+(cat-init) 
+(setf z3 (cyclicgroup 3))
+(setf rsltn1 (cyclicgroup-rsltn 3))
+(setf rsltn2 (bar-rsltn z3))
+(setf f (2rsltn-zgmrph rsltn1 rsltn2))
+(setf g (2rsltn-zgmrph rsltn2 rsltn1))
+(setf k1 (2rsltn-hmtpop rsltn1 rsltn2))
+(setf k2 (2rsltn-hmtpop rsltn2 rsltn1))
+
+
+
+(setf zgchcm1 (rsltn-zgchcm rsltn1))
+(setf zgchcm2 (rsltn-zgchcm rsltn2))
+(setf d1 (zgbndr1 zgchcm1))
+(setf d2 (zgbndr1 zgchcm2))
+
+(setf iz1 (add (cmps d1 k1) (cmps k1 d1)))
+(setf drch1 (sbtr (idnt-mrph zgchcm1) (cmps g f)))
+
+(setf iz2 (add (cmps d2 k2) (cmps k2 d2)))
+(setf drch2 (sbtr (idnt-mrph zgchcm2) (cmps f g)))
+
+(? iz1 0 (zggnrt 0 0))
+(? drch1 0 (zggnrt 0 0))
+
+(? iz1 1 (zggnrt 0 1))
+(? drch1 1 (zggnrt 0 1))
+(? iz1 2 (zggnrt 0 2))
+(? drch1 2 (zggnrt 0 2))
+(? iz1 3 (zggnrt 0 3))
+(? drch1 3 (zggnrt 0 3))
+
+(? d1 (? k1 1 (zggnrt 0 1)))
+(? k1 (? d1 1 (zggnrt 0 1)))
+(? (cmps g f) 1 (zggnrt 0 1))
+(? f 1 (zggnrt 0 1))
+(? g (? f 1 (zggnrt 0 1)))
+
+
+(dotimes (i 6)
+   (progn
+    (print (? iz1 i (zggnrt 0 i)))
+    (print (? drch1 i (zggnrt 0 i)))
+))
+
+(? iz2 1 (zggnrt 0 '(1)))
+(? drch2 1 (zggnrt 0 '(1)))
+(? iz2 2 (zggnrt 0 '(2 1)))
+(? drch2 2 (zggnrt 0 '(2 1)))
+(? iz2 2 (zggnrt 0 '(1 1)))
+(? drch2 2 (zggnrt 0 '(1 1)))
+
+
+(? iz2 3 (zggnrt 0 '(1 1 2)))
+(? drch2 3 (zggnrt 0 '(1 1 2)))
+|#
+
+
+#| 
+(cat-init) 
+(setf z4 (cyclicgroup 4))
+(setf rsltn1 (bar-rsltn z4))
+(setf rsltn2 (cyclicgroup-rsltn 4))
+
+(setf f (2rsltn-zgmrph rsltn1 rsltn2))
+(setf g (2rsltn-zgmrph rsltn2 rsltn1))
+(setf h (2rsltn-hmtpop rsltn1 rsltn2))
+(setf k (2rsltn-hmtpop rsltn2 rsltn1))
+
+(setf zgchcm1 (rsltn-zgchcm rsltn1))
+(setf zgchcm2 (rsltn-zgchcm rsltn2))
+(setf d1 (zgbndr1 zgchcm1))
+(setf d2 (zgbndr1 zgchcm2))
+
+(setf h2 (rsltn-cntrhmtp rsltn2)
+         f1 (f rsltn1)
+         g2 (g rsltn2))
+
+(setf group (group1 zgchcm2)
+      zgcmpr2 (zgcmpr1 zgchcm2))
+
+(setf grcmpr (cmpr1 group) mult (mult1 group) nullel (nullel group))
+
+         
+
+
+
+(setf iz1 (add (cmps d1 h) (cmps h d1)))
+(setf drch1 (sbtr (idnt-mrph zgchcm1) (cmps g f)))
+
+(? iz1 0 (zggnrt 0 '()))
+(? drch1 0 (zggnrt 0 '()))
+(? f 0 (zggnrt 0 nil))
+
+(? iz1 1 (zggnrt 0 '(1)))
+(? drch1 1 (zggnrt 0 '(1)))
+(? f 1 (zggnrt 0 '(1)))
+
+
+(? iz1 2 (zggnrt 0 '(1 1)))
+(? drch1 2 (zggnrt 0 '(1 1)))
+
+(? iz1 3 (zggnrt 0 '(1 1 1)))
+(? drch1 3 (zggnrt 0 '(1 1 1)))
+
+(? iz1 4 (zggnrt 0 '(1 1 1 1)))
+(? drch1 4 (zggnrt 0 '(1 1 1 1)))
+
+(setf iz2 (add (cmps d2 k) (cmps k d2)))
+(setf drch2 (sbtr (idnt-mrph zgchcm2) (cmps f g)))
+
+(? iz2 4 (zggnrt 0 4))
+(? drch2 4 (zggnrt 0 4))
+
+
+|# 
+
+
+ 
\ No newline at end of file
diff --git a/examples/anromero/persistent-homology/filtered-complexes.lsp b/examples/anromero/persistent-homology/filtered-complexes.lsp
new file mode 100644
index 0000000..ab665f7
--- /dev/null
+++ b/examples/anromero/persistent-homology/filtered-complexes.lsp
@@ -0,0 +1,843 @@
+;; FILTERED-COMPLEXES   FILTERED-COMPLEXES   FILTERED-COMPLEXES   FILTERED-COMPLEXES
+;; FILTERED-COMPLEXES   FILTERED-COMPLEXES   FILTERED-COMPLEXES   FILTERED-COMPLEXES
+;; FILTERED-COMPLEXES   FILTERED-COMPLEXES   FILTERED-COMPLEXES   FILTERED-COMPLEXES
+
+(IN-PACKAGE "COMMON-LISP-USER")
+
+(provide "filtered-complexes")
+
+(DEFTYPE degr () 'fixnum)
+
+(DEFTYPE CHCM-FLIN () 'function) 
+                     ;; '(function (degr gnrt) degr)
+
+
+(DEFCLASS FILTERED-CHAIN-COMPLEX (chain-complex)
+    ((flin :type chcm-flin :initarg :flin :reader flin1)))
+
+(DEFVAR *flcc-list*)
+(SETF *flcc-list* +empty-list+)
+(PUSHNEW '*flcc-list* *list-list*)
+
+(DEFMETHOD PRINT-OBJECT ((flcm FILTERED-CHAIN-COMPLEX) stream)
+(the FILTERED-CHAIN-COMPLEX
+   (progn
+      (format stream "[K~D Filtered-Chain-Complex]" (idnm flcm))
+     flcm)))
+
+(DEFUN FLCC (idnm)
+   (declare (type fixnum idnm))
+   (the (or FILTERED-CHAIN-COMPLEX null)
+      (find idnm *flcc-list* :key #'idnm)))
+
+
+;; Function that builds a filtered chain complex. 
+(DEFUN BUILD-FLCC
+    (&key cmpr basis bsgn intr-dffr dffr-strt flin orgn)
+   (declare
+      (type cmprf cmpr)
+      (type intr-mrph intr-dffr)
+      (type basis basis)
+      (type gnrt bsgn)
+      (type strt dffr-strt)
+      (type Chcm-Flin flin)
+      (list orgn))
+   (the FILTERED-CHAIN-COMPLEX
+     (progn
+         (let ((already (find orgn *flcc-list* :key #'orgn :test #'equal)))
+            (declare (type (or null FILTERED-CHAIN-COMPLEX) already))
+            (when already
+               (return-from build-flcc already)))
+         (let ((rslt (build-chcm :cmpr cmpr :basis basis :bsgn bsgn
+                        :intr-dffr intr-dffr :strt dffr-strt
+                        :orgn orgn)))
+            (declare (type chain-complex rslt))
+            (change-class rslt 'FILTERED-CHAIN-COMPLEX)
+            (setf (slot-value rslt 'flin) flin)
+            (push rslt *flcc-list*)
+               rslt))))
+
+
+;; Function that changes a chain complex chcm to a filtered complex, with filtration
+;; index of a generator defined by the function flin, and origin orgn. 
+#|(DEFUN CHANGE-CHCM-TO-FLCC (chcm &key flin orgn)
+   (declare
+      (type chain-complex chcm)
+      (type chcm-flin flin)
+      (list orgn))
+   (the FILTERED-CHAIN-COMPLEX
+      (progn
+         (change-class chcm 'FILTERED-CHAIN-COMPLEX)
+         ;;(setf orgn (list (orgn chcm) 'then orgn))
+         (let ((already (find orgn *flcc-list* :key #'orgn :test #'equal)))
+            (declare (type (or null FILTERED-CHAIN-COMPLEX) already))
+            (when already
+               (return-from change-chcm-to-flcc already)))
+         (setf (slot-value chcm 'flin) flin)
+         ;;(setf (slot-value chcm 'orgn) orgn)
+         (push chcm *flcc-list*)
+         chcm)))
+|#
+
+
+(DEFMETHOD CHANGE-CHCM-TO-FLCC ((chcm chain-complex) flin flin-orgn)
+   (declare
+      (type chain-complex chcm)
+      (type chcm-flin flin)
+      (list flin-orgn))
+   (the FILTERED-CHAIN-COMPLEX
+      (progn
+         (change-class chcm 'FILTERED-CHAIN-COMPLEX)
+         (setf orgn (append (orgn chcm) (list 'FILTERED-WITH) flin-orgn))
+         (let ((already (find orgn *flcc-list* :key #'orgn :test #'equal)))
+            (declare (type (or null FILTERED-CHAIN-COMPLEX) already))
+            (when already
+               (return-from change-chcm-to-flcc already)))
+         (setf (slot-value chcm 'flin) flin)
+         (setf (slot-value chcm 'orgn) orgn)
+         (push chcm *flcc-list*)
+         chcm)))
+
+
+(DEFMACRO FLIN (&rest rest)
+   (ecase (length rest)
+      (1 `(flin1 ,@rest))
+      (2 `(flin2 ,@rest))
+      (3 `(flin3 ,@rest))))
+
+(DEFUN FLIN3 (object degr gnrt)         
+   (declare
+      (type FILTERED-CHAIN-COMPLEX object)
+      (fixnum degr)
+      (type gnrt gnrt))
+   (the fixnum
+      (with-slots (flin) object
+         (declare (type chcm-flin flin))
+         (funcall flin degr gnrt))))
+
+(DEFUN FLIN2 (object cmbn)
+   (declare
+    (type FILTERED-CHAIN-COMPLEX object)
+    (type cmbn cmbn))
+   (the fixnum
+      (with-slots (flin) object
+         (declare (type chcm-flin flin))
+        (with-cmbn (degr cmbn-list) cmbn
+          (declare
+           (fixnum degr)
+           (list cmbn-list))
+          (labels ((list-max (list)
+                     (declare (type list list))
+                     (let* ((max-int (car list)))
+                        (do ((mark1 list (cdr mark1)))
+                            ((endp mark1))
+                           (setq max-int (max max-int (car mark1))))
+                        max-int)))
+         (if (endp cmbn-list)
+            0
+            (list-max 
+              (mapcar 
+                #'(lambda (term)
+                    (flin3 object degr (gnrt term)))
+                cmbn-list))))))))
+   
+
+
+;; Function that returns the min and max of the filtration index of the elements of the basis
+;; for degree degr
+(DEFUN FLIN-MIN-MAX (fltrcm degr)
+   (declare (type FILTERED-CHAIN-COMPLEX fltrcm)
+            (type fixnum degr))
+   (when (eq (basis fltrcm) :locally-effective)
+    (error "flin-min-max cannot work with a LOCALLY-EFFECTIVE chain complex."))
+   (the list
+     (let* ((basis (basis fltrcm degr)))
+        (declare (list basis))
+        (if (endp basis)
+           (list 0 0)
+           (let* ((min (flin fltrcm degr (first basis)))
+                  (max min))
+              (declare (type fixnum min max))
+              (dolist (gnrt (cdr basis))
+                 (let ((aux (flin fltrcm degr gnrt)))
+                    (declare (type fixnum aux))
+                    (if (< aux min)
+                       (setf min aux)
+                       (if (> aux max)
+                          (setf max aux)))))
+              (list min max))))))
+           
+ 
+   
+;; Function that returns the elements of the basis that have bidegree (p,q).
+(DEFUN BIGRD-BASIS (fltrcm p q)
+   (declare (type FILTERED-CHAIN-COMPLEX fltrcm)
+            (type fixnum p q))
+   (when (eq (basis fltrcm) :locally-effective)
+    (error "Bigrd-Basis cannot work with a LOCALLY-EFFECTIVE chain complex."))
+   (the list
+     (let* ((degr (+ p q))
+            (basis (basis fltrcm degr)))
+        (declare 
+          (type list basis)
+          (fixnum degr))
+        (mapcan 
+          #'(lambda (gnrt)
+              (declare (type gnrt gnrt))
+              (if (= (flin fltrcm degr gnrt) p)
+                 (list gnrt)
+                 nil))
+          basis))))
+
+;; Function that returns the elements of the basis of degree "degr" that have
+;; filtration index <= "fltr-index".
+(DEFUN FLTRD-BASIS (fltrcm degr fltr-index)
+   (declare (type FILTERED-CHAIN-COMPLEX fltrcm)
+            (type fixnum degr fltr-index))
+   (when (eq (basis fltrcm) :locally-effective)
+    (error "Fltrd-Basis cannot work with a LOCALLY-EFFECTIVE chain complex."))
+   (let ((min (first (flin-min-max fltrcm degr))))
+      (declare (type fixnum min))
+      (the list
+        (mapcan
+          #'(lambda (i)
+              (bigrd-basis fltrcm i (- degr i)))
+          (<a-b> min fltr-index)))))
+
+;; Function that returns the elements of the basis with degree "degr",
+;; ordered by the filtration index.
+(DEFUN ORDERED-BASIS (fltrcm degr)
+   (declare
+    (type FILTERED-CHAIN-COMPLEX fltrcm)
+    (fixnum degr))
+   (when (eq (basis fltrcm) :locally-effective)
+    (error "Ordered-Basis cannot work with a LOCALLY-EFFECTIVE chain complex."))
+   (the list
+     (let ((max (second (flin-min-max fltrcm degr))))
+        (declare (type fixnum max))
+        (fltrd-basis fltrcm degr max))))  
+
+;; Matrix of the differential application of degree "degr" of the subcomplex
+;; F_pX, where p=fltr-index and X=fltrcm.
+(defun FLCC-DFFR-MTRX (fltrcm degr fltr-index)
+  (declare
+    (type FILTERED-CHAIN-COMPLEX fltrcm)
+    (fixnum degr fltr-index))
+   (when (eq (basis fltrcm) :locally-effective)
+    (error "flcc-dffr-mtrx cannot work with a LOCALLY-EFFECTIVE chain complex."))
+  (the matrix
+    (let* ((cmpr (cmpr1 fltrcm))
+	     (dffr (dffr fltrcm))
+	     (sbasis (fltrd-basis fltrcm degr fltr-index))
+           (tbasis (ordered-basis fltrcm (1- degr)))
+           ;; If the differential application in the filtered complex respects the filtration,
+           ;; i.e., d(F_pA_n) \in (F_pA)_{n-1}, the target basis is (fltrd-basis fltrcm (1- degr) fltr-index)
+           (srank (length sbasis))
+	     (trank (length tbasis)))
+       (declare
+        (type cmprf cmpr)
+        (type morphism dffr)
+        (fixnum degr)
+        (list sbasis tbasis)
+        (fixnum srank trank))
+       (let ((rslt 
+               #-ACLPC
+                    (make-array (list trank srank)
+				:element-type 'fixnum
+				:initial-element 0)
+               #+ACLPC
+                    (if (or (zerop srank) (zerop trank))
+                       (make-array (list trank srank)
+                          :element-type 'fixnum)
+                       (make-array (list trank srank)
+                          :element-type 'fixnum
+                          :initial-element 0))
+               ))               
+            (declare (type matrix rslt))
+            (do ((j 0 (1+ j))
+	           (mark sbasis (cdr mark)))
+                ((endp mark))
+               (declare
+                (fixnum j)
+                (list mark))
+               (let ((cmbn (gnrt-? dffr degr (car mark))))
+                  (declare (type cmbn cmbn))
+                  (do ((mark1 (cmbn-list cmbn) (cdr mark1)))
+                      ((endp mark1))
+                     (declare (list mark1))
+                     (with--term (cffc gnrt) mark1
+                       (declare 
+                         (fixnum cffc)
+                         (type gnrt gnrt))
+                       (do ((mark2 tbasis (cdr mark2))
+                            (i 0 (1+ i))
+                            (found nil))
+                           ((or (endp mark2) found))
+                          (declare 
+                            (list mark2)
+                            (fixnum i found))
+                          (if (eq :equal (funcall cmpr gnrt (car mark2)))
+                             (progn
+                              (setq found 1)
+                              (setf (aref rslt i j) cffc))))))))
+               rslt))))
+
+
+;; OTHER CLASSES THAT INHERIT FROM FILTERED-CHAIN-COMPLEX
+
+
+(DEFCLASS FILTERED-COALGEBRA (filtered-chain-complex coalgebra)
+    ())
+
+(DEFVAR *FLCLGB-LIST*)
+(SETF *FLCLGB-LIST* +empty-list+)
+(PUSHNEW '*FLCLGB-LIST* *list-list*)
+
+(DEFMETHOD PRINT-OBJECT ((flclgb FILTERED-COALGEBRA) stream)
+(the FILTERED-COALGEBRA
+   (progn
+      (format stream "[K~D FILTERED-COALGEBRA]" (idnm flclgb))
+     flclgb)))
+
+(DEFUN FltrClgb (idnm)
+   (declare (type fixnum idnm))
+   (the (or FILTERED-COALGEBRA null)
+      (find idnm *flclgb-list* :key #'idnm)))
+
+;; Function that builds a filtered coalgebra. 
+(DEFUN BUILD-FltrClgb
+    (&key cmpr basis bsgn intr-dffr dffr-strt intr-cprd cprd-strt flin orgn)
+   (declare
+     (type cmprf cmpr)
+     (type intr-mrph intr-dffr intr-cprd)
+     (type basis basis)
+     (type gnrt bsgn)
+     (type strt dffr-strt cprd-strt)
+     (type chcm-flin flin)
+     (list orgn))
+   (the FILTERED-COALGEBRA
+     (progn
+         (let ((already (find orgn *flclgb-list* :key #'orgn :test #'equal)))
+            (declare (type (or null FILTERED-COALGEBRA) already))
+            (when already
+               (return-from build-FltrClgb already)))
+         (let ((rslt (build-clgb :cmpr cmpr :basis basis :bsgn bsgn
+                        :intr-dffr intr-dffr :dffr-strt dffr-strt
+                       :intr-cprd intr-cprf :cprd-strt cprd-strt
+                        :orgn orgn)))
+            (declare (type coalgebra rslt))
+            (change-class rslt 'FILTERED-COALGEBRA)
+            (setf (slot-value rslt 'flin) flin)
+            (push rslt *flclgb-list*)
+               rslt))))
+
+(defmethod change-chcm-to-flcc ((chcm coalgebra) flin flin-orgn )
+   (declare
+      
+      (type chcm-flin flin)
+      (list flin-orgn))
+   (the FILTERED-COALGEBRA
+      (progn
+         (change-class chcm 'FILTERED-COALGEBRA)
+         (setf orgn (append (orgn chcm) (list 'FILTERED-WITH) flin-orgn))
+         (let ((already (find orgn *flclgb-list* :key #'orgn :test #'equal)))
+            (declare (type (or null FILTERED-COALGEBRA) already))
+            (when already
+               (return-from change-chcm-to-flcc already)))
+         (setf (slot-value chcm 'flin) flin)
+         (setf (slot-value chcm 'orgn) orgn)
+         (push chcm *flCLGB-list*)
+         chcm)))
+
+
+(DEFCLASS FILTERED-ALGEBRA (filtered-chain-complex algebra)
+    ())
+
+(DEFVAR *FLALGB-LIST*)
+(SETF *FLALGB-LIST* +empty-list+)
+(PUSHNEW '*FLALGB-LIST* *list-list*)
+
+(DEFMETHOD PRINT-OBJECT ((flalgb FILTERED-ALGEBRA) stream)
+(the FILTERED-ALGEBRA
+   (progn
+      (format stream "[K~D FILTERED-ALGEBRA]" (idnm flalgb))
+     flalgb)))
+
+(DEFUN FltrAlgb (idnm)
+   (declare (type fixnum idnm))
+   (the (or FILTERED-ALGEBRA null)
+      (find idnm *flalgb-list* :key #'idnm)))
+
+;; Function that builds a filtered algebra. 
+(DEFUN BUILD-FltrAlgb
+    (&key cmpr basis bsgn intr-dffr dffr-strt intr-aprd aprd-strt flin orgn)
+   (declare
+     (type cmprf cmpr)
+     (type intr-mrph intr-dffr intr-aprd)
+     (type basis basis)
+     (type gnrt bsgn)
+     (type strt dffr-strt aprd-strt)
+     (type chcm-flin flin)
+     (list orgn))
+   (the FILTERED-ALGEBRA
+     (progn
+         (let ((already (find orgn *flalgb-list* :key #'orgn :test #'equal)))
+            (declare (type (or null FILTERED-ALGEBRA) already))
+            (when already
+               (return-from build-FltrAlgb already)))
+         (let ((rslt (build-algb :cmpr cmpr :basis basis :bsgn bsgn
+                        :intr-dffr intr-dffr :dffr-strt dffr-strt
+                       :intr-aprd intr-aprf :aprd-strt aprd-strt
+                        :orgn orgn)))
+            (declare (type algebra rslt))
+            (change-class rslt 'FILTERED-ALGEBRA)
+            (setf (slot-value rslt 'flin) flin)
+            (push rslt *flalgb-list*)
+               rslt))))
+
+(defmethod change-chcm-to-flcc ((chcm algebra) flin flin-orgn )
+   (declare
+      
+      (type chcm-flin flin)
+      (list flin-orgn))
+   (the FILTERED-ALGEBRA
+      (progn
+         (change-class chcm 'FILTERED-ALGEBRA)
+         (setf orgn (append (orgn chcm) (list 'FILTERED-WITH) flin-orgn))
+         (let ((already (find orgn *flalgb-list* :key #'orgn :test #'equal)))
+            (declare (type (or null FILTERED-ALGEBRA) already))
+            (when already
+               (return-from change-chcm-to-flcc already)))
+         (setf (slot-value chcm 'flin) flin)
+         (setf (slot-value chcm 'orgn) orgn)
+         (push chcm *flaLGB-list*)
+         chcm)))
+
+
+(DEFCLASS FILTERED-HOPF-ALGEBRA (filtered-chain-complex hopf-algebra)
+    ())
+
+(DEFVAR *FLHOPF-LIST*)
+(SETF *FLHOPF-LIST* +empty-list+)
+(PUSHNEW '*FLHOPF-LIST* *list-list*)
+
+(DEFMETHOD PRINT-OBJECT ((flhopf FILTERED-HOPF-ALGEBRA) stream)
+(the FILTERED-HOPF-ALGEBRA
+   (progn
+      (format stream "[K~D FILTERED-HOPF-ALGEBRA]" (idnm flhopf))
+     flhopf)))
+
+(DEFUN FltrHopf (idnm)
+   (declare (type fixnum idnm))
+   (the (or FILTERED-HOPF-ALGEBRA null)
+      (find idnm *flhopf-list* :key #'idnm)))
+
+(defmethod change-chcm-to-flcc ((chcm hopf-algebra) flin flin-orgn )
+   (declare
+      
+      (type chcm-flin flin)
+      (list flin-orgn))
+   (the FILTERED-hofp-algebra
+      (progn
+         (change-class chcm 'FILTERED-hopf-COALGEBRA)
+        (setf orgn (append (orgn chcm) (list 'FILTERED-WITH) flin-orgn))
+         (let ((already (find orgn *flhopf-list* :key #'orgn :test #'equal)))
+            (declare (type (or null FILTERED-HOPF-COALGEBRA) already))
+            (when already
+               (return-from change-chcm-to-flcc already)))
+         (setf (slot-value chcm 'flin) flin)
+         (setf (slot-value chcm 'orgn) orgn)
+         (push chcm *flhopf-list*)
+         chcm)))
+
+
+(DEFCLASS FILTERED-SIMPLICIAL-SET (FILTERED-CHAIN-COMPLEX simplicial-set )
+    ())
+
+(DEFVAR *FLSMST-LIST*)
+(SETF *FLSMST-LIST* +empty-list+)
+(PUSHNEW '*FLSMST-LIST* *list-list*)
+
+(DEFMETHOD PRINT-OBJECT ((flsmst filtered-simplicial-set) stream)
+ (the filtered-simplicial-set
+   (progn
+      (format stream "[K~D Filtered-Simplicial-Set]" (idnm flsmst))
+      flsmst)))
+
+(DEFUN FltrSmSet (idnm)
+   (declare (type fixnum idnm))
+   (the (or filtered-simplicial-set null)
+      (find idnm *flsmst-list* :key #'idnm)))
+
+
+
+;; Function that builds a filtered simplicial set 
+(DEFUN BUILD-FltrSmSt
+    (&key cmpr basis bspn face face* intr-bndr bndr-strt intr-dgnl dgnl-strt flin orgn)
+   (declare
+     (type cmprf cmpr)
+     (type basis basis)
+     (type gmsm bspn)
+     (type face face)
+     (type (or null face*) face*)
+     (type (or intr-mrph null) intr-bndr intr-dgnl)
+        (type (or strt null) bndr-strt dgnl-strt)
+     (type chcm-flin flin)
+     (list orgn))
+   (the FILTERED-SIMPLICIAL-SET
+     (progn
+         (let ((already (find orgn *flsmst-list* :key #'orgn :test #'equal)))
+            (declare (type (or null FILTERED-SIMPLICIAL-SET) already))
+            (when already
+               (return-from build-FltrSmst already)))
+         (let ((rslt (build-smst :cmpr cmpr :basis basis :bspn bspn
+                       :face face :face* face* :intr-bndr intr-bndr 
+                       :bndr-strt bndr-strt :intr-dgnl intr-dgnl 
+                       :dgnl-strt dgnl :orgn orgn)))
+            (declare (type simplicial-set rslt))
+            (change-class rslt 'FILTERED-SIMPLICIAL-SET)
+            (setf (slot-value rslt 'flin) flin)
+            (push rslt *flsmst-list*)
+               rslt))))
+
+(defmethod change-chcm-to-flcc ((chcm simplicial-set) flin flin-orgn )
+   (declare
+      
+      (type chcm-flin flin)
+      (list flin-orgn))
+   (the FILTERED-SIMPLICIAL-SET
+      (progn
+         (change-class chcm 'FILTERED-SIMPLICIAL-SET)
+         (setf orgn (append (orgn chcm) (list 'FILTERED-WITH) flin-orgn))
+         (let ((already (find orgn *flsmst-list* :key #'orgn :test #'equal)))
+            (declare (type (or null FILTERED-SIMPLICIAL-SET) already))
+            (when already
+               (return-from change-chcm-to-flcc already)))
+         (setf (slot-value chcm 'flin) flin)
+         (setf (slot-value chcm 'orgn) orgn)
+         (push chcm *flsmst-list*)
+         chcm)))
+
+
+(DEFCLASS FILTERED-KAN (FILTERED-CHAIN-COMPLEX KAN )
+    ())
+
+(DEFVAR *FLKAN-LIST*)
+(SETF *FLKAN-LIST* +empty-list+)
+(PUSHNEW '*FLKAN-LIST* *list-list*)
+
+(DEFMETHOD PRINT-OBJECT ((flkan filtered-kan) stream)
+ (the filtered-kan
+   (progn
+      (format stream "[K~D Filtered-Kan-Simplicial-Set]" (idnm flkan))
+      flkan)))
+
+(DEFUN FltrKan (idnm)
+   (declare (type fixnum idnm))
+   (the (or filtered-kan null)
+      (find idnm *flkan-list* :key #'idnm)))
+
+(defmethod change-chcm-to-flcc ((chcm kan) flin flin-orgn )
+   (declare
+      
+      (type chcm-flin flin)
+      (list flin-orgn))
+   (the FILTERED-KAN
+      (progn
+         (change-class chcm 'FILTERED-KAN)
+         (setf orgn (append (orgn chcm) (list 'FILTERED-WITH) flin-orgn))
+         (let ((already (find orgn *flkan-list* :key #'orgn :test #'equal)))
+            (declare (type (or null FILTERED-KAN) already))
+            (when already
+               (return-from change-chcm-to-flcc already)))
+         (setf (slot-value chcm 'flin) flin)
+         (setf (slot-value chcm 'orgn) orgn)
+         (push chcm *flkan-list*)
+         chcm)))
+
+
+(DEFCLASS FILTERED-SIMPLICIAL-GROUP (FILTERED-CHAIN-COMPLEX SIMPLICIAL-GROUP )
+    ())
+
+(DEFCLASS FILTERED-AB-SIMPLICIAL-GROUP (FILTERED-CHAIN-COMPLEX AB-SIMPLICIAL-GROUP )
+    ())
+
+(DEFVAR *FLSMGR-LIST*)
+(SETF *FLSMGR-LIST* +empty-list+)
+(PUSHNEW '*FLSMGR-LIST* *list-list*)
+
+(DEFMETHOD PRINT-OBJECT ((flsmgr filtered-simplicial-group) stream)
+ (the filtered-simplicial-group
+   (progn
+      (format stream "[K~D Filtered-Simplicial-Group]" (idnm flsmgr))
+      flsmgr)))
+
+(DEFMETHOD PRINT-OBJECT ((flsmgr filtered-ab-simplicial-group) stream)
+ (the filtered-simplicial-group
+   (progn
+      (format stream "[K~D Filtered-Abelian-Simplicial-Group]" (idnm flsmgr))
+      flsmgr)))
+
+(DEFUN FltrSmgr (idnm)
+   (declare (type fixnum idnm))
+   (the (or filtered-simplicial-group null)
+      (find idnm *flsmgr-list* :key #'idnm)))
+
+(DEFUN BUILD-FltrSmGr
+    (&key cmpr basis bspn face face* intr-bndr bndr-strt intr-dgnl dgnl-strt 
+      sintr-grml sintr-grin flin orgn)
+   (declare
+     (type cmprf cmpr)
+     (type basis basis)
+     (type gmsm bspn)
+     (type face face)
+     (type (or null face*) face*)
+     (type (or intr-mrph null) intr-bndr intr-dgnl)
+        (type (or strt null) bndr-strt dgnl-strt)
+     (type sintr sintr-grml sintr-grin)
+     (type chcm-flin flin)
+     (list orgn))
+   (the FILTERED-SIMPLICIAL-GROUP
+     (progn
+         (let ((already (find orgn *flsmgr-list* :key #'orgn :test #'equal)))
+            (declare (type (or null FILTERED-SIMPLICIAL-GROUP) already))
+            (when already
+               (return-from build-FltrSmgr already)))
+         (let ((rslt (build-smgr :cmpr cmpr :basis basis :bspn bspn
+                       :face face :face* face* :intr-bndr intr-bndr 
+                       :bndr-strt bndr-strt :intr-dgnl intr-dgnl 
+                       :dgnl-strt dgnl :sintr-grml sintr-grml
+                       :sintr-grin sintr-grin :orgn orgn)))
+            (declare (type simplicial-group rslt))
+            (change-class rslt 'FILTERED-SIMPLICIAL-GROUP)
+            (setf (slot-value rslt 'flin) flin)
+            (push rslt *flsmgr-list*)
+               rslt))))
+
+(DEFMACRO BUILD-FlABSMGR (&rest rest)
+  `(change-class (build-flsmgr ,@rest) 'filtered-ab-simplicial-group))
+
+(defmethod change-chcm-to-flcc ((chcm simplicial-group) flin flin-orgn )
+   (declare
+      
+      (type chcm-flin flin)
+      (list flin-orgn))
+   (the FILTERED-SIMPLICIAL-GROUP
+      (progn
+         (change-class chcm 'FILTERED-SIMPLICIAL-GROUP)
+         (setf orgn (append (orgn chcm) (list 'FILTERED-WITH) flin-orgn))
+         (let ((already (find orgn *flsmgr-list* :key #'orgn :test #'equal)))
+            (declare (type (or null FILTERED-SIMPLICIAL-GROUP) already))
+            (when already
+               (return-from change-chcm-to-flcc already)))
+         (setf (slot-value chcm 'flin) flin)
+         (setf (slot-value chcm 'orgn) orgn)
+         (push chcm *flsmgr-list*)
+         chcm)))
+
+(defmethod change-chcm-to-flcc ((chcm ab-simplicial-group) flin flin-orgn )
+   (declare
+      
+      (type chcm-flin flin)
+      (list flin-orgn))
+   (the FILTERED-AB-SIMPLICIAL-GROUP
+      (progn
+         (change-class chcm 'AB-FILTERED-SIMPLICIAL-GROUP)
+         (setf orgn (append (orgn chcm) (list 'FILTERED-WITH) flin-orgn))
+         (let ((already (find orgn *flabsmgr-list* :key #'orgn :test #'equal)))
+            (declare (type (or null FILTERED-AB-SIMPLICIAL-GROUP) already))
+            (when already
+               (return-from change-chcm-to-flcc already)))
+         (setf (slot-value chcm 'flin) flin)
+         (setf (slot-value chcm 'orgn) orgn)
+         (push chcm *flabsmgr-list*)
+         chcm)))
+
+        
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;    EXAMPLES    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+;; BICOMPLEXES
+
+;; Filtration index function of a Bicomplex (first degree of a generator).
+(setf BCflin 
+      #'(lambda (degr gnrt)
+       (declare 
+         (type fixnum degr)
+         (type gnrt gnrt))
+       (let* ((degr1 (BcGnrt-Degr1 gnrt))
+              (degr2 (BcGnrt-Degr2 gnrt)))
+          (declare (type fixnum degr1 degr2))
+          (if (=  degr (+ degr1 degr2))
+             degr1
+             0))))
+
+#|
+(funcall BCflin 5 (build-bcgnrt 2 3 'a))
+(funcall BCflin 7 (build-bcgnrt 6 1 'c))
+|# 
+
+;; Function that changes the bicomplex bc to a filtered complex, with filtration
+;; index of a generator defined as its first degree. 
+(defun CHANGE-BICM-TO-FLCC (bc)
+   (declare 
+     (type bicomplex bc))
+   (let* ((orgn (orgn bc))
+          (flin BCflin))
+      (declare
+       (type list orgn)
+       (type chcm-flin flin))
+      (the FILTERED-CHAIN-COMPLEX
+        (change-chcm-to-flcc bc flin '(Bicomplex-Flin)))))
+
+#|
+(defun bas (degr1 degr2)
+   (if (and (= degr1 0) (= degr2 1)) (return-from bas '(a)))
+   (if (and (= degr1 1) (= degr2 0)) (return-from bas '(b)))
+   (if (and (= degr1 1) (= degr2 1)) (return-from bas '(c)))
+   (if (and (= degr1 2) (= degr2 0))  (return-from bas '(d)))
+   (return-from bas nil))
+ 
+(defun dif1 (degr1 degr2 gnrt)
+   (if (and (= degr1 1) (= degr2 1) (eql gnrt 'c)) (return-from dif1 (list (cons 2 'a))))
+   (if (and (= degr1 2) (= degr2 0) (eql gnrt 'd)) (return-from dif1 (list (cons 2 'b))))
+   (return-from dif1 nil))
+(defun dif2 (degr1 degr2 gnrt)
+   (if (and (= degr1 1) (= degr2 1) (eql gnrt 'c)) (return-from dif2 (list (cons 1 'b))))
+   (return-from dif2 nil))
+
+(setf bc (Build-Bicm :bcbasis #'bas :dffr1 #'dif1 :dffr2 #'dif2 :cmpr 's-cmpr 
+          :orgn '(BC-test)))
+
+(change-bicm-to-flcc bc)
+(flin bc 1 (build-bcgnrt 0 1 'a))
+(flin bc (cmbn 2 4 (build-bcgnrt 1 1 'c)))
+(flin bc (cmbn 2 4 (build-bcgnrt 1 1 'c) 2 (build-bcgnrt 2 0 'd)))
+(bigrd-basis bc 1 1)
+(bigrd-basis bc 2 0)
+(fltrd-basis bc 2 1)
+(ordered-basis bc 2)
+(flcc-dffr-mtrx bc 2 1)
+(flcc-dffr-mtrx bc 2 2)
+|#
+
+
+;; BARS
+
+(defun abar-bidegree (abar)
+    (declare (type abar abar))
+    (the list
+      (let ((p (1- (length abar)))
+            (q 0))
+        (declare (type fixnum p q))
+        (setf q (apply #'+ (mapcar #'car (rest abar))))
+        (decf q p)
+        (return-from abar-bidegree (list p q)))))
+
+
+(setf abar-flin 
+      #'(lambda (degr abar)
+       (declare (type fixnum degr)
+         (type abar abar))
+       (let* ((abar-bidgr (abar-bidegree abar))
+              (degr1 (first abar-bidgr))
+             (degr2 (second abar-bidgr)))
+         (if (=  degr (+ degr1 degr2))
+           degr1
+          0))))
+
+#|
+(setq kz2 (k-z2-1))
+(setq bar2 (bar kz2))
+
+(change-chcm-to-flcc bar2 abar-flin '(abar-flin))
+
+
+(setf basis7 (basis bar2 7))
+
+(mapcar
+ #'(lambda (gnrt)
+     (flin bar2 7 gnrt))
+ basis7)
+
+(flin bar2 (cmbn 7 (first basis7) (second basis7))) 
+
+(bigrd-basis bar2 2 5)
+(bigrd-basis bar2 3 4)
+(fltrd-basis bar2 7 2)
+(ordered-basis bar2 7)
+(flcc-dffr-mtrx bar2 7 2)
+(flcc-dffr-mtrx bar2 7 3)
+|#
+
+;; COBAR
+
+(defun allp-bidegree (allp)
+    (declare (type allp allp))
+    (the list
+      (let ((p (1- (length allp)))
+            (q 0))
+        (declare (type fixnum p q))
+        (setf q (apply #'+ (mapcar #'car (rest allp))))
+        (incf q p)
+        (return-from allp-bidegree (list (- p) q)))))
+
+(setf cobar-flin 
+      #'(lambda (degr allp)
+       (declare (type fixnum degr)
+         (type allp allp))
+       (let* ((allp-bidgr (allp-bidegree allp))
+              (degr1 (first allp-bidgr))
+             (degr2 (second allp-bidgr)))
+         (if (=  degr (+ degr1 degr2))
+           degr1
+          0))))
+
+;; TENSOR PRODUCTS 
+ 
+(setf tnpr-flin 
+      #'(lambda (degr tnpr)
+       (declare 
+         (type fixnum degr)
+         (type tnpr tnpr))
+       (the fixnum
+          (degr1 tnpr))))
+
+
+;; FIBRATIONS (CARTESIAN PRODUCTS AND TWISTED PRODUCTS)
+
+(setf crpr-flin 
+      #'(lambda (degr crpr)
+          (declare
+           (type fixnum degr)
+           (type crpr crpr))
+          (let* ((b (cadr crpr))
+                 (dgop (car b)))
+             (declare
+              (type iabsm b)
+              (type fixnum dgop))
+             (the fixnum
+               (- degr (length (dgop-int-ext dgop)))))))
+
+#|
+(funcall fbrt-flin 3 '(:crpr (1 . s2) 0 . 3))
+(funcall fbrt-flin 4 '(:crpr (5 . s2) 0 . 3))
+|# 
+ 
+
+;; BICONES
+ 
+(defun bicone-flin (flinb flinc flind)
+   (declare (type chcm-flin flinb flinc flind))
+   (flet ((rslt (degr bicn)
+            (declare 
+              (type bicn bicn)
+              (type degr degr))
+            (let ((bcnx (bcnx bicn)))
+               (declare (type (member :bcnb :bcnc :bcnd) bcnx))
+               (if (eql :bcnb bcnx)
+                  (funcall flinb degr (ibicn bicn))
+                  (if (eql :bcnc bcnx)
+                     (funcall flinc degr (ibicn bicn))
+                     (funcall flind degr (ibicn bicn)))))))
+     (the chcm-flin #'rslt))) 
\ No newline at end of file
diff --git a/examples/anromero/persistent-homology/persistent-homology.cl b/examples/anromero/persistent-homology/persistent-homology.cl
new file mode 100644
index 0000000..cf9a3dd
--- /dev/null
+++ b/examples/anromero/persistent-homology/persistent-homology.cl
@@ -0,0 +1,501 @@
+
+
+
+
+
+(defun eff-prst-hmlg-basis-dvs-quotient (FltrCm r p q)
+   (declare 
+     (type filtered-chain-complex fltrcm)
+     (type fixnum r p q))
+   (the list
+     (let* ((degr (+ p q))
+            (fltr-p-basis (fltrd-basis fltrcm degr p))
+            (p-basis-l (length fltr-p-basis))
+            (num-mtrx (spsq-num-mtrx fltrcm (1+ p) p q))
+            (den-mtrx (spsq-den-mtrx fltrcm r p q)) 
+            (cmbn-list nil)
+            (divs nil))
+        (declare
+         (list fltr-p-basis cmbn-list divs)
+         (type fixnum degr p-basis-l)
+         (type matrix num-mtrx den-mtrx))
+        (progn
+         (if (= 0 (array-total-size num-mtrx))
+            (progn
+             (setq cmbn-list nil)
+             (setq divs nil))
+            (if (= 0 (array-total-size den-mtrx))
+               (progn
+                (setq cmbn-list (gnrt-mtrx-to-list num-mtrx))
+                (setq divs (make-list (length cmbn-list) :initial-element 0)))
+               (let ((quotient-list (mtrx-quotient num-mtrx den-mtrx)))
+                  (declare (list quotient-list))
+                  (setq cmbn-list (first quotient-list)
+                    divs (second quotient-list)))))
+         (list
+          (mapcar 
+            #'(lambda (int-list)
+                (declare (list int-list))
+                (the cmbn
+                  (let* ((cmbn (cmbn degr))
+                         (cmpr (cmpr fltrcm)))
+                     (declare 
+                       (type cmbn cmbn)
+                       (type cmprf cmpr))
+                     (do ((mark1 int-list (cdr mark1))
+                          (mark2 fltr-p-basis (cdr mark2)))
+                         ((or (endp mark1) (endp mark2)))
+                        (declare (type list mark1 mark2))
+                        (if (not (= 0 (car mark1)))
+                           (setq cmbn (2cmbn-add cmpr cmbn 
+                                        (cmbn degr (car mark1) (car mark2))))))
+                     cmbn))) 
+            cmbn-list)
+          divs)))))
+
+;; (setf fltrcm triangle r 1 p 5 q -4)
+;; (setf degr (+ p q))
+;; (setf fltr-p-basis (fltrd-basis fltrcm degr p))
+;; (setf p-basis-l (length fltr-p-basis))
+;; (setf z1-list (fltr-chcm-z-gnrt-list fltrcm r p q))
+;;(eff-prst-hmlg-basis-dvs-2 fltrcm r p q)
+;;(eff-prst-hmlg-basis-dvs-2 fltrcm r 1 -1)
+;;(eff-prst-hmlg-basis-dvs-2 fltrcm r 2 -2)
+;;(eff-prst-hmlg-basis-dvs-2 fltrcm r 3 -3)
+;;(eff-prst-hmlg-basis-dvs-2 fltrcm r 4 -4)
+;;(eff-prst-hmlg-basis-dvs-2 fltrcm r 5 -5)
+
+(defun eff-prst-hmlg-basis-dvs-total (FltrCm r p q)
+   (declare 
+     (type filtered-chain-complex fltrcm)
+     (type fixnum r p q))
+   (the list
+     (let* ((degr (+ p q))
+            (fltr-p-basis (fltrd-basis fltrcm degr p))
+            (p-basis-l (length fltr-p-basis))
+            (fltr-p-1-list (fltr-basis-gnrt-list fltrcm degr (1- p)))
+            (z1-list (fltr-chcm-z-gnrt-list fltrcm (1+ p) p q))
+            (z1-mtrx (gnrt-list-to-mtrx z1-list))
+            (z2-list (fltr-chcm-z-gnrt-list fltrcm (1- r) (1- (+ p r)) (+ 2 (- q r))))
+            (z2-mtrx (gnrt-list-to-mtrx z2-list))
+            (fltr-p-1-mtrx (gnrt-list-to-mtrx fltr-p-1-list))
+            (dffr-mtrx (flcc-dffr-mtrx fltrcm (1+ degr) (1- (+ p r))))
+            (nil-mtrx 
+              #-ACLPC (make-array (list 0 0)
+                        :element-type 'fixnum
+                        :initial-element 0)
+              #+ACLPC (make-array (list 0 0)
+                        :element-type 'fixnum))
+            (dffr-z2-mtrx 
+              (if (or (= 0 (array-total-size z2-mtrx)) (= 0 (array-total-size dffr-mtrx)))
+                 nil-mtrx
+                 (mtrx-prdc dffr-mtrx z2-mtrx)))
+            (bnd-z2-line-n p-basis-l)
+            (bnd-z2-column-n (column-number dffr-z2-mtrx))
+            (bnd-z2-mtrx
+             (if (or (= 0 bnd-z2-line-n) (= 0 bnd-z2-column-n))
+                nil-mtrx
+                (submatrix dffr-z2-mtrx 0 (1- bnd-z2-line-n) 0 (1- bnd-z2-column-n))))
+            (num-mtrx z1-mtrx)
+            (den-mtrx bnd-z2-mtrx) 
+            (cmbn-list nil)
+            (divs nil))
+        (declare
+         (list fltr-p-basis cmbn-list divs)
+         (type fixnum degr p-basis-l)
+         (type matrix num-mtrx den-mtrx))
+        (progn
+         (if (= 0 (array-total-size num-mtrx))
+            (progn
+             (setq cmbn-list nil)
+             (setq divs nil))
+            (if (= 0 (array-total-size den-mtrx))
+               (progn
+                (setq cmbn-list (gnrt-mtrx-to-list num-mtrx))
+                (setq divs (make-list (length cmbn-list) :initial-element 0)))
+               (let ((quotient-list (mtrx-quotient num-mtrx den-mtrx)))
+                  (declare (list quotient-list))
+                  (setq cmbn-list (first quotient-list)
+                    divs (second quotient-list)))))
+         (list
+          (mapcar 
+            #'(lambda (int-list)
+                (declare (list int-list))
+                (the cmbn
+                  (let* ((cmbn (cmbn degr))
+                         (cmpr (cmpr fltrcm)))
+                     (declare 
+                       (type cmbn cmbn)
+                       (type cmprf cmpr))
+                     (do ((mark1 int-list (cdr mark1))
+                          (mark2 fltr-p-basis (cdr mark2)))
+                         ((or (endp mark1) (endp mark2)))
+                        (declare (type list mark1 mark2))
+                        (if (not (= 0 (car mark1)))
+                           (setq cmbn (2cmbn-add cmpr cmbn 
+                                        (cmbn degr (car mark1) (car mark2))))))
+                     cmbn))) 
+            cmbn-list)
+          divs)))))
+
+
+(defun eff-prst-hmlg-basis-dvs-bar (FltrCm r p q)
+   (declare 
+     (type filtered-chain-complex fltrcm)
+     (type fixnum r p q))
+   (the list
+     (let* ((degr (+ p q))
+            (fltr-p-basis (fltrd-basis fltrcm degr p))
+            (p-basis-l (length fltr-p-basis))
+            (num-mtrx (spsq-den-mtrx fltrcm r p q))
+            (den-mtrx (spsq-den-mtrx fltrcm (- r 1) p q)) 
+            (cmbn-list nil)
+            (divs nil))
+        (declare
+         (list fltr-p-basis cmbn-list divs)
+         (type fixnum degr p-basis-l)
+         (type matrix num-mtrx den-mtrx))
+        (progn
+         (if (= 0 (array-total-size num-mtrx))
+            (progn
+             (setq cmbn-list nil)
+             (setq divs nil))
+            (if (= 0 (array-total-size den-mtrx))
+               (progn
+                (setq cmbn-list (gnrt-mtrx-to-list num-mtrx))
+                (setq divs (make-list (length cmbn-list) :initial-element 0)))
+               (let ((quotient-list (mtrx-quotient num-mtrx den-mtrx)))
+                  (declare (list quotient-list))
+                  (setq cmbn-list (first quotient-list)
+                    divs (second quotient-list)))))
+         (list
+          (mapcar 
+            #'(lambda (int-list)
+                (declare (list int-list))
+                (the cmbn
+                  (let* ((cmbn (cmbn degr))
+                         (cmpr (cmpr fltrcm)))
+                     (declare 
+                       (type cmbn cmbn)
+                       (type cmprf cmpr))
+                     (do ((mark1 int-list (cdr mark1))
+                          (mark2 fltr-p-basis (cdr mark2)))
+                         ((or (endp mark1) (endp mark2)))
+                        (declare (type list mark1 mark2))
+                        (if (not (= 0 (car mark1)))
+                           (setq cmbn (2cmbn-add cmpr cmbn 
+                                        (cmbn degr (car mark1) (car mark2))))))
+                     cmbn))) 
+            cmbn-list)
+          divs)))))
+
+
+
+
+
+(defun eff-prst-hmlg-gnrts-total (FltrCm r p q)
+   (declare 
+     (type filtered-chain-complex fltrcm)
+     (type fixnum r p q))
+   (let* ((basis-dvs (eff-prst-hmlg-basis-dvs-total fltrcm r p q))
+         (basis (first basis-dvs))
+         (dvs (second basis-dvs))
+         (rslt nil))
+      (declare (type list basis-dvs basis dvs rslt))
+      (do ((mark1 basis (cdr mark1))
+           (mark2 dvs (cdr mark2)))
+          ((endp mark1))
+         (if (not (eql 1 (car mark2)))
+            (setf rslt (append rslt (list (car mark1))))))
+     rslt))
+
+(defun eff-prst-hmlg-gnrts-quotient (FltrCm r p q)
+   (declare 
+     (type filtered-chain-complex fltrcm)
+     (type fixnum r p q))
+   (let* ((basis-dvs (eff-prst-hmlg-basis-dvs-quotient fltrcm r p q))
+         (basis (first basis-dvs))
+         (dvs (second basis-dvs))
+         (rslt nil))
+      (declare (type list basis-dvs basis dvs rslt))
+      (do ((mark1 basis (cdr mark1))
+           (mark2 dvs (cdr mark2)))
+          ((endp mark1))
+         (if (not (eql 1 (car mark2)))
+            (setf rslt (append rslt (list (car mark1))))))
+     rslt))
+
+(defun eff-prst-hmlg-gnrts-bar (FltrCm r p q)
+   (declare 
+     (type filtered-chain-complex fltrcm)
+     (type fixnum r p q))
+   (let* ((basis-dvs (eff-prst-hmlg-basis-dvs-bar fltrcm r p q))
+         (basis (first basis-dvs))
+         (dvs (second basis-dvs))
+         (rslt nil))
+      (declare (type list basis-dvs basis dvs rslt))
+      (do ((mark1 basis (cdr mark1))
+           (mark2 dvs (cdr mark2)))
+          ((endp mark1))
+         (if (not (eql 1 (car mark2)))
+            (setf rslt (append rslt (list (car mark1))))))
+     rslt))
+
+
+(defun eff-prst-hmlg-group-total (fltrcm r p q)
+   (declare 
+     (type filtered-chain-complex fltrcm)
+     (type fixnum r p q))  
+   (let* ((basis-dvs (eff-prst-hmlg-basis-dvs-total fltrcm r p q))
+          (cmbns (first basis-dvs))
+          (divs (second basis-dvs)))
+      (declare (list basis-dvs cmbns divs))
+      
+      (dolist (item divs)
+         (declare (type fixnum item))
+         (if (not (eql 1 item))
+            (progn
+             (format t "~2%Component Z")
+             (unless (zerop item) 
+                (format t "/~DZ" item))
+             )))
+     (terpri)))
+
+(defun eff-prst-hmlg-group-quotient (fltrcm r p q)
+   (declare 
+     (type filtered-chain-complex fltrcm)
+     (type fixnum r p q))  
+   (let* ((basis-dvs (eff-prst-hmlg-basis-dvs-quotient fltrcm r p q))
+          (cmbns (first basis-dvs))
+          (divs (second basis-dvs)))
+      (declare (list basis-dvs cmbns divs))
+      
+      (dolist (item divs)
+         (declare (type fixnum item))
+         (if (not (eql 1 item))
+            (progn
+             (format t "~2%Component Z")
+             (unless (zerop item) 
+                (format t "/~DZ" item))
+             )))
+     (terpri)))
+
+(defun eff-prst-hmlg-group-bar (fltrcm r p q)
+   (declare 
+     (type filtered-chain-complex fltrcm)
+     (type fixnum r p q))  
+   (let* ((basis-dvs (eff-prst-hmlg-basis-dvs-bar fltrcm r p q))
+          (cmbns (first basis-dvs))
+          (divs (second basis-dvs)))
+      (declare (list basis-dvs cmbns divs))
+      
+      (dolist (item divs)
+         (declare (type fixnum item))
+         (if (not (eql 1 item))
+            (progn
+             (format t "~2%Component Z")
+             (unless (zerop item) 
+                (format t "/~DZ" item))
+             )))
+     (terpri)))
+
+(defun prst-hmlg-group-total-rpq (fltrcm r p q)
+   (declare
+    (type filtered-chain-complex fltrcm)
+    (type fixnum r p q))
+   (let* ((hmtp-eq (efhm fltrcm))
+          (eff-chcm (rbcc hmtp-eq))
+          (degr (+ p q)))
+      (declare
+       (type homotopy-equivalence hmtp-eq)
+       (type chain-complex eff-chcm)
+       (type fixnum degr))
+      (progn
+       (if (not (typep eff-chcm 'filtered-chain-complex))
+          (translate-filtration hmtp-eq))
+        (eff-prst-hmlg-group-total eff-chcm r p q))))
+
+(defun prst-hmlg-group-quotient-rpq (fltrcm r p q)
+   (declare
+    (type filtered-chain-complex fltrcm)
+    (type fixnum r p q))
+   (let* ((hmtp-eq (efhm fltrcm))
+          (eff-chcm (rbcc hmtp-eq))
+          (degr (+ p q)))
+      (declare
+       (type homotopy-equivalence hmtp-eq)
+       (type chain-complex eff-chcm)
+       (type fixnum degr))
+      (progn
+       (if (not (typep eff-chcm 'filtered-chain-complex))
+          (translate-filtration hmtp-eq))
+        (eff-prst-hmlg-group-quotient eff-chcm r p q))))
+
+(defun prst-hmlg-group-bar-rpq (fltrcm r p q)
+   (declare
+    (type filtered-chain-complex fltrcm)
+    (type fixnum r p q))
+   (let* ((hmtp-eq (efhm fltrcm))
+          (eff-chcm (rbcc hmtp-eq))
+          (degr (+ p q)))
+      (declare
+       (type homotopy-equivalence hmtp-eq)
+       (type chain-complex eff-chcm)
+       (type fixnum degr))
+      (progn
+       (if (not (typep eff-chcm 'filtered-chain-complex))
+          (translate-filtration hmtp-eq))
+        (eff-prst-hmlg-group-bar eff-chcm r p q))))
+
+(defun prst-hmlg-gnrts-total-rpq (FltrCm r p q)
+   (declare
+    (type filtered-chain-complex fltrcm)
+    (type fixnum r p q))
+   (let* ((hmtp-eq (efhm fltrcm))
+          (eff-chcm (rbcc hmtp-eq))
+          (degr (+ p q)))
+      (declare
+       (type homotopy-equivalence hmtp-eq)
+       (type chain-complex eff-chcm)
+       (type fixnum degr))
+      (progn
+       (if (not (typep eff-chcm 'filtered-chain-complex))
+          (translate-filtration hmtp-eq))
+        (eff-prst-hmlg-gnrts-total eff-chcm r p q))))
+
+(defun prst-hmlg-gnrts-quotient-rpq (FltrCm r p q)
+   (declare
+    (type filtered-chain-complex fltrcm)
+    (type fixnum r p q))
+   (let* ((hmtp-eq (efhm fltrcm))
+          (eff-chcm (rbcc hmtp-eq))
+          (degr (+ p q)))
+      (declare
+       (type homotopy-equivalence hmtp-eq)
+       (type chain-complex eff-chcm)
+       (type fixnum degr))
+      (progn
+       (if (not (typep eff-chcm 'filtered-chain-complex))
+          (translate-filtration hmtp-eq))
+        (eff-prst-hmlg-gnrts-quotient eff-chcm r p q))))
+
+(defun prst-hmlg-gnrts-bar-rpq (FltrCm r p q)
+   (declare
+    (type filtered-chain-complex fltrcm)
+    (type fixnum r p q))
+   (let* ((hmtp-eq (efhm fltrcm))
+          (eff-chcm (rbcc hmtp-eq))
+          (degr (+ p q)))
+      (declare
+       (type homotopy-equivalence hmtp-eq)
+       (type chain-complex eff-chcm)
+       (type fixnum degr))
+      (progn
+       (if (not (typep eff-chcm 'filtered-chain-complex))
+          (translate-filtration hmtp-eq))
+        (eff-prst-hmlg-gnrts-bar eff-chcm r p q))))
+
+ (defun total-prst-hmlg-gnrts (fltrcm i j n)
+   (prst-hmlg-gnrts-total-rpq fltrcm (1+ (- j i)) i (- n i) ))
+
+(defun total-prst-hmlg-group (fltrcm i j n)
+  (format t "Persistent Homology H^{~D,~D}_~D" i j n)
+  (prst-hmlg-group-total-rpq fltrcm (1+ (- j i)) i (- n i) ))
+
+ (defun prst-hmlg-gnrts-quotient (fltrcm i j n)
+   (prst-hmlg-gnrts-quotient-rpq fltrcm (1+ (- j i)) i (- n i) ))
+
+(defun prst-hmlg-group-quotient (fltrcm i j n)
+  (format t "Persistent Homology H^{~D,~D}_~D" i j n)
+  (prst-hmlg-group-quotient-rpq fltrcm (1+ (- j i)) i (- n i) ))
+
+
+ (defun prst-hmlg-gnrts (fltrcm i j n)
+   (prst-hmlg-gnrts-bar-rpq fltrcm (1+ (- j i)) i (- n i) ))
+
+(defun prst-hmlg-group (fltrcm i j n)
+  (format t "Persistent Homology B^{~D,~D}_~D" i j n)
+  (prst-hmlg-group-bar-rpq fltrcm (1+ (- j i)) i (- n i) ))
+
+
+
+
+
+
+;; EXAMPLE: TRIANGLE
+
+
+(defun contains-element (list element)
+  (let ((rslt nil))
+    (dotimes (i (length list))
+      (if (eq element (nth i list))
+          (setf rslt 't)))
+    rslt))
+
+
+
+(setf triangle
+  (build-finite-ss
+   '(a b c
+     1 ab (b a) ac (c a) bc (c b)
+       2 abc (bc ac ab) )))
+
+
+
+(setf triangle-flin 
+      #'(lambda (degr gnrt)
+       (declare 
+         (type fixnum degr)
+        (type gnrt gnrt))
+          (let (
+                (l1 (list 'a))
+                (l2 (list 'b))
+                (l3 (list 'c))
+                (l4 (list 'ab))
+                (l5 (list 'bc))
+                (l6 (list 'ac))
+                (l7 (list 'abc))
+                (rslt -1))
+            
+              (if (contains-element l1 gnrt)  (setf rslt 1)
+                (if (contains-element l2 gnrt)  (setf rslt 2)
+                  (if (contains-element l3 gnrt)  (setf rslt 3)
+                    (if (contains-element l4 gnrt)  (setf rslt 4)
+                      (if (contains-element l5 gnrt)  (setf rslt 5)
+                        (if (contains-element l6 gnrt)  (setf rslt 6)
+                           (if (contains-element l7 gnrt)  (setf rslt 7)
+
+
+                        )))))))
+            rslt)))
+
+
+(setf triangle (change-chcm-to-flcc triangle triangle-flin 'triangle-flin))
+
+
+(dotimes (p 8)
+    (print (spsq-group triangle 1 p (- 0 p)))
+    (print (spsq-group triangle 1 p (- 1 p)))
+    (print (spsq-group triangle 1 p (- 2 p)))
+    (print (spsq-group triangle 1 p (- 3 p))))
+
+
+(dotimes (p 8)
+    (print (spsq-group triangle 2 p (- 0 p)))
+    (print (spsq-group triangle 2 p (- 1 p)))
+    (print (spsq-group triangle 2 p (- 2 p)))
+  (print (spsq-group triangle 2 p (- 3 p))))
+
+
+(dotimes (n 3)
+  (dotimes (p 8)
+    (print (prst-hmlg-group triangle p p n))
+    (print (prst-hmlg-group triangle p (1+ p) n))
+    (print (prst-hmlg-group triangle p (+ 2 p) n))
+    (print (prst-hmlg-group triangle p (+ 3 p) n))
+    (print (prst-hmlg-group triangle p (+ 4 p) n))
+))
+
+
+
+
diff --git a/examples/anromero/persistent-homology/spectral-sequences.lsp b/examples/anromero/persistent-homology/spectral-sequences.lsp
new file mode 100644
index 0000000..4b55947
--- /dev/null
+++ b/examples/anromero/persistent-homology/spectral-sequences.lsp
@@ -0,0 +1,1359 @@
+;; SPECTRAL-SEQUENCES   SPECTRAL-SEQUENCES   SPECTRAL-SEQUENCES   SPECTRAL-SEQUENCES
+;; SPECTRAL-SEQUENCES   SPECTRAL-SEQUENCES   SPECTRAL-SEQUENCES   SPECTRAL-SEQUENCES
+;; SPECTRAL-SEQUENCES   SPECTRAL-SEQUENCES   SPECTRAL-SEQUENCES   SPECTRAL-SEQUENCES
+
+
+(IN-PACKAGE "COMMON-LISP-USER")
+
+(provide "spectral-sequences")
+
+
+
+;; Auxiliary functions to deal with matrices
+
+(defun submatrix (mtrx first-line last-line first-col last-col)
+   (declare (type matrix mtrx)
+            (type fixnum first-line last-line first-col last-col))
+  (the matrix
+    (let ((line-n (line-number mtrx))
+	  (column-n (column-number mtrx)))
+      (declare (type fixnum line-n column-n))
+      (assert (<= first-line last-line (1- line-n)))
+      (assert (<= first-col last-col (1- column-n)))
+      (let* ((line-num (+ (- last-line first-line) 1))
+             (column-num (+ (- last-col first-col) 1))
+             (rslt (make-array (list line-num column-num)
+			      :element-type 'fixnum)))
+         (declare (type fixnum line-num column-num) 
+                  (type matrix rslt))
+         (dotimes (il line-num)
+            (declare (type fixnum il))
+            (dotimes (ic column-num)
+               (declare (type fixnum ic))
+               (setf (aref rslt il ic)
+                     (aref mtrx (+ il first-line) (+ ic first-col)))))
+         rslt))))
+
+#|
+(setf m (random-matrix 4 6 10))
+(submatrix m 1 3 2 4)
+|#
+
+
+(Defun column-j (mtrx j)
+   (declare (type matrix mtrx)
+            (type fixnum j))
+   (assert (< j (column-number mtrx)))
+   (the list
+     (let ((line-n (line-number mtrx)))
+        (declare (type fixnum line-n))
+        (mapcar
+         #'(lambda (i)
+             (declare (type fixnum i))
+             (aref mtrx i j))
+         (<a-b> 0 (1- line-n))))))
+
+#|
+(setf m (random-matrix 4 6 10))
+(column-j m 2)
+|#
+
+;; Function that concatenates two matrices (if their line number is different, the 
+;; needed zeros are added. 
+(defun mtrx-conc (mtrx1 mtrx2)
+   (declare (type matrix mtrx1 mtrx2))
+   (the matrix
+     (let* ((line-n-1 (line-number mtrx1))
+            (column-n-1 (column-number mtrx1))
+            (line-n-2 (line-number mtrx2))
+            (column-n-2 (column-number mtrx2))
+            (line-n (max line-n-1 line-n-2))
+            (column-n (+ column-n-1 column-n-2)))
+        (declare (type fixnum line-n-1 column-n-1 line-n-2
+                   column-n-2 line-n column-n))
+        (let ((rslt 
+                #-ACLPC
+                (make-array (list line-n column-n)
+                  :element-type 'fixnum
+                  :initial-element 0)
+                #+ACLPC
+                (if (or (zerop line-n) (zerop column-n))
+                   (make-array (list line-n column-n)
+                     :element-type 'fixnum)
+                   (make-array (list line-n column-n)
+                     :element-type 'fixnum
+                     :initial-element 0))))
+           (declare (type matrix rslt))
+           (do ((j 0 (1+ j)))
+               ((>= j column-n-1))
+              (declare (type fixnum j))
+              (do ((i 0 (1+ i)))
+                   ((>= i line-n-1))
+                 (declare (type fixnum i))
+                 (Setf (aref rslt i j) (aref mtrx1 i j))))
+           (do ((j 0 (1+ j)))
+                ((>= j column-n-2))
+              (declare (type fixnum j))
+              (do ((i 0 (1+ i)))
+                   ((>= i line-n-2))
+                 (declare (type fixnum i))
+                 (Setf (aref rslt i (+ column-n-1 j)) (aref mtrx2 i j))))
+            rslt))))
+
+#|
+(setf m1 (random-matrix 3 4 10))
+(setf m2 (random-matrix 4 2 10))
+(mtrx-conc m1 m2)
+(mtrx-conc m2 m1)
+|#
+
+ 
+;; Functions related with submodules and matrices
+
+;; Function that returns a list of generators of the kernel of a matrix.
+;; Each generator is a list of integers which represent its coordinates
+;; in the initial basis.
+(defun kernel (mtrx)
+   (declare (type matrix mtrx))
+   (the list
+     (let* ((smith-list (smith mtrx))
+            (m (third smith-list))
+            (q (fourth smith-list))
+            (min (min (line-number mtrx) (column-number mtrx)))
+            (rslt nil))
+        (declare 
+          (type list smith-list rslt)
+          (type matrix m q)
+          (type fixnum min))
+        (progn
+         (do ((j (1- (column-number mtrx)) (1- j)))
+             ((< j min))
+            (declare (type fixnum j))
+            (setq rslt (nconc (list (column-j q j)) rslt)))
+         (do ((i (1- min) (1- i)))
+             ((or (< i 0) (not (eql  0 (aref m i i)))))
+            (declare (type fixnum i))
+            (setq rslt (nconc (list (column-j q i)) rslt)))
+         rslt))))
+
+#|
+(setf m (random-matrix 3 4 10))
+(kernel m)
+|#
+
+
+;; Returns a matrix which has as columns the elements of the list.
+;; (Each element in the list is a list of integers).
+(defun Gnrt-List-to-Mtrx (gnrt-list)
+   (declare (type list gnrt-list))
+   (the matrix
+     (let* ((column-n (length gnrt-list))
+            (line-n (length (car gnrt-list)))
+            (rslt 
+              #-ACLPC
+              (make-array (list line-n column-n)
+                :element-type 'fixnum
+                :initial-element 0)
+              #+ACLPC
+              (if (or (zerop line-n) (zerop column-n))
+                 (make-array (list line-n column-n)
+                   :element-type 'fixnum)
+                 (make-array (list line-n column-n)
+                   :element-type 'fixnum
+                   :initial-element 0))))
+        (declare 
+          (type fixnum column-n line-n)
+          (type matrix rslt))
+        (do ((j 0 (1+ j))
+             (mark2 gnrt-list (cdr mark2)))
+            ((endp mark2))
+           (declare
+            (type fixnum j)
+            (list mark2)) 
+           (if (eql line-n (length (car mark2)))
+              (do ((i 0 (1+ i))
+                   (mark1 (car mark2) (cdr mark1)))
+                  ((endp mark1))
+                 (declare 
+                   (type fixnum i)
+                   (list mark1))
+                 (setf (aref rslt i j) (car mark1)))))
+        rslt)))
+
+#|
+(setq gnrt-list (list '(2 4 6 8) '(0 1 0 0) '(0 3 3 3)))
+(Gnrt-List-to-Mtrx gnrt-list)
+|# 
+
+;; Returns the list of columns of the matrix mtrx.
+(defun gnrt-mtrx-to-list (mtrx)
+   (declare (type matrix mtrx))
+   (the list
+     (let* ((column-n (column-number mtrx)))
+        (declare (type fixnum column-n))
+        (mapcar
+         #'(lambda (j)
+             (declare (type fixnum j))
+             (column-j mtrx j))
+       (<a-b> 0 (1- column-n))))))
+
+#|
+(setf m (random-matrix 3 4 10))
+(gnrt-mtrx-to-list m)
+|#
+
+;; Returns the representation basis-divisors of a quotient of submodules B/C
+;; which are the images of the matrices mtrx1 and mtrx2, where basis=list
+;; of combinations (c_1...c_m) that forms a basis for B and divisors=list of
+;; integers (n_1....n_m) such that (n_1*c_1,...,n_m*c_m) forms a basis for C. 
+(defun mtrx-quotient (mtrx1 mtrx2)
+   (declare (type matrix mtrx1 mtrx2))
+   (the list
+     (let* ((smith-list-1 (smith mtrx1))
+            (p1 (first smith-list-1))
+            (p1-1 (second smith-list-1))
+            (d1 (third smith-list-1))
+            (p1-1Xmtrx2 (mtrx-prdc p1-1 mtrx2))
+            (p1Xd1 (copy-mtrx p1))
+            (d1-1Xp1-1Xmtrx2 (copy-mtrx p1-1Xmtrx2)))
+        (declare
+         (list smith-list-1)
+         (type matrix p1 p1-1 s1 p1-1Xmtrx2 p1Xd1 d1-1Xp1))
+        (progn
+         (let* ((line-n-1 (line-number p1))
+                (column-n-1 (column-number p1)))
+            (declare (type fixnum line-n-1 column-n-1))
+            (dotimes (ic column-n-1)
+               (declare (type fixnum ic))
+               (if (and (< ic (line-number d1)) (< ic (column-number d1)))
+                  (let ((d (aref d1 ic ic)))
+                     (declare (type fixnum d))
+                     (dotimes (il line-n-1)
+                        (declare (type fixnum il))
+                        (if (and (not (eql 1 d)) (not (eql 0 d)))
+                           (setf (aref p1Xd1 il ic) (* d (aref p1Xd1 il ic)))))))))
+         (let* ((line-n-2 (line-number p1-1Xmtrx2))
+                (column-n-2 (column-number p1-1Xmtrx2)))
+            (declare (type fixnum line-n-2 column-n-2))    
+            (dotimes (il line-n-2)
+               (declare (type fixnum il))
+               (if (and (< il (line-number d1)) (< il (column-number d1)))
+                  (let ((d (aref d1 il il)))
+                     (if (and (not (eql 1 d)) (not (eql 0 d)))
+                        (dotimes (ic column-n-2)
+                           (declare (type fixnum ic))
+                           (setf (aref d1-1Xp1-1Xmtrx2 il ic) 
+                                 (floor (aref d1-1Xp1-1Xmtrx2 il ic) d))))))))
+         (let* ((smith-list-2 (smith d1-1Xp1-1Xmtrx2))
+                (p2 (first smith-list-2))
+                (basis-mtrx (mtrx-prdc p1Xd1 p2))
+                (div-mtrx (third smith-list-2))
+                (cmbns nil)
+                (divs nil))
+            (declare 
+              (list smith-list-2 cmbns divs)
+              (type matrix p2 basis-mtrx div-mtrx))
+            (do ((i 0 (1+ i)))
+                ((or (>= i (line-number d1)) (>= i (column-number d1))
+                     (eql 0 (aref d1 i i))))
+               (declare (type fixnum i))
+               (progn
+                (setq cmbns (nconc cmbns (list (column-j basis-mtrx i))))
+                (if (and (< i (line-number div-mtrx)) (< i (column-number div-mtrx))) 
+                   (setq divs (nconc divs (list (aref div-mtrx i i))))
+                   (setq divs (nconc divs (list 0))))))
+            (list cmbns divs))))))
+
+#|
+(setf m1 (gnrt-list-to-mtrx '((1 1 1 1) (0 2 0 3) (1 0 0 0))))
+(setf m2 (gnrt-list-to-mtrx '((2 3 1 4) (0 1 1 1))))
+(mtrx-quotient m1 m2)
+|#
+
+
+
+;; SPECIFIC FUNCTIONS FOR THE COMPUTATION OF SPECTRAL SEQUENCES 
+;; OF EFFECTIVE FILTERED COMPLEXES.
+
+
+;; GROUPS
+
+;; Returns the matrix that defines Z^r_{p,q} (a submatrix of the 
+;; differential matrix M, such that the elements of Z^r_{p,q} are those that
+;; when we apply M to them we obtain zero, i.e. Z^r_{p,q}=Ker M). Only can be applied
+;; to a finitely generated complex. 
+(defun FLTR-CHCM-Z-MTRX (fltrcm r p q)
+  (declare
+    (type filtered-chain-complex fltrcm)
+    (type fixnum r p q))
+  (the matrix
+    (let* ((cmpr (cmpr1 fltrcm))
+	     (dffr (dffr fltrcm))
+	     (degr (+ p q))
+           (sbasis (fltrd-basis fltrcm degr p))
+           (tbasis 
+             (mapcan 
+              #'(lambda (i)
+                  (declare (type fixnum i))
+                  (bigrd-basis fltrcm i (- (1- degr) i)))
+              (<a-b> (1+ (- p r)) p)))) ;; We suppose that the differential
+                                        ;; respects the filtration, i.e., 
+                                        ;; d(F_pX) \in F_p(dX). If not, we must
+                                        ;; consider (<a-b> (1+ (-p r)) t(degr),
+                                        ;; where t(degr)=max{flin(x), x \in X_degr}.
+       (declare
+        (type cmprf cmpr)
+        (type morphism dffr)
+        (type fixnum degr)
+        (list sbasis tbasis))
+      (let ((srank (length sbasis))
+	      (trank (length tbasis)))
+         (declare (type fixnum srank trank))
+         (let ((rslt 
+               #-ACLPC
+                    (make-array (list trank srank)
+				:element-type 'fixnum
+				:initial-element 0)
+               #+ACLPC
+                    (if (or (zerop srank) (zerop trank))
+                       (make-array (list trank srank)
+                          :element-type 'fixnum)
+                       (make-array (list trank srank)
+                          :element-type 'fixnum
+                          :initial-element 0))))               
+            (declare (type matrix rslt))
+            (do ((j 0 (1+ j))
+	           (mark sbasis (cdr mark)))
+                ((endp mark))
+               (declare
+                (type fixnum j)
+                (list mark))
+               (let ((cmbn (gnrt-? dffr degr (car mark))))
+                  (declare (type cmbn cmbn))
+                  (do ((mark1 (cmbn-list cmbn) (cdr mark1)))
+                      ((endp mark1))
+                     (declare (list mark1))
+                     (with--term (cffc gnrt) mark1
+                       (declare 
+                         (type fixnum cffc)
+                         (type gnrt gnrt))
+                       (do ((mark2 tbasis (cdr mark2))
+                            (i 0 (1+ i))
+                            (found nil))
+                           ((or (endp mark2) found))
+                          (declare 
+                            (list mark2)
+                            (type fixnum i found))
+                          (if (eq :equal (funcall cmpr gnrt (car mark2)))
+                             (progn
+                              (setq found 1)
+                              (setf (aref rslt i j) cffc))))))))
+               rslt)))))
+
+#|
+(cat-init)
+(setq kz2 (k-z2-1))
+(setq fcc (bar kz2))
+(Change-Chcm-TO-Flcc fcc abar-flin `(abar-flin))
+(FLTR-CHCM-Z-MTRX fcc 2 3 2)
+(FLTR-CHCM-Z-MTRX fcc 1 2 4)
+|#
+ 
+
+;; Returns a list of generators (list of coordinates) of Z^r_{p,q}
+;; (only for finitely generated complexes)
+(defun Fltr-Chcm-Z-Gnrt-List (FltrCm r p q)
+   (declare (type filtered-chain-complex fltrcm)
+     (type fixnum r p q))
+   (the list
+         (let* ((degr (+ p q))
+                (all-basis-gnrt-list (fltr-basis-gnrt-list fltrcm degr p)))
+            (declare
+             (type fixnum degr)
+             (list all-basis-gnrt-list))
+            (if (= 0 r)
+               all-basis-gnrt-list
+               (let* ((mat (FLTR-CHCM-Z-MTRX fltrcm r p q))
+                   (line-n (line-number mat))
+                   (column-n (column-number mat)))
+                  (declare 
+                    (type matrix mat)
+                    (type fixnum line-n column-n))
+                  (if (= 0 column-n) nil
+                     (if (= 0 line-n)
+                     all-basis-gnrt-list
+                     (kernel mat))))))))
+#|
+(Fltr-Chcm-Z-Gnrt-List fcc 2 3 2)
+(Fltr-Chcm-Z-Gnrt-List fcc 1 2 4)
+|# 
+
+;; Returns a list of lists with the coordinates of the elements of
+;; the basis of F_pX_n (with p=fltr-index, n=degr), that are lists with
+;; the form (0...0 i 0...0) (only for finitely generated complexes)
+(defun fltr-basis-gnrt-list (FltrCm degr fltr-index)
+   (declare 
+     (type filtered-chain-complex fltrcm)
+     (type fixnum degr fltr-index))
+   (the list
+     (let* ((all-basis (fltrd-basis fltrcm degr fltr-index))
+            (basis-l (length all-basis))
+            (rslt 
+              (the list
+                (mapcar
+                 #'(lambda (i)
+                     (nconc (make-list (1- i) :initial-element 0) 
+                       (list 1) (make-list (- basis-l i) :initial-element 0)))
+                 (<a-b> 1 basis-l)))))
+        rslt)))
+
+#|
+(fltr-basis-gnrt-list fcc 6 2)
+|#
+ 
+
+;; Returns the matrix of the generators of the numerator in E^r_{p,q}
+;; (Only for finitely generated complexes)
+(defun spsq-num-mtrx (FltrCm r p q)
+  (the matrix
+    (let* ((degr (+ p q))
+           (fltr-p-basis (fltrd-basis fltrcm degr p))
+           (p-basis-l (length fltr-p-basis))
+           (z1-list (fltr-chcm-z-gnrt-list fltrcm r p q))
+           (fltr-p-1-list (fltr-basis-gnrt-list fltrcm degr (1- p)))
+           (z1-mtrx (gnrt-list-to-mtrx z1-list))
+           (fltr-p-1-mtrx (gnrt-list-to-mtrx fltr-p-1-list))
+           (num1-mtrx (mtrx-conc z1-mtrx fltr-p-1-mtrx))
+           (num1-line-n (line-number num1-mtrx)))
+       (declare
+        (type fixnum degr num1-line-n)
+        (type list fltr-p-basis p-basis-l z1-list fltr-p-1-list)
+        (type matrix z1-mtrx fltr-p-1-mtrx num1-mtrx))
+       (if (eql num1-line-n p-basis-l)
+          num1-mtrx 
+          (let* ((num-line-n p-basis-l)
+                 (num-column-n (column-number num1-mtrx))
+                 (rslt  
+                   #-ACLPC (make-array (list num-line-n num-column-n)
+                             :element-type 'fixnum
+                             :initial-element 0)
+                   #+ACLPC
+                   (if (or (zerop num-line-n) (zerop num-column-n))
+                      (make-array (list num-line-n num-column-n)
+                        :element-type 'fixnum)
+                      (make-array (list num-line-n num-column-n)
+                        :element-type 'fixnum
+                        :initial-element 0))))
+             (declare
+              (type fixnum num-lin-n num-column-n)
+              (type matrix rslt))
+             (do ((j 0 (1+ j)))
+                 ((>= j num-column-n))
+                (declare (type fixnum j))
+                (do ((i 0 (1+ i)))
+                    ((>= i num1-line-n))
+                   (declare (type fixnum i))
+                   (Setf (aref rslt i j) (aref num1-mtrx i j))))
+             rslt)))))
+
+#|
+(spsq-num-mtrx fcc 2 3 2)
+(spsq-num-mtrx fcc 1 2 4)
+|# 
+
+;; Returns the matrix of the generators of the denominator in E^r_{p,q}
+;; (Only for finitely generated complexes) 
+(defun spsq-den-mtrx (FltrCm r p q)
+   (the matrix
+     (let* ((degr (+ p q))
+            (fltr-p-basis (fltrd-basis fltrcm degr p))
+            (p-basis-l (length fltr-p-basis))
+            (fltr-p-1-list (fltr-basis-gnrt-list fltrcm degr (1- p)))
+            (z2-list (fltr-chcm-z-gnrt-list fltrcm (1- r) (1- (+ p r)) (+ 2 (- q r))))
+            (z2-mtrx (gnrt-list-to-mtrx z2-list))
+            (fltr-p-1-mtrx (gnrt-list-to-mtrx fltr-p-1-list))
+            (dffr-mtrx (flcc-dffr-mtrx fltrcm (1+ degr) (1- (+ p r))))
+            (nil-mtrx 
+              #-ACLPC (make-array (list 0 0)
+                        :element-type 'fixnum
+                        :initial-element 0)
+              #+ACLPC (make-array (list 0 0)
+                        :element-type 'fixnum))
+            (dffr-z2-mtrx 
+              (if (or (= 0 (array-total-size z2-mtrx)) (= 0 (array-total-size dffr-mtrx)))
+                 nil-mtrx
+                 (mtrx-prdc dffr-mtrx z2-mtrx)))
+            (bnd-z2-line-n p-basis-l)
+            (bnd-z2-column-n (column-number dffr-z2-mtrx))
+            (bnd-z2-mtrx
+             (if (or (= 0 bnd-z2-line-n) (= 0 bnd-z2-column-n))
+                nil-mtrx
+                (submatrix dffr-z2-mtrx 0 (1- bnd-z2-line-n) 0 (1- bnd-z2-column-n))))
+            (den1-mtrx (mtrx-conc bnd-z2-mtrx fltr-p-1-mtrx))
+            (den-column-n (column-number den1-mtrx))
+            (den-line-n p-basis-l)
+            (rslt  
+              #-ACLPC (make-array (list den-line-n den-column-n)
+                        :element-type 'fixnum
+                        :initial-element 0)
+              #+ACLPC
+              (if (or (zerop den-line-n) (zerop den-column-n))
+                 (make-array (list den-line-n den-column-n)
+                   :element-type 'fixnum)
+                 (make-array (list den-line-n den-column-n)
+                   :element-type 'fixnum
+                   :initial-element 0))))
+        (declare
+             (list fltr-p-basis fltr-p-1-list z2-list)
+             (type fixnum degr p-basis-l bnd-z2-line-n bnd-z2-column-n den-column-n den-line-n)
+             (type matrix z2-mtrx fltr-p-1-mtrx dffr-mtrx nil-mtrx 
+               dffr-z2-mtrx bnd-z2-mtrx den1-mtrx rslt))
+        (do ((j 0 (1+ j)))
+            ((>= j den-column-n))
+           (declare (type fixnum j))
+           (do ((i 0 (1+ i)))
+               ((>= i (min den-line-n (line-number den1-mtrx))))
+              (declare (type fixnum i))
+              (Setf (aref rslt i j) (aref den1-mtrx i j))))
+        rslt)))
+                   
+#|
+(spsq-den-mtrx fcc 2 3 2)
+(spsq-den-mtrx fcc 1 2 4)
+|#   
+
+;; Function that returns the representation basis-divisors of E^r_{p,q} of a
+;; finitely generated complex. 
+(defun eff-spsq-basis-dvs (FltrCm r p q)
+   (declare 
+     (type filtered-chain-complex fltrcm)
+     (type fixnum r p q))
+   (the list
+     (let* ((degr (+ p q))
+            (fltr-p-basis (fltrd-basis fltrcm degr p))
+            (p-basis-l (length fltr-p-basis))
+            (num-mtrx (spsq-num-mtrx fltrcm r p q))
+            (den-mtrx (spsq-den-mtrx fltrcm r p q)) 
+            (cmbn-list nil)
+            (divs nil))
+        (declare
+         (list fltr-p-basis cmbn-list divs)
+         (type fixnum degr p-basis-l)
+         (type matrix num-mtrx den-mtrx))
+        (progn
+         (if (= 0 (array-total-size num-mtrx))
+            (progn
+             (setq cmbn-list nil)
+             (setq divs nil))
+            (if (= 0 (array-total-size den-mtrx))
+               (progn
+                (setq cmbn-list (gnrt-mtrx-to-list num-mtrx))
+                (setq divs (make-list (length cmbn-list) :initial-element 0)))
+               (let ((quotient-list (mtrx-quotient num-mtrx den-mtrx)))
+                  (declare (list quotient-list))
+                  (setq cmbn-list (first quotient-list)
+                    divs (second quotient-list)))))
+         (list
+          (mapcar 
+            #'(lambda (int-list)
+                (declare (list int-list))
+                (the cmbn
+                  (let* ((cmbn (cmbn degr))
+                         (cmpr (cmpr fltrcm)))
+                     (declare 
+                       (type cmbn cmbn)
+                       (type cmprf cmpr))
+                     (do ((mark1 int-list (cdr mark1))
+                          (mark2 fltr-p-basis (cdr mark2)))
+                         ((or (endp mark1) (endp mark2)))
+                        (declare (type list mark1 mark2))
+                        (if (not (= 0 (car mark1)))
+                           (setq cmbn (2cmbn-add cmpr cmbn 
+                                        (cmbn degr (car mark1) (car mark2))))))
+                     cmbn))) 
+            cmbn-list)
+          divs)))))
+
+#|
+(do ((r 1 (1+ r)))
+    ((> r 3))
+   (dotimes (n 8)
+      (dotimes (p (+ n 1))
+         (let ((q (- n p)))
+            (print (list r p q))
+            (princ (eff-spsq-basis-dvs fcc r p q))
+            ))))
+|# 
+
+
+(defun eff-spsq-gnrts (FltrCm r p q)
+   (declare 
+     (type filtered-chain-complex fltrcm)
+     (type fixnum r p q))
+   (let* ((basis-dvs (eff-spsq-basis-dvs fltrcm r p q))
+         (basis (first basis-dvs))
+         (dvs (second basis-dvs))
+         (rslt nil))
+      (declare (type list basis-dvs basis dvs rslt))
+      (do ((mark1 basis (cdr mark1))
+           (mark2 dvs (cdr mark2)))
+          ((endp mark1))
+         (if (not (eql 1 (car mark2)))
+            (setf rslt (append rslt (list (car mark1))))))
+      rslt))
+      
+ 
+;; Function that presents on the screen the components of the E^r_{p,q}
+;; of the spectral sequence of a filtered complex.
+(defun eff-spsq-group (fltrcm r p q)
+   (declare 
+     (type filtered-chain-complex fltrcm)
+     (type fixnum r p q))  
+   (let* ((basis-dvs (eff-spsq-basis-dvs fltrcm r p q))
+          (cmbns (first basis-dvs))
+          (divs (second basis-dvs)))
+      (declare (list basis-dvs cmbns divs))
+      (format t "Spectral sequence E^~D_{~D,~D}" r p q)
+      (dolist (item divs)
+         (declare (type fixnum item))
+         (if (not (eql 1 item))
+            (progn
+             (format t "~2%Component Z")
+             (unless (zerop item) 
+                (format t "/~DZ" item))
+             )))
+      (terpri)))
+
+#|
+(do ((r 1 (1+ r)))
+    ((> r 3))
+   (dotimes (n 8)
+      (dotimes (p (+ n 1))
+         (let ((q (- n p)))
+            (eff-spsq-group fcc r p q)
+            (terpri)
+            (terpri)
+            ))))
+|# 
+
+
+
+;; DIFFERENTIAL FUNCTIONS
+
+;; Auxiliary functions to deal with coefficients of elements with regard to 
+;; some generators or elements of a basis. 
+
+
+;; Function that returns the coordinates of a vector vctr with regard to
+;; the basis whose elements are the columns of the matrix gnrt-mtrx.
+(defun vctr-coordinates (vctr gnrt-mtrx)
+   (declare 
+     (type list vctr)
+     (type matrix gnrt-mtrx))
+   (the list
+     (let* ((C (gnrt-list-to-mtrx (list vctr)))
+            (B (copy-mtrx gnrt-mtrx))
+            (smith-list (smith B))
+            (p-1 (second smith-list))
+            (D (third smith-list))
+            (q (fourth smith-list))
+            (q-1 (fifth smith-list))
+            (C2 (mtrx-prdc p-1 C))
+            (line-n (column-number B))
+            (A2 
+             #-ACLPC
+             (make-array (list line-n 1)
+               :element-type 'fixnum
+               :initial-element 0)
+             #+ACLPC
+             (if (zerop line-n)
+                (make-array (list line-n 1)
+                  :element-type 'fixnum)
+                (make-array (list line-n 1)
+                  :element-type 'fixnum
+                  :initial-element 0)))
+            (end nil))
+        (declare 
+          (type matrix C B p-1 D q q-1 C2 A2)
+          (type list smith-list)
+          (type fixnum line-n end))
+        (do ((i 0 (1+ i)))
+            ((or (>= i (column-number D)) (>= i (line-number D)) end))
+           (declare (type fixnum i))
+           (let* ((di (aref D i i)))
+              (declare (type fixnum di))
+              (if (eql 0 di)
+                 (setq found 1)
+                 (progn
+                  (setf (aref A2 i 0) (floor (aref C2 i 0) di))))))
+        (let* ((A (mtrx-prdc Q A2)))
+           (declare (type matrix A))
+           (column-j A 0)))))
+
+#|
+(setf m (gnrt-list-to-mtrx '((1 0 0 0) (2 3 4 5) (0 1 0 3))))
+(setq vctr '(5 9 8 19))
+(vctr-coordinates vctr m)
+|# 
+
+;; Function that returns the list of coefficients of the combination "cmbn"
+;; in the basis (list of generators) "basis" (with comparison function "cmpr").
+(defun cmbn-cffc-list (cmbn basis cmpr)
+   (declare 
+     (type cmbn cmbn)
+     (type list basis)
+     (type cmprf cmpr))
+   (the list
+     (let* ((rslt nil)
+            (mark1 (cmbn-list cmbn))
+            (term (car mark1))
+            (cffc (cffc term))
+            (gnrt (gnrt term)))
+        (declare
+         (type list rslt mark1)
+         (type term term)
+         (type cffc cffc)
+         (type gnrt gnrt))
+        (do ((mark2 basis (cdr mark2)))
+            ((endp mark2))
+           (declare 
+             (type list mark2))
+           (if (endp mark1)
+              (setq rslt (nconc rslt (list 0)))
+           (if (eq :equal (funcall cmpr gnrt (car mark2)))
+              (progn
+               (setq rslt (nconc rslt (list cffc)))
+               (pop mark1)
+               (setq term (car mark1))
+               (setq cffc (cffc term) gnrt (gnrt term)))
+              (setq rslt (nconc rslt (list 0))))))
+        rslt)))
+
+#|
+(setf basis (list 'a 'b 'c 'd 'e 'f))
+(setq cmbn (cmbn 2 3 'a 5 'c 8 'f))
+(cmbn-cffc-list cmbn basis #'s-cmpr)
+|# 
+
+;; Function that returns the list of coordinates of the combination "cmbn" in the basis
+;; formed by the combinations in the list "gnrt-list". All these combinations are combinations
+;; of the generators in "basis" ("cmpr" is the comparison function). 
+(defun cmbn-coordinates (cmbn gnrt-list basis cmpr)
+   (declare 
+     (type cmbn cmbn)
+     (type list gnrt-list basis)
+     (type cmprf cmpr))
+   (the list
+     (let* ((vctr (cmbn-cffc-list cmbn basis cmpr))
+            (B (gnrt-list-to-mtrx
+                (mapcar
+                 #'(lambda (cmbn2)
+                     (declare (type cmbn cmbn2))
+                     (cmbn-cffc-list cmbn2 basis cmpr))
+                 gnrt-list))))
+        (declare
+         (type list vctr)
+         (type matrix B))
+        (vctr-coordinates vctr B))))
+
+#|
+(setf basis (list 'a 'b 'c 'd 'e 'f))
+(setq cmbn (cmbn 2 3 'a 5 'c 6 'f))
+(setq gnrt-list (list (cmbn 2 1 'a 2 'd 2 'f) (cmbn 2 5 'c -6 'd)))
+(cmbn-coordinates cmbn gnrt-list basis #'s-cmpr)
+|# 
+    
+         
+;; Main function to compute the differential of an element in the spectral sequence          
+
+
+;; Function that returns the list of integers which correspond to the coordinates
+;; on each of the components of E^r_{p-r,q+r-1} of the differential 
+;; d: E^r_{p,q} --> E^r_{p-r,q+r-1} applied to the element of E^r_{p,q}
+;; which has as coordinates the list int-list. (Only for finitely generated complexes)
+(defun eff-spsq-dffr (fltrcm r p q int-list)
+   (declare
+    (type filtered-chain-complex fltrcm)
+    (type fixnum r p q)
+    (list int-list))
+   (the list
+     (let* ((cmpr (cmpr1 fltrcm))
+            (degr (+ p q))
+            (sbasis (fltrd-basis fltrcm degr p))
+            (tbasis (fltrd-basis fltrcm (1- degr) (- p r)))
+            (num-mtrx (spsq-num-mtrx fltrcm r p q))
+            (den-mtrx (spsq-den-mtrx fltrcm r p q))
+            (Z-gnrt-list (Fltr-Chcm-Z-Gnrt-List fltrcm r p q))
+            (s-basis-dvs (mtrx-quotient (copy-mtrx num-mtrx) den-mtrx))
+            (s-gnrt-list (first s-basis-dvs))
+            (s-dvs (second s-basis-dvs))
+            (t-basis-dvs (spsq-basis-dvs fltrcm r (- p r) (1- (+ q r))))
+            (t-gnrt-list (first t-basis-dvs))
+            (t-dvs (second t-basis-dvs))
+            (selement (make-list (length sbasis) :initial-element 0))
+            (cmbn (cmbn degr)))
+        (declare 
+          (type fcmpr cmpr)
+          (type fixnum degr)
+          (type list sbasis tbasis z-gnrt-list s-basis-dvs s-gnrt-list s-dvs
+            t-basis-dvs t-gnrt-list t-dvs selement)
+          (type matrix num-mtrx den-mtrx)
+          (type cmbn cmbn))
+        (progn
+         (labels ((2list-add (list1 list2)
+                    (declare (type list list1 list2))
+                    (the list
+                      (mapcar #'+ list1 list2)))
+                  (n-list (n list)
+                    (declare
+                     (type list list)
+                     (type fixnum n))
+                    (the list
+                      (mapcar #'(lambda (i)
+                                  (* n i))
+                        list))))
+           (do ((mark1 s-gnrt-list (cdr mark1))
+                (mark2 s-dvs (cdr mark2))
+                (mark3 int-list))
+               ((endp mark1))
+              (declare (list mark1 mark2 mark3))
+              (if (not (eql 1 (car mark2)))
+                 (progn
+                  (setq selement (2list-add selement (n-list (car mark3) (car mark1))))
+                  (pop mark3)))))
+         (let* ((selt-coord (vctr-coordinates selement num-mtrx)))
+            (declare (list selt-coord))
+            (do ((mark1 z-gnrt-list (cdr mark1))
+                 (mark2 selt-coord (cdr mark2)))
+                ((endp mark1))
+               (declare (list mark1 mark2))
+               (if (not (eql 0 (car mark2)))
+                  (setq cmbn (2cmbn-add cmpr cmbn (n-cmbn (car mark2)
+                                                    (funcall 
+                                                      #'(lambda (int-list)
+                                                          (declare (list int-list))
+                                                          (the cmbn
+                                                            (let* ((cmbn2 (cmbn degr)))
+                                                               (declare 
+                                                                 (type cmbn cmbn))
+                                                               (do ((mark3 int-list (cdr mark3))
+                                                                    (mark4 sbasis (cdr mark4)))
+                                                                   ((or (endp mark3) (endp mark4)))
+                                                                  (declare (type list mark3 mark4))
+                                                                  (if (not (= 0 (car mark3)))
+                                                                     (setq cmbn2 (2cmbn-add cmpr cmbn2 
+                                                                                   (cmbn degr (car mark3) (car mark4))))))
+                                                               cmbn2)))
+                                                      (car mark1))))))))
+         (let* ((dffr-cmbn (dffr fltrcm cmbn))
+                (crdnt (cmbn-coordinates dffr-cmbn t-gnrt-list tbasis cmpr))
+                (rslt nil))
+            (declare
+             (type cmbn dffr-cmbn)
+             (type list crdnt rslt))
+            (do ((mark1 t-dvs (cdr mark1))
+                 (mark2 crdnt (cdr mark2)))
+                ((endp mark1))
+               (declare (list mark1 mark2))
+               (if (not (eql 1 (car mark1)))
+                  (if (eql 0 (car mark1))
+                     (setq rslt (nconc rslt (list (car mark2))))
+                     (setq rslt (nconc rslt (list (mod (car mark2) (car mark1))))))))
+            rslt)))))          
+                           
+#|
+(eff-spsq-dffr fcc 1 2 3 '(1))
+(eff-spsq-dffr fcc 1 2 5 '(0 1))
+(eff-spsq-dffr fcc 1 2 5 '(1 0))
+(eff-spsq-dffr fcc 1 3 4 '(1 0))
+(eff-spsq-dffr fcc 1 3 4 '(0 1))
+|# 
+
+;; CONVERGENCE OF THE SPECTRAL SEQUENCE            
+
+;; Function that determines if at level r and for degree n the E^r_{p,q} of the
+;; filtered complex fltrcm with p+q=degr are equal to E^\infty_{p,q} (i.e., it 
+;; determines if the convergence of the spectral sequence has been reached at 
+;; level r for the degree n). The list hmlg-cmpns contains the "components" of
+;; the homology group of the complex. It begins with m zeros if the free part of the
+;; group is Z^m and the rest of the list contains the torsion coefficients.
+;; (only for finitely generated complexes). 
+(defun eff-compare-spsq-with-homology (fltrcm r degr hmlg-cmpns)
+   (declare
+    (type filtered-chain-complex fltrcm)
+    (type fixnum r degr)
+    (type list hmlg-cmpns))
+   (let* ((min-max (flin-min-max fltrcm degr))
+          (min (first min-max))
+          (max (second min-max))
+          (spsq-cmpns
+           (mapcan
+           #'(lambda (p)
+               (declare (type fixnum p))
+               (let* ((q (- degr p)))
+                  (declare (type fixnum q))
+                  (second (eff-spsq-basis-dvs fltrcm r p q))))
+            (<a-b> min max)))
+          (mark2 hmlg-cmpns)
+          (hmlg-prdc 1)
+          (spsq-prdc 1))
+      (declare 
+        (type function spsq)
+        (type list spsq-cmpns mark2)
+        (type fixnum hmlg-prdc spsq-prdc))
+      (progn
+       (do ((mark1 spsq-cmpns (cdr mark1)))
+           ((endp mark1))
+          (declare (type list mark1))
+          (if (eql 0 (car mark1))
+             (if (not (eql 0 (car mark2)))
+                (return-from eff-compare-spsq-with-homology nil)
+                (pop mark2))
+             (setq spsq-prdc (* spsq-prdc (car mark1)))))
+       (do ((mark3 mark2 (cdr mark3)))
+           ((endp mark3))
+          (declare (type list mark3))
+          (setq hmlg-prdc (* hmlg-prdc (car mark3))))
+       (if (eql hmlg-prdc spsq-prdc)
+          't
+          nil))))
+   
+#|
+(homology fcc 5) 
+(eff-compare-spsq-with-homology fcc  1 5 '(2))
+(homology fcc 6)
+(eff-compare-spsq-with-homology fcc  1 6 '(2))
+|# 
+
+;; Function that determines the level r at which for degree n the E^r_{p,q} of the
+;; filtered complex fltrcm with p+q=degr are equal to E^\infty_{p,q} (i.e., it 
+;; determines the level r which the convergence of the spectral sequence has been 
+;; reached at for the degree n).            
+(defun eff-spsq-cnvg (fltrcm degr)
+   (declare 
+     (type filtered-chain-complex fltrcm)
+     (type fixnum degr))
+   (the fixnum
+     (let* ((hmlg-dvs-gnrs (homologie (chcm-mat fltrcm degr) (chcm-mat fltrcm (1+ degr))))
+            (hmlg-cmpns (reverse
+                         (mapcar
+                          #'(lambda (l)
+                              (first l))
+                          hmlg-dvs-gnrs)))
+            (cnvg-r 0))
+        (declare 
+          (list hmlg-dvs-gnrs hmlg-cmpns)
+          (type fixnum cnvg-r))
+        (do ((r 1 (1+ r)))
+            ((> cnvg-r 0))
+           (declare (type fixnum r))
+           (if (eff-compare-spsq-with-homology fltrcm r degr hmlg-cmpns)
+              (setq cnvg-r r)))
+        cnvg-r)))
+
+#|
+(eff-spsq-cnvg fcc 5)
+(eff-spsq-cnvg fcc 6)
+|# 
+
+;; EFFECTIVE HOMOLOGY
+
+
+;; Function that returns the order of filtration t (with regard to the filtration in the
+;; left complex, which is translated to the top and right ones) of the homotopy in the right reduction,
+;; which will determine the level r (=t+1) up to which the spectral sequences E^r_p,q 
+;; (with p+q=n) of the left and right complexes are isomorphic. This function can only be used
+;; when the top complex is effective (we need to obtain the elements in the basis of this complex). 
+(defun hmtp-eq-fltr-order (hmtp-eq degr)
+   (declare 
+     (type HOMOTOPY-EQUIVALENCE hmtp-eq)
+     (type fixnum degr))
+   (let* ((lcc (lbcc hmtp-eq))
+          (tcc (tcc hmtp-eq))
+          (lf (lf hmtp-eq))
+          (rh (rh hmtp-eq))
+          (max 0))
+      (declare
+       (type chain-complex lcc tcc)
+       (type morphism lf rh)
+       (type fixnum max))
+      (when (eq (basis tcc) :locally-effective)
+         (error "Hmtp-eq-fltr-order cannot work when the top complex of the homotopy equivalence
+             is a LOCALLY-EFFECTIVE chain complex."))
+      (mapcar 
+        #'(lambda (gnrt)
+            (declare (type gnrt gnrt))
+            (setq max (max max (- (flin lcc (lf hmtp-eq (rh hmtp-eq degr gnrt)))
+                        (flin lcc (lf hmtp-eq degr gnrt))))))
+        (basis tcc degr))
+      max))
+
+#|
+(setf hmtp-eq (efhm fcc)) ;; Trivial homotopy equivalence
+(hmtp-eq-fltr-order hmtp-eq 3)
+
+(setq k3 (k-z2 3))
+(Setq hmtp-eq3 (efhm k3))
+(setq ek3 (rbcc hmtp-eq3))
+(Change-Chcm-TO-Flcc ek3 :flin abar-flin :orgn `(filtered-chain-complex ,ek3))
+(setf k3-flin
+        #'(lambda (degr gnrt)
+            (flin ek3 (rf hmtp-eq3 (lg hmtp-eq3 degr gnrt)))))
+(Change-Chcm-TO-Flcc k3 :flin k3-flin :orgn `(filtered-chain-complex ,k3))
+(hmtp-eq-fltr-order hmtp-eq3 3)
+(hmtp-eq-fltr-order hmtp-eq3 5)
+|#
+
+;; Function that changes the right bottom chain complex in a homotopy equivalence into 
+;; a filtered complex, with a filtration defined translating the filtration in the left complex 
+;; (which must be a filtered complex). 
+(defun translate-filtration (hmtp-eq)
+   (declare
+    (type homotopy-equivalence hmtp-eq))
+   (let ((fltrcm (lbcc hmtp-eq))
+         (eff-chcm (rbcc hmtp-eq)))
+      (declare (type chain-complex fltrcm eff-chcm))
+      (Change-Chcm-TO-Flcc eff-chcm :flin
+                                 #'(lambda (degr gnrt)
+                                     (flin fltrcm (lf hmtp-eq (rg hmtp-eq degr gnrt))))
+                                 :orgn (orgn eff-chcm))))
+     
+  
+ 
+;; Function that returns the representation basis-divisors of E^r_{p,q} for a filtered
+;; complex fltrcm with effective homology, computing the E^r_{p,q} of the effective complex
+;; in the right side of the homotopy equivalence. 
+;; If the effective complex is a filtered complex, we supose that both reductions in the equi-
+;; valence are compatible with the filtrations (f and g respect the filtration index and h has
+;; filtration order < r). If not, we define the filtration in the effective
+;; complex translating the filtration in the original filtered complex FltrCm, suposing that the 
+;; homotopy in the right side is compatible with the filtration in the left complex for such r (we 
+;; supose that flin(rh(lf(y)))-flin(lf(y))<r for every y in the top complex). 
+(defun spsq-basis-dvs (FltrCm r p q)
+   (declare 
+     (type filtered-chain-complex fltrcm)
+     (type fixnum r p q))
+   (let* ((hmtp-eq (efhm fltrcm))
+          (eff-chcm (rbcc hmtp-eq))
+          (degr (+ p q)))
+      (declare 
+        (type homotopy-equivalence hmtp-eq)
+        (type chain-complex eff-chcm)
+        (type fixnum degr))
+      (progn
+       (if (not (typep eff-chcm 'filtered-chain-complex))
+          (translate-filtration hmtp-eq))
+       (let ((spsq-list (eff-spsq-basis-dvs eff-chcm r p q)))
+          (declare (list spsq-list))
+          (if (eql fltrcm eff-chcm) spsq-list
+             (list
+              (mapcar
+               #'(lambda (cmbn)
+                   (lf hmtp-eq (rg hmtp-eq cmbn)))
+               (first spsq-list))
+              (second spsq-list)))))))
+
+#|
+(spsq-basis-dvs k3 2 2 2)
+|# 
+
+
+(defun spsq-gnrts (fltrcm r p q)
+   (declare
+    (type filtered-chain-complex fltrcm)
+    (type fixnum r p q))
+   (let* ((hmtp-eq (efhm fltrcm))
+          (eff-chcm (rbcc hmtp-eq))
+          (degr (+ p q)))
+      (declare
+       (type homotopy-equivalence hmtp-eq)
+       (type chain-complex eff-chcm)
+       (type fixnum degr))
+      (progn
+       (if (not (typep eff-chcm 'filtered-chain-complex))
+          (translate-filtration hmtp-eq))
+       (eff-spsq-gnrts eff-chcm r p q))))
+
+;; Function that presents on the screen the components of the E^r_{p,q}
+;; of the spectral sequence of a filtered complex fltrcm with effective homology.
+;; If the effective complex is a filtered complex, we supose that both reductions in the equi-
+;; valence are compatible with the filtrations (f and g respect the filtration index and h has
+;; filtration order < r). If not, we define the filtration in the effective
+;; complex translating the filtration in the original filtered complex FltrCm, suposing that the 
+;; homotopy in the right side is compatible with the filtration in the left complex for such r (we 
+;; supose that flin(rh(lf(y)))-flin(lf(y))<r for every y in the top complex). 
+(defun spsq-group (fltrcm r p q)
+   (declare
+    (type filtered-chain-complex fltrcm)
+    (type fixnum r p q))
+   (let* ((hmtp-eq (efhm fltrcm))
+          (eff-chcm (rbcc hmtp-eq))
+          (degr (+ p q)))
+      (declare
+       (type homotopy-equivalence hmtp-eq)
+       (type chain-complex eff-chcm)
+       (type fixnum degr))
+      (progn
+       (if (not (typep eff-chcm 'filtered-chain-complex))
+          (translate-filtration hmtp-eq))
+       (eff-spsq-group eff-chcm r p q))))
+
+;; Function that returns the list of integers which correspond to the coordinates
+;; on each of the components of E^r_{p-r,q+r-1} of the differential 
+;; d: E^r_{p,q} --> E^r_{p-r,q+r-1} applied to the element of E^r_{p,q}
+;; which has as coordinates the list int-list.
+(defun spsq-dffr (fltrcm r p q int-list)
+   (declare
+    (type filtered-chain-complex fltrcm)
+    (type fixnum p q r)
+    (type list int-list))
+   (let* ((hmtp-eq (efhm fltrcm))
+          (eff-chcm (rbcc hmtp-eq))
+          (degr (+ p q)))
+      (declare
+       (type homotopy-equivalence hmtp-eq)
+       (type chain-complex eff-chcm)
+       (type fixnum degr))
+      (progn
+       (if (not (typep eff-chcm 'filtered-chain-complex))
+          (translate-filtration hmtp-eq))
+       (eff-spsq-dffr eff-chcm r p q int-list))))
+   
+;; Function that determines the level r at which for degree n the E^r_{p,q} (with p+q=degr)
+;; of the filtered complex fltrcm (with effective homology) are equal to E^\infty_{p,q} (i.e., it 
+;; determines the level r which the convergence of the spectral sequence has been 
+;; reached at for the degree n).
+(defun spsq-cnvg (fltrcm degr)
+   (declare
+    (type filtered-chain-complex fltrcm)
+    (type fixnum degr))
+   (let* ((hmtp-eq (efhm fltrcm))
+          (eff-chcm (rbcc hmtp-eq)))
+      (declare
+       (type homotopy-equivalence hmtp-eq)
+       (type chain-complex eff-chcm)
+       (type fixnum degr))
+      (progn
+       (if (not (typep eff-chcm 'filtered-chain-complex))
+          (translate-filtration hmtp-eq))
+       (eff-spsq-cnvg eff-chcm degr))))
+
+
+ 
+       
+          
+;; Homology filtration
+
+
+(defun homology-gnrt-list (chcm degr)
+     (declare (type cc chcm) (type fixnum degr))
+     (let ((src (cons :unused (basis chcm degr)))
+           (hom-dvs-gnrts (homologie (chcm-mat chcm degr) (chcm-mat chcm (1+ degr))))
+           (rslt nil))
+        (declare (type list src hom-dvs-gnrts rslt))
+        (mapcar #'(lambda (item)
+                    (declare (type list item))
+                    (let ((cmbn (cmbn degr))
+                          (cmpr (cmpr chcm)))
+                       (dolist (item2 (rest item))
+                          (declare (type cons item2))
+                          (setf cmbn (2cmbn-add cmpr cmbn (cmbn degr (car item2) (nth (cdr item2) src)))))
+                       cmbn))
+          hom-dvs-gnrts)))
+
+
+
+
+(defun homology-fltr1 (fltrcm degr fltr-index)
+   (declare
+    (type filtered-chain-complex fltrcm)
+    (type fixnum degr fltr-index))
+   (let* ((r (spsq-cnvg fltrcm degr))
+          (cmpr (cmpr1 fltrcm))
+          (total-basis (fltrd-basis fltrcm degr fltr-index))
+          (dffr-mtrx (FLTR-CHCM-Z-MTRX fltrcm r fltr-index (- degr fltr-index)))
+          (fltrt-basis 
+           (mapcan #'(lambda (p)
+                       (let* ((q (- degr p))
+                              (num-mtrx (spsq-num-mtrx fltrcm r p q))
+                              (den-mtrx (spsq-den-mtrx fltrcm r p q))
+                              (Z-gnrt-list (Fltr-Chcm-Z-Gnrt-List fltrcm r p q))
+                              (ss-basis-dvs (mtrx-quotient (copy-mtrx num-mtrx) den-mtrx))
+                              (ss-gnrt-list (first ss-basis-dvs))
+                              (ss-dvs (second ss-basis-dvs))
+                              (rslt nil))
+                          (declare 
+                            (type fcmpr cmpr)
+                            (type fixnum r q)
+                            (type list total-basis z-gnrt-list ss-basis-dvs ss-gnrt-list ss-dvs rslt)
+                            (type matrix num-mtrx den-mtrx))
+                          (labels ((2list-add (list1 list2)
+                                     (declare (type list list1 list2))
+                                     (the list
+                                       (mapcar #'+ list1 list2)))
+                                   (n-list (n list)
+                                     (declare
+                                       (type list list)
+                                       (type fixnum n))
+                                     (the list
+                                       (mapcar #'(lambda (i)
+                                                   (* n i))
+                                         list))))
+                            (do ((mark1 ss-gnrt-list (cdr mark1))
+                                 (mark2 ss-dvs (cdr mark2)))
+                                ((endp mark1))
+                               (declare (type list mark1 mark2))
+                               (if (not (eql 1 (car mark2)))
+                                  (let* ((selt (first mark1))
+                                         ;;(coord (cmbn-cffc-list selt total-basis cmpr))
+                                         (cmbn (cmbn degr)))
+                                     (progn
+                                       (let* ((selt-coord (vctr-coordinates selt num-mtrx)))
+                                          (declare (list selt-coord))
+                                          (do ((mark3 z-gnrt-list (cdr mark3))
+                                               (mark4 selt-coord (cdr mark4)))
+                                              ((endp mark3))
+                                             (declare (list mark3 mark4))
+                                             (if (not (eql 0 (car mark4)))
+                                                (setq cmbn (2cmbn-add cmpr cmbn (n-cmbn (car mark4)
+                                                                                  (funcall 
+                                                                                    #'(lambda (int-list)
+                                                                                        (declare (list int-list))
+                                                                                        (the cmbn
+                                                                                          (let* ((cmbn2 (cmbn degr)))
+                                                                                             (declare 
+                                                                                               (type cmbn 
+                                                                                                 cmbn2))
+                                                                                             (do ((
+                                                                                                   mark5 int-list (cdr 
+                                                                                                                    mark5))
+                                                                                                  (mark6 total-basis (cdr mark6)))
+                                                                                                 ((or (endp mark5) (endp mark6)))
+                                                                                                (declare (type list mark5 mark6))
+                                                                                                (if (not (= 0 (car mark5)))
+                                                                                                   (setq cmbn2 (2cmbn-add cmpr cmbn2 
+                                                                                                                 (cmbn degr (car 
+                                                                                                                              mark5) (car 
+                                                                                                                                       mark6))))))
+                                                               cmbn2)))
+                                                      (car mark3))))))))
+                                       (setf rslt (nconc rslt (list cmbn)))
+                                       rslt)))))))
+                          (<a-b> 0 fltr-index))))
+      (if (not (endp fltrt-basis))
+          (let ((fltrt-mtrx
+                  (gnrt-list-to-mtrx
+                    (mapcar #'(lambda (cmbn)
+                                (cmbn-cff-list cmbn total-basis cmpr))
+                      (fltrt-basis))))
+                (num-mtrx (mtrx-conc fltrt-mtrx dffr-mtrx)))
+             (mtrx-quotient num-mtrx dffr-mtrx))
+         nil)))
+
+
+
+(defun eff-hmlg-fltr (fltrcm degr p)
+   (declare
+     (type filtered-chain-complex fltrcm)
+     (type fixnum degr p))
+   (let* ((min-max-1 (flin-min-max fltrcm (1- degr)))
+          (min-1 (first min-max-1))
+          (max-1 (second min-max-1))
+          (min-max+1 (flin-min-max fltrcm (1+ degr)))
+          (min+1 (first min-max+1))
+          (max+1 (second min-max+1))
+          (r (1+ (- p min-1)))
+          (q (- degr p))
+          (Z-gnrts (Fltr-Chcm-Z-Gnrt-List FltrCm r p q))
+          (dffr-mtrx (FLTR-CHCM-Z-MTRX fltrcm (+ 2 (- degr min+1)) (1+ degr) 0))
+          (num-mtrx (mtrx-conc (gnrt-list-to-mtrx z-gnrts) dffr-mtrx))
+          (basis-divs (mtrx-quotient num-mtrx dffr-mtrx))
+          (divs (second basis-divs)))
+      (format t "Filtration F_~D H_~D" p degr)
+      (dolist (item divs)
+         (declare (type fixnum item))
+         (if (not (eql 1 item))
+            (progn
+             (format t "~2%Component Z")
+             (unless (zerop item) 
+                (format t "/~DZ" item))
+             )))))
+     
+
+(defun hmlg-fltr (fltrcm degr p)
+   (declare
+    (type filtered-chain-complex fltrcm)
+    (type fixnum degr))
+   (let* ((hmtp-eq (efhm fltrcm))
+          (eff-chcm (rbcc hmtp-eq)))
+      (declare
+       (type homotopy-equivalence hmtp-eq)
+       (type chain-complex eff-chcm)
+       (type fixnum degr))
+      (progn
+       (if (not (typep eff-chcm 'filtered-chain-complex))
+          (translate-filtration hmtp-eq))
+       (eff-hmlg-fltr eff-chcm degr p))))
+
+
+
+
+(DEFTYPE ss-type () '(member :serre :eilenberg-moore :filtration))
+         
+   
+
+(defclass OUTPUT-SPECTRAL-SEQUENCE ()
+    ((hmeq :type homotopy-equivalence :initarg hmeq :reader hmeq)
+     (eff-flin :type chcm-fltrindex :initarg eff-flin :reader eff-flin)
+     (bgn :type fixnum :initarg bgn :reader bgn)
+     ;; IDentification NuMber

+     (idnm :type fixnum :initform (incf *idnm-counter*) :reader idnm)

+     ;; ORiGiN

+     (orgn :type list :initarg :orgn :reader orgn)))
+
+
+(DEFVAR *oss-list*)
+(SETF *oss-list* +empty-list+)
+(PUSHNEW '*oss-list* *list-list*)
+
+(DEFMETHOD PRINT-OBJECT ((oss OUTPUT-SPECTRAL-SEQUENCE) stream)
+(the output-spectral-sequence
+   (progn
+      (format stream "[K~D output-spectral-sequence]" (idnm oss))
+     oss)))
+
+(DEFUN Oss (idnm)
+   (declare (type fixnum idnm))
+   (the (or OUTPUT-SPECTRAL-SEQUENCE null)
+      (find idnm *oss-list* :key #'idnm)))
+
+
+(DEFUN BUILD-oss (&key hmeq eff-flin bgn orgn)
+   (declare
+      (type homotopy-equivalence hmeq)
+      (type chcm-fltrindex eff-flin)
+      (type fixnum bgn)
+      (type list orgn))
+   (the output-spectral-sequence
+      (progn
+         (let ((already (find orgn *oss-list* :test #'equal :key #'orgn)))
+            (declare (type (or output-spectral-sequence null) already))
+            (when already
+               (return-from build-oss already)))
+         (let ((oss (make-instance 'output-spectral-sequence
+                        :hmeq hmeq
+                        :eff-flin eff-flin
+                        :bgn bgn
+                        :orgn orgn)))
+            (declare (type output-spectral-sequence oss))
+            (push oss *oss-list*)
+            oss))))
+     
+;;(defun serre-ss (fibration)
+
+#|(defun serre-ss (f)
+   (declare (type fibration f))
+   (let* ((X (fibration-total f))
+          (hmeq (efhm X))
+          (eX (rbcc efhm))
+|#
\ No newline at end of file
diff --git a/examples/anromero/suspended-classifying-spaces-lisp-files/OMparsers.cl b/examples/anromero/suspended-classifying-spaces-lisp-files/OMparsers.cl
new file mode 100644
index 0000000..eca59cd
--- /dev/null
+++ b/examples/anromero/suspended-classifying-spaces-lisp-files/OMparsers.cl
@@ -0,0 +1,469 @@
+(in-package :user)
+
+
+
+
+(defun OMgetNextLabel (s)
+   (let* ((p1 (search "<" s)))
+      (delete-if #'(lambda (item) t) s :start 0 :end p1)
+          (let ((p1 (search "<" s))
+                (p2 (if (search " " s) (min (search ">" s) (search " " s))
+                      (search ">" s) )))
+      (subseq s (1+ p1) p2))))
+
+(defun OMgetNextSymbol (s)
+   (let* ((p1 (search "cd=" s))
+          (p2 (search "name=" s))
+          (p3 (search "/>" s))
+          (rslt1 (subseq s (+ 3 p1) p2))
+          (rslt2 (subseq s (+ 5 p2) p3))
+          )
+         (OMLispSymbol (list (delete #\" (delete #\space rslt1)) (delete #\" (delete #\space rslt2))))
+         ))
+
+(defun OMparseNextInteger (s)
+   (if (not (equal (OMgetNextLabel s) "OMI"))
+      (error "The next token is not an integer")
+      (let* ((p1 (search "<OMI>" s))
+             (p2 (search "</OMI>" s))
+             (rslt (parse-integer (subseq s (+ 5 p1) p2))))
+         (delete-if #'(lambda (item) t) s :start 0 :end (+ 6 p2))
+         rslt
+         )))
+
+(defun OMparseNextString (s)
+   (if (not (equal (OMgetNextLabel s) "OMSTR"))
+      (error "The next token is not a string")
+      (let* ((p1 (search "<OMSTR>" s))
+             (p2 (search "</OMSTR>" s))
+             (rslt (subseq s (+ 7 p1) p2)))
+         (delete-if #'(lambda (item) t) s :start 0 :end (+ 8 p2))
+         rslt
+         )))
+
+(defun OMparseNextVar (s)
+   (if (not (equal (OMgetNextLabel s) "OMV"))
+      (error "The next token is not a variable")
+      (let* ((p1 (search "<OMV>" s))
+             (p2 (search "</OMV>" s))
+             (rslt (intern (subseq s (+ 5 p1) p2))))
+         (delete-if #'(lambda (item) t) s :start 0 :end (+ 6 p2))
+         rslt
+         )))
+
+(defun OMparseNextSymbol (s)
+   (if (not (equal (OMgetNextLabel s) "OMS"))
+      (error "The next token is not a symbol")
+      (let* ((rslt (OMgetNextSymbol s))
+             (p (search "/>" s))
+             )
+         (delete-if #'(lambda (item) t) s :start 0 :end (+ 2 p))
+         rslt
+         )))
+  
+(DEFTYPE direct-symbol () '(member list cyclicgroup symmetricgroup))
+
+
+(defun OMLispSymbol (list)
+   (let ((cd (first list))
+         (name (second list)))
+      (if (equal cd "list1")
+         (if (equal name "list")
+            'list)
+         (if (equal cd "resolutions")
+            (if (equal name "zgcombination")
+               "zgcombination"
+               (if (equal name "zgterm")
+                  "zgterm"
+                  (if (equal name "zggnrt")
+                     "zggnrt"
+                     (if (equal name "resolution")
+                        "resolution"))))
+            (if (equal cd "group1")
+               (if (equal name "cyclic_group")
+                   'cyclicgroup
+                 (if (equal name "symmetric_group")
+                     'symmetricgroup)
+                 )
+              )))))
+
+(defun OMparseNextApplication (s)
+   (if (not (equal (OMgetNextLabel s) "OMA"))
+      (error "The next token is not an application")
+      (let* ((p1 (search "<OMA>" s)))
+         (delete-if #'(lambda (item) t) s :start 0 :end (+ 5 p1))
+         (let ((head (if (equal (OMgetNextLabel s) "OMS")
+                        (OMparseNextSymbol s)
+                        (OMparseNextObject s)))
+               (rest nil))
+            (if (typep head 'direct-symbol)
+               (do ((rest nil  (append rest (list nextobj))))
+                   ((equal (OMgetNextLabel s) "/OMA") (let ((p (search "</OMA>" s)))
+                                                         (delete-if #'(lambda (item) t) s :start 0 :end (+ 6 p1))
+                                                         (eval (append (list head) rest))))
+                  (setf nextobj (OMparseNextObject s))
+                  )
+               (if (equal head "resolution")
+                  (OMparseResolution s)
+                  (error "imposible to parse")
+            ))))))
+         
+         
+         
+           
+(defun OMparseNextObject (s)
+   (progn 
+     (if (equal (OMgetNextLabel s) "OMOBJ")
+        (delete-if #'(lambda (item) t) s :start 0 :end (+ 7 (search "<OMOBJ>" s))))
+   
+     (if (equal (subseq (OMgetNextLabel s) 0 3) "!--")
+        (delete-if #'(lambda (item) t) s :start 0 :end (+ 4 (search "--/>" s))))
+      
+     (let ((rslt
+            (if (equal (OMgetNextLabel s) "OMI")
+               (OMparseNextInteger s)
+               (if (equal (OMgetNextLabel s) "OMSTR")
+                  (OMparseNextString s)
+                  (if (equal (OMgetNextLabel s) "OMV")
+                     (OMparseNextVar s)
+                     (if (equal (OMgetNextLabel s) "OMS")
+                        (OMLispSymbol(OMparseNextSymbol s))
+                        (if (equal (OMgetNextLabel s) "OMA")
+                           (OMparseNextApplication s)
+                           (error "imposible to parse"))))))))
+        (progn
+         (if (and (not (equal s "")) (equal (OMgetNextLabel s) "/OMOBJ"))
+            (delete-if #'(lambda (item) t) s :start 0 :end (+ 8 (search "</OMOBJ>" s))))
+         rslt))))
+
+
+
+   
+
+
+(defun OMparseZggnrt (s grbasis zgbasis-degr)
+   (if (not (equal (OMgetNextLabel s) "OMA"))
+      (error "The next label is not an application")
+      (progn 
+        (delete-if #'(lambda (item) t) s :start 0 :end (+ 5 (search "<OMA>" s)))
+        (if (not (equal (OMgetNextSymbol s) "zggnrt"))
+           (error "This is not specified as a zggnrt")
+           (progn 
+             (OMparseNextSymbol s)
+             (let* ((i1 (OMparseNextInteger s))
+                    (i2 (OMparseNextInteger s)))
+                (delete-if #'(lambda (item) t) s :start 0 :end (+ 6 (search "</OMA>" s)))
+                (zggnrt (nth (1- i1) grbasis) (nth (1- i2) zgbasis-degr))))))))
+
+
+(defun OMparseZgterm (s degr grbasis zgbasis)
+   (if (not (equal (OMgetNextLabel s) "OMA"))
+      (error "The next label is not an application")
+      (progn 
+        (delete-if #'(lambda (item) t) s :start 0 :end (+ 5 (search "<OMA>" s)))
+        (if (not (equal (OMgetNextSymbol s) "zgterm"))
+           (error "This is not specified as a zgterm")
+           (progn 
+             (OMparseNextSymbol s)
+             (let* ((coeff (OMparseNextInteger s))
+                    (zggnrt (OMparseZggnrt s grbasis (funcall zgbasis degr))))
+                (delete-if #'(lambda (item) t) s :start 0 :end (+ 6 (search "</OMA>" s)))
+                (term-cmbn degr coeff zggnrt )))))))
+
+(defun OMparseZgcmbn (s degr grbasis grcmpr zgbasis zgcmpr)
+   (if (equal (subseq (OMgetNextLabel s) 0 3) "!--")
+      (delete-if #'(lambda (item) t) s :start 0 :end (+ 4 (search "--/>" s))))
+   (if (not (equal (OMgetNextLabel s) "OMA"))
+      (error "The next label is not an application")
+      (progn 
+        (delete-if #'(lambda (item) t) s :start 0 :end (+ 5 (search "<OMA>" s)))
+        (if (not (equal (OMgetNextSymbol s) "zgcombination"))
+           (error "This is not specified as a zgcombination")
+           (progn 
+             (OMparseNextSymbol s)
+             (let ((cmbn-list nil))
+                (do ((term-list nil  (push  (cons 1 nexttermcmbn) term-list)))
+                   ((equal (OMgetNextLabel s) "/OMA") (setf cmbn-list term-list) )
+                  (setf nexttermcmbn (OMparseZgterm s degr grbasis zgbasis))
+                  )
+                (delete-if #'(lambda (item) t) s :start 0 :end (+ 6 (search "</OMA>" s)))
+                (if cmbn-list
+                   (cmbn-cmbn (zggnrt-cmpr grcmpr zgcmpr) cmbn-list)
+                   (zero-cmbn degr))))))))
+
+(defun OMparseZgboundaryList (s grbasis grcmpr zgbasis zgcmpr maxdegr)
+   (if (equal (subseq (OMgetNextLabel s) 0 3) "!--")
+      (delete-if #'(lambda (item) t) s :start 0 :end (+ 4 (search "--/>" s))))
+   (if (not (equal (OMgetNextLabel s) "OMA"))
+      (error "The next label is not an application")
+      (progn 
+        (delete-if #'(lambda (item) t) s :start 0 :end (+ 5 (search "<OMA>" s)))
+        (if (not (equal (OMgetNextSymbol s) 'list))
+           (error "This is not specified as a list")
+           (progn 
+             (OMparseNextSymbol s)
+             (let ((rslt nil))
+                (dotimes (i maxdegr)
+                   (if (equal (subseq (OMgetNextLabel s) 0 3) "!--")
+                      (delete-if #'(lambda (item) t) s :start 0 :end (+ 4 (search "--/>" s))))
+                   (if (not (equal (OMgetNextLabel s) "OMA"))
+                      (error "The next label is not an application")
+                      (progn 
+                        (delete-if #'(lambda (item) t) s :start 0 :end (+ 5 (search "<OMA>" s)))
+                        (if (not (equal (OMgetNextSymbol s) 'list))
+                           (error "This is not specified as a list")
+                           (progn 
+                             (OMparseNextSymbol s)
+                             (let ((rslt-i nil))
+                                (do ((aux nil (push cmbn aux)))
+                                    ((equal (OMgetNextLabel s) "/OMA") (setf rslt-i aux))
+                                   (setf cmbn (OMparseZgcmbn s i grbasis grcmpr zgbasis zgcmpr)))
+                                (delete-if #'(lambda (item) t) s :start 0 :end (+ 6 (search "</OMA>" s)))
+                                (push (nreverse rslt-i) rslt)))))))
+                (delete-if #'(lambda (item) t) s :start 0 :end (+ 6 (search "</OMA>" s)))
+                (nreverse rslt)))))))
+                   
+
+(defun OMparseContractinghmtpList (s grbasis grcmpr zgbasis zgcmpr maxdegr)
+   (if (equal (subseq (OMgetNextLabel s) 0 3) "!--")
+      (delete-if #'(lambda (item) t) s :start 0 :end (+ 4 (search "--/>" s))))
+   (if (not (equal (OMgetNextLabel s) "OMA"))
+      (error "The next label is not an application")
+      (progn 
+        (delete-if #'(lambda (item) t) s :start 0 :end (+ 5 (search "<OMA>" s)))
+        (if (not (equal (OMgetNextSymbol s) 'list))
+           (error "This is not specified as a list")
+           (progn 
+             (OMparseNextSymbol s)
+             (let ((rslt nil))
+                (dotimes (i (1- maxdegr))
+                   (if (equal (subseq (OMgetNextLabel s) 0 3) "!--")
+                      (delete-if #'(lambda (item) t) s :start 0 :end (+ 4 (search "--/>" s))))
+                   (if (not (equal (OMgetNextLabel s) "OMA"))
+                      (error "The next label is not an application")
+                      (progn 
+                        (delete-if #'(lambda (item) t) s :start 0 :end (+ 5 (search "<OMA>" s)))
+                        (if (not (equal (OMgetNextSymbol s) 'list))
+                           (error "This is not specified as a list")
+                           (progn 
+                             (OMparseNextSymbol s)
+                             (let ((rslt-i nil))
+                                (do ((mark1 (funcall zgbasis i) (cdr mark1)))
+                                    ((endp mark1) (push (nreverse rslt-i) rslt))
+                                  (progn
+                                    (if (equal (subseq (OMgetNextLabel s) 0 3) "!--")
+                                       (delete-if #'(lambda (item) t) s :start 0 :end (+ 4 (search "--/>" s))))
+                                   (if (not (equal (OMgetNextLabel s) "OMA"))
+                                      (error "The next label is not an application")
+                                      (progn 
+                                        (delete-if #'(lambda (item) t) s :start 0 :end (+ 5 (search "<OMA>" s)))
+                                        (if (not (equal (OMgetNextSymbol s) 'list))
+                                           (error "This is not specified as a list")
+                                           (progn 
+                                             (OMparseNextSymbol s)
+                                             (let ((rslt-i-g nil))
+                                                
+                                                (do ((mark2 grbasis (cdr mark2)))
+                                                    ((endp mark2) (push (nreverse rslt-i-g) rslt-i))
+                                                   (setf cmbn (OMparseZgcmbn s (1+ i) grbasis grcmpr zgbasis zgcmpr))
+                                                   (push cmbn rslt-i-g))
+                                                (delete-if #'(lambda (item) t) s :start 0 :end (+ 6 (search "</OMA>" s)))
+                                                )))))))
+                                (delete-if #'(lambda (item) t) s :start 0 :end (+ 6 (search "</OMA>" s)))
+                                ))))))
+                (delete-if #'(lambda (item) t) s :start 0 :end (+ 6 (search "</OMA>" s)))
+                (nreverse rslt)))))))
+
+
+
+(defun OMrsltnZgbasis (rank-list maxdegr)
+   (flet ((rslt (degr)
+            (declare (fixnum degr))
+            (if (> degr maxdegr) (error "unknown basis for this degree")
+               (if (< degr 0) nil
+                  (let ((rank (nth degr rank-list))
+                        (list nil))
+                     (dotimes (i rank)
+                        (push (concatenate 'string "g" (Write-to-string degr) (Write-to-string (1+ i))) list))
+                     (nreverse list))))))
+     
+     (the basis #'rslt)))
+
+(defun OMrsltnZgboundary-intr (Zgboundary-list zgbasis maxdegr)
+   (flet ((rslt (degr gnrt)
+            (declare (fixnum degr) (type gnrt gnrt))
+            (if (> degr maxdegr) (error "unknown basis for this degree")
+               (if (< degr 1) (zero-cmbn (1- degr))
+                  (nth (position gnrt (funcall zgbasis degr)  :test #'equal) (nth (1- degr) Zgboundary-list))))))
+          (the intr-mrph #'rslt)))
+
+(defun OMrsltnCntrHmtp-intr (Zgcontractinghmtp-list zgbasis grbasis maxdegr)
+   (flet ((rslt (degr zggnrt)
+            (declare (fixnum degr) (type zggnrt zggnrt))
+            (if (> degr (1- maxdegr)) (error "unknown basis for this degree")
+               (with-zggnrt (gnrt1 gnrt2) zggnrt
+                 (let ((gnrt1-pos (position gnrt1 grbasis :test #'equal))
+                       (gnrt2-pos (position gnrt2 (funcall zgbasis degr) :test #'equal)))
+                    (nth gnrt1-pos (nth gnrt2-pos (nth degr Zgcontractinghmtp-list))))))))
+               (the intr-mrph #'rslt)))
+
+
+
+                             
+                             
+(defun OMparseResolution (s)
+   ;;(if (not (equal (OMgetNextLabel s) "OMA"))
+    ;;  (error "The next label is not an application")
+    ;;  (progn 
+    ;;    (delete-if #'(lambda (item) t) s :start 0 :end (+ 5 (search "<OMA>" s)))
+    ;;    (if (not (equal (OMgetNextSymbol s) "resolution"))
+    ;;       (error "This is not specified as a resolution")
+    ;;       (progn 
+    ;;         (OMparseNextSymbol s)
+             (let* ((group (OMparseNextObject s))
+                    (maxdegr (OMparseNextObject s))
+                    (rank-list (OMparseNextObject s))
+                    (zgbasis (OMrsltnZgbasis rank-list maxdegr)))
+                (with-slots ((grcmpr cmpr) (grbasis elements) nullel) group
+                  (let* ((zgboundary-list (OMparseZgboundaryList s grbasis grcmpr zgbasis #'s-cmpr maxdegr))
+                         (cntrchmtp-list (OMparseContractinghmtpList s grbasis grcmpr zgbasis #'s-cmpr maxdegr))
+                         (zgchcm (BUILD-ZGCHCM :group group :zgcmpr #'s-cmpr :zgbasis zgbasis :zgbsgn "g00" 
+                                   :intr-zgbndr (OMrsltnZgboundary-intr Zgboundary-list zgbasis maxdegr)
+                                   :zgbndr-strt :gnrt :orgn  `(ZG-Chain complex for ,group obtained from HAP)))
+                         (cmpr (cmpr1 zgchcm))
+                         (f-intr #'(lambda (degr zggnrt)
+                                     (if (zerop degr) (cmbn degr 1 :zgnrt) (zero-cmbn degr))))
+                         (g-intr #'(lambda (degr gnrt)
+                                     (if (zerop degr) (cmbn degr 1 (zggnrt nullel "g01")) (zero-cmbn degr))))
+                         (h-intr (OMrsltnCntrHmtp-intr cntrchmtp-list zgbasis grbasis maxdegr))
+
+                         (f (build-mrph :sorc zgchcm :trgt (z-chcm) :degr 0 :intr f-intr :strt :gnrt :orgn `(f-mrph for ,group obtained from HAP)))
+                         (g (build-mrph :sorc (z-chcm) :trgt zgchcm :degr 0 :intr g-intr :strt :gnrt :orgn  `(g-mrph for ,group obtained from HAP)))
+                         (h (build-mrph :sorc zgchcm :trgt zgchcm :degr 1 :intr h-intr :strt :gnrt :orgn `(h-mrph for ,group obtained from HAP))))
+                     (delete-if #'(lambda (item) t) s :start 0 :end (+ 6 (search "</OMA>" s)))
+                     (build-rdct :f f :g g :h h :orgn `(Resolution of ,group obtained from HAP))))))
+;;;))))
+                       
+(defun FileToString (FileName)
+     (with-open-file (f FileName :direction :input)
+       (labels ((getString (f s)
+                 (let* ((aux (read-line f nil 'EOF)))
+                    (if (not (string= aux 'EOF))
+                       (getString f (concatenate 'string s (if (not (string= s "")) (format nil "~%")) aux)) 
+                       s))))
+       (getString f ""))))
+
+                             
+
+#|
+
+
+
+   
+
+(cat-init)
+(load "omparsers.lisp")
+(setf s (filetostring "resolution.log")) 
+(setf rsltn1 (OmparseNextObject s))
+(setf group (group1 (tcc rsltn1)))
+(setf (slot-value group 'resolution) rsltn1)
+(setf k-g-1 (k-g-1 group))
+(setf k-g-2 (k-g group 2))
+(setf k-g-3 (k-g group 3))
+
+(homology k-g-1 0 6)
+(homology k-g-2 0 6)
+(homology k-g-3 0 6)
+
+
+
+(if (equal (OMgetNextLabel s) "OMOBJ")
+        (delete-if #'(lambda (item) t) s :start 0 :end (+ 7 (search "<OMOBJ>" s))))
+   
+     (if (equal (subseq (OMgetNextLabel s) 0 3) "!--")
+        (delete-if #'(lambda (item) t) s :start 0 :end (+ 4 (search "--/>" s))))
+
+
+(if (not (equal (OMgetNextLabel s) "OMA"))
+      (error "The next label is not an application"))
+(delete-if #'(lambda (item) t) s :start 0 :end (+ 5 (search "<OMA>" s)))
+(if (not (equal (OMgetNextSymbol s) "resolution"))
+   (error "This is not specified as a resolution"))
+
+(OMparseNextSymbol s)
+
+(setf group (OMparseNextObject s))
+(setf maxdegr (OMparseNextObject s))
+(setf rank-list (OMparseNextObject s))
+(setf zgbasis (OMrsltnZgbasis rank-list maxdegr))
+
+(setf grcmpr (cmpr1 group) grbasis (elements group) nullel (nullel group))
+(setf zgcmpr #'s-cmpr)
+(setf zgboundary-list (OMparseZgboundaryList s grbasis grcmpr zgbasis #'s-cmpr maxdegr))
+;;(setf cntrchmtp-list (OMparseContractinghmtpList s grbasis grcmpr zgbasis #'s-cmpr maxdegr))                                  
+                         
+(if (not (equal (OMgetNextLabel s) "OMA"))
+      (error "The next label is not an application"))
+
+(delete-if #'(lambda (item) t) s :start 0 :end (+ 5 (search "<OMA>" s)))
+
+(if (not (equal (OMgetNextSymbol s) 'list))
+           (error "This is not specified as a list"))
+(OMparseNextSymbol s)
+
+(setf rslt nil)
+
+(setf i 0)
+(if (not (equal (OMgetNextLabel s) "OMA"))
+                      (error "The next label is not an application"))
+(delete-if #'(lambda (item) t) s :start 0 :end (+ 5 (search "<OMA>" s)))
+(OMparseNextSymbol s)
+(setf rslt-i nil)  
+
+(setf mark1 zgbasis)
+
+
+                (dotimes (i maxdegr)
+                   (if (not (equal (OMgetNextLabel s) "OMA"))
+                      (error "The next label is not an application")
+                      (progn 
+                        (delete-if #'(lambda (item) t) s :start 0 :end (+ 5 (search "<OMA>" s)))
+                        (if (not (equal (OMgetNextSymbol s) 'list))
+                           (error "This is not specified as a list")
+                           (progn 
+                             (OMparseNextSymbol s)
+                             (let ((rslt-i nil))
+                                (do ((mark1 (funcall zgbasis (1+ i)) (cdr mark1)))
+                                    ((endp mark1) (push rslt-i rslt))
+                                    
+                                   (if (not (equal (OMgetNextLabel s) "OMA"))
+                                      (error "The next label is not an application")
+                                      (progn 
+                                        (delete-if #'(lambda (item) t) s :start 0 :end (+ 5 (search "<OMA>" s)))
+                                        (if (not (equal (OMgetNextSymbol s) 'list))
+                                           (error "This is not specified as a list")
+                                           (progn 
+                                             (OMparseNextSymbol s)
+                                             (let ((rslt-i-g nil))
+                                                
+                                                (do ((mark2 grbasis (cdr mark2)))
+                                                    ((endp mark2) (push rslt-i-g rslt-i))
+                                                   (setf cmbn (OMparseZgcmbn s (1+ i) grbasis grcmpr zgbasis zgcmpr))
+                                                   (push cmbn rslt-i-g))
+                                                (delete-if #'(lambda (item) t) s :start 0 :end (+ 6 (search "</OMA>" s)))
+                                                ))))))
+                                (delete-if #'(lambda (item) t) s :start 0 :end (+ 6 (search "</OMA>" s)))
+                                ))))))
+                (delete-if #'(lambda (item) t) s :start 0 :end (+ 6 (search "</OMA>" s)))
+                rslt)))))
+
+
+
+|# 
+
+
+
+
+
+
+
diff --git a/examples/anromero/suspended-classifying-spaces-lisp-files/cylinders.cl b/examples/anromero/suspended-classifying-spaces-lisp-files/cylinders.cl
new file mode 100644
index 0000000..73d8b3c
--- /dev/null
+++ b/examples/anromero/suspended-classifying-spaces-lisp-files/cylinders.cl
@@ -0,0 +1,454 @@
+;;;  CYLIDERS  CYLIDERS  CYLIDERS  CYLIDERS  CYLIDERS  CYLIDERS  CYLIDERS  
+;;;  CYLIDERS  CYLIDERS  CYLIDERS  CYLIDERS  CYLIDERS  CYLIDERS  CYLIDERS 
+;;;  CYLIDERS  CYLIDERS  CYLIDERS  CYLIDERS  CYLIDERS  CYLIDERS  CYLIDERS 
+
+(IN-PACKAGE "COMMON-LISP-USER")
+
+(PROVIDE "CYCLINDERS")
+
+
+;; MACROS
+
+(DEFMACRO CYLNX (CYLN)
+   `(car ,CYLN))
+
+(DEFMACRO ICYLN (CYLN)
+   `(cdr ,CYLN))
+
+(DEFMACRO CYLNA1 (gnrt)
+   `(cons :CYLNA1 ,gnrt))
+
+(DEFMACRO CYLNB (gnrt)
+   `(cons :CYLNB ,gnrt))
+
+(DEFMACRO CYLNA2 (gnrt)
+   `(cons :CYLNA2 ,gnrt))
+
+(DEFMACRO WITH-CYLN ((CYLNx iCYLN) CYLN . body)
+   `(let ((,CYLNx (CYLNx ,CYLN))
+          (,iCYLN (iCYLN ,CYLN)))
+       (declare
+          (type (member :CYLNA1 :CYLNB :CYLNA2) ,CYLNx)
+          (type gnrt ,iCYLN))
+       ,@body))
+
+
+(DEFUN DISPATCH-CYLN-CMBN (cmbn)
+   (declare (type cmbn cmbn))
+   (the (values cmbn cmbn cmbn)
+      (with-cmbn (degr list) cmbn
+         (let ((listA1 +empty-list+)
+               (listB +empty-list+)
+               (listA2 +empty-list+))
+            (declare (list listA1 listB listA2))
+            (dolist (term list)
+               (declare (type term term))
+               (with-term (cffc cyln) term
+                  (with-cyln (cylnx icyln) cyln
+                     (ecase cylnx
+                        (:cylnA1 (push (term cffc icyln) listA1))
+                        (:cylnB (push (term cffc icyln) listB))
+                        (:cylnA2 (push (term cffc icyln) listA2))))))
+            (values
+               (make-cmbn :degr (1- degr) :list (nreverse listA1))
+               (make-cmbn :degr degr :list (nreverse listB))
+               (make-cmbn :degr degr :list (nreverse listA2)))))))
+
+#|
+  (dispatch-CYLN-cmbn (cmbn 3 3 (cylnA1 'a11) 4 (cylnA1 'a12) 33 (cylnB 'b) 333 (cylnA2 'a2)))
+|#
+
+(DEFUN CYLN-CMBN-CMBNA1 (cmbn)
+   (declare (type cmbn cmbn))
+   (the cmbn
+      (with-cmbn (degr list) cmbn
+         (make-cmbn :degr (1- degr)
+            :list (do ((rslt +empty-list+)
+                       (mark list (cdr mark)))
+                      ((endp mark) (nreverse rslt))
+                     (declare (list rslt mark))
+                     (with--term (cffc CYLN) mark
+                     (with-CYLN (CYLNx gnrtA1) CYLN
+                        (if (eq CYLNx :CYLNA1)
+                           (push (term cffc gnrtA1) rslt)
+                           (return (nreverse rslt))))))))))
+
+(DEFUN CYLN-CMBN-CMBNB (cmbn)
+   (declare (type cmbn cmbn))
+   (the cmbn
+      (with-cmbn (degr list) cmbn
+         (make-cmbn :degr degr
+            :list (do ((rslt +empty-list+)
+                       (mark (member :CYLNb list :key #'cadr) (cdr mark)))
+                      ((endp mark) (nreverse rslt))
+                     (declare (list rslt mark))
+                     (with--term (cffc CYLN) mark
+                     (with-CYLN (CYLNx gnrtB) CYLN
+                        (if (eq CYLNx :CYLNB)
+                           (push (term cffc gnrtB) rslt)
+                           (return (nreverse rslt))))))))))
+
+(DEFUN CYLN-CMBN-CMBNA2 (cmbn)
+   (declare (type cmbn cmbn))
+   (the cmbn
+      (with-cmbn (degr list) cmbn
+         (make-cmbn :degr degr
+            :list (mapcar
+                     #'(lambda (term)
+                          (declare (type term term))
+                          (with-term (cffc CYLN) term
+                             (term cffc (iCYLN CYLN))))
+                     (member :CYLNA2 list :key #'cadr))))))
+
+#|
+ 
+  (CYLN-cmbn-cmbnA1 (cmbn 3 1 (CYLNA1 'a) 2 (CYLNB 'b)))
+  (CYLN-cmbn-cmbnA1 (cmbn 3 2 (CYLNB 'b)))
+  (CYLN-cmbn-cmbnB (cmbn 3 1 (CYLNA1 'a) 2 (CYLNB 'b) 3 (CYLNA2 'c)))
+  (CYLN-cmbn-cmbnB (cmbn 3 1 (CYLNA1 'a) 3 (CYLNA2 'c)))
+  (CYLN-cmbn-cmbnA2 (cmbn 3 1 (CYLNA1 'a) 2 (CYLNB 'b) 3 (CYLNA2 'c)))
+  (CYLN-cmbn-cmbnA2 (cmbn 3 2 (CYLNA1 'b)))
+|#
+
+(DEFUN MAKE-CYLN-CMBN (cmbnA1 cmbnB cmbnA2)
+   (declare (type cmbn cmbnA1 cmbnB cmbnA2))
+   (the cmbn
+      (with-cmbn (degrA1 listA1) cmbnA1
+      (with-cmbn (degrB listB) cmbnB
+      (with-cmbn (degrA2 listA2) cmbnA2
+         (unless (= (1+ degrA1) degrB degrA2)
+            (error "In MAKE-CYLN-CMBN, the degrees are not coherent."))
+         (make-cmbn :degr degrB
+            :list (nconc
+                     (mapcar #'(lambda (termA1)
+                                  (declare (type term termA1))
+                                  (with-term (cffc gnrtA1) termA1
+                                     (term cffc (CYLNA1 gnrtA1))))
+                        listA1)
+                     (mapcar #'(lambda (termB)
+                                  (declare (type term termB))
+                                  (with-term (cffc gnrtB) termB
+                                     (term cffc (CYLNB gnrtB))))
+                        listB)
+                     (mapcar #'(lambda (termA2)
+                                  (declare (type term termA2))
+                                  (with-term (cffc gnrtA2) termA2
+                                     (term cffc (CYLNA2 gnrtA2))))
+                        listA2))))))))
+
+#|
+  (multiple-value-call #'make-CYLN-cmbn 
+     (dispatch-CYLN-cmbn (cmbn 3 3 (CYLNA1 'A11) 4 (CYLNA1 'A12) 33 (CYLNB 'B) 333 (CYLNA2 'A2))))
+|#
+
+(DEFMETHOD PRINT-KEYCONS ((car (eql :CYLNA1)) cdr stream)
+   (declare
+      (type gnrt cdr)
+      (stream stream))
+   (the (eql t)
+      (progn
+         (format stream "<CylnA1 ~A>" cdr)
+         t)))
+
+(DEFMETHOD PRINT-KEYCONS ((car (eql :CYLNB)) cdr stream)
+   (declare
+      (type gnrt cdr)
+      (stream stream))
+   (the (eql t)
+      (progn
+         (format stream "<CylnB ~A>" cdr)
+         t)))
+
+(DEFMETHOD PRINT-KEYCONS ((car (eql :CYLNA2)) cdr stream)
+   (declare
+      (type gnrt cdr)
+      (stream stream))
+   (the (eql t)
+      (progn
+         (format stream "<CylnA2 ~A>" cdr)
+         t)))
+
+#|
+  (CYLNa1 'a)
+  (CYLNB 'b)
+  (CYLNA2 'c)
+|#
+
+(DEFUN cylnX-CMPR (s1 s2)
+   (declare (symbol s1 s2))
+   (the cmpr
+      (if (string= s1 s2) :equal
+         (if (string= s1 :cylnA1) :less
+            (if (string= s2 :cylnA1) :greater
+               (if (string= s1 :cylnB) :less
+                  :greater))))))
+         
+
+(DEFUN CYLINDER-CMPR (cmprA cmprB)
+   (declare (type cmprf cmpra cmprb))
+   (flet ((rslt (cyln1 cyln2)
+             (declare (type cyln cyln1 cyln2))
+             (let ((cylnx1 (cylnx cyln1)))
+                (declare (type (member :cylnA1 :cylnB :cylnA2) cylnx))
+                (lexico
+                   (cylnX-CMPR cylnx1 (cylnx cyln2))
+                   (case cylnx1
+                      (:cylnA1 (funcall cmprA (icyln cyln1) (icyln cyln2)))
+                      (:cylnB (funcall cmprB (icyln cyln1) (icyln cyln2)))
+                      (:cylnA2 (funcall cmprA (icyln cyln1) (icyln cyln2))))))))
+      (the cmprf #'rslt)))
+
+#|
+  (setf r (cylinder-cmpr #'f-cmpr #'f-cmpr ))
+  (funcall r (cylnA1 1) (cylnB 0))
+  (funcall r (cylnA1 1) (cylnA1 2))
+  (funcall r (cylnB 0) (cylnA1 1))
+  (funcall r (cylnA1 2) (cylnA1 1)) 
+|#
+
+(DEFUN CYLINDER-BASIS (basisA basisB)
+   (declare (type basis basisA basisB))
+   (the basis
+      (if (or (eq :locally-effective basisA)
+              (eq :locally-effective basisB)
+              )
+         :locally-effective
+         (flet ((rslt (degr)
+                   (declare (fixnum degr))
+                   (append
+                      (mapcar #'(lambda (item)
+                                   (declare (type gnrt item))
+                                   (cylnA1 item))
+                         (funcall basisA (1- degr)))
+                      (mapcar #'(lambda (item)
+                                   (declare (type gnrt item))
+                                   (cylnB item))
+                         (funcall basisB degr))
+                      (mapcar #'(lambda (item)
+                                   (declare (type gnrt item))
+                                   (cylnA2 item))
+                         (funcall basisA degr)))))
+            (the basis #'rslt)))))
+
+#|
+  (CYLINDER-basis :locally-effective :locally-effective )
+  (setf b #'(lambda (degr) (mapcar #'(lambda (item) (cons degr item)) (<a-b> 0 degr))))
+  (setf r (CYLINDER-basis b b))
+  (funcall r 3)
+|#
+
+(DEFUN CYLINDER-INTR-DFFR (cmprA cmprB dffrA dffrB f)
+   (declare
+      (type cmprf cmprA cmprB)
+      (type morphism dffrA dffrB f))
+   (flet ((rslt (cmbn)
+             (declare (type cmbn cmbn))
+             (the cmbn
+                (multiple-value-bind (cmbnA1 cmbnB cmbnA2) (dispatch-cyln-cmbn cmbn)
+                   (declare (type cmbn cmbnA1 cmbnB cmbnA2))
+                   (let ((dffrA1-cmbn (cmbn-? dffrA cmbnA1))
+                         (dffrB-cmbn (cmbn-? dffrB cmbnB))
+                         (dffrA2-cmbn (cmbn-? dffrA cmbnA2))
+                         (f-cmbn (cmbn-? f cmbnA1))
+                         )
+                      (declare (type cmbn dffrA1-cmbn dffrB-cmbn dffrA2-cmbn f-cmbn))
+                      (let ((cmbnB (2cmbn-add cmprB f-cmbn dffrB-cmbn))
+                            (cmbnA2 (2cmbn-sbtr cmprA dffrA2-cmbn cmbnA1)))
+                         (declare (type cmbn cmbnB cmbnA2))
+                         (make-cyln-cmbn (cmbn-opps dffrA1-cmbn) cmbnB cmbnA2)))))))
+      (the intr-mrph #'rslt)))
+
+
+(DEFUN CYLINDER (f)
+   (declare (type morphism f))
+   (the chain-complex
+     (with-slots (sorc trgt) f
+       (declare
+        (type chain-complex sorc trgt ))
+       (let ((rslt (build-chcm
+                    :cmpr (cylinder-cmpr (cmpr sorc) (cmpr trgt))
+                    :basis (cylinder-basis (basis sorc) (basis trgt))
+                    :bsgn :undefined
+                    :intr-dffr (cylinder-intr-dffr (cmpr sorc) (cmpr trgt)
+                                     (dffr sorc) (dffr trgt) f)
+                    :strt :cmbn
+                    :orgn `(cylinder ,f))))
+          (declare (type chain-complex rslt))
+          (slot-makunbound rslt 'bsgn)
+          rslt))))
+
+
+
+
+
+(defun cylinder-rrdct (f)
+   (declare (type morphism f))
+   (the reduction
+     (with-slots (sorc (Bcc trgt)) f
+       (with-slots ((cmprb cmpr)) Bcc
+         (let ((cylinder (cylinder f)))
+            (let ((rf (build-mrph
+                       :sorc cylinder :trgt Bcc :degr 0
+                       :intr #'(lambda (cmbn)
+                                 (declare (type cmbn cmbn))
+                                 (2cmbn-add cmprB (cyln-cmbn-cmbnB cmbn) (cmbn-? f (cyln-cmbn-cmbnA2 cmbn))))
+                       :strt :cmbn
+                       :orgn `(cylinder ,f rf)))
+                  (rg (build-mrph
+                       :sorc Bcc :trgt cylinder :degr 0
+                       :intr #'(lambda (cmbn)
+                                 (declare (type cmbn cmbn))
+                                 (let* ((cmbnA1 (zero-cmbn (1- (cmbn-degr cmbn))))
+                                        (cmbnA2 (zero-cmbn (cmbn-degr cmbn))))
+                                    (declare (type cmbn cmbnA1 cmbnA2))
+                                    (make-cyln-cmbn cmbnA1 cmbn cmbnA2)))
+                       :strt :cmbn
+                       :orgn `(cylinder ,f rg)))
+                  (rh (build-mrph
+                       :sorc cylinder :trgt cylinder :degr +1
+                       :intr #'(lambda (cmbn)
+                                 (declare (type cmbn cmbn))
+                                 (let* ((cmbnA1 (cmbn-opps (cyln-cmbn-cmbnA2 cmbn)))
+                                        (cmbnB (zero-cmbn (1+ (cmbn-degr cmbn))))
+                                        (cmbnA2 (zero-cmbn (1+ (cmbn-degr cmbn)))))
+                                    (declare (type cmbn cmbnA1 cmbnB cmbnA2))
+                                    (make-cyln-cmbn cmbnA1 cmbnB cmbnA2)))
+                       :strt :cmbn
+                       :orgn `(cylinder ,f rh))))
+               (declare
+                (type chain-complex cylinder)
+                (type morphism rf rg rh))
+               (build-rdct :f rf :g rg :h rh :orgn `(cylinder right reduction ,f))))))))
+
+
+(defun cylinder-lrdct (f g h k)
+   (declare (type morphism f g h k))
+   (the reduction
+     (with-slots ((Acc sorc) (Bcc trgt)) f
+       (with-slots ((cmprA cmpr)) Acc
+         (with-slots ((cmprb cmpr)) Bcc
+           (let ((cylinder (cylinder f)))
+              (let ((lf (build-mrph
+                         :sorc cylinder :trgt Acc :degr 0
+                         :intr #'(lambda (cmbn)
+                                   (declare (type cmbn cmbn))
+                                   (2cmbn-sbtr cmprA 
+                                     (2cmbn-add cmpra (cyln-cmbn-cmbnA2 cmbn) (cmbn-? g (cyln-cmbn-cmbnB cmbn)))
+                                     (cmbn-? h (cyln-cmbn-cmbnA1 cmbn))))
+                         :strt :cmbn
+                         :orgn `(cylinder hmtpeq ,f lf)))
+                    (lg (build-mrph
+                         :sorc Acc :trgt cylinder :degr 0
+                         :intr #'(lambda (cmbn)
+                                   (declare (type cmbn cmbn))
+                                   (let* ((cmbnA1 (zero-cmbn (1- (cmbn-degr cmbn))))
+                                          (cmbnB (zero-cmbn (cmbn-degr cmbn)))
+                                          )
+                                      (declare (type cmbn cmbnA1 cmbnB ))
+                                      (make-cyln-cmbn cmbnA1 cmbnB cmbn)))
+                         :strt :cmbn
+                         :orgn `(cylinder hmtpeq ,f lg)))
+                    (lh (build-mrph
+                         :sorc cylinder :trgt cylinder :degr +1
+                         :intr #'(lambda (cmbn)
+                                   (declare (type cmbn cmbn))
+                                   (multiple-value-bind (cmbnA1 cmbnB cmbnA2) 
+                                       (dispatch-cyln-cmbn cmbn)
+                                      (let* ((cmbnA11 (cmbn-opps (cmbn-? h cmbnA1)))
+                                             (cmbnA12 (cmbn-opps (cmbn-? g (cmbn-? k (cmbn-? f cmbnA1)))))
+                                             (cmbnA13 (cmbn-? g (cmbn-? f (cmbn-? h cmbnA1))))
+                                             (cmbnA14 (cmbn-? g cmbnB))
+                                             (cmbnB1 (cmbn-opps (cmbn-? k (cmbn-? k (cmbn-? f cmbnA1)))))
+                                             (cmbnB2 (cmbn-? k (cmbn-? f (cmbn-? h cmbnA1))))
+                                             (cmbnB3 (cmbn-? k cmbnB))
+                                             (cmbnA21 (cmbn-opps (cmbn-? h (cmbn-? h cmbnA1))))
+                                             (cmbnA22 (cmbn-opps (cmbn-? h (cmbn-? g (cmbn-? k (cmbn-? f cmbnA1))))))
+                                             (cmbnA23 (cmbn-? h (cmbn-? g (cmbn-? f (cmbn-? h cmbnA1)))))
+                                             (cmbnA24 (cmbn-? g (cmbn-? k (cmbn-? k (cmbn-? f cmbnA1)))))
+                                             (cmbnA25 (cmbn-opps (cmbn-? g (cmbn-? k (cmbn-? f (cmbn-? h cmbnA1))))))
+                                             (cmbnA26 (cmbn-? h (cmbn-? g cmbnB)))
+                                             (cmbnA27 (cmbn-opps (cmbn-? g (cmbn-? k cmbnB)))))
+                                         (declare (type cmbn cmbnA11 cmbnA12 cmbnA13 cmbnA14
+                                                    cmbnB1 cmbnB2 cmbnB3 
+                                                    cmbnA21 cmbnA22 cmbnA23 cmbnA24 cmbnA25 cmbnA26 cmbnA27))
+                                         (make-cyln-cmbn (ncmbn-add cmprA cmbnA11 cmbnA12 cmbnA13 cmbnA14)
+                                     (ncmbn-add cmprB cmbnB1 cmbnB2 cmbnB3)
+                                     (ncmbn-add cmprA cmbnA21 cmbnA22 cmbnA23 cmbnA24 cmbnA25 cmbnA26 cmbnA27)))))
+                                     
+                         :strt :cmbn
+                         :orgn `(cylinder hmtpeq ,f lh))))
+            (declare
+                     (type chain-complex cylinder)
+                     (type morphism lf lg lh))
+            (build-rdct :f lf :g lg :h lh :orgn `(cylinder left reduction ,f)))))))))
+
+
+#|
+ (cat-init) 
+ (setf z3 (cyclicgroup 3))
+ 
+ (setf rsltn1 (cyclicgroup-rsltn 3))
+ (setf rsltn2 (bar-rsltn z3))
+ (setf f (zgmrph-twi (2rsltn-zgmrph rsltn1 rsltn2)))
+ (setf g (zgmrph-twi (2rsltn-zgmrph rsltn2 rsltn1)))
+ (setf h (zgmrph-twi (2rsltn-hmtpop rsltn1 rsltn2)))
+ (setf k (zgmrph-twi (2rsltn-hmtpop rsltn2 rsltn1)))
+ (setf Acc (sorc f) Bcc (trgt f))
+
+
+ (setf rrdct (cylinder-rrdct f))
+ (setf lrdct (cylinder-lrdct f g h k))
+
+ (setf lf (f lrdct) lg (g lrdct) lh (h lrdct))
+ (setf rf (f rrdct) rg (g rrdct) rh (h rrdct))
+
+ (pre-check-rdct rrdct)
+ (setf *tc* (cmbn 3 1 (cylnA1 2) 10 (cylnB '(1 2 1)) 100 (cylnA2 3)))
+ (setf *bc* (cmbn 3 1 '(1 1 2)))
+ (check-rdct)
+ (setf *tc* (cmbn 4 10 (cylnB '(1 2 1 1)) 5 (cylnB '(1 2 2 1)) 100 (cylnA2 4)))
+ (setf *bc* (cmbn 2 5 '(1 1) 7 '(2 1) -4 '(2 2)))
+ (check-rdct)
+
+
+ (pre-check-rdct lrdct)
+
+ (setf *tc* (cmbn 3 1 (cylnA1 2) 10 (cylnB '(1 2 1)) 100 (cylnA2 3)))
+ (setf *bc* (cmbn 3 1 3))
+ (check-rdct)
+
+ (setf *tc* (cmbn 4 10 (cylnB '(1 2 1 1)) 5 (cylnB '(1 2 2 1)) 100 (cylnA2 4)))
+ (setf *bc* (cmbn 2 1 2))
+ (check-rdct)
+|#
+
+
+ (DEFMETHOD SEARCH-EFHM (smst (orgn (eql 'k-g-1)))
+   (declare (type simplicial-group smst))
+   (the homotopy-equivalence
+    (let* ((group (second (orgn smst)))
+           (rsltn1 (bar-rsltn group))
+           (rsltn2 (resolution group))
+           (f (zgmrph-twi (2rsltn-zgmrph rsltn1 rsltn2)))
+           (g (zgmrph-twi (2rsltn-zgmrph rsltn2 rsltn1)))
+           (h (zgmrph-twi (2rsltn-hmtpop rsltn1 rsltn2)))
+           (k (zgmrph-twi (2rsltn-hmtpop rsltn2 rsltn1)))
+           (rrdct (cylinder-rrdct f))
+           (lrdct (cylinder-lrdct f g h k)))
+       (build-hmeq :lrdct lrdct :rrdct rrdct :orgn `(efhm of ,smst)))))
+
+ #|
+ (setf z3 (cyclicgroup 3))
+ (setf k-z3-1 (k-g-1 z3))
+
+ (cat-init)
+ (setf z4 (cyclicgroup 4))
+ (setf k-z4-1 (k-g-1 z4))
+ (setf k-z4-2 (classifying-space k-z4-1))
+
+ (cat-init)
+ (setf z2 (cyclicgroup 2))
+ (setf k-z2-1 (k-g-1 z2))
+ (setf k-z2-2 (classifying-space k-z2-1))
+ |#
+        
diff --git a/examples/anromero/suspended-classifying-spaces-lisp-files/fundamental-classes.cl b/examples/anromero/suspended-classifying-spaces-lisp-files/fundamental-classes.cl
new file mode 100644
index 0000000..b6fdd6e
--- /dev/null
+++ b/examples/anromero/suspended-classifying-spaces-lisp-files/fundamental-classes.cl
@@ -0,0 +1,173 @@
+;; Fundamental classes
+(IN-PACKAGE "COMMON-LISP-USER")
+
+
+(DEFUN Zp-FUNDAMENTAL-GMSM (p dmns pi-elm)  ;; pi-elm not "equal" to 0
+   (declare (fixnum dmns pi-elm))
+   (the gmsm
+      (if (= 1 dmns)
+         (list pi-elm)
+         (let ((bspn (if (= 2 dmns) nil +null-gbar+)))
+            (declare (type gmsm bspn))
+            (make-gbar :dmns dmns
+               :list (cons (absm 0 (Zp-fundamental-gmsm p (1- dmns) pi-elm))
+                        (mapcar
+                           #'(lambda (k)
+                                (declare (fixnum k))
+                                (absm (mask k) bspn))
+                           (nreverse (<a-b> 0 (- dmns 2))))))))))
+#|
+
+  (Zp-fundamental-gmsm 2 1 1)
+  (Zp-fundamental-gmsm 2 2 1)
+  (Zp-fundamental-gmsm 2 3 1)
+  (Zp-fundamental-gmsm 2 4 1) 
+
+  (Zp-fundamental-gmsm 5 1 1)
+  (Zp-fundamental-gmsm 5 4 1)
+  
+|#
+
+
+(DEFUN Zp-COCYCLE-GBAR (p n dmns cocycle)
+  ;; cocycle \in Z^n(\Delta^{dmns}, \pi) with \pi = Z/pZ
+  (declare
+    (fixnum p n dmns)
+    (list cocycle))
+  (the absm
+    (progn
+      (mapc
+        #'(lambda (cons)
+	    (declare (cons cons))
+            (setf (cdr cons)
+                  (mod (cdr cons) p)))
+       cocycle)
+      (cond ((= n 1)
+	     (g-bar-absm (cyclicgroup p) (nreverse (mapcar #'cdr cocycle))))
+	    ((= n dmns)
+	     (let ((value (cdr (first cocycle))))
+	       (declare (fixnum value))
+	       (if (zerop value)
+		   (absm (mask dmns) +null-gbar+)
+		 (absm 0 (zp-fundamental-gmsm p dmns value)))))
+	    (t
+	     (let ((cocycle1 +empty-list+)
+		   (cocycle2 +empty-list+))
+	       (declare (list cocycle1 cocycle2))
+	       (dolist (cons cocycle)
+		 (declare (cons cons))
+		 (if (evenp (car cons))
+		     (push (cons (ash (car cons) -1) (cdr cons))
+			   cocycle1)
+		   (push (cons (ash (car cons) -1) (cdr cons))
+			 cocycle2)))
+	       (setf cocycle1 (nreverse cocycle1)
+		     cocycle2 (nreverse cocycle2))
+	       (mapc
+		#'(lambda (cons)
+		    (declare (cons cons))
+		    (when (evenp (car cons))
+			  (setf (cdr cons)
+				(mod (- (cdr cons)
+					(cdr (assoc (1+ (car cons)) cocycle1)))
+				     p))))
+		cocycle2)
+	       (let ((head-absm (zp-cocycle-gbar p (1- n) (1- dmns) cocycle2))
+		     (tail-absm (zp-cocycle-gbar p n (1- dmns) cocycle1)))
+		 (declare (type absm head-absm tail-absm))
+		 (normalize-gbar
+		  (cons dmns
+			(cons head-absm
+			      (rest (unnormalize-gbar tail-absm
+						      (if (= n 2) () +null-gbar+)))))))))))))
+
+
+(DEFUN Zp-COCYCLE-GBAR-HEAD (p n dmns cocycle)
+  ;; cocycle \in Z^n(\Delta^{dmns}, \pi) with \pi = Z/pZ
+  (declare
+    (fixnum n dmns)
+    (list cocycle))
+  (the absm
+    (progn
+      (mapc
+        #'(lambda (cons)
+	    (declare (cons cons))
+            (setf (cdr cons)
+                  (mod (cdr cons) p)))
+       cocycle)
+      (cond ((= n 1)
+	     (error "In Zp-COCYCLE-GBAR-HEAD, this point should not have been reached."))
+		 ; (zp-bar-absm (nreverse (mapcar #'cdr cocycle))))
+	    ((= n dmns)
+	     (let ((value (cdr (first cocycle))))
+	       (declare (fixnum value))
+	       (if (zerop value)
+		   (if (= n 2)
+		       (absm 1 +empty-list+)
+		     (absm (mask (1- dmns)) +null-gbar+))
+		 (absm 0 (zp-fundamental-gmsm p (1- dmns) value)))))
+	    (t
+	     (let ((cocycle1 +empty-list+)
+		   (cocycle2 +empty-list+))
+	       (declare (list cocycle1 cocycle2))
+	       (dolist (cons cocycle)
+		 (declare (cons cons))
+		 (if (evenp (car cons))
+		     (push (cons (ash (car cons) -1) (cdr cons))
+			   cocycle1)
+		   (push (cons (ash (car cons) -1) (cdr cons))
+			 cocycle2)))
+	       (setf cocycle1 (nreverse cocycle1)
+		     cocycle2 (nreverse cocycle2))
+	       (mapc
+		#'(lambda (cons)
+		    (declare (cons cons))
+		    (when (evenp (car cons))
+			  (setf (cdr cons)
+				(mod (- (cdr cons)
+					(cdr (assoc (1+ (car cons)) cocycle1)))
+				     p))))
+		cocycle2)
+	       (zp-cocycle-gbar p (1- n) (1- dmns) cocycle2)))))))
+
+
+
+
+
+(DEFUN Zp-WHITEHEAD-SINTR (p smst n chml-clss
+				&aux (face (face smst))
+				     (k-zp-n-1 (k-zp p (1- n)))
+				     (idnt (bspn k-zp-n-1))
+				     (efhm (efhm smst)))
+   (declare
+      (type simplicial-set smst)
+      (fixnum n)
+      (type morphism chml-clss)
+      (type face face)
+      (type ab-simplicial-group k-zp-n-1)
+      (type gmsm idnt)
+      (type homotopy-equivalence efhm))
+   (setf chml-clss
+	 (i-cmps chml-clss (rf efhm) (lg efhm)))
+   (flet ((rslt (dmns gmsm)
+	    (declare
+	      (fixnum dmns)
+	      (type gmsm gmsm))
+	    (if (< dmns n)
+	        (absm (mask (1- dmns)) idnt)
+	      (zp-cocycle-gbar-head p n dmns
+		(gmsm-cocycle face n dmns gmsm chml-clss)))))
+     (the sintr #'rslt)))
+
+(DEFUN Zp-WHITEHEAD (p smst chml-clss &aux (n (- (degr chml-clss))))
+   (declare
+      (type simplicial-set smst)
+      (fixnum p n)
+      (type morphism chml-clss))
+   (the fibration
+      (build-smmr
+         :sorc smst :trgt (k-zp p (1- n)) :degr -1
+         :sintr (Zp-whitehead-sintr p smst n chml-clss)
+         :orgn `(Zp-whitehead ,p ,smst))))
+
+
diff --git a/examples/anromero/suspended-classifying-spaces-lisp-files/permutation-groups.cl b/examples/anromero/suspended-classifying-spaces-lisp-files/permutation-groups.cl
new file mode 100644
index 0000000..881401e
--- /dev/null
+++ b/examples/anromero/suspended-classifying-spaces-lisp-files/permutation-groups.cl
@@ -0,0 +1,153 @@
+
+(defun permgr-elements (l)
+  (declare (type 'list l))
+  (let* ((n (length (first l)))
+         (end nil)
+         (rslt (list (<a-b> 1 n))))
+    
+    (while (not end)
+      (progn
+        (setf end t) 
+        (mapcar #'(lambda (p)
+                    (progn
+                      (mapcar #'(lambda (p2)
+                                  (let ((p*p2 (permgr-mult p p2))
+                                        (pos -1))
+                                    (do ((j 0 (1+ j)))
+                                        ((or (not (equal pos -1)) (>= j (length rslt))))
+                                      (if (equal (l-cmpr p*p2 (nth j rslt)) :less)
+                                          (setf pos j)
+                                        (if (equal (l-cmpr p*p2 (nth j rslt)) :equal)
+                                            (setf pos -2)
+                                          (if (and (equal j (1- (length rslt))) (equal pos -1))
+                                              (setf pos (length rslt))))))
+                                    (if (> pos -1)
+                                        (progn
+                                          (setf rslt (append (subseq rslt 0 pos) (list p*p2) (subseq rslt pos (length rslt))))
+                                          (setf end nil))))
+                                    
+                                  (let ((p2*p (permgr-mult p2 p))
+                                        (pos -1))
+                                    (do ((j 0 (1+ j)))
+                                        ((or (not (equal pos -1)) (>= j (length rslt))))
+                                        (if (equal (l-cmpr p2*p (nth j rslt)) :less)
+                                            (setf pos j)
+                                          (if (equal (l-cmpr p2*p (nth j rslt)) :equal)
+                                              (setf pos -2)
+                                            (if (and (equal j (1- (length rslt))) (equal pos -1))
+                                                (setf pos (length rslt))))))
+                                      (if (> pos -1)
+                                          (progn
+                                            (setf rslt (append (subseq rslt 0 pos) (list p2*p) (subseq rslt pos (length rslt))))
+                                            (setf end nil)))
+                                  
+                                  
+                                  ))
+                        rslt)
+                      ))
+      l)))
+    rslt))
+                
+  
+
+#|
+(permgr-elements (list '(2 3 1) '(2 1 3)))
+(permgr-elements (list '(2 3 4 1) '(2 1 3 4)))
+(permgr-elements (list '(2 3 4 5 1) '(2 1 3 4 5)))
+
+|#
+
+
+
+
+
+
+(defun permgr-mult (p1 p2)
+  (declare (type 'list p1 p2))
+  (mapcar #'(lambda (i)
+              (nth (1- i) p2))
+    p1))
+
+#|
+(permgr-mult '(1 3 2) '(1 2 3))
+(permgr-mult '(1 5 4 3 2) '(1 2 3 5 4))
+|#
+
+(defun permgr-inv (p1)
+  (declare (type 'list p1))
+  (mapcar #'(lambda (i)
+              (1+ (position i p1)))
+    (<a-b> 1 (length p1))))
+
+#|
+(permgr-inv '(1 3 2 5 4))
+(permgr-mult '(1 3 2 5 4) '(1 3 2 5 4))
+(permgr-mult '(1 5 2 3 4) (permgr-inv '(1 5 2 3 4)))
+(permgr-mult '(5 4 3 1 2) (permgr-inv '(5 4 3 1 2)))
+|#
+
+
+
+(defun permutationgroup (l)
+  (declare (type 'list l))
+  (build-group :elements (permgr-elements l)
+               :cmpr #'l-cmpr
+               :mult #'permgr-mult
+               :inv #'permgr-inv
+               :nullel (<a-b> 1 (length (first l))) :orgn `(Permutation group generated by ,l)
+               ))
+
+
+#|
+(setf s3 (permutationgroup (list '(2 3 1) '(2 1 3))))
+|#
+
+
+
+(defun symmetricgroup (n)
+  (let* ((l (list (append (<a-b> 2 n) (list 1)) (append (list 2 1) (<a-b> 3 n))))
+         (rslt (permutationgroup l)))
+    (setf (slot-value rslt 'orgn) `(Symmetric group ,n))
+    rslt)) 
+
+#|
+(cat-init)
+(setf s3 (symmetricgroup 3))
+(elements s3)
+
+(setf s4 (symmetricgroup 4))
+(elements s4)
+
+
+
+
+|#
+
+
+
+(defun alternatinggroup (n)
+  (let* ((l (list 
+            (if (or (eq n 1) (eq n 2)) nil
+              (if (eq n 3) (list '(2 3 1))
+                (if (oddp n) (list (append (<a-b> 2 n) (list 1)) (append (<a-b> 1 (- n 3)) (list (1- n) n (- n 2))))
+                  (list (append (<a-b> 2 (1- n)) (list 1 n)) (append (<a-b> 1 (- n 3)) (list (1- n) n (- n 2)))))))))
+         (rslt (permutationgroup l)))
+    (setf (slot-value rslt 'orgn) `(Alternating group ,n))
+    rslt))
+
+
+#|
+(cat-init)
+(setf a3 (alternatinggroup 3))
+(elements a3)
+
+(setf a4 (alternatinggroup 4))
+(elements a4)
+
+
+
+|#
+
+                    
+            
+            
\ No newline at end of file
diff --git a/examples/anromero/suspended-classifying-spaces-lisp-files/resolutions.cl b/examples/anromero/suspended-classifying-spaces-lisp-files/resolutions.cl
new file mode 100644
index 0000000..fef9831
--- /dev/null
+++ b/examples/anromero/suspended-classifying-spaces-lisp-files/resolutions.cl
@@ -0,0 +1,1791 @@
+
+
+;; RESOLUTIONS   RESOLUTIONS   RESOLUTIONS   RESOLUTIONS   RESOLUTIONS   RESOLUTIONS   
+;; RESOLUTIONS   RESOLUTIONS   RESOLUTIONS   RESOLUTIONS   RESOLUTIONS   RESOLUTIONS   
+;; RESOLUTIONS   RESOLUTIONS   RESOLUTIONS   RESOLUTIONS   RESOLUTIONS   RESOLUTIONS   
+
+(IN-PACKAGE "COMMON-LISP-USER")
+
+(provide "resolutions")
+
+
+;;;;;;;;;;;;;;;;;;;;;
+;;;;; clases y tipos
+;;;;;;;;;;;;;;;;;;;;;
+
+(DEFUN ZGgnrt-P (object)
+   (declare (type any object))
+   (the boolean
+     (and (consp object)
+          (eql :ZGgnrt (car object))
+          (consp (cdr object))
+          ;;(consp (cadr object))
+          ;;(consp (cddr object))
+          (typep (cadr object) 'gnrt)
+          (typep (cddr object) 'gnrt)
+          )))
+
+(DEFTYPE ZGgnrt () '(satisfies ZGgnrt-p)) 
+
+(DEFUN ZGTERM-P (object)
+   (declare (type any object))
+   (the boolean
+     (and (consp object)
+          (typep (car object) 'fixnum)
+          (typep (cdr object) 'ZGgnrt))))
+
+(DEFTYPE ZGTERM () '(satisfies zgterm-p))
+
+;; IZGCMBN = Internal-ZGCoMBiNation 
+(DEFUN IZGCMBN-P (object)
+;; IZGCMBN = Internal ZGCoMBiNation,    
+;; without the keyword and the degree
+   (declare (type any object))
+   (the boolean
+     (and (listp object)
+          (every #'zgterm-p object))))
+
+(DEFTYPE IZGCMBN () '(satisfies izgcmbn-p)) 
+
+;; ZGCMBN = ZGCoMBiNation 
+(DEFUN ZGCMBN-P (object)
+   (declare (type any object))
+   (the boolean
+     (and (consp object)
+          (eql (car object) :cmbn)
+          (consp (cdr object))
+          (typep (second object) 'fixnum)
+          (typep (cddr object) 'iZGcmbn))))
+
+(DEFTYPE ZGCMBN () '(satisfies ZGcmbn-p)) 
+
+
+
+(DEFTYPE GROUP-BASIS () '(or list (eql :locally-effective))) 
+
+;;(DEFCLASS GROUP-MRPH () ()) ;; to be redefined later
+  
+(DEFCLASS GROUP ()
+   ((elements :type group-basis :initarg :elements :reader elements)
+   (cmpr :type cmprf :initarg :cmpr :reader cmpr1)
+   (mult :type function :initarg :mult :reader mult1)
+   (inv :type function :initarg :inv :reader inv1)
+   (nullel :type gnrt :initarg :nullel :reader nullel)
+   (idnm :type fixnum :initform (incf *idnm-counter*) :reader idnm)
+   (orgn :type list :initarg :orgn :reader orgn)
+   (resolution :type reduction :initarg :resolution :reader resolution))
+  )
+
+(DEFCLASS AB-GROUP (GROUP)
+    ())
+
+(DEFCLASS GROUP-MRPH ()
+    ;; SOuRCe     
+    ((sorc :type group :initarg :sorc :reader sorc)
+     ;; TaRGeT 
+     (trgt :type group :initarg :trgt :reader trgt)
+      
+     ;; INTeRnal      
+     (intr :type function :initarg :intr :reader intr)      
+          ;; IDentification NuMber      
+     (idnm :type fixnum :initform (incf *idnm-counter*) :reader idnm)      
+     ;; ORiGiN      
+     (orgn :type list :initarg :orgn :reader orgn)))
+
+
+
+
+(DEFVAR *group-list*)
+(SETF *group-list* +empty-list+)
+(PUSHNEW '*group-list* *list-list*)
+
+(DEFVAR *ab-group-list*)
+(SETF *ab-group-list* +empty-list+)
+(PUSHNEW '*ab-group-list* *list-list*)
+
+(DEFVAR *group-mrph-list*)
+(SETF *group-mrph-list* +empty-list+)
+(PUSHNEW '*group-mrph-list* *list-list*)
+
+
+(DEFMETHOD PRINT-OBJECT ((group GROUP) stream)
+   (the GROUP
+     (progn
+      (format stream "[K~D Group]" (idnm group))
+      group)))
+
+(DEFMETHOD PRINT-OBJECT ((group ab-GROUP) stream)
+   (the ab-GROUP
+     (progn
+      (format stream "[K~D Abelian-Group]" (idnm group))
+      group)))
+
+(DEFMETHOD PRINT-OBJECT ((group-mrph GROUP-MRPH) stream)
+   (the GROUP-MRPH
+     (progn
+      (format stream "[K~D Group-morphism]" (idnm group-mrph))
+      group-mrph)))
+
+
+(DEFUN GROUP (idnm)
+   (declare (type fixnum idnm))
+   (the (or GROUP null)
+      (find idnm *group-list* :key #'idnm)))
+
+(DEFUN AB-GROUP (idnm)
+   (declare (type fixnum idnm))
+   (the (or AB-GROUP null)
+      (find idnm *ab-group-list* :key #'idnm)))
+
+(DEFUN GROUP-MRPH (idnm)
+   (declare (type fixnum idnm))
+   (the (or GROUP-MRPH null)
+      (find idnm *group-mrph-list* :key #'idnm)))
+
+
+
+
+   
+
+;;(DEFCLASS ZG-MORPHISM () ())  ;; will be redefined later.
+
+
+(DEFCLASS ZG-CHAIN-COMPLEX (chain-complex)
+    (
+     (group :type group :initarg :group :reader group1)
+     (zgcmpr :type cmprf :initarg :zgcmpr :reader zgcmpr1)
+     (zgbasis :type basis :initarg :zgbasis :reader zgbasis1)
+     (zgbsgn :type gnrt :initarg :zgbsgn :reader zgbsgn)
+     (zgbndr :type ZG-morphism :initarg :zgbndr :reader zgbndr1)
+     ))
+
+(DEFVAR *zgcc-list*)
+(SETF *zgcc-list* +empty-list+)
+(PUSHNEW '*zgcc-list* *list-list*)
+
+(DEFMETHOD PRINT-OBJECT ((zgcm ZG-CHAIN-COMPLEX) stream)
+   (the ZG-CHAIN-COMPLEX
+     (progn
+      (format stream "[K~D ZG-Chain-Complex]" (idnm zgcm))
+      zgcm)))
+
+(DEFUN ZGCC (idnm)
+   (declare (type fixnum idnm))
+   (the (or ZG-CHAIN-COMPLEX null)
+      (find idnm *zgcc-list* :key #'idnm)))
+
+
+
+
+;; ZGSTRT = ZGSTRaTegy 
+(DEFTYPE ZGSTRT () '(member :gnrt :zggnrt :zgcmbn))
+
+;; INTR-ZGMRPH = INTeRnal-ZGMoRPHism 
+(DEFTYPE INTR-ZGMRPH () 'function)                
+;; (or (function (degr gnrt) zgcmbn)    ;; if :gnrt strategy
+;;     (function (degr zggnrt) zgcmbn)  ;; if :zggnrt strategy                
+;;     (function (zgcmbn) zgcmbn)     ;; if :zgcmbn strategy 
+
+(DEFCLASS ZG-MORPHISM (morphism)
+    (
+     (zgintr :type intr-zgmrph :initarg :zg-intr :reader intr-zgmrph)
+     (zgstrt :type zgstrt :initarg :zgstrt :reader zgstrt) 
+    ))
+
+(DEFVAR *zgmrph-list*)
+(SETF *zgmrph-list* +empty-list+)
+(PUSHNEW '*zgmrph-list* *list-list*)
+
+
+(DEFMETHOD PRINT-OBJECT ((mrph ZG-MORPHISM) stream)
+   (the ZG-MORPHISM
+      (progn
+	(format stream "[K~D ZG-Morphism (degree ~D): K~D -> K~D]"
+		  (idnm mrph) (degr mrph)
+		  (idnm (sorc mrph)) (idnm (trgt mrph)))
+         mrph)))
+
+
+(DEFUN zgmrph (idnm)
+   (declare (type fixnum idnm))
+   (the (or ZG-MORPHISM null)
+      (find idnm *zgmrph-list* :key #'idnm)))
+
+
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;;; macros
+;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+(DEFMACRO ZGgnrt (gnrt1 gnrt2)
+  `(cons  :zggnrt
+     (cons ,gnrt1 ,gnrt2)))
+
+
+(DEFMACRO zggnrt1 (ZGgnrt)
+   `(car (cdr ,ZGgnrt)))
+
+(DEFMACRO zggnrt2 (ZGgnrt)
+  `(cddr ,ZGgnrt))
+
+;; (setf gn1 (zggnrt 'g1 'b1))
+;; (setf gn2 (zggnrt 'g2 'b1))
+;; (setf gn3 (zggnrt 'g1 'b2))
+;; (setf gn4 (zggnrt 'g2 'b2))
+
+(DEFMACRO WITH-ZGgnrt ((zggnrt1 zggnrt2) zggnrt . body)
+   `(let (,@(if zggnrt1 `((,zggnrt1 (zggnrt1 ,zggnrt))) nil)
+          ,@(if zggnrt2 `((,zggnrt2 (zggnrt2 ,zggnrt))) nil))
+       (declare
+         (type gnrt ,@(if zggnrt1 `(,zggnrt1) nil) ,@(if zggnrt2 `(,zggnrt2) nil)))
+       ,@body))
+
+;;(with-zggnrt (gnrt1 gnrt2) gn3
+;;     (progn
+;;      (format t "~D" gnrt1)
+;;      (format t "~D" gnrt2))) 
+
+
+;; Sobra??? podemos usar directamente el macro term
+(DEFMACRO ZGTERM (cffc zggnrt)
+  `(cons ,cffc ,zggnrt))
+
+
+;; Sobra??? podemos usar directamente el macro with-term
+(DEFMACRO WITH-zgTERM ((cffc zggnrt) zgterm . body)
+   `(let (,@(if cffc `((,cffc (cffc ,zgterm))) nil)
+          ,@(if zggnrt `((,zggnrt (gnrt ,zgterm))) nil))
+       (declare
+          (fixnum ,@(if cffc `(,cffc) nil))
+          (type zggnrt ,@(if zggnrt `(,zggnrt) nil)))
+       ,@body))
+
+
+
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+(defun build-group 
+    (&key elements cmpr mult inv nullel orgn)
+   (declare 
+     (type group-basis elements)
+     (type cmprf cmpr)
+     (type function mult)
+     (type function inv)
+     (type gnrt nullel)
+     (list orgn))
+   (the group
+     (progn
+      (let ((already (find orgn *group-list* :test #'equal :key #'orgn)))
+         (declare (type (or group null) already))
+         (when already
+            (return-from build-group already)))
+      (unless elements
+         (setf elements :locally-effective))
+      (let ((group (make-instance 'group
+                     :cmpr cmpr
+                     :elements elements
+                     :mult mult
+                     :inv inv
+                     :nullel nullel
+                     :orgn orgn)))
+         (declare (type group group))   
+         (push group *group-list*)
+         group))))
+
+(DEFUN BUILD-GRMR (&key sorc trgt intr orgn)
+   (declare
+      (type group sorc trgt)
+      (type (or intr-mrph null) intr)
+      (list orgn))
+   (the group-mrph
+     (progn
+         (let ((already (find orgn *group-mrph-list* :test #'equal :key #'orgn)))
+            (declare (type (or group-mrph null) already))
+            (when already
+               (return-from build-grmr already)))
+         (let ((mrph (make-instance 'group-mrph
+                        :sorc sorc :trgt trgt 
+                        :intr intr 
+                        :orgn orgn)))
+            (declare (type group-mrph mrph))
+            (push mrph *group-mrph-list*)
+            mrph))))
+
+
+(DEFMACRO BUILD-AB-GROUP (&rest rest)
+  `(change-class (build-group ,@rest) 'ab-group))
+
+  
+   
+(DEFMETHOD ?2 ((grmrph group-mrph) grelt)
+   (declare (type gnrt grelt))
+   (the gnrt
+     (with-slots (intr) grmrph
+       (funcall intr grelt))))
+
+
+(DEFMETHOD ?3 ((group group) g1 g2)
+   (declare
+      (type gnrt g1 g2))
+   (the gnrt
+     (with-slots (mult) group
+      (funcall mult g1 g2))))
+
+#|
+(setf elements '(0 1 2 3 4))
+(setf cmpr #'f-cmpr)
+(setf grmult #'(lambda (g1 g2)
+                  (mod (+ g1 g2) 5)))
+(setf inv #'(lambda (g)
+                 (mod (- 5 g) 5)))
+(setf nullel 0)
+(setf orgn '(Z_5))
+(setf gr (build-group :elements elements :cmpr cmpr :mult grmult :inv inv :nullel 0 :orgn orgn))
+(setf intr #'(lambda (g) (funcall grmult g g)))
+(setf grmrph (build-grmr :sorc gr :trgt gr :intr intr :orgn '(grmrph)))
+(? grmrph 3)
+(? gr 1 2)
+|#
+      
+
+
+        
+(DEFUN ZGGNRT-CMPR (grcmpr zgcmpr)
+   (declare (type cmprf grcmpr zgcmpr))
+   (flet ((rslt (gnrt1 gnrt2)
+            (declare (type zggnrt gnrt1 gnrt2))
+            (the cmpr
+              (let ((gnrt12 (zggnrt2 gnrt1))
+                    (gnrt22 (zggnrt2 gnrt2)))
+                 (declare (type gnrt gnrt12 gnrt22))
+                 (lexico
+                  (funcall zgcmpr gnrt12 gnrt22)
+                  (let ((gnrt11 (zggnrt1 gnrt1))
+                        (gnrt21 (zggnrt1 gnrt2)))
+                     (declare (type gnrt gnrt11 gnrt21))
+                     (funcall grcmpr gnrt11 gnrt21)))))))
+     (the cmprf #'rslt)))
+
+
+;;(setf cmpr (zggnrt-cmpr #'s-cmpr #'s-cmpr))
+;;(funcall cmpr gn1 gn2)
+
+(DEFUN ZGCHCM-BASIS (grbasis zgbasis)
+   (declare (type group-basis grbasis)
+            (type basis zgbasis))
+   (when (or (eq grbasis :locally-effective)
+             (eq zgbasis :locally-effective))
+      (return-from ZGCHCM-BASIS :locally-effective))
+   (flet ((rslt (degr)
+             (declare (fixnum degr))
+             (the list
+                (progn
+                   (when (minusp degr)
+                      (return-from rslt +empty-list+))
+                   (the list
+                     (mapcan
+                      #'(lambda (gnrt2)
+                          (declare (type gnrt gnrt2))
+                          (the list
+                            (mapcar
+                             #'(lambda (gnrt1)
+                                 (declare (type gnrt gnrt1))
+                                 (the zggnrt
+                                   (zggnrt gnrt1 gnrt2)))
+                             grbasis)))
+                       (funcall zgbasis degr)))
+                      ))
+                      ))
+      (the basis #'rslt)))
+
+;; (setf basis1 '(0 1 2 3 4))
+;; (setf basis2 
+;;       #'(lambda (degr)
+;;           (<a-b> 0 degr)))
+;; (setf zgbasis (ZGCHCM-BASIS basis1 basis2))
+   
+
+
+(DEFUN ZGMRPH-GNRT-GNRT (intr degr gnrt)
+   (declare
+    (type intr-zgmrph intr)
+    (fixnum degr)
+    (type gnrt gnrt))
+   (funcall intr degr gnrt))
+
+(DEFUN ZGMRPH-GNRT-ZGGNRT (grcmpr zgcmpr grmult intr degr zggnrt)
+   (declare
+    (type cmprf grcmpr zgcmpr)
+    (type function grmult)
+    (type intr-zgmrph intr)
+    (fixnum degr)
+    (type zggnrt zggnrt))
+   (let* ((zggnrt1 (zggnrt1 zggnrt))
+          (zggnrt2 (zggnrt2 zggnrt))
+          (zgcmbn (ZGMRPH-GNRT-GNRT intr degr zggnrt2))
+          (degr (cmbn-degr zgcmbn))
+          (list (cmbn-list zgcmbn))
+          (n-cmbn-list +empty-list+))
+      (declare (list n-cmbn-list))
+      (if list 
+         (progn 
+           (mapcar #'(lambda (zgterm)
+                  (declare (type zgterm zgterm))
+                  (with-zgterm (cffc gnrt) zgterm
+                   (declare (type fixnum cffc)
+                     (type zggnrt gnrt))
+                   (with-zggnrt (gnrt1 gnrt2) gnrt
+                    (declare (type gnrt gnrt1 gnrt2))
+                    (push (cons 1
+                      (term-cmbn degr cffc (zggnrt (funcall grmult zggnrt1 gnrt1) gnrt2)))
+                      n-cmbn-list))))
+             list)
+           (cmbn-cmbn (zggnrt-cmpr grcmpr zgcmpr) n-cmbn-list))
+         (zero-cmbn degr))))
+
+;; (setf grbasis '(0 1 2 3 4))
+;; (setf zgbasis 
+;;      #'(lambda (degr)
+;;           (<a-b> 0 degr)))
+;; (setf grmult #'(lambda (g1 g2)
+;;                  (mod (+ g1 g2) 5)))
+;; (setf grcmpr #'f-cmpr zgcmpr #'f-cmpr)
+;;(setf intr #'(lambda (degr gnrt)
+;;               (declare
+;;                (fixnum degr)
+;;                (type gnrt gnrt))
+;;               (let ((cmbn (cmbn degr)))
+;;                  (declare (type cmbn cmbn))
+;;                  (mapcar #'(lambda (i)
+;;                              (declare (fixnum i))
+;;                              (setf cmbn
+;;                               (2cmbn-add (zggnrt-cmpr #'f-cmpr #'f-cmpr) cmbn (term-cmbn degr i (zggnrt i gnrt))
+;;                               )))
+;;                    (<a-b> 1 4))
+;;                  cmbn)))
+
+;;(ZGMRPH-GNRT-ZGGNRT grcmpr zgcmpr grmult intr 5 (zggnrt 1 3))
+
+(DEFUN ZGMRPH-GNRT-ZGCMBN (grcmpr zgcmpr grmult intr zgcmbn)
+   (declare
+    (type cmprf grcmpr zgcmpr)
+    (type function grmult)
+    (type intr-zgmrph intr)
+    (type zgcmbn zgcmbn))
+      (the cmbn
+        (with-cmbn (degr list) zgcmbn
+          (if list
+             (let ((n-cmbn-list +empty-list+))
+                (declare (list n-cmbn-list))
+                (do ((mark list (cdr mark))
+                     )
+                    ((endp mark))
+                   (declare (list mark))
+                   (with-term (cffc gnrt) (car mark) 
+                   (push 
+                     (cons cffc 
+                       (zgmrph-gnrt-zggnrt grcmpr zgcmpr grmult intr degr gnrt))
+                     n-cmbn-list)))
+                (cmbn-cmbn (zggnrt-cmpr grcmpr zgcmpr) n-cmbn-list))
+             (cmbn degr)))))
+
+;;(ZGMRPH-GNRT-ZGCMBN grcmpr zgcmpr grmult intr (cmbn 5 2 (zggnrt 1 3) 3 (zggnrt 2 4)))
+
+
+(DEFUN ZGMRPH-ZGGNRT-ZGGNRT (intr degr zggnrt)
+   (declare
+    (type intr-zgmrph intr)
+    (fixnum degr)
+    (type zggnrt zggnrt))
+   (funcall intr degr zggnrt))
+
+
+
+(DEFUN ZGMRPH-ZGGNRT-ZGCMBN (grcmpr zgcmpr intr zgcmbn)
+   (declare
+    (type intr-zgmrph intr)
+    (type cmprf grcmpr zgcmpr)
+    (type zgcmbn zgcmbn))
+   
+      (the cmbn
+      (with-cmbn (degr list) zgcmbn
+         (let ((n-cmbn-list +empty-list+))
+            (declare (list n-cmbn-list))
+            (do ((mark list (cdr mark))
+                 )
+                ((endp mark))
+               (declare (list mark))
+               (with-term (cffc gnrt) (car mark) 
+                   (push 
+                     (cons cffc 
+                       (zgmrph-zggnrt-zggnrt intr degr gnrt))
+                     n-cmbn-list)))
+	    (cmbn-cmbn (zggnrt-cmpr grcmpr zgcmpr) n-cmbn-list)))))
+
+
+
+(DEFUN ZGmrph-GNRT-? (ZGmrph degr gnrt)
+   (declare
+      (type zg-morphism ZGmrph)
+      (fixnum degr)
+      (type gnrt gnrt))
+   (the cmbn
+     (with-slots (zgintr zgstrt trgt) zgmrph
+       (with-slots (group) trgt
+            (declare
+             (type intr-zgmrph zgintr)
+             (type zgstrt zgstrt)
+             (type group group))
+
+       (with-slots (nullel) group
+         (prog1
+          (ecase zgstrt
+            (:gnrt
+             (zgmrph-gnrt-gnrt zgintr degr gnrt))
+            (:zggnrt
+             (funcall zgintr degr (zggnrt nullel gnrt)))
+            (:cmbn
+             (funcall zgintr (term-cmbn degr 1 (zggnrt nullel gnrt)))))
+          ))))))
+
+
+(DEFUN ZGmrph-ZGGNRT-? (ZGmrph degr zggnrt)
+   (declare
+      (type ZG-morphism ZGmrph)
+      (fixnum degr)
+      (type zggnrt zggnrt))
+   (the cmbn
+     (with-slots (trgt zgintr zgstrt ) zgmrph
+       (with-slots (group) trgt
+            (declare
+               (type zg-chain-complex trgt)
+               (fixnum mdegr )
+               (type intr-zgmrph zgintr)
+               (type zgstrt zgstrt)
+             (type group group))
+       (with-slots ((grcmpr cmpr) mult nullel) group
+         (with-slots (zgcmpr)  trgt
+            (declare (type cmprf zgcmpr grcmpr))
+           (prog1
+                     (ecase zgstrt
+                        (:gnrt
+                         (zgmrph-gnrt-zggnrt grcmpr zgcmpr mult zgintr degr zggnrt))
+                        (:zggnrt
+                         (funcall zgintr degr zggnrt))
+                        (:cmbn
+                         (funcall zgintr (term-cmbn degr 1 zggnrt))))
+            )))))))
+
+
+(DEFUN ZGmrph-ZGCMBN-? (ZGmrph zgcmbn)
+   (declare
+      (type ZG-morphism ZGmrph)
+      (fixnum degr)
+      (type zggnrt zggnrt))
+   (the cmbn
+     (with-slots (trgt zgintr zgstrt ) zgmrph
+       (with-slots (group zgcmpr) trgt
+            (declare
+             (type zg-chain-complex trgt)
+             (type intr-zgmrph zgintr)
+             (type zgstrt zgstrt)
+             (type group group)
+             )
+       (with-slots ((grcmpr cmpr) mult nullel) group
+         (declare
+          (type cmprf grcmpr)
+          (type function mult)
+          (type gnrt nullel))
+         (prog1
+          (ecase zgstrt
+            (:gnrt
+             (zgmrph-gnrt-zgcmbn grcmpr zgcmpr mult zgintr zgcmbn))
+            (:zggnrt
+             (zgmrph-zggnrt-zgcmbn grcmpr zgcmpr zgintr zgcmbn))
+            (:cmbn
+             (funcall zgintr zgcmbn)))
+            ))))))
+
+(Defun izgmrph-imrph (grcmpr zgcmpr mult intr strt)
+   (declare (type intr-zgmrph intr)
+     (type zgstrt strt))
+   (flet ((rslt (degr zggnrt)
+             (declare
+                (fixnum degr)
+                (type zggnrt zggnrt))
+             (ecase strt
+                        (:gnrt
+                         (zgmrph-gnrt-zggnrt grcmpr zgcmpr mult intr degr zggnrt))
+                        (:zggnrt
+                         (funcall intr degr zggnrt))
+                        (:cmbn
+                         (funcall intr (term-cmbn degr 1 zggnrt))))))
+     (the intr-mrph #'rslt)))
+
+
+(DEFUN INTR-ZGCHCM-MRPH (zgmrph)
+   (declare (type zg-morphism zgmrph))
+   (flet ((rslt (degr zggnrt)
+             (declare
+                (fixnum degr)
+                (type zggnrt zggnrt))
+             (zgmrph-zggnrt-? zgmrph degr zggnrt)))
+     (the intr-mrph #'rslt)))
+                
+               
+(DEFUN BUILD-ZGCHCM
+    (&key group zgcmpr zgbasis zgbsgn intr-zgbndr zgbndr-strt orgn)
+   (declare
+    (type group group)
+    (type cmprf zgcmpr)
+    (type basis zgbasis)
+    (type gnrt zgbsgn)
+    (type intr-zgmrph intr-zgbndr)
+    (type zgstrt zgbndr-strt)
+    (list orgn))
+   (let ((already (find orgn *zgcc-list* :test #'equal :key #'orgn)))
+      (declare (type (or zg-chain-complex null) already))
+      (when already
+         (return-from build-zgchcm already)))
+   (if intr-zgbndr
+      (unless zgbndr-strt
+            (error "In BUILD-ZGCHCM, an intr-zgbndr is given but not its strategy."))
+      )
+   (the zg-chain-complex
+     (with-slots ((grcmpr cmpr) (grbasis elements) mult nullel) group
+       (let* ((cmpr (zggnrt-cmpr grcmpr zgcmpr))
+              (basis (ZGCHCM-BASIS grbasis zgbasis))
+              (bsgn (zggnrt nullel zgbsgn))
+              (intr-dffr (izgmrph-imrph grcmpr zgcmpr mult intr-zgbndr zgbndr-strt))
+              (rslt (build-chcm :cmpr cmpr :basis basis :bsgn bsgn
+                     :intr-dffr intr-dffr :strt :gnrt :orgn orgn)))
+         (change-class rslt 'zg-chain-complex)
+         (setf (slot-value rslt 'group) group)
+         (setf (slot-value rslt 'zgcmpr) zgcmpr)
+         (setf (slot-value rslt 'zgbasis) zgbasis)
+         (setf (slot-value rslt 'zgbsgn) zgbsgn)
+         (setf (slot-value rslt 'zgbndr) (build-zgmrph :sorc rslt :trgt rslt :degr -1
+                                          :zgintr intr-zgbndr :zgstrt zgbndr-strt :orgn `(zgbndr ,rslt)))
+         (push rslt *zgcc-list*)
+         rslt))))
+
+
+(DEFUN BUILD-ZGMRPH (&key sorc trgt degr zgintr zgstrt orgn)
+   (declare
+    (type zg-chain-complex sorc trgt)
+    (fixnum degr)
+    (type intr-zgmrph intr)
+    (type zgstrt strt)
+    (list orgn))
+   (the zg-morphism
+     (with-slots (group zgcmpr) trgt
+       (with-slots ((grcmpr cmpr) (grbasis elements) mult nullel ) group
+         (let* ((intr (izgmrph-imrph grcmpr zgcmpr mult zgintr zgstrt))
+                (rslt (build-mrph :sorc sorc :trgt trgt :degr degr
+                        :intr intr :strt :gnrt :orgn orgn)))
+            (change-class rslt 'zg-morphism)
+            (setf (slot-value rslt 'zgintr) zgintr)
+            (setf (slot-value rslt 'zgstrt) zgstrt)
+            (push rslt *zgcc-list*)
+            rslt)))))
+
+
+
+
+
+;;(DEFMETHOD zg-?2 ((zgmrph zg-morphism) zgcmbn)
+;;   (declare (type zgcmbn zgcmbn))
+;;   (the zgcmbn
+;;      (zgmrph-zgcmbn-? zgmrph zgcmbn)))
+
+
+
+;;(DEFMETHOD zg-?3 ((zgmrph zg-morphism) degr gnrt)
+;;   (declare
+;;      (fixnum degr)
+;;      (type gnrt gnrt))
+;;   (the zgcmbn
+;;      (zgmrph-gnrt-? zgmrph degr gnrt)))
+
+
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;TENSOR WITH INTEGERS
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+(DEFUN zgcmbn-twi (zgcmpr zgcmbn)
+   (declare (type zgcmbn zgcmbn))
+   (with-cmbn (degr list) zgcmbn
+     (if list
+        (let* ((cmbn-list +empty-list+))
+           (mapcar #'(lambda (zgterm)
+                       (with-zgterm (cffc zggnrt) zgterm
+                         (let ((gnrt2 (zggnrt2 zggnrt)))
+                            (push (cons 1
+                                    (term-cmbn degr cffc gnrt2))
+                              cmbn-list))))
+             list)
+           (cmbn-cmbn zgcmpr cmbn-list))
+     (zero-cmbn degr))))
+
+;; (setf zgcmbn (cmbn 5 2 (zggnrt 1 3) 3 (zggnrt 2 4)))
+;; (zgcmbn-twi #'f-cmpr zgcmbn)
+;; (setf zgcmbn2 (cmbn 5 2 (zggnrt 1 3) 3 (zggnrt 2 4) -8 (zggnrt 6 3)))
+;; (zgcmbn-twi #'f-cmpr zgcmbn2)
+
+
+(Defun zgmrph-twi-intr (mrph)
+   (declare (type zg-morphism mrph))     
+   (flet ((rslt (degr gnrt)
+             (declare
+                (fixnum degr)
+                (type zggnrt zggnrt))
+            (with-slots (trgt) mrph
+              (with-slots (zgcmpr) trgt
+             (zgcmbn-twi zgcmpr (zgmrph-gnrt-? mrph degr gnrt))))))
+     (the intr-mrph #'rslt)))
+
+(defun zgmrph-twi (mrph)
+   (declare (type zg-morphism mrph))
+   (the morphism
+     (with-slots (sorc trgt degr zgintr zgstrt orgn) mrph
+       (build-mrph :sorc (chcm-twi sorc) :trgt (chcm-twi trgt) :degr degr
+                     :intr (zgmrph-twi-intr mrph) :strt :gnrt :orgn `(tensor-with-integers ,orgn))
+                    )))
+
+(defun chcm-twi (chcm)
+   (declare (type zg-chain-complex chcm))
+   (the chain-complex
+     (if (string= (car (orgn chcm)) 'bar-zgchcm) 
+        (with-slots (group) chcm
+          (k-g-1 group))
+     (with-slots (zgcmpr zgbasis zgbsgn zgbndr orgn) chcm
+       (build-chcm :cmpr zgcmpr :basis zgbasis :bsgn zgbsgn :intr-dffr (zgmrph-twi-intr zgbndr) 
+        :strt :gnrt :orgn `(tensor-with-integers ,orgn))))))
+
+
+
+
+
+
+
+
+
+;;;;; EJEMPLOS
+
+
+#|
+(cat-init) 
+(setf Z3 (build-group :elements '(0 1 2) :cmpr #'f-cmpr :mult #'(lambda (g1 g2)
+                                                                  (mod (+ g1 g2) 3))
+          :inv #'(lambda (g)
+                 (mod (- 3 g) 3)) :nullel 0 :orgn '(Cyclic Group order 3)))
+
+(setf zgbasis #'(lambda (degr) (list degr)))
+(setf zgbspn 0)
+(setf zgcmpr #'f-cmpr)
+(setf intr #'(lambda(degr gnrt)
+               (let ((degr- (1- degr)))
+                  (if (oddp degr)
+                     (cmbn degr- -1 (zggnrt 0 degr-)  1 (zggnrt 1 degr-))
+                     (cmbn degr- 1 (zggnrt 0 degr-)  1 (zggnrt 1 degr-)  1 (zggnrt 2 degr-))))))
+
+(setf zgchcm (BUILD-ZGCHCM
+    :group Z3 :zgcmpr zgcmpr :zgbasis zgbasis :zgbsgn 0 :intr-zgbndr intr :zgbndr-strt :gnrt :orgn '(prueba)
+))
+
+(setf zgmrph (zgbndr1 zgchcm))
+(ZGmrph-GNRT-? zgmrph 4 4)
+(ZGmrph-zgGNRT-? zgmrph 4 (zggnrt 2 4))
+(ZGmrph-zgGNRT-? zgmrph 3 (zggnrt 0 3))
+(ZGmrph-zgGNRT-? zgmrph 3 (zggnrt 1 3))
+(ZGmrph-zgGNRT-? zgmrph 3 (zggnrt 2 3))
+(ZGmrph-zgGNRT-? zgmrph 4 (zggnrt 0 4))
+
+(ZGmrph-zgcmbn-? zgmrph (cmbn 4 1 (zggnrt 2 4) -3 (zggnrt 3 4)))
+(ZGmrph-zgcmbn-? zgmrph (cmbn 4 2 (zggnrt 2 4) -5 (zggnrt 3 4)))
+(ZGmrph-zgcmbn-? zgmrph (cmbn 3 1 (zggnrt 2 3) -3 (zggnrt 3 3)))
+(ZGmrph-zgGNRT-? zgmrph 3 (zggnrt 2 3))
+(ZGmrph-zgGNRT-? zgmrph 3 (zggnrt 3 3))
+
+
+(setf chcm (chcm-twi zgchcm))
+(? chcm 3 3)
+(? chcm 4 4)
+(? chcm 5 5 ))
+
+(homology chcm 0 10)
+
+|#
+
+
+#| 
+(setf ZCC
+      (the chain-complex
+        (build-chcm
+         :cmpr #'(lambda (gnrt1 gnrt2) (the cmpr :equal))
+         :basis #'(lambda (n)
+                    (the list
+                      (if (zerop n) '(:Z-gnrt) +empty-list+)))
+         :bsgn :Z-gnrt
+         :intr-dffr #'(lambda (cmbn)
+                        (the cmbn (zero-cmbn (1- (cmbn-degr cmbn)))))
+         :strt :cmbn
+         :orgn '(zcc-constant))))
+|#
+;; ya está definido con la función (z-chcm) 
+
+(defun cyclicgroup (n)
+   (declare (fixnum n))
+   (build-ab-group :elements (<a-b> 0 (1- n)) :cmpr #'f-cmpr :mult #'(lambda (g1 g2)
+                                                                  (mod (+ g1 g2) n))
+           :inv #'(lambda (g)
+                 (mod (- n g) n)) :nullel 0 :orgn `(Cyclic-group of order ,n)))
+
+
+(defun z-group ()
+    (build-ab-group :elements :locally-effective :cmpr #'f-cmpr :mult #'(lambda (g1 g2)
+                                                                  (+ g1 g2) )
+           :inv #'(lambda (g)
+                 (- g)) :nullel 0 :orgn `(z-group)))
+
+
+(DEFMETHOD SLOT-UNBOUND (class (group group) (slot-name (eql 'resolution)))
+   (declare (ignore class))
+   (the reduction
+     (let ((rsltn (search-resolution group (first (orgn group)))))
+       (setf (slot-value group 'resolution)
+	     (or rsltn
+          (error "I don't know how to determine ~
+                         a resolution for 
+                         ~A (Origin: ~A)." group (orgn group)))))))
+
+(DEFGENERIC SEARCH-resolution (group orgn))
+
+(DEFMETHOD SEARCH-RESOLUTION (group orgn)
+  (declare (ignore group orgn))
+  nil)
+
+
+
+      
+
+(defun cyclicgroup-zgchcm (n)
+   (let* ((group (cyclicgroup n))
+          (zgbasis #'(lambda (degr) (list degr)))
+          (zgcmpr #'f-cmpr)
+          (intr #'(lambda(degr gnrt)
+               (let ((degr- (1- degr)))
+                  (if (zerop degr) (zero-cmbn -1)
+                     (if (oddp degr)
+                        (cmbn degr- -1 (zggnrt 0 degr-)  1 (zggnrt 1 degr-))
+                        (let ((list +empty-list+))
+                           (mapcar #'(lambda (i)
+                                       (push (cons 1 (zggnrt (- n i) degr-)) list))
+                             (<a-b> 1  n))
+                           (make-cmbn :degr degr- :list list))))))))
+          (BUILD-ZGCHCM
+    :group group :zgcmpr zgcmpr :zgbasis zgbasis :zgbsgn 0 
+           :intr-zgbndr intr :zgbndr-strt :gnrt :orgn  `(ZG-Chain complex for ,group)
+)))
+                     
+#|
+(setf z5 (cyclicgroup 5))
+(setf z5-zgchcm (cyclicgroup-zgchcm 5))
+(? z5-zgchcm 3 (zggnrt 2 3))
+(? z5-zgchcm 4 (zggnrt 2 4))
+|#   
+
+
+(defun cyclicgroup-rsltn (n)
+   (let* ((group (cyclicgroup n))
+          (zgchcm (cyclicgroup-zgchcm n))
+          (cmpr (cmpr1 zgchcm))
+          (f-intr #'(lambda (degr zggnrt)
+                      (with-zggnrt (gnrt1 gnrt2) zggnrt
+                        (if (zerop degr) (cmbn degr 1 :zgnrt) (zero-cmbn degr)))))
+          (g-intr #'(lambda (degr gnrt)
+                      (if (zerop degr) (cmbn degr 1 (zggnrt 0 0)) (zero-cmbn degr))))
+          (h-intr #'(lambda (degr zggnrt)
+                      (with-zggnrt (gnrt1 gnrt2) zggnrt
+                        (if (oddp degr)
+                           (if (= gnrt1 (1- n)) (cmbn (1+ degr) 1 (zggnrt 0 (1+ degr)))
+                              (zero-cmbn (1+ degr)))
+                           (let ((list +empty-list+))
+                              (dotimes (i gnrt1)
+                                 (push (cons 1 (zggnrt i (1+ degr))) list ))
+                              (make-cmbn :degr (1+ degr) :list (nreverse list)))))))
+          (f (build-mrph :sorc zgchcm :trgt (z-chcm) :degr 0 :intr f-intr :strt :gnrt :orgn `(f-mrph for ,group)))
+          (g (build-mrph :sorc (z-chcm) :trgt zgchcm :degr 0 :intr g-intr :strt :gnrt :orgn  `(g-mrph for ,group)))
+          (h (build-mrph :sorc zgchcm :trgt zgchcm :degr 1 :intr h-intr :strt :gnrt :orgn `(h-mrph for ,group))))
+      (build-rdct :f f :g g :h h :orgn `(Resolution of ,group)))) 
+                      
+
+(DEFMETHOD SEARCH-RESOLUTION (group (orgn (eql 'Cyclic-group)))
+  (declare
+     (type group group))
+  (the reduction
+    (with-slots (elements) group
+      (let ((n (length elements)))
+         (cyclicgroup-rsltn n)))))
+
+
+                      
+#|(defun cyclicgroup-with-resolution (n)
+   (let ((group (cyclicgroup n))
+         (rsltn (cyclicgroup-rsltn n)))
+      (setf (slot-value group 'resolution) rsltn)
+      group))
+|#
+
+(DEFMETHOD HOMOLOGY ((group group) degr1 &optional (degr2 (1+ degr1)))
+   (declare (fixnum degr1 degr2))
+   (with-slots (resolution) group 
+     (let ((chcm (chcm-twi (tcc resolution))))
+        (homology chcm degr1 degr2))))
+            
+#|
+(setf z3 (cyclicgroup 3))
+(homology z3 0 6)
+(setf g (build-group :elements '(0 1 2) :cmpr #'f-cmpr :mult #'(lambda (g1 g2)
+                                                                  (mod (+ g1 g2) 3))
+          :inv #'(lambda (g)
+                 (mod (- 3 g) 3)) :nullel 0 :orgn '(hola)))
+(homology g 0 6) 
+|#
+
+
+
+;;;; BAR RESOLUTION
+
+
+(defun bar-zgcmpr (grcmpr)
+   (declare (type cmprf grcmpr))
+   (labels ((rslt (gnrt1 gnrt2)
+           (declare (list gnrt1 gnrt2))
+           (unless gnrt1
+              (return-from rslt (if gnrt2 :less :equal)))
+           (unless gnrt2
+              (return-from rslt :greater))
+           (lexico
+            (funcall grcmpr (first gnrt1) (first gnrt2))
+            (rslt (rest gnrt1) (rest gnrt2)))
+         ))
+      (the cmprf #'rslt)))
+
+(defun bar-zgbasis (elements nullel)
+   (declare (type group-basis elements)
+     (type gnrt nullel))
+   (when (eq elements :locally-effective)
+      (return-from bar-zgbasis :locally-effective))
+   (labels ((rslt (degr)
+            (declare (fixnum degr))
+            ;;(the list
+              (progn
+               (when (minusp degr)
+                  (return-from rslt +empty-list+))
+               (when (zerop degr)
+                  (return-from rslt (list (list))))
+               (let ((basis-1 (rslt (1- degr)))
+                     (elements-0 (remove nullel elements)))
+                    (mapcan #'(lambda (gbar)
+                                (mapcar #'(lambda (g)
+                                            (append gbar (list g)))
+                                  elements-0)
+                                )
+                      basis-1)))))
+     ;;)
+     (the basis #'rslt)))
+                    
+                    
+
+(DEFUN bar-bndr-i (grmult nullel indx degr gnrt)
+   (declare
+    (fixnum indx degr)
+    (list gnrt))
+   (the cmbn
+     (cond ((zerop indx) (cmbn (1- degr) 1 (zggnrt (car gnrt) (rest gnrt))))
+           ((= indx degr) (cmbn (1- degr) 1 (zggnrt nullel (butlast gnrt))))
+           (t
+            (do ((rslt +empty-list+ (cons (car mark) rslt))
+                 (mark gnrt (cdr mark))
+                 (i 1 (1+ i)))
+                ((= i indx) (let ((new-k (funcall grmult (car mark) (cadr mark))))
+                                        (declare (type gnrt new-k))
+                               (if (equal nullel new-k)
+                                  (zero-cmbn (1- degr)) 
+                                  (cmbn (1- degr) 1 (zggnrt nullel (nreconc rslt (cons new-k (cddr mark))))))))
+               (declare
+                (list rslt mark)
+                (fixnum i)))))))
+
+
+(defun bar-bndr-intr (grcmpr grmult nullel)
+    #'(lambda (degr gnrt)
+        (if (zerop degr)
+           (zero-cmbn -1)
+           (let ((cmbn-list
+                  (mapcar #'(lambda (indx)
+                              (let ((cmbn (bar-bndr-i grmult nullel indx degr gnrt)))
+                                 (if (oddp indx)
+                                    (cons -1 cmbn)
+                                    (cons 1 cmbn))))
+                    (<a-b> 0 degr))))
+              (cmbn-cmbn (zggnrt-cmpr grcmpr (bar-zgcmpr grcmpr)) cmbn-list)))))
+     
+
+
+(defun bar-zgchcm (group)
+   (declare (type group group))
+  (the zg-chain-complex
+    (with-slots (elements cmpr mult nullel) group
+     (build-zgchcm
+      :group group
+      :zgcmpr (bar-zgcmpr cmpr)
+	:zgbasis (bar-zgbasis elements nullel)
+	:zgbsgn +empty-list+
+	:intr-zgbndr (bar-bndr-intr cmpr mult nullel)
+      :zgbndr-strt :gnrt
+	:orgn  `(bar-zgchcm ,group)))))
+
+(defun bar-cntrhmtp-intr (grcmpr grmult nullel)
+   #'(lambda (degr zggnrt)
+                      (with-zggnrt (gnrt1 gnrt2) zggnrt
+                        (if (equal nullel gnrt1)
+                           (zero-cmbn (1+ degr))
+                           (if (zerop degr)
+                              (cmbn 1 1 (zggnrt nullel (list gnrt1)))
+                              (cmbn (1+ degr) 1 (zggnrt nullel (cons gnrt1 gnrt2))))))))
+   
+
+(defun bar-f-intr ()
+   #'(lambda (degr zggnrt)
+       (if (zerop degr) (cmbn degr 1 :zgnrt) (zero-cmbn degr))))
+
+
+(defun bar-g-intr (nullel)
+   #'(lambda (degr gnrt)
+         (if (zerop degr) (cmbn degr 1 (zggnrt nullel +empty-list+)) (zero-cmbn degr))))
+
+(defun bar-rsltn (group)
+   (declare (type group group))
+   (the reduction
+    (with-slots (cmpr mult nullel) group
+      (let* ((zgchcm (bar-zgchcm group))
+             (f (build-mrph :sorc zgchcm :trgt (z-chcm) :degr 0 :intr (bar-f-intr) :strt :gnrt :orgn `(f-mrph in bar-resolution for ,group)))
+             (g (build-mrph :sorc (z-chcm) :trgt zgchcm :degr 0 :intr (bar-g-intr nullel) :strt :gnrt :orgn  `(g-mrph in bar-resolution for ,group)))
+             (h (build-mrph :sorc zgchcm :trgt zgchcm :degr 1 :intr (bar-cntrhmtp-intr cmpr mult nullel)
+                  :strt :gnrt :orgn `(h-mrph in bar-resolution for ,group))))
+         (build-rdct :f f :g g :h h :orgn `(Bar-resolution of ,group)))))) 
+
+
+                   
+;;; EJEMPLOS
+
+#|
+(setf z5 (cyclicgroup 5))
+(setf bar-chcm-z5 (bar-zgchcm z5))
+
+(setf zgbasis (zgbasis1 bar-chcm-z5))
+(funcall zgbasis 2)
+
+(setf zgmrph (zgbndr1 bar-chcm-z5))
+(ZGmrph-GNRT-? zgmrph 4 '(1 2 3 4))
+(ZGmrph-zgGNRT-? zgmrph 4 (zggnrt 2 '(1 2 3 4)))
+(ZGmrph-zgGNRT-? zgmrph 4 (zggnrt 1 '(1 1 4 4)))
+(ZGmrph-zgcmbn-? zgmrph (cmbn 4 1 (zggnrt 2 '(1 2 3 4)) -3 (zggnrt 1 '(1 1 4 4))))
+
+(setf chcm (chcm-twi bar-chcm-z5))
+(? chcm 4 '(1 2 3 4))
+(? chcm 5 '(1 1 2 3 4))
+
+
+(homology chcm 3)
+
+
+(setf bar-rsltn-z5 (bar-rsltn z5))
+(pre-check-rdct bar-rsltn-z5)
+
+(setf *tc* (cmbn 4 3 (zggnrt 4 '(1 2 1 4)) -3 (zggnrt 2 '(3 1 2 3)) 8 (zggnrt 1 '(4 4 3 2))))
+
+(setf *bc* (cmbn 0 1 :zgnrt))
+
+(check-rdct)
+
+
+
+|# 
+
+
+
+
+
+
+
+
+(defun K-G-1-cmpr (grcmpr)
+   (declare (type cmprf grcmpr))
+   (labels ((rslt (gnrt1 gnrt2)
+           (declare (list gnrt1 gnrt2))
+           (unless gnrt1
+              (return-from rslt (if gnrt2 :less :equal)))
+           (unless gnrt2
+              (return-from rslt :greater))
+           (lexico
+            (funcall grcmpr (first gnrt1) (first gnrt2))
+            (rslt (rest gnrt1) (rest gnrt2)))
+         ))
+      (the cmprf #'rslt)))
+
+
+#|
+(defun K-G-1-basis (elements nullel)
+   (declare (type group-basis elements)
+     (type gnrt nullel))
+   (when (eq elements :locally-effective)
+      (return-from K-G-1-basis :locally-effective))
+   (labels ((rslt (degr)
+            (declare (fixnum degr))
+            ;;(the list
+              (progn
+               (when (minusp degr)
+                  (return-from rslt +empty-list+))
+               (when (zerop degr)
+                  (return-from rslt (list (list))))
+               (let ((basis-1 (rslt (1- degr)))
+                     (elements-0 (remove nullel elements)))
+                    (mapcan #'(lambda (gbar)
+                                (mapcar #'(lambda (g)
+                                            (append gbar (list g)))
+                                  elements-0)
+                                )
+                      basis-1)))))
+     ;;)
+     (the basis #'rslt)))
+|#
+
+(defun K-G-1-basis (elements nullel)
+   (declare (type group-basis elements)
+     (type gnrt nullel))
+   (when (eq elements :locally-effective)
+      (return-from K-G-1-basis :locally-effective))
+   (labels ((rslt (degr)
+            (declare (fixnum degr))
+            ;;(the list
+              (progn
+               (when (minusp degr)
+                  (return-from rslt +empty-list+))
+               (when (zerop degr)
+                  (return-from rslt (list (list))))
+               (let ((basis-1 (rslt (1- degr)))
+                     (elements-0
+                      
+                  (do ((indx 0 (1+ indx))
+                      (aux +empty-list+))
+                    ((>= indx (length elements)) (nreverse aux))
+                    (if (not (equal nullel (nth indx elements)))
+                       (push (nth indx elements) aux)))))
+                     
+                   
+                    (mapcan #'(lambda (gbar)
+                                (mapcar #'(lambda (g)
+                                            (append gbar (list g)))
+                                  elements-0)
+                                )
+                      basis-1)))))
+     ;;)
+     (the basis #'rslt)))
+                    
+                    
+
+(DEFUN K-G-1-FACE (grmult nullel)
+   (flet ((face (indx dmns gmsm)
+            (declare
+             (fixnum indx dmns)
+             (list gmsm))
+            (the absm
+              (cond ((zerop indx) (absm 0 (rest gmsm)))
+                    ((= indx dmns) (absm 0 (butlast gmsm)))
+                    (t
+                     (do ((rslt +empty-list+ (cons (car mark) rslt))
+                          (mark gmsm (cdr mark))
+                          (i 1 (1+ i)))
+                         ((= i indx) (let ((new-k (funcall grmult (car mark) (cadr mark))))
+                                        (declare (type gnrt new-k))
+                                        (if (equal nullel new-k)
+                                           (absm (2-exp (1- indx)) (nreconc rslt (cddr mark)))
+                                           (absm 0 (nreconc rslt (cons new-k (cddr mark)))))))
+                        (declare
+                         (list rslt mark)
+                         (fixnum i))))))))
+     (the face #'face)))
+         
+   
+(DEFUN G-ABSM-BAR (nullel absm)
+  (declare (type absm absm))
+  (the list
+    (with-absm (dgop bar1) absm
+      (do ((dgop dgop (ash dgop -1))
+	   (rslt +empty-list+))
+	  ((and (zerop dgop) (endp bar1)) (nreverse rslt))
+	  (declare
+	     (fixnum dgop)
+	     (list rslt))
+	  (push (if (oddp dgop)
+		    nullel
+		  (pop bar1))
+		rslt)))))
+
+
+(DEFUN G-BAR-ABSM (nullel bar)
+  (declare (list bar))
+  (the absm
+     (do ((rslt-dgop 0)
+	  (rslt-bar +empty-list+)
+	  (mark bar (cdr mark))
+	  (bark 1 (+ bark bark)))
+	 ((endp mark) (absm rslt-dgop (nreverse rslt-bar)))
+	(declare
+	   (fixnum rslt-dgop bark)
+	   (list rslt-bar mark))
+	(let ((k-i (car mark)))
+	  (declare (fixnum k-i))
+	  (if (equal nullel k-i)
+	     (incf rslt-dgop bark)
+	     (push k-i rslt-bar))))))
+
+ 
+
+(DEFUN K-G-1-GRML (grmult nullel)
+   (flet ((grml (dmns crpr)
+            (declare
+             (fixnum dmns)
+             (type crpr crpr))
+            (the absm
+              (with-crpr (dgop1 bar1 dgop2 bar2) crpr
+                (do ((indx 1 (1+ indx))
+                     (dgop1 dgop1 (ash dgop1 -1))
+                     (dgop2 dgop2 (ash dgop2 -1))
+                     (bark 1 (ash bark +1))
+                     (rslt-dgop 0)
+                     (rslt-bar +empty-list+))
+                    ((> indx dmns) (absm rslt-dgop (nreverse rslt-bar)))
+                   (declare
+                    (fixnum indx dgop1 dgop2 bark rslt-dgop)
+		(list rslt-bar))
+                   (let ((item (if (evenp dgop1)
+                                  (if (evenp dgop2)
+                                     (funcall grmult (pop bar1) (pop bar2))
+                                     (pop bar1))
+                                  (if (evenp dgop2)
+                                     (pop bar2)
+                                     nullel))))
+                      (declare (type gnrt item))
+                      (if (equal nullel item)
+                         (incf rslt-dgop bark)
+                         (push item rslt-bar))))))))
+     (the intr-mrph #'grml)))
+
+
+(DEFUN K-G-1-GRIN (grin)
+   (flet ((grin (dmns bar)
+            (declare
+             (ignore dmns)
+             (list bar))
+            (the absm
+              (absm 0 (mapcar #'grin bar)))))
+     (the intr-mrph #'grin)))
+          
+
+
+(DEFMETHOD K-G-1 ((group GROUP))
+   (declare (type group group))
+  (the simplicial-group
+    (if (string= (car (orgn group)) 'z-group) 
+        (k-z-1)
+       
+       (with-slots (elements cmpr mult nullel inv) group
+         (build-smgr
+          :cmpr (k-g-1-cmpr cmpr)
+          :basis (k-g-1-basis elements nullel)
+          :bspn +empty-list+
+          :face (k-g-1-face mult nullel)
+          :sintr-grml (k-g-1-grml mult nullel)
+          :sintr-grin (k-g-1-grin inv)
+          :orgn  `(k-g-1 ,group)))
+       )))
+
+(DEFMETHOD K-G-1 ((group AB-GROUP))
+   (declare (type AB-group group))
+  (the AB-simplicial-group
+    (if (string= (car (orgn group)) 'z-group) 
+        (k-z-1)
+       (with-slots (elements cmpr mult nullel inv) group
+     (build-AB-smgr
+      :cmpr (k-g-1-cmpr cmpr)
+	:basis (k-g-1-basis elements nullel)
+	:bspn +empty-list+
+	:face (k-g-1-face mult nullel)
+	:sintr-grml (k-g-1-grml mult nullel)
+	:sintr-grin (k-g-1-grin inv)
+	:orgn  `(k-g-1 ,group)))
+    )))
+
+
+(defun K-G-0-basis (elements)
+   (declare (type group-basis elements))
+   (when (eq elements :locally-effective)
+      (return-from K-G-0-basis :locally-effective))
+   (labels ((rslt (degr)
+            (declare (fixnum degr))
+            ;;(the list
+              (progn
+               (when (not (equal degr 0))
+                  (return-from rslt +empty-list+))
+               (return-from rslt elements)
+               )))
+     ;;)
+     (the basis #'rslt)))
+
+
+
+(DEFUN K-G-0-FACE ()
+   (flet ((face (indx dmns gmsm)
+            (declare
+             (fixnum indx dmns)
+             (gnrt gmsm))
+            (the absm
+              (absm 0 gmsm))))
+     (the face #'face)))
+
+(DEFUN K-G-0-GRML (grmult)
+   (flet ((grml (dmns crpr)
+            (declare
+             (fixnum dmns)
+             (type crpr crpr))
+            (the absm
+              (with-crpr (dgop1 g1 dgop2 g2) crpr
+               (absm (dgop-ext-int (nreverse (<a-b> 0 (1- dmns)))) (funcall grmult g1 g2)))
+                )))
+     (the intr-mrph #'grml)))
+
+(DEFUN K-G-0-GRIN (grin)
+   (flet ((grin (dmns g)
+            (declare
+             (ignore dmns)
+             (gnrt g))
+            (the absm
+              (absm 0 (funcall grin g)))))
+     (the intr-mrph #'grin)))
+
+
+(DEFMETHOD K-G-0 ((group GROUP))
+   (declare (type group group))
+  (the simplicial-group
+    (with-slots (elements cmpr mult nullel inv) group
+     (build-smgr
+      :cmpr cmpr
+	:basis (k-g-0-basis elements)
+	:bspn nullel
+	:face (k-g-0-face)
+	:sintr-grml (k-g-0-grml mult)
+	:sintr-grin (k-g-0-grin inv)
+	:orgn  `(k-g-0 ,group)))
+    ))
+
+(DEFMETHOD K-G-0 ((group AB-GROUP))
+   (declare (type AB-group group))
+  (the AB-simplicial-group
+    (with-slots (elements cmpr mult nullel inv) group
+     (build-AB-smgr
+      :cmpr cmpr
+	:basis (k-g-0-basis elements)
+	:bspn nullel
+	:face (k-g-0-face)
+	:sintr-grml (k-g-0-grml mult)
+	:sintr-grin (k-g-0-grin inv)
+	:orgn  `(k-g-0 ,group)))
+
+    ))
+
+
+
+
+(DEFMETHOD K-G ((gROUP ab-group) n)
+   (declare (fixnum n)
+     (type AB-group group))
+   (the ab-simplicial-group
+     (if (= n 0)
+        (k-g-0 group)
+        (if (= n 1)
+           (k-g-1 group)
+           (classifying-space (k-g group (1- n)))))))
+
+(DEFMETHOD K-G ((group gROUP) n)
+   (declare (fixnum n)
+     (type group group))
+   (the simplicial-group
+     (if (= n 0)
+        (k-g-0 group)
+        (if (= n 1)
+           (k-g-1 group)
+           (classifying-space (k-g group (1- n)))))))
+
+(DEFUN K-ZP-1 (p)
+   (k-g-1 (cyclicgroup p)))
+
+(DEFUN K-Zp (p n)
+   (declare (fixnum p n)
+     )
+   (the ab-simplicial-group
+     (if (= n 0) 
+        (k-g-0 (cyclicgroup p))
+      (if (= n 1)
+         (k-Zp-1 p)
+         (classifying-space (k-Zp p (1- n)))))))
+
+
+(defun univ-fbrt-intr (G n)
+   (declare
+    (type group G)
+    (fixnum n))
+   (flet ((rslt (degr gmsm)
+            (declare 
+              (fixnum degr)
+              (type gnrt gmsm))
+            (if (equal n 1)
+               (absm (dgop-ext-int (nreverse (<a-b> 0 (- degr 2)))) (first (last gmsm)))
+               (with-gbar (d list) gmsm
+                 (first list)))))
+     (the sintr #'rslt)))
+            
+            
+(defun univ-fbrt-tw (G n)
+   (the fibration
+      (build-smmr
+         :sorc (k-g g n) :trgt (k-g g (1- n)) :degr -1
+         :sintr (univ-fbrt-intr G n)
+         :orgn `(universal fibration ,G ,n))))
+  
+
+(defun rsltn-zgchcm (rsltn)
+   (declare (type reduction rsltn))
+   (tcc rsltn))
+
+(defun rsltn-cntrhmtp (rsltn)
+   (declare (type reduction rsltn))
+   (h rsltn))
+   
+(defun 2rsltn-zgmrph-intr (rsltn1 rsltn2)
+   (let ((zgchcm1 (rsltn-zgchcm rsltn1))
+         (zgchcm2 (rsltn-zgchcm rsltn2))
+         (h2 (rsltn-cntrhmtp rsltn2))
+         (f1 (f rsltn1))
+         (g2 (g rsltn2))
+         (d1 (zgbndr1 (rsltn-zgchcm rsltn1))))
+      
+      (with-slots (group (zgcmpr2 zgcmpr)) zgchcm2
+        (with-slots ((grcmpr cmpr) mult nullel) group
+          (labels ((rslt (degr gnrt)
+                     (if (zerop degr)
+                        (? g2 (? f1 degr (zggnrt nullel gnrt)))
+                        (? h2 
+                          
+                          (with-cmbn (degr- list) (zgmrph-gnrt-? d1 degr gnrt)
+                            (let ((n-cmbn-list +empty-list+))
+                               (declare (list n-cmbn-list))
+                               (do ((mark list (cdr mark))
+                                    )
+                                   ((endp mark))
+                                  (declare (list mark))
+                                  (with-term (cffc ZGgnrt) (car mark) 
+                                    (push 
+                                      (cons cffc 
+                                        
+                                        (let* ((gnrt1 (zggnrt1 zggnrt))
+                                               (gnrt2 (zggnrt2 zggnrt))
+                                               (zgcmbn (rslt degr- gnrt2))
+                                               (list (cmbn-list zgcmbn))
+                                               (n-cmbn-list2 +empty-list+))
+                                           (declare (list n-cmbn-list2))
+                                           (if list 
+                                              (progn 
+                                                (mapcar #'(lambda (zgterm)
+                                                            (declare (type zgterm zgterm))
+                                                            (with-zgterm (cffc2 zggnrt2) zgterm
+                                                             (declare (type fixnum cffc2)
+                                                               (type zggnrt zggnrt2))
+                                                             (with-zggnrt (gnrt21 gnrt22) zggnrt2
+                                                              (declare (type gnrt gnrt21 gnrt22))
+                                                              (push (cons 1
+                                                                      (term-cmbn degr- cffc2 (zggnrt (funcall mult gnrt1 gnrt21) gnrt22)))
+                                                                n-cmbn-list2))))
+                                                  list)
+                                                (cmbn-cmbn (zggnrt-cmpr grcmpr zgcmpr2) n-cmbn-list2))
+                                              (zero-cmbn degr-))))
+                                        
+
+                                        n-cmbn-list)))
+                               (cmbn-cmbn (zggnrt-cmpr grcmpr zgcmpr2) n-cmbn-list)))))))
+            #'rslt)))))
+                          
+
+
+
+                    
+
+
+(defun 2rsltn-zgmrph (rsltn1 rsltn2)
+   (let ((zgchcm1 (rsltn-zgchcm rsltn1))
+         (zgchcm2 (rsltn-zgchcm rsltn2)))
+      (build-zgmrph :sorc zgchcm1 :trgt zgchcm2 :degr 0 :zgintr (2rsltn-zgmrph-intr rsltn1 rsltn2)
+       :zgstrt :gnrt :orgn `(ZG-morphism from ,rsltn1 to ,rsltn2))))
+
+
+#|
+
+(cat-init) 
+(setf z3 (cyclicgroup 3))
+(setf rsltn1 (cyclicgroup-rsltn 3))
+(setf rsltn2 (bar-rsltn z3))
+(setf f (2rsltn-zgmrph rsltn1 rsltn2))
+(setf g (2rsltn-zgmrph rsltn2 rsltn1))
+
+(setf zgchcm1 (rsltn-zgchcm rsltn1))
+(setf zgchcm2 (rsltn-zgchcm rsltn2))
+(setf f1 (f rsltn1)
+         g2 (g rsltn2))
+(setf d1 (zgbndr1 (rsltn-zgchcm rsltn1)))
+(setf h2 (rsltn-cntrhmtp rsltn2))
+(setf group (group1 zgchcm2) zgcmpr2 (zgcmpr1 zgchcm2))
+(setf grcmpr (cmpr1 group) mult (mult1 group) nullel (nullel group))
+
+(ZGmrph-GNRT-? f 0 0)
+(ZGmrph-zgGNRT-? f 0 (zggnrt 0 0))
+(ZGmrph-zgGNRT-? f 0 (zggnrt 1 0))
+(ZGmrph-zgGNRT-? f 0 (zggnrt 2 0))
+(ZGmrph-zgGNRT-? f 1 (zggnrt 0 1))
+(ZGmrph-zgGNRT-? f 1 (zggnrt 1 1))
+(ZGmrph-zgGNRT-? f 1 (zggnrt 2 1))
+
+(ZGmrph-zgGNRT-? f 2 (zggnrt 2 2))
+(? f 2 (zggnrt 2 2))
+
+
+(zgmrph-gnrt-? f 1 1)
+(setf f-intr (2rsltn-zgmrph-intr rsltn1 rsltn2))
+(funcall f-intr 1 1)
+
+     
+|#
+
+
+
+(defun 2rsltn-hmtpop-intr (rsltn1 rsltn2)
+   (let ((zgchcm1 (rsltn-zgchcm rsltn1))
+         (h1 (rsltn-cntrhmtp rsltn1))
+         (m (2rsltn-zgmrph rsltn1 rsltn2))
+         (n (2rsltn-zgmrph rsltn2 rsltn1))
+         (d1 (zgbndr1 (rsltn-zgchcm rsltn1))))
+      
+      
+      (with-slots (group (zgcmpr1 zgcmpr)) zgchcm1
+        (with-slots ((grcmpr cmpr) mult nullel) group
+          (let ((cmpr (zggnrt-cmpr grcmpr zgcmpr1)))
+             
+             (labels ((rslt (degr gnrt)
+                       (if (zerop degr)
+                        (2cmbn-sbtr cmpr (? h1 degr (zggnrt nullel gnrt)) 
+                                         (? h1 (zgmrph-zgcmbn-? n (zgmrph-gnrt-? m degr gnrt))))
+                          (2cmbn-sbtr cmpr (2cmbn-sbtr cmpr (? h1 degr (zggnrt nullel gnrt)) 
+                                         (? h1 (zgmrph-zgcmbn-? n (zgmrph-gnrt-? m degr gnrt))))
+                           (? h1 
+                             (with-cmbn (degr- list) (zgmrph-gnrt-? d1 degr gnrt)
+                            (let ((n-cmbn-list +empty-list+))
+                               (declare (list n-cmbn-list))
+                               (do ((mark list (cdr mark))
+                                    )
+                                   ((endp mark))
+                                  (declare (list mark))
+                                  (with-term (cffc ZGgnrt) (car mark) 
+                                    (push 
+                                      (cons cffc 
+                                        
+                                        (let* ((gnrt1 (zggnrt1 zggnrt))
+                                               (gnrt2 (zggnrt2 zggnrt))
+                                               (zgcmbn (rslt degr- gnrt2))
+                                               (list (cmbn-list zgcmbn))
+                                               (n-cmbn-list2 +empty-list+))
+                                           (declare (list n-cmbn-list2))
+                                           (if list 
+                                              (progn 
+                                                (mapcar #'(lambda (zgterm)
+                                                            (declare (type zgterm zgterm))
+                                                            (with-zgterm (cffc2 zggnrt2) zgterm
+                                                             (declare (type fixnum cffc2)
+                                                               (type zggnrt zggnrt2))
+                                                             (with-zggnrt (gnrt21 gnrt22) zggnrt2
+                                                              (declare (type gnrt gnrt21 gnrt22))
+                                                              (push (cons 1
+                                                                      (term-cmbn degr cffc2 (zggnrt (funcall mult gnrt1 gnrt21) gnrt22)))
+                                                                n-cmbn-list2))))
+                                                  list)
+                                                (cmbn-cmbn cmpr n-cmbn-list2))
+                                              (zero-cmbn degr))))
+                                        
+
+                                        n-cmbn-list)))
+                               (cmbn-cmbn cmpr n-cmbn-list)))
+                             
+                             
+                             
+                             
+                             
+                             
+                             
+                             
+                             )))))
+                          
+                          
+            #'rslt))))))
+
+(defun 2rsltn-hmtpop (rsltn1 rsltn2)
+   (let ((zgchcm1 (rsltn-zgchcm rsltn1))
+         )
+      (build-zgmrph :sorc zgchcm1 :trgt zgchcm1 :degr 1 :zgintr (2rsltn-hmtpop-intr rsltn1 rsltn2)
+       :zgstrt :gnrt :orgn `(ZG-homotopy-operator from ,rsltn1 to ,rsltn2))))
+
+
+
+#|
+
+(cat-init) 
+(setf z3 (cyclicgroup 3))
+(setf rsltn1 (cyclicgroup-rsltn 3))
+(setf rsltn2 (bar-rsltn z3))
+(setf f (2rsltn-zgmrph rsltn1 rsltn2))
+(setf g (2rsltn-zgmrph rsltn2 rsltn1))
+(setf k1 (2rsltn-hmtpop rsltn1 rsltn2))
+(setf k2 (2rsltn-hmtpop rsltn2 rsltn1))
+
+
+
+(setf zgchcm1 (rsltn-zgchcm rsltn1))
+(setf zgchcm2 (rsltn-zgchcm rsltn2))
+(setf d1 (zgbndr1 zgchcm1))
+(setf d2 (zgbndr1 zgchcm2))
+
+(setf iz1 (add (cmps d1 k1) (cmps k1 d1)))
+(setf drch1 (sbtr (idnt-mrph zgchcm1) (cmps g f)))
+
+(setf iz2 (add (cmps d2 k2) (cmps k2 d2)))
+(setf drch2 (sbtr (idnt-mrph zgchcm2) (cmps f g)))
+
+(? iz1 0 (zggnrt 0 0))
+(? drch1 0 (zggnrt 0 0))
+
+(? iz1 1 (zggnrt 0 1))
+(? drch1 1 (zggnrt 0 1))
+(? iz1 2 (zggnrt 0 2))
+(? drch1 2 (zggnrt 0 2))
+(? iz1 3 (zggnrt 0 3))
+(? drch1 3 (zggnrt 0 3))
+
+(? d1 (? k1 1 (zggnrt 0 1)))
+(? k1 (? d1 1 (zggnrt 0 1)))
+(? (cmps g f) 1 (zggnrt 0 1))
+(? f 1 (zggnrt 0 1))
+(? g (? f 1 (zggnrt 0 1)))
+
+
+(dotimes (i 6)
+   (progn
+    (print (? iz1 i (zggnrt 0 i)))
+    (print (? drch1 i (zggnrt 0 i)))
+))
+
+(? iz2 1 (zggnrt 0 '(1)))
+(? drch2 1 (zggnrt 0 '(1)))
+(? iz2 2 (zggnrt 0 '(2 1)))
+(? drch2 2 (zggnrt 0 '(2 1)))
+(? iz2 2 (zggnrt 0 '(1 1)))
+(? drch2 2 (zggnrt 0 '(1 1)))
+
+
+(? iz2 3 (zggnrt 0 '(1 1 2)))
+(? drch2 3 (zggnrt 0 '(1 1 2)))
+|#
+
+
+#| 
+(cat-init) 
+(setf z4 (cyclicgroup 4))
+(setf rsltn1 (bar-rsltn z4))
+(setf rsltn2 (cyclicgroup-rsltn 4))
+
+(setf f (2rsltn-zgmrph rsltn1 rsltn2))
+(setf g (2rsltn-zgmrph rsltn2 rsltn1))
+(setf h (2rsltn-hmtpop rsltn1 rsltn2))
+(setf k (2rsltn-hmtpop rsltn2 rsltn1))
+
+(setf zgchcm1 (rsltn-zgchcm rsltn1))
+(setf zgchcm2 (rsltn-zgchcm rsltn2))
+(setf d1 (zgbndr1 zgchcm1))
+(setf d2 (zgbndr1 zgchcm2))
+
+(setf h2 (rsltn-cntrhmtp rsltn2)
+         f1 (f rsltn1)
+         g2 (g rsltn2))
+
+(setf group (group1 zgchcm2)
+      zgcmpr2 (zgcmpr1 zgchcm2))
+
+(setf grcmpr (cmpr1 group) mult (mult1 group) nullel (nullel group))
+
+         
+
+
+
+(setf iz1 (add (cmps d1 h) (cmps h d1)))
+(setf drch1 (sbtr (idnt-mrph zgchcm1) (cmps g f)))
+
+(? iz1 0 (zggnrt 0 '()))
+(? drch1 0 (zggnrt 0 '()))
+(? f 0 (zggnrt 0 nil))
+
+(? iz1 1 (zggnrt 0 '(1)))
+(? drch1 1 (zggnrt 0 '(1)))
+(? f 1 (zggnrt 0 '(1)))
+
+
+(? iz1 2 (zggnrt 0 '(1 1)))
+(? drch1 2 (zggnrt 0 '(1 1)))
+
+(? iz1 3 (zggnrt 0 '(1 1 1)))
+(? drch1 3 (zggnrt 0 '(1 1 1)))
+
+(? iz1 4 (zggnrt 0 '(1 1 1 1)))
+(? drch1 4 (zggnrt 0 '(1 1 1 1)))
+
+(setf iz2 (add (cmps d2 k) (cmps k d2)))
+(setf drch2 (sbtr (idnt-mrph zgchcm2) (cmps f g)))
+
+(? iz2 4 (zggnrt 0 4))
+(? drch2 4 (zggnrt 0 4))
+
+
+|# 
+
+(defun K-Cm-n (m n)
+   (K-Zp m n))
+
+ 
\ No newline at end of file
diff --git a/examples/anromero/suspended-classifying-spaces-lisp-files/suspended-classifying-spaces-examples.cl b/examples/anromero/suspended-classifying-spaces-lisp-files/suspended-classifying-spaces-examples.cl
new file mode 100644
index 0000000..eacd832
--- /dev/null
+++ b/examples/anromero/suspended-classifying-spaces-lisp-files/suspended-classifying-spaces-examples.cl
@@ -0,0 +1,10036 @@
+International Allegro CL Enterprise Edition
+8.1 [Windows] (Nov 20, 2008 16:34)
+Copyright (C) 1985-2007, Franz Inc., Oakland, CA, USA.  All Rights Reserved.
+
+This development copy of Allegro CL is licensed to:
+   [TC16573] Universidad de La Rioja
+
+CG version 1.103.2.10 / IDE version 1.103.2.15
+Loaded options from C:\Documents and Settings\Ana\Mis documentos\allegro-prefs-8-1.cl.
+
+;; Optimization settings: safety 1, space 1, speed 1, debug 2.
+;; For a complete description of all compiler switches given the current optimization settings evaluate
+;; (EXPLAIN-COMPILER-SETTINGS).
+
+[changing package from "COMMON-LISP-USER" to "COMMON-GRAPHICS-USER"]
+CG-USER(1): (in-package :user)
+#<The COMMON-LISP-USER package>
+CL-USER(2): (progn
+              (load "cat-init")
+              (load-cfiles)
+              (load "resolutions")
+              (load "cylinders")
+              (load "omparsers")
+              (load "fundamental-classes")
+              (load "permutation-groups")
+              (load "homotopy"))
+
+; Loading C:\Archivos de programa\acl81\ana\cat-init.cl
+
+ FILE  1: macros
+ FILE  2: various
+ FILE  3: classes
+ FILE  4: combinations
+ FILE  5: chain-complexes
+ FILE  6: chcm-elementary-op
+ FILE  7: effective-homology
+ FILE  8: homology-groups
+ FILE  9: searching-homology
+ FILE 10: cones
+ FILE 11: bicones
+ FILE 12: tensor-products
+ FILE 13: coalgebras
+ FILE 14: cobar
+ FILE 15: algebras
+ FILE 16: bar
+ FILE 17: simplicial-sets
+ FILE 18: simplicial-mrphs
+ FILE 19: delta
+ FILE 20: special-smsts
+ FILE 21: suspensions
+ FILE 22: disk-pasting
+ FILE 23: cartesian-products
+ FILE 24: eilenberg-zilber
+ FILE 25: kan
+ FILE 26: simplicial-groups
+ FILE 27: fibrations
+ FILE 28: loop-spaces
+ FILE 29: ls-twisted-products
+ FILE 30: lp-space-efhm
+ FILE 31: classifying-spaces
+ FILE 32: k-pi-n
+ FILE 33: serre
+ FILE 34: cs-twisted-products
+ FILE 35: cl-space-efhm
+ FILE 36: whitehead
+ FILE 37: smith
+; Fast loading C:\Archivos de programa\acl81\macros.fasl
+; Fast loading C:\Archivos de programa\acl81\various.fasl
+; Fast loading C:\Archivos de programa\acl81\classes.fasl
+; Fast loading C:\Archivos de programa\acl81\combinations.fasl
+; Fast loading C:\Archivos de programa\acl81\chain-complexes.fasl
+; Fast loading C:\Archivos de programa\acl81\chcm-elementary-op.fasl
+; Fast loading C:\Archivos de programa\acl81\effective-homology.fasl
+; Fast loading C:\Archivos de programa\acl81\homology-groups.fasl
+; Fast loading C:\Archivos de programa\acl81\searching-homology.fasl
+; Fast loading C:\Archivos de programa\acl81\cones.fasl
+; Fast loading C:\Archivos de programa\acl81\bicones.fasl
+; Fast loading C:\Archivos de programa\acl81\tensor-products.fasl
+; Fast loading C:\Archivos de programa\acl81\coalgebras.fasl
+; Fast loading C:\Archivos de programa\acl81\cobar.fasl
+; Fast loading C:\Archivos de programa\acl81\algebras.fasl
+; Fast loading C:\Archivos de programa\acl81\bar.fasl
+; Fast loading C:\Archivos de programa\acl81\simplicial-sets.fasl
+; Fast loading C:\Archivos de programa\acl81\simplicial-mrphs.fasl
+; Fast loading C:\Archivos de programa\acl81\delta.fasl
+; Fast loading C:\Archivos de programa\acl81\special-smsts.fasl
+; Fast loading C:\Archivos de programa\acl81\suspensions.fasl
+; Fast loading C:\Archivos de programa\acl81\disk-pasting.fasl
+; Fast loading C:\Archivos de programa\acl81\cartesian-products.fasl
+; Fast loading C:\Archivos de programa\acl81\eilenberg-zilber.fasl
+; Fast loading C:\Archivos de programa\acl81\kan.fasl
+; Fast loading C:\Archivos de programa\acl81\simplicial-groups.fasl
+; Fast loading C:\Archivos de programa\acl81\fibrations.fasl
+; Fast loading C:\Archivos de programa\acl81\loop-spaces.fasl
+; Fast loading C:\Archivos de programa\acl81\ls-twisted-products.fasl
+; Fast loading C:\Archivos de programa\acl81\lp-space-efhm.fasl
+; Fast loading C:\Archivos de programa\acl81\classifying-spaces.fasl
+; Fast loading C:\Archivos de programa\acl81\k-pi-n.fasl
+; Fast loading C:\Archivos de programa\acl81\serre.fasl
+; Fast loading C:\Archivos de programa\acl81\cs-twisted-products.fasl
+; Fast loading C:\Archivos de programa\acl81\cl-space-efhm.fasl
+; Fast loading C:\Archivos de programa\acl81\whitehead.fasl
+; Fast loading C:\Archivos de programa\acl81\smith.fasl
+; Fast loading C:\Archivos de programa\acl81\resolutions.fasl
+; Fast loading C:\Archivos de programa\acl81\cylinders.fasl
+; Fast Loading C:\Archivos de programa\acl81\omparsers.fasl
+; Fast Loading C:\Archivos de programa\acl81\symmetricgroup.fasl
+; Fast Loading C:\Archivos de programa\acl81\fundamental-classes.fasl
+; Fast Loading C:\Archivos de programa\acl81\permutation-groups.fasl
+; Fast Loading C:\Archivos de programa\acl81\homotopy.fasl
+T
+CL-USER(3): (setf z5 (cyclicgroup 5))
+[K1 Abelian-Group]
+CL-USER(4): (setf k-z5-1 (k-g-1 z5))
+[K2 Abelian-Simplicial-Group]
+CL-USER(5): (efhm k-z5-1)
+[K50 Homotopy-Equivalence K2 <= K40 => K31]
+CL-USER(6): (homology k-z5-1 5)
+
+Computing boundary-matrix in dimension 5.
+Rank of the source-module : 1.
+
+
+;; Clock -> 2011-07-12, 10h 48m 45s.
+Computing the boundary of the generator 1/1 (dimension 5) :
+5 
+End of computing.
+
+
+Computing boundary-matrix in dimension 6.
+Rank of the source-module : 1.
+
+
+;; Clock -> 2011-07-12, 10h 48m 45s.
+Computing the boundary of the generator 1/1 (dimension 6) :
+6 
+End of computing.
+
+
+
+
+Homology in dimension 5 :
+
+
+Component Z/5Z
+
+
+---done---
+
+;; Clock -> 2011-07-12, 10h 48m 45s.
+
+NIL
+CL-USER(7): (setf s-k-z5-1 (suspension k-z5-1))
+[K51 Simplicial-Set]
+CL-USER(8): (efhm s-k-z5-1)
+[K68 Homotopy-Equivalence K51 <= K56 => K62]
+CL-USER(9): (homotopy s-k-z5-1 5)
+
+Computing boundary-matrix in dimension 1.
+Rank of the source-module : 0.
+
+
+Computing boundary-matrix in dimension 2.
+Rank of the source-module : 1.
+
+
+;; Clock -> 2011-07-12, 10h 50m 9s.
+Computing the boundary of the generator 1/1 (dimension 2) :
+1 
+End of computing.
+
+
+
+;; Clock -> 2011-07-12, 10h 50m 9s.
+
+
+Computing boundary-matrix in dimension 2.
+Rank of the source-module : 1.
+
+
+;; Clock -> 2011-07-12, 10h 50m 9s.
+Computing the boundary of the generator 1/1 (dimension 2) :
+1 
+End of computing.
+
+
+Computing boundary-matrix in dimension 3.
+Rank of the source-module : 1.
+
+
+;; Clock -> 2011-07-12, 10h 50m 9s.
+Computing the boundary of the generator 1/1 (dimension 3) :
+2 
+End of computing.
+
+
+
+;; Clock -> 2011-07-12, 10h 50m 9s.
+
+
+Computing boundary-matrix in dimension 2.
+Rank of the source-module : 1.
+
+
+;; Clock -> 2011-07-12, 10h 50m 9s.
+Computing the boundary of the generator 1/1 (dimension 2) :
+1 
+End of computing.
+
+
+Computing boundary-matrix in dimension 3.
+Rank of the source-module : 1.
+
+
+;; Clock -> 2011-07-12, 10h 50m 9s.
+Computing the boundary of the generator 1/1 (dimension 3) :
+2 
+End of computing.
+
+
+
+;; Clock -> 2011-07-12, 10h 50m 9s.
+
+
+Computing boundary-matrix in dimension 3.
+Rank of the source-module : 3.
+
+
+;; Clock -> 2011-07-12, 10h 50m 9s.
+Computing the boundary of the generator 1/3 (dimension 3) :
+<TnPr S-BSGN 3> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 9s.
+Computing the boundary of the generator 2/3 (dimension 3) :
+<TnPr 1 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 9s.
+Computing the boundary of the generator 3/3 (dimension 3) :
+<TnPr 2 0> 
+End of computing.
+
+
+Computing boundary-matrix in dimension 4.
+Rank of the source-module : 4.
+
+
+;; Clock -> 2011-07-12, 10h 50m 9s.
+Computing the boundary of the generator 1/4 (dimension 4) :
+<TnPr S-BSGN 4> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 9s.
+Computing the boundary of the generator 2/4 (dimension 4) :
+<TnPr 1 2> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 9s.
+Computing the boundary of the generator 3/4 (dimension 4) :
+<TnPr 2 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 9s.
+Computing the boundary of the generator 4/4 (dimension 4) :
+<TnPr 3 0> 
+End of computing.
+
+
+
+;; Clock -> 2011-07-12, 10h 50m 9s.
+
+
+Computing boundary-matrix in dimension 4.
+Rank of the source-module : 9.
+
+
+;; Clock -> 2011-07-12, 10h 50m 9s.
+Computing the boundary of the generator 1/9 (dimension 4) :
+<TnPr <TnPr S-BSGN 0> <<Abar[4 3]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 9s.
+Computing the boundary of the generator 2/9 (dimension 4) :
+<TnPr <TnPr S-BSGN 0> <<Abar[2 1][2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 9s.
+Computing the boundary of the generator 3/9 (dimension 4) :
+<TnPr <TnPr S-BSGN 1> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 9s.
+Computing the boundary of the generator 4/9 (dimension 4) :
+<TnPr <TnPr S-BSGN 2> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 9s.
+Computing the boundary of the generator 5/9 (dimension 4) :
+<TnPr <TnPr 1 0> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 9s.
+Computing the boundary of the generator 6/9 (dimension 4) :
+<TnPr <TnPr S-BSGN 4> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 9s.
+Computing the boundary of the generator 7/9 (dimension 4) :
+<TnPr <TnPr 1 2> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 9s.
+Computing the boundary of the generator 8/9 (dimension 4) :
+<TnPr <TnPr 2 1> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 9s.
+Computing the boundary of the generator 9/9 (dimension 4) :
+<TnPr <TnPr 3 0> <<Abar>>> 
+End of computing.
+
+
+Computing boundary-matrix in dimension 5.
+Rank of the source-module : 15.
+
+
+;; Clock -> 2011-07-12, 10h 50m 9s.
+Computing the boundary of the generator 1/15 (dimension 5) :
+<TnPr <TnPr S-BSGN 0> <<Abar[5 4]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 9s.
+Computing the boundary of the generator 2/15 (dimension 5) :
+<TnPr <TnPr S-BSGN 0> <<Abar[2 1][3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 10s.
+Computing the boundary of the generator 3/15 (dimension 5) :
+<TnPr <TnPr S-BSGN 0> <<Abar[3 2][2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 10s.
+Computing the boundary of the generator 4/15 (dimension 5) :
+<TnPr <TnPr S-BSGN 1> <<Abar[4 3]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 10s.
+Computing the boundary of the generator 5/15 (dimension 5) :
+<TnPr <TnPr S-BSGN 1> <<Abar[2 1][2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 10s.
+Computing the boundary of the generator 6/15 (dimension 5) :
+<TnPr <TnPr S-BSGN 2> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 10s.
+Computing the boundary of the generator 7/15 (dimension 5) :
+<TnPr <TnPr 1 0> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 10s.
+Computing the boundary of the generator 8/15 (dimension 5) :
+<TnPr <TnPr S-BSGN 3> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 10s.
+Computing the boundary of the generator 9/15 (dimension 5) :
+<TnPr <TnPr 1 1> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 10s.
+Computing the boundary of the generator 10/15 (dimension 5) :
+<TnPr <TnPr 2 0> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 10s.
+Computing the boundary of the generator 11/15 (dimension 5) :
+<TnPr <TnPr S-BSGN 5> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 10s.
+Computing the boundary of the generator 12/15 (dimension 5) :
+<TnPr <TnPr 1 3> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 10s.
+Computing the boundary of the generator 13/15 (dimension 5) :
+<TnPr <TnPr 2 2> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 11s.
+Computing the boundary of the generator 14/15 (dimension 5) :
+<TnPr <TnPr 3 1> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 11s.
+Computing the boundary of the generator 15/15 (dimension 5) :
+<TnPr <TnPr 4 0> <<Abar>>> 
+End of computing.
+
+
+
+;; Clock -> 2011-07-12, 10h 50m 11s.
+
+
+Computing boundary-matrix in dimension 5.
+Rank of the source-module : 21.
+
+
+;; Clock -> 2011-07-12, 10h 50m 11s.
+Computing the boundary of the generator 1/21 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar[5 <<Abar[4 3]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 11s.
+Computing the boundary of the generator 2/21 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar[5 <<Abar[2 1][2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 11s.
+Computing the boundary of the generator 3/21 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar>>> <<Abar[4 <<Abar[3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 11s.
+Computing the boundary of the generator 4/21 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[2 1]>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 11s.
+Computing the boundary of the generator 5/21 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 2> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 11s.
+Computing the boundary of the generator 6/21 (dimension 5) :
+<TnPr <TnPr <TnPr 1 0> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 11s.
+Computing the boundary of the generator 7/21 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[5 4]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 11s.
+Computing the boundary of the generator 8/21 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[2 1][3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 12s.
+Computing the boundary of the generator 9/21 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[3 2][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 12s.
+Computing the boundary of the generator 10/21 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar[4 3]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 12s.
+Computing the boundary of the generator 11/21 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar[2 1][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 12s.
+Computing the boundary of the generator 12/21 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 2> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 12s.
+Computing the boundary of the generator 13/21 (dimension 5) :
+<TnPr <TnPr <TnPr 1 0> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 12s.
+Computing the boundary of the generator 14/21 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 3> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 12s.
+Computing the boundary of the generator 15/21 (dimension 5) :
+<TnPr <TnPr <TnPr 1 1> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 12s.
+Computing the boundary of the generator 16/21 (dimension 5) :
+<TnPr <TnPr <TnPr 2 0> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 12s.
+Computing the boundary of the generator 17/21 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 5> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 13s.
+Computing the boundary of the generator 18/21 (dimension 5) :
+<TnPr <TnPr <TnPr 1 3> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 13s.
+Computing the boundary of the generator 19/21 (dimension 5) :
+<TnPr <TnPr <TnPr 2 2> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 19s.
+Computing the boundary of the generator 20/21 (dimension 5) :
+<TnPr <TnPr <TnPr 3 1> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 19s.
+Computing the boundary of the generator 21/21 (dimension 5) :
+<TnPr <TnPr <TnPr 4 0> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+Computing boundary-matrix in dimension 6.
+Rank of the source-module : 39.
+
+
+;; Clock -> 2011-07-12, 10h 50m 19s.
+Computing the boundary of the generator 1/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar[6 <<Abar[5 4]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 19s.
+Computing the boundary of the generator 2/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar[6 <<Abar[2 1][3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 19s.
+Computing the boundary of the generator 3/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar[6 <<Abar[3 2][2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 20s.
+Computing the boundary of the generator 4/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar[3 <<Abar[2 1]>>][3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 20s.
+Computing the boundary of the generator 5/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar>>> <<Abar[5 <<Abar[4 3]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 20s.
+Computing the boundary of the generator 6/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar>>> <<Abar[5 <<Abar[2 1][2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 20s.
+Computing the boundary of the generator 7/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[2 1]>>> <<Abar[4 <<Abar[3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 20s.
+Computing the boundary of the generator 8/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 2> <<Abar>>> <<Abar[4 <<Abar[3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 20s.
+Computing the boundary of the generator 9/39 (dimension 6) :
+<TnPr <TnPr <TnPr 1 0> <<Abar>>> <<Abar[4 <<Abar[3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 20s.
+Computing the boundary of the generator 10/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[3 2]>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 20s.
+Computing the boundary of the generator 11/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar[2 1]>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 20s.
+Computing the boundary of the generator 12/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 3> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 20s.
+Computing the boundary of the generator 13/39 (dimension 6) :
+<TnPr <TnPr <TnPr 1 1> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 20s.
+Computing the boundary of the generator 14/39 (dimension 6) :
+<TnPr <TnPr <TnPr 2 0> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 20s.
+Computing the boundary of the generator 15/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[6 5]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 21s.
+Computing the boundary of the generator 16/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[2 1][4 3]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 21s.
+Computing the boundary of the generator 17/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[3 2][3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 22s.
+Computing the boundary of the generator 18/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[4 3][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 22s.
+Computing the boundary of the generator 19/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[2 1][2 1][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 22s.
+Computing the boundary of the generator 20/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar[5 4]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 23s.
+Computing the boundary of the generator 21/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar[2 1][3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 24s.
+Computing the boundary of the generator 22/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar[3 2][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 24s.
+Computing the boundary of the generator 23/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 2> <<Abar[4 3]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 25s.
+Computing the boundary of the generator 24/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 2> <<Abar[2 1][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 26s.
+Computing the boundary of the generator 25/39 (dimension 6) :
+<TnPr <TnPr <TnPr 1 0> <<Abar[4 3]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 26s.
+Computing the boundary of the generator 26/39 (dimension 6) :
+<TnPr <TnPr <TnPr 1 0> <<Abar[2 1][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 26s.
+Computing the boundary of the generator 27/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 3> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 28s.
+Computing the boundary of the generator 28/39 (dimension 6) :
+<TnPr <TnPr <TnPr 1 1> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 30s.
+Computing the boundary of the generator 29/39 (dimension 6) :
+<TnPr <TnPr <TnPr 2 0> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 32s.
+Computing the boundary of the generator 30/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 4> <<Abar[2 1]>>> <<Abar>>> 
+*CR* -- Cut = 6.6320505e-4 -- N = 1332
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 35s.
+Computing the boundary of the generator 31/39 (dimension 6) :
+<TnPr <TnPr <TnPr 1 2> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 41s.
+Computing the boundary of the generator 32/39 (dimension 6) :
+<TnPr <TnPr <TnPr 2 1> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 46s.
+Computing the boundary of the generator 33/39 (dimension 6) :
+<TnPr <TnPr <TnPr 3 0> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 47s.
+Computing the boundary of the generator 34/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 6> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 50m 50s.
+Computing the boundary of the generator 35/39 (dimension 6) :
+<TnPr <TnPr <TnPr 1 4> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 51m 14s.
+Computing the boundary of the generator 36/39 (dimension 6) :
+<TnPr <TnPr <TnPr 2 3> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.0019053577 -- N = 3747
+*CR* -- Cut = 0.0030287788 -- N = 5565
+*CR* -- Cut = 0.0037655816 -- N = 7046
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 52m 42s.
+Computing the boundary of the generator 37/39 (dimension 6) :
+<TnPr <TnPr <TnPr 3 2> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.0045507667 -- N = 8614
+*CR* -- Cut = 0.005675921 -- N = 10577
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 53m 42s.
+Computing the boundary of the generator 38/39 (dimension 6) :
+<TnPr <TnPr <TnPr 4 1> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.0063750423 -- N = 11880
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 53m 55s.
+Computing the boundary of the generator 39/39 (dimension 6) :
+<TnPr <TnPr <TnPr 5 0> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+
+;; Clock -> 2011-07-12, 10h 53m 56s.
+
+
+Computing boundary-matrix in dimension 5.
+Rank of the source-module : 21.
+
+
+;; Clock -> 2011-07-12, 10h 53m 56s.
+Computing the boundary of the generator 1/21 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar[5 <<Abar[4 3]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 53m 56s.
+Computing the boundary of the generator 2/21 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar[5 <<Abar[2 1][2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 53m 56s.
+Computing the boundary of the generator 3/21 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar>>> <<Abar[4 <<Abar[3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 53m 56s.
+Computing the boundary of the generator 4/21 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[2 1]>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 53m 56s.
+Computing the boundary of the generator 5/21 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 2> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 53m 56s.
+Computing the boundary of the generator 6/21 (dimension 5) :
+<TnPr <TnPr <TnPr 1 0> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 53m 56s.
+Computing the boundary of the generator 7/21 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[5 4]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 53m 56s.
+Computing the boundary of the generator 8/21 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[2 1][3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 53m 56s.
+Computing the boundary of the generator 9/21 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[3 2][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 53m 56s.
+Computing the boundary of the generator 10/21 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar[4 3]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 53m 57s.
+Computing the boundary of the generator 11/21 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar[2 1][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 53m 57s.
+Computing the boundary of the generator 12/21 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 2> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 53m 57s.
+Computing the boundary of the generator 13/21 (dimension 5) :
+<TnPr <TnPr <TnPr 1 0> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 53m 57s.
+Computing the boundary of the generator 14/21 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 3> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 53m 57s.
+Computing the boundary of the generator 15/21 (dimension 5) :
+<TnPr <TnPr <TnPr 1 1> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 53m 57s.
+Computing the boundary of the generator 16/21 (dimension 5) :
+<TnPr <TnPr <TnPr 2 0> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 53m 57s.
+Computing the boundary of the generator 17/21 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 5> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 53m 57s.
+Computing the boundary of the generator 18/21 (dimension 5) :
+<TnPr <TnPr <TnPr 1 3> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 53m 58s.
+Computing the boundary of the generator 19/21 (dimension 5) :
+<TnPr <TnPr <TnPr 2 2> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 1s.
+Computing the boundary of the generator 20/21 (dimension 5) :
+<TnPr <TnPr <TnPr 3 1> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 2s.
+Computing the boundary of the generator 21/21 (dimension 5) :
+<TnPr <TnPr <TnPr 4 0> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+Computing boundary-matrix in dimension 6.
+Rank of the source-module : 39.
+
+
+;; Clock -> 2011-07-12, 10h 54m 2s.
+Computing the boundary of the generator 1/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar[6 <<Abar[5 4]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 2s.
+Computing the boundary of the generator 2/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar[6 <<Abar[2 1][3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 2s.
+Computing the boundary of the generator 3/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar[6 <<Abar[3 2][2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 2s.
+Computing the boundary of the generator 4/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar[3 <<Abar[2 1]>>][3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 2s.
+Computing the boundary of the generator 5/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar>>> <<Abar[5 <<Abar[4 3]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 2s.
+Computing the boundary of the generator 6/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar>>> <<Abar[5 <<Abar[2 1][2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 2s.
+Computing the boundary of the generator 7/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[2 1]>>> <<Abar[4 <<Abar[3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 2s.
+Computing the boundary of the generator 8/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 2> <<Abar>>> <<Abar[4 <<Abar[3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 2s.
+Computing the boundary of the generator 9/39 (dimension 6) :
+<TnPr <TnPr <TnPr 1 0> <<Abar>>> <<Abar[4 <<Abar[3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 2s.
+Computing the boundary of the generator 10/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[3 2]>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 2s.
+Computing the boundary of the generator 11/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar[2 1]>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 2s.
+Computing the boundary of the generator 12/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 3> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 2s.
+Computing the boundary of the generator 13/39 (dimension 6) :
+<TnPr <TnPr <TnPr 1 1> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 3s.
+Computing the boundary of the generator 14/39 (dimension 6) :
+<TnPr <TnPr <TnPr 2 0> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 3s.
+Computing the boundary of the generator 15/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[6 5]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 3s.
+Computing the boundary of the generator 16/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[2 1][4 3]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 3s.
+Computing the boundary of the generator 17/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[3 2][3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 4s.
+Computing the boundary of the generator 18/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[4 3][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 4s.
+Computing the boundary of the generator 19/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[2 1][2 1][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 4s.
+Computing the boundary of the generator 20/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar[5 4]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 4s.
+Computing the boundary of the generator 21/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar[2 1][3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 5s.
+Computing the boundary of the generator 22/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar[3 2][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 5s.
+Computing the boundary of the generator 23/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 2> <<Abar[4 3]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 5s.
+Computing the boundary of the generator 24/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 2> <<Abar[2 1][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 6s.
+Computing the boundary of the generator 25/39 (dimension 6) :
+<TnPr <TnPr <TnPr 1 0> <<Abar[4 3]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 6s.
+Computing the boundary of the generator 26/39 (dimension 6) :
+<TnPr <TnPr <TnPr 1 0> <<Abar[2 1][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 6s.
+Computing the boundary of the generator 27/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 3> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 7s.
+Computing the boundary of the generator 28/39 (dimension 6) :
+<TnPr <TnPr <TnPr 1 1> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 8s.
+Computing the boundary of the generator 29/39 (dimension 6) :
+<TnPr <TnPr <TnPr 2 0> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 10s.
+Computing the boundary of the generator 30/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 4> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 10s.
+Computing the boundary of the generator 31/39 (dimension 6) :
+<TnPr <TnPr <TnPr 1 2> <<Abar[2 1]>>> <<Abar>>> 
+*CR* -- Cut = 0.0068156803 -- N = 12771
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 14s.
+Computing the boundary of the generator 32/39 (dimension 6) :
+<TnPr <TnPr <TnPr 2 1> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 17s.
+Computing the boundary of the generator 33/39 (dimension 6) :
+<TnPr <TnPr <TnPr 3 0> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 17s.
+Computing the boundary of the generator 34/39 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 6> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 18s.
+Computing the boundary of the generator 35/39 (dimension 6) :
+<TnPr <TnPr <TnPr 1 4> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 27s.
+Computing the boundary of the generator 36/39 (dimension 6) :
+<TnPr <TnPr <TnPr 2 3> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.007411653 -- N = 13953
+*CR* -- Cut = 0.007767046 -- N = 14611
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 54m 54s.
+Computing the boundary of the generator 37/39 (dimension 6) :
+<TnPr <TnPr <TnPr 3 2> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.00818243 -- N = 15505
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 55m 9s.
+Computing the boundary of the generator 38/39 (dimension 6) :
+<TnPr <TnPr <TnPr 4 1> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 10h 55m 13s.
+Computing the boundary of the generator 39/39 (dimension 6) :
+<TnPr <TnPr <TnPr 5 0> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+
+;; Clock -> 2011-07-12, 10h 55m 13s.
+
+
+
+
+Homotopy in dimension 5 :
+
+
+Component Z/5Z
+
+Component Z/5Z
+
+NIL
+CL-USER(10): (setf z3 (cyclicgroup 3))
+[K627 Abelian-Group]
+CL-USER(11): (setf k-z3-1 (k-g-1 z3))
+[K628 Abelian-Simplicial-Group]
+CL-USER(12): (setf k-z3+3-1 (crts-prdc k-z3-1 k-z3-1))
+[K633 Simplicial-Set]
+CL-USER(13): (setf s-k-z3+3-1 (suspension k-z3+3-1))
+[K640 Simplicial-Set]
+CL-USER(14): (homotopy s-k-z3+3-1 4)
+
+Computing boundary-matrix in dimension 1.
+Rank of the source-module : 0.
+
+
+Computing boundary-matrix in dimension 2.
+Rank of the source-module : 2.
+
+
+;; Clock -> 2011-07-12, 11h 26m 14s.
+Computing the boundary of the generator 1/2 (dimension 2) :
+<TnPr 0 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 14s.
+Computing the boundary of the generator 2/2 (dimension 2) :
+<TnPr 1 0> 
+End of computing.
+
+
+
+;; Clock -> 2011-07-12, 11h 26m 14s.
+
+
+Computing boundary-matrix in dimension 2.
+Rank of the source-module : 2.
+
+
+;; Clock -> 2011-07-12, 11h 26m 14s.
+Computing the boundary of the generator 1/2 (dimension 2) :
+<TnPr 0 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 14s.
+Computing the boundary of the generator 2/2 (dimension 2) :
+<TnPr 1 0> 
+End of computing.
+
+
+Computing boundary-matrix in dimension 3.
+Rank of the source-module : 3.
+
+
+;; Clock -> 2011-07-12, 11h 26m 14s.
+Computing the boundary of the generator 1/3 (dimension 3) :
+<TnPr 0 2> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 14s.
+Computing the boundary of the generator 2/3 (dimension 3) :
+<TnPr 1 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 14s.
+Computing the boundary of the generator 3/3 (dimension 3) :
+<TnPr 2 0> 
+End of computing.
+
+
+
+;; Clock -> 2011-07-12, 11h 26m 14s.
+
+
+Computing boundary-matrix in dimension 2.
+Rank of the source-module : 2.
+
+
+;; Clock -> 2011-07-12, 11h 26m 14s.
+Computing the boundary of the generator 1/2 (dimension 2) :
+<TnPr 0 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 14s.
+Computing the boundary of the generator 2/2 (dimension 2) :
+<TnPr 1 0> 
+End of computing.
+
+
+Computing boundary-matrix in dimension 3.
+Rank of the source-module : 3.
+
+
+;; Clock -> 2011-07-12, 11h 26m 14s.
+Computing the boundary of the generator 1/3 (dimension 3) :
+<TnPr 0 2> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 14s.
+Computing the boundary of the generator 2/3 (dimension 3) :
+<TnPr 1 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 14s.
+Computing the boundary of the generator 3/3 (dimension 3) :
+<TnPr 2 0> 
+End of computing.
+
+
+
+;; Clock -> 2011-07-12, 11h 26m 14s.
+
+
+Computing boundary-matrix in dimension 3.
+Rank of the source-module : 11.
+
+
+;; Clock -> 2011-07-12, 11h 26m 14s.
+Computing the boundary of the generator 1/11 (dimension 3) :
+<TnPr <TnPr S-BSGN 0> 3> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 14s.
+Computing the boundary of the generator 2/11 (dimension 3) :
+<TnPr <TnPr S-BSGN 1> 2> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 14s.
+Computing the boundary of the generator 3/11 (dimension 3) :
+<TnPr <TnPr S-BSGN 2> 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 14s.
+Computing the boundary of the generator 4/11 (dimension 3) :
+<TnPr <TnPr <TnPr 0 1> 0> 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 14s.
+Computing the boundary of the generator 5/11 (dimension 3) :
+<TnPr <TnPr <TnPr 1 0> 0> 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 14s.
+Computing the boundary of the generator 6/11 (dimension 3) :
+<TnPr <TnPr S-BSGN 3> 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 14s.
+Computing the boundary of the generator 7/11 (dimension 3) :
+<TnPr <TnPr <TnPr 0 1> 1> 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 14s.
+Computing the boundary of the generator 8/11 (dimension 3) :
+<TnPr <TnPr <TnPr 1 0> 1> 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 14s.
+Computing the boundary of the generator 9/11 (dimension 3) :
+<TnPr <TnPr <TnPr 0 2> 0> 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 14s.
+Computing the boundary of the generator 10/11 (dimension 3) :
+<TnPr <TnPr <TnPr 1 1> 0> 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 14s.
+Computing the boundary of the generator 11/11 (dimension 3) :
+<TnPr <TnPr <TnPr 2 0> 0> 0> 
+End of computing.
+
+
+Computing boundary-matrix in dimension 4.
+Rank of the source-module : 21.
+
+
+;; Clock -> 2011-07-12, 11h 26m 15s.
+Computing the boundary of the generator 1/21 (dimension 4) :
+<TnPr <TnPr S-BSGN 0> 4> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 15s.
+Computing the boundary of the generator 2/21 (dimension 4) :
+<TnPr <TnPr S-BSGN 1> 3> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 15s.
+Computing the boundary of the generator 3/21 (dimension 4) :
+<TnPr <TnPr S-BSGN 2> 2> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 15s.
+Computing the boundary of the generator 4/21 (dimension 4) :
+<TnPr <TnPr <TnPr 0 1> 0> 2> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 15s.
+Computing the boundary of the generator 5/21 (dimension 4) :
+<TnPr <TnPr <TnPr 1 0> 0> 2> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 15s.
+Computing the boundary of the generator 6/21 (dimension 4) :
+<TnPr <TnPr S-BSGN 3> 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 15s.
+Computing the boundary of the generator 7/21 (dimension 4) :
+<TnPr <TnPr <TnPr 0 1> 1> 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 15s.
+Computing the boundary of the generator 8/21 (dimension 4) :
+<TnPr <TnPr <TnPr 1 0> 1> 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 15s.
+Computing the boundary of the generator 9/21 (dimension 4) :
+<TnPr <TnPr <TnPr 0 2> 0> 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 15s.
+Computing the boundary of the generator 10/21 (dimension 4) :
+<TnPr <TnPr <TnPr 1 1> 0> 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 15s.
+Computing the boundary of the generator 11/21 (dimension 4) :
+<TnPr <TnPr <TnPr 2 0> 0> 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 15s.
+Computing the boundary of the generator 12/21 (dimension 4) :
+<TnPr <TnPr S-BSGN 4> 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 15s.
+Computing the boundary of the generator 13/21 (dimension 4) :
+<TnPr <TnPr <TnPr 0 1> 2> 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 15s.
+Computing the boundary of the generator 14/21 (dimension 4) :
+<TnPr <TnPr <TnPr 1 0> 2> 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 15s.
+Computing the boundary of the generator 15/21 (dimension 4) :
+<TnPr <TnPr <TnPr 0 2> 1> 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 15s.
+Computing the boundary of the generator 16/21 (dimension 4) :
+<TnPr <TnPr <TnPr 1 1> 1> 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 15s.
+Computing the boundary of the generator 17/21 (dimension 4) :
+<TnPr <TnPr <TnPr 2 0> 1> 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 15s.
+Computing the boundary of the generator 18/21 (dimension 4) :
+<TnPr <TnPr <TnPr 0 3> 0> 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 15s.
+Computing the boundary of the generator 19/21 (dimension 4) :
+<TnPr <TnPr <TnPr 1 2> 0> 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 15s.
+Computing the boundary of the generator 20/21 (dimension 4) :
+<TnPr <TnPr <TnPr 2 1> 0> 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 15s.
+Computing the boundary of the generator 21/21 (dimension 4) :
+<TnPr <TnPr <TnPr 3 0> 0> 0> 
+End of computing.
+
+
+
+;; Clock -> 2011-07-12, 11h 26m 15s.
+
+
+*CR* -- Cut = 0.008484252 -- N = 16123
+Computing boundary-matrix in dimension 4.
+Rank of the source-module : 63.
+
+
+;; Clock -> 2011-07-12, 11h 26m 26s.
+Computing the boundary of the generator 1/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[4 3]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 26s.
+Computing the boundary of the generator 2/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1][2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 26s.
+Computing the boundary of the generator 3/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 26s.
+Computing the boundary of the generator 4/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 26s.
+Computing the boundary of the generator 5/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 26s.
+Computing the boundary of the generator 6/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 26s.
+Computing the boundary of the generator 7/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 26s.
+Computing the boundary of the generator 8/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 2> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 26s.
+Computing the boundary of the generator 9/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 26s.
+Computing the boundary of the generator 10/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 2> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 26s.
+Computing the boundary of the generator 11/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 26s.
+Computing the boundary of the generator 12/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 26s.
+Computing the boundary of the generator 13/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar>>> <<Abar[4 3]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 26s.
+Computing the boundary of the generator 14/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar>>> <<Abar[2 1][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 26s.
+Computing the boundary of the generator 15/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 1> <<Abar>>> <<Abar>>> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 27s.
+Computing the boundary of the generator 16/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 0> <<Abar>>> <<Abar>>> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 27s.
+Computing the boundary of the generator 17/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar[2 1]>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 27s.
+Computing the boundary of the generator 18/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar[2 1]>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 27s.
+Computing the boundary of the generator 19/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 2> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 27s.
+Computing the boundary of the generator 20/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 1> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 27s.
+Computing the boundary of the generator 21/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 2> 0> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 27s.
+Computing the boundary of the generator 22/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 0> 0> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 27s.
+Computing the boundary of the generator 23/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 0> 0> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 27s.
+Computing the boundary of the generator 24/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar[4 3]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 27s.
+Computing the boundary of the generator 25/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar[2 1][2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 27s.
+Computing the boundary of the generator 26/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 1> <<Abar>>> <<Abar[3 2]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 27s.
+Computing the boundary of the generator 27/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 0> <<Abar>>> <<Abar[3 2]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 28s.
+Computing the boundary of the generator 28/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar[2 1]>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 28s.
+Computing the boundary of the generator 29/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 2> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 28s.
+Computing the boundary of the generator 30/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 1> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 28s.
+Computing the boundary of the generator 31/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 2> 0> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 28s.
+Computing the boundary of the generator 32/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 0> 0> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 28s.
+Computing the boundary of the generator 33/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 0> 0> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 28s.
+Computing the boundary of the generator 34/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar[4 3]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 28s.
+Computing the boundary of the generator 35/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar[2 1][2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 29s.
+Computing the boundary of the generator 36/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 1> <<Abar[3 2]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 29s.
+Computing the boundary of the generator 37/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 0> <<Abar[3 2]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 29s.
+Computing the boundary of the generator 38/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 2> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 29s.
+Computing the boundary of the generator 39/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 1> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 29s.
+Computing the boundary of the generator 40/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 2> 0> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 30s.
+Computing the boundary of the generator 41/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 0> 0> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 30s.
+Computing the boundary of the generator 42/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 0> 0> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 30s.
+Computing the boundary of the generator 43/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 4> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 30s.
+Computing the boundary of the generator 44/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 3> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 30s.
+Computing the boundary of the generator 45/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 2> 2> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.008873884 -- N = 16836
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 32s.
+Computing the boundary of the generator 46/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 0> 2> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 34s.
+Computing the boundary of the generator 47/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 0> 2> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 36s.
+Computing the boundary of the generator 48/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 3> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 36s.
+Computing the boundary of the generator 49/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 1> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 38s.
+Computing the boundary of the generator 50/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 1> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 39s.
+Computing the boundary of the generator 51/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 2> 0> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 41s.
+Computing the boundary of the generator 52/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 1> 0> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 43s.
+Computing the boundary of the generator 53/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 2 0> 0> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 44s.
+Computing the boundary of the generator 54/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 4> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 45s.
+Computing the boundary of the generator 55/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 2> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 46s.
+Computing the boundary of the generator 56/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 2> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 48s.
+Computing the boundary of the generator 57/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 2> 1> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.009364715 -- N = 17500
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 49s.
+Computing the boundary of the generator 58/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 1> 1> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 51s.
+Computing the boundary of the generator 59/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 2 0> 1> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 52s.
+Computing the boundary of the generator 60/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 3> 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 52s.
+Computing the boundary of the generator 61/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 2> 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 54s.
+Computing the boundary of the generator 62/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 2 1> 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 55s.
+Computing the boundary of the generator 63/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 3 0> 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+Computing boundary-matrix in dimension 5.
+Rank of the source-module : 152.
+
+
+;; Clock -> 2011-07-12, 11h 26m 56s.
+Computing the boundary of the generator 1/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[5 4]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 56s.
+Computing the boundary of the generator 2/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1][3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 56s.
+Computing the boundary of the generator 3/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[3 2][2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 56s.
+Computing the boundary of the generator 4/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[4 3]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 56s.
+Computing the boundary of the generator 5/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1][2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 56s.
+Computing the boundary of the generator 6/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[4 3]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 56s.
+Computing the boundary of the generator 7/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1][2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 56s.
+Computing the boundary of the generator 8/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 56s.
+Computing the boundary of the generator 9/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 56s.
+Computing the boundary of the generator 10/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 56s.
+Computing the boundary of the generator 11/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 2> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 56s.
+Computing the boundary of the generator 12/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 56s.
+Computing the boundary of the generator 13/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 2> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 56s.
+Computing the boundary of the generator 14/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 56s.
+Computing the boundary of the generator 15/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 56s.
+Computing the boundary of the generator 16/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar>>> <<Abar[3 2]>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 56s.
+Computing the boundary of the generator 17/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 1> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 57s.
+Computing the boundary of the generator 18/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 0> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 57s.
+Computing the boundary of the generator 19/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar[3 2]>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 57s.
+Computing the boundary of the generator 20/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 1> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 57s.
+Computing the boundary of the generator 21/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 0> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 57s.
+Computing the boundary of the generator 22/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar[3 2]>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 57s.
+Computing the boundary of the generator 23/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 1> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 57s.
+Computing the boundary of the generator 24/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 0> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 57s.
+Computing the boundary of the generator 25/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 3> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 57s.
+Computing the boundary of the generator 26/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 2> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 58s.
+Computing the boundary of the generator 27/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 2> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 58s.
+Computing the boundary of the generator 28/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 0> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 58s.
+Computing the boundary of the generator 29/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 0> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 58s.
+Computing the boundary of the generator 30/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 3> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 58s.
+Computing the boundary of the generator 31/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 1> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 59s.
+Computing the boundary of the generator 32/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 1> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 59s.
+Computing the boundary of the generator 33/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 2> 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 59s.
+Computing the boundary of the generator 34/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 1> 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 59s.
+Computing the boundary of the generator 35/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 2 0> 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 26m 59s.
+Computing the boundary of the generator 36/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar>>> <<Abar[5 4]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 0s.
+Computing the boundary of the generator 37/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar>>> <<Abar[2 1][3 2]>>> <<Abar>>> 
+*CR* -- Cut = 0.009671103 -- N = 17912
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 0s.
+Computing the boundary of the generator 38/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar>>> <<Abar[3 2][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 0s.
+Computing the boundary of the generator 39/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 1> <<Abar>>> <<Abar>>> <<Abar[4 3]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 0s.
+Computing the boundary of the generator 40/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 1> <<Abar>>> <<Abar>>> <<Abar[2 1][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 0s.
+Computing the boundary of the generator 41/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 0> <<Abar>>> <<Abar>>> <<Abar[4 3]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 1s.
+Computing the boundary of the generator 42/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 0> <<Abar>>> <<Abar>>> <<Abar[2 1][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 1s.
+Computing the boundary of the generator 43/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar[2 1]>>> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 1s.
+Computing the boundary of the generator 44/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar[2 1]>>> <<Abar>>> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 1s.
+Computing the boundary of the generator 45/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 2> <<Abar>>> <<Abar>>> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 2s.
+Computing the boundary of the generator 46/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 1> <<Abar>>> <<Abar>>> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 2s.
+Computing the boundary of the generator 47/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 2> 0> <<Abar>>> <<Abar>>> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 3s.
+Computing the boundary of the generator 48/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 0> 0> <<Abar>>> <<Abar>>> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 3s.
+Computing the boundary of the generator 49/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 0> 0> <<Abar>>> <<Abar>>> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 4s.
+Computing the boundary of the generator 50/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar[3 2]>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 4s.
+Computing the boundary of the generator 51/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 1> <<Abar>>> <<Abar[2 1]>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 5s.
+Computing the boundary of the generator 52/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 0> <<Abar>>> <<Abar[2 1]>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 5s.
+Computing the boundary of the generator 53/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar[3 2]>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 5s.
+Computing the boundary of the generator 54/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 1> <<Abar[2 1]>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 5s.
+Computing the boundary of the generator 55/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 0> <<Abar[2 1]>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 6s.
+Computing the boundary of the generator 56/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 3> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 6s.
+Computing the boundary of the generator 57/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 2> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 7s.
+Computing the boundary of the generator 58/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 2> 1> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 8s.
+Computing the boundary of the generator 59/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 0> 1> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 9s.
+Computing the boundary of the generator 60/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 0> 1> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 10s.
+Computing the boundary of the generator 61/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 3> 0> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 10s.
+Computing the boundary of the generator 62/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 1> 0> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 11s.
+Computing the boundary of the generator 63/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 1> 0> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 12s.
+Computing the boundary of the generator 64/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 2> 0> 0> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 13s.
+Computing the boundary of the generator 65/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 1> 0> 0> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 14s.
+Computing the boundary of the generator 66/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 2 0> 0> 0> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 15s.
+Computing the boundary of the generator 67/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar[5 4]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 15s.
+Computing the boundary of the generator 68/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar[2 1][3 2]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 15s.
+Computing the boundary of the generator 69/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar[3 2][2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 16s.
+Computing the boundary of the generator 70/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 1> <<Abar>>> <<Abar[4 3]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 16s.
+Computing the boundary of the generator 71/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 1> <<Abar>>> <<Abar[2 1][2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 17s.
+Computing the boundary of the generator 72/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 0> <<Abar>>> <<Abar[4 3]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 17s.
+Computing the boundary of the generator 73/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 0> <<Abar>>> <<Abar[2 1][2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 18s.
+Computing the boundary of the generator 74/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar[2 1]>>> <<Abar[3 2]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 18s.
+Computing the boundary of the generator 75/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 2> <<Abar>>> <<Abar[3 2]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 20s.
+Computing the boundary of the generator 76/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 1> <<Abar>>> <<Abar[3 2]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 22s.
+Computing the boundary of the generator 77/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 2> 0> <<Abar>>> <<Abar[3 2]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 23s.
+Computing the boundary of the generator 78/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 0> 0> <<Abar>>> <<Abar[3 2]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 24s.
+Computing the boundary of the generator 79/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 0> 0> <<Abar>>> <<Abar[3 2]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 25s.
+Computing the boundary of the generator 80/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar[3 2]>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 26s.
+Computing the boundary of the generator 81/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 1> <<Abar[2 1]>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.010428162 -- N = 19091
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 27s.
+Computing the boundary of the generator 82/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 0> <<Abar[2 1]>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 27s.
+Computing the boundary of the generator 83/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 3> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 28s.
+Computing the boundary of the generator 84/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 2> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 30s.
+Computing the boundary of the generator 85/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 2> 1> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 32s.
+Computing the boundary of the generator 86/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 0> 1> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 36s.
+Computing the boundary of the generator 87/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 0> 1> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 38s.
+Computing the boundary of the generator 88/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 3> 0> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 39s.
+Computing the boundary of the generator 89/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 1> 0> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 41s.
+Computing the boundary of the generator 90/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 1> 0> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 43s.
+Computing the boundary of the generator 91/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 2> 0> 0> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 45s.
+Computing the boundary of the generator 92/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 1> 0> 0> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 47s.
+Computing the boundary of the generator 93/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 2 0> 0> 0> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 49s.
+Computing the boundary of the generator 94/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar[5 4]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 49s.
+Computing the boundary of the generator 95/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar[2 1][3 2]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 50s.
+Computing the boundary of the generator 96/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar[3 2][2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 51s.
+Computing the boundary of the generator 97/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 1> <<Abar[4 3]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 52s.
+Computing the boundary of the generator 98/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 1> <<Abar[2 1][2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 53s.
+Computing the boundary of the generator 99/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 0> <<Abar[4 3]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 54s.
+Computing the boundary of the generator 100/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 0> <<Abar[2 1][2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 55s.
+Computing the boundary of the generator 101/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 2> <<Abar[3 2]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 27m 58s.
+Computing the boundary of the generator 102/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 1> <<Abar[3 2]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 28m 2s.
+Computing the boundary of the generator 103/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 2> 0> <<Abar[3 2]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 28m 5s.
+Computing the boundary of the generator 104/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 0> 0> <<Abar[3 2]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.011627681 -- N = 20450
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 28m 7s.
+Computing the boundary of the generator 105/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 0> 0> <<Abar[3 2]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 28m 9s.
+Computing the boundary of the generator 106/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 3> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 28m 11s.
+Computing the boundary of the generator 107/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 2> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 28m 15s.
+Computing the boundary of the generator 108/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 2> 1> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 28m 20s.
+Computing the boundary of the generator 109/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 0> 1> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 28m 24s.
+Computing the boundary of the generator 110/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 0> 1> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 28m 28s.
+Computing the boundary of the generator 111/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 3> 0> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 28m 30s.
+Computing the boundary of the generator 112/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 1> 0> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 28m 34s.
+Computing the boundary of the generator 113/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 1> 0> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 28m 37s.
+Computing the boundary of the generator 114/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 2> 0> 0> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 28m 42s.
+Computing the boundary of the generator 115/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 1> 0> 0> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 28m 46s.
+Computing the boundary of the generator 116/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 2 0> 0> 0> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 28m 50s.
+Computing the boundary of the generator 117/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 5> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 28m 50s.
+Computing the boundary of the generator 118/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 4> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 28m 53s.
+Computing the boundary of the generator 119/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 2> 3> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.013046071 -- N = 21789
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 29m 1s.
+Computing the boundary of the generator 120/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 0> 3> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 29m 15s.
+Computing the boundary of the generator 121/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 0> 3> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 29m 27s.
+Computing the boundary of the generator 122/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 3> 2> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 29m 36s.
+Computing the boundary of the generator 123/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 1> 2> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.014317282 -- N = 22849
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 30m 13s.
+Computing the boundary of the generator 124/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 1> 2> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.015753578 -- N = 16408
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 30m 46s.
+Computing the boundary of the generator 125/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 2> 0> 2> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.013701802 -- N = 17436
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 31m 44s.
+Computing the boundary of the generator 126/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 1> 0> 2> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.015032681 -- N = 18066
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 32m 41s.
+Computing the boundary of the generator 127/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 2 0> 0> 2> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.016601875 -- N = 4967
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 33m 32s.
+Computing the boundary of the generator 128/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 4> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 33m 37s.
+Computing the boundary of the generator 129/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 2> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 34m 12s.
+Computing the boundary of the generator 130/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 2> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.011981033 -- N = 6448
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 34m 38s.
+Computing the boundary of the generator 131/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 2> 1> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 35m 18s.
+Computing the boundary of the generator 132/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 1> 1> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.014471108 -- N = 7937
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 35m 58s.
+Computing the boundary of the generator 133/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 2 0> 1> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 36m 33s.
+Computing the boundary of the generator 134/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 3> 0> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.01644922 -- N = 6611
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 36m 47s.
+Computing the boundary of the generator 135/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 2> 0> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 37m 29s.
+Computing the boundary of the generator 136/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 2 1> 0> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.017286744 -- N = 7003
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 38m 18s.
+Computing the boundary of the generator 137/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 3 0> 0> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 38m 29s.
+Computing the boundary of the generator 138/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 5> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 38m 30s.
+Computing the boundary of the generator 139/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 3> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 38m 42s.
+Computing the boundary of the generator 140/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 3> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 38m 50s.
+Computing the boundary of the generator 141/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 2> 2> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.018456804 -- N = 7390
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 39m 23s.
+Computing the boundary of the generator 142/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 1> 2> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 39m 55s.
+Computing the boundary of the generator 143/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 2 0> 2> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.020442575 -- N = 7937
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 40m 21s.
+Computing the boundary of the generator 144/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 3> 1> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 40m 31s.
+Computing the boundary of the generator 145/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 2> 1> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 41m 1s.
+Computing the boundary of the generator 146/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 2 1> 1> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.02240238 -- N = 8307
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 41m 33s.
+Computing the boundary of the generator 147/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 3 0> 1> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 41m 39s.
+Computing the boundary of the generator 148/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 4> 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 41m 43s.
+Computing the boundary of the generator 149/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 3> 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 41m 54s.
+Computing the boundary of the generator 150/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 2 2> 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.023798611 -- N = 8615
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 29s.
+Computing the boundary of the generator 151/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 3 1> 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 37s.
+Computing the boundary of the generator 152/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 4 0> 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+
+;; Clock -> 2011-07-12, 11h 42m 40s.
+
+
+Computing boundary-matrix in dimension 4.
+Rank of the source-module : 63.
+
+
+;; Clock -> 2011-07-12, 11h 42m 40s.
+Computing the boundary of the generator 1/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[4 3]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 40s.
+Computing the boundary of the generator 2/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1][2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 40s.
+Computing the boundary of the generator 3/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 40s.
+Computing the boundary of the generator 4/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 40s.
+Computing the boundary of the generator 5/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 40s.
+Computing the boundary of the generator 6/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 40s.
+Computing the boundary of the generator 7/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 40s.
+Computing the boundary of the generator 8/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 2> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 40s.
+Computing the boundary of the generator 9/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 40s.
+Computing the boundary of the generator 10/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 2> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 40s.
+Computing the boundary of the generator 11/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 40s.
+Computing the boundary of the generator 12/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 40s.
+Computing the boundary of the generator 13/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar>>> <<Abar[4 3]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 40s.
+Computing the boundary of the generator 14/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar>>> <<Abar[2 1][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 40s.
+Computing the boundary of the generator 15/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 1> <<Abar>>> <<Abar>>> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 40s.
+Computing the boundary of the generator 16/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 0> <<Abar>>> <<Abar>>> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 41s.
+Computing the boundary of the generator 17/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar[2 1]>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 41s.
+Computing the boundary of the generator 18/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar[2 1]>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 41s.
+Computing the boundary of the generator 19/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 2> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 41s.
+Computing the boundary of the generator 20/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 1> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 41s.
+Computing the boundary of the generator 21/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 2> 0> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 41s.
+Computing the boundary of the generator 22/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 0> 0> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 41s.
+Computing the boundary of the generator 23/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 0> 0> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 41s.
+Computing the boundary of the generator 24/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar[4 3]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 41s.
+Computing the boundary of the generator 25/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar[2 1][2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 41s.
+Computing the boundary of the generator 26/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 1> <<Abar>>> <<Abar[3 2]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 42s.
+Computing the boundary of the generator 27/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 0> <<Abar>>> <<Abar[3 2]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 42s.
+Computing the boundary of the generator 28/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar[2 1]>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 42s.
+Computing the boundary of the generator 29/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 2> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 42s.
+Computing the boundary of the generator 30/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 1> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 42s.
+Computing the boundary of the generator 31/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 2> 0> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 42s.
+Computing the boundary of the generator 32/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 0> 0> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 42s.
+Computing the boundary of the generator 33/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 0> 0> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 43s.
+Computing the boundary of the generator 34/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar[4 3]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 43s.
+Computing the boundary of the generator 35/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar[2 1][2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 43s.
+Computing the boundary of the generator 36/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 1> <<Abar[3 2]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 43s.
+Computing the boundary of the generator 37/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 0> <<Abar[3 2]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 44s.
+Computing the boundary of the generator 38/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 2> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 44s.
+Computing the boundary of the generator 39/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 1> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 45s.
+Computing the boundary of the generator 40/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 2> 0> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 45s.
+Computing the boundary of the generator 41/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 0> 0> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 46s.
+Computing the boundary of the generator 42/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 0> 0> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 46s.
+Computing the boundary of the generator 43/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 4> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 46s.
+Computing the boundary of the generator 44/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 3> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 46s.
+Computing the boundary of the generator 45/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 2> 2> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 47s.
+Computing the boundary of the generator 46/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 0> 2> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 48s.
+Computing the boundary of the generator 47/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 0> 2> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.024053123 -- N = 8716
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 50s.
+Computing the boundary of the generator 48/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 3> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 50s.
+Computing the boundary of the generator 49/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 1> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 51s.
+Computing the boundary of the generator 50/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 1> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 51s.
+Computing the boundary of the generator 51/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 2> 0> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 52s.
+Computing the boundary of the generator 52/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 1> 0> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 53s.
+Computing the boundary of the generator 53/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 2 0> 0> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 53s.
+Computing the boundary of the generator 54/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 4> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 53s.
+Computing the boundary of the generator 55/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 2> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 54s.
+Computing the boundary of the generator 56/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 2> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 54s.
+Computing the boundary of the generator 57/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 2> 1> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 55s.
+Computing the boundary of the generator 58/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 1> 1> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 55s.
+Computing the boundary of the generator 59/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 2 0> 1> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 56s.
+Computing the boundary of the generator 60/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 3> 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 56s.
+Computing the boundary of the generator 61/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 2> 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 56s.
+Computing the boundary of the generator 62/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 2 1> 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 57s.
+Computing the boundary of the generator 63/63 (dimension 4) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 3 0> 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+Computing boundary-matrix in dimension 5.
+Rank of the source-module : 152.
+
+
+;; Clock -> 2011-07-12, 11h 42m 57s.
+Computing the boundary of the generator 1/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[5 4]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 57s.
+Computing the boundary of the generator 2/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1][3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 57s.
+Computing the boundary of the generator 3/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[3 2][2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 57s.
+Computing the boundary of the generator 4/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[4 3]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 57s.
+Computing the boundary of the generator 5/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1][2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 57s.
+Computing the boundary of the generator 6/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[4 3]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 57s.
+Computing the boundary of the generator 7/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1][2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 57s.
+Computing the boundary of the generator 8/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 57s.
+Computing the boundary of the generator 9/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 58s.
+Computing the boundary of the generator 10/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 58s.
+Computing the boundary of the generator 11/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 2> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 58s.
+Computing the boundary of the generator 12/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 58s.
+Computing the boundary of the generator 13/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 2> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 58s.
+Computing the boundary of the generator 14/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 58s.
+Computing the boundary of the generator 15/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 58s.
+Computing the boundary of the generator 16/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar>>> <<Abar[3 2]>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 58s.
+Computing the boundary of the generator 17/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 1> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 58s.
+Computing the boundary of the generator 18/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 0> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 58s.
+Computing the boundary of the generator 19/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar[3 2]>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 59s.
+Computing the boundary of the generator 20/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 1> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 59s.
+Computing the boundary of the generator 21/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 0> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 59s.
+Computing the boundary of the generator 22/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar[3 2]>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 59s.
+Computing the boundary of the generator 23/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 1> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 59s.
+Computing the boundary of the generator 24/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 0> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 42m 59s.
+Computing the boundary of the generator 25/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 3> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 0s.
+Computing the boundary of the generator 26/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 2> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 0s.
+Computing the boundary of the generator 27/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 2> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 0s.
+Computing the boundary of the generator 28/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 0> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 0s.
+Computing the boundary of the generator 29/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 0> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 0s.
+Computing the boundary of the generator 30/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 3> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 0s.
+Computing the boundary of the generator 31/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 1> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 1s.
+Computing the boundary of the generator 32/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 1> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 1s.
+Computing the boundary of the generator 33/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 2> 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 1s.
+Computing the boundary of the generator 34/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 1> 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 1s.
+Computing the boundary of the generator 35/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 2 0> 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 1s.
+Computing the boundary of the generator 36/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar>>> <<Abar[5 4]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 1s.
+Computing the boundary of the generator 37/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar>>> <<Abar[2 1][3 2]>>> <<Abar>>> 
+*CR* -- Cut = 0.023999266 -- N = 8751
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 2s.
+Computing the boundary of the generator 38/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar>>> <<Abar[3 2][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 2s.
+Computing the boundary of the generator 39/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 1> <<Abar>>> <<Abar>>> <<Abar[4 3]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 2s.
+Computing the boundary of the generator 40/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 1> <<Abar>>> <<Abar>>> <<Abar[2 1][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 2s.
+Computing the boundary of the generator 41/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 0> <<Abar>>> <<Abar>>> <<Abar[4 3]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 3s.
+Computing the boundary of the generator 42/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 0> <<Abar>>> <<Abar>>> <<Abar[2 1][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 3s.
+Computing the boundary of the generator 43/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar[2 1]>>> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 3s.
+Computing the boundary of the generator 44/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar[2 1]>>> <<Abar>>> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 3s.
+Computing the boundary of the generator 45/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 2> <<Abar>>> <<Abar>>> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 4s.
+Computing the boundary of the generator 46/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 1> <<Abar>>> <<Abar>>> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 4s.
+Computing the boundary of the generator 47/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 2> 0> <<Abar>>> <<Abar>>> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 5s.
+Computing the boundary of the generator 48/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 0> 0> <<Abar>>> <<Abar>>> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 5s.
+Computing the boundary of the generator 49/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 0> 0> <<Abar>>> <<Abar>>> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 5s.
+Computing the boundary of the generator 50/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar[3 2]>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 5s.
+Computing the boundary of the generator 51/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 1> <<Abar>>> <<Abar[2 1]>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 6s.
+Computing the boundary of the generator 52/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 0> <<Abar>>> <<Abar[2 1]>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 6s.
+Computing the boundary of the generator 53/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar[3 2]>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 6s.
+Computing the boundary of the generator 54/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 1> <<Abar[2 1]>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 6s.
+Computing the boundary of the generator 55/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 0> <<Abar[2 1]>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 7s.
+Computing the boundary of the generator 56/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 3> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 7s.
+Computing the boundary of the generator 57/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 2> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 8s.
+Computing the boundary of the generator 58/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 2> 1> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 8s.
+Computing the boundary of the generator 59/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 0> 1> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 9s.
+Computing the boundary of the generator 60/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 0> 1> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 9s.
+Computing the boundary of the generator 61/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 3> 0> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 10s.
+Computing the boundary of the generator 62/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 1> 0> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 10s.
+Computing the boundary of the generator 63/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 1> 0> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 11s.
+Computing the boundary of the generator 64/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 2> 0> 0> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 11s.
+Computing the boundary of the generator 65/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 1> 0> 0> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 12s.
+Computing the boundary of the generator 66/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 2 0> 0> 0> <<Abar>>> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 12s.
+Computing the boundary of the generator 67/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar[5 4]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 12s.
+Computing the boundary of the generator 68/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar[2 1][3 2]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 12s.
+Computing the boundary of the generator 69/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar>>> <<Abar[3 2][2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 13s.
+Computing the boundary of the generator 70/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 1> <<Abar>>> <<Abar[4 3]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 13s.
+Computing the boundary of the generator 71/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 1> <<Abar>>> <<Abar[2 1][2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 13s.
+Computing the boundary of the generator 72/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 0> <<Abar>>> <<Abar[4 3]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 13s.
+Computing the boundary of the generator 73/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 0> <<Abar>>> <<Abar[2 1][2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 13s.
+Computing the boundary of the generator 74/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar[2 1]>>> <<Abar[3 2]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 14s.
+Computing the boundary of the generator 75/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 2> <<Abar>>> <<Abar[3 2]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 14s.
+Computing the boundary of the generator 76/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 1> <<Abar>>> <<Abar[3 2]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 15s.
+Computing the boundary of the generator 77/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 2> 0> <<Abar>>> <<Abar[3 2]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 16s.
+Computing the boundary of the generator 78/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 0> 0> <<Abar>>> <<Abar[3 2]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 17s.
+Computing the boundary of the generator 79/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 0> 0> <<Abar>>> <<Abar[3 2]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 17s.
+Computing the boundary of the generator 80/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar[3 2]>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 17s.
+Computing the boundary of the generator 81/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 1> <<Abar[2 1]>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 18s.
+Computing the boundary of the generator 82/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 0> <<Abar[2 1]>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 18s.
+Computing the boundary of the generator 83/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 3> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 19s.
+Computing the boundary of the generator 84/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 2> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 20s.
+Computing the boundary of the generator 85/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 2> 1> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 21s.
+Computing the boundary of the generator 86/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 0> 1> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 22s.
+Computing the boundary of the generator 87/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 0> 1> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 23s.
+Computing the boundary of the generator 88/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 3> 0> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 23s.
+Computing the boundary of the generator 89/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 1> 0> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 24s.
+Computing the boundary of the generator 90/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 1> 0> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.024359837 -- N = 8862
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 25s.
+Computing the boundary of the generator 91/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 2> 0> 0> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 25s.
+Computing the boundary of the generator 92/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 1> 0> 0> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 26s.
+Computing the boundary of the generator 93/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 2 0> 0> 0> <<Abar>>> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 26s.
+Computing the boundary of the generator 94/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar[5 4]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 26s.
+Computing the boundary of the generator 95/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar[2 1][3 2]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 27s.
+Computing the boundary of the generator 96/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 0> <<Abar[3 2][2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 27s.
+Computing the boundary of the generator 97/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 1> <<Abar[4 3]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 27s.
+Computing the boundary of the generator 98/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 1> <<Abar[2 1][2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 27s.
+Computing the boundary of the generator 99/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 0> <<Abar[4 3]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 28s.
+Computing the boundary of the generator 100/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 0> <<Abar[2 1][2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 28s.
+Computing the boundary of the generator 101/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 2> <<Abar[3 2]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 29s.
+Computing the boundary of the generator 102/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 1> <<Abar[3 2]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 29s.
+Computing the boundary of the generator 103/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 2> 0> <<Abar[3 2]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 30s.
+Computing the boundary of the generator 104/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 0> 0> <<Abar[3 2]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 31s.
+Computing the boundary of the generator 105/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 0> 0> <<Abar[3 2]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 31s.
+Computing the boundary of the generator 106/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 3> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 32s.
+Computing the boundary of the generator 107/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 2> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 33s.
+Computing the boundary of the generator 108/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 2> 1> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 34s.
+Computing the boundary of the generator 109/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 0> 1> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 36s.
+Computing the boundary of the generator 110/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 0> 1> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 37s.
+Computing the boundary of the generator 111/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 3> 0> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 37s.
+Computing the boundary of the generator 112/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 1> 0> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 38s.
+Computing the boundary of the generator 113/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 1> 0> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 39s.
+Computing the boundary of the generator 114/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 2> 0> 0> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 40s.
+Computing the boundary of the generator 115/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 1> 0> 0> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 41s.
+Computing the boundary of the generator 116/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 2 0> 0> 0> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 42s.
+Computing the boundary of the generator 117/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> 5> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 42s.
+Computing the boundary of the generator 118/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> 4> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 43s.
+Computing the boundary of the generator 119/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 2> 3> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 44s.
+Computing the boundary of the generator 120/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 0> 3> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 46s.
+Computing the boundary of the generator 121/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 0> 3> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.024477713 -- N = 8980
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 49s.
+Computing the boundary of the generator 122/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 3> 2> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 49s.
+Computing the boundary of the generator 123/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 1> 2> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 56s.
+Computing the boundary of the generator 124/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 1> 2> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 43m 57s.
+Computing the boundary of the generator 125/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 2> 0> 2> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 44m 4s.
+Computing the boundary of the generator 126/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 1> 0> 2> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.024651775 -- N = 9089
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 44m 15s.
+Computing the boundary of the generator 127/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 2 0> 0> 2> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 44m 16s.
+Computing the boundary of the generator 128/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 4> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 44m 17s.
+Computing the boundary of the generator 129/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 2> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 44m 22s.
+Computing the boundary of the generator 130/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 2> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 44m 26s.
+Computing the boundary of the generator 131/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 2> 1> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.02475143 -- N = 9176
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 44m 30s.
+Computing the boundary of the generator 132/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 1> 1> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 44m 35s.
+Computing the boundary of the generator 133/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 2 0> 1> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 44m 38s.
+Computing the boundary of the generator 134/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 3> 0> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 44m 41s.
+Computing the boundary of the generator 135/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 2> 0> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 44m 44s.
+Computing the boundary of the generator 136/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 2 1> 0> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 44m 50s.
+Computing the boundary of the generator 137/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 3 0> 0> 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.024916824 -- N = 9269
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 44m 52s.
+Computing the boundary of the generator 138/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 5> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 44m 52s.
+Computing the boundary of the generator 139/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 1> 3> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 44m 53s.
+Computing the boundary of the generator 140/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 0> 3> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 44m 54s.
+Computing the boundary of the generator 141/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 2> 2> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 44m 56s.
+Computing the boundary of the generator 142/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 1> 2> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 44m 58s.
+Computing the boundary of the generator 143/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 2 0> 2> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 44m 59s.
+Computing the boundary of the generator 144/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 3> 1> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 45m 0s.
+Computing the boundary of the generator 145/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 2> 1> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 45m 3s.
+Computing the boundary of the generator 146/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 2 1> 1> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.024949644 -- N = 9336
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 45m 10s.
+Computing the boundary of the generator 147/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 3 0> 1> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 45m 10s.
+Computing the boundary of the generator 148/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 0 4> 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 45m 11s.
+Computing the boundary of the generator 149/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 1 3> 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 45m 13s.
+Computing the boundary of the generator 150/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 2 2> 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 45m 18s.
+Computing the boundary of the generator 151/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 3 1> 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 11h 45m 19s.
+Computing the boundary of the generator 152/152 (dimension 5) :
+<TnPr <TnPr <TnPr <TnPr <TnPr <TnPr <TnPr 4 0> 0> 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+
+;; Clock -> 2011-07-12, 11h 45m 19s.
+
+
+
+
+Homotopy in dimension 4 :
+
+
+Component Z/3Z
+
+Component Z/3Z
+
+Component Z/3Z
+
+Component Z/3Z
+
+Component Z/3Z
+
+Component Z/3Z
+
+Component Z/3Z
+
+Component Z/3Z
+
+NIL
+CL-USER(15): (setf z (z-group))
+[K1423 Abelian-Group]
+CL-USER(16): (setf k-z-1 (k-g-1 z))
+[K1424 Abelian-Simplicial-Group]
+CL-USER(17): (setf s-k-z-1 (suspension k-z-1))
+[K1436 Simplicial-Set]
+CL-USER(18): (homotopy s-k-z-1 2)
+
+Computing boundary-matrix in dimension 1.
+Rank of the source-module : 0.
+
+
+Computing boundary-matrix in dimension 2.
+Rank of the source-module : 1.
+
+
+;; Clock -> 2011-07-12, 12h 48m 0s.
+Computing the boundary of the generator 1/1 (dimension 2) :
+S1 
+End of computing.
+
+
+
+;; Clock -> 2011-07-12, 12h 48m 0s.
+
+
+Computing boundary-matrix in dimension 2.
+Rank of the source-module : 1.
+
+
+;; Clock -> 2011-07-12, 12h 48m 0s.
+Computing the boundary of the generator 1/1 (dimension 2) :
+S1 
+End of computing.
+
+
+Computing boundary-matrix in dimension 3.
+Rank of the source-module : 0.
+
+
+
+;; Clock -> 2011-07-12, 12h 48m 0s.
+
+
+Computing boundary-matrix in dimension 2.
+Rank of the source-module : 1.
+
+
+;; Clock -> 2011-07-12, 12h 48m 0s.
+Computing the boundary of the generator 1/1 (dimension 2) :
+S1 
+End of computing.
+
+
+Computing boundary-matrix in dimension 3.
+Rank of the source-module : 0.
+
+
+
+;; Clock -> 2011-07-12, 12h 48m 0s.
+
+
+Computing boundary-matrix in dimension 2.
+Rank of the source-module : 1.
+
+
+;; Clock -> 2011-07-12, 12h 48m 0s.
+Computing the boundary of the generator 1/1 (dimension 2) :
+S1 
+End of computing.
+
+
+Computing boundary-matrix in dimension 3.
+Rank of the source-module : 0.
+
+
+
+;; Clock -> 2011-07-12, 12h 48m 0s.
+
+
+
+
+Homotopy in dimension 2 :
+
+
+Component Z
+
+NIL
+CL-USER(19):  (homotopy s-k-z-1 3)
+
+Computing boundary-matrix in dimension 1.
+Rank of the source-module : 0.
+
+
+Computing boundary-matrix in dimension 2.
+Rank of the source-module : 1.
+
+
+;; Clock -> 2011-07-12, 12h 48m 4s.
+Computing the boundary of the generator 1/1 (dimension 2) :
+S1 
+End of computing.
+
+
+
+;; Clock -> 2011-07-12, 12h 48m 4s.
+
+
+Computing boundary-matrix in dimension 2.
+Rank of the source-module : 1.
+
+
+;; Clock -> 2011-07-12, 12h 48m 4s.
+Computing the boundary of the generator 1/1 (dimension 2) :
+S1 
+End of computing.
+
+
+Computing boundary-matrix in dimension 3.
+Rank of the source-module : 0.
+
+
+
+;; Clock -> 2011-07-12, 12h 48m 4s.
+
+
+Computing boundary-matrix in dimension 2.
+Rank of the source-module : 1.
+
+
+;; Clock -> 2011-07-12, 12h 48m 4s.
+Computing the boundary of the generator 1/1 (dimension 2) :
+S1 
+End of computing.
+
+
+Computing boundary-matrix in dimension 3.
+Rank of the source-module : 0.
+
+
+
+;; Clock -> 2011-07-12, 12h 48m 4s.
+
+
+Computing boundary-matrix in dimension 3.
+Rank of the source-module : 1.
+
+
+;; Clock -> 2011-07-12, 12h 48m 4s.
+Computing the boundary of the generator 1/1 (dimension 3) :
+<TnPr S1 S1> 
+End of computing.
+
+
+Computing boundary-matrix in dimension 4.
+Rank of the source-module : 0.
+
+
+
+;; Clock -> 2011-07-12, 12h 48m 4s.
+
+
+Computing boundary-matrix in dimension 3.
+Rank of the source-module : 1.
+
+
+;; Clock -> 2011-07-12, 12h 48m 4s.
+Computing the boundary of the generator 1/1 (dimension 3) :
+<TnPr S1 S1> 
+End of computing.
+
+
+Computing boundary-matrix in dimension 4.
+Rank of the source-module : 0.
+
+
+
+;; Clock -> 2011-07-12, 12h 48m 4s.
+
+
+
+
+Homotopy in dimension 3 :
+
+
+Component Z
+
+NIL
+CL-USER(20):  (homotopy s-k-z-1 4)
+
+Computing boundary-matrix in dimension 1.
+Rank of the source-module : 0.
+
+
+Computing boundary-matrix in dimension 2.
+Rank of the source-module : 1.
+
+
+;; Clock -> 2011-07-12, 12h 48m 9s.
+Computing the boundary of the generator 1/1 (dimension 2) :
+S1 
+End of computing.
+
+
+
+;; Clock -> 2011-07-12, 12h 48m 9s.
+
+
+Computing boundary-matrix in dimension 2.
+Rank of the source-module : 1.
+
+
+;; Clock -> 2011-07-12, 12h 48m 9s.
+Computing the boundary of the generator 1/1 (dimension 2) :
+S1 
+End of computing.
+
+
+Computing boundary-matrix in dimension 3.
+Rank of the source-module : 0.
+
+
+
+;; Clock -> 2011-07-12, 12h 48m 9s.
+
+
+Computing boundary-matrix in dimension 2.
+Rank of the source-module : 1.
+
+
+;; Clock -> 2011-07-12, 12h 48m 9s.
+Computing the boundary of the generator 1/1 (dimension 2) :
+S1 
+End of computing.
+
+
+Computing boundary-matrix in dimension 3.
+Rank of the source-module : 0.
+
+
+
+;; Clock -> 2011-07-12, 12h 48m 9s.
+
+
+Computing boundary-matrix in dimension 3.
+Rank of the source-module : 1.
+
+
+;; Clock -> 2011-07-12, 12h 48m 9s.
+Computing the boundary of the generator 1/1 (dimension 3) :
+<TnPr S1 S1> 
+End of computing.
+
+
+Computing boundary-matrix in dimension 4.
+Rank of the source-module : 0.
+
+
+
+;; Clock -> 2011-07-12, 12h 48m 9s.
+
+
+Computing boundary-matrix in dimension 4.
+Rank of the source-module : 2.
+
+
+;; Clock -> 2011-07-12, 12h 48m 9s.
+Computing the boundary of the generator 1/2 (dimension 4) :
+<TnPr <TnPr S-BSGN *> <<Abar[2 S1][2 S1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 9s.
+Computing the boundary of the generator 2/2 (dimension 4) :
+<TnPr <TnPr S1 *> <<Abar[2 S1]>>> 
+End of computing.
+
+
+Computing boundary-matrix in dimension 5.
+Rank of the source-module : 2.
+
+
+;; Clock -> 2011-07-12, 12h 48m 9s.
+Computing the boundary of the generator 1/2 (dimension 5) :
+<TnPr <TnPr S-BSGN S1> <<Abar[2 S1][2 S1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 9s.
+Computing the boundary of the generator 2/2 (dimension 5) :
+<TnPr <TnPr S1 S1> <<Abar[2 S1]>>> 
+End of computing.
+
+
+
+;; Clock -> 2011-07-12, 12h 48m 10s.
+
+
+Computing boundary-matrix in dimension 4.
+Rank of the source-module : 2.
+
+
+;; Clock -> 2011-07-12, 12h 48m 10s.
+Computing the boundary of the generator 1/2 (dimension 4) :
+<TnPr <TnPr S-BSGN *> <<Abar[2 S1][2 S1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 10s.
+Computing the boundary of the generator 2/2 (dimension 4) :
+<TnPr <TnPr S1 *> <<Abar[2 S1]>>> 
+End of computing.
+
+
+Computing boundary-matrix in dimension 5.
+Rank of the source-module : 2.
+
+
+;; Clock -> 2011-07-12, 12h 48m 10s.
+Computing the boundary of the generator 1/2 (dimension 5) :
+<TnPr <TnPr S-BSGN S1> <<Abar[2 S1][2 S1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 10s.
+Computing the boundary of the generator 2/2 (dimension 5) :
+<TnPr <TnPr S1 S1> <<Abar[2 S1]>>> 
+End of computing.
+
+
+
+;; Clock -> 2011-07-12, 12h 48m 10s.
+
+
+
+
+Homotopy in dimension 4 :
+
+
+Component Z/2Z
+
+NIL
+CL-USER(21):  (homotopy s-k-z-1 5)
+
+Computing boundary-matrix in dimension 1.
+Rank of the source-module : 0.
+
+
+Computing boundary-matrix in dimension 2.
+Rank of the source-module : 1.
+
+
+;; Clock -> 2011-07-12, 12h 48m 16s.
+Computing the boundary of the generator 1/1 (dimension 2) :
+S1 
+End of computing.
+
+
+
+;; Clock -> 2011-07-12, 12h 48m 16s.
+
+
+Computing boundary-matrix in dimension 2.
+Rank of the source-module : 1.
+
+
+;; Clock -> 2011-07-12, 12h 48m 16s.
+Computing the boundary of the generator 1/1 (dimension 2) :
+S1 
+End of computing.
+
+
+Computing boundary-matrix in dimension 3.
+Rank of the source-module : 0.
+
+
+
+;; Clock -> 2011-07-12, 12h 48m 16s.
+
+
+Computing boundary-matrix in dimension 2.
+Rank of the source-module : 1.
+
+
+;; Clock -> 2011-07-12, 12h 48m 16s.
+Computing the boundary of the generator 1/1 (dimension 2) :
+S1 
+End of computing.
+
+
+Computing boundary-matrix in dimension 3.
+Rank of the source-module : 0.
+
+
+
+;; Clock -> 2011-07-12, 12h 48m 16s.
+
+
+Computing boundary-matrix in dimension 3.
+Rank of the source-module : 1.
+
+
+;; Clock -> 2011-07-12, 12h 48m 16s.
+Computing the boundary of the generator 1/1 (dimension 3) :
+<TnPr S1 S1> 
+End of computing.
+
+
+Computing boundary-matrix in dimension 4.
+Rank of the source-module : 0.
+
+
+
+;; Clock -> 2011-07-12, 12h 48m 16s.
+
+
+Computing boundary-matrix in dimension 4.
+Rank of the source-module : 2.
+
+
+;; Clock -> 2011-07-12, 12h 48m 16s.
+Computing the boundary of the generator 1/2 (dimension 4) :
+<TnPr <TnPr S-BSGN *> <<Abar[2 S1][2 S1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 16s.
+Computing the boundary of the generator 2/2 (dimension 4) :
+<TnPr <TnPr S1 *> <<Abar[2 S1]>>> 
+End of computing.
+
+
+Computing boundary-matrix in dimension 5.
+Rank of the source-module : 2.
+
+
+;; Clock -> 2011-07-12, 12h 48m 16s.
+Computing the boundary of the generator 1/2 (dimension 5) :
+<TnPr <TnPr S-BSGN S1> <<Abar[2 S1][2 S1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 16s.
+Computing the boundary of the generator 2/2 (dimension 5) :
+<TnPr <TnPr S1 S1> <<Abar[2 S1]>>> 
+End of computing.
+
+
+
+;; Clock -> 2011-07-12, 12h 48m 16s.
+
+
+Computing boundary-matrix in dimension 5.
+Rank of the source-module : 7.
+
+
+;; Clock -> 2011-07-12, 12h 48m 16s.
+Computing the boundary of the generator 1/7 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[5 <<Abar[4 3]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 16s.
+Computing the boundary of the generator 2/7 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[5 <<Abar[2 1][2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 16s.
+Computing the boundary of the generator 3/7 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN S1> <<Abar>>> <<Abar[4 <<Abar[3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 16s.
+Computing the boundary of the generator 4/7 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN *> <<Abar[2 S1]>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 16s.
+Computing the boundary of the generator 5/7 (dimension 5) :
+<TnPr <TnPr <TnPr S1 *> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 16s.
+Computing the boundary of the generator 6/7 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN S1> <<Abar[2 S1][2 S1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 16s.
+Computing the boundary of the generator 7/7 (dimension 5) :
+<TnPr <TnPr <TnPr S1 S1> <<Abar[2 S1]>>> <<Abar>>> 
+End of computing.
+
+
+Computing boundary-matrix in dimension 6.
+Rank of the source-module : 12.
+
+
+;; Clock -> 2011-07-12, 12h 48m 16s.
+Computing the boundary of the generator 1/12 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[6 <<Abar[5 4]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 16s.
+Computing the boundary of the generator 2/12 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[6 <<Abar[2 1][3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 16s.
+Computing the boundary of the generator 3/12 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[6 <<Abar[3 2][2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 16s.
+Computing the boundary of the generator 4/12 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[3 <<Abar[2 1]>>][3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 16s.
+Computing the boundary of the generator 5/12 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN S1> <<Abar>>> <<Abar[5 <<Abar[4 3]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 16s.
+Computing the boundary of the generator 6/12 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN S1> <<Abar>>> <<Abar[5 <<Abar[2 1][2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 16s.
+Computing the boundary of the generator 7/12 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN *> <<Abar[2 S1]>>> <<Abar[4 <<Abar[3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 16s.
+Computing the boundary of the generator 8/12 (dimension 6) :
+<TnPr <TnPr <TnPr S1 *> <<Abar>>> <<Abar[4 <<Abar[3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 16s.
+Computing the boundary of the generator 9/12 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN S1> <<Abar[2 S1]>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 16s.
+Computing the boundary of the generator 10/12 (dimension 6) :
+<TnPr <TnPr <TnPr S1 S1> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 16s.
+Computing the boundary of the generator 11/12 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN *> <<Abar[2 S1][2 S1][2 S1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 16s.
+Computing the boundary of the generator 12/12 (dimension 6) :
+<TnPr <TnPr <TnPr S1 *> <<Abar[2 S1][2 S1]>>> <<Abar>>> 
+End of computing.
+
+
+
+;; Clock -> 2011-07-12, 12h 48m 17s.
+
+
+Computing boundary-matrix in dimension 5.
+Rank of the source-module : 7.
+
+
+;; Clock -> 2011-07-12, 12h 48m 17s.
+Computing the boundary of the generator 1/7 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[5 <<Abar[4 3]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 17s.
+Computing the boundary of the generator 2/7 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[5 <<Abar[2 1][2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 17s.
+Computing the boundary of the generator 3/7 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN S1> <<Abar>>> <<Abar[4 <<Abar[3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 17s.
+Computing the boundary of the generator 4/7 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN *> <<Abar[2 S1]>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 17s.
+Computing the boundary of the generator 5/7 (dimension 5) :
+<TnPr <TnPr <TnPr S1 *> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 17s.
+Computing the boundary of the generator 6/7 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN S1> <<Abar[2 S1][2 S1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 17s.
+Computing the boundary of the generator 7/7 (dimension 5) :
+<TnPr <TnPr <TnPr S1 S1> <<Abar[2 S1]>>> <<Abar>>> 
+End of computing.
+
+
+Computing boundary-matrix in dimension 6.
+Rank of the source-module : 12.
+
+
+;; Clock -> 2011-07-12, 12h 48m 17s.
+Computing the boundary of the generator 1/12 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[6 <<Abar[5 4]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 17s.
+Computing the boundary of the generator 2/12 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[6 <<Abar[2 1][3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 17s.
+Computing the boundary of the generator 3/12 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[6 <<Abar[3 2][2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 17s.
+Computing the boundary of the generator 4/12 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[3 <<Abar[2 1]>>][3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 17s.
+Computing the boundary of the generator 5/12 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN S1> <<Abar>>> <<Abar[5 <<Abar[4 3]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 17s.
+Computing the boundary of the generator 6/12 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN S1> <<Abar>>> <<Abar[5 <<Abar[2 1][2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 17s.
+Computing the boundary of the generator 7/12 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN *> <<Abar[2 S1]>>> <<Abar[4 <<Abar[3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 17s.
+Computing the boundary of the generator 8/12 (dimension 6) :
+<TnPr <TnPr <TnPr S1 *> <<Abar>>> <<Abar[4 <<Abar[3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 17s.
+Computing the boundary of the generator 9/12 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN S1> <<Abar[2 S1]>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 17s.
+Computing the boundary of the generator 10/12 (dimension 6) :
+<TnPr <TnPr <TnPr S1 S1> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 17s.
+Computing the boundary of the generator 11/12 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN *> <<Abar[2 S1][2 S1][2 S1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 17s.
+Computing the boundary of the generator 12/12 (dimension 6) :
+<TnPr <TnPr <TnPr S1 *> <<Abar[2 S1][2 S1]>>> <<Abar>>> 
+End of computing.
+
+
+
+;; Clock -> 2011-07-12, 12h 48m 17s.
+
+
+
+
+Homotopy in dimension 5 :
+
+
+Component Z/2Z
+
+NIL
+CL-USER(22):  (homotopy s-k-z-1 6)
+
+Computing boundary-matrix in dimension 1.
+Rank of the source-module : 0.
+
+
+Computing boundary-matrix in dimension 2.
+Rank of the source-module : 1.
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+Computing the boundary of the generator 1/1 (dimension 2) :
+S1 
+End of computing.
+
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+
+
+Computing boundary-matrix in dimension 2.
+Rank of the source-module : 1.
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+Computing the boundary of the generator 1/1 (dimension 2) :
+S1 
+End of computing.
+
+
+Computing boundary-matrix in dimension 3.
+Rank of the source-module : 0.
+
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+
+
+Computing boundary-matrix in dimension 2.
+Rank of the source-module : 1.
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+Computing the boundary of the generator 1/1 (dimension 2) :
+S1 
+End of computing.
+
+
+Computing boundary-matrix in dimension 3.
+Rank of the source-module : 0.
+
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+
+
+Computing boundary-matrix in dimension 3.
+Rank of the source-module : 1.
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+Computing the boundary of the generator 1/1 (dimension 3) :
+<TnPr S1 S1> 
+End of computing.
+
+
+Computing boundary-matrix in dimension 4.
+Rank of the source-module : 0.
+
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+
+
+Computing boundary-matrix in dimension 4.
+Rank of the source-module : 2.
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+Computing the boundary of the generator 1/2 (dimension 4) :
+<TnPr <TnPr S-BSGN *> <<Abar[2 S1][2 S1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+Computing the boundary of the generator 2/2 (dimension 4) :
+<TnPr <TnPr S1 *> <<Abar[2 S1]>>> 
+End of computing.
+
+
+Computing boundary-matrix in dimension 5.
+Rank of the source-module : 2.
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+Computing the boundary of the generator 1/2 (dimension 5) :
+<TnPr <TnPr S-BSGN S1> <<Abar[2 S1][2 S1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+Computing the boundary of the generator 2/2 (dimension 5) :
+<TnPr <TnPr S1 S1> <<Abar[2 S1]>>> 
+End of computing.
+
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+
+
+Computing boundary-matrix in dimension 5.
+Rank of the source-module : 7.
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+Computing the boundary of the generator 1/7 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[5 <<Abar[4 3]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+Computing the boundary of the generator 2/7 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[5 <<Abar[2 1][2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+Computing the boundary of the generator 3/7 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN S1> <<Abar>>> <<Abar[4 <<Abar[3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+Computing the boundary of the generator 4/7 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN *> <<Abar[2 S1]>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+Computing the boundary of the generator 5/7 (dimension 5) :
+<TnPr <TnPr <TnPr S1 *> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+Computing the boundary of the generator 6/7 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN S1> <<Abar[2 S1][2 S1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+Computing the boundary of the generator 7/7 (dimension 5) :
+<TnPr <TnPr <TnPr S1 S1> <<Abar[2 S1]>>> <<Abar>>> 
+End of computing.
+
+
+Computing boundary-matrix in dimension 6.
+Rank of the source-module : 12.
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+Computing the boundary of the generator 1/12 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[6 <<Abar[5 4]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+Computing the boundary of the generator 2/12 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[6 <<Abar[2 1][3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+Computing the boundary of the generator 3/12 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[6 <<Abar[3 2][2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+Computing the boundary of the generator 4/12 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[3 <<Abar[2 1]>>][3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+Computing the boundary of the generator 5/12 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN S1> <<Abar>>> <<Abar[5 <<Abar[4 3]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+Computing the boundary of the generator 6/12 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN S1> <<Abar>>> <<Abar[5 <<Abar[2 1][2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+Computing the boundary of the generator 7/12 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN *> <<Abar[2 S1]>>> <<Abar[4 <<Abar[3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+Computing the boundary of the generator 8/12 (dimension 6) :
+<TnPr <TnPr <TnPr S1 *> <<Abar>>> <<Abar[4 <<Abar[3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+Computing the boundary of the generator 9/12 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN S1> <<Abar[2 S1]>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+Computing the boundary of the generator 10/12 (dimension 6) :
+<TnPr <TnPr <TnPr S1 S1> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+Computing the boundary of the generator 11/12 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN *> <<Abar[2 S1][2 S1][2 S1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+Computing the boundary of the generator 12/12 (dimension 6) :
+<TnPr <TnPr <TnPr S1 *> <<Abar[2 S1][2 S1]>>> <<Abar>>> 
+End of computing.
+
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+
+
+Computing boundary-matrix in dimension 6.
+Rank of the source-module : 17.
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+Computing the boundary of the generator 1/17 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar>>> <<Abar[6 <<Abar[5 <<Abar[4 3]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+Computing the boundary of the generator 2/17 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar>>> <<Abar[6 <<Abar[5 <<Abar[2 1][2 1]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+Computing the boundary of the generator 3/17 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN S1> <<Abar>>> <<Abar>>> <<Abar[5 <<Abar[4 <<Abar[3 2]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+Computing the boundary of the generator 4/17 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar[2 S1]>>> <<Abar>>> <<Abar[4 <<Abar[3 <<Abar[2 1]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 26s.
+Computing the boundary of the generator 5/17 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr S1 *> <<Abar>>> <<Abar>>> <<Abar[4 <<Abar[3 <<Abar[2 1]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 27s.
+Computing the boundary of the generator 6/17 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[6 <<Abar[5 4]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 27s.
+Computing the boundary of the generator 7/17 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[6 <<Abar[2 1][3 2]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 27s.
+Computing the boundary of the generator 8/17 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[6 <<Abar[3 2][2 1]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 27s.
+Computing the boundary of the generator 9/17 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[3 <<Abar[2 1]>>][3 <<Abar[2 1]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 27s.
+Computing the boundary of the generator 10/17 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN S1> <<Abar>>> <<Abar[5 <<Abar[4 3]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 27s.
+Computing the boundary of the generator 11/17 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN S1> <<Abar>>> <<Abar[5 <<Abar[2 1][2 1]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 27s.
+Computing the boundary of the generator 12/17 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar[2 S1]>>> <<Abar[4 <<Abar[3 2]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 27s.
+Computing the boundary of the generator 13/17 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr S1 *> <<Abar>>> <<Abar[4 <<Abar[3 2]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 27s.
+Computing the boundary of the generator 14/17 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN S1> <<Abar[2 S1]>>> <<Abar[3 <<Abar[2 1]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 27s.
+Computing the boundary of the generator 15/17 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr S1 S1> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 27s.
+Computing the boundary of the generator 16/17 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar[2 S1][2 S1][2 S1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 29s.
+Computing the boundary of the generator 17/17 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr S1 *> <<Abar[2 S1][2 S1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+Computing boundary-matrix in dimension 7.
+Rank of the source-module : 32.
+
+
+;; Clock -> 2011-07-12, 12h 48m 29s.
+Computing the boundary of the generator 1/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar>>> <<Abar[7 <<Abar[6 <<Abar[5 4]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 29s.
+Computing the boundary of the generator 2/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar>>> <<Abar[7 <<Abar[6 <<Abar[2 1][3 2]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 29s.
+Computing the boundary of the generator 3/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar>>> <<Abar[7 <<Abar[6 <<Abar[3 2][2 1]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 29s.
+Computing the boundary of the generator 4/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar>>> <<Abar[7 <<Abar[3 <<Abar[2 1]>>][3 <<Abar[2 1]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 29s.
+Computing the boundary of the generator 5/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN S1> <<Abar>>> <<Abar>>> <<Abar[6 <<Abar[5 <<Abar[4 3]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 29s.
+Computing the boundary of the generator 6/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN S1> <<Abar>>> <<Abar>>> <<Abar[6 <<Abar[5 <<Abar[2 1][2 1]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 29s.
+Computing the boundary of the generator 7/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar[2 S1]>>> <<Abar>>> <<Abar[5 <<Abar[4 <<Abar[3 2]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 29s.
+Computing the boundary of the generator 8/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S1 *> <<Abar>>> <<Abar>>> <<Abar[5 <<Abar[4 <<Abar[3 2]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 30s.
+Computing the boundary of the generator 9/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> <<Abar[4 <<Abar[3 <<Abar[2 1]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 30s.
+Computing the boundary of the generator 10/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN S1> <<Abar[2 S1]>>> <<Abar>>> <<Abar[4 <<Abar[3 <<Abar[2 1]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 30s.
+Computing the boundary of the generator 11/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S1 S1> <<Abar>>> <<Abar>>> <<Abar[4 <<Abar[3 <<Abar[2 1]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 30s.
+Computing the boundary of the generator 12/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[7 <<Abar[6 5]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 30s.
+Computing the boundary of the generator 13/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[7 <<Abar[2 1][4 3]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 30s.
+Computing the boundary of the generator 14/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[7 <<Abar[3 2][3 2]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 30s.
+Computing the boundary of the generator 15/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[7 <<Abar[4 3][2 1]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 30s.
+Computing the boundary of the generator 16/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[7 <<Abar[2 1][2 1][2 1]>>]>>> <<Abar>>> 
+*CR* -- Cut = 0.025002742 -- N = 9372
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 31s.
+Computing the boundary of the generator 17/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[3 <<Abar[2 1]>>][4 <<Abar[3 2]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 31s.
+Computing the boundary of the generator 18/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[4 <<Abar[3 2]>>][3 <<Abar[2 1]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 31s.
+Computing the boundary of the generator 19/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN S1> <<Abar>>> <<Abar[6 <<Abar[5 4]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 31s.
+Computing the boundary of the generator 20/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN S1> <<Abar>>> <<Abar[6 <<Abar[2 1][3 2]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 32s.
+Computing the boundary of the generator 21/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN S1> <<Abar>>> <<Abar[6 <<Abar[3 2][2 1]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 32s.
+Computing the boundary of the generator 22/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN S1> <<Abar>>> <<Abar[3 <<Abar[2 1]>>][3 <<Abar[2 1]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 32s.
+Computing the boundary of the generator 23/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar[2 S1]>>> <<Abar[5 <<Abar[4 3]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 32s.
+Computing the boundary of the generator 24/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar[2 S1]>>> <<Abar[5 <<Abar[2 1][2 1]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 33s.
+Computing the boundary of the generator 25/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S1 *> <<Abar>>> <<Abar[5 <<Abar[4 3]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 33s.
+Computing the boundary of the generator 26/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S1 *> <<Abar>>> <<Abar[5 <<Abar[2 1][2 1]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 33s.
+Computing the boundary of the generator 27/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN S1> <<Abar[2 S1]>>> <<Abar[4 <<Abar[3 2]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 33s.
+Computing the boundary of the generator 28/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S1 S1> <<Abar>>> <<Abar[4 <<Abar[3 2]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 34s.
+Computing the boundary of the generator 29/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar[2 S1][2 S1]>>> <<Abar[3 <<Abar[2 1]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 35s.
+Computing the boundary of the generator 30/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S1 *> <<Abar[2 S1]>>> <<Abar[3 <<Abar[2 1]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 36s.
+Computing the boundary of the generator 31/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN S1> <<Abar[2 S1][2 S1][2 S1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 48m 41s.
+Computing the boundary of the generator 32/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S1 S1> <<Abar[2 S1][2 S1]>>> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.025244262 -- N = 9428
+*CR* -- Cut = 0.026013508 -- N = 9770
+*CR* -- Cut = 0.025819128 -- N = 9868
+End of computing.
+
+
+
+;; Clock -> 2011-07-12, 12h 50m 21s.
+
+
+Computing boundary-matrix in dimension 6.
+Rank of the source-module : 17.
+
+
+;; Clock -> 2011-07-12, 12h 50m 21s.
+Computing the boundary of the generator 1/17 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar>>> <<Abar[6 <<Abar[5 <<Abar[4 3]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 21s.
+Computing the boundary of the generator 2/17 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar>>> <<Abar[6 <<Abar[5 <<Abar[2 1][2 1]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 21s.
+Computing the boundary of the generator 3/17 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN S1> <<Abar>>> <<Abar>>> <<Abar[5 <<Abar[4 <<Abar[3 2]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 21s.
+Computing the boundary of the generator 4/17 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar[2 S1]>>> <<Abar>>> <<Abar[4 <<Abar[3 <<Abar[2 1]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 21s.
+Computing the boundary of the generator 5/17 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr S1 *> <<Abar>>> <<Abar>>> <<Abar[4 <<Abar[3 <<Abar[2 1]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 21s.
+Computing the boundary of the generator 6/17 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[6 <<Abar[5 4]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 21s.
+Computing the boundary of the generator 7/17 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[6 <<Abar[2 1][3 2]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 21s.
+Computing the boundary of the generator 8/17 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[6 <<Abar[3 2][2 1]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 21s.
+Computing the boundary of the generator 9/17 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[3 <<Abar[2 1]>>][3 <<Abar[2 1]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 22s.
+Computing the boundary of the generator 10/17 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN S1> <<Abar>>> <<Abar[5 <<Abar[4 3]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 22s.
+Computing the boundary of the generator 11/17 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN S1> <<Abar>>> <<Abar[5 <<Abar[2 1][2 1]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 22s.
+Computing the boundary of the generator 12/17 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar[2 S1]>>> <<Abar[4 <<Abar[3 2]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 22s.
+Computing the boundary of the generator 13/17 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr S1 *> <<Abar>>> <<Abar[4 <<Abar[3 2]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 22s.
+Computing the boundary of the generator 14/17 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN S1> <<Abar[2 S1]>>> <<Abar[3 <<Abar[2 1]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 22s.
+Computing the boundary of the generator 15/17 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr S1 S1> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 22s.
+Computing the boundary of the generator 16/17 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar[2 S1][2 S1][2 S1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 23s.
+Computing the boundary of the generator 17/17 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr S1 *> <<Abar[2 S1][2 S1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+Computing boundary-matrix in dimension 7.
+Rank of the source-module : 32.
+
+
+;; Clock -> 2011-07-12, 12h 50m 23s.
+Computing the boundary of the generator 1/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar>>> <<Abar[7 <<Abar[6 <<Abar[5 4]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 23s.
+Computing the boundary of the generator 2/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar>>> <<Abar[7 <<Abar[6 <<Abar[2 1][3 2]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 23s.
+Computing the boundary of the generator 3/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar>>> <<Abar[7 <<Abar[6 <<Abar[3 2][2 1]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 23s.
+Computing the boundary of the generator 4/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar>>> <<Abar[7 <<Abar[3 <<Abar[2 1]>>][3 <<Abar[2 1]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 23s.
+Computing the boundary of the generator 5/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN S1> <<Abar>>> <<Abar>>> <<Abar[6 <<Abar[5 <<Abar[4 3]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 23s.
+Computing the boundary of the generator 6/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN S1> <<Abar>>> <<Abar>>> <<Abar[6 <<Abar[5 <<Abar[2 1][2 1]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 23s.
+Computing the boundary of the generator 7/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar[2 S1]>>> <<Abar>>> <<Abar[5 <<Abar[4 <<Abar[3 2]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 23s.
+Computing the boundary of the generator 8/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S1 *> <<Abar>>> <<Abar>>> <<Abar[5 <<Abar[4 <<Abar[3 2]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 23s.
+Computing the boundary of the generator 9/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> <<Abar[4 <<Abar[3 <<Abar[2 1]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 23s.
+Computing the boundary of the generator 10/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN S1> <<Abar[2 S1]>>> <<Abar>>> <<Abar[4 <<Abar[3 <<Abar[2 1]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 23s.
+Computing the boundary of the generator 11/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S1 S1> <<Abar>>> <<Abar>>> <<Abar[4 <<Abar[3 <<Abar[2 1]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 23s.
+Computing the boundary of the generator 12/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[7 <<Abar[6 5]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 23s.
+Computing the boundary of the generator 13/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[7 <<Abar[2 1][4 3]>>]>>> <<Abar>>> 
+*CR* -- Cut = 0.02626452 -- N = 9977
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 24s.
+Computing the boundary of the generator 14/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[7 <<Abar[3 2][3 2]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 24s.
+Computing the boundary of the generator 15/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[7 <<Abar[4 3][2 1]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 24s.
+Computing the boundary of the generator 16/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[7 <<Abar[2 1][2 1][2 1]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 24s.
+Computing the boundary of the generator 17/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[3 <<Abar[2 1]>>][4 <<Abar[3 2]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 25s.
+Computing the boundary of the generator 18/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar>>> <<Abar[4 <<Abar[3 2]>>][3 <<Abar[2 1]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 25s.
+Computing the boundary of the generator 19/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN S1> <<Abar>>> <<Abar[6 <<Abar[5 4]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 25s.
+Computing the boundary of the generator 20/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN S1> <<Abar>>> <<Abar[6 <<Abar[2 1][3 2]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 26s.
+Computing the boundary of the generator 21/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN S1> <<Abar>>> <<Abar[6 <<Abar[3 2][2 1]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 26s.
+Computing the boundary of the generator 22/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN S1> <<Abar>>> <<Abar[3 <<Abar[2 1]>>][3 <<Abar[2 1]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 27s.
+Computing the boundary of the generator 23/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar[2 S1]>>> <<Abar[5 <<Abar[4 3]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 27s.
+Computing the boundary of the generator 24/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar[2 S1]>>> <<Abar[5 <<Abar[2 1][2 1]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 27s.
+Computing the boundary of the generator 25/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S1 *> <<Abar>>> <<Abar[5 <<Abar[4 3]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 27s.
+Computing the boundary of the generator 26/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S1 *> <<Abar>>> <<Abar[5 <<Abar[2 1][2 1]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 28s.
+Computing the boundary of the generator 27/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN S1> <<Abar[2 S1]>>> <<Abar[4 <<Abar[3 2]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 28s.
+Computing the boundary of the generator 28/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S1 S1> <<Abar>>> <<Abar[4 <<Abar[3 2]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 29s.
+Computing the boundary of the generator 29/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN *> <<Abar[2 S1][2 S1]>>> <<Abar[3 <<Abar[2 1]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 29s.
+Computing the boundary of the generator 30/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S1 *> <<Abar[2 S1]>>> <<Abar[3 <<Abar[2 1]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 30s.
+Computing the boundary of the generator 31/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S-BSGN S1> <<Abar[2 S1][2 S1][2 S1]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-12, 12h 50m 34s.
+Computing the boundary of the generator 32/32 (dimension 7) :
+<TnPr <TnPr <TnPr <TnPr S1 S1> <<Abar[2 S1][2 S1]>>> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.02604392 -- N = 10039
+*CR* -- Cut = 0.02635973 -- N = 10124
+End of computing.
+
+
+
+;; Clock -> 2011-07-12, 12h 51m 35s.
+
+
+
+
+Homotopy in dimension 6 :
+
+
+Component Z/12Z
+
+NIL
+CL-USER(23): (setf s1 (filetostring "resolutions3-8-first-part.txt"))
+
+
+
+CL-USER(25): (setf s2 (filetostring "resolutions3-8-second-part.txt"))
+
+
+
+			
+CL-USER(26): (setf s (concatenate 'string   s1 s2))
+
+
+
+			
+CL-USER(27): (setf rsltn (OMparseNextObject s))
+[K2362 Reduction K2356 => K17]
+CL-USER(28): (setf s3 (group1 (tcc rsltn)))
+[K2355 Group]
+CL-USER(30): (setf (slot-value s3 'resolution) rsltn)
+[K2362 Reduction K2356 => K17]
+CL-USER(31): (setf k-s3-1 (k-g-1 s3))
+[K2363 Simplicial-Group]
+CL-USER(32): (setf s-k-s3-1 (suspension k-s3-1))
+[K2375 Simplicial-Set]
+CL-USER(33): (homotopy s-k-s3-1 3)
+
+Computing boundary-matrix in dimension 1.
+Rank of the source-module : 0.
+
+
+Computing boundary-matrix in dimension 2.
+Rank of the source-module : 2.
+
+
+;; Clock -> 2011-07-14, 9h 54m 34s.
+Computing the boundary of the generator 1/2 (dimension 2) :
+"g11" 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 54m 34s.
+Computing the boundary of the generator 2/2 (dimension 2) :
+"g12" 
+End of computing.
+
+
+
+;; Clock -> 2011-07-14, 9h 54m 34s.
+
+
+Computing boundary-matrix in dimension 2.
+Rank of the source-module : 2.
+
+
+;; Clock -> 2011-07-14, 9h 54m 34s.
+Computing the boundary of the generator 1/2 (dimension 2) :
+"g11" 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 54m 34s.
+Computing the boundary of the generator 2/2 (dimension 2) :
+"g12" 
+End of computing.
+
+
+Computing boundary-matrix in dimension 3.
+Rank of the source-module : 3.
+
+
+;; Clock -> 2011-07-14, 9h 54m 34s.
+Computing the boundary of the generator 1/3 (dimension 3) :
+"g21" 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 54m 34s.
+Computing the boundary of the generator 2/3 (dimension 3) :
+"g22" 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 54m 34s.
+Computing the boundary of the generator 3/3 (dimension 3) :
+"g23" 
+End of computing.
+
+
+
+;; Clock -> 2011-07-14, 9h 54m 34s.
+
+
+Computing boundary-matrix in dimension 2.
+Rank of the source-module : 2.
+
+
+;; Clock -> 2011-07-14, 9h 54m 34s.
+Computing the boundary of the generator 1/2 (dimension 2) :
+"g11" 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 54m 34s.
+Computing the boundary of the generator 2/2 (dimension 2) :
+"g12" 
+End of computing.
+
+
+Computing boundary-matrix in dimension 3.
+Rank of the source-module : 3.
+
+
+;; Clock -> 2011-07-14, 9h 54m 34s.
+Computing the boundary of the generator 1/3 (dimension 3) :
+"g21" 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 54m 34s.
+Computing the boundary of the generator 2/3 (dimension 3) :
+"g22" 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 54m 34s.
+Computing the boundary of the generator 3/3 (dimension 3) :
+"g23" 
+End of computing.
+
+
+
+;; Clock -> 2011-07-14, 9h 54m 34s.
+
+
+Computing boundary-matrix in dimension 3.
+Rank of the source-module : 6.
+
+
+;; Clock -> 2011-07-14, 9h 54m 34s.
+Computing the boundary of the generator 1/6 (dimension 3) :
+<TnPr S-BSGN 3> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 54m 34s.
+Computing the boundary of the generator 2/6 (dimension 3) :
+<TnPr g11 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 54m 34s.
+Computing the boundary of the generator 3/6 (dimension 3) :
+<TnPr g12 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 54m 34s.
+Computing the boundary of the generator 4/6 (dimension 3) :
+<TnPr g21 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 54m 34s.
+Computing the boundary of the generator 5/6 (dimension 3) :
+<TnPr g22 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 54m 34s.
+Computing the boundary of the generator 6/6 (dimension 3) :
+<TnPr g23 0> 
+End of computing.
+
+
+Computing boundary-matrix in dimension 4.
+Rank of the source-module : 10.
+
+
+;; Clock -> 2011-07-14, 9h 54m 35s.
+Computing the boundary of the generator 1/10 (dimension 4) :
+<TnPr S-BSGN 4> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 54m 35s.
+Computing the boundary of the generator 2/10 (dimension 4) :
+<TnPr g11 2> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 54m 35s.
+Computing the boundary of the generator 3/10 (dimension 4) :
+<TnPr g12 2> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 54m 35s.
+Computing the boundary of the generator 4/10 (dimension 4) :
+<TnPr g21 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 54m 35s.
+Computing the boundary of the generator 5/10 (dimension 4) :
+<TnPr g22 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 54m 35s.
+Computing the boundary of the generator 6/10 (dimension 4) :
+<TnPr g23 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 54m 35s.
+Computing the boundary of the generator 7/10 (dimension 4) :
+<TnPr g31 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 54m 35s.
+Computing the boundary of the generator 8/10 (dimension 4) :
+<TnPr g32 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 54m 35s.
+Computing the boundary of the generator 9/10 (dimension 4) :
+<TnPr g33 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 54m 35s.
+Computing the boundary of the generator 10/10 (dimension 4) :
+<TnPr g34 0> 
+End of computing.
+
+
+
+;; Clock -> 2011-07-14, 9h 54m 35s.
+
+
+Computing boundary-matrix in dimension 3.
+Rank of the source-module : 6.
+
+
+;; Clock -> 2011-07-14, 9h 54m 35s.
+Computing the boundary of the generator 1/6 (dimension 3) :
+<TnPr S-BSGN 3> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 54m 35s.
+Computing the boundary of the generator 2/6 (dimension 3) :
+<TnPr g11 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 54m 35s.
+Computing the boundary of the generator 3/6 (dimension 3) :
+<TnPr g12 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 54m 35s.
+Computing the boundary of the generator 4/6 (dimension 3) :
+<TnPr g21 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 54m 35s.
+Computing the boundary of the generator 5/6 (dimension 3) :
+<TnPr g22 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 54m 35s.
+Computing the boundary of the generator 6/6 (dimension 3) :
+<TnPr g23 0> 
+End of computing.
+
+
+Computing boundary-matrix in dimension 4.
+Rank of the source-module : 10.
+
+
+;; Clock -> 2011-07-14, 9h 54m 35s.
+Computing the boundary of the generator 1/10 (dimension 4) :
+<TnPr S-BSGN 4> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 54m 35s.
+Computing the boundary of the generator 2/10 (dimension 4) :
+<TnPr g11 2> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 54m 35s.
+Computing the boundary of the generator 3/10 (dimension 4) :
+<TnPr g12 2> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 54m 35s.
+Computing the boundary of the generator 4/10 (dimension 4) :
+<TnPr g21 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 54m 35s.
+Computing the boundary of the generator 5/10 (dimension 4) :
+<TnPr g22 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 54m 35s.
+Computing the boundary of the generator 6/10 (dimension 4) :
+<TnPr g23 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 54m 35s.
+Computing the boundary of the generator 7/10 (dimension 4) :
+<TnPr g31 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 54m 35s.
+Computing the boundary of the generator 8/10 (dimension 4) :
+<TnPr g32 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 54m 35s.
+Computing the boundary of the generator 9/10 (dimension 4) :
+<TnPr g33 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 54m 35s.
+Computing the boundary of the generator 10/10 (dimension 4) :
+<TnPr g34 0> 
+End of computing.
+
+
+
+;; Clock -> 2011-07-14, 9h 54m 35s.
+
+
+
+
+Homotopy in dimension 3 :
+
+
+Component Z/2Z
+
+NIL
+CL-USER(34): (homotopy s-k-s3-1 4)
+
+Computing boundary-matrix in dimension 1.
+Rank of the source-module : 0.
+
+
+Computing boundary-matrix in dimension 2.
+Rank of the source-module : 2.
+
+
+;; Clock -> 2011-07-14, 9h 55m 49s.
+Computing the boundary of the generator 1/2 (dimension 2) :
+"g11" 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 49s.
+Computing the boundary of the generator 2/2 (dimension 2) :
+"g12" 
+End of computing.
+
+
+
+;; Clock -> 2011-07-14, 9h 55m 49s.
+
+
+Computing boundary-matrix in dimension 2.
+Rank of the source-module : 2.
+
+
+;; Clock -> 2011-07-14, 9h 55m 49s.
+Computing the boundary of the generator 1/2 (dimension 2) :
+"g11" 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 49s.
+Computing the boundary of the generator 2/2 (dimension 2) :
+"g12" 
+End of computing.
+
+
+Computing boundary-matrix in dimension 3.
+Rank of the source-module : 3.
+
+
+;; Clock -> 2011-07-14, 9h 55m 49s.
+Computing the boundary of the generator 1/3 (dimension 3) :
+"g21" 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 49s.
+Computing the boundary of the generator 2/3 (dimension 3) :
+"g22" 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 49s.
+Computing the boundary of the generator 3/3 (dimension 3) :
+"g23" 
+End of computing.
+
+
+
+;; Clock -> 2011-07-14, 9h 55m 49s.
+
+
+Computing boundary-matrix in dimension 2.
+Rank of the source-module : 2.
+
+
+;; Clock -> 2011-07-14, 9h 55m 49s.
+Computing the boundary of the generator 1/2 (dimension 2) :
+"g11" 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 49s.
+Computing the boundary of the generator 2/2 (dimension 2) :
+"g12" 
+End of computing.
+
+
+Computing boundary-matrix in dimension 3.
+Rank of the source-module : 3.
+
+
+;; Clock -> 2011-07-14, 9h 55m 49s.
+Computing the boundary of the generator 1/3 (dimension 3) :
+"g21" 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 49s.
+Computing the boundary of the generator 2/3 (dimension 3) :
+"g22" 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 49s.
+Computing the boundary of the generator 3/3 (dimension 3) :
+"g23" 
+End of computing.
+
+
+
+;; Clock -> 2011-07-14, 9h 55m 49s.
+
+
+Computing boundary-matrix in dimension 3.
+Rank of the source-module : 6.
+
+
+;; Clock -> 2011-07-14, 9h 55m 50s.
+Computing the boundary of the generator 1/6 (dimension 3) :
+<TnPr S-BSGN 3> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 50s.
+Computing the boundary of the generator 2/6 (dimension 3) :
+<TnPr g11 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 50s.
+Computing the boundary of the generator 3/6 (dimension 3) :
+<TnPr g12 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 50s.
+Computing the boundary of the generator 4/6 (dimension 3) :
+<TnPr g21 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 50s.
+Computing the boundary of the generator 5/6 (dimension 3) :
+<TnPr g22 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 50s.
+Computing the boundary of the generator 6/6 (dimension 3) :
+<TnPr g23 0> 
+End of computing.
+
+
+Computing boundary-matrix in dimension 4.
+Rank of the source-module : 10.
+
+
+;; Clock -> 2011-07-14, 9h 55m 50s.
+Computing the boundary of the generator 1/10 (dimension 4) :
+<TnPr S-BSGN 4> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 50s.
+Computing the boundary of the generator 2/10 (dimension 4) :
+<TnPr g11 2> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 50s.
+Computing the boundary of the generator 3/10 (dimension 4) :
+<TnPr g12 2> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 50s.
+Computing the boundary of the generator 4/10 (dimension 4) :
+<TnPr g21 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 50s.
+Computing the boundary of the generator 5/10 (dimension 4) :
+<TnPr g22 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 50s.
+Computing the boundary of the generator 6/10 (dimension 4) :
+<TnPr g23 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 50s.
+Computing the boundary of the generator 7/10 (dimension 4) :
+<TnPr g31 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 50s.
+Computing the boundary of the generator 8/10 (dimension 4) :
+<TnPr g32 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 50s.
+Computing the boundary of the generator 9/10 (dimension 4) :
+<TnPr g33 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 50s.
+Computing the boundary of the generator 10/10 (dimension 4) :
+<TnPr g34 0> 
+End of computing.
+
+
+
+;; Clock -> 2011-07-14, 9h 55m 50s.
+
+
+Computing boundary-matrix in dimension 4.
+Rank of the source-module : 16.
+
+
+;; Clock -> 2011-07-14, 9h 55m 50s.
+Computing the boundary of the generator 1/16 (dimension 4) :
+<TnPr <TnPr S-BSGN 0> <<Abar[4 3]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 50s.
+Computing the boundary of the generator 2/16 (dimension 4) :
+<TnPr <TnPr S-BSGN 0> <<Abar[2 1][2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 51s.
+Computing the boundary of the generator 3/16 (dimension 4) :
+<TnPr <TnPr S-BSGN 1> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 51s.
+Computing the boundary of the generator 4/16 (dimension 4) :
+<TnPr <TnPr S-BSGN 2> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 51s.
+Computing the boundary of the generator 5/16 (dimension 4) :
+<TnPr <TnPr g11 0> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 51s.
+Computing the boundary of the generator 6/16 (dimension 4) :
+<TnPr <TnPr g12 0> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 51s.
+Computing the boundary of the generator 7/16 (dimension 4) :
+<TnPr <TnPr S-BSGN 4> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 51s.
+Computing the boundary of the generator 8/16 (dimension 4) :
+<TnPr <TnPr g11 2> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 51s.
+Computing the boundary of the generator 9/16 (dimension 4) :
+<TnPr <TnPr g12 2> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 51s.
+Computing the boundary of the generator 10/16 (dimension 4) :
+<TnPr <TnPr g21 1> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 51s.
+Computing the boundary of the generator 11/16 (dimension 4) :
+<TnPr <TnPr g22 1> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 51s.
+Computing the boundary of the generator 12/16 (dimension 4) :
+<TnPr <TnPr g23 1> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 51s.
+Computing the boundary of the generator 13/16 (dimension 4) :
+<TnPr <TnPr g31 0> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 51s.
+Computing the boundary of the generator 14/16 (dimension 4) :
+<TnPr <TnPr g32 0> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 51s.
+Computing the boundary of the generator 15/16 (dimension 4) :
+<TnPr <TnPr g33 0> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 51s.
+Computing the boundary of the generator 16/16 (dimension 4) :
+<TnPr <TnPr g34 0> <<Abar>>> 
+End of computing.
+
+
+Computing boundary-matrix in dimension 5.
+Rank of the source-module : 29.
+
+
+;; Clock -> 2011-07-14, 9h 55m 51s.
+Computing the boundary of the generator 1/29 (dimension 5) :
+<TnPr <TnPr S-BSGN 0> <<Abar[5 4]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 51s.
+Computing the boundary of the generator 2/29 (dimension 5) :
+<TnPr <TnPr S-BSGN 0> <<Abar[2 1][3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 51s.
+Computing the boundary of the generator 3/29 (dimension 5) :
+<TnPr <TnPr S-BSGN 0> <<Abar[3 2][2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 51s.
+Computing the boundary of the generator 4/29 (dimension 5) :
+<TnPr <TnPr S-BSGN 1> <<Abar[4 3]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 51s.
+Computing the boundary of the generator 5/29 (dimension 5) :
+<TnPr <TnPr S-BSGN 1> <<Abar[2 1][2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 51s.
+Computing the boundary of the generator 6/29 (dimension 5) :
+<TnPr <TnPr S-BSGN 2> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 51s.
+Computing the boundary of the generator 7/29 (dimension 5) :
+<TnPr <TnPr g11 0> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 52s.
+Computing the boundary of the generator 8/29 (dimension 5) :
+<TnPr <TnPr g12 0> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 52s.
+Computing the boundary of the generator 9/29 (dimension 5) :
+<TnPr <TnPr S-BSGN 3> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 52s.
+Computing the boundary of the generator 10/29 (dimension 5) :
+<TnPr <TnPr g11 1> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 52s.
+Computing the boundary of the generator 11/29 (dimension 5) :
+<TnPr <TnPr g12 1> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 52s.
+Computing the boundary of the generator 12/29 (dimension 5) :
+<TnPr <TnPr g21 0> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 52s.
+Computing the boundary of the generator 13/29 (dimension 5) :
+<TnPr <TnPr g22 0> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 52s.
+Computing the boundary of the generator 14/29 (dimension 5) :
+<TnPr <TnPr g23 0> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 52s.
+Computing the boundary of the generator 15/29 (dimension 5) :
+<TnPr <TnPr S-BSGN 5> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 52s.
+Computing the boundary of the generator 16/29 (dimension 5) :
+<TnPr <TnPr g11 3> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 52s.
+Computing the boundary of the generator 17/29 (dimension 5) :
+<TnPr <TnPr g12 3> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 52s.
+Computing the boundary of the generator 18/29 (dimension 5) :
+<TnPr <TnPr g21 2> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 52s.
+Computing the boundary of the generator 19/29 (dimension 5) :
+<TnPr <TnPr g22 2> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 52s.
+Computing the boundary of the generator 20/29 (dimension 5) :
+<TnPr <TnPr g23 2> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 53s.
+Computing the boundary of the generator 21/29 (dimension 5) :
+<TnPr <TnPr g31 1> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 53s.
+Computing the boundary of the generator 22/29 (dimension 5) :
+<TnPr <TnPr g32 1> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 53s.
+Computing the boundary of the generator 23/29 (dimension 5) :
+<TnPr <TnPr g33 1> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 53s.
+Computing the boundary of the generator 24/29 (dimension 5) :
+<TnPr <TnPr g34 1> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 53s.
+Computing the boundary of the generator 25/29 (dimension 5) :
+<TnPr <TnPr g41 0> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 53s.
+Computing the boundary of the generator 26/29 (dimension 5) :
+<TnPr <TnPr g42 0> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 53s.
+Computing the boundary of the generator 27/29 (dimension 5) :
+<TnPr <TnPr g43 0> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 53s.
+Computing the boundary of the generator 28/29 (dimension 5) :
+<TnPr <TnPr g44 0> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 53s.
+Computing the boundary of the generator 29/29 (dimension 5) :
+<TnPr <TnPr g45 0> <<Abar>>> 
+End of computing.
+
+
+
+;; Clock -> 2011-07-14, 9h 55m 53s.
+
+
+Computing boundary-matrix in dimension 4.
+Rank of the source-module : 16.
+
+
+;; Clock -> 2011-07-14, 9h 55m 53s.
+Computing the boundary of the generator 1/16 (dimension 4) :
+<TnPr <TnPr S-BSGN 0> <<Abar[4 3]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 53s.
+Computing the boundary of the generator 2/16 (dimension 4) :
+<TnPr <TnPr S-BSGN 0> <<Abar[2 1][2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 53s.
+Computing the boundary of the generator 3/16 (dimension 4) :
+<TnPr <TnPr S-BSGN 1> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 53s.
+Computing the boundary of the generator 4/16 (dimension 4) :
+<TnPr <TnPr S-BSGN 2> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 53s.
+Computing the boundary of the generator 5/16 (dimension 4) :
+<TnPr <TnPr g11 0> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 53s.
+Computing the boundary of the generator 6/16 (dimension 4) :
+<TnPr <TnPr g12 0> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 53s.
+Computing the boundary of the generator 7/16 (dimension 4) :
+<TnPr <TnPr S-BSGN 4> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 53s.
+Computing the boundary of the generator 8/16 (dimension 4) :
+<TnPr <TnPr g11 2> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 53s.
+Computing the boundary of the generator 9/16 (dimension 4) :
+<TnPr <TnPr g12 2> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 53s.
+Computing the boundary of the generator 10/16 (dimension 4) :
+<TnPr <TnPr g21 1> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 53s.
+Computing the boundary of the generator 11/16 (dimension 4) :
+<TnPr <TnPr g22 1> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 53s.
+Computing the boundary of the generator 12/16 (dimension 4) :
+<TnPr <TnPr g23 1> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 53s.
+Computing the boundary of the generator 13/16 (dimension 4) :
+<TnPr <TnPr g31 0> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 53s.
+Computing the boundary of the generator 14/16 (dimension 4) :
+<TnPr <TnPr g32 0> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 53s.
+Computing the boundary of the generator 15/16 (dimension 4) :
+<TnPr <TnPr g33 0> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 53s.
+Computing the boundary of the generator 16/16 (dimension 4) :
+<TnPr <TnPr g34 0> <<Abar>>> 
+End of computing.
+
+
+Computing boundary-matrix in dimension 5.
+Rank of the source-module : 29.
+
+
+;; Clock -> 2011-07-14, 9h 55m 53s.
+Computing the boundary of the generator 1/29 (dimension 5) :
+<TnPr <TnPr S-BSGN 0> <<Abar[5 4]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 53s.
+Computing the boundary of the generator 2/29 (dimension 5) :
+<TnPr <TnPr S-BSGN 0> <<Abar[2 1][3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 53s.
+Computing the boundary of the generator 3/29 (dimension 5) :
+<TnPr <TnPr S-BSGN 0> <<Abar[3 2][2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 53s.
+Computing the boundary of the generator 4/29 (dimension 5) :
+<TnPr <TnPr S-BSGN 1> <<Abar[4 3]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 53s.
+Computing the boundary of the generator 5/29 (dimension 5) :
+<TnPr <TnPr S-BSGN 1> <<Abar[2 1][2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 53s.
+Computing the boundary of the generator 6/29 (dimension 5) :
+<TnPr <TnPr S-BSGN 2> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 53s.
+Computing the boundary of the generator 7/29 (dimension 5) :
+<TnPr <TnPr g11 0> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 53s.
+Computing the boundary of the generator 8/29 (dimension 5) :
+<TnPr <TnPr g12 0> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 53s.
+Computing the boundary of the generator 9/29 (dimension 5) :
+<TnPr <TnPr S-BSGN 3> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 54s.
+Computing the boundary of the generator 10/29 (dimension 5) :
+<TnPr <TnPr g11 1> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 54s.
+Computing the boundary of the generator 11/29 (dimension 5) :
+<TnPr <TnPr g12 1> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 54s.
+Computing the boundary of the generator 12/29 (dimension 5) :
+<TnPr <TnPr g21 0> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 54s.
+Computing the boundary of the generator 13/29 (dimension 5) :
+<TnPr <TnPr g22 0> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 54s.
+Computing the boundary of the generator 14/29 (dimension 5) :
+<TnPr <TnPr g23 0> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 54s.
+Computing the boundary of the generator 15/29 (dimension 5) :
+<TnPr <TnPr S-BSGN 5> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 54s.
+Computing the boundary of the generator 16/29 (dimension 5) :
+<TnPr <TnPr g11 3> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 54s.
+Computing the boundary of the generator 17/29 (dimension 5) :
+<TnPr <TnPr g12 3> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 54s.
+Computing the boundary of the generator 18/29 (dimension 5) :
+<TnPr <TnPr g21 2> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 54s.
+Computing the boundary of the generator 19/29 (dimension 5) :
+<TnPr <TnPr g22 2> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 54s.
+Computing the boundary of the generator 20/29 (dimension 5) :
+<TnPr <TnPr g23 2> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 54s.
+Computing the boundary of the generator 21/29 (dimension 5) :
+<TnPr <TnPr g31 1> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 54s.
+Computing the boundary of the generator 22/29 (dimension 5) :
+<TnPr <TnPr g32 1> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 54s.
+Computing the boundary of the generator 23/29 (dimension 5) :
+<TnPr <TnPr g33 1> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 54s.
+Computing the boundary of the generator 24/29 (dimension 5) :
+<TnPr <TnPr g34 1> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 54s.
+Computing the boundary of the generator 25/29 (dimension 5) :
+<TnPr <TnPr g41 0> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 54s.
+Computing the boundary of the generator 26/29 (dimension 5) :
+<TnPr <TnPr g42 0> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 54s.
+Computing the boundary of the generator 27/29 (dimension 5) :
+<TnPr <TnPr g43 0> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 54s.
+Computing the boundary of the generator 28/29 (dimension 5) :
+<TnPr <TnPr g44 0> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 55m 54s.
+Computing the boundary of the generator 29/29 (dimension 5) :
+<TnPr <TnPr g45 0> <<Abar>>> 
+End of computing.
+
+
+
+;; Clock -> 2011-07-14, 9h 55m 54s.
+
+
+
+
+Homotopy in dimension 4 :
+
+
+Component Z/12Z
+
+NIL
+CL-USER(35): (homotopy s-k-s3-1 5)
+
+Computing boundary-matrix in dimension 1.
+Rank of the source-module : 0.
+
+
+Computing boundary-matrix in dimension 2.
+Rank of the source-module : 2.
+
+
+;; Clock -> 2011-07-14, 9h 56m 7s.
+Computing the boundary of the generator 1/2 (dimension 2) :
+"g11" 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 7s.
+Computing the boundary of the generator 2/2 (dimension 2) :
+"g12" 
+End of computing.
+
+
+
+;; Clock -> 2011-07-14, 9h 56m 7s.
+
+
+Computing boundary-matrix in dimension 2.
+Rank of the source-module : 2.
+
+
+;; Clock -> 2011-07-14, 9h 56m 7s.
+Computing the boundary of the generator 1/2 (dimension 2) :
+"g11" 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 7s.
+Computing the boundary of the generator 2/2 (dimension 2) :
+"g12" 
+End of computing.
+
+
+Computing boundary-matrix in dimension 3.
+Rank of the source-module : 3.
+
+
+;; Clock -> 2011-07-14, 9h 56m 7s.
+Computing the boundary of the generator 1/3 (dimension 3) :
+"g21" 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 7s.
+Computing the boundary of the generator 2/3 (dimension 3) :
+"g22" 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 7s.
+Computing the boundary of the generator 3/3 (dimension 3) :
+"g23" 
+End of computing.
+
+
+
+;; Clock -> 2011-07-14, 9h 56m 7s.
+
+
+Computing boundary-matrix in dimension 2.
+Rank of the source-module : 2.
+
+
+;; Clock -> 2011-07-14, 9h 56m 7s.
+Computing the boundary of the generator 1/2 (dimension 2) :
+"g11" 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 7s.
+Computing the boundary of the generator 2/2 (dimension 2) :
+"g12" 
+End of computing.
+
+
+Computing boundary-matrix in dimension 3.
+Rank of the source-module : 3.
+
+
+;; Clock -> 2011-07-14, 9h 56m 7s.
+Computing the boundary of the generator 1/3 (dimension 3) :
+"g21" 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 7s.
+Computing the boundary of the generator 2/3 (dimension 3) :
+"g22" 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 7s.
+Computing the boundary of the generator 3/3 (dimension 3) :
+"g23" 
+End of computing.
+
+
+
+;; Clock -> 2011-07-14, 9h 56m 7s.
+
+
+Computing boundary-matrix in dimension 3.
+Rank of the source-module : 6.
+
+
+;; Clock -> 2011-07-14, 9h 56m 7s.
+Computing the boundary of the generator 1/6 (dimension 3) :
+<TnPr S-BSGN 3> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 7s.
+Computing the boundary of the generator 2/6 (dimension 3) :
+<TnPr g11 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 7s.
+Computing the boundary of the generator 3/6 (dimension 3) :
+<TnPr g12 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 7s.
+Computing the boundary of the generator 4/6 (dimension 3) :
+<TnPr g21 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 7s.
+Computing the boundary of the generator 5/6 (dimension 3) :
+<TnPr g22 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 7s.
+Computing the boundary of the generator 6/6 (dimension 3) :
+<TnPr g23 0> 
+End of computing.
+
+
+Computing boundary-matrix in dimension 4.
+Rank of the source-module : 10.
+
+
+;; Clock -> 2011-07-14, 9h 56m 7s.
+Computing the boundary of the generator 1/10 (dimension 4) :
+<TnPr S-BSGN 4> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 7s.
+Computing the boundary of the generator 2/10 (dimension 4) :
+<TnPr g11 2> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 7s.
+Computing the boundary of the generator 3/10 (dimension 4) :
+<TnPr g12 2> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 7s.
+Computing the boundary of the generator 4/10 (dimension 4) :
+<TnPr g21 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 8s.
+Computing the boundary of the generator 5/10 (dimension 4) :
+<TnPr g22 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 8s.
+Computing the boundary of the generator 6/10 (dimension 4) :
+<TnPr g23 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 8s.
+Computing the boundary of the generator 7/10 (dimension 4) :
+<TnPr g31 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 8s.
+Computing the boundary of the generator 8/10 (dimension 4) :
+<TnPr g32 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 8s.
+Computing the boundary of the generator 9/10 (dimension 4) :
+<TnPr g33 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 8s.
+Computing the boundary of the generator 10/10 (dimension 4) :
+<TnPr g34 0> 
+End of computing.
+
+
+
+;; Clock -> 2011-07-14, 9h 56m 8s.
+
+
+Computing boundary-matrix in dimension 4.
+Rank of the source-module : 16.
+
+
+;; Clock -> 2011-07-14, 9h 56m 8s.
+Computing the boundary of the generator 1/16 (dimension 4) :
+<TnPr <TnPr S-BSGN 0> <<Abar[4 3]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 8s.
+Computing the boundary of the generator 2/16 (dimension 4) :
+<TnPr <TnPr S-BSGN 0> <<Abar[2 1][2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 8s.
+Computing the boundary of the generator 3/16 (dimension 4) :
+<TnPr <TnPr S-BSGN 1> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 8s.
+Computing the boundary of the generator 4/16 (dimension 4) :
+<TnPr <TnPr S-BSGN 2> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 8s.
+Computing the boundary of the generator 5/16 (dimension 4) :
+<TnPr <TnPr g11 0> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 8s.
+Computing the boundary of the generator 6/16 (dimension 4) :
+<TnPr <TnPr g12 0> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 8s.
+Computing the boundary of the generator 7/16 (dimension 4) :
+<TnPr <TnPr S-BSGN 4> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 8s.
+Computing the boundary of the generator 8/16 (dimension 4) :
+<TnPr <TnPr g11 2> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 8s.
+Computing the boundary of the generator 9/16 (dimension 4) :
+<TnPr <TnPr g12 2> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 8s.
+Computing the boundary of the generator 10/16 (dimension 4) :
+<TnPr <TnPr g21 1> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 8s.
+Computing the boundary of the generator 11/16 (dimension 4) :
+<TnPr <TnPr g22 1> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 8s.
+Computing the boundary of the generator 12/16 (dimension 4) :
+<TnPr <TnPr g23 1> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 8s.
+Computing the boundary of the generator 13/16 (dimension 4) :
+<TnPr <TnPr g31 0> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 8s.
+Computing the boundary of the generator 14/16 (dimension 4) :
+<TnPr <TnPr g32 0> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 8s.
+Computing the boundary of the generator 15/16 (dimension 4) :
+<TnPr <TnPr g33 0> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 8s.
+Computing the boundary of the generator 16/16 (dimension 4) :
+<TnPr <TnPr g34 0> <<Abar>>> 
+End of computing.
+
+
+Computing boundary-matrix in dimension 5.
+Rank of the source-module : 29.
+
+
+;; Clock -> 2011-07-14, 9h 56m 8s.
+Computing the boundary of the generator 1/29 (dimension 5) :
+<TnPr <TnPr S-BSGN 0> <<Abar[5 4]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 8s.
+Computing the boundary of the generator 2/29 (dimension 5) :
+<TnPr <TnPr S-BSGN 0> <<Abar[2 1][3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 8s.
+Computing the boundary of the generator 3/29 (dimension 5) :
+<TnPr <TnPr S-BSGN 0> <<Abar[3 2][2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 4/29 (dimension 5) :
+<TnPr <TnPr S-BSGN 1> <<Abar[4 3]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 5/29 (dimension 5) :
+<TnPr <TnPr S-BSGN 1> <<Abar[2 1][2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 6/29 (dimension 5) :
+<TnPr <TnPr S-BSGN 2> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 7/29 (dimension 5) :
+<TnPr <TnPr g11 0> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 8/29 (dimension 5) :
+<TnPr <TnPr g12 0> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 9/29 (dimension 5) :
+<TnPr <TnPr S-BSGN 3> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 10/29 (dimension 5) :
+<TnPr <TnPr g11 1> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 11/29 (dimension 5) :
+<TnPr <TnPr g12 1> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 12/29 (dimension 5) :
+<TnPr <TnPr g21 0> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 13/29 (dimension 5) :
+<TnPr <TnPr g22 0> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 14/29 (dimension 5) :
+<TnPr <TnPr g23 0> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 15/29 (dimension 5) :
+<TnPr <TnPr S-BSGN 5> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 16/29 (dimension 5) :
+<TnPr <TnPr g11 3> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 17/29 (dimension 5) :
+<TnPr <TnPr g12 3> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 18/29 (dimension 5) :
+<TnPr <TnPr g21 2> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 19/29 (dimension 5) :
+<TnPr <TnPr g22 2> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 20/29 (dimension 5) :
+<TnPr <TnPr g23 2> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 21/29 (dimension 5) :
+<TnPr <TnPr g31 1> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 22/29 (dimension 5) :
+<TnPr <TnPr g32 1> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 23/29 (dimension 5) :
+<TnPr <TnPr g33 1> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 24/29 (dimension 5) :
+<TnPr <TnPr g34 1> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 25/29 (dimension 5) :
+<TnPr <TnPr g41 0> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 26/29 (dimension 5) :
+<TnPr <TnPr g42 0> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 27/29 (dimension 5) :
+<TnPr <TnPr g43 0> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 28/29 (dimension 5) :
+<TnPr <TnPr g44 0> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 29/29 (dimension 5) :
+<TnPr <TnPr g45 0> <<Abar>>> 
+End of computing.
+
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+
+
+Computing boundary-matrix in dimension 5.
+Rank of the source-module : 36.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 1/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar[5 <<Abar[4 3]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 2/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar[5 <<Abar[2 1][2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 3/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar>>> <<Abar[4 <<Abar[3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 4/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[2 1]>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 5/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 2> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 6/36 (dimension 5) :
+<TnPr <TnPr <TnPr g11 0> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 7/36 (dimension 5) :
+<TnPr <TnPr <TnPr g12 0> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 8/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[5 4]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 9/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[2 1][3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 10/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[3 2][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 11/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar[4 3]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 12/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar[2 1][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 13/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 2> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 14/36 (dimension 5) :
+<TnPr <TnPr <TnPr g11 0> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 15/36 (dimension 5) :
+<TnPr <TnPr <TnPr g12 0> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 16/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 3> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 9s.
+Computing the boundary of the generator 17/36 (dimension 5) :
+<TnPr <TnPr <TnPr g11 1> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 10s.
+Computing the boundary of the generator 18/36 (dimension 5) :
+<TnPr <TnPr <TnPr g12 1> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 10s.
+Computing the boundary of the generator 19/36 (dimension 5) :
+<TnPr <TnPr <TnPr g21 0> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 10s.
+Computing the boundary of the generator 20/36 (dimension 5) :
+<TnPr <TnPr <TnPr g22 0> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 10s.
+Computing the boundary of the generator 21/36 (dimension 5) :
+<TnPr <TnPr <TnPr g23 0> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 10s.
+Computing the boundary of the generator 22/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 5> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 10s.
+Computing the boundary of the generator 23/36 (dimension 5) :
+<TnPr <TnPr <TnPr g11 3> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 10s.
+Computing the boundary of the generator 24/36 (dimension 5) :
+<TnPr <TnPr <TnPr g12 3> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 10s.
+Computing the boundary of the generator 25/36 (dimension 5) :
+<TnPr <TnPr <TnPr g21 2> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 10s.
+Computing the boundary of the generator 26/36 (dimension 5) :
+<TnPr <TnPr <TnPr g22 2> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 10s.
+Computing the boundary of the generator 27/36 (dimension 5) :
+<TnPr <TnPr <TnPr g23 2> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 11s.
+Computing the boundary of the generator 28/36 (dimension 5) :
+<TnPr <TnPr <TnPr g31 1> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 11s.
+Computing the boundary of the generator 29/36 (dimension 5) :
+<TnPr <TnPr <TnPr g32 1> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 11s.
+Computing the boundary of the generator 30/36 (dimension 5) :
+<TnPr <TnPr <TnPr g33 1> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 11s.
+Computing the boundary of the generator 31/36 (dimension 5) :
+<TnPr <TnPr <TnPr g34 1> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.026471086 -- N = 10197
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 11s.
+Computing the boundary of the generator 32/36 (dimension 5) :
+<TnPr <TnPr <TnPr g41 0> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 12s.
+Computing the boundary of the generator 33/36 (dimension 5) :
+<TnPr <TnPr <TnPr g42 0> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 12s.
+Computing the boundary of the generator 34/36 (dimension 5) :
+<TnPr <TnPr <TnPr g43 0> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 12s.
+Computing the boundary of the generator 35/36 (dimension 5) :
+<TnPr <TnPr <TnPr g44 0> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 12s.
+Computing the boundary of the generator 36/36 (dimension 5) :
+<TnPr <TnPr <TnPr g45 0> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+Computing boundary-matrix in dimension 6.
+Rank of the source-module : 69.
+
+
+;; Clock -> 2011-07-14, 9h 56m 13s.
+Computing the boundary of the generator 1/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar[6 <<Abar[5 4]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 13s.
+Computing the boundary of the generator 2/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar[6 <<Abar[2 1][3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 13s.
+Computing the boundary of the generator 3/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar[6 <<Abar[3 2][2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 13s.
+Computing the boundary of the generator 4/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar[3 <<Abar[2 1]>>][3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 13s.
+Computing the boundary of the generator 5/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar>>> <<Abar[5 <<Abar[4 3]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 13s.
+Computing the boundary of the generator 6/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar>>> <<Abar[5 <<Abar[2 1][2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 13s.
+Computing the boundary of the generator 7/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[2 1]>>> <<Abar[4 <<Abar[3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 13s.
+Computing the boundary of the generator 8/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 2> <<Abar>>> <<Abar[4 <<Abar[3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 13s.
+Computing the boundary of the generator 9/69 (dimension 6) :
+<TnPr <TnPr <TnPr g11 0> <<Abar>>> <<Abar[4 <<Abar[3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 13s.
+Computing the boundary of the generator 10/69 (dimension 6) :
+<TnPr <TnPr <TnPr g12 0> <<Abar>>> <<Abar[4 <<Abar[3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 14s.
+Computing the boundary of the generator 11/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[3 2]>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 14s.
+Computing the boundary of the generator 12/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar[2 1]>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 14s.
+Computing the boundary of the generator 13/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 3> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 14s.
+Computing the boundary of the generator 14/69 (dimension 6) :
+<TnPr <TnPr <TnPr g11 1> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 14s.
+Computing the boundary of the generator 15/69 (dimension 6) :
+<TnPr <TnPr <TnPr g12 1> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 14s.
+Computing the boundary of the generator 16/69 (dimension 6) :
+<TnPr <TnPr <TnPr g21 0> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 14s.
+Computing the boundary of the generator 17/69 (dimension 6) :
+<TnPr <TnPr <TnPr g22 0> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 14s.
+Computing the boundary of the generator 18/69 (dimension 6) :
+<TnPr <TnPr <TnPr g23 0> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 14s.
+Computing the boundary of the generator 19/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[6 5]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 14s.
+Computing the boundary of the generator 20/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[2 1][4 3]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 14s.
+Computing the boundary of the generator 21/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[3 2][3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 14s.
+Computing the boundary of the generator 22/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[4 3][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 14s.
+Computing the boundary of the generator 23/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[2 1][2 1][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 14s.
+Computing the boundary of the generator 24/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar[5 4]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 15s.
+Computing the boundary of the generator 25/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar[2 1][3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 15s.
+Computing the boundary of the generator 26/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar[3 2][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 15s.
+Computing the boundary of the generator 27/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 2> <<Abar[4 3]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 15s.
+Computing the boundary of the generator 28/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 2> <<Abar[2 1][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 15s.
+Computing the boundary of the generator 29/69 (dimension 6) :
+<TnPr <TnPr <TnPr g11 0> <<Abar[4 3]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 15s.
+Computing the boundary of the generator 30/69 (dimension 6) :
+<TnPr <TnPr <TnPr g11 0> <<Abar[2 1][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 15s.
+Computing the boundary of the generator 31/69 (dimension 6) :
+<TnPr <TnPr <TnPr g12 0> <<Abar[4 3]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 15s.
+Computing the boundary of the generator 32/69 (dimension 6) :
+<TnPr <TnPr <TnPr g12 0> <<Abar[2 1][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 15s.
+Computing the boundary of the generator 33/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 3> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 15s.
+Computing the boundary of the generator 34/69 (dimension 6) :
+<TnPr <TnPr <TnPr g11 1> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 16s.
+Computing the boundary of the generator 35/69 (dimension 6) :
+<TnPr <TnPr <TnPr g12 1> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 16s.
+Computing the boundary of the generator 36/69 (dimension 6) :
+<TnPr <TnPr <TnPr g21 0> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 16s.
+Computing the boundary of the generator 37/69 (dimension 6) :
+<TnPr <TnPr <TnPr g22 0> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 16s.
+Computing the boundary of the generator 38/69 (dimension 6) :
+<TnPr <TnPr <TnPr g23 0> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 16s.
+Computing the boundary of the generator 39/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 4> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 16s.
+Computing the boundary of the generator 40/69 (dimension 6) :
+<TnPr <TnPr <TnPr g11 2> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 18s.
+Computing the boundary of the generator 41/69 (dimension 6) :
+<TnPr <TnPr <TnPr g12 2> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 18s.
+Computing the boundary of the generator 42/69 (dimension 6) :
+<TnPr <TnPr <TnPr g21 1> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 19s.
+Computing the boundary of the generator 43/69 (dimension 6) :
+<TnPr <TnPr <TnPr g22 1> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 20s.
+Computing the boundary of the generator 44/69 (dimension 6) :
+<TnPr <TnPr <TnPr g23 1> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 21s.
+Computing the boundary of the generator 45/69 (dimension 6) :
+<TnPr <TnPr <TnPr g31 0> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 22s.
+Computing the boundary of the generator 46/69 (dimension 6) :
+<TnPr <TnPr <TnPr g32 0> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 22s.
+Computing the boundary of the generator 47/69 (dimension 6) :
+<TnPr <TnPr <TnPr g33 0> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 22s.
+Computing the boundary of the generator 48/69 (dimension 6) :
+<TnPr <TnPr <TnPr g34 0> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 22s.
+Computing the boundary of the generator 49/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 6> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 23s.
+Computing the boundary of the generator 50/69 (dimension 6) :
+<TnPr <TnPr <TnPr g11 4> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 25s.
+Computing the boundary of the generator 51/69 (dimension 6) :
+<TnPr <TnPr <TnPr g12 4> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 25s.
+Computing the boundary of the generator 52/69 (dimension 6) :
+<TnPr <TnPr <TnPr g21 3> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.026193824 -- N = 10254
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 30s.
+Computing the boundary of the generator 53/69 (dimension 6) :
+<TnPr <TnPr <TnPr g22 3> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 33s.
+Computing the boundary of the generator 54/69 (dimension 6) :
+<TnPr <TnPr <TnPr g23 3> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 36s.
+Computing the boundary of the generator 55/69 (dimension 6) :
+<TnPr <TnPr <TnPr g31 2> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.026362488 -- N = 10311
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 43s.
+Computing the boundary of the generator 56/69 (dimension 6) :
+<TnPr <TnPr <TnPr g32 2> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 46s.
+Computing the boundary of the generator 57/69 (dimension 6) :
+<TnPr <TnPr <TnPr g33 2> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 56m 51s.
+Computing the boundary of the generator 58/69 (dimension 6) :
+<TnPr <TnPr <TnPr g34 2> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.026545823 -- N = 10368
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 2s.
+Computing the boundary of the generator 59/69 (dimension 6) :
+<TnPr <TnPr <TnPr g41 1> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 3s.
+Computing the boundary of the generator 60/69 (dimension 6) :
+<TnPr <TnPr <TnPr g42 1> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 7s.
+Computing the boundary of the generator 61/69 (dimension 6) :
+<TnPr <TnPr <TnPr g43 1> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 11s.
+Computing the boundary of the generator 62/69 (dimension 6) :
+<TnPr <TnPr <TnPr g44 1> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.02681824 -- N = 10420
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 18s.
+Computing the boundary of the generator 63/69 (dimension 6) :
+<TnPr <TnPr <TnPr g45 1> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 25s.
+Computing the boundary of the generator 64/69 (dimension 6) :
+<TnPr <TnPr <TnPr g51 0> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 25s.
+Computing the boundary of the generator 65/69 (dimension 6) :
+<TnPr <TnPr <TnPr g52 0> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 26s.
+Computing the boundary of the generator 66/69 (dimension 6) :
+<TnPr <TnPr <TnPr g53 0> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 28s.
+Computing the boundary of the generator 67/69 (dimension 6) :
+<TnPr <TnPr <TnPr g54 0> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 28s.
+Computing the boundary of the generator 68/69 (dimension 6) :
+<TnPr <TnPr <TnPr g55 0> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 30s.
+Computing the boundary of the generator 69/69 (dimension 6) :
+<TnPr <TnPr <TnPr g56 0> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+
+;; Clock -> 2011-07-14, 9h 57m 32s.
+
+
+Computing boundary-matrix in dimension 5.
+Rank of the source-module : 36.
+
+
+;; Clock -> 2011-07-14, 9h 57m 32s.
+Computing the boundary of the generator 1/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar[5 <<Abar[4 3]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 32s.
+Computing the boundary of the generator 2/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar[5 <<Abar[2 1][2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 32s.
+Computing the boundary of the generator 3/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar>>> <<Abar[4 <<Abar[3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 32s.
+Computing the boundary of the generator 4/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[2 1]>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 32s.
+Computing the boundary of the generator 5/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 2> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 32s.
+Computing the boundary of the generator 6/36 (dimension 5) :
+<TnPr <TnPr <TnPr g11 0> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 32s.
+Computing the boundary of the generator 7/36 (dimension 5) :
+<TnPr <TnPr <TnPr g12 0> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 32s.
+Computing the boundary of the generator 8/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[5 4]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 32s.
+Computing the boundary of the generator 9/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[2 1][3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 32s.
+Computing the boundary of the generator 10/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[3 2][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 32s.
+Computing the boundary of the generator 11/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar[4 3]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 32s.
+Computing the boundary of the generator 12/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar[2 1][2 1]>>> <<Abar>>> 
+*CR* -- Cut = 0.027058253 -- N = 10497
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 32s.
+Computing the boundary of the generator 13/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 2> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 32s.
+Computing the boundary of the generator 14/36 (dimension 5) :
+<TnPr <TnPr <TnPr g11 0> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 32s.
+Computing the boundary of the generator 15/36 (dimension 5) :
+<TnPr <TnPr <TnPr g12 0> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 32s.
+Computing the boundary of the generator 16/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 3> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 32s.
+Computing the boundary of the generator 17/36 (dimension 5) :
+<TnPr <TnPr <TnPr g11 1> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 32s.
+Computing the boundary of the generator 18/36 (dimension 5) :
+<TnPr <TnPr <TnPr g12 1> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 32s.
+Computing the boundary of the generator 19/36 (dimension 5) :
+<TnPr <TnPr <TnPr g21 0> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 32s.
+Computing the boundary of the generator 20/36 (dimension 5) :
+<TnPr <TnPr <TnPr g22 0> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 32s.
+Computing the boundary of the generator 21/36 (dimension 5) :
+<TnPr <TnPr <TnPr g23 0> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 32s.
+Computing the boundary of the generator 22/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 5> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 32s.
+Computing the boundary of the generator 23/36 (dimension 5) :
+<TnPr <TnPr <TnPr g11 3> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 33s.
+Computing the boundary of the generator 24/36 (dimension 5) :
+<TnPr <TnPr <TnPr g12 3> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 33s.
+Computing the boundary of the generator 25/36 (dimension 5) :
+<TnPr <TnPr <TnPr g21 2> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 33s.
+Computing the boundary of the generator 26/36 (dimension 5) :
+<TnPr <TnPr <TnPr g22 2> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 33s.
+Computing the boundary of the generator 27/36 (dimension 5) :
+<TnPr <TnPr <TnPr g23 2> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 33s.
+Computing the boundary of the generator 28/36 (dimension 5) :
+<TnPr <TnPr <TnPr g31 1> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 34s.
+Computing the boundary of the generator 29/36 (dimension 5) :
+<TnPr <TnPr <TnPr g32 1> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 34s.
+Computing the boundary of the generator 30/36 (dimension 5) :
+<TnPr <TnPr <TnPr g33 1> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 34s.
+Computing the boundary of the generator 31/36 (dimension 5) :
+<TnPr <TnPr <TnPr g34 1> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 34s.
+Computing the boundary of the generator 32/36 (dimension 5) :
+<TnPr <TnPr <TnPr g41 0> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 34s.
+Computing the boundary of the generator 33/36 (dimension 5) :
+<TnPr <TnPr <TnPr g42 0> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 34s.
+Computing the boundary of the generator 34/36 (dimension 5) :
+<TnPr <TnPr <TnPr g43 0> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 35s.
+Computing the boundary of the generator 35/36 (dimension 5) :
+<TnPr <TnPr <TnPr g44 0> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 35s.
+Computing the boundary of the generator 36/36 (dimension 5) :
+<TnPr <TnPr <TnPr g45 0> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+Computing boundary-matrix in dimension 6.
+Rank of the source-module : 69.
+
+
+;; Clock -> 2011-07-14, 9h 57m 35s.
+Computing the boundary of the generator 1/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar[6 <<Abar[5 4]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 37s.
+Computing the boundary of the generator 2/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar[6 <<Abar[2 1][3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 37s.
+Computing the boundary of the generator 3/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar[6 <<Abar[3 2][2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 37s.
+Computing the boundary of the generator 4/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar[3 <<Abar[2 1]>>][3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 37s.
+Computing the boundary of the generator 5/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar>>> <<Abar[5 <<Abar[4 3]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 37s.
+Computing the boundary of the generator 6/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar>>> <<Abar[5 <<Abar[2 1][2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 37s.
+Computing the boundary of the generator 7/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[2 1]>>> <<Abar[4 <<Abar[3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 37s.
+Computing the boundary of the generator 8/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 2> <<Abar>>> <<Abar[4 <<Abar[3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 37s.
+Computing the boundary of the generator 9/69 (dimension 6) :
+<TnPr <TnPr <TnPr g11 0> <<Abar>>> <<Abar[4 <<Abar[3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 37s.
+Computing the boundary of the generator 10/69 (dimension 6) :
+<TnPr <TnPr <TnPr g12 0> <<Abar>>> <<Abar[4 <<Abar[3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 37s.
+Computing the boundary of the generator 11/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[3 2]>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 37s.
+Computing the boundary of the generator 12/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar[2 1]>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 37s.
+Computing the boundary of the generator 13/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 3> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 37s.
+Computing the boundary of the generator 14/69 (dimension 6) :
+<TnPr <TnPr <TnPr g11 1> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 37s.
+Computing the boundary of the generator 15/69 (dimension 6) :
+<TnPr <TnPr <TnPr g12 1> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 37s.
+Computing the boundary of the generator 16/69 (dimension 6) :
+<TnPr <TnPr <TnPr g21 0> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 37s.
+Computing the boundary of the generator 17/69 (dimension 6) :
+<TnPr <TnPr <TnPr g22 0> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 38s.
+Computing the boundary of the generator 18/69 (dimension 6) :
+<TnPr <TnPr <TnPr g23 0> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 38s.
+Computing the boundary of the generator 19/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[6 5]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 38s.
+Computing the boundary of the generator 20/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[2 1][4 3]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 38s.
+Computing the boundary of the generator 21/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[3 2][3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 38s.
+Computing the boundary of the generator 22/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[4 3][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 38s.
+Computing the boundary of the generator 23/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[2 1][2 1][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 38s.
+Computing the boundary of the generator 24/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar[5 4]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 38s.
+Computing the boundary of the generator 25/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar[2 1][3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 38s.
+Computing the boundary of the generator 26/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar[3 2][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 38s.
+Computing the boundary of the generator 27/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 2> <<Abar[4 3]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 38s.
+Computing the boundary of the generator 28/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 2> <<Abar[2 1][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 38s.
+Computing the boundary of the generator 29/69 (dimension 6) :
+<TnPr <TnPr <TnPr g11 0> <<Abar[4 3]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 39s.
+Computing the boundary of the generator 30/69 (dimension 6) :
+<TnPr <TnPr <TnPr g11 0> <<Abar[2 1][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 39s.
+Computing the boundary of the generator 31/69 (dimension 6) :
+<TnPr <TnPr <TnPr g12 0> <<Abar[4 3]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 39s.
+Computing the boundary of the generator 32/69 (dimension 6) :
+<TnPr <TnPr <TnPr g12 0> <<Abar[2 1][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 39s.
+Computing the boundary of the generator 33/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 3> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 39s.
+Computing the boundary of the generator 34/69 (dimension 6) :
+<TnPr <TnPr <TnPr g11 1> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 39s.
+Computing the boundary of the generator 35/69 (dimension 6) :
+<TnPr <TnPr <TnPr g12 1> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 40s.
+Computing the boundary of the generator 36/69 (dimension 6) :
+<TnPr <TnPr <TnPr g21 0> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 40s.
+Computing the boundary of the generator 37/69 (dimension 6) :
+<TnPr <TnPr <TnPr g22 0> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 40s.
+Computing the boundary of the generator 38/69 (dimension 6) :
+<TnPr <TnPr <TnPr g23 0> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 40s.
+Computing the boundary of the generator 39/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 4> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 40s.
+Computing the boundary of the generator 40/69 (dimension 6) :
+<TnPr <TnPr <TnPr g11 2> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 41s.
+Computing the boundary of the generator 41/69 (dimension 6) :
+<TnPr <TnPr <TnPr g12 2> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 41s.
+Computing the boundary of the generator 42/69 (dimension 6) :
+<TnPr <TnPr <TnPr g21 1> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 42s.
+Computing the boundary of the generator 43/69 (dimension 6) :
+<TnPr <TnPr <TnPr g22 1> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 42s.
+Computing the boundary of the generator 44/69 (dimension 6) :
+<TnPr <TnPr <TnPr g23 1> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 44s.
+Computing the boundary of the generator 45/69 (dimension 6) :
+<TnPr <TnPr <TnPr g31 0> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 44s.
+Computing the boundary of the generator 46/69 (dimension 6) :
+<TnPr <TnPr <TnPr g32 0> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 44s.
+Computing the boundary of the generator 47/69 (dimension 6) :
+<TnPr <TnPr <TnPr g33 0> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 44s.
+Computing the boundary of the generator 48/69 (dimension 6) :
+<TnPr <TnPr <TnPr g34 0> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 45s.
+Computing the boundary of the generator 49/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 6> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 45s.
+Computing the boundary of the generator 50/69 (dimension 6) :
+<TnPr <TnPr <TnPr g11 4> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 46s.
+Computing the boundary of the generator 51/69 (dimension 6) :
+<TnPr <TnPr <TnPr g12 4> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 46s.
+Computing the boundary of the generator 52/69 (dimension 6) :
+<TnPr <TnPr <TnPr g21 3> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.027114734 -- N = 10505
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 50s.
+Computing the boundary of the generator 53/69 (dimension 6) :
+<TnPr <TnPr <TnPr g22 3> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 52s.
+Computing the boundary of the generator 54/69 (dimension 6) :
+<TnPr <TnPr <TnPr g23 3> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 54s.
+Computing the boundary of the generator 55/69 (dimension 6) :
+<TnPr <TnPr <TnPr g31 2> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 56s.
+Computing the boundary of the generator 56/69 (dimension 6) :
+<TnPr <TnPr <TnPr g32 2> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 57m 57s.
+Computing the boundary of the generator 57/69 (dimension 6) :
+<TnPr <TnPr <TnPr g33 2> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 0s.
+Computing the boundary of the generator 58/69 (dimension 6) :
+<TnPr <TnPr <TnPr g34 2> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.027164893 -- N = 10514
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 6s.
+Computing the boundary of the generator 59/69 (dimension 6) :
+<TnPr <TnPr <TnPr g41 1> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 7s.
+Computing the boundary of the generator 60/69 (dimension 6) :
+<TnPr <TnPr <TnPr g42 1> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 9s.
+Computing the boundary of the generator 61/69 (dimension 6) :
+<TnPr <TnPr <TnPr g43 1> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 11s.
+Computing the boundary of the generator 62/69 (dimension 6) :
+<TnPr <TnPr <TnPr g44 1> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 15s.
+Computing the boundary of the generator 63/69 (dimension 6) :
+<TnPr <TnPr <TnPr g45 1> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.027187303 -- N = 10525
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 18s.
+Computing the boundary of the generator 64/69 (dimension 6) :
+<TnPr <TnPr <TnPr g51 0> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 18s.
+Computing the boundary of the generator 65/69 (dimension 6) :
+<TnPr <TnPr <TnPr g52 0> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 18s.
+Computing the boundary of the generator 66/69 (dimension 6) :
+<TnPr <TnPr <TnPr g53 0> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 20s.
+Computing the boundary of the generator 67/69 (dimension 6) :
+<TnPr <TnPr <TnPr g54 0> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 20s.
+Computing the boundary of the generator 68/69 (dimension 6) :
+<TnPr <TnPr <TnPr g55 0> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 21s.
+Computing the boundary of the generator 69/69 (dimension 6) :
+<TnPr <TnPr <TnPr g56 0> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+
+;; Clock -> 2011-07-14, 9h 58m 23s.
+
+
+
+
+Homotopy in dimension 5 :
+
+
+Component Z/2Z
+
+Component Z/2Z
+
+NIL
+CL-USER(36): (homotopy s-k-s3-1 6)
+
+Computing boundary-matrix in dimension 1.
+Rank of the source-module : 0.
+
+
+Computing boundary-matrix in dimension 2.
+Rank of the source-module : 2.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 1/2 (dimension 2) :
+"g11" 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 2/2 (dimension 2) :
+"g12" 
+End of computing.
+
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+
+
+Computing boundary-matrix in dimension 2.
+Rank of the source-module : 2.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 1/2 (dimension 2) :
+"g11" 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 2/2 (dimension 2) :
+"g12" 
+End of computing.
+
+
+Computing boundary-matrix in dimension 3.
+Rank of the source-module : 3.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 1/3 (dimension 3) :
+"g21" 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 2/3 (dimension 3) :
+"g22" 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 3/3 (dimension 3) :
+"g23" 
+End of computing.
+
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+
+
+Computing boundary-matrix in dimension 2.
+Rank of the source-module : 2.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 1/2 (dimension 2) :
+"g11" 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 2/2 (dimension 2) :
+"g12" 
+End of computing.
+
+
+Computing boundary-matrix in dimension 3.
+Rank of the source-module : 3.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 1/3 (dimension 3) :
+"g21" 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 2/3 (dimension 3) :
+"g22" 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 3/3 (dimension 3) :
+"g23" 
+End of computing.
+
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+
+
+Computing boundary-matrix in dimension 3.
+Rank of the source-module : 6.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 1/6 (dimension 3) :
+<TnPr S-BSGN 3> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 2/6 (dimension 3) :
+<TnPr g11 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 3/6 (dimension 3) :
+<TnPr g12 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 4/6 (dimension 3) :
+<TnPr g21 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 5/6 (dimension 3) :
+<TnPr g22 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 6/6 (dimension 3) :
+<TnPr g23 0> 
+End of computing.
+
+
+Computing boundary-matrix in dimension 4.
+Rank of the source-module : 10.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 1/10 (dimension 4) :
+<TnPr S-BSGN 4> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 2/10 (dimension 4) :
+<TnPr g11 2> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 3/10 (dimension 4) :
+<TnPr g12 2> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 4/10 (dimension 4) :
+<TnPr g21 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 5/10 (dimension 4) :
+<TnPr g22 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 6/10 (dimension 4) :
+<TnPr g23 1> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 7/10 (dimension 4) :
+<TnPr g31 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 8/10 (dimension 4) :
+<TnPr g32 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 9/10 (dimension 4) :
+<TnPr g33 0> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 10/10 (dimension 4) :
+<TnPr g34 0> 
+End of computing.
+
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+
+
+Computing boundary-matrix in dimension 4.
+Rank of the source-module : 16.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 1/16 (dimension 4) :
+<TnPr <TnPr S-BSGN 0> <<Abar[4 3]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 2/16 (dimension 4) :
+<TnPr <TnPr S-BSGN 0> <<Abar[2 1][2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 3/16 (dimension 4) :
+<TnPr <TnPr S-BSGN 1> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 4/16 (dimension 4) :
+<TnPr <TnPr S-BSGN 2> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 5/16 (dimension 4) :
+<TnPr <TnPr g11 0> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 6/16 (dimension 4) :
+<TnPr <TnPr g12 0> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 7/16 (dimension 4) :
+<TnPr <TnPr S-BSGN 4> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 8/16 (dimension 4) :
+<TnPr <TnPr g11 2> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 9/16 (dimension 4) :
+<TnPr <TnPr g12 2> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 10/16 (dimension 4) :
+<TnPr <TnPr g21 1> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 11/16 (dimension 4) :
+<TnPr <TnPr g22 1> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 12/16 (dimension 4) :
+<TnPr <TnPr g23 1> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 13/16 (dimension 4) :
+<TnPr <TnPr g31 0> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 14/16 (dimension 4) :
+<TnPr <TnPr g32 0> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 15/16 (dimension 4) :
+<TnPr <TnPr g33 0> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 16/16 (dimension 4) :
+<TnPr <TnPr g34 0> <<Abar>>> 
+End of computing.
+
+
+Computing boundary-matrix in dimension 5.
+Rank of the source-module : 29.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 1/29 (dimension 5) :
+<TnPr <TnPr S-BSGN 0> <<Abar[5 4]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 2/29 (dimension 5) :
+<TnPr <TnPr S-BSGN 0> <<Abar[2 1][3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 3/29 (dimension 5) :
+<TnPr <TnPr S-BSGN 0> <<Abar[3 2][2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 4/29 (dimension 5) :
+<TnPr <TnPr S-BSGN 1> <<Abar[4 3]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 5/29 (dimension 5) :
+<TnPr <TnPr S-BSGN 1> <<Abar[2 1][2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 6/29 (dimension 5) :
+<TnPr <TnPr S-BSGN 2> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 7/29 (dimension 5) :
+<TnPr <TnPr g11 0> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 8/29 (dimension 5) :
+<TnPr <TnPr g12 0> <<Abar[3 2]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 9/29 (dimension 5) :
+<TnPr <TnPr S-BSGN 3> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 10/29 (dimension 5) :
+<TnPr <TnPr g11 1> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 11/29 (dimension 5) :
+<TnPr <TnPr g12 1> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 12/29 (dimension 5) :
+<TnPr <TnPr g21 0> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 13/29 (dimension 5) :
+<TnPr <TnPr g22 0> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 14/29 (dimension 5) :
+<TnPr <TnPr g23 0> <<Abar[2 1]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 15/29 (dimension 5) :
+<TnPr <TnPr S-BSGN 5> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 48s.
+Computing the boundary of the generator 16/29 (dimension 5) :
+<TnPr <TnPr g11 3> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 49s.
+Computing the boundary of the generator 17/29 (dimension 5) :
+<TnPr <TnPr g12 3> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 49s.
+Computing the boundary of the generator 18/29 (dimension 5) :
+<TnPr <TnPr g21 2> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 49s.
+Computing the boundary of the generator 19/29 (dimension 5) :
+<TnPr <TnPr g22 2> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 49s.
+Computing the boundary of the generator 20/29 (dimension 5) :
+<TnPr <TnPr g23 2> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 49s.
+Computing the boundary of the generator 21/29 (dimension 5) :
+<TnPr <TnPr g31 1> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 49s.
+Computing the boundary of the generator 22/29 (dimension 5) :
+<TnPr <TnPr g32 1> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 49s.
+Computing the boundary of the generator 23/29 (dimension 5) :
+<TnPr <TnPr g33 1> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 49s.
+Computing the boundary of the generator 24/29 (dimension 5) :
+<TnPr <TnPr g34 1> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 49s.
+Computing the boundary of the generator 25/29 (dimension 5) :
+<TnPr <TnPr g41 0> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 49s.
+Computing the boundary of the generator 26/29 (dimension 5) :
+<TnPr <TnPr g42 0> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 49s.
+Computing the boundary of the generator 27/29 (dimension 5) :
+<TnPr <TnPr g43 0> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 49s.
+Computing the boundary of the generator 28/29 (dimension 5) :
+<TnPr <TnPr g44 0> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 49s.
+Computing the boundary of the generator 29/29 (dimension 5) :
+<TnPr <TnPr g45 0> <<Abar>>> 
+End of computing.
+
+
+
+;; Clock -> 2011-07-14, 9h 58m 49s.
+
+
+Computing boundary-matrix in dimension 5.
+Rank of the source-module : 36.
+
+
+;; Clock -> 2011-07-14, 9h 58m 49s.
+Computing the boundary of the generator 1/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar[5 <<Abar[4 3]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 49s.
+Computing the boundary of the generator 2/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar[5 <<Abar[2 1][2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 49s.
+Computing the boundary of the generator 3/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar>>> <<Abar[4 <<Abar[3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 49s.
+Computing the boundary of the generator 4/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[2 1]>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 49s.
+Computing the boundary of the generator 5/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 2> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 49s.
+Computing the boundary of the generator 6/36 (dimension 5) :
+<TnPr <TnPr <TnPr g11 0> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 49s.
+Computing the boundary of the generator 7/36 (dimension 5) :
+<TnPr <TnPr <TnPr g12 0> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 49s.
+Computing the boundary of the generator 8/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[5 4]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 49s.
+Computing the boundary of the generator 9/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[2 1][3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 49s.
+Computing the boundary of the generator 10/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[3 2][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 49s.
+Computing the boundary of the generator 11/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar[4 3]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 49s.
+Computing the boundary of the generator 12/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar[2 1][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 49s.
+Computing the boundary of the generator 13/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 2> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 49s.
+Computing the boundary of the generator 14/36 (dimension 5) :
+<TnPr <TnPr <TnPr g11 0> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 49s.
+Computing the boundary of the generator 15/36 (dimension 5) :
+<TnPr <TnPr <TnPr g12 0> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 49s.
+Computing the boundary of the generator 16/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 3> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 49s.
+Computing the boundary of the generator 17/36 (dimension 5) :
+<TnPr <TnPr <TnPr g11 1> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 49s.
+Computing the boundary of the generator 18/36 (dimension 5) :
+<TnPr <TnPr <TnPr g12 1> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 50s.
+Computing the boundary of the generator 19/36 (dimension 5) :
+<TnPr <TnPr <TnPr g21 0> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 50s.
+Computing the boundary of the generator 20/36 (dimension 5) :
+<TnPr <TnPr <TnPr g22 0> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 50s.
+Computing the boundary of the generator 21/36 (dimension 5) :
+<TnPr <TnPr <TnPr g23 0> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 50s.
+Computing the boundary of the generator 22/36 (dimension 5) :
+<TnPr <TnPr <TnPr S-BSGN 5> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 50s.
+Computing the boundary of the generator 23/36 (dimension 5) :
+<TnPr <TnPr <TnPr g11 3> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 50s.
+Computing the boundary of the generator 24/36 (dimension 5) :
+<TnPr <TnPr <TnPr g12 3> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 50s.
+Computing the boundary of the generator 25/36 (dimension 5) :
+<TnPr <TnPr <TnPr g21 2> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 50s.
+Computing the boundary of the generator 26/36 (dimension 5) :
+<TnPr <TnPr <TnPr g22 2> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 50s.
+Computing the boundary of the generator 27/36 (dimension 5) :
+<TnPr <TnPr <TnPr g23 2> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 50s.
+Computing the boundary of the generator 28/36 (dimension 5) :
+<TnPr <TnPr <TnPr g31 1> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 51s.
+Computing the boundary of the generator 29/36 (dimension 5) :
+<TnPr <TnPr <TnPr g32 1> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 51s.
+Computing the boundary of the generator 30/36 (dimension 5) :
+<TnPr <TnPr <TnPr g33 1> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 51s.
+Computing the boundary of the generator 31/36 (dimension 5) :
+<TnPr <TnPr <TnPr g34 1> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 51s.
+Computing the boundary of the generator 32/36 (dimension 5) :
+<TnPr <TnPr <TnPr g41 0> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 51s.
+Computing the boundary of the generator 33/36 (dimension 5) :
+<TnPr <TnPr <TnPr g42 0> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 51s.
+Computing the boundary of the generator 34/36 (dimension 5) :
+<TnPr <TnPr <TnPr g43 0> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 51s.
+Computing the boundary of the generator 35/36 (dimension 5) :
+<TnPr <TnPr <TnPr g44 0> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 51s.
+Computing the boundary of the generator 36/36 (dimension 5) :
+<TnPr <TnPr <TnPr g45 0> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+Computing boundary-matrix in dimension 6.
+Rank of the source-module : 69.
+
+
+;; Clock -> 2011-07-14, 9h 58m 51s.
+Computing the boundary of the generator 1/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar[6 <<Abar[5 4]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 52s.
+Computing the boundary of the generator 2/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar[6 <<Abar[2 1][3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 52s.
+Computing the boundary of the generator 3/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar[6 <<Abar[3 2][2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 52s.
+Computing the boundary of the generator 4/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar[3 <<Abar[2 1]>>][3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 52s.
+Computing the boundary of the generator 5/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar>>> <<Abar[5 <<Abar[4 3]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 52s.
+Computing the boundary of the generator 6/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar>>> <<Abar[5 <<Abar[2 1][2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 52s.
+Computing the boundary of the generator 7/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[2 1]>>> <<Abar[4 <<Abar[3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 52s.
+Computing the boundary of the generator 8/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 2> <<Abar>>> <<Abar[4 <<Abar[3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 52s.
+Computing the boundary of the generator 9/69 (dimension 6) :
+<TnPr <TnPr <TnPr g11 0> <<Abar>>> <<Abar[4 <<Abar[3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 52s.
+Computing the boundary of the generator 10/69 (dimension 6) :
+<TnPr <TnPr <TnPr g12 0> <<Abar>>> <<Abar[4 <<Abar[3 2]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 52s.
+Computing the boundary of the generator 11/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[3 2]>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 52s.
+Computing the boundary of the generator 12/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar[2 1]>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 52s.
+Computing the boundary of the generator 13/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 3> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 52s.
+Computing the boundary of the generator 14/69 (dimension 6) :
+<TnPr <TnPr <TnPr g11 1> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 52s.
+Computing the boundary of the generator 15/69 (dimension 6) :
+<TnPr <TnPr <TnPr g12 1> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 52s.
+Computing the boundary of the generator 16/69 (dimension 6) :
+<TnPr <TnPr <TnPr g21 0> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 53s.
+Computing the boundary of the generator 17/69 (dimension 6) :
+<TnPr <TnPr <TnPr g22 0> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 53s.
+Computing the boundary of the generator 18/69 (dimension 6) :
+<TnPr <TnPr <TnPr g23 0> <<Abar>>> <<Abar[3 <<Abar[2 1]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 53s.
+Computing the boundary of the generator 19/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[6 5]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 53s.
+Computing the boundary of the generator 20/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[2 1][4 3]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 53s.
+Computing the boundary of the generator 21/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[3 2][3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 53s.
+Computing the boundary of the generator 22/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[4 3][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 53s.
+Computing the boundary of the generator 23/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 0> <<Abar[2 1][2 1][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 53s.
+Computing the boundary of the generator 24/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar[5 4]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 53s.
+Computing the boundary of the generator 25/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar[2 1][3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 53s.
+Computing the boundary of the generator 26/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 1> <<Abar[3 2][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 54s.
+Computing the boundary of the generator 27/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 2> <<Abar[4 3]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 54s.
+Computing the boundary of the generator 28/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 2> <<Abar[2 1][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 54s.
+Computing the boundary of the generator 29/69 (dimension 6) :
+<TnPr <TnPr <TnPr g11 0> <<Abar[4 3]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 54s.
+Computing the boundary of the generator 30/69 (dimension 6) :
+<TnPr <TnPr <TnPr g11 0> <<Abar[2 1][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 54s.
+Computing the boundary of the generator 31/69 (dimension 6) :
+<TnPr <TnPr <TnPr g12 0> <<Abar[4 3]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 54s.
+Computing the boundary of the generator 32/69 (dimension 6) :
+<TnPr <TnPr <TnPr g12 0> <<Abar[2 1][2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 54s.
+Computing the boundary of the generator 33/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 3> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 54s.
+Computing the boundary of the generator 34/69 (dimension 6) :
+<TnPr <TnPr <TnPr g11 1> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 55s.
+Computing the boundary of the generator 35/69 (dimension 6) :
+<TnPr <TnPr <TnPr g12 1> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 55s.
+Computing the boundary of the generator 36/69 (dimension 6) :
+<TnPr <TnPr <TnPr g21 0> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 55s.
+Computing the boundary of the generator 37/69 (dimension 6) :
+<TnPr <TnPr <TnPr g22 0> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 55s.
+Computing the boundary of the generator 38/69 (dimension 6) :
+<TnPr <TnPr <TnPr g23 0> <<Abar[3 2]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 55s.
+Computing the boundary of the generator 39/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 4> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 55s.
+Computing the boundary of the generator 40/69 (dimension 6) :
+<TnPr <TnPr <TnPr g11 2> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 56s.
+Computing the boundary of the generator 41/69 (dimension 6) :
+<TnPr <TnPr <TnPr g12 2> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 57s.
+Computing the boundary of the generator 42/69 (dimension 6) :
+<TnPr <TnPr <TnPr g21 1> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 57s.
+Computing the boundary of the generator 43/69 (dimension 6) :
+<TnPr <TnPr <TnPr g22 1> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 58s.
+Computing the boundary of the generator 44/69 (dimension 6) :
+<TnPr <TnPr <TnPr g23 1> <<Abar[2 1]>>> <<Abar>>> 
+*CR* -- Cut = 0.02723752 -- N = 10538
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 58m 59s.
+Computing the boundary of the generator 45/69 (dimension 6) :
+<TnPr <TnPr <TnPr g31 0> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 59m 0s.
+Computing the boundary of the generator 46/69 (dimension 6) :
+<TnPr <TnPr <TnPr g32 0> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 59m 0s.
+Computing the boundary of the generator 47/69 (dimension 6) :
+<TnPr <TnPr <TnPr g33 0> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 59m 0s.
+Computing the boundary of the generator 48/69 (dimension 6) :
+<TnPr <TnPr <TnPr g34 0> <<Abar[2 1]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 59m 0s.
+Computing the boundary of the generator 49/69 (dimension 6) :
+<TnPr <TnPr <TnPr S-BSGN 6> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 59m 1s.
+Computing the boundary of the generator 50/69 (dimension 6) :
+<TnPr <TnPr <TnPr g11 4> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 59m 1s.
+Computing the boundary of the generator 51/69 (dimension 6) :
+<TnPr <TnPr <TnPr g12 4> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 59m 2s.
+Computing the boundary of the generator 52/69 (dimension 6) :
+<TnPr <TnPr <TnPr g21 3> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 59m 4s.
+Computing the boundary of the generator 53/69 (dimension 6) :
+<TnPr <TnPr <TnPr g22 3> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 59m 6s.
+Computing the boundary of the generator 54/69 (dimension 6) :
+<TnPr <TnPr <TnPr g23 3> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 59m 8s.
+Computing the boundary of the generator 55/69 (dimension 6) :
+<TnPr <TnPr <TnPr g31 2> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 59m 10s.
+Computing the boundary of the generator 56/69 (dimension 6) :
+<TnPr <TnPr <TnPr g32 2> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 59m 12s.
+Computing the boundary of the generator 57/69 (dimension 6) :
+<TnPr <TnPr <TnPr g33 2> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.02728105 -- N = 10552
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 59m 15s.
+Computing the boundary of the generator 58/69 (dimension 6) :
+<TnPr <TnPr <TnPr g34 2> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 59m 19s.
+Computing the boundary of the generator 59/69 (dimension 6) :
+<TnPr <TnPr <TnPr g41 1> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 59m 20s.
+Computing the boundary of the generator 60/69 (dimension 6) :
+<TnPr <TnPr <TnPr g42 1> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 59m 22s.
+Computing the boundary of the generator 61/69 (dimension 6) :
+<TnPr <TnPr <TnPr g43 1> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 59m 24s.
+Computing the boundary of the generator 62/69 (dimension 6) :
+<TnPr <TnPr <TnPr g44 1> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 59m 26s.
+Computing the boundary of the generator 63/69 (dimension 6) :
+<TnPr <TnPr <TnPr g45 1> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.027316269 -- N = 10565
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 59m 30s.
+Computing the boundary of the generator 64/69 (dimension 6) :
+<TnPr <TnPr <TnPr g51 0> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 59m 30s.
+Computing the boundary of the generator 65/69 (dimension 6) :
+<TnPr <TnPr <TnPr g52 0> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 59m 31s.
+Computing the boundary of the generator 66/69 (dimension 6) :
+<TnPr <TnPr <TnPr g53 0> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 59m 32s.
+Computing the boundary of the generator 67/69 (dimension 6) :
+<TnPr <TnPr <TnPr g54 0> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 59m 32s.
+Computing the boundary of the generator 68/69 (dimension 6) :
+<TnPr <TnPr <TnPr g55 0> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 9h 59m 33s.
+Computing the boundary of the generator 69/69 (dimension 6) :
+<TnPr <TnPr <TnPr g56 0> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+
+;; Clock -> 2011-07-14, 9h 59m 33s.
+
+
+*CR* -- Cut = 0.027431589 -- N = 10574
+*CR* -- Cut = 0.027409986 -- N = 10581
+*CR* -- Cut = 0.027447063 -- N = 10601
+*CR* -- Cut = 0.027479827 -- N = 10657
+*CR* -- Cut = 0.02755706 -- N = 10710
+*CR* -- Cut = 0.027726682 -- N = 10786
+*CR* -- Cut = 0.027987706 -- N = 10898
+*CR* -- Cut = 0.028594453 -- N = 11093
+*CR* -- Cut = 0.028853327 -- N = 11175
+*CR* -- Cut = 0.029098665 -- N = 11284
+*CR* -- Cut = 0.02917352 -- N = 11327
+*CR* -- Cut = 0.02930427 -- N = 11396
+*CR* -- Cut = 0.030319087 -- N = 11615
+*CR* -- Cut = 0.030405309 -- N = 11708
+*CR* -- Cut = 0.030384291 -- N = 11746
+*CR* -- Cut = 0.030515656 -- N = 11774
+*CR* -- Cut = 0.031394616 -- N = 8479
+*CR* -- Cut = 0.028224792 -- N = 8561
+*CR* -- Cut = 0.028261755 -- N = 8604
+*CR* -- Cut = 0.028326884 -- N = 8629
+*CR* -- Cut = 0.028889015 -- N = 8819
+*CR* -- Cut = 0.028893422 -- N = 8847
+*CR* -- Cut = 0.029014897 -- N = 8881
+*CR* -- Cut = 0.029757868 -- N = 9103
+*CR* -- Cut = 0.029971622 -- N = 9210
+*CR* -- Cut = 0.029928245 -- N = 9238
+*CR* -- Cut = 0.030070832 -- N = 9262
+*CR* -- Cut = 0.03054888 -- N = 9378
+*CR* -- Cut = 0.030755755 -- N = 9475
+*CR* -- Cut = 0.03078257 -- N = 9500
+*CR* -- Cut = 0.030935898 -- N = 9529
+*CR* -- Cut = 0.031507302 -- N = 9483
+*CR* -- Cut = 0.03135413 -- N = 9549
+*CR* -- Cut = 0.031555425 -- N = 9583
+*CR* -- Cut = 0.031551644 -- N = 9600
+*CR* -- Cut = 0.031776916 -- N = 9652
+*CR* -- Cut = 0.032632053 -- N = 8387
+*CR* -- Cut = 0.03133738 -- N = 8454
+*CR* -- Cut = 0.031436592 -- N = 8525
+*CR* -- Cut = 0.03143434 -- N = 8539
+*CR* -- Cut = 0.031562917 -- N = 8575
+*CR* -- Cut = 0.031557184 -- N = 8594
+*CR* -- Cut = 0.031637106 -- N = 8596
+*CR* -- Cut = 0.03194841 -- N = 8740
+*CR* -- Cut = 0.032019418 -- N = 8688
+*CR* -- Cut = 0.032713216 -- N = 8806
+*CR* -- Cut = 0.033036035 -- N = 8895
+*CR* -- Cut = 0.032949958 -- N = 8901
+*CR* -- Cut = 0.033048354 -- N = 8908
+*CR* -- Cut = 0.03341168 -- N = 8989
+*CR* -- Cut = 0.033435553 -- N = 9025
+*CR* -- Cut = 0.033545233 -- N = 9039
+*CR* -- Cut = 0.034353748 -- N = 9204
+*CR* -- Cut = 0.034458824 -- N = 9268
+*CR* -- Cut = 0.034690924 -- N = 9348
+*CR* -- Cut = 0.034693472 -- N = 9355
+*CR* -- Cut = 0.03482469 -- N = 9367
+*CR* -- Cut = 0.03489123 -- N = 9387
+*CR* -- Cut = 0.03490389 -- N = 9415
+*CR* -- Cut = 0.03562493 -- N = 9585
+*CR* -- Cut = 0.035654992 -- N = 9635
+*CR* -- Cut = 0.035713308 -- N = 9652
+*CR* -- Cut = 0.035746217 -- N = 9667
+*CR* -- Cut = 0.035940286 -- N = 9706
+*CR* -- Cut = 0.036304988 -- N = 9849
+*CR* -- Cut = 0.036636807 -- N = 9935
+*CR* -- Cut = 0.037287433 -- N = 10126
+Computing boundary-matrix in dimension 6.
+Rank of the source-module : 83.
+
+
+;; Clock -> 2011-07-14, 10h 18m 15s.
+Computing the boundary of the generator 1/83 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[6 <<Abar[5 <<Abar[4 3]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 10h 18m 15s.
+Computing the boundary of the generator 2/83 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[6 <<Abar[5 <<Abar[2 1][2 1]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 10h 18m 15s.
+Computing the boundary of the generator 3/83 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[5 <<Abar[4 <<Abar[3 2]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 10h 18m 15s.
+Computing the boundary of the generator 4/83 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> <<Abar[2 1]>>> <<Abar>>> <<Abar>>> <<Abar[4 <<Abar[3 <<Abar[2 1]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 10h 18m 15s.
+Computing the boundary of the generator 5/83 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 2> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[4 <<Abar[3 <<Abar[2 1]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 10h 18m 15s.
+Computing the boundary of the generator 6/83 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr <TnPr g11 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[4 <<Abar[3 <<Abar[2 1]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 10h 18m 15s.
+Computing the boundary of the generator 7/83 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr <TnPr g12 0> <<Abar>>> <<Abar>>> <<Abar>>> <<Abar[4 <<Abar[3 <<Abar[2 1]>>]>>]>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 10h 18m 15s.
+Computing the boundary of the generator 8/83 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar>>> <<Abar[6 <<Abar[5 <<Abar[4 3]>>]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 10h 18m 15s.
+Computing the boundary of the generator 9/83 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar>>> <<Abar[6 <<Abar[5 <<Abar[2 1][2 1]>>]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 10h 18m 15s.
+Computing the boundary of the generator 10/83 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> <<Abar>>> <<Abar>>> <<Abar[5 <<Abar[4 <<Abar[3 2]>>]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 10h 18m 16s.
+Computing the boundary of the generator 11/83 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> <<Abar[2 1]>>> <<Abar>>> <<Abar[4 <<Abar[3 <<Abar[2 1]>>]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 10h 18m 16s.
+Computing the boundary of the generator 12/83 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 2> <<Abar>>> <<Abar>>> <<Abar[4 <<Abar[3 <<Abar[2 1]>>]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 10h 18m 16s.
+Computing the boundary of the generator 13/83 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr <TnPr g11 0> <<Abar>>> <<Abar>>> <<Abar[4 <<Abar[3 <<Abar[2 1]>>]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 10h 18m 16s.
+Computing the boundary of the generator 14/83 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr <TnPr g12 0> <<Abar>>> <<Abar>>> <<Abar[4 <<Abar[3 <<Abar[2 1]>>]>>]>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 10h 18m 16s.
+Computing the boundary of the generator 15/83 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar[6 <<Abar[5 4]>>]>>> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.037479904 -- N = 10189
+*CR* -- Cut = 0.037520714 -- N = 10227
+*CR* -- Cut = 0.037702538 -- N = 10266
+*CR* -- Cut = 0.03763576 -- N = 10288
+End of computing.
+
+
+;; Clock -> 2011-07-14, 10h 18m 50s.
+Computing the boundary of the generator 16/83 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar[6 <<Abar[2 1][3 2]>>]>>> <<Abar>>> <<Abar>>> 
+*CR* -- Cut = 0.03776791 -- N = 10319
+End of computing.
+
+
+;; Clock -> 2011-07-14, 10h 19m 0s.
+Computing the boundary of the generator 17/83 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar[6 <<Abar[3 2][2 1]>>]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 10h 19m 4s.
+Computing the boundary of the generator 18/83 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 0> <<Abar>>> <<Abar[3 <<Abar[2 1]>>][3 <<Abar[2 1]>>]>>> <<Abar>>> <<Abar>>> 
+End of computing.
+
+
+;; Clock -> 2011-07-14, 10h 19m 4s.
+Computing the boundary of the generator 19/83 (dimension 6) :
+<TnPr <TnPr <TnPr <TnPr <TnPr S-BSGN 1> <<Abar>>> <<Abar[5 <<Abar[4 3]>>]>>> <<Abar>>> <<Abar>>> 
+Error: `#<Closure (:INTERNAL (FLET BAR-CMPR RSLT) 0) @ #x2d0c02c2>' is not of the expected type `NUMBER'
+[condition type: TYPE-ERROR]
+CL-USER(37): 
\ No newline at end of file