From 8f0d75b1057dc36ec4cac088edbf68c74731745e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ana=20Romero=20Ib=C3=A1=C3=B1ez?= <anromero@unirioja.loc>
Date: Mon, 16 Sep 2019 18:45:53 +0200
Subject: [PATCH 1/2] Functions for change a chain complex to a filtered chain
 complex modified Example of bicomplex added

---
 src/anromero/bicomplexes.lisp         |   58 +-
 src/anromero/filtered-complexes.lisp  | 1085 ++++++++++++-------------
 src/anromero/persistent-homology.lisp |    2 +-
 src/anromero/spectral-sequences.lisp  |   21 +-
 4 files changed, 585 insertions(+), 581 deletions(-)

diff --git a/src/anromero/bicomplexes.lisp b/src/anromero/bicomplexes.lisp
index 889afd5..ad7bf82 100644
--- a/src/anromero/bicomplexes.lisp
+++ b/src/anromero/bicomplexes.lisp
@@ -373,8 +373,64 @@
       (slot-makunbound chcm 'bsgn)
       chcm)))
 
+
+
 #|
-;; Example of bicomplex from a list of morphisms of two chain complexes
+;; EXAMPLE OF BICOMPLEX
+
+(cat-init)
+
+
+(defun bcbasis (degr1 degr2)
+     (if (and (= degr1 0) (= degr2 1)) (return-from bcbasis '(a1 a2)))
+     (if (and (= degr1 1) (= degr2 0)) (return-from bcbasis '(b)))
+     (if (and (= degr1 1) (= degr2 1)) (return-from bcbasis '(c1 c2)))
+     (if (and (= degr1 2) (= degr2 0))  (return-from bcbasis '(d1 d2)))
+     (return-from bcbasis nil))
+
+(defun dif1 (degr1 degr2 gnrt)
+     (if (and (= degr1 1) (= degr2 1) (eql gnrt 'c1)) (return-from dif1 (list (cons 2 'a1))))
+     (if (and (= degr1 1) (= degr2 1) (eql gnrt 'c2)) (return-from dif1 (list (cons 2 'a2))))
+     (if (and (= degr1 2) (= degr2 0) (eql gnrt 'd1)) (return-from dif1 (list (cons 2 'b))))
+     (return-from dif1 nil))
+
+(defun dif2 (degr1 degr2 gnrt)
+     (if (and (= degr1 1) (= degr2 1) (eql gnrt 'c1)) (return-from dif2 (list (cons 1 'b))))
+     (return-from dif2 nil))
+
+(setf bc (build-bicm :cmpr #'s-cmpr :bcbasis #'bcbasis :dffr1 #'dif1 :dffr2 #'dif2
+          :orgn '(Bicomplex1)))
+
+(basis bc 1)
+
+(change-bicm-to-flcc bc)
+
+
+(do ((r 1 (1+ r)))
+    ((> r 3))
+   (dotimes (n 3)
+      (dotimes (p (+ n 1))
+         (let ((q (- n p)))
+            (spsq-group bc r p q)
+            (terpri)
+            (terpri)
+            ))))
+
+(SPSQ-DFFR-OF-ONE-ELEMENT bc 1 1 1 '(1))
+
+(SPSQ-DFFR-OF-ONE-ELEMENT bc 2 2 0 '(1 0))
+
+(SPSQ-DFFR-OF-ONE-ELEMENT bc 2 2 0 '(0 1))
+
+(spsq-cnvg bc 4)
+
+|#
+
+
+
+
+#|
+;; EXAMPLE OF BICOMPLEX FROM A LIST OF MORPHISMS OF TWO CHAIN COMPLEXES
 
 ;; First we build the three chain complexes
 
diff --git a/src/anromero/filtered-complexes.lisp b/src/anromero/filtered-complexes.lisp
index d9a5e83..eaa8f14 100644
--- a/src/anromero/filtered-complexes.lisp
+++ b/src/anromero/filtered-complexes.lisp
@@ -9,11 +9,11 @@
 (DEFTYPE degr () 'fixnum)
 
 (DEFTYPE CHCM-FLIN () 'function) 
-                     ;; '(function (degr gnrt) degr)
+;; '(function (degr gnrt) degr)
 
 
 (DEFCLASS FILTERED-CHAIN-COMPLEX (chain-complex)
-    ((flin :type chcm-flin :initarg :flin :reader flin1)))
+  ((flin :type chcm-flin :initarg :flin :reader flin1)))
 
 (DEFVAR *flcc-list*)
 (SETF *flcc-list* +empty-list+)
@@ -22,278 +22,254 @@
 #+clisp(eval-when (:compile-toplevel :load-toplevel :execute)
          (setf (ext:package-lock :clos) nil))
 (DEFMETHOD PRINT-OBJECT ((flcm FILTERED-CHAIN-COMPLEX) stream)
-(the FILTERED-CHAIN-COMPLEX
-   (progn
+  (the FILTERED-CHAIN-COMPLEX
+    (progn
       (format stream "[K~D Filtered-Chain-Complex]" (idnm flcm))
-     flcm)))
+      flcm)))
 #+clisp(eval-when (:compile-toplevel :load-toplevel :execute)
          (setf (ext:package-lock :clos) t))
 
 
 
 (DEFUN FLCC (idnm)
-   (declare (type fixnum idnm))
-   (the (or FILTERED-CHAIN-COMPLEX null)
-      (find idnm *flcc-list* :key #'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))))
+  (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)
-      (type 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)
-      ;;(type list flin-orgn)
-)
-   (the FILTERED-CHAIN-COMPLEX
-      (progn
-         (change-class chcm 'FILTERED-CHAIN-COMPLEX)
-        (let* ((orgn (orgn chcm))
-               (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)
-         (push chcm *flcc-list*))
-         chcm)))
+(DEFMETHOD CHANGE-CHCM-TO-FLCC ((chcm chain-complex) flin)
+  (declare
+   (type chain-complex chcm)
+   (type chcm-flin flin))
+  (the FILTERED-CHAIN-COMPLEX
+    (progn
+      (change-class chcm 'FILTERED-CHAIN-COMPLEX)
+      (let* ((orgn (orgn chcm))
+             (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)
+        (push chcm *flcc-list*))
+      chcm)))
 
 
 (DEFMACRO FLIN (&rest rest)
-   (ecase (length rest)
-      (1 `(flin1 ,@rest))
-      (2 `(flin2 ,@rest))
-      (3 `(flin3 ,@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))))
+  (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
+  (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))))))))
-   
+             (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)
+  (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))))))
-           
- 
-   
+  (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)
+  (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 
+  (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))))
+                  (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)
+  (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
+  (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)))))
+        (<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)
+  (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))))  
+  (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)
+(DEFUN FLCC-DFFR-MTRX (fltrcm degr fltr-index)
   (declare
-    (type FILTERED-CHAIN-COMPLEX fltrcm)
-    (fixnum degr fltr-index))
-   (when (eq (basis fltrcm) :locally-effective)
+   (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))
+           (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))
-                          (if (eq :equal (funcall cmpr gnrt (car mark2)))
-                             (progn
-                              (setq found 1)
-                              (setf (aref rslt i j) cffc))))))))
-               rslt))))
+           (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))
+                  (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*
     "The variable *FLCLGB-LIST* is bound to a list of user created filtered coalgebras")
@@ -304,65 +280,63 @@
 #+clisp(eval-when (:compile-toplevel :load-toplevel :execute)
          (setf (ext:package-lock :clos) nil))
 (DEFMETHOD PRINT-OBJECT ((flclgb FILTERED-COALGEBRA) stream)
-(the FILTERED-COALGEBRA
-   (progn
+  (the FILTERED-COALGEBRA
+    (progn
       (format stream "[K~D FILTERED-COALGEBRA]" (idnm flclgb))
-     flclgb)))
+      flclgb)))
 #+clisp(eval-when (:compile-toplevel :load-toplevel :execute)
          (setf (ext:package-lock :clos) t))
 
 (DEFUN FltrClgb (idnm)
-   (declare (type fixnum idnm))
-   (the (or FILTERED-COALGEBRA null)
-      (find idnm *flclgb-list* :key #'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-cprd :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))))
+  (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-cprd :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)
-      ;;(type list flin-orgn)
-)
-   (the FILTERED-COALGEBRA
-      (progn
-         (change-class chcm 'FILTERED-COALGEBRA)
-        (let* ((orgn (orgn chcm))
-              (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)
-          (push chcm *flCLGB-list*)
-         chcm))))
+(DEFMETHOD CHANGE-CHCM-TO-FLCC ((chcm coalgebra) flin)
+  (declare      
+   (type chcm-flin flin))
+  (the FILTERED-COALGEBRA
+    (progn
+      (change-class chcm 'FILTERED-COALGEBRA)
+      (let* ((orgn (orgn chcm))
+             (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)
+        (push chcm *flCLGB-list*)
+        chcm))))
 
 
 (DEFCLASS FILTERED-ALGEBRA (filtered-chain-complex algebra)
-    ())
+  ())
 
 (DEFVAR *FLALGB-LIST*
     "The variable *FLALGB-LIST* is bound to a list of user created filtered algebras.")
@@ -373,67 +347,63 @@
 #+clisp(eval-when (:compile-toplevel :load-toplevel :execute)
          (setf (ext:package-lock :clos) nil))
 (DEFMETHOD PRINT-OBJECT ((flalgb FILTERED-ALGEBRA) stream)
-(the FILTERED-ALGEBRA
-   (progn
+  (the FILTERED-ALGEBRA
+    (progn
       (format stream "[K~D FILTERED-ALGEBRA]" (idnm flalgb))
-     flalgb)))
+      flalgb)))
 #+clisp(eval-when (:compile-toplevel :load-toplevel :execute)
          (setf (ext:package-lock :clos) t))
 
 (DEFUN FltrAlgb (idnm)
-   (declare (type fixnum idnm))
-   (the (or FILTERED-ALGEBRA null)
-      (find idnm *flalgb-list* :key #'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-aprd :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))))
+  (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-aprd :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) (list flin-orgn)))
-        (let* (
-              (orgn (orgn chcm))
-              (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)
-          (push chcm *flaLGB-list*)
-         chcm))))
+(DEFMETHOD CHANGE-CHCM-TO-FLCC ((chcm algebra) flin)
+  (declare      
+   (type chcm-flin flin))
+  (the FILTERED-ALGEBRA
+    (progn
+      (change-class chcm 'FILTERED-ALGEBRA)
+      (let* ((orgn (orgn chcm))
+             (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)
+        (push chcm *flaLGB-list*)
+        chcm))))
 
 
 (DEFCLASS FILTERED-HOPF-ALGEBRA (filtered-chain-complex hopf-algebra)
-    ())
+  ())
 
 (DEFVAR *FLHOPF-LIST*
     "The variable *FLHOPF-LIST* is bound to a list of user created filtered Hopf algebras.")
@@ -444,40 +414,36 @@
 #+clisp(eval-when (:compile-toplevel :load-toplevel :execute)
          (setf (ext:package-lock :clos) nil))
 (DEFMETHOD PRINT-OBJECT ((flhopf FILTERED-HOPF-ALGEBRA) stream)
-(the FILTERED-HOPF-ALGEBRA
-   (progn
+  (the FILTERED-HOPF-ALGEBRA
+    (progn
       (format stream "[K~D FILTERED-HOPF-ALGEBRA]" (idnm flhopf))
-     flhopf)))
+      flhopf)))
 #+clisp(eval-when (:compile-toplevel :load-toplevel :execute)
          (setf (ext:package-lock :clos) t))
 
 (DEFUN FltrHopf (idnm)
-   (declare (type fixnum idnm))
-   (the (or FILTERED-HOPF-ALGEBRA null)
-      (find idnm *flhopf-list* :key #'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-hopf-algebra
-      (progn
-         (change-class chcm 'FILTERED-hopf-ALGEBRA)
-        ;;(setf orgn (append (orgn chcm) (list 'FILTERED-WITH) (list flin-orgn)))
-        (let* (
-               (orgn (orgn chcm))
-               (already (find orgn *flhopf-list* :key #'orgn :test #'equal)))
-          (declare (type (or null FILTERED-HOPF-ALGEBRA) already))
-          (when already
-               (return-from change-chcm-to-flcc already))
-         (setf (slot-value chcm 'flin) flin)
-          (push chcm *flhopf-list*)
-         chcm))))
+(DEFMETHOD CHANGE-CHCM-TO-FLCC ((chcm hopf-algebra) flin)
+  (declare      
+   (type chcm-flin flin))
+  (the FILTERED-hopf-algebra
+    (progn
+      (change-class chcm 'FILTERED-hopf-ALGEBRA)
+      (let* ((orgn (orgn chcm))
+             (already (find orgn *flhopf-list* :key #'orgn :test #'equal)))
+        (declare (type (or null FILTERED-HOPF-ALGEBRA) already))
+        (when already
+          (return-from change-chcm-to-flcc already))
+        (setf (slot-value chcm 'flin) flin)
+        (push chcm *flhopf-list*)
+        chcm))))
 
 
 (DEFCLASS FILTERED-SIMPLICIAL-SET (FILTERED-CHAIN-COMPLEX simplicial-set )
-    ())
+  ())
 
 (DEFVAR *FLSMST-LIST*
     "The variable *FLSMST-LIST* is bound to a list of user created filtered simplicial sets")
@@ -488,71 +454,67 @@
 #+clisp(eval-when (:compile-toplevel :load-toplevel :execute)
          (setf (ext:package-lock :clos) nil))
 (DEFMETHOD PRINT-OBJECT ((flsmst filtered-simplicial-set) stream)
- (the filtered-simplicial-set
-   (progn
+  (the filtered-simplicial-set
+    (progn
       (format stream "[K~D Filtered-Simplicial-Set]" (idnm flsmst))
-     flsmst)))
+      flsmst)))
 #+clisp(eval-when (:compile-toplevel :load-toplevel :execute)
          (setf (ext:package-lock :clos) t))
 
 (DEFUN FltrSmSet (idnm)
-   (declare (type fixnum idnm))
-   (the (or filtered-simplicial-set null)
-      (find idnm *flsmst-list* :key #'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-strt :orgn orgn)))
-            (declare (type simplicial-set rslt))
-            (change-class rslt 'FILTERED-SIMPLICIAL-SET)
-            (setf (slot-value rslt 'flin) flin)
-            (push rslt *flsmst-list*)
-               rslt))))
+  (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-strt :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) (list flin-orgn)))
-        (let* (
-               (orgn (orgn chcm))
-               (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)
-         (push chcm *flsmst-list*)
-         chcm))))
+(DEFMETHOD CHANGE-CHCM-TO-FLCC ((chcm simplicial-set) flin)
+  (declare      
+   (type chcm-flin flin))
+  (the FILTERED-SIMPLICIAL-SET
+    (progn
+      (change-class chcm 'FILTERED-SIMPLICIAL-SET)
+      (let* ((orgn (orgn chcm))
+             (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)
+        (push chcm *flsmst-list*)
+        chcm))))
 
 
 (DEFCLASS FILTERED-KAN (FILTERED-CHAIN-COMPLEX KAN )
-    ())
+  ())
 
 (DEFVAR *FLKAN-LIST*
     "The variable *FLKAN-LIST* is bound to a list of user created filtered Kan complexes")
@@ -563,47 +525,43 @@
 #+clisp(eval-when (:compile-toplevel :load-toplevel :execute)
          (setf (ext:package-lock :clos) nil))
 (DEFMETHOD PRINT-OBJECT ((flkan filtered-kan) stream)
- (the filtered-kan
-   (progn
+  (the filtered-kan
+    (progn
       (format stream "[K~D Filtered-Kan-Simplicial-Set]" (idnm flkan))
-     flkan)))
+      flkan)))
 #+clisp(eval-when (:compile-toplevel :load-toplevel :execute)
          (setf (ext:package-lock :clos) t))
 
 (DEFUN FltrKan (idnm)
-   (declare (type fixnum idnm))
-   (the (or filtered-kan null)
-      (find idnm *flkan-list* :key #'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) (list flin-orgn)))
-        (let* (
-               (orgn (orgn chcm))
-               (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)
-         (push chcm *flkan-list*)
-         chcm))))
+(DEFMETHOD CHANGE-CHCM-TO-FLCC ((chcm kan) flin)
+  (declare      
+   (type chcm-flin flin))
+  (the FILTERED-KAN
+    (progn
+      (change-class chcm 'FILTERED-KAN)
+      (let* ((orgn (orgn chcm))
+             (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)
+        (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*
     "The variable *FLSMGR-LIST* is bound to a list of user created filtered simplicial groups")
-    
+
 (SETF *FLSMGR-LIST* +empty-list+)
 (PUSHNEW '*FLSMGR-LIST* *list-list*)
 
@@ -616,99 +574,90 @@
 #+clisp(eval-when (:compile-toplevel :load-toplevel :execute)
          (setf (ext:package-lock :clos) nil))
 (DEFMETHOD PRINT-OBJECT ((flsmgr filtered-simplicial-group) stream)
- (the filtered-simplicial-group
-   (progn
+  (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
+  (the filtered-simplicial-group
+    (progn
       (format stream "[K~D Filtered-Abelian-Simplicial-Group]" (idnm flsmgr))
-     flsmgr)))
+      flsmgr)))
 #+clisp(eval-when (:compile-toplevel :load-toplevel :execute)
          (setf (ext:package-lock :clos) t))
 
 (DEFUN FltrSmgr (idnm)
-   (declare (type fixnum idnm))
-   (the (or filtered-simplicial-group null)
-      (find idnm *flsmgr-list* :key #'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-strt :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))))
+          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-strt :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* (
-               (orgn (orgn chcm))
-               (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)
-         (push chcm *flsmgr-list*)
-         chcm))))
+(defmethod CHANGE-CHCM-TO-FLCC ((chcm simplicial-group) flin)
+  (declare   
+   (type chcm-flin flin))
+  (the FILTERED-SIMPLICIAL-GROUP
+    (progn
+      (change-class chcm 'FILTERED-SIMPLICIAL-GROUP)
+      (let* ((orgn (orgn chcm))
+             (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)
+        (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* (
-               (orgn (orgn chcm))
-               (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)
+(DEFMETHOD CHANGE-CHCM-TO-FLCC ((chcm ab-simplicial-group) flin)
+  (declare
+     (type chcm-flin flin))
+  (the FILTERED-AB-SIMPLICIAL-GROUP
+    (progn
+      (change-class chcm 'AB-FILTERED-SIMPLICIAL-GROUP)
+      (let* (
+             (orgn (orgn chcm))
+             (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)
         (push chcm *flabsmgr-list*)
-         chcm))))
+        chcm))))
+
 
-        
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;    EXAMPLES    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 
@@ -718,16 +667,16 @@
 
 ;; 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))))
+  #'(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))
@@ -737,32 +686,32 @@
 ;; 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* ((flin BCflin))
-      (declare       
-       (type chcm-flin flin))
-      (the FILTERED-CHAIN-COMPLEX
-        (change-chcm-to-flcc bc flin 'Bicomplex-Flin))))
+  (declare 
+   (type bicomplex bc))
+  (let* ((flin BCflin))
+    (declare       
+     (type chcm-flin flin))
+    (the FILTERED-CHAIN-COMPLEX
+      (change-chcm-to-flcc bc 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))
- 
+  (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))
+  (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))
+  (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)))
+                     :orgn '(BC-test)))
 
 (change-bicm-to-flcc bc)
 (flin bc 1 (build-bcgnrt 0 1 'a))
@@ -780,40 +729,40 @@
 ;; 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)))))
+  (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)))))
 
 (DEFVAR abar-flin)
 (setf abar-flin 
-      #'(lambda (degr abar)
-       (declare (type fixnum degr)
-         (type abar abar))
-       (let* ((abar-bidgr (abar-bidegree abar))
-              (degr1 (first abar-bidgr))
+  #'(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
+        (if (=  degr (+ degr1 degr2))
+            degr1
           0))))
 
 #|
 (setq kz2 (k-z2-1))
 (setq bar2 (bar kz2))
 
-(change-chcm-to-flcc bar2 abar-flin 'abar-flin)
+(change-chcm-to-flcc bar2 abar-flin)
 
 
 (setf basis7 (basis bar2 7))
 
 (mapcar
- #'(lambda (gnrt)
-     (flin bar2 7 gnrt))
- basis7)
+    #'(lambda (gnrt)
+        (flin bar2 7 gnrt))
+  basis7)
 
 (flin bar2 (cmbn 7 (first basis7) (second basis7))) 
 
@@ -828,18 +777,18 @@
 ;; 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)))))
+  (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)))))
 
 (DEFVAR cobar-flin)
 (setf cobar-flin 
- #'(lambda (degr allp)
+  #'(lambda (degr allp)
       (declare (ignore degr)
                (type allp allp))
       (with-allp (l) allp
@@ -852,28 +801,28 @@
 
 (DEFVAR tnpr-flin)
 (setf tnpr-flin 
-      #'(lambda (degr tnpr)
-          (declare 
-            (ignore degr)
-            (type tnpr tnpr))
-       (the fixnum
-         (degr1 tnpr))))
+  #'(lambda (degr tnpr)
+      (declare 
+       (ignore degr)
+       (type tnpr tnpr))
+      (the fixnum
+        (degr1 tnpr))))
 
 ;; FIBRATIONS (CARTESIAN PRODUCTS AND TWISTED PRODUCTS)
 
 (DEFVAR crpr-flin)
 (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)))))))
+  #'(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))
@@ -884,17 +833,17 @@
 
 ;; 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))
+(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))) 
+    (the chcm-flin #'rslt))) 
diff --git a/src/anromero/persistent-homology.lisp b/src/anromero/persistent-homology.lisp
index 7296199..ad4f40b 100644
--- a/src/anromero/persistent-homology.lisp
+++ b/src/anromero/persistent-homology.lisp
@@ -479,7 +479,7 @@
             rslt)))
 
 
-(setf triangle (change-chcm-to-flcc triangle triangle-flin 'triangle-flin))
+(setf triangle (change-chcm-to-flcc triangle triangle-flin))
 
 
 (dotimes (p 8)
diff --git a/src/anromero/spectral-sequences.lisp b/src/anromero/spectral-sequences.lisp
index 219bb65..f7ba8ec 100644
--- a/src/anromero/spectral-sequences.lisp
+++ b/src/anromero/spectral-sequences.lisp
@@ -396,7 +396,7 @@
 (cat-init)
 (setq kz2 (k-z2-1))
 (setq fcc (bar kz2))
-(Change-Chcm-TO-Flcc fcc abar-flin `(abar-flin))
+(Change-Chcm-TO-Flcc fcc abar-flin)
 (fltr-chcm-z-mtrx fcc 2 3 2)
 (fltr-chcm-z-mtrx fcc 1 2 4)
 |#
@@ -1141,11 +1141,11 @@
 (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))
+(change-chcm-to-flcc ek3 abar-flin)
 (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))
+(change-chcm-to-flcc k3 k3-flin)
 (hmtp-eq-fltr-order hmtp-eq3 3)
 (hmtp-eq-fltr-order hmtp-eq3 5)
 |#
@@ -1162,7 +1162,7 @@
     (Change-Chcm-TO-Flcc eff-chcm 
                          #'(lambda (degr gnrt)
                              (flin fltrcm (lf hmtp-eq (rg hmtp-eq degr gnrt))))
-                         (orgn eff-chcm))))
+                         )))
 
 
 
@@ -1235,8 +1235,7 @@
          (eff-chcm (rbcc hmtp-eq)))
     (declare
      (type homotopy-equivalence hmtp-eq)
-     (type chain-complex eff-chcm)
-     )
+     (type chain-complex eff-chcm))
     (progn
       (if (not (typep eff-chcm 'filtered-chain-complex))
           (translate-filtration hmtp-eq))
@@ -1617,8 +1616,8 @@
     (declare (type simplicial-set fltrcm)
              (type chain-complex ecc))
     (progn
-      (change-chcm-to-flcc fltrcm crpr-flin 'crpr-flin)
-      (change-chcm-to-flcc ecc tnpr-flin 'tnpr-flin)
+      (change-chcm-to-flcc fltrcm crpr-flin)
+      (change-chcm-to-flcc ecc tnpr-flin)
       (the spectral-sequence
         (build-ss fltrcm `(Serre-Spectral-Sequence ,f))))))
 
@@ -1629,8 +1628,8 @@
   (let ((ecc (rbcc (efhm x))))
     (declare (type chain-complex ecc))
     (progn
-      (change-chcm-to-flcc x crpr-flin 'crpr-flin)
-      (change-chcm-to-flcc ecc tnpr-flin 'tnpr-flin)
+      (change-chcm-to-flcc x crpr-flin)
+      (change-chcm-to-flcc ecc tnpr-flin)
       (the spectral-sequence
         (build-ss x   `(Serre-Spectral-Sequence ,x))))))
 
@@ -1661,7 +1660,7 @@
      (type simplicial-set ox)
      (type chain-complex ecc))
     (progn
-      (change-chcm-to-flcc ecc cobar-flin 'cobar-flin)
+      (change-chcm-to-flcc ecc cobar-flin)
       (the spectral-sequence
         (build-ss ecc `(Eilenberg-Moore-Spectral-Sequence ,x))))))
 

From c8e2bb4c038a839aec8eab407428bb0ee9bcbda1 Mon Sep 17 00:00:00 2001
From: Miguel Marco <mmarco@unizar.es>
Date: Wed, 18 Sep 2019 17:27:30 +0200
Subject: [PATCH 2/2] Remove src/kenzo.fas file from git repo

---
 src/kenzo.fas | Bin 63208 -> 0 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 delete mode 100755 src/kenzo.fas

diff --git a/src/kenzo.fas b/src/kenzo.fas
deleted file mode 100755
index 749c853c1d80f2d4698967789f963800174a56e9..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 63208
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
W%d>JIVioT@>Gb6vxQZ#rn*Rfs?Ff<p