From b9a6785c15bae7343ab726ad3e0b15203331cd36 Mon Sep 17 00:00:00 2001 From: gheber Date: Sat, 13 Jun 2015 19:23:15 -0500 Subject: [PATCH] Update cat-init and add SBCL compilation HowTo --- doc/How-to-Compile-Kenzo-with-SBCL.txt | 4652 ++++++++++++++++++++++++ kenzo.asd | 4 +- src/cat-init.lisp | 21 +- kenzo.lisp => src/kenzo.lisp | 0 4 files changed, 4668 insertions(+), 9 deletions(-) create mode 100644 doc/How-to-Compile-Kenzo-with-SBCL.txt rename kenzo.lisp => src/kenzo.lisp (100%) diff --git a/doc/How-to-Compile-Kenzo-with-SBCL.txt b/doc/How-to-Compile-Kenzo-with-SBCL.txt new file mode 100644 index 0000000..49ae60a --- /dev/null +++ b/doc/How-to-Compile-Kenzo-with-SBCL.txt @@ -0,0 +1,4652 @@ +C:\home\quicklisp\local-projects\kenzo\src>sbcl +This is SBCL 1.2.12, an implementation of ANSI Common Lisp. +More information about SBCL is available at . + +SBCL is free software, provided as is, with absolutely no warranty. +It is mostly in the public domain; some portions are provided under +BSD-style licenses. See the CREDITS and COPYING files in the +distribution for more information. + +WARNING: the Windows port is fragile, particularly for multithreaded +code. Unfortunately, the development team currently lacks the time +and resources this platform demands. +* (load "cat-init") + + FILE 1: kenzo + FILE 2: macros + FILE 3: various + FILE 4: classes + FILE 5: combinations + FILE 6: chain-complexes + FILE 7: chcm-elementary-op + FILE 8: effective-homology + FILE 9: homology-groups + FILE 10: searching-homology + FILE 11: cones + FILE 12: bicones + FILE 13: tensor-products + FILE 14: coalgebras + FILE 15: cobar + FILE 16: algebras + FILE 17: bar + FILE 18: simplicial-sets + FILE 19: simplicial-mrphs + FILE 20: delta + FILE 21: special-smsts + FILE 22: suspensions + FILE 23: disk-pasting + FILE 24: cartesian-products + FILE 25: eilenberg-zilber + FILE 26: kan + FILE 27: simplicial-groups + FILE 28: fibrations + FILE 29: loop-spaces + FILE 30: ls-twisted-products + FILE 31: lp-space-efhm + FILE 32: classifying-spaces + FILE 33: k-pi-n + FILE 34: serre + FILE 35: cs-twisted-products + FILE 36: cl-space-efhm + FILE 37: whitehead + FILE 38: smith +T +* (compile-files) + +*CMBN-CONTROL* = T + +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/kenzo.lisp" (writte +n 01 JAN 2015 05:29:34 PM): +; compiling (IN-PACKAGE #:CAT) +; compiling (DEFUN KENZO-VERSION ...) +; compiling (DECLAIM (OPTIMIZE # ...)) +; compiling (DEFMACRO DEFINE-CONSTANT ...) +; compiling (DEFVAR *CMBN-CONTROL*) +; compiling (SETF *CMBN-CONTROL* ...) +; compiling (DEFINE-CONSTANT +EMPTY-LIST+ ...) +; compiling (DEFINE-CONSTANT +F-EMPTY-VECTOR+ ...) +; compiling (DEFINE-CONSTANT +S-EMPTY-VECTOR+ ...) +; compiling (DEFINE-CONSTANT +TRUE+ ...) +; compiling (DEFINE-CONSTANT +FALSE+ ...) +; compiling (DEFINE-CONSTANT +2-EXP+ ...) +; compiling (DEFINE-CONSTANT +MASK+ ...) +; compiling (DEFVAR *LIST-LIST* ...) +; compiling (DEFVAR *CHCM-LIST*) +; compiling (SETF *CHCM-LIST* ...) +; compiling (PUSHNEW (QUOTE *CHCM-LIST*) ...) +; compiling (DEFPARAMETER +MAXIMAL-DIMENSION+ ...) +; compiling (DEFVAR *MRPH-LIST*) +; compiling (SETF *MRPH-LIST* ...) +; compiling (PUSHNEW (QUOTE *MRPH-LIST*) ...) +; compiling (DEFVAR *START-STACK* ...) +; compiling (DEFPARAMETER +TOO-MUCH-TIME+ ...) +; compiling (DEFVAR *RESULTS-MAX* ...) +; compiling (DEFVAR *RESULTS-COEF* ...) +; compiling (DEFVAR *RESULTS-CMLT-TM* ...) +; compiling (DEFVAR *RESULTS-N* ...) +; compiling (DEFVAR *RESULTS-VERBOSE* ...) +; compiling (DEFVAR *FUTURE-DISPLAY* ...) +; compiling (DEFVAR *TIME-INTERVAL* ...) +; compiling (DEFVAR *RDCT-LIST*) +; compiling (SETF *RDCT-LIST* ...) +; compiling (PUSHNEW (QUOTE *RDCT-LIST*) ...) +; compiling (DEFVAR *HMEQ-LIST*) +; compiling (SETF *HMEQ-LIST* ...) +; compiling (PUSHNEW (QUOTE *HMEQ-LIST*) ...) +; compiling (DEFVAR *TDD*) +; compiling (DEFVAR *BDD*) +; compiling (DEFVAR *ID-FG*) +; compiling (DEFVAR *ID-GF-DH-HD*) +; compiling (DEFVAR *HH*) +; compiling (DEFVAR *FH*) +; compiling (DEFVAR *HG*) +; compiling (DEFVAR *DF-FD*) +; compiling (DEFVAR *DG-GD*) +; compiling (DEFVAR *TC*) +; compiling (DEFVAR *BC*) +; compiling (DEFVAR *HOMOLOGY-VERBOSE* ...) +; compiling (DEFVAR *TNPR-WITH-DEGREES* ...) +; compiling (DEFVAR *CLGB-LIST*) +; compiling (SETF *CLGB-LIST* ...) +; compiling (PUSHNEW (QUOTE *CLGB-LIST*) ...) +; compiling (DEFVAR *ALGB-LIST*) +; compiling (SETF *ALGB-LIST* ...) +; compiling (PUSHNEW (QUOTE *ALGB-LIST*) ...) +; compiling (DEFVAR *HOPF-LIST*) +; compiling (SETF *HOPF-LIST* ...) +; compiling (PUSHNEW (QUOTE *HOPF-LIST*) ...) +; compiling (DEFVAR *SMST-LIST*) +; compiling (SETF *SMST-LIST* ...) +; compiling (PUSHNEW (QUOTE *SMST-LIST*) ...) +; compiling (DEFVAR *SMMR-LIST*) +; compiling (SETF *SMMR-LIST* ...) +; compiling (PUSHNEW (QUOTE *SMMR-LIST*) ...) +; compiling (DEFVAR *KAN-LIST*) +; compiling (SETF *KAN-LIST* ...) +; compiling (PUSHNEW (QUOTE *KAN-LIST*) ...) +; compiling (DEFVAR *SMGR-LIST*) +; compiling (SETF *SMGR-LIST* ...) +; compiling (PUSHNEW (QUOTE *SMGR-LIST*) ...) + +; C:/home/quicklisp/local-projects/kenzo/src/kenzo.fasl written +; compilation finished in 0:00:00.129 +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/macros.lisp" (writt +en 02 JAN 2015 07:44:04 AM): +; compiling (IN-PACKAGE #:CAT) +; compiling (PROVIDE "macros") +; compiling (DEFMACRO -1-EXPT-N ...) +; compiling (DEFMACRO -1-EXPT-N+1 ...) +; compiling (DEFMACRO -1-EXPT-N-1 ...) +; compiling (DEFMACRO 2-EXP ...) +; compiling (DEFMACRO MASK ...) +; compiling (DEFMACRO BINOMIAL-P-Q ...) +; compiling (DEFMACRO LEXICO ...) +; compiling (DEFMACRO TERM ...) +; compiling (DEFMACRO -TERM ...) +; compiling (DEFMACRO CFFC ...) +; compiling (DEFMACRO -CFFC ...) +; compiling (DEFMACRO GNRT ...) +; compiling (DEFMACRO -GNRT ...) +; compiling (DEFMACRO WITH-TERM ...) +; compiling (DEFMACRO WITH--TERM ...) +; compiling (DEFMACRO WITH-CMBN ...) +; compiling (DEFMACRO TERM-CMBN ...) +; compiling (DEFMACRO CMBN-NON-ZERO-P ...) +; compiling (DEFMACRO CMBN-ZERO-P ...) +; compiling (DEFMACRO CONTROL ...) +; compiling (DEFMACRO CONTROLN ...) +; compiling (DEFVAR *WRONG-CMBN*) +; compiling (DEFMACRO CMPR ...) +; compiling (DEFMACRO CMPR3 ...) +; compiling (DEFMACRO BASIS ...) +; compiling (DEFMACRO BASIS3 ...) +; compiling (DEFMACRO DFFR ...) +; compiling (DEFMACRO ? ...) +; compiling (DEFMACRO I-CMPS ...) +; compiling (DEFMACRO I-ADD ...) +; compiling (DEFMACRO I-SBTR ...) +; compiling (DEFMACRO BCC ...) +; compiling (DEFMACRO TCC ...) +; compiling (DEFMACRO F ...) +; compiling (DEFMACRO G ...) +; compiling (DEFMACRO H ...) +; compiling (DEFMACRO LBCC ...) +; compiling (DEFMACRO RBCC ...) +; compiling (DEFMACRO LF ...) +; compiling (DEFMACRO LG ...) +; compiling (DEFMACRO LH ...) +; compiling (DEFMACRO RF ...) +; compiling (DEFMACRO RG ...) +; compiling (DEFMACRO RH ...) +; compiling (DEFMACRO BASELIG ...) +; compiling (DEFMACRO BASECOL ...) +; compiling (DEFMACRO CON0 ...) +; compiling (DEFMACRO CON1 ...) +; compiling (DEFMACRO WITH-CONE ...) +; compiling (DEFMACRO BCNB ...) +; compiling (DEFMACRO BCNC ...) +; compiling (DEFMACRO BCND ...) +; compiling (DEFMACRO WITH-BICN ...) +; compiling (DEFMACRO TNPR ...) +; compiling (DEFMACRO WITH-TNPR ...) +; compiling (DEFMACRO CPRD ...) +; compiling (DEFMACRO CBGN ...) +; compiling (DEFMACRO CDEGR ...) +; compiling (DEFMACRO CGNRT ...) +; compiling (DEFMACRO -CDEGR ...) +; compiling (DEFMACRO -CGNRT ...) +; compiling (DEFMACRO WITH-CBGN ...) +; compiling (DEFMACRO WITH--CBGN ...) +; compiling (DEFMACRO WITH-ALLP ...) +; compiling (DEFMACRO GNRT-ALLP-TNPR ...) +; compiling (DEFMACRO APRD ...) +; compiling (DEFMACRO BRGN ...) +; compiling (DEFMACRO BDEGR ...) +; compiling (DEFMACRO BGNRT ...) +; compiling (DEFMACRO -BDEGR ...) +; compiling (DEFMACRO -BGNRT ...) +; compiling (DEFMACRO WITH-BRGN ...) +; compiling (DEFMACRO WITH--BRGN ...) +; compiling (DEFMACRO WITH-ABAR ...) +; compiling (DEFMACRO WITH-GBAR ...) +; compiling (DEFMACRO ABSM ...) +; compiling (DEFMACRO WITH-ABSM ...) +; compiling (DEFMACRO DEGENERATE-P ...) +; compiling (DEFMACRO NON-DEGENERATE-P ...) +; compiling (DEFMACRO BSPN ...) +; compiling (DEFMACRO BNDR ...) +; compiling (DEFMACRO DGNL ...) +; compiling (DEFMACRO FACE ...) +; compiling (DEFMACRO D ...) +; compiling (DEFMACRO MAKE-GMSM-FACES-INFO ...) +; compiling (DEFMACRO INFO-GMSM ...) +; compiling (DEFMACRO INFO-FACES ...) +; compiling (DEFMACRO INFO-FACE-I ...) +; compiling (DEFMACRO INFO-BNDR ...) +; compiling (DEFMACRO CRPR ...) +; compiling (DEFMACRO CRPR2 ...) +; compiling (DEFMACRO CRPR4 ...) +; compiling (DEFMACRO ABSM1 ...) +; compiling (DEFMACRO ABSM2 ...) +; compiling (DEFMACRO WITH-CRPR ...) +; compiling (DEFMACRO WITH-CRPR-2 ...) +; compiling (DEFMACRO WITH-CRPR-4 ...) +; compiling (DEFMACRO EILENBERG-ZILBER ...) +; compiling (DEFMACRO KFLL ...) +; compiling (DEFMACRO KFLL4 ...) +; compiling (DEFMACRO GRML ...) +; compiling (DEFMACRO GRIN ...) +; compiling (DEFMACRO BUILD-AB-SMGR ...) +; compiling (DEFMACRO POWR ...) +; compiling (DEFMACRO PGMSM ...) +; compiling (DEFMACRO EXPN ...) +; compiling (DEFMACRO WITH-POWR ...) +; compiling (DEFMACRO WITH-APOWR ...) +; compiling (DEFMACRO APOWR ...) +; compiling (DEFMACRO APDGOP ...) +; compiling (DEFMACRO APGMSM ...) +; compiling (DEFMACRO APEXPN ...) +; compiling (DEFMACRO LINE-NUMBER ...) +; compiling (DEFMACRO COLUMN-NUMBER ...) +; compiling (DEFMACRO LINE-OP-5 ...) +; compiling (DEFMACRO COLUMN-OP-5 ...) +; compiling (DEFMACRO LINE-SWAP-5 ...) +; compiling (DEFMACRO COLUMN-SWAP-5 ...) +; compiling (DEFMACRO LINE-MINUS-5 ...) +; compiling (DEFMACRO COLUMN-MINUS-5 ...) +; compiling (DEFMACRO GNRT-NAME ...) + +; C:/home/quicklisp/local-projects/kenzo/src/macros.fasl written +; compilation finished in 0:00:00.548 +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/various.lisp" (writ +ten 02 JAN 2015 07:42:24 AM): +; compiling (IN-PACKAGE #:CAT) +; compiling (PROVIDE "various") +; compiling (DEFUN BINOMIAL-N-P ...) +; compiling (SETF *PRINT-LEVEL* ...) +; compiling (DEFUN ...) +; compiling (DEFUN >A-B< ...) +; compiling (DEFUN >A-B> ...) +; compiling (DEFUN V ...) +; compiling (DEFUN SRANDOM ...) +; compiling (DEFUN CLOCK ...) +; compiling (DEFUN DONE ...) + +; C:/home/quicklisp/local-projects/kenzo/src/various.fasl written +; compilation finished in 0:00:00.036 +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/classes.lisp" (writ +ten 02 JAN 2015 07:32:42 AM): +; compiling (IN-PACKAGE #:CAT) +; compiling (PROVIDE "classes") +; compiling (DEFTYPE ANY ...) +; compiling (DEFSTRUCT (CMBN #) ...) +; compiling (DEFUN CFFC-P ...) +; compiling (DEFTYPE CFFC ...) +; compiling (DEFTYPE GNRT ...) +; compiling (DEFTYPE CMPR ...) +; compiling (DEFTYPE CMPRF ...) +; compiling (DEFUN TERM-P ...) +; compiling (DEFTYPE TERM ...) +; compiling (DEFUN ICMBN-P ...) +; compiling (DEFTYPE ICMBN ...) +; compiling (DEFTYPE BASIS ...) +; compiling (DEFTYPE INTR-MRPH ...) +; compiling (DEFCLASS CHAIN-COMPLEX ...) +; compiling (DEFCLASS MORPHISM ...) +; compiling (DEFCLASS HOMOTOPY-EQUIVALENCE ...) +; compiling (DEFVAR *IDNM-COUNTER*) +; compiling (SETF *IDNM-COUNTER* ...) +; compiling (DEFCLASS CHAIN-COMPLEX ...) +; compiling (DEFTYPE STRT ...) +; compiling (DEFCLASS MORPHISM ...) +; compiling (DEFSTRUCT (RESULT #) ...) +; compiling (DEFCLASS REDUCTION ...) +; compiling (DEFCLASS HOMOTOPY-EQUIVALENCE ...) +; compiling (DEFSTRUCT (MATRICE #) ...) +; compiling (DEFSTRUCT (T-MAT #) ...) +; compiling (DEFSTRUCT (CONE # ...) ...) +; compiling (DEFSTRUCT (BICN # ...) ...) +; compiling (DEFSTRUCT (TNPR # ...) ...) +; compiling (DEFCLASS COALGEBRA ...) +; compiling (DEFUN CBGN-P ...) +; compiling (DEFTYPE CBGN ...) +; compiling (DEFUN IALLP-P ...) +; compiling (DEFTYPE IALLP ...) +; compiling (DEFSTRUCT (ALLP #) ...) +; compiling (DEFCLASS ALGEBRA ...) +; compiling (DEFCLASS HOPF-ALGEBRA ...) +; compiling (DEFUN BRGN-P ...) +; compiling (DEFTYPE BRGN ...) +; compiling (DEFUN IABAR-P ...) +; compiling (DEFTYPE IABAR ...) +; compiling (DEFSTRUCT (ABAR #) ...) +; compiling (DEFTYPE DGOP ...) +; compiling (DEFTYPE GMSM ...) +; compiling (DEFTYPE DLOP ...) +; compiling (DEFSTRUCT (ABSM # ...) ...) +; compiling (DEFTYPE FACE ...) +; compiling (DEFTYPE FACE* ...) +; compiling (DEFCLASS SIMPLICIAL-SET ...) +; compiling (DEFTYPE SINTR ...) +; compiling (DEFCLASS SIMPLICIAL-MRPH ...) +; compiling (DEFUN SOFT-DLOP-P ...) +; compiling (DEFTYPE SOFT-DLOP ...) +; compiling (DEFSTRUCT (CRPR # ...) ...) +; compiling (DEFTYPE KFLL ...) +; compiling (DEFCLASS KAN ...) +; compiling (DEFUN FIBRATION-P ...) +; compiling (DEFTYPE FIBRATION ...) +; compiling (DEFCLASS SIMPLICIAL-GROUP ...) +; compiling (DEFCLASS AB-SIMPLICIAL-GROUP ...) +; compiling (DEFUN EXPN-P ...) +; compiling (DEFTYPE EXPN ...) +; compiling (DEFUN POWR-P ...) +; compiling (DEFTYPE POWR ...) +; compiling (DEFUN APOWR-P ...) +; compiling (DEFTYPE APOWR ...) +; compiling (DEFUN ILOOP-P ...) +; compiling (DEFTYPE ILOOP ...) +; compiling (SB-EXT:UNLOCK-PACKAGE :COMMON-LISP) +; compiling (DEFSTRUCT (LOOP #) ...) +; compiling (SB-EXT:LOCK-PACKAGE :COMMON-LISP) +; compiling (DEFSTRUCT (GBAR #) ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/classes.lisp +; in: DEFSTRUCT ABAR +; (DEFSTRUCT (CAT::ABAR (:PRINT-FUNCTION CAT::ABAR-PRINT)) (LIST)) +; --> PROGN DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER PROGN +; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* LET* +; --> SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET +; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS +; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* +; --> LOCALLY SYMBOL-MACROLET BLOCK FUNCALL +; ==> +; (SB-C::%FUNCALL #'CAT::ABAR-PRINT #:OBJECT938 #:STREAM939 +; SB-KERNEL:*CURRENT-LEVEL-IN-PRINT*) +; +; caught STYLE-WARNING: +; undefined function: ABAR-PRINT + +; in: DEFSTRUCT ABSM +; (DEFSTRUCT (CAT::ABSM (:CONC-NAME NIL) (:PRINT-FUNCTION CAT::ABSM-PRINT)) +; (CAT::DGOP) +; (CAT::GMSM)) +; --> PROGN DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER PROGN +; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* LET* +; --> SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET +; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS +; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* +; --> LOCALLY SYMBOL-MACROLET BLOCK FUNCALL +; ==> +; (SB-C::%FUNCALL #'CAT::ABSM-PRINT #:OBJECT1022 #:STREAM1023 +; SB-KERNEL:*CURRENT-LEVEL-IN-PRINT*) +; +; caught STYLE-WARNING: +; undefined function: ABSM-PRINT + +; in: DEFSTRUCT ALLP +; (DEFSTRUCT (CAT::ALLP (:PRINT-FUNCTION CAT::ALLP-PRINT)) (LIST)) +; --> PROGN DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER PROGN +; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* LET* +; --> SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET +; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS +; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* +; --> LOCALLY SYMBOL-MACROLET BLOCK FUNCALL +; ==> +; (SB-C::%FUNCALL #'CAT::ALLP-PRINT #:OBJECT824 #:STREAM825 +; SB-KERNEL:*CURRENT-LEVEL-IN-PRINT*) +; +; caught STYLE-WARNING: +; undefined function: ALLP-PRINT + +; in: DEFSTRUCT BICN +; (DEFSTRUCT (CAT::BICN (:CONC-NAME NIL) (:PRINT-FUNCTION CAT::BICN-PRINT)) +; (CAT::BCNX) +; (CAT::IBICN)) +; --> PROGN DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER PROGN +; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* LET* +; --> SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET +; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS +; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* +; --> LOCALLY SYMBOL-MACROLET BLOCK FUNCALL +; ==> +; (SB-C::%FUNCALL #'CAT::BICN-PRINT #:OBJECT567 #:STREAM568 +; SB-KERNEL:*CURRENT-LEVEL-IN-PRINT*) +; +; caught STYLE-WARNING: +; undefined function: BICN-PRINT + +; in: DEFSTRUCT CMBN +; (DEFSTRUCT (CAT::CMBN (:PRINT-FUNCTION CAT::CMBN-PRINT)) +; (CAT::DEGR -1 :TYPE FIXNUM) +; (LIST NIL :TYPE LIST)) +; --> PROGN DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER PROGN +; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* LET* +; --> SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET +; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS +; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* +; --> LOCALLY SYMBOL-MACROLET BLOCK FUNCALL +; ==> +; (SB-C::%FUNCALL #'CAT::CMBN-PRINT #:OBJECT0 #:STREAM1 +; SB-KERNEL:*CURRENT-LEVEL-IN-PRINT*) +; +; caught STYLE-WARNING: +; undefined function: CMBN-PRINT + +; in: DEFSTRUCT CONE +; (DEFSTRUCT (CAT::CONE (:CONC-NAME NIL) (:PRINT-FUNCTION CAT::CONE-PRINT)) +; (CAT::CONX) +; (CAT::ICON)) +; --> PROGN DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER PROGN +; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* LET* +; --> SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET +; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS +; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* +; --> LOCALLY SYMBOL-MACROLET BLOCK FUNCALL +; ==> +; (SB-C::%FUNCALL #'CAT::CONE-PRINT #:OBJECT472 #:STREAM473 +; SB-KERNEL:*CURRENT-LEVEL-IN-PRINT*) +; +; caught STYLE-WARNING: +; undefined function: CONE-PRINT + +; in: DEFSTRUCT CRPR +; (DEFSTRUCT (CAT::CRPR (:PRINT-FUNCTION CAT::CRPR-PRINT) (:CONC-NAME NIL)) +; (CAT::DGOP1) +; (CAT::GMSM1) +; (CAT::DGOP2) +; (CAT::GMSM2)) +; --> PROGN DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER PROGN +; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* LET* +; --> SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET +; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS +; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* +; --> LOCALLY SYMBOL-MACROLET BLOCK FUNCALL +; ==> +; (SB-C::%FUNCALL #'CAT::CRPR-PRINT #:OBJECT1121 #:STREAM1122 +; SB-KERNEL:*CURRENT-LEVEL-IN-PRINT*) +; +; caught STYLE-WARNING: +; undefined function: CRPR-PRINT + +; in: DEFSTRUCT GBAR +; (DEFSTRUCT (CAT::GBAR (:PRINT-FUNCTION CAT::GBAR-PRINT)) +; (CAT::DMNS -1 :TYPE FIXNUM) +; (LIST NIL :TYPE LIST)) +; --> PROGN DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER PROGN +; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* LET* +; --> SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET +; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS +; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* +; --> LOCALLY SYMBOL-MACROLET BLOCK FUNCALL +; ==> +; (SB-C::%FUNCALL #'CAT::GBAR-PRINT #:OBJECT1381 #:STREAM1382 +; SB-KERNEL:*CURRENT-LEVEL-IN-PRINT*) +; +; caught STYLE-WARNING: +; undefined function: GBAR-PRINT + +; in: DEFSTRUCT LOOP +; (DEFSTRUCT (LOOP (:PRINT-FUNCTION CAT::LOOP-PRINT)) (LIST)) +; --> PROGN DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER PROGN +; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* LET* +; --> SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET +; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS +; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* +; --> LOCALLY SYMBOL-MACROLET BLOCK FUNCALL +; ==> +; (SB-C::%FUNCALL #'CAT::LOOP-PRINT #:OBJECT1302 #:STREAM1303 +; SB-KERNEL:*CURRENT-LEVEL-IN-PRINT*) +; +; caught STYLE-WARNING: +; undefined function: LOOP-PRINT + +; in: DEFSTRUCT RESULT +; (DEFSTRUCT (CAT::RESULT (:PRINT-FUNCTION CAT::RESULT-PRINT)) +; (CAT::GNRT NIL :TYPE CAT::GNRT) +; (CAT::VALUE NIL :TYPE CAT::CMBN) +; (CAT::CLNM 0 :TYPE FIXNUM) +; (CAT::RNTM 0.0 :TYPE SINGLE-FLOAT)) +; --> PROGN DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER PROGN +; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* LET* +; --> SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET +; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS +; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* +; --> LOCALLY SYMBOL-MACROLET BLOCK FUNCALL +; ==> +; (SB-C::%FUNCALL #'CAT::RESULT-PRINT #:OBJECT137 #:STREAM138 +; SB-KERNEL:*CURRENT-LEVEL-IN-PRINT*) +; +; caught STYLE-WARNING: +; undefined function: RESULT-PRINT + +; in: DEFSTRUCT TNPR +; (DEFSTRUCT (CAT::TNPR (:CONC-NAME NIL) (:PRINT-FUNCTION CAT::TNPR-PRINT)) +; CAT::DEGR1 +; CAT::GNRT1 +; CAT::DEGR2 +; CAT::GNRT2) +; --> PROGN DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER PROGN +; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* LET* +; --> SB-INT:NAMED-LAMBDA FUNCTION SYMBOL-MACROLET +; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS +; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* +; --> LOCALLY SYMBOL-MACROLET BLOCK FUNCALL +; ==> +; (SB-C::%FUNCALL #'CAT::TNPR-PRINT #:OBJECT662 #:STREAM663 +; SB-KERNEL:*CURRENT-LEVEL-IN-PRINT*) +; +; caught STYLE-WARNING: +; undefined function: TNPR-PRINT +; +; compilation unit finished +; Undefined functions: +; ABAR-PRINT ABSM-PRINT ALLP-PRINT BICN-PRINT CMBN-PRINT CONE-PRINT CRPR-PRI +NT GBAR-PRINT LOOP-PRINT RESULT-PRINT TNPR-PRINT +; caught 11 STYLE-WARNING conditions + + +; C:/home/quicklisp/local-projects/kenzo/src/classes.fasl written +; compilation finished in 0:00:00.680 +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/combinations.lisp" +(written 02 JAN 2015 07:40:46 AM): +; compiling (IN-PACKAGE #:CAT) +; compiling (PROVIDE "combinations") +; compiling (DEFUN CMBN-PRINT ...) +; compiling (DEFUN MAPLEXICO ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/combinations.lisp +; in: DEFUN MAPLEXICO +; (THE BOOLEAN +; (DO ((CAT::MARK1 CAT::LIST1 (CDR CAT::MARK1)) +; (CAT::MARK2 CAT::LIST2 (CDR CAT::MARK2))) +; (NIL) +; (DECLARE (LIST CAT::MARK1 CAT::MARK2)) +; (UNLESS CAT::MARK1 +; (RETURN-FROM CAT::MAPLEXICO +; (IF CAT::MARK2 +; :LESS +; :EQUAL))) +; (UNLESS CAT::MARK2 (RETURN-FROM CAT::MAPLEXICO :GREATER)) +; (CASE (FUNCALL CAT::CMPR (CAR CAT::MARK1) (CAR CAT::MARK2)) +; (:LESS (RETURN-FROM CAT::MAPLEXICO :LESS)) +; (:GREATER (RETURN-FROM CAT::MAPLEXICO :GREATER))))) +; +; note: deleting unreachable code + +; compiling (DEFUN S-CMPR ...) +; compiling (DEFUN F-CMPR ...) +; compiling (DEFUN L-CMPR ...) +; compiling (DEFUN CMBN ...) +; compiling (DEFUN CHECK-CMBN ...) +; compiling (DEFUN ZERO-CMBN ...) +; compiling (DEFUN ZERO-INTR-DFFR ...) +; compiling (DEFINE-CONSTANT +ZERO-NEGATIVE-CMBN+ ...) +; compiling (DEFUN CMBN-OPPS ...) +; compiling (DEFUN N-CMBN ...) +; compiling (DEFUN 2CMBN-ADD ...) +; compiling (DEFUN 2CMBN-SBTR ...) +; compiling (DEFUN 2N-2CMBN ...) +; compiling (DEFUN CMBN-CMBN ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/combinations.lisp +; in: DEFUN CMBN-CMBN +; (THE CAT::CMBN +; (LET ((CAT::NEW-RSLT CAT::+EMPTY-LIST+)) +; (DECLARE (LIST CAT::NEW-RSLT)) +; (DO ((CAT::MARK1 # #) +; (CAT::MARK2 CAT::N-CMBN-LIST #)) +; ((ENDP CAT::MARK2)) +; (DECLARE (LIST CAT::MARK1 CAT::MARK2)) +; (WHEN (ENDP CAT::MARK1) (PUSH # CAT::NEW-RSLT) (RETURN)) +; (PUSH (CAT::2N-2CMBN CAT::CMPR # # # #) CAT::NEW-RSLT)) +; (LET ((CAT::OLD-RSLT CAT::+EMPTY-LIST+)) +; (DECLARE (LIST CAT::OLD-RSLT)) +; (LOOP (UNLESS # #) +; (SETF #) +; (DO # # # # #))))) +; +; note: deleting unreachable code + +; compiling (DEFUN NTERM-ADD ...) +; compiling (DEFUN NCMBN-ADD ...) +; compiling (DEFUN DSTR-ADD-TERM-TO-CMBN ...); +; compilation unit finished +; printed 2 notes + + +; C:/home/quicklisp/local-projects/kenzo/src/combinations.fasl written +; compilation finished in 0:00:00.161 +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/chain-complexes.lis +p" (written 02 JAN 2015 07:30:05 AM): +; compiling (IN-PACKAGE #:CAT) +; compiling (PROVIDE "chain-complexes") +; compiling (DEFUN CAT-INIT ...) +; compiling (DEFUN HOW-MANY-OBJECTS ...) +; compiling (DEFUN ALL-OBJECTS ...) +; compiling (DEFUN KD ...) +; compiling (DEFUN K ...) +; compiling (DEFUN KD2 ...) +; compiling (DEFMETHOD PRINT-OBJECT ...) +; compiling (DEFUN CHCM ...) +; compiling (DEFUN RESULT-PRINT ...) +; compiling (DEFMETHOD ?2 ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/chain-complexes.lisp +; in: DEFMETHOD ?2 (MORPHISM T) +; (THE CAT::CMBN (CAT::CMBN-? CAT::MRPH CAT::CMBN)) +; +; note: type assertion too complex to check: +; (VALUES CMBN &REST T). + +; compiling (DEFMETHOD ?2 ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/chain-complexes.lisp +; in: DEFMETHOD ?2 (CHAIN-COMPLEX T) +; (THE CAT::CMBN (CAT::CMBN-? (CAT::DFFR1 CAT::CHCM) CAT::CMBN)) +; +; note: type assertion too complex to check: +; (VALUES CMBN &REST T). + +; compiling (DEFMETHOD ?3 ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/chain-complexes.lisp +; in: DEFMETHOD ?3 (MORPHISM T T) +; (THE CAT::CMBN (CAT::GNRT-? CAT::MRPH CAT::DEGR CAT::GNRT)) +; +; note: type assertion too complex to check: +; (VALUES CMBN &REST T). + +; compiling (DEFMETHOD ?3 ...) +; compiling (DEFMETHOD PRINT-OBJECT ...) +; compiling (DEFUN MRPH ...) +; compiling (DEFUN BUILD-CHCM ...) +; compiling (DEFUN BASIS2 ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/chain-complexes.lisp +; in: DEFUN BASIS2 +; (THE LIST +; (WITH-SLOTS (CAT::BASIS) +; CAT::OBJECT +; (DECLARE (TYPE CAT::BASIS CAT::BASIS)) +; (WHEN (EQ :LOCALLY-EFFECTIVE CAT::BASIS) +; (ERROR "The object ~A is locally-effective." CAT::OBJECT)) +; (FUNCALL CAT::BASIS CAT::N))) +; +; note: type assertion too complex to check: +; (VALUES &OPTIONAL LIST &REST T). + +; compiling (DEFUN BUILD-MRPH ...) +; compiling (DEFUN NRESULTS ...) +; compiling (DEFUN TIME-LIST ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/chain-complexes.lisp +; in: DEFUN TIME-LIST +; (LET ((CAT::RNTM (CAT::RESULT-RNTM CAT::RSLT))) +; (DECLARE (INTEGER CAT::RNTM)) +; (WHEN (PLUSP CAT::RNTM) (PUSH CAT::RNTM CAT::TIME-LIST))) +; +; note: deleting unreachable code + +; (PUSH CAT::RNTM CAT::TIME-LIST) +; --> LET* +; ==> +; CAT::RNTM +; +; note: deleting unreachable code + +; --> LET* SETQ THE CONS +; ==> +; CAT::TIME-LIST +; +; note: deleting unreachable code + +; (LET ((CAT::RNTM (CAT::RESULT-RNTM CAT::RSLT))) +; (DECLARE (INTEGER CAT::RNTM)) +; (WHEN (PLUSP CAT::RNTM) (PUSH CAT::RNTM CAT::TIME-LIST))) +; +; caught WARNING: +; Derived type of (SB-KERNEL:%RAW-INSTANCE-REF/SINGLE (THE RESULT RSLT) 4) is +; (VALUES SINGLE-FLOAT &OPTIONAL), +; conflicting with its asserted type +; INTEGER. +; See also: +; The SBCL Manual, Node "Handling of Types" + +; compiling (DEFUN CLEAN-RESULTS ...) +; compiling (DEFUN MRPH-GNRT ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/chain-complexes.lisp +; in: DEFUN MRPH-GNRT +; (LET ((CAT::RNTM (FLOAT (/ CAT::RUNTIME INTERNAL-TIME-UNITS-PER-SECOND)))) + +; (DECLARE (SINGLE-FLOAT CAT::RNTM)) +; (INCF CAT::*RESULTS-CMLT-TM* CAT::RNTM) +; CAT::RNTM) +; +; note: deleting unreachable code + +; compiling (DEFUN MRPH-CMBN ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/chain-complexes.lisp +; in: DEFUN MRPH-CMBN +; (THE CAT::CMBN +; (CAT::WITH-CMBN (CAT::DEGR LIST) CAT::CMBN +; (LET ((CAT::N-CMBN-LIST CAT::+EMPTY-LIST+)) +; (DECLARE (LIST CAT::N-CMBN-LIST)) +; (DO (# +; #) +; (#) +; (DECLARE #) +; (MULTIPLE-VALUE-BIND # # # #)) +; (CAT::CMBN-CMBN CAT::TCMPR2 CAT::N-CMBN-LIST)))) +; +; note: type assertion too complex to check: +; (VALUES CMBN &REST T). + +; compiling (DEFUN DO-CONTROL ...) +; compiling (DEFUN GNRT-? ...) +; compiling (DEFUN CMBN-? ...); +; compilation unit finished +; caught 1 WARNING condition +; printed 9 notes + + +; C:/home/quicklisp/local-projects/kenzo/src/chain-complexes.fasl written +; compilation finished in 0:00:00.378 +STYLE-WARNING: Implicitly creating new generic function CAT::?2. +STYLE-WARNING: Implicitly creating new generic function CAT::?3. +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/chcm-elementary-op. +lisp" (written 02 JAN 2015 07:31:43 AM): +; compiling (IN-PACKAGE #:CAT) +; compiling (PROVIDE "chcm-elementary-op") +; compiling (DEFUN Z-CHCM ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/chcm-elementary-op.lisp +; in: DEFUN Z-CHCM +; (THE CAT::CHAIN-COMPLEX +; (CAT::BUILD-CHCM :CMPR +; #'(LAMBDA (CAT::GNRT1 CAT::GNRT2) +; (DECLARE (IGNORE CAT::GNRT1 CAT::GNRT2)) +; (THE CAT::CMPR :EQUAL)) +; :BASIS +; #'(LAMBDA (CAT::N) +; (DECLARE (TYPE FIXNUM CAT::N)) +; (THE LIST +; (IF # +; # +; CAT::+EMPTY-LIST+))) +; :BSGN :Z-GNRT :INTR-DFFR #'CAT::ZERO-INTR-DFFR :STRT + +; :CMBN :ORGN ...)) +; +; note: type assertion too complex to check: +; (VALUES CHAIN-COMPLEX &REST T). + +; compiling (DEFUN ZERO-MRPH ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/chcm-elementary-op.lisp +; in: DEFUN ZERO-MRPH +; (THE CAT::MORPHISM +; (CAT::BUILD-MRPH :SORC CAT::CHCM1 :TRGT CAT::CHCM2 :DEGR CAT::DEGR :I +NTR +; #'(LAMBDA (CAT::CMBN) +; (DECLARE (TYPE CAT::CMBN CAT::CMBN)) +; (CAT::ZERO-CMBN (+ # CAT::DEGR))) +; :STRT :CMBN :ORGN ...)) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFUN IDNT-MRPH ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/chcm-elementary-op.lisp +; in: DEFUN IDNT-MRPH +; (THE CAT::MORPHISM +; (CAT::BUILD-MRPH :SORC CAT::CHCM :TRGT CAT::CHCM :DEGR 0 :INTR +; #'IDENTITY :STRT :CMBN :ORGN ...)) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFUN OPPS ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/chcm-elementary-op.lisp +; in: DEFUN OPPS +; (THE CAT::MORPHISM +; (WITH-SLOTS (CAT::SORC CAT::TRGT CAT::DEGR) +; CAT::MRPH +; (CAT::BUILD-MRPH :SORC CAT::SORC :TRGT CAT::TRGT :DEGR CAT::DEGR :I +NTR +; #'(LAMBDA (CAT::CMBN) (DECLARE #) (CAT::CMBN-OPPS +#)) +; :STRT :CMBN :ORGN ...))) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFMETHOD CMPS ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/chcm-elementary-op.lisp +; in: DEFMETHOD CMPS (CHAIN-COMPLEX CHAIN-COMPLEX) +; (THE CAT::MORPHISM +; (CAT::CMPS (CAT::DFFR CAT::CHCM1) (CAT::DFFR CAT::CHCM2) CAT::STRT)) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFMETHOD CMPS ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/chcm-elementary-op.lisp +; in: DEFMETHOD CMPS (CHAIN-COMPLEX MORPHISM) +; (THE CAT::MORPHISM (CAT::CMPS (CAT::DFFR CAT::CHCM1) CAT::MRPH2 CAT::STRT) +) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFMETHOD CMPS ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/chcm-elementary-op.lisp +; in: DEFMETHOD CMPS (MORPHISM CHAIN-COMPLEX) +; (THE CAT::MORPHISM (CAT::CMPS CAT::MRPH1 (CAT::DFFR CAT::CHCM2) CAT::STRT) +) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFMETHOD CMPS ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/chcm-elementary-op.lisp +; in: DEFMETHOD CMPS (MORPHISM MORPHISM) +; (THE CAT::CMBN (CAT::CMBN-? CAT::MRPH1 (CAT::CMBN-? CAT::MRPH2 CAT::CMBN)) +) +; +; note: type assertion too complex to check: +; (VALUES CMBN &REST T). + +; (THE CAT::CMBN +; (CAT::CMBN-? CAT::MRPH1 (CAT::GNRT-? CAT::MRPH2 CAT::DEGR CAT::GNRT)) +) +; +; note: type assertion too complex to check: +; (VALUES CMBN &REST T). + +; (DEFMETHOD CAT::CMPS +; ((CAT::MRPH1 CAT::MORPHISM) (CAT::MRPH2 CAT::MORPHISM) +; &OPTIONAL CAT::STRT) +; (DECLARE (TYPE (OR CAT::STRT NULL) CAT::STRT)) +; (THE CAT::MORPHISM +; (WITH-SLOTS ((CAT::SORC1 CAT::SORC) (CAT::TRGT1 CAT::TRGT) +; (CAT::DEGR1 CAT::DEGR) (CAT::STRT1 CAT::STRT)) +; CAT::MRPH1 +; (DECLARE (TYPE CAT::CHAIN-COMPLEX CAT::SORC1 CAT::TRGT1) +; (FIXNUM CAT::DEGR1) +; (TYPE CAT::STRT CAT::STRT1)) +; (WITH-SLOTS (# # # #) +; CAT::MRPH2 +; (DECLARE # +; # +; #) +; (UNLESS # #) +; (UNLESS CAT::STRT #) +; (WHEN # #) +; (WHEN # #) +; (WHEN # #) +; (ECASE CAT::STRT # #))))) +; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER PROGN SB-PCL::LOAD-DEFMETHOD +; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION +; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS +; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET LET SB-PCL::BIND-ARGS +; --> LET* LOCALLY SYMBOL-MACROLET BLOCK +; ==> +; (THE CAT::MORPHISM +; (LET ((#:G166 CAT::MRPH1)) +; (DECLARE (IGNORABLE #:G166)) +; (DECLARE (SB-PCL::%VARIABLE-REBINDING #:G166 CAT::MRPH1)) +; #:G166 +; (SYMBOL-MACROLET ((CAT::SORC1 #) +; (CAT::TRGT1 #) +; (CAT::DEGR1 #) +; (CAT::STRT1 #)) +; (DECLARE (TYPE CAT::CHAIN-COMPLEX CAT::SORC1 CAT::TRGT1) +; (FIXNUM CAT::DEGR1) +; (TYPE CAT::STRT CAT::STRT1)) +; (LET (#) +; (DECLARE #) +; (DECLARE #) +; #:G168 +; (SYMBOL-MACROLET # +; # +; # +; # +; # +; # +; # +; #))))) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER PROGN SB-PCL::LOAD-DEFMETHOD +; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION +; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS +; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET LET SB-PCL::BIND-ARGS +; --> LET* LOCALLY SYMBOL-MACROLET +; ==> +; (BLOCK CAT::CMPS +; (THE CAT::MORPHISM +; (LET ((#:G166 CAT::MRPH1)) +; (DECLARE (IGNORABLE #:G166)) +; (DECLARE (SB-PCL::%VARIABLE-REBINDING #:G166 CAT::MRPH1)) +; #:G166 +; (SYMBOL-MACROLET (# # # #) +; (DECLARE # +; # +; #) +; (LET # +; # +; # +; #:G168 +; #))))) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFUN N-MRPH-INTR ...) +; compiling (DEFUN N-MRPH ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/chcm-elementary-op.lisp +; in: DEFUN N-MRPH +; (THE CAT::MORPHISM +; (WITH-SLOTS (CAT::SORC CAT::TRGT CAT::DEGR) +; CAT::MRPH +; (DECLARE (TYPE CAT::CHAIN-COMPLEX CAT::SORC CAT::TRGT) +; (FIXNUM CAT::DEGR)) +; (CAT::BUILD-MRPH :SORC CAT::SORC :TRGT CAT::TRGT :DEGR CAT::DEGR :I +NTR +; (CAT::N-MRPH-INTR CAT::N CAT::MRPH) :STRT :CMBN :O +RGN +; ...))) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFMETHOD ADD ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/chcm-elementary-op.lisp +; in: DEFMETHOD ADD (MORPHISM MORPHISM) +; (DEFMETHOD CAT::ADD +; ((CAT::MRPH1 CAT::MORPHISM) (CAT::MRPH2 CAT::MORPHISM) +; &OPTIONAL CAT::STRT) +; (DECLARE (TYPE (OR NULL CAT::STRT) CAT::STRT)) +; (THE CAT::MORPHISM +; (WITH-SLOTS ((CAT::SORC1 CAT::SORC) (CAT::TRGT1 CAT::TRGT) +; (CAT::DEGR1 CAT::DEGR) (CAT::STRT1 CAT::STRT)) +; CAT::MRPH1 +; (DECLARE (TYPE CAT::CHAIN-COMPLEX CAT::SORC1 CAT::TRGT1) +; (FIXNUM CAT::DEGR1) +; (TYPE CAT::STRT CAT::STRT1)) +; (WITH-SLOTS (# # # #) +; CAT::MRPH2 +; (DECLARE # +; # +; #) +; (UNLESS # #) +; (WHEN # #) +; (WHEN # #) +; (UNLESS CAT::STRT #) +; (WHEN # #) +; (LET # +; # +; #))))) +; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER PROGN SB-PCL::LOAD-DEFMETHOD +; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION +; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS +; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET LET SB-PCL::BIND-ARGS +; --> LET* LOCALLY SYMBOL-MACROLET BLOCK +; ==> +; (THE CAT::MORPHISM +; (LET ((#:G323 CAT::MRPH1)) +; (DECLARE (IGNORABLE #:G323)) +; (DECLARE (SB-PCL::%VARIABLE-REBINDING #:G323 CAT::MRPH1)) +; #:G323 +; (SYMBOL-MACROLET ((CAT::SORC1 #) +; (CAT::TRGT1 #) +; (CAT::DEGR1 #) +; (CAT::STRT1 #)) +; (DECLARE (TYPE CAT::CHAIN-COMPLEX CAT::SORC1 CAT::TRGT1) +; (FIXNUM CAT::DEGR1) +; (TYPE CAT::STRT CAT::STRT1)) +; (LET (#) +; (DECLARE #) +; (DECLARE #) +; #:G325 +; (SYMBOL-MACROLET # +; # +; # +; # +; # +; # +; # +; #))))) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFMETHOD SBTR ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/chcm-elementary-op.lisp +; in: DEFMETHOD SBTR (MORPHISM MORPHISM) +; (DEFMETHOD CAT::SBTR +; ((CAT::MRPH1 CAT::MORPHISM) (CAT::MRPH2 CAT::MORPHISM) +; &OPTIONAL CAT::STRT) +; (DECLARE (TYPE (OR NULL CAT::STRT) CAT::STRT)) +; (THE CAT::MORPHISM +; (WITH-SLOTS ((CAT::SORC1 CAT::SORC) (CAT::TRGT1 CAT::TRGT) +; (CAT::DEGR1 CAT::DEGR) (CAT::STRT1 CAT::STRT)) +; CAT::MRPH1 +; (DECLARE (TYPE CAT::CHAIN-COMPLEX CAT::SORC1 CAT::TRGT1) +; (FIXNUM CAT::DEGR1) +; (TYPE CAT::STRT CAT::STRT1)) +; (WITH-SLOTS (# # # #) +; CAT::MRPH2 +; (DECLARE # +; # +; #) +; (UNLESS # #) +; (WHEN # #) +; (WHEN # #) +; (UNLESS CAT::STRT #) +; (WHEN # #) +; (LET # +; # +; #))))) +; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER PROGN SB-PCL::LOAD-DEFMETHOD +; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION +; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS +; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET LET SB-PCL::BIND-ARGS +; --> LET* LOCALLY SYMBOL-MACROLET BLOCK +; ==> +; (THE CAT::MORPHISM +; (LET ((#:G453 CAT::MRPH1)) +; (DECLARE (IGNORABLE #:G453)) +; (DECLARE (SB-PCL::%VARIABLE-REBINDING #:G453 CAT::MRPH1)) +; #:G453 +; (SYMBOL-MACROLET ((CAT::SORC1 #) +; (CAT::TRGT1 #) +; (CAT::DEGR1 #) +; (CAT::STRT1 #)) +; (DECLARE (TYPE CAT::CHAIN-COMPLEX CAT::SORC1 CAT::TRGT1) +; (FIXNUM CAT::DEGR1) +; (TYPE CAT::STRT CAT::STRT1)) +; (LET (#) +; (DECLARE #) +; (DECLARE #) +; #:G455 +; (SYMBOL-MACROLET # +; # +; # +; # +; # +; # +; # +; #))))) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFUN CHANGE-SORC-TRGT ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/chcm-elementary-op.lisp +; in: DEFUN CHANGE-SORC-TRGT +; (THE CAT::MORPHISM +; (WITH-SLOTS (CAT::SORC CAT::TRGT CAT::DEGR CAT::INTR CAT::STRT) +; CAT::MRPH +; (CAT::BUILD-MRPH :SORC (OR CAT::NEW-SORC CAT::SORC) :TRGT +; (OR CAT::NEW-TRGT CAT::TRGT) :DEGR CAT::DEGR :INTR + +; CAT::INTR :STRT CAT::STRT :ORGN ...))) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFUN DSTR-CHANGE-SORC-TRGT ...) +; compiling (DEFMETHOD ADD ...); +; compilation unit finished +; printed 15 notes + + +; C:/home/quicklisp/local-projects/kenzo/src/chcm-elementary-op.fasl written +; compilation finished in 0:00:00.577 +STYLE-WARNING: Implicitly creating new generic function CAT::CMPS. +STYLE-WARNING: Implicitly creating new generic function CAT::ADD. +STYLE-WARNING: Implicitly creating new generic function CAT::SBTR. +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/effective-homology. +lisp" (written 01 JAN 2015 06:51:00 PM): +; compiling (IN-PACKAGE #:CAT) +; compiling (PROVIDE "effective-homology") +; compiling (DEFMETHOD PRINT-OBJECT ...) +; compiling (DEFUN RDCT ...) +; compiling (DEFUN BUILD-RDCT ...) +; compiling (DEFUN TRIVIAL-RDCT ...) +; compiling (DEFMETHOD BUILD-HMEQ ...) +; compiling (DEFMETHOD PRINT-OBJECT ...) +; compiling (DEFMETHOD HMEQ ...) +; compiling (DEFMETHOD BUILD-HMEQ ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/effective-homology.lisp +; in: DEFMETHOD BUILD-HMEQ ((EQL :LF) T) +; (THE CAT::HOMOTOPY-EQUIVALENCE +; (PROGN +; (UNLESS CAT::ORGN (SETF CAT::ORGN `#)) +; (LET ((CAT::ALREADY #)) +; (DECLARE (TYPE # CAT::ALREADY)) +; (WHEN CAT::ALREADY (RETURN-FROM CAT::BUILD-HMEQ CAT::ALREADY))) +; (CAT::BUILD-HMEQ :LRDCT +; (CAT::BUILD-RDCT :F CAT::LF :G CAT::LG :H CAT::LH :ORGN +; `(CAT::BUILD-HMEQ ,CAT::LF ,CAT::LG ,CAT::LH ,CAT::RF ,CAT::RG +; ,CAT::RH CAT::LRDCT)) +; :RRDCT +; (CAT::BUILD-RDCT :F CAT::RF :G CAT::RG :H CAT::RH :ORGN +; `(CAT::BUILD-HMEQ ,CAT::LF ,CAT::LG ,CAT::LH ,CAT::RF ,CAT::RG +; ,CAT::RH CAT::RRDCT)) +; :ORGN CAT::ORGN))) +; +; note: type assertion too complex to check: +; (VALUES HOMOTOPY-EQUIVALENCE &REST T). + +; compiling (DEFUN TRIVIAL-HMEQ ...) +; compiling (DEFUN PRE-CHECK-RDCT ...) +; compiling (DEFUN CHECK-RDCT ...) +; compiling (DEFMETHOD CMPS ...) +; compiling (DEFMETHOD ADD ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/effective-homology.lisp +; in: DEFMETHOD ADD (REDUCTION MORPHISM) +; (ERROR "Why a third argument in (ADD REDUCTION MORPHISM)?") +; ==> +; "Why a third argument in (ADD REDUCTION MORPHISM)?" +; +; note: deleting unreachable code + +; compiling (DEFUN BASIC-PERTURBATION-LEMMA ...) +; compiling (DEFUN EASY-PERTURBATION-LEMMA ...) +; compiling (DEFUN SPECIAL-BPL ...) +; compiling (DEFUN SPECIAL-BPL-2 ...) +; compiling (DEFUN BPL-*-SIGMA ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/effective-homology.lisp +; in: DEFUN BPL-*-SIGMA +; (THE CAT::MORPHISM +; (LET ((CAT::CMPR (CAT::CMPR #)) +; (CAT::H-DELTA (CAT::CMPS CAT::HOMOTOPY CAT::PERTURBATION))) +; (DECLARE (TYPE CAT::CMPRF CAT::CMPR) +; (TYPE CAT::MORPHISM CAT::H-DELTA)) +; (FLET ((CAT::SIGMA-* # +; # +; #)) +; (CAT::BUILD-MRPH :SORC (CAT::SORC CAT::HOMOTOPY) :TRGT +; (CAT::SORC CAT::HOMOTOPY) :DEGR 0 :INTR +; #'CAT::SIGMA-* :STRT :GNRT :ORGN ...)))) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFMETHOD ADD ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/effective-homology.lisp +; in: DEFMETHOD ADD (HOMOTOPY-EQUIVALENCE MORPHISM) +; (DEFMETHOD CAT::ADD +; ((CAT::HMEQ CAT::HOMOTOPY-EQUIVALENCE) +; (CAT::LB-PERTURBATION CAT::MORPHISM) +; &OPTIONAL CAT::DUMMY) +; (DECLARE (IGNORE CAT::DUMMY)) +; (THE CAT::HOMOTOPY-EQUIVALENCE +; (WITH-SLOTS (CAT::LRDCT CAT::RRDCT) +; CAT::HMEQ +; (DECLARE (TYPE CAT::REDUCTION CAT::LRDCT CAT::RRDCT)) +; (MULTIPLE-VALUE-BIND (CAT::NEW-LRDCT CAT::TOP-PERTURBATION) +; (CAT::ADD CAT::LRDCT CAT::LB-PERTURBATION) +; (DECLARE # +; #) +; (CAT::BUILD-HMEQ :LRDCT CAT::NEW-LRDCT :RRDCT # :ORGN `#))))) +; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER PROGN SB-PCL::LOAD-DEFMETHOD +; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION +; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS +; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET LET SB-PCL::BIND-ARGS +; --> LET* LOCALLY SYMBOL-MACROLET BLOCK +; ==> +; (THE CAT::HOMOTOPY-EQUIVALENCE +; (LET ((#:G1057 CAT::HMEQ)) +; (DECLARE (IGNORABLE #:G1057)) +; (DECLARE (SB-PCL::%VARIABLE-REBINDING #:G1057 CAT::HMEQ)) +; #:G1057 +; (SYMBOL-MACROLET ((CAT::LRDCT #) (CAT::RRDCT #)) +; (DECLARE (TYPE CAT::REDUCTION CAT::LRDCT CAT::RRDCT)) +; (MULTIPLE-VALUE-BIND (CAT::NEW-LRDCT CAT::TOP-PERTURBATION) +; (CAT::ADD # CAT::LB-PERTURBATION) +; (DECLARE # +; #) +; (CAT::BUILD-HMEQ :LRDCT CAT::NEW-LRDCT :RRDCT # :ORGN `#))))) +; +; note: type assertion too complex to check: +; (VALUES HOMOTOPY-EQUIVALENCE &REST T). +; +; compilation unit finished +; printed 4 notes + + +; C:/home/quicklisp/local-projects/kenzo/src/effective-homology.fasl written +; compilation finished in 0:00:00.350 +STYLE-WARNING: Implicitly creating new generic function CAT::BUILD-HMEQ. +STYLE-WARNING: Implicitly creating new generic function CAT::HMEQ. +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/homology-groups.lis +p" (written 26 DEC 2014 07:39:46 PM): +; compiling (IN-PACKAGE #:CAT) +; compiling (PROVIDE "homology-groups") +; compiling (DEFUN CREER-MATRICE ...) +; compiling (DEFUN CHERCHER-HOR ...) +; compiling (DEFUN CHERCHER-VER ...) +; compiling (DEFUN INSERER-TERME ...) +; compiling (DEFUN SUPPRIMER-TERME ...) +; compiling (DEFUN MAJ-TERME ...) +; compiling (DEFUN MAJ-LIGNE ...) +; compiling (DEFUN MAJ-COLONNE ...) +; compiling (DEFUN MAJ-MATRICE ...) +; compiling (DEFUN DISP-P ...) +; compiling (DEFUN DISP-LIGNE ...) +; compiling (DEFUN DISP-COLONNE ...) +; compiling (DEFUN NLIG ...) +; compiling (DEFUN NCOL ...) +; compiling (DEFUN DISP-MATRICE ...) +; compiling (DEFMETHOD PRINT-OBJECT ...) +; compiling (DEFUN DISP-MATRICE-COLONNES ...) +; compiling (DEFUN TERME ...) +; compiling (DEFUN MAT-ALEAT ...) +; compiling (DEFUN OP-ELEM ...) +; compiling (DEFUN PEIGNE-VER ...) +; compiling (DEFUN PEIGNE-HOR ...) +; compiling (DEFUN OP-LIG ...) +; compiling (DEFUN OP-COL ...) +; compiling (DEFUN OP-LIG-N ...) +; compiling (DEFUN OP-COL-N ...) +; compiling (DEFUN N-LIG ...) +; compiling (DEFUN N-COL ...) +; compiling (DEFUN COPIER-MATRICE ...) +; compiling (DEFUN RESTE ...) +; compiling (DEFUN DIVISEUR ...) +; compiling (DEFUN MAJ-PEIGNE-VER ...) +; compiling (DEFUN MAJ-PEIGNE-HOR ...) +; compiling (DEFUN IDENTITE ...) +; compiling (DEFUN INIT-PEIGNE-VER ...) +; compiling (DEFUN INIT-PEIGNE-HOR ...) +; compiling (DEFUN DISP-PEIGNE ...) +; compiling (DEFUN TERME-MINIMAL-MATRICE ...) +; compiling (DEFUN TUER-LIGNE ...) +; compiling (DEFUN TUER-COLONNE ...) +; compiling (DEFUN PIVOT ...) +; compiling (DEFUN PIVOT-PARALLELE ...) +; compiling (DEFUN GENERATEUR-TORSION-H* ...) +; compiling (DEFUN TERMINER-H* ...) +; compiling (DEFUN RESTE-MINIMAL-LIGNE ...) +; compiling (DEFUN RESTE-MINIMAL-COLONNE ...) +; compiling (DEFUN HOMOLOGIE ...) +; compiling (DEFUN CHCM-MAT ...) +; compiling (DEFUN CHCM-HOMOLOGY ...) +; compiling (DEFUN CHCM-HOMOLOGY-GEN ...) +; compiling (DEFUN CHCM-HOMOLOGY-GEN-OLD ...) + +; C:/home/quicklisp/local-projects/kenzo/src/homology-groups.fasl written +; compilation finished in 0:00:00.360 +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/searching-homology. +lisp" (written 24 DEC 2014 10:16:32 PM): +; compiling (IN-PACKAGE #:CAT) +; compiling (PROVIDE "searching-homology") +; compiling (DEFUN ECHCM ...) +; compiling (DEFMETHOD HOMOLOGY ...) +; compiling (DEFGENERIC SEARCH-EFHM ...) +; compiling (DEFMETHOD SEARCH-EFHM ...) +; compiling (DEFMETHOD SLOT-UNBOUND ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/searching-homology.lisp +; in: DEFMETHOD SLOT-UNBOUND (T CHAIN-COMPLEX (EQL 'EFHM)) +; (THE CAT::HOMOTOPY-EQUIVALENCE +; (LET ((CAT::EFHM (CAT::SEARCH-EFHM CAT::CHCM #))) +; (SETF (CAT::EFHM CAT::CHCM) (OR CAT::EFHM # #)))) +; +; note: type assertion too complex to check: +; (VALUES HOMOTOPY-EQUIVALENCE &REST T). +; +; compilation unit finished +; printed 1 note + + +; C:/home/quicklisp/local-projects/kenzo/src/searching-homology.fasl written +; compilation finished in 0:00:00.045 +STYLE-WARNING: Implicitly creating new generic function CAT::HOMOLOGY. +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/cones.lisp" (writte +n 01 JAN 2015 01:16:52 PM): +; compiling (IN-PACKAGE #:CAT) +; compiling (PROVIDE "cones") +; compiling (DEFUN CONE-PRINT ...) +; compiling (DEFUN CONE-CMPR ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/cones.lisp +; in: DEFUN CONE-CMPR +; (THE CAT::CMPR +; (LET ((CAT::IND1 (CAT::CONX CAT::GNRT1)) +; (CAT::IND2 (CAT::CONX CAT::GNRT2)) +; (CAT::GNRT11 (CAT::ICON CAT::GNRT1)) +; (CAT::GNRT22 (CAT::ICON CAT::GNRT2))) +; (DECLARE (FIXNUM CAT::IND1 CAT::IND2) +; (TYPE CAT::GNRT CAT::GNRT11 CAT::GNRT22)) +; (ECASE CAT::IND1 (0 (ECASE CAT::IND2 # #)) (1 (ECASE CAT::IND2 # #) +)))) +; +; note: type assertion too complex to check: +; (VALUES (MEMBER :LESS :EQUAL :GREATER) &REST T). + +; compiling (DEFUN CONE-BASIS ...) +; compiling (DEFUN TERM-CON0 ...) +; compiling (DEFUN TERM-CON1 ...) +; compiling (DEFUN TERM-UNCON ...) +; compiling (DEFUN CMBN-CON0 ...) +; compiling (DEFUN CMBN-CON1 ...) +; compiling (DEFUN CONE-CMBN-SPLIT ...) +; compiling (DEFUN CONE-2CMBN-APPEND ...) +; compiling (DEFUN CONE-2MRPH-DIAG-IMPL ...) +; compiling (DEFUN CONE-3MRPH-TRIANGLE-IMPL ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/cones.lisp +; in: DEFUN CONE-3MRPH-TRIANGLE-IMPL +; (THE CAT::CMBN +; (ECASE (CAT::CONX CAT::GNRT) +; (0 (CAT::CMBN-CON0 (CAT::? CAT::MRPH0 CAT::DEGR #))) +; (1 +; (LET (#) +; (DECLARE #) +; (CAT::CONE-2CMBN-APPEND # #))))) +; +; note: type assertion too complex to check: +; (VALUES CMBN &REST T). + +; compiling (DEFUN CONE ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/cones.lisp +; in: DEFUN CONE +; (THE CAT::CHAIN-COMPLEX +; (LET ((CAT::CHCM0 (CAT::TRGT CAT::MRPH)) +; (CAT::CHCM1 (CAT::SORC CAT::MRPH))) +; (DECLARE (TYPE CAT::CHAIN-COMPLEX CAT::CHCM0 CAT::CHCM1)) +; (CAT::BUILD-CHCM :CMPR +; (CAT::CONE-CMPR (CAT::CMPR CAT::CHCM0) +; (CAT::CMPR CAT::CHCM1)) +; :BASIS +; (CAT::CONE-BASIS (CAT::BASIS CAT::CHCM0) +; (CAT::BASIS CAT::CHCM1)) +; :BSGN (CAT::CON0 (CAT::BSGN CAT::CHCM0)) :INTR-DFF +R +; (CAT::CONE-3MRPH-TRIANGLE-IMPL (CAT::CMPR CAT::CHC +M0) +; (CAT::DFFR CAT::CHCM0) (CAT::N-MRPH -1 #) CAT::MR +PH) +; :STRT :GNRT :ORGN ...))) +; +; note: type assertion too complex to check: +; (VALUES CHAIN-COMPLEX &REST T). + +; compiling (DEFUN CONE-2MRPH-DIAG ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/cones.lisp +; in: DEFUN CONE-2MRPH-DIAG +; (THE CAT::MORPHISM +; (PROGN +; (UNLESS (= (CAT::DEGR CAT::MRPH0) (CAT::DEGR CAT::MRPH1)) +; (ERROR "Non-coherent degrees in CONE-2MRPH-DIAG.")) +; (CAT::BUILD-MRPH :SORC CAT::SORC-CONE :TRGT CAT::TRGT-CONE :DEGR +; (CAT::DEGR CAT::MRPH0) :INTR +; (CAT::CONE-2MRPH-DIAG-IMPL CAT::MRPH0 CAT::MRPH1) +; :STRT :CMBN :ORGN ...))) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFUN CONE-3MRPH-TRIANGLE ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/cones.lisp +; in: DEFUN CONE-3MRPH-TRIANGLE +; (THE CAT::MORPHISM +; (PROGN +; (UNLESS (= (CAT::DEGR CAT::MRPH0) (CAT::DEGR CAT::MRPH1)) +; (ERROR "Non-coherent degrees in CONE-3MRPH-TRIANGLE.")) +; (UNLESS (= (1+ #) (CAT::DEGR CAT::PHI)) +; (ERROR "Non-coherent-degrees in CONE-3MRPH-TRIANGLE.")) +; (CAT::BUILD-MRPH :SORC CAT::SORC-CONE :TRGT CAT::TRGT-CONE :DEGR +; (CAT::DEGR CAT::MRPH0) :INTR +; (CAT::CONE-3MRPH-TRIANGLE-IMPL (CAT::CMPR #) +; CAT::MRPH0 CAT::MRPH1 CAT::PHI) +; :STRT :GNRT :ORGN ...))) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFUN CONE-EFHM ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/cones.lisp +; in: DEFUN CONE-EFHM +; (THE CAT::HOMOTOPY-EQUIVALENCE +; (LET* ((CAT::PHI (SECOND #)) +; (CAT::CHCM0 (CAT::TRGT CAT::PHI)) +; (CAT::CHCM1 (CAT::SORC CAT::PHI)) +; (CAT::EFHM0 (CAT::EFHM CAT::CHCM0)) +; (CAT::EFHM1 (CAT::EFHM CAT::CHCM1)) +; (CAT::LF0 (CAT::LF CAT::EFHM0)) +; (CAT::LG0 (CAT::LG CAT::EFHM0)) +; (CAT::LH0 (CAT::LH CAT::EFHM0)) +; (CAT::RF0 (CAT::RF CAT::EFHM0)) +; (CAT::RG0 (CAT::RG CAT::EFHM0)) +; (CAT::RH0 (CAT::RH CAT::EFHM0)) +; (CAT::LF1 (CAT::LF CAT::EFHM1)) +; ...) +; (DECLARE +; (TYPE CAT::CHAIN-COMPLEX CAT::CHCM0 CAT::CHCM1 CAT::HCONE CAT::ECO +NE) +; (TYPE CAT::MORPHISM CAT::PHI CAT::LF0 CAT::LG0 CAT::LH0 CAT::RF0 +; CAT::RG0 CAT::RH0 CAT::LF1 CAT::LG1 CAT::LH1 ...)) +; (CAT::BUILD-HMEQ :LRDCT +; (CAT::BUILD-RDCT :F CAT::LF :G CAT::LG :H CAT::LH +; :ORGN +; `(CAT::CONE-EFHM ,CAT::CONE +; CAT::LRDCT)) +; :RRDCT +; (CAT::BUILD-RDCT :F CAT::RF :G CAT::RG :H CAT::RH +; :ORGN +; `(CAT::CONE-EFHM ,CAT::CONE +; CAT::RRDCT)) +; :ORGN `(CAT::CONE-EFHM ,CAT::CONE)))) +; +; note: type assertion too complex to check: +; (VALUES HOMOTOPY-EQUIVALENCE &REST T). + +; compiling (DEFMETHOD SEARCH-EFHM ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/cones.lisp +; in: DEFMETHOD SEARCH-EFHM (T (EQL 'CONE)) +; (THE CAT::HOMOTOPY-EQUIVALENCE (CAT::CONE-EFHM CAT::CHCM)) +; +; note: type assertion too complex to check: +; (VALUES HOMOTOPY-EQUIVALENCE &REST T). +; +; compilation unit finished +; printed 7 notes + + +; C:/home/quicklisp/local-projects/kenzo/src/cones.fasl written +; compilation finished in 0:00:00.266 +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/bicones.lisp" (writ +ten 24 DEC 2014 10:18:22 PM): +; compiling (IN-PACKAGE #:CAT) +; compiling (PROVIDE "bicones") +; compiling (DEFUN DISPATCH-BICN-CMBN ...) +; compiling (DEFUN BICN-CMBN-CMBNB ...) +; compiling (DEFUN BICN-CMBN-CMBNC ...) +; compiling (DEFUN BICN-CMBN-CMBND ...) +; compiling (DEFUN MAKE-BICN-CMBN ...) +; compiling (DEFUN BICN-PRINT ...) +; compiling (DEFUN BICONE-CMPR ...) +; compiling (DEFUN BICONE-BASIS ...) +; compiling (DEFUN BICONE-INTR-DFFR ...) +; compiling (DEFUN BICONE ...) +; compiling (DEFMETHOD CMPS ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/bicones.lisp +; in: DEFMETHOD CMPS (HOMOTOPY-EQUIVALENCE HOMOTOPY-EQUIVALENCE) +; (DEFMETHOD CAT::CMPS +; ((CAT::HMEQ1 CAT::HOMOTOPY-EQUIVALENCE) +; (CAT::HMEQ2 CAT::HOMOTOPY-EQUIVALENCE) +; &OPTIONAL CAT::DUMMY) +; (DECLARE (IGNORE CAT::DUMMY)) +; (THE CAT::HOMOTOPY-EQUIVALENCE +; (PROGN +; (WHEN (EQ 'CAT::TRIVIAL-HMEQ #) (RETURN-FROM CAT::CMPS CAT::HMEQ1) +) +; (WITH-SLOTS (# # # # # # # # #) +; CAT::HMEQ1 +; (DECLARE # +; #) +; (WITH-SLOTS # +; CAT::HMEQ2 +; # +; # +; #))))) +; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER PROGN SB-PCL::LOAD-DEFMETHOD +; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION +; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS +; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET LET SB-PCL::BIND-ARGS +; --> LET* LOCALLY SYMBOL-MACROLET BLOCK +; ==> +; (THE CAT::HOMOTOPY-EQUIVALENCE +; (PROGN +; (WHEN (EQ 'CAT::TRIVIAL-HMEQ (CAT::ORGN CAT::HMEQ2)) +; (RETURN-FROM CAT::CMPS CAT::HMEQ1)) +; (LET ((#:G561 CAT::HMEQ1)) +; (DECLARE (IGNORABLE #:G561)) +; (DECLARE (SB-PCL::%VARIABLE-REBINDING #:G561 CAT::HMEQ1)) +; #:G561 +; (SYMBOL-MACROLET (# # # # # # # # #) +; (DECLARE # +; #) +; (LET # +; # +; # +; #:G563 +; #))))) +; +; note: type assertion too complex to check: +; (VALUES HOMOTOPY-EQUIVALENCE &REST T). +; +; compilation unit finished +; printed 1 note + + +; C:/home/quicklisp/local-projects/kenzo/src/bicones.fasl written +; compilation finished in 0:00:00.212 +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/tensor-products.lis +p" (written 26 DEC 2014 07:41:48 PM): +; compiling (IN-PACKAGE #:CAT) +; compiling (PROVIDE "tensor-products") +; compiling (DEFUN TNPR-PRINT ...) +; compiling (DEFUN 2CMBN-TNPR ...) +; compiling (DEFUN TNSR-PRDC-CMPR ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/tensor-products.lisp +; in: DEFUN TNSR-PRDC-CMPR +; (THE CAT::CMPR +; (CAT::LEXICO +; (CAT::F-CMPR (CAT::DEGR1 CAT::TNPR1) (CAT::DEGR1 CAT::TNPR2)) +; (FUNCALL CAT::CMPR1 (CAT::GNRT1 CAT::TNPR1) (CAT::GNRT1 CAT::TNPR2)) + +; (FUNCALL CAT::CMPR2 (CAT::GNRT2 CAT::TNPR1) (CAT::GNRT2 CAT::TNPR2)) +)) +; +; note: type assertion too complex to check: +; (VALUES (MEMBER :LESS :EQUAL :GREATER) &REST T). + +; compiling (DEFUN TNSR-PRDC-BASIS ...) +; compiling (DEFUN TNSR-PRDC-INTR-DFFR ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/tensor-products.lisp +; in: DEFUN TNSR-PRDC-INTR-DFFR +; (IF CAT::SIGN +; (- CAT::CFFC2) +; CAT::CFFC2) +; ==> +; CAT::CFFC2 +; +; note: deleting unreachable code + +; (LET ((CAT::DEGR1-1 (1- CAT::DEGR1)) +; (CAT::DEGR2-1 (1- CAT::DEGR2)) +; (CAT::SIGN (ODDP CAT::DEGR1)) +; (CAT::LIST1 +; (CAT::CMBN-LIST (CAT::GNRT-? CAT::DFFR1 CAT::DEGR1 CAT::GNRT1))) +; (CAT::LIST2 +; (CAT::CMBN-LIST (CAT::GNRT-? CAT::DFFR2 CAT::DEGR2 CAT::GNRT2)))) +; (DECLARE (FIXNUM CAT::DEGR1-1 CAT::DEGR2-1 CAT::SIGN) +; (LIST CAT::LIST1 CAT::LIST2)) +; (CAT::MAKE-CMBN :DEGR (1- CAT::DEGR) :LIST +; (NCONC (MAPCAR #'(LAMBDA # # #) CAT::LIST1) +; (MAPCAR #'(LAMBDA # # #) CAT::LIST2)))) +; +; note: deleting unreachable code + +; (NCONC +; (MAPCAR +; #'(LAMBDA (CAT::TERM1) +; (DECLARE (TYPE CAT::TERM CAT::TERM1)) +; (CAT::WITH-TERM (CAT::CFFC1 CAT::GNRT1) CAT::TERM1 +; (CAT::TERM CAT::CFFC1 #))) +; CAT::LIST1) +; (MAPCAR +; #'(LAMBDA (CAT::TERM2) +; (DECLARE (TYPE CAT::TERM CAT::TERM2)) +; (CAT::WITH-TERM (CAT::CFFC2 CAT::GNRT2) CAT::TERM2 (CAT::TERM # #))) + +; CAT::LIST2)) +; +; note: deleting unreachable code + +; (THE CAT::CMBN +; (CAT::WITH-TNPR (CAT::DEGR1 CAT::GNRT1 CAT::DEGR2 CAT::GNRT2) CAT::TN +PR +; (LET ((CAT::DEGR1-1 #) +; (CAT::DEGR2-1 #) +; (CAT::SIGN #) +; (CAT::LIST1 #) +; (CAT::LIST2 #)) +; (DECLARE (FIXNUM CAT::DEGR1-1 CAT::DEGR2-1 CAT::SIG +N) +; (LIST CAT::LIST1 CAT::LIST2)) +; (CAT::MAKE-CMBN :DEGR (1- CAT::DEGR) :LIST +; (NCONC # #))))) +; +; note: deleting unreachable code + +; (MAPCAR +; #'(LAMBDA (CAT::TERM1) +; (DECLARE (TYPE CAT::TERM CAT::TERM1)) +; (CAT::WITH-TERM (CAT::CFFC1 CAT::GNRT1) CAT::TERM1 +; (CAT::TERM CAT::CFFC1 +; (CAT::TNPR CAT::DEGR1-1 CAT::GNRT1 CAT::DE +GR2 +; CAT::GNRT2)))) +; CAT::LIST1) +; --> LET LET SB-INT:DO-ANONYMOUS BLOCK LET +; ==> +; CAT::LIST1 +; +; note: deleting unreachable code + +; #'(LAMBDA (CAT::TERM2) +; (DECLARE (TYPE CAT::TERM CAT::TERM2)) +; (CAT::WITH-TERM (CAT::CFFC2 CAT::GNRT2) CAT::TERM2 +; (CAT::TERM +; (IF CAT::SIGN +; (- CAT::CFFC2) +; CAT::CFFC2) +; (CAT::TNPR CAT::DEGR1 CAT::GNRT1 CAT::DEGR2-1 +; CAT::GNRT2)))) +; +; note: deleting unreachable code + +; (MAPCAR +; #'(LAMBDA (CAT::TERM2) +; (DECLARE (TYPE CAT::TERM CAT::TERM2)) +; (CAT::WITH-TERM (CAT::CFFC2 CAT::GNRT2) CAT::TERM2 +; (CAT::TERM +; (IF CAT::SIGN +; # +; CAT::CFFC2) +; (CAT::TNPR CAT::DEGR1 CAT::GNRT1 CAT::DEGR2-1 +; CAT::GNRT2)))) +; CAT::LIST2) +; --> LET LET SB-INT:DO-ANONYMOUS BLOCK LET +; ==> +; CAT::LIST2 +; +; note: deleting unreachable code + +; (LET ((CAT::DEGR1-1 (1- CAT::DEGR1)) +; (CAT::DEGR2-1 (1- CAT::DEGR2)) +; (CAT::SIGN (ODDP CAT::DEGR1)) +; (CAT::LIST1 +; (CAT::CMBN-LIST (CAT::GNRT-? CAT::DFFR1 CAT::DEGR1 CAT::GNRT1))) +; (CAT::LIST2 +; (CAT::CMBN-LIST (CAT::GNRT-? CAT::DFFR2 CAT::DEGR2 CAT::GNRT2)))) +; (DECLARE (FIXNUM CAT::DEGR1-1 CAT::DEGR2-1 CAT::SIGN) +; (LIST CAT::LIST1 CAT::LIST2)) +; (CAT::MAKE-CMBN :DEGR (1- CAT::DEGR) :LIST +; (NCONC (MAPCAR #'(LAMBDA # # #) CAT::LIST1) +; (MAPCAR #'(LAMBDA # # #) CAT::LIST2)))) +; +; caught WARNING: +; Derived type of +; T and NIL +; in +; (ODDP DEGR1) +; is +; (VALUES (MEMBER T NIL) &OPTIONAL), +; conflicting with their asserted type +; FIXNUM. +; See also: +; The SBCL Manual, Node "Handling of Types" + +; compiling (DEFMETHOD TNSR-PRDC ...) +; compiling (DEFUN TNSR-PRDC-INTR ...) +; compiling (DEFMETHOD TNSR-PRDC ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/tensor-products.lisp +; in: DEFMETHOD TNSR-PRDC (MORPHISM MORPHISM) +; (DEFMETHOD CAT::TNSR-PRDC +; ((CAT::MRPH1 CAT::MORPHISM) (CAT::MRPH2 CAT::MORPHISM)) +; (THE CAT::MORPHISM +; (WITH-SLOTS ((CAT::SORC1 CAT::SORC) (CAT::TRGT1 CAT::TRGT) +; (CAT::DEGR1 CAT::DEGR)) +; CAT::MRPH1 +; (WITH-SLOTS (# # #) +; CAT::MRPH2 +; (THE CAT::MORPHISM #))))) +; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER PROGN SB-PCL::LOAD-DEFMETHOD +; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION +; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS +; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* +; --> LOCALLY SYMBOL-MACROLET BLOCK THE LET SYMBOL-MACROLET LET SYMBOL-MACROLET + +; ==> +; (THE CAT::MORPHISM +; (PROGN +; (IF (AND (EQ 'CAT::IDNT-MRPH #) (EQ 'CAT::IDNT-MRPH #)) +; (PROGN (RETURN-FROM CAT::TNSR-PRDC #)) +; NIL) +; (IF (OR (EQ 'CAT::ZERO-MRPH #) (EQ 'CAT::ZERO-MRPH #)) +; (PROGN (RETURN-FROM CAT::TNSR-PRDC #)) +; NIL) +; (CAT::BUILD-MRPH :SORC +; (CAT::TNSR-PRDC +; (SB-PCL::ACCESSOR-SLOT-VALUE #:G363 'CAT::SORC) +; (SB-PCL::ACCESSOR-SLOT-VALUE #:G365 'CAT::SORC)) +; :TRGT +; (CAT::TNSR-PRDC +; (SB-PCL::ACCESSOR-SLOT-VALUE #:G363 'CAT::TRGT) +; (SB-PCL::ACCESSOR-SLOT-VALUE #:G365 'CAT::TRGT)) +; :DEGR +; (+ (SB-PCL::ACCESSOR-SLOT-VALUE #:G363 'CAT::DEGR) +; (SB-PCL::ACCESSOR-SLOT-VALUE #:G365 'CAT::DEGR)) +; :INTR (CAT::TNSR-PRDC-INTR CAT::MRPH1 CAT::MRPH2) +; :STRT :GNRT :ORGN ...))) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFMETHOD TNSR-PRDC ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/tensor-products.lisp +; in: DEFMETHOD TNSR-PRDC (REDUCTION REDUCTION) +; (DEFMETHOD CAT::TNSR-PRDC +; ((CAT::RDCT1 CAT::REDUCTION) (CAT::RDCT2 CAT::REDUCTION)) +; (THE CAT::REDUCTION +; (PROGN +; (WHEN (AND # #) (RETURN-FROM CAT::TNSR-PRDC #)) +; (WITH-SLOTS (# # # # #) +; CAT::RDCT1 +; (DECLARE # +; #) +; (WITH-SLOTS # +; CAT::RDCT2 +; # +; #))))) +; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER PROGN SB-PCL::LOAD-DEFMETHOD +; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION +; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS +; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* +; --> LOCALLY SYMBOL-MACROLET BLOCK +; ==> +; (THE CAT::REDUCTION +; (PROGN +; (WHEN (AND (EQ 'CAT::TRIVIAL-RDCT #) (EQ 'CAT::TRIVIAL-RDCT #)) +; (RETURN-FROM CAT::TNSR-PRDC (CAT::TRIVIAL-RDCT #))) +; (LET ((#:G386 CAT::RDCT1)) +; (DECLARE (IGNORABLE #:G386)) +; (DECLARE (SB-PCL::%VARIABLE-REBINDING #:G386 CAT::RDCT1)) +; #:G386 +; (SYMBOL-MACROLET (# # # # #) +; (DECLARE # +; #) +; (LET # +; # +; # +; #:G388 +; #))))) +; +; note: type assertion too complex to check: +; (VALUES REDUCTION &REST T). + +; compiling (DEFMETHOD TNSR-PRDC ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/tensor-products.lisp +; in: DEFMETHOD TNSR-PRDC (HOMOTOPY-EQUIVALENCE HOMOTOPY-EQUIVALENCE) +; (THE CAT::HOMOTOPY-EQUIVALENCE +; (CAT::BUILD-HMEQ :LRDCT +; (CAT::TNSR-PRDC (CAT::LRDCT CAT::HMEQ1) +; (CAT::LRDCT CAT::HMEQ2)) +; :RRDCT +; (CAT::TNSR-PRDC (CAT::RRDCT CAT::HMEQ1) +; (CAT::RRDCT CAT::HMEQ2)) +; :ORGN `(CAT::TNSR-PRDC ,CAT::HMEQ1 ,CAT::HMEQ2))) +; +; note: type assertion too complex to check: +; (VALUES HOMOTOPY-EQUIVALENCE &REST T). + +; compiling (DEFMETHOD SEARCH-EFHM ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/tensor-products.lisp +; in: DEFMETHOD SEARCH-EFHM (T (EQL 'TNSR-PRDC)) +; (THE CAT::HOMOTOPY-EQUIVALENCE +; (CAT::TNSR-PRDC (CAT::EFHM (SECOND (CAT::ORGN CAT::CHCM))) +; (CAT::EFHM (THIRD (CAT::ORGN CAT::CHCM))))) +; +; note: type assertion too complex to check: +; (VALUES HOMOTOPY-EQUIVALENCE &REST T). +; +; compilation unit finished +; caught 1 WARNING condition +; printed 12 notes + + +; C:/home/quicklisp/local-projects/kenzo/src/tensor-products.fasl written +; compilation finished in 0:00:00.445 +STYLE-WARNING: Implicitly creating new generic function CAT::TNSR-PRDC. +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/coalgebras.lisp" (w +ritten 26 DEC 2014 07:42:51 PM): +; compiling (IN-PACKAGE #:CAT) +; compiling (PROVIDE "coalgebras") +; compiling (DEFMETHOD PRINT-OBJECT ...) +; compiling (DEFUN CLGB ...) +; compiling (DEFUN BUILD-CLGB ...) +; compiling (DEFUN CHANGE-CHCM-TO-CLGB ...) + +; C:/home/quicklisp/local-projects/kenzo/src/coalgebras.fasl written +; compilation finished in 0:00:00.042 +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/cobar.lisp" (writte +n 25 DEC 2014 09:02:57 PM): +; compiling (IN-PACKAGE #:CAT) +; compiling (PROVIDE "cobar") +; compiling (DEFUN ALLP ...) +; compiling (DEFPARAMETER +NULL-ALLP+ ...) +; compiling (DEFUN ALLP-PRINT ...) +; compiling (DEFUN COBAR-CMPR ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/cobar.lisp +; in: DEFUN COBAR-CMPR +; (THE CAT::CMPR +; (LET ((CAT::LIST1 (CAT::ALLP-LIST CAT::ALLP1)) +; (CAT::LIST2 (CAT::ALLP-LIST CAT::ALLP2))) +; (DECLARE (TYPE CAT::IALLP CAT::LIST1 CAT::LIST2)) +; (CAT::LEXICO (CAT::F-CMPR (LENGTH CAT::LIST1) (LENGTH CAT::LIST2)) +; (CAT::MAPLEXICO #'(LAMBDA # #) CAT::LIST1 CAT::LIST2)) +)) +; +; note: type assertion too complex to check: +; (VALUES (MEMBER :LESS :EQUAL :GREATER) &REST T). + +; compiling (DEFUN COBAR-BASIS-LENGTH ...) +; compiling (DEFUN COBAR-BASIS ...) +; compiling (DEFUN COBAR-INTR-VRTC-DFFR ...) +; compiling (DEFMETHOD VRTC-COBAR ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/cobar.lisp +; in: DEFMETHOD VRTC-COBAR (CHAIN-COMPLEX) +; (DEFMETHOD CAT::VRTC-COBAR ((CAT::CHCM CAT::CHAIN-COMPLEX)) +; (THE CAT::CHAIN-COMPLEX +; (WITH-SLOTS (CAT::CMPR CAT::BASIS CAT::DFFR) +; CAT::CHCM +; (DECLARE (TYPE CAT::CMPRF CAT::CMPR) +; (TYPE CAT::BASIS CAT::BASIS) +; (TYPE CAT::MORPHISM CAT::DFFR)) +; (CAT::BUILD-CHCM :CMPR (CAT::COBAR-CMPR CAT::CMPR) :BASIS +; (CAT::COBAR-BASIS CAT::BASIS) :BSGN +; CAT::+NULL-ALLP+ :INTR-DFFR +; (CAT::COBAR-INTR-VRTC-DFFR CAT::DFFR) :STRT :GNR +T +; :ORGN ...)))) +; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER PROGN SB-PCL::LOAD-DEFMETHOD +; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION +; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS +; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* +; --> LOCALLY SYMBOL-MACROLET BLOCK +; ==> +; (THE CAT::CHAIN-COMPLEX +; (LET ((#:G297 CAT::CHCM)) +; (DECLARE (IGNORABLE #:G297)) +; (DECLARE (SB-PCL::%VARIABLE-REBINDING #:G297 CAT::CHCM)) +; #:G297 +; (SYMBOL-MACROLET ((CAT::CMPR #) (CAT::BASIS #) (CAT::DFFR #)) +; (DECLARE (TYPE CAT::CMPRF CAT::CMPR) +; (TYPE CAT::BASIS CAT::BASIS) +; (TYPE CAT::MORPHISM CAT::DFFR)) +; (CAT::BUILD-CHCM :CMPR (CAT::COBAR-CMPR #) :BASIS +; (CAT::COBAR-BASIS #) :BSGN CAT::+NULL-ALLP+ +; :INTR-DFFR (CAT::COBAR-INTR-VRTC-DFFR #) :STRT +; :GNRT :ORGN ...)))) +; +; note: type assertion too complex to check: +; (VALUES CHAIN-COMPLEX &REST T). + +; compiling (DEFUN COBAR-INTR-HRZN-DFFR ...) +; compiling (DEFUN COBAR-HRZN-DFFR ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/cobar.lisp +; in: DEFUN COBAR-HRZN-DFFR +; (THE CAT::MORPHISM +; (WITH-SLOTS (CAT::CPRD) +; CAT::CLGB +; (DECLARE (TYPE CAT::MORPHISM CAT::CPRD)) +; (CAT::BUILD-MRPH :SORC (CAT::VRTC-COBAR CAT::CLGB) :TRGT +; (CAT::VRTC-COBAR CAT::CLGB) :DEGR -1 :INTR +; (CAT::COBAR-INTR-HRZN-DFFR CAT::CPRD) :STRT :GNRT +; :ORGN ...))) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFUN COBAR-INTR-DFFR ...) +; compiling (DEFMETHOD COBAR ...) +; compiling (DEFUN CMBN-ALLP-CMBN-TNPR ...) +; compiling (DEFUN NCMBN-COBAR ...) +; compiling (DEFUN MRPH-VRTC-COBAR-INTR ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/cobar.lisp +; in: DEFUN MRPH-VRTC-COBAR-INTR +; (THE CAT::CMBN +; (CAT::NCMBN-COBAR +; (MAPCAR +; #'(LAMBDA (CAT::CBGN) (DECLARE #) (CAT::WITH-CBGN # CAT::CBGN #)) +; (CAT::ALLP-LIST CAT::ALLP)))) +; +; note: type assertion too complex to check: +; (VALUES CMBN &REST T). + +; compiling (DEFMETHOD VRTC-COBAR ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/cobar.lisp +; in: DEFMETHOD VRTC-COBAR (MORPHISM) +; (THE CAT::MORPHISM +; (IF (EQ (FIRST (CAT::ORGN CAT::MRPH)) 'CAT::IDNT-MRPH) +; (CAT::IDNT-MRPH (CAT::VRTC-COBAR (CAT::SORC CAT::MRPH))) +; (CAT::BUILD-MRPH :SORC (CAT::VRTC-COBAR (CAT::SORC CAT::MRPH)) :T +RGT +; (CAT::VRTC-COBAR (CAT::TRGT CAT::MRPH)) :DEGR 0 +; :INTR (CAT::MRPH-VRTC-COBAR-INTR CAT::MRPH) :STR +T +; :GNRT :ORGN ...))) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFUN HMTP-VRTC-COBAR-INTR ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/cobar.lisp +; in: DEFUN HMTP-VRTC-COBAR-INTR +; (LET* ((CAT::CBGN-LIST (REVERSE (CAT::ALLP-LIST CAT::ALLP))) +; (CAT::RSLT (LIST NIL)) +; (CAT::SIGN (ODDP (APPLY #'+ #))) +; (CAT::GFGF-TAIL (CAT::TERM-CMBN 0 1 CAT::+NULL-ALLP+))) +; (DECLARE (LIST CAT::CBGN-LIST CAT::RSLT) +; (FIXNUM CAT::SIGN) +; (TYPE CAT::CMBN CAT::GFGF-TAIL)) +; (UNLESS CAT::CBGN-LIST (RETURN-FROM CAT::RSLT (CAT::ZERO-CMBN 1))) +; (LOOP +; (LET ((CAT::CBGN #)) +; (DECLARE (TYPE CAT::CBGN CAT::CBGN)) +; (CAT::WITH-CBGN (CAT::DEGR CAT::GNRT) CAT::CBGN (WHEN # #) +; (INCF CAT::DEGR) +; (LET # +; # +; #) +; (UNLESS CAT::CBGN-LIST #) (SETF #)))) +; (CAT::MAKE-CMBN :DEGR (1+ CAT::DEGR) :LIST (REST CAT::RSLT))) +; +; note: deleting unreachable code + +; (NOT CAT::SIGN) +; --> IF +; ==> +; CAT::SIGN +; +; note: deleting unreachable code + +; (NCONC CAT::RSLT CAT::HGFGF) +; ==> +; CAT::RSLT +; +; note: deleting unreachable code + +; (UNLESS CAT::CBGN-LIST (RETURN)) +; --> IF +; ==> +; CAT::CBGN-LIST +; +; note: deleting unreachable code + +; (CAT::GNRT-? CAT::GF CAT::DEGR CAT::GNRT) +; ==> +; CAT::GF +; +; note: deleting unreachable code + +; (LET ((CAT::CBGN (CAR CAT::CBGN-LIST))) +; (DECLARE (TYPE CAT::CBGN CAT::CBGN)) +; (CAT::WITH-CBGN (CAT::DEGR CAT::GNRT) CAT::CBGN +; (WHEN (EVENP CAT::DEGR) (SETF CAT::SIGN #)) +; (INCF CAT::DEGR) +; (LET ((CAT::H-GNRT #)) +; (DECLARE (TYPE CAT::CMBN CAT::H-GNRT)) +; (LET (#) +; (DECLARE #) +; (WHEN CAT::SIGN #) +; (SETF #) +; (LET # +; # +; #) +; (NCONC CAT::RSLT CAT::HGFGF))) +; (UNLESS CAT::CBGN-LIST (RETURN)) +; (SETF CAT::GFGF-TAIL +; (CAT::CMBN-ALLP-CMBN-TNPR # CAT::GFGF-TAIL)))) +; +; note: deleting unreachable code +; +; note: deleting unreachable code + +; (EVENP CAT::DEGR) +; --> NOT IF LOGTEST +; ==> +; CAT::DEGR +; +; note: deleting unreachable code + +; (INCF CAT::DEGR) +; --> SETQ THE + +; ==> +; CAT::DEGR +; +; note: deleting unreachable code + +; (LET ((CAT::H-GNRT (CAT::GNRT-? CAT::H CAT::DEGR CAT::GNRT))) +; (DECLARE (TYPE CAT::CMBN CAT::H-GNRT)) +; (LET ((CAT::HGFGF (CAT::CMBN-LIST #))) +; (DECLARE (TYPE CAT::CMBN CAT::HGFGF)) +; (WHEN CAT::SIGN (MAPC #'(LAMBDA # # #) CAT::HGFGF)) +; (SETF CAT::CBGN-LIST (REST CAT::CBGN-LIST)) +; (LET ((CAT::HEAD #)) +; (DECLARE (LIST CAT::HEAD)) +; (MAPC #'(LAMBDA # #) CAT::HGFGF)) +; (NCONC CAT::RSLT CAT::HGFGF))) +; +; note: deleting unreachable code + +; (LET ((CAT::HGFGF +; (CAT::CMBN-LIST +; (CAT::CMBN-ALLP-CMBN-TNPR CAT::H-GNRT CAT::GFGF-TAIL)))) +; (DECLARE (TYPE CAT::CMBN CAT::HGFGF)) +; (WHEN CAT::SIGN +; (MAPC #'(LAMBDA (CAT::TERM) (DECLARE #) (SETF #)) CAT::HGFGF)) +; (SETF CAT::CBGN-LIST (REST CAT::CBGN-LIST)) +; (LET ((CAT::HEAD (REVERSE CAT::CBGN-LIST))) +; (DECLARE (LIST CAT::HEAD)) +; (MAPC #'(LAMBDA (CAT::TERM) (SETF #)) CAT::HGFGF)) +; (NCONC CAT::RSLT CAT::HGFGF)) +; +; note: deleting unreachable code + +; #'(LAMBDA (CAT::TERM) +; (DECLARE (TYPE CAT::TERM CAT::TERM)) +; (SETF (CAT::CFFC CAT::TERM) (- (CAT::CFFC CAT::TERM)))) +; +; note: deleting unreachable code + +; (MAPC +; #'(LAMBDA (CAT::TERM) +; (DECLARE (TYPE CAT::TERM CAT::TERM)) +; (SETF (CAT::CFFC CAT::TERM) (- #))) +; CAT::HGFGF) +; --> LET LET +; ==> +; CAT::HGFGF +; +; note: deleting unreachable code + +; (REST CAT::CBGN-LIST) +; --> CDR +; ==> +; CAT::CBGN-LIST +; +; note: deleting unreachable code + +; (LET ((CAT::HEAD (REVERSE CAT::CBGN-LIST))) +; (DECLARE (LIST CAT::HEAD)) +; (MAPC #'(LAMBDA (CAT::TERM) (SETF # #)) CAT::HGFGF)) +; +; note: deleting unreachable code + +; (MAPC #'(LAMBDA (CAT::TERM) (SETF (CAT::ALLP-LIST #) (APPEND CAT::HEAD #)) +) +; CAT::HGFGF) +; --> LET LET +; ==> +; CAT::HGFGF +; +; note: deleting unreachable code + +; (1+ CAT::DEGR) +; --> + +; ==> +; CAT::DEGR +; +; note: deleting unreachable code + +; (CAT::ZERO-CMBN 1) +; +; note: deleting unreachable code + +; (LET* ((CAT::CBGN-LIST (REVERSE (CAT::ALLP-LIST CAT::ALLP))) +; (CAT::RSLT (LIST NIL)) +; (CAT::SIGN (ODDP (APPLY #'+ #))) +; (CAT::GFGF-TAIL (CAT::TERM-CMBN 0 1 CAT::+NULL-ALLP+))) +; (DECLARE (LIST CAT::CBGN-LIST CAT::RSLT) +; (FIXNUM CAT::SIGN) +; (TYPE CAT::CMBN CAT::GFGF-TAIL)) +; (UNLESS CAT::CBGN-LIST (RETURN-FROM CAT::RSLT (CAT::ZERO-CMBN 1))) +; (LOOP +; (LET ((CAT::CBGN #)) +; (DECLARE (TYPE CAT::CBGN CAT::CBGN)) +; (CAT::WITH-CBGN (CAT::DEGR CAT::GNRT) CAT::CBGN (WHEN # #) +; (INCF CAT::DEGR) +; (LET # +; # +; #) +; (UNLESS CAT::CBGN-LIST #) (SETF #)))) +; (CAT::MAKE-CMBN :DEGR (1+ CAT::DEGR) :LIST (REST CAT::RSLT))) +; +; caught WARNING: +; Derived type of +; T and NIL +; in +; (ODDP (APPLY #'+ (MAPCAR #'CAR CBGN-LIST))) +; is +; (VALUES (MEMBER T NIL) &OPTIONAL), +; conflicting with their asserted type +; FIXNUM. +; See also: +; The SBCL Manual, Node "Handling of Types" + +; compiling (DEFUN HMTP-VRTC-COBAR ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/cobar.lisp +; in: DEFUN HMTP-VRTC-COBAR +; (THE CAT::MORPHISM +; (IF (EQ (FIRST (CAT::ORGN CAT::H)) 'CAT::ZERO-MRPH) +; (CAT::ZERO-MRPH (CAT::VRTC-COBAR (CAT::SORC CAT::H))) +; (CAT::BUILD-MRPH :SORC (CAT::VRTC-COBAR (CAT::SORC CAT::H)) :TRGT + +; (CAT::VRTC-COBAR (CAT::SORC CAT::H)) :DEGR 1 :IN +TR +; (CAT::HMTP-VRTC-COBAR-INTR CAT::H CAT::GF) :STRT + +; :GNRT :ORGN ...))) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFMETHOD VRTC-COBAR ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/cobar.lisp +; in: DEFMETHOD VRTC-COBAR (REDUCTION) +; (DEFMETHOD CAT::VRTC-COBAR ((CAT::RDCT CAT::REDUCTION)) +; (THE CAT::REDUCTION +; (IF (EQ (FIRST #) 'CAT::TRIVIAL-RDCT) +; (CAT::TRIVIAL-RDCT (CAT::VRTC-COBAR #)) +; (WITH-SLOTS (CAT::F CAT::G CAT::H) +; CAT::RDCT +; (CAT::BUILD-RDCT :F # :G # :H # :ORGN `#))))) +; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER PROGN SB-PCL::LOAD-DEFMETHOD +; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION +; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS +; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* +; --> LOCALLY SYMBOL-MACROLET BLOCK +; ==> +; (THE CAT::REDUCTION +; (IF (EQ (FIRST (CAT::ORGN CAT::RDCT)) 'CAT::TRIVIAL-RDCT) +; (CAT::TRIVIAL-RDCT (CAT::VRTC-COBAR (CAT::BCC CAT::RDCT))) +; (LET ((#:G634 CAT::RDCT)) +; (DECLARE (IGNORABLE #:G634)) +; (DECLARE (SB-PCL::%VARIABLE-REBINDING #:G634 CAT::RDCT)) +; #:G634 +; (SYMBOL-MACROLET (# # #) +; (CAT::BUILD-RDCT :F # :G # :H # :ORGN `#))))) +; +; note: type assertion too complex to check: +; (VALUES REDUCTION &REST T). + +; compiling (DEFMETHOD VRTC-COBAR ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/cobar.lisp +; in: DEFMETHOD VRTC-COBAR (HOMOTOPY-EQUIVALENCE) +; (DEFMETHOD CAT::VRTC-COBAR ((CAT::HMEQ CAT::HOMOTOPY-EQUIVALENCE)) +; (THE CAT::HOMOTOPY-EQUIVALENCE +; (IF (EQ (FIRST #) 'CAT::TRIVIAL-HMEQ) +; (CAT::TRIVIAL-HMEQ (CAT::VRTC-COBAR #)) +; (WITH-SLOTS (CAT::LRDCT CAT::RRDCT) +; CAT::HMEQ +; (CAT::BUILD-HMEQ :LRDCT # :RRDCT # :ORGN `#))))) +; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER PROGN SB-PCL::LOAD-DEFMETHOD +; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION +; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS +; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* +; --> LOCALLY SYMBOL-MACROLET BLOCK +; ==> +; (THE CAT::HOMOTOPY-EQUIVALENCE +; (IF (EQ (FIRST (CAT::ORGN CAT::HMEQ)) 'CAT::TRIVIAL-HMEQ) +; (CAT::TRIVIAL-HMEQ (CAT::VRTC-COBAR (CAT::LBCC CAT::HMEQ))) +; (LET ((#:G650 CAT::HMEQ)) +; (DECLARE (IGNORABLE #:G650)) +; (DECLARE (SB-PCL::%VARIABLE-REBINDING #:G650 CAT::HMEQ)) +; #:G650 +; (SYMBOL-MACROLET (# #) +; (CAT::BUILD-HMEQ :LRDCT # :RRDCT # :ORGN `#))))) +; +; note: type assertion too complex to check: +; (VALUES HOMOTOPY-EQUIVALENCE &REST T). + +; compiling (DEFMETHOD COBAR ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/cobar.lisp +; in: DEFMETHOD COBAR (HOMOTOPY-EQUIVALENCE) +; (THE CAT::HOMOTOPY-EQUIVALENCE +; (IF (EQ (FIRST (CAT::ORGN CAT::HMEQ)) 'CAT::TRIVIAL-HMEQ) +; (CAT::TRIVIAL-HMEQ (CAT::COBAR (CAT::LBCC CAT::HMEQ))) +; (CAT::ADD (CAT::VRTC-COBAR CAT::HMEQ) +; (CAT::COBAR-HRZN-DFFR (CAT::LBCC CAT::HMEQ))))) +; +; note: type assertion too complex to check: +; (VALUES HOMOTOPY-EQUIVALENCE &REST T). +; +; compilation unit finished +; caught 1 WARNING condition +; printed 27 notes + + +; C:/home/quicklisp/local-projects/kenzo/src/cobar.fasl written +; compilation finished in 0:00:00.621 +STYLE-WARNING: Implicitly creating new generic function CAT::VRTC-COBAR. +STYLE-WARNING: Implicitly creating new generic function CAT::COBAR. +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/algebras.lisp" (wri +tten 26 DEC 2014 07:44:40 PM): +; compiling (IN-PACKAGE #:CAT) +; compiling (PROVIDE "algebras") +; compiling (DEFMETHOD PRINT-OBJECT ...) +; compiling (DEFUN ALGB ...) +; compiling (DEFUN BUILD-ALGB ...) +; compiling (DEFUN CHANGE-CHCM-TO-ALGB ...) +; compiling (DEFMETHOD PRINT-OBJECT ...) +; compiling (DEFUN HOPF ...) + +; C:/home/quicklisp/local-projects/kenzo/src/algebras.fasl written +; compilation finished in 0:00:00.055 +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/bar.lisp" (written +25 DEC 2014 09:02:01 PM): +; compiling (IN-PACKAGE #:CAT) +; compiling (PROVIDE "bar") +; compiling (DEFUN ABAR ...) +; compiling (DEFPARAMETER +NULL-ABAR+ ...) +; compiling (DEFUN ABAR-PRINT ...) +; compiling (DEFUN BAR-CMPR ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/bar.lisp +; in: DEFUN BAR-CMPR +; (THE CAT::CMPR +; (LET ((CAT::LIST1 (CAT::ABAR-LIST CAT::ABAR1)) +; (CAT::LIST2 (CAT::ABAR-LIST CAT::ABAR2))) +; (DECLARE (LIST CAT::LIST1 CAT::LIST2)) +; (CAT::LEXICO (CAT::F-CMPR (LENGTH CAT::LIST1) (LENGTH CAT::LIST2)) +; (CAT::MAPLEXICO #'(LAMBDA # #) CAT::LIST1 CAT::LIST2)) +)) +; +; note: type assertion too complex to check: +; (VALUES (MEMBER :LESS :EQUAL :GREATER) &REST T). + +; compiling (DEFUN BAR-BASIS-LENGTH ...) +; compiling (DEFUN BAR-BASIS ...) +; compiling (DEFUN BAR-INTR-VRTC-DFFR ...) +; compiling (DEFMETHOD VRTC-BAR ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/bar.lisp +; in: DEFMETHOD VRTC-BAR (CHAIN-COMPLEX) +; (DEFMETHOD CAT::VRTC-BAR ((CAT::CHCM CAT::CHAIN-COMPLEX)) +; (THE CAT::CHAIN-COMPLEX +; (WITH-SLOTS (CAT::CMPR CAT::BASIS CAT::DFFR) +; CAT::CHCM +; (DECLARE (TYPE CAT::CMPRF CAT::CMPR) +; (TYPE CAT::BASIS CAT::BASIS) +; (TYPE CAT::MORPHISM CAT::DFFR)) +; (CAT::BUILD-CHCM :CMPR (CAT::BAR-CMPR CAT::CMPR) :BASIS +; (CAT::BAR-BASIS CAT::BASIS) :BSGN CAT::+NULL-ABA +R+ +; :INTR-DFFR (CAT::BAR-INTR-VRTC-DFFR CAT::DFFR) +; :STRT :GNRT :ORGN ...)))) +; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER PROGN SB-PCL::LOAD-DEFMETHOD +; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION +; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS +; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* +; --> LOCALLY SYMBOL-MACROLET BLOCK +; ==> +; (THE CAT::CHAIN-COMPLEX +; (LET ((#:G283 CAT::CHCM)) +; (DECLARE (IGNORABLE #:G283)) +; (DECLARE (SB-PCL::%VARIABLE-REBINDING #:G283 CAT::CHCM)) +; #:G283 +; (SYMBOL-MACROLET ((CAT::CMPR #) (CAT::BASIS #) (CAT::DFFR #)) +; (DECLARE (TYPE CAT::CMPRF CAT::CMPR) +; (TYPE CAT::BASIS CAT::BASIS) +; (TYPE CAT::MORPHISM CAT::DFFR)) +; (CAT::BUILD-CHCM :CMPR (CAT::BAR-CMPR #) :BASIS (CAT::BAR-BASIS #) +; :BSGN CAT::+NULL-ABAR+ :INTR-DFFR +; (CAT::BAR-INTR-VRTC-DFFR #) :STRT :GNRT :ORGN +; ...)))) +; +; note: type assertion too complex to check: +; (VALUES CHAIN-COMPLEX &REST T). + +; compiling (DEFUN BAR-INTR-HRZN-DFFR ...) +; compiling (DEFUN BAR-HRZN-DFFR ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/bar.lisp +; in: DEFUN BAR-HRZN-DFFR +; (THE CAT::MORPHISM +; (WITH-SLOTS (CAT::APRD) +; CAT::ALGB +; (DECLARE (TYPE CAT::MORPHISM CAT::APRD)) +; (CAT::BUILD-MRPH :SORC (CAT::VRTC-BAR CAT::ALGB) :TRGT +; (CAT::VRTC-BAR CAT::ALGB) :DEGR -1 :INTR +; (CAT::BAR-INTR-HRZN-DFFR CAT::APRD) :STRT :GNRT :O +RGN +; ...))) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFUN BAR-INTR-DFFR ...) +; compiling (DEFMETHOD BAR ...) +; compiling (DEFUN CMBN-ABAR-CMBN-TNPR ...) +; compiling (DEFUN NCMBN-BAR ...) +; compiling (DEFUN MRPH-VRTC-BAR-INTR ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/bar.lisp +; in: DEFUN MRPH-VRTC-BAR-INTR +; (THE CAT::CMBN +; (CAT::NCMBN-BAR +; (MAPCAR +; #'(LAMBDA (CAT::BRGN) (DECLARE #) (CAT::WITH-BRGN # CAT::BRGN #)) +; (CAT::ABAR-LIST CAT::ABAR)))) +; +; note: type assertion too complex to check: +; (VALUES CMBN &REST T). + +; compiling (DEFMETHOD VRTC-BAR ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/bar.lisp +; in: DEFMETHOD VRTC-BAR (MORPHISM) +; (THE CAT::MORPHISM +; (IF (EQ (FIRST (CAT::ORGN CAT::MRPH)) 'CAT::IDNT-MRPH) +; (CAT::IDNT-MRPH (CAT::VRTC-BAR (CAT::SORC CAT::MRPH))) +; (CAT::BUILD-MRPH :SORC (CAT::VRTC-BAR (CAT::SORC CAT::MRPH)) :TRG +T +; (CAT::VRTC-BAR (CAT::TRGT CAT::MRPH)) :DEGR 0 :I +NTR +; (CAT::MRPH-VRTC-BAR-INTR CAT::MRPH) :STRT :GNRT +; :ORGN ...))) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFUN HMTP-VRTC-BAR-INTR ...) +; compiling (DEFUN HMTP-VRTC-BAR ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/bar.lisp +; in: DEFUN HMTP-VRTC-BAR +; (THE CAT::MORPHISM +; (IF (EQ (FIRST (CAT::ORGN CAT::H)) 'CAT::ZERO-MRPH) +; (CAT::ZERO-MRPH (CAT::VRTC-BAR (CAT::SORC CAT::H))) +; (CAT::BUILD-MRPH :SORC (CAT::VRTC-BAR (CAT::SORC CAT::H)) :TRGT +; (CAT::VRTC-BAR (CAT::SORC CAT::H)) :DEGR 1 :INTR + +; (CAT::HMTP-VRTC-BAR-INTR CAT::H CAT::GF) :STRT +; :GNRT :ORGN ...))) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFMETHOD VRTC-BAR ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/bar.lisp +; in: DEFMETHOD VRTC-BAR (REDUCTION) +; (DEFMETHOD CAT::VRTC-BAR ((CAT::RDCT CAT::REDUCTION)) +; (THE CAT::REDUCTION +; (IF (EQ (FIRST #) 'CAT::TRIVIAL-RDCT) +; (CAT::TRIVIAL-RDCT (CAT::VRTC-BAR #)) +; (WITH-SLOTS (CAT::F CAT::G CAT::H) +; CAT::RDCT +; (CAT::BUILD-RDCT :F # :G # :H # :ORGN `#))))) +; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER PROGN SB-PCL::LOAD-DEFMETHOD +; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION +; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS +; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* +; --> LOCALLY SYMBOL-MACROLET BLOCK +; ==> +; (THE CAT::REDUCTION +; (IF (EQ (FIRST (CAT::ORGN CAT::RDCT)) 'CAT::TRIVIAL-RDCT) +; (CAT::TRIVIAL-RDCT (CAT::VRTC-BAR (CAT::BCC CAT::RDCT))) +; (LET ((#:G669 CAT::RDCT)) +; (DECLARE (IGNORABLE #:G669)) +; (DECLARE (SB-PCL::%VARIABLE-REBINDING #:G669 CAT::RDCT)) +; #:G669 +; (SYMBOL-MACROLET (# # #) +; (CAT::BUILD-RDCT :F # :G # :H # :ORGN `#))))) +; +; note: type assertion too complex to check: +; (VALUES REDUCTION &REST T). + +; compiling (DEFMETHOD VRTC-BAR ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/bar.lisp +; in: DEFMETHOD VRTC-BAR (HOMOTOPY-EQUIVALENCE) +; (DEFMETHOD CAT::VRTC-BAR ((CAT::HMEQ CAT::HOMOTOPY-EQUIVALENCE)) +; (THE CAT::HOMOTOPY-EQUIVALENCE +; (IF (EQ (FIRST #) 'CAT::TRIVIAL-HMEQ) +; (CAT::TRIVIAL-HMEQ (CAT::VRTC-BAR #)) +; (WITH-SLOTS (CAT::LRDCT CAT::RRDCT) +; CAT::HMEQ +; (CAT::BUILD-HMEQ :LRDCT # :RRDCT # :ORGN `#))))) +; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER PROGN SB-PCL::LOAD-DEFMETHOD +; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION +; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS +; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* +; --> LOCALLY SYMBOL-MACROLET BLOCK +; ==> +; (THE CAT::HOMOTOPY-EQUIVALENCE +; (IF (EQ (FIRST (CAT::ORGN CAT::HMEQ)) 'CAT::TRIVIAL-HMEQ) +; (CAT::TRIVIAL-HMEQ (CAT::VRTC-BAR (CAT::LBCC CAT::HMEQ))) +; (LET ((#:G685 CAT::HMEQ)) +; (DECLARE (IGNORABLE #:G685)) +; (DECLARE (SB-PCL::%VARIABLE-REBINDING #:G685 CAT::HMEQ)) +; #:G685 +; (SYMBOL-MACROLET (# #) +; (CAT::BUILD-HMEQ :LRDCT # :RRDCT # :ORGN `#))))) +; +; note: type assertion too complex to check: +; (VALUES HOMOTOPY-EQUIVALENCE &REST T). + +; compiling (DEFMETHOD BAR ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/bar.lisp +; in: DEFMETHOD BAR (HOMOTOPY-EQUIVALENCE) +; (THE CAT::HOMOTOPY-EQUIVALENCE +; (IF (EQ (FIRST (CAT::ORGN CAT::HMEQ)) 'CAT::TRIVIAL-HMEQ) +; (CAT::TRIVIAL-HMEQ (CAT::BAR (CAT::LBCC CAT::HMEQ))) +; (CAT::ADD (CAT::VRTC-BAR CAT::HMEQ) +; (CAT::BAR-HRZN-DFFR (CAT::LBCC CAT::HMEQ))))) +; +; note: type assertion too complex to check: +; (VALUES HOMOTOPY-EQUIVALENCE &REST T). +; +; compilation unit finished +; printed 9 notes + + +; C:/home/quicklisp/local-projects/kenzo/src/bar.fasl written +; compilation finished in 0:00:00.385 +STYLE-WARNING: Implicitly creating new generic function CAT::VRTC-BAR. +STYLE-WARNING: Implicitly creating new generic function CAT::BAR. +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/simplicial-sets.lis +p" (written 26 DEC 2014 07:46:13 PM): +; compiling (IN-PACKAGE #:CAT) +; compiling (PROVIDE "simplicial-sets") +; compiling (DEFUN DGOP-EXT-INT ...) +; compiling (DEFUN DGOP-INT-EXT ...) +; compiling (DEFUN HYPHENIZE-LIST ...) +; compiling (DEFUN ABSM-PRINT ...) +; compiling (DEFUN FACE4 ...) +; compiling (DEFMETHOD PRINT-OBJECT ...) +; compiling (DEFUN SMST ...) +; compiling (DEFUN BUILD-SMST ...) +; compiling (DEFUN A-BASIS2 ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/simplicial-sets.lisp +; in: DEFUN A-BASIS2 +; (MAKE-ARRAY (1+ CAT::DMNS) :ELEMENT-TYPE 'LIST) +; --> LOCALLY +; ==> +; (MAKE-ARRAY (1+ CAT::DMNS) :ELEMENT-TYPE 'LIST) +; +; caught STYLE-WARNING: +; The default initial element 0 is not a LIST. + +; compiling (DEFUN INTR-DIAGONAL ...) +; compiling (DEFUN FACE-BNDR ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/simplicial-sets.lisp +; in: DEFUN FACE-BNDR +; (THE CAT::CMBN +; (PROGN +; (WHEN (ZEROP CAT::DMNS) +; (RETURN-FROM CAT::RSLT CAT::+ZERO-NEGATIVE-CMBN+)) +; (LET ((CAT::PRE-RSLT CAT::+EMPTY-LIST+)) +; (DECLARE (LIST CAT::PRE-RSLT)) +; (DOTIMES (CAT::INDX #) +; (DECLARE #) +; (LET # +; # +; #)) +; (APPLY #'CAT::NTERM-ADD CAT::CMPR (1- CAT::DMNS) CAT::PRE-RSLT)))) + +; +; note: type assertion too complex to check: +; (VALUES CMBN &REST T). + +; compiling (DEFUN FACE*-BNDR ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/simplicial-sets.lisp +; in: DEFUN FACE*-BNDR +; (THE CAT::CMBN +; (PROGN +; (WHEN (ZEROP CAT::DMNS) +; (RETURN-FROM CAT::RSLT CAT::+ZERO-NEGATIVE-CMBN+)) +; (LET ((CAT::PRE-RSLT CAT::+EMPTY-LIST+)) +; (DECLARE (LIST CAT::PRE-RSLT)) +; (DOTIMES (CAT::INDX #) +; (DECLARE #) +; (LET # +; # +; #)) +; (APPLY #'CAT::NTERM-ADD CAT::CMPR (1- CAT::DMNS) CAT::PRE-RSLT)))) + +; +; note: type assertion too complex to check: +; (VALUES CMBN &REST T). + +; compiling (DEFUN A-CMPR3 ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/simplicial-sets.lisp +; in: DEFUN A-CMPR3 +; (THE CAT::CMPR +; (CAT::WITH-ABSM (CAT::DGOP1 CAT::GMSM1) CAT::ABSM1 +; (CAT::WITH-ABSM (CAT::DGOP2 CAT::GMSM2) CAT::ABSM2 +; (CAT::LEXICO +; (CAT::F-CMPR CAT::DGOP1 CAT::DGOP2) +; (FUNCALL CAT::CMPR CAT::GMSM1 +; CAT::GMSM2))))) +; +; note: type assertion too complex to check: +; (VALUES (MEMBER :LESS :EQUAL :GREATER) &REST T). + +; compiling (DEFUN BSPN-P ...) +; compiling (DEFUN DLOP-EXT-INT ...) +; compiling (DEFUN DLOP-INT-EXT ...) +; compiling (DEFUN 1DGOP*DGOP ...) +; compiling (DEFUN DGOP*DGOP ...) +; compiling (DEFUN REMOVE-BIT ...) +; compiling (DEFUN DGOP/DGOP ...) +; compiling (DEFUN 1DLOP-DGOP ...) +; compiling (DEFUN A-FACE4 ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/simplicial-sets.lisp +; in: DEFUN A-FACE4 +; (CAT::ABSM CAT::DGOP2 CAT::GMSM) +; --> CAT::MAKE-ABSM +; ==> +; CAT::DGOP2 +; +; note: deleting unreachable code + +; compiling (DEFUN 1DGNR ...) +; compiling (DEFUN NDGNR ...) +; compiling (DEFUN NFACE ...) +; compiling (DEFUN CHECK-FACES ...) +; compiling (DEFUN CHECK-SMST ...); +; compilation unit finished +; caught 1 STYLE-WARNING condition +; printed 4 notes + + +; C:/home/quicklisp/local-projects/kenzo/src/simplicial-sets.fasl written +; compilation finished in 0:00:00.255 +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/simplicial-mrphs.li +sp" (written 26 DEC 2014 07:47:43 PM): +; compiling (IN-PACKAGE #:CAT) +; compiling (PROVIDE "simplicial-mrphs") +; compiling (DEFMETHOD ?3 ...) +; compiling (DEFMETHOD PRINT-OBJECT ...) +; compiling (DEFUN SMMR ...) +; compiling (DEFUN SINTR-INTR ...) +; compiling (DEFUN BUILD-SMMR ...) +; compiling (DEFUN TW-A-SINTR3 ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/simplicial-mrphs.lisp +; in: DEFUN TW-A-SINTR3 +; (THE CAT::ABSM +; (CAT::WITH-ABSM (CAT::DGOP CAT::GMSM) CAT::ABSM +; (LET ((CAT::DMNS-1 #)) +; (DECLARE (FIXNUM CAT::DMNS-1)) +; (IF (LOGBITP CAT::DMNS-1 CAT::DGOP) +; (CAT::ABSM # CAT::BSPN) +; (CAT::NDGNR CAT::DGOP #))))) +; +; note: type assertion too complex to check: +; (VALUES ABSM &REST T). +; +; compilation unit finished +; printed 1 note + + +; C:/home/quicklisp/local-projects/kenzo/src/simplicial-mrphs.fasl written +; compilation finished in 0:00:00.069 +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/delta.lisp" (writte +n 24 DEC 2014 10:50:38 PM): +; compiling (IN-PACKAGE #:CAT) +; compiling (PROVIDE "delta") +; compiling (DEFMETHOD PRINT-KEYCONS ...) +; compiling (DEFUN SOFT-DELTA-CMPR ...) +; compiling (DEFUN DELTA-FACE ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/delta.lisp +; in: DEFUN DELTA-FACE +; (THE CAT::ABSM +; (DO ((CAT::PMARK 1 (ASH CAT::PMARK 1)) +; (CAT::BMARK CAT::INDX) +; (CAT::GMSM2 CAT::GMSM (ASH CAT::GMSM2 -1))) +; (NIL) +; (DECLARE (FIXNUM CAT::PMARK CAT::BMARK CAT::GMSM2)) +; (WHEN (ODDP CAT::GMSM2) +; (WHEN (MINUSP #) (RETURN-FROM CAT::DELTA-FACE #))))) +; +; note: deleting unreachable code + +; compiling (DEFUN SOFT-DELTA-FACE ...) +; compiling (DEFUN DELTA-BNDR ...) +; compiling (DEFUN SOFT-DELTA-BNDR ...) +; compiling (DEFUN DELTA-DGNL ...) +; compiling (DEFUN SOFT-DELTA-DGNL ...) +; compiling (DEFUN DELTA-INFINITY ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/delta.lisp +; in: DEFUN DELTA-INFINITY +; (THE CAT::SIMPLICIAL-SET +; (CAT::BUILD-SMST :CMPR #'CAT::F-CMPR :BASIS :LOCALLY-EFFECTIVE :BSPN +1 +; :FACE #'CAT::DELTA-FACE :INTR-DGNL #'CAT::DELTA-DGNL + +; :DGNL-STRT ...)) +; +; note: type assertion too complex to check: +; (VALUES SIMPLICIAL-SET &REST T). + +; compiling (DEFUN SOFT-DELTA-INFINITY ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/delta.lisp +; in: DEFUN SOFT-DELTA-INFINITY +; (THE CAT::SIMPLICIAL-SET +; (CAT::BUILD-SMST :CMPR #'CAT::SOFT-DELTA-CMPR :BASIS :LOCALLY-EFFECTI +VE +; :BSPN (CAT::D 1) :FACE #'CAT::SOFT-DELTA-FACE +; :INTR-DGNL #'CAT::SOFT-DELTA-DGNL :DGNL-STRT ...)) +; +; note: type assertion too complex to check: +; (VALUES SIMPLICIAL-SET &REST T). + +; compiling (DEFUN DELTA-N-BASIS ...) +; compiling (DEFUN SOFT-DELTA-N-BASIS ...) +; compiling (DEFUN DELTA ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/delta.lisp +; in: DEFUN DELTA +; (THE CAT::SIMPLICIAL-SET +; (CAT::BUILD-SMST :CMPR #'CAT::F-CMPR :BASIS +; (CAT::DELTA-N-BASIS CAT::DMNS) :BSPN 1 :FACE +; #'CAT::DELTA-FACE :INTR-DGNL #'CAT::DELTA-DGNL +; :DGNL-STRT ...)) +; +; note: type assertion too complex to check: +; (VALUES SIMPLICIAL-SET &REST T). + +; compiling (DEFUN SOFT-DELTA ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/delta.lisp +; in: DEFUN SOFT-DELTA +; (THE CAT::SIMPLICIAL-SET +; (CAT::BUILD-SMST :CMPR #'CAT::SOFT-DELTA-CMPR :BASIS +; (CAT::SOFT-DELTA-N-BASIS CAT::DMNS) :BSPN (CAT::D 1) + +; :FACE #'CAT::SOFT-DELTA-FACE :INTR-DGNL +; #'CAT::SOFT-DELTA-DGNL :DGNL-STRT ...)) +; +; note: type assertion too complex to check: +; (VALUES SIMPLICIAL-SET &REST T). + +; compiling (DEFUN DELTAB-CMPR ...) +; compiling (DEFUN DELTAB-BNDR ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/delta.lisp +; in: DEFUN DELTAB-BNDR +; (THE CAT::CMBN +; (IF (< CAT::DMNS 2) +; (CAT::ZERO-CMBN (1- CAT::DMNS)) +; (CAT::MAKE-CMBN :DEGR (1- CAT::DMNS) :LIST +; (DO (# +; # +; # +; #) +; (# CAT::RSLT) +; (DECLARE # +; #) +; (WHEN # # #))))) +; +; note: type assertion too complex to check: +; (VALUES CMBN &REST T). + +; compiling (DEFUN DELTAB2-FACE ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/delta.lisp +; in: DEFUN DELTAB2-FACE +; (THE CAT::ABSM +; (PROGN +; (WHEN (= 2 CAT::DMNS) (RETURN-FROM CAT::DELTAB2-FACE (CAT::ABSM 1 1) +)) +; (DO ((CAT::PMARK 1 #) +; (CAT::BMARK CAT::INDX) +; (CAT::GMSM2 CAT::GMSM #)) +; (NIL) +; (DECLARE (FIXNUM CAT::PMARK CAT::BMARK CAT::GMSM2)) +; (WHEN (ODDP CAT::GMSM2) (WHEN # #))))) +; +; note: deleting unreachable code + +; compiling (DEFUN DELTAB2-DGNL ...) +; compiling (DEFUN DELTAB2-BNDR ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/delta.lisp +; in: DEFUN DELTAB2-BNDR +; (THE CAT::CMBN +; (IF (< CAT::DMNS 3) +; (CAT::ZERO-CMBN (1- CAT::DMNS)) +; (CAT::MAKE-CMBN :DEGR (1- CAT::DMNS) :LIST +; (DO (# +; # +; # +; #) +; (# CAT::RSLT) +; (DECLARE # +; #) +; (WHEN # # #))))) +; +; note: type assertion too complex to check: +; (VALUES CMBN &REST T). + +; compiling (DEFUN DELTAB ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/delta.lisp +; in: DEFUN DELTAB +; (THE CAT::SIMPLICIAL-SET +; (CAT::BUILD-SMST :CMPR #'CAT::DELTAB-CMPR :BASIS :LOCALLY-EFFECTIVE +; :BSPN 1 :FACE #'CAT::DELTA-FACE :INTR-DGNL +; #'CAT::DELTA-DGNL :DGNL-STRT ...)) +; +; note: type assertion too complex to check: +; (VALUES SIMPLICIAL-SET &REST T). + +; compiling (DEFUN DELTAB2 ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/delta.lisp +; in: DEFUN DELTAB2 +; (THE CAT::SIMPLICIAL-SET +; (CAT::BUILD-SMST :CMPR #'CAT::F-CMPR :BASIS :LOCALLY-EFFECTIVE :BSPN +1 +; :FACE #'CAT::DELTAB2-FACE :INTR-DGNL +; #'CAT::DELTAB2-DGNL :DGNL-STRT ...)) +; +; note: type assertion too complex to check: +; (VALUES SIMPLICIAL-SET &REST T). +; +; compilation unit finished +; printed 10 notes + + +; C:/home/quicklisp/local-projects/kenzo/src/delta.fasl written +; compilation finished in 0:00:00.261 +STYLE-WARNING: Implicitly creating new generic function CAT::PRINT-KEYCONS. +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/special-smsts.lisp" + (written 24 DEC 2014 10:51:30 PM): +; compiling (IN-PACKAGE #:CAT) +; compiling (PROVIDE "special-smsts") +; compiling (DEFUN FINITE-SS-PRE-TABLE ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/special-smsts.lisp +; in: DEFUN FINITE-SS-PRE-TABLE +; (ERROR "In BUILD-FINITE-SS, the argument ~A does not make sense." CAT::ITE +M) +; ==> +; "In BUILD-FINITE-SS, the argument ~A does not make sense." +; +; note: deleting unreachable code +; +; note: deleting unreachable code + +; compiling (DEFUN FINITE-SS-PRE-TABLE-TABLE ...) +; compiling (DEFUN FINITE-SS-FIND-GMSM ...) +; compiling (DEFUN FINITE-SS-FINISH-TABLE ...) +; compiling (DEFUN FINITE-SS-FINISH-LINE ...) +; compiling (DEFUN FINITE-SS-FINISH-ENTRY ...) +; compiling (DEFUN FINITE-SS-TABLE ...) +; compiling (DEFUN FINITE-SS-BASIS ...) +; compiling (DEFUN FINITE-SS-FACE ...) +; compiling (DEFUN FINITE-SS-INTR-BNDR ...) +; compiling (DEFUN BUILD-FINITE-SS ...) +; compiling (DEFUN SPHERE-CMPR ...) +; compiling (DEFUN SPHERE-BASIS ...) +; compiling (DEFUN SPHERE-FACE ...) +; compiling (DEFUN SPHERE ...) +; compiling (DEFUN SPHERE-WEDGE-BASIS ...) +; compiling (DEFUN SPHERE-WEDGE-FACE ...) +; compiling (DEFUN SPHERE-WEDGE ...) +; compiling (DEFUN MOORE-CMPR ...) +; compiling (DEFUN MOORE-BASIS ...) +; compiling (DEFUN MOORE-FACE ...) +; compiling (DEFUN MOORE-INTR-BNDR ...) +; compiling (DEFUN MOORE ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/special-smsts.lisp +; in: DEFUN MOORE +; (THE CAT::SIMPLICIAL-SET +; (CAT::BUILD-SMST :CMPR #'CAT::MOORE-CMPR :BASIS +; (CAT::MOORE-BASIS CAT::DMNS) :FACE +; (CAT::MOORE-FACE CAT::PII CAT::DMNS) :INTR-BNDR +; (CAT::MOORE-INTR-BNDR CAT::PII CAT::DMNS) :BNDR-STRT + +; :CMBN :ORGN ...)) +; +; note: type assertion too complex to check: +; (VALUES SIMPLICIAL-SET &REST T). + +; compiling (DEFUN R-PROJ-SPACE-CMPR ...) +; compiling (DEFUN R-PROJ-SPACE-BASIS ...) +; compiling (DEFUN R-PROJ-SPACE-FACE ...) +; compiling (DEFUN R-PROJ-SPACE-INTR-BNDR ...) +; compiling (DEFUN R-PROJ-SPACE ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/special-smsts.lisp +; in: DEFUN R-PROJ-SPACE +; (THE CAT::SIMPLICIAL-SET +; (CAT::BUILD-SMST :CMPR #'CAT::R-PROJ-SPACE-CMPR :BASIS +; (CAT::R-PROJ-SPACE-BASIS CAT::K CAT::L) :BSPN 0 :FAC +E +; (CAT::R-PROJ-SPACE-FACE CAT::K) :INTR-BNDR +; (CAT::R-PROJ-SPACE-INTR-BNDR CAT::K) :BNDR-STRT ...) +) +; +; note: type assertion too complex to check: +; (VALUES SIMPLICIAL-SET &REST T). + +; compiling (DEFUN CMBN-GMSMS ...) +; compiling (DEFUN GMSMS-SUBSMST ...); +; compilation unit finished +; printed 4 notes + + +; C:/home/quicklisp/local-projects/kenzo/src/special-smsts.fasl written +; compilation finished in 0:00:00.208 +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/suspensions.lisp" ( +written 24 DEC 2014 10:57:09 PM): +; compiling (IN-PACKAGE #:CAT) +; compiling (PROVIDE "suspensions") +; compiling (DEFUN SUSPENSION-CMPR ...) +; compiling (DEFUN SUSPENSION-BASIS ...) +; compiling (DEFUN SUSPENSION-INTR-DFFR ...) +; compiling (DEFUN SUSPENSION ...) +; compiling (DEFMETHOD SUSPENSION-1 ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/suspensions.lisp +; in: DEFMETHOD SUSPENSION-1 (CHAIN-COMPLEX) +; (DEFMETHOD CAT::SUSPENSION-1 ((CAT::CHCM CAT::CHAIN-COMPLEX)) +; (THE CAT::CHAIN-COMPLEX +; (WITH-SLOTS (CAT::CMPR CAT::BASIS CAT::DFFR) +; CAT::CHCM +; (CAT::BUILD-CHCM :CMPR (CAT::SUSPENSION-CMPR CAT::CMPR) :BASIS +; (CAT::SUSPENSION-BASIS CAT::BASIS) :BSGN :S-BSGN + +; :INTR-DFFR (CAT::SUSPENSION-INTR-DFFR CAT::DFFR) + +; :STRT :CMBN :ORGN ...)))) +; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER PROGN SB-PCL::LOAD-DEFMETHOD +; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION +; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS +; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* +; --> LOCALLY SYMBOL-MACROLET BLOCK +; ==> +; (THE CAT::CHAIN-COMPLEX +; (LET ((#:G66 CAT::CHCM)) +; (DECLARE (IGNORABLE #:G66)) +; (DECLARE (SB-PCL::%VARIABLE-REBINDING #:G66 CAT::CHCM)) +; #:G66 +; (SYMBOL-MACROLET ((CAT::CMPR #) (CAT::BASIS #) (CAT::DFFR #)) +; (CAT::BUILD-CHCM :CMPR (CAT::SUSPENSION-CMPR #) :BASIS +; (CAT::SUSPENSION-BASIS #) :BSGN :S-BSGN :INTR-DFFR + +; (CAT::SUSPENSION-INTR-DFFR #) :STRT :CMBN :ORGN +; ...)))) +; +; note: type assertion too complex to check: +; (VALUES CHAIN-COMPLEX &REST T). + +; compiling (DEFUN SUSPENSION-INTR-CPRD ...) +; compiling (DEFMETHOD SUSPENSION-1 ...) +; compiling (DEFUN SUSPENSION-FACE ...) +; compiling (DEFMETHOD SUSPENSION-1 ...) +; compiling (DEFUN SUSPENSION-INTR ...) +; compiling (DEFMETHOD SUSPENSION-1 ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/suspensions.lisp +; in: DEFMETHOD SUSPENSION-1 (MORPHISM) +; (THE CAT::MORPHISM +; (LET ((CAT::ORGN (CAT::ORGN CAT::MRPH))) +; (DECLARE (LIST CAT::ORGN)) +; (WHEN (EQ (FIRST CAT::ORGN) 'CAT::ZERO-MRPH) +; (RETURN-FROM CAT::SUSPENSION-1 (CAT::ZERO-MRPH # # #))) +; (WHEN (EQ (FIRST CAT::ORGN) 'CAT::IDNT-MRPH) +; (RETURN-FROM CAT::SUSPENSION-1 (CAT::IDNT-MRPH #))) +; (CAT::BUILD-MRPH :SORC (CAT::SUSPENSION (CAT::SORC CAT::MRPH)) :TRG +T +; (CAT::SUSPENSION (CAT::TRGT CAT::MRPH)) :DEGR +; (CAT::DEGR CAT::MRPH) :INTR +; (CAT::SUSPENSION-INTR CAT::MRPH) :STRT :CMBN :ORGN + +; ...))) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFMETHOD SUSPENSION-1 ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/suspensions.lisp +; in: DEFMETHOD SUSPENSION-1 (REDUCTION) +; (THE CAT::REDUCTION +; (PROGN +; (WHEN (EQ (FIRST #) 'CAT::TRIVIAL-RDCT) +; (RETURN-FROM CAT::SUSPENSION-1 (CAT::TRIVIAL-RDCT #))) +; (CAT::BUILD-RDCT :F (CAT::SUSPENSION (CAT::F CAT::RDCT)) :G +; (CAT::SUSPENSION (CAT::G CAT::RDCT)) :H +; (CAT::SUSPENSION (CAT::H CAT::RDCT)) :ORGN +; `(CAT::SUSPENSION ,CAT::RDCT)))) +; +; note: type assertion too complex to check: +; (VALUES REDUCTION &REST T). + +; compiling (DEFMETHOD SUSPENSION-1 ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/suspensions.lisp +; in: DEFMETHOD SUSPENSION-1 (HOMOTOPY-EQUIVALENCE) +; (THE CAT::HOMOTOPY-EQUIVALENCE +; (PROGN +; (WHEN (EQ (FIRST #) 'CAT::TRIVIAL-HMEQ) +; (RETURN-FROM CAT::SUSPENSION-1 (CAT::TRIVIAL-HMEQ #))) +; (CAT::BUILD-HMEQ :LRDCT (CAT::SUSPENSION (CAT::LRDCT CAT::HMEQ)) :RR +DCT +; (CAT::SUSPENSION (CAT::RRDCT CAT::HMEQ)) :ORGN +; `(CAT::SUSPENSION ,CAT::HMEQ)))) +; +; note: type assertion too complex to check: +; (VALUES HOMOTOPY-EQUIVALENCE &REST T). + +; compiling (DEFMETHOD SEARCH-EFHM ...); +; compilation unit finished +; printed 4 notes + + +; C:/home/quicklisp/local-projects/kenzo/src/suspensions.fasl written +; compilation finished in 0:00:00.206 +STYLE-WARNING: Implicitly creating new generic function CAT::SUSPENSION-1. +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/disk-pasting.lisp" +(written 24 DEC 2014 10:58:09 PM): +; compiling (IN-PACKAGE #:CAT) +; compiling (PROVIDE "disk-pasting") +; compiling (DEFUN DISK-PASTING-CMPR ...) +; compiling (DEFUN DISK-PASTING-BASIS ...) +; compiling (DEFUN DISK-PASTING-INTR-DFFR ...) +; compiling (DEFUN CHCM-DISK-PASTING ...) +; compiling (DEFUN DISK-PASTING-FACE ...) +; compiling (DEFUN DISK-PASTING ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/disk-pasting.lisp +; in: DEFUN DISK-PASTING +; (THE CAT::SIMPLICIAL-SET +; (WITH-SLOTS (CAT::CMPR CAT::BASIS CAT::BSGN CAT::FACE CAT::DFFR) +; CAT::SMST +; (DECLARE (TYPE CAT::CMPRF CAT::CMPR) +; (TYPE CAT::BASIS CAT::BASIS) +; (TYPE CAT::GMSM CAT::BSGN) +; (TYPE CAT::FACE CAT::FACE) +; (TYPE CAT::MORPHISM CAT::DFFR)) +; (LET ((CAT::NEW-FACE #) (CAT::NEW-BNDR #)) +; (DECLARE (TYPE CAT::FACE CAT::NEW-FACE) +; (TYPE CAT::CMBN CAT::NEW-BNDR)) +; (DO (# +; #) +; (#) +; (DECLARE # +; #) +; (LET # +; # +; #)) +; (CAT::BUILD-SMST :CMPR (CAT::DISK-PASTING-CMPR CAT::CMPR CAT::NEW +) +; :BASIS +; (CAT::DISK-PASTING-BASIS CAT::BASIS CAT::DMNS +; CAT::NEW) +; :BSPN CAT::BSGN :FACE CAT::NEW-FACE :INTR-BNDR +; (CAT::DISK-PASTING-INTR-DFFR CAT::DFFR CAT::DMNS + +; CAT::NEW CAT::NEW-BNDR) +; :BNDR-STRT ...)))) +; +; note: type assertion too complex to check: +; (VALUES SIMPLICIAL-SET &REST T). + +; compiling (DEFUN MRPH-DISK-PASTING-INTR ...) +; compiling (DEFUN MRPH-DISK-PASTING ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/disk-pasting.lisp +; in: DEFUN MRPH-DISK-PASTING +; (THE CAT::MORPHISM +; (CAT::BUILD-MRPH :SORC CAT::NEW-SORC :TRGT CAT::NEW-TRGT :DEGR +; (CAT::DEGR CAT::MRPH) :INTR +; (CAT::MRPH-DISK-PASTING-INTR CAT::MRPH +; (CAT::CMPR CAT::NEW-TRGT) CAT::DMNS CAT::NEW +; CAT::NEW-IM) +; :STRT :CMBN :ORGN ...)) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFUN HMEQ-DISK-PASTING ...) +; compiling (DEFMETHOD SEARCH-EFHM ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/disk-pasting.lisp +; in: DEFMETHOD SEARCH-EFHM (T (EQL 'DISK-PASTING)) +; (THE CAT::HOMOTOPY-EQUIVALENCE +; (DESTRUCTURING-BIND +; (CAT::OLD-SMST CAT::DMNS CAT::NEW CAT::FACES) +; (REST (CAT::ORGN CAT::SMST)) +; (DECLARE (TYPE CAT::SIMPLICIAL-SET CAT::OLD-SMST) +; (FIXNUM CAT::DMNS) +; (SYMBOL CAT::NEW) +; (IGNORE CAT::FACES)) +; (CAT::HMEQ-DISK-PASTING (CAT::EFHM CAT::OLD-SMST) CAT::DMNS CAT::NE +W +; (CAT::? CAT::SMST CAT::DMNS CAT::NEW) :NEW-LBCC CAT::SMST))) +; +; note: type assertion too complex to check: +; (VALUES HOMOTOPY-EQUIVALENCE &REST T). +; +; compilation unit finished +; printed 3 notes + + +; C:/home/quicklisp/local-projects/kenzo/src/disk-pasting.fasl written +; compilation finished in 0:00:00.152 +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/cartesian-products. +lisp" (written 24 DEC 2014 10:58:35 PM): +; compiling (IN-PACKAGE #:CAT) +; compiling (PROVIDE "cartesian-products") +; compiling (DEFUN CRPR-PRINT ...) +; compiling (DEFUN EXTRACT-COMMON-DGOP ...) +; compiling (DEFUN 2ABSM-ACRPR ...) +; compiling (DEFUN CRTS-PRDC-CMPR ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/cartesian-products.lisp +; in: DEFUN CRTS-PRDC-CMPR +; (THE CAT::CMPR +; (CAT::LEXICO +; (CAT::F-CMPR (CAT::DGOP1 CAT::CRPR1) (CAT::DGOP1 CAT::CRPR2)) +; (CAT::F-CMPR (CAT::DGOP2 CAT::CRPR1) (CAT::DGOP2 CAT::CRPR2)) +; (FUNCALL CAT::CMPR1 (CAT::GMSM1 CAT::CRPR1) (CAT::GMSM1 CAT::CRPR2)) + +; (FUNCALL CAT::CMPR2 (CAT::GMSM2 CAT::CRPR1) (CAT::GMSM2 CAT::CRPR2)) +)) +; +; note: type assertion too complex to check: +; (VALUES (MEMBER :LESS :EQUAL :GREATER) &REST T). + +; compiling (DEFUN CRTS-PRDC-BASIS ...) +; compiling (DEFUN CRTS-PRDC-FACE ...) +; compiling (DEFUN CRTS-PRDC-FACE* ...) +; compiling (DEFUN CRTS-PRDC ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/cartesian-products.lisp +; in: DEFUN CRTS-PRDC +; (THE CAT::SIMPLICIAL-SET +; (CAT::BUILD-SMST :CMPR (CAT::CRTS-PRDC-CMPR CAT::CMPR1 CAT::CMPR2) +; :BASIS (CAT::CRTS-PRDC-BASIS CAT::BASIS1 CAT::BASIS2 +) +; :BSPN (CAT::CRPR 0 CAT::BSPN1 0 CAT::BSPN2) :FACE +; (CAT::CRTS-PRDC-FACE CAT::FACE1 CAT::FACE2) :FACE* +; (CAT::CRTS-PRDC-FACE* CAT::FACE1 CAT::FACE2) :ORGN . +..)) +; +; note: type assertion too complex to check: +; (VALUES SIMPLICIAL-SET &REST T). +; +; compilation unit finished +; printed 2 notes + + +; C:/home/quicklisp/local-projects/kenzo/src/cartesian-products.fasl written +; compilation finished in 0:00:00.111 +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/eilenberg-zilber.li +sp" (written 24 DEC 2014 10:58:54 PM): +; compiling (IN-PACKAGE #:CAT) +; compiling (PROVIDE "eilenberg-zilber") +; compiling (DEFUN SHUFFLE-SIGN ...) +; compiling (DEFUN INTR-EML ...) +; compiling (DEFUN EML ...) +; compiling (DEFUN INTR-PHI ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/eilenberg-zilber.lisp +; in: DEFUN INTR-PHI +; (THE CAT::CMBN +; (LET* ((CAT::N (CAT::CMBN-DEGR CAT::CMBN)) +; (CAT::N+1 (1+ CAT::N)) +; (CAT::ARRAY-PQ (MAKE-ARRAY #))) +; (DECLARE (FIXNUM CAT::N CAT::N+1) +; (SIMPLE-ARRAY CAT::ARRAY-PQ)) +; (DO ((CAT::I 1 #)) +; ((> CAT::I CAT::N+1)) +; (DECLARE (FIXNUM CAT::I)) +; (DO (# +; #) +; (#) +; (DECLARE #) +; (SETF #))) +; (DOLIST (CAT::TERM (CAT::CMBN-LIST CAT::CMBN)) +; (DECLARE (TYPE CAT::TERM CAT::TERM)) +; (CAT::WITH-TERM (CAT::CFFC CAT::CRPR) CAT::TERM +; (LET # +; # +; #))) +; (CAT::INTR-PHI-2 CAT::ARRAY-PQ CAT::CMPR))) +; +; note: type assertion too complex to check: +; (VALUES CMBN &REST T). + +; compiling (DEFUN INTR-PHI-2 ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/eilenberg-zilber.lisp +; in: DEFUN INTR-PHI-2 +; (THE CAT::CMBN +; (LET* ((CAT::N+1 (1- #)) +; (CAT::N (1- CAT::N+1)) +; (CAT::CMBN-LIST CAT::+EMPTY-LIST+)) +; (DECLARE (FIXNUM CAT::N CAT::N+1) +; (LIST CAT::CMBN-LIST)) +; (DO ((CAT::I 1 #) +; (CAT::CMBN-I # #) +; (CAT::MASK # #)) +; ((= CAT::I CAT::N+1)) +; (DECLARE (FIXNUM CAT::I CAT::MASK) +; (LIST CAT::CMBN-I)) +; (LET (#) +; (DECLARE #) +; (DO # # # #))) +; (IF CAT::CMBN-LIST +; (APPLY #'CAT::NCMBN-ADD CAT::CMPR CAT::CMBN-LIST) +; (CAT::ZERO-CMBN CAT::N+1)))) +; +; note: type assertion too complex to check: +; (VALUES CMBN &REST T). + +; compiling (DEFUN PHI ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/eilenberg-zilber.lisp +; in: DEFUN PHI +; (THE CAT::MORPHISM +; (CAT::BUILD-MRPH :SORC (CAT::CRTS-PRDC CAT::SMST1 CAT::SMST2) :TRGT +; (CAT::CRTS-PRDC CAT::SMST1 CAT::SMST2) :DEGR 1 :INTR + +; (CAT::INTR-PHI CAT::SMST1 CAT::SMST2) :STRT :CMBN :O +RGN +; ...)) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFUN INTR-AW ...) +; compiling (DEFUN AW ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/eilenberg-zilber.lisp +; in: DEFUN AW +; (THE CAT::MORPHISM +; (CAT::BUILD-MRPH :SORC CAT::CRTS-PRDC :TRGT CAT::TNSR-PRDC :DEGR 0 :I +NTR +; (CAT::INTR-AW CAT::FACE1 CAT::FACE2) :STRT :GNRT :OR +GN +; ...)) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFUN EZ ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/eilenberg-zilber.lisp +; in: DEFUN EZ +; (THE CAT::REDUCTION +; (CAT::BUILD-RDCT :F (CAT::AW CAT::SMST1 CAT::SMST2) :G +; (CAT::EML CAT::SMST1 CAT::SMST2) :H +; (CAT::PHI CAT::SMST1 CAT::SMST2) :ORGN +; `(CAT::EILENBERG-ZILBER ,CAT::SMST1 ,CAT::SMST2))) +; +; note: type assertion too complex to check: +; (VALUES REDUCTION &REST T). + +; compiling (DEFUN LEFT-CRTS-PRDC-EFHM ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/eilenberg-zilber.lisp +; in: DEFUN LEFT-CRTS-PRDC-EFHM +; (THE CAT::HOMOTOPY-EQUIVALENCE +; (CAT::BUILD-HMEQ :LRDCT +; (CAT::TRIVIAL-RDCT +; (CAT::CRTS-PRDC CAT::SMST1 CAT::SMST2)) +; :RRDCT (CAT::EZ CAT::SMST1 CAT::SMST2))) +; +; note: type assertion too complex to check: +; (VALUES HOMOTOPY-EQUIVALENCE &REST T). + +; compiling (DEFMETHOD SEARCH-EFHM ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/eilenberg-zilber.lisp +; in: DEFMETHOD SEARCH-EFHM (T (EQL 'CRTS-PRDC)) +; (THE CAT::HOMOTOPY-EQUIVALENCE +; (CAT::CMPS +; (CAT::LEFT-CRTS-PRDC-EFHM (SECOND (CAT::ORGN CAT::SMST)) +; (THIRD (CAT::ORGN CAT::SMST))) +; (CAT::TNSR-PRDC (CAT::EFHM (SECOND #)) (CAT::EFHM (THIRD #))))) +; +; note: type assertion too complex to check: +; (VALUES HOMOTOPY-EQUIVALENCE &REST T). +; +; compilation unit finished +; printed 7 notes + + +; C:/home/quicklisp/local-projects/kenzo/src/eilenberg-zilber.fasl written +; compilation finished in 0:00:00.215 +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/kan.lisp" (written +26 DEC 2014 07:50:18 PM): +; compiling (IN-PACKAGE #:CAT) +; compiling (PROVIDE "kan") +; compiling (DEFUN KAN ...) +; compiling (DEFMETHOD PRINT-OBJECT ...) +; compiling (DEFUN SMST-KAN ...) +; compiling (DEFUN CHECK-HAT ...) +; compiling (DEFUN CHECK-KAN ...) + +; C:/home/quicklisp/local-projects/kenzo/src/kan.fasl written +; compilation finished in 0:00:00.039 +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/simplicial-groups.l +isp" (written 26 DEC 2014 07:51:23 PM): +; compiling (IN-PACKAGE #:CAT) +; compiling (PROVIDE "simplicial-groups") +; compiling (DEFUN SMGR ...) +; compiling (DEFMETHOD PRINT-OBJECT ...) +; compiling (DEFMETHOD PRINT-OBJECT ...) +; compiling (DEFUN BUILD-SMGR ...) +; compiling (DEFUN A-GRML4 ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/simplicial-groups.lisp +; in: DEFUN A-GRML4 +; (THE CAT::ABSM +; (LET ((CAT::ACRPR (CAT::2ABSM-ACRPR CAT::ABSM1 CAT::ABSM2))) +; (DECLARE (TYPE CAT::ABSM CAT::ACRPR)) +; (CAT::WITH-ABSM (CAT::DGOP CAT::CRPR) CAT::ACRPR +; (CAT::NDGNR CAT::DGOP +; (FUNCALL CAT::SINTR-GRML # CAT::CRPR))) +)) +; +; note: type assertion too complex to check: +; (VALUES ABSM &REST T). + +; compiling (DEFUN A-GRIN4 ...) +; compiling (DEFMETHOD SLOT-UNBOUND ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/simplicial-groups.lisp +; in: DEFMETHOD SLOT-UNBOUND (T SIMPLICIAL-GROUP (EQL 'KFLL)) +; (DEFMETHOD SLOT-UNBOUND +; (CLASS (CAT::SMGR CAT::SIMPLICIAL-GROUP) +; (CAT::NAME (EQL (QUOTE CAT::KFLL)))) +; (DECLARE (IGNORE CLASS)) +; (THE CAT::KFLL (PROGN (PUSH CAT::SMGR CAT::*KAN-LIST*) (SETF # #)))) +; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER PROGN SB-PCL::LOAD-DEFMETHOD +; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION +; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS +; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* +; --> LOCALLY SYMBOL-MACROLET SB-PCL::PV-BINDING SB-PCL::PV-BINDING1 +; --> SB-PCL::PV-ENV LOCALLY LET BLOCK THE PROGN +; --> SB-PCL::OPTIMIZED-SET-SLOT-VALUE LET SB-PCL::INSTANCE-WRITE +; --> SB-PCL::INSTANCE-WRITE-STANDARD LOCALLY LET TYPECASE LET COND IF PROGN +; --> AND IF +; ==> +; NIL +; +; caught STYLE-WARNING: +; This is not a FUNCTION: +; NIL +; See also: +; The SBCL Manual, Node "Handling of Types" + +; compiling (DEFUN SMGR-KFLL-INTR ...) +; compiling (DEFUN SMGR-KFLL ...) +; compiling (DEFMETHOD SLOT-UNBOUND ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/simplicial-groups.lisp +; in: DEFMETHOD SLOT-UNBOUND (T SIMPLICIAL-GROUP (EQL 'APRD)) +; (DEFMETHOD SLOT-UNBOUND +; (CLASS (CAT::SMGR CAT::SIMPLICIAL-GROUP) +; (CAT::NAME (EQL (QUOTE CAT::APRD)))) +; (DECLARE (IGNORE CLASS)) +; (THE CAT::MORPHISM (PROGN (PUSH CAT::SMGR CAT::*HOPF-LIST*) (SETF # #))) +) +; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER PROGN SB-PCL::LOAD-DEFMETHOD +; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION +; --> SYMBOL-MACROLET SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS +; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-FUNCTIONS FLET SB-PCL::BIND-ARGS LET* +; --> LOCALLY SYMBOL-MACROLET SB-PCL::PV-BINDING SB-PCL::PV-BINDING1 +; --> SB-PCL::PV-ENV LOCALLY LET BLOCK THE PROGN +; --> SB-PCL::OPTIMIZED-SET-SLOT-VALUE LET SB-PCL::INSTANCE-WRITE +; --> SB-PCL::INSTANCE-WRITE-STANDARD LOCALLY LET TYPECASE LET COND IF PROGN +; --> AND IF +; ==> +; NIL +; +; caught STYLE-WARNING: +; This is not a MORPHISM: +; NIL +; See also: +; The SBCL Manual, Node "Handling of Types" + +; compiling (DEFUN SMGR-APRD ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/simplicial-groups.lisp +; in: DEFUN SMGR-APRD +; (THE CAT::MORPHISM +; (LET ((CAT::EML (CAT::EML CAT::SMGR CAT::SMGR)) +; (CAT::GRML (CAT::GRML CAT::SMGR))) +; (DECLARE (TYPE CAT::MORPHISM CAT::EML) +; (TYPE CAT::SIMPLICIAL-MRPH CAT::GRML)) +; (CAT::CMPS CAT::GRML CAT::EML))) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). +; +; compilation unit finished +; caught 2 STYLE-WARNING conditions +; printed 2 notes + + +; C:/home/quicklisp/local-projects/kenzo/src/simplicial-groups.fasl written +; compilation finished in 0:00:00.204 +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/fibrations.lisp" (w +ritten 24 DEC 2014 10:59:37 PM): +; compiling (IN-PACKAGE #:CAT) +; compiling (PROVIDE "fibrations") +; compiling (DEFUN FIBRATION-TOTAL-FACE ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/fibrations.lisp +; in: DEFUN FIBRATION-TOTAL-FACE +; (THE CAT::ABSM +; (PROGN +; (WHEN (< CAT::INDX CAT::DMNS) +; (RETURN-FROM CAT::RSLT +; (FUNCALL CAT::UFACE CAT::INDX CAT::DMNS CAT::CRPR))) +; (CAT::WITH-CRPR (CAT::B-ABSM CAT::F-ABSM) CAT::CRPR +; (LET (# # #) +; (DECLARE #) +; (CAT::2ABSM-ACRPR CAT::DELN-B #))))) +; +; note: type assertion too complex to check: +; (VALUES ABSM &REST T). + +; compiling (DEFUN FIBRATION-TOTAL ...) +; compiling (DEFUN FIBRATION-KFLL ...); +; compilation unit finished +; printed 1 note + + +; C:/home/quicklisp/local-projects/kenzo/src/fibrations.fasl written +; compilation finished in 0:00:00.052 +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/loop-spaces.lisp" ( +written 25 DEC 2014 09:01:28 PM): +; compiling (IN-PACKAGE #:CAT) +; compiling (PROVIDE "loop-spaces") +; compiling (DEFPARAMETER +NULL-LOOP+ ...) +; compiling (DEFUN NORMALIZE-LOOP ...) +; compiling (DEFUN UNNORMALIZE-LOOP ...) +; compiling (DEFUN LOOP3 ...) +; compiling (DEFUN LOOP-PRINT ...) +; compiling (DEFUN APOWR-NILOOP ...) +; compiling (DEFUN LOOP-SPACE-CMPR ...) +; compiling (DEFUN APOWR-FACE4 ...) +; compiling (DEFUN APOWR-LASTFACE4 ...) +; compiling (DEFUN LOOP-SPACE-FACE ...) +; compiling (DEFUN LOOP-SPACE-FACE* ...) +; compiling (DEFUN LOOP-SPACE-GRIN-SINTR ...) +; compiling (DEFUN LOOP-SPACE-GRML-SINTR ...) +; compiling (DEFUN LOOP-SPACE ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/loop-spaces.lisp +; in: DEFUN LOOP-SPACE +; (THE CAT::SIMPLICIAL-GROUP +; (IF (= CAT::N 1) +; (WITH-SLOTS (CAT::CMPR CAT::FACE) +; CAT::SMST +; (DECLARE (TYPE CAT::CMPRF CAT::CMPR) +; (TYPE CAT::FACE CAT::FACE)) +; (CAT::BUILD-SMGR :CMPR (CAT::LOOP-SPACE-CMPR CAT::CMPR) :BASIS +; :LOCALLY-EFFECTIVE :BSPN CAT::+NULL-LOOP+ :FAC +E +; (CAT::LOOP-SPACE-FACE CAT::CMPR CAT::FACE) :FA +CE* +; (CAT::LOOP-SPACE-FACE* CAT::CMPR CAT::FACE) +; :SINTR-GRML ...)) +; (CAT::LOOP-SPACE (CAT::LOOP-SPACE CAT::SMST) (1- CAT::N)))) +; +; note: type assertion too complex to check: +; (VALUES SIMPLICIAL-GROUP &REST T). + +; compiling (DEFUN GDELTAB ...); +; compilation unit finished +; printed 1 note + + +; C:/home/quicklisp/local-projects/kenzo/src/loop-spaces.fasl written +; compilation finished in 0:00:00.158 +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/ls-twisted-products +.lisp" (written 24 DEC 2014 11:00:19 PM): +; compiling (IN-PACKAGE #:CAT) +; compiling (PROVIDE "ls-twisted-products") +; compiling (DEFUN ABSM-LOOPABSM ...) +; compiling (DEFUN TWISTED-CRTS-PRDC-FACE ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/ls-twisted-products.lisp +; in: DEFUN TWISTED-CRTS-PRDC-FACE +; (THE CAT::ABSM +; (PROGN +; (UNLESS (= CAT::INDX CAT::DMNS) +; (RETURN-FROM CAT::RSLT +; (FUNCALL CAT::NON-TWISTED-FACE CAT::INDX CAT::DMNS CAT::CRPR))) +; (CAT::WITH-CRPR (CAT::ABSM1 CAT::ABSM2) CAT::CRPR +; (LET (# #) +; (DECLARE #) +; (SETF #) +; (CAT::2ABSM-ACRPR CAT::FACE1 CAT::FACE2))))) +; +; note: type assertion too complex to check: +; (VALUES ABSM &REST T). + +; compiling (DEFUN TWISTED-CRTS-PRDC ...) +; compiling (DEFUN DTAU-D-INTR ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/ls-twisted-products.lisp +; in: DEFUN DTAU-D-INTR +; (THE CAT::CMBN +; (LET ((CAT::DMNS-1 (1- CAT::DMNS))) +; (DECLARE (FIXNUM CAT::DMNS-1)) +; (WHEN (LOGBITP CAT::DMNS-1 (CAT::DGOP1 CAT::CRPR)) +; (RETURN-FROM CAT::RSLT (CAT::ZERO-CMBN CAT::DMNS-1))) +; (LET ((CAT::FACE-TAU #) (CAT::FACE #) (CAT::SIGN #)) +; (DECLARE (TYPE CAT::ABSM CAT::FACE-TAU CAT::FACE) +; (FIXNUM CAT::SIGN)) +; (CAT::WITH-ABSM (CAT::DGOP-TAU CAT::GMSM-TAU) CAT::FACE-TAU +; (CAT::WITH-ABSM # CAT::FACE #))))) +; +; note: type assertion too complex to check: +; (VALUES CMBN &REST T). + +; compiling (DEFUN DTAU-D ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/ls-twisted-products.lisp +; in: DEFUN DTAU-D +; (THE CAT::MORPHISM +; (CAT::BUILD-MRPH :SORC CAT::CRTS-PRDC :TRGT CAT::CRTS-PRDC :DEGR -1 +; :INTR +; (CAT::DTAU-D-INTR CAT::CRTS-PRDC-CMPR +; CAT::CRTS-PRDC-FACE CAT::TWISTED-CRTS-PRDC-FACE) +; :STRT :GNRT :ORGN ...)) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFUN SZCZARBA ...) +; compiling (DEFUN TWISTED-TNSR-PRDC ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/ls-twisted-products.lisp +; in: DEFUN TWISTED-TNSR-PRDC +; (THE CAT::CHAIN-COMPLEX (CAT::BCC CAT::SZCZARBA)) +; +; note: type assertion too complex to check: +; (VALUES CHAIN-COMPLEX &REST T). + +; compiling (DEFUN POP-FIRST-ABSM ...) +; compiling (DEFUN CRTS-CONTRACTION-INTR ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/ls-twisted-products.lisp +; in: DEFUN CRTS-CONTRACTION-INTR +; (CAT::H-TILDE CAT::Y-N+1 CAT::GP-N) +; +; note: deleting unreachable code + +; (IF (CAT::DEGENERATE-P CAT::GP-N) +; CAT::H-TILDES +; (CAT::2CMBN-ADD CAT::CRTS-CMPR +; (CAT::H-HAT (CAT::LOOP-LIST (CAT::GMSM CAT::GP-N))) +; CAT::H-TILDES)) +; ==> +; CAT::H-TILDES +; +; note: deleting unreachable code + +; (CAT::2CMBN-ADD CAT::CRTS-CMPR +; (CAT::H-HAT (CAT::LOOP-LIST (CAT::GMSM CAT::GP-N))) +; CAT::H-TILDES) +; ==> +; CAT::CRTS-CMPR +; +; note: deleting unreachable code + +; (LOGAND (CAT::DGOP CAT::NEXT-X-N) (CAT::DGOP CAT::GP-N)) +; +; note: deleting unreachable code + +; (CAT::2CMBN-SBTR CAT::CRTS-CMPR (CAT::HH CAT::NEXT-X-N CAT::GP-N) +; CAT::H-TILDE) +; ==> +; CAT::CRTS-CMPR +; +; note: deleting unreachable code + +; (CAT::CMBN-OPPS CAT::H-TILDE) +; ==> +; CAT::H-TILDE +; +; note: deleting unreachable code + +; (THE CAT::CMBN +; (LET ((CAT::N+1 (1+ CAT::N))) +; (DECLARE (FIXNUM CAT::N+1)) +; (LABELS ((CAT::HH # +; # +; #) +; (CAT::H-TILDE # +; # +; # +; #) +; (CAT::H-HAT # +; # +; #)) +; (CAT::WITH-CRPR (CAT::ABSM1 CAT::LOOP-ABSM2) CAT::CRPR +; (CAT::HH CAT::ABSM1 CAT::LOOP-ABSM2))))) +; +; note: type assertion too complex to check: +; (VALUES CMBN &REST T). + +; (CAT::DGOP CAT::GP-N) +; --> SB-KERNEL:%INSTANCE-REF +; ==> +; (THE CAT::ABSM CAT::GP-N) +; +; caught WARNING: +; Derived type of GP-N is +; (VALUES LOOP &OPTIONAL), +; conflicting with its asserted type +; ABSM. +; See also: +; The SBCL Manual, Node "Handling of Types" + +; (CAT::H-TILDE CAT::Y-N+1 CAT::GP-N) +; +; caught WARNING: +; Derived type of GP-N is +; (VALUES LOOP &OPTIONAL), +; conflicting with its asserted type +; ABSM. +; See also: +; The SBCL Manual, Node "Handling of Types" + +; compiling (DEFUN CRTS-CONTRACTION ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/ls-twisted-products.lisp +; in: DEFUN CRTS-CONTRACTION +; (THE CAT::MORPHISM +; (CAT::BUILD-MRPH :SORC CAT::TWISTED-CRTS-PRDC :TRGT +; CAT::TWISTED-CRTS-PRDC :DEGR 1 :INTR +; (CAT::CRTS-CONTRACTION-INTR (CAT::CMPR SPACE) +; (CAT::BSPN SPACE) (CAT::FACE SPACE) +; (CAT::CMPR CAT::TWISTED-CRTS-PRDC)) +; :STRT :GNRT :ORGN ...)) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFUN TNPR-CONTRACTION ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/ls-twisted-products.lisp +; in: DEFUN TNPR-CONTRACTION +; (THE CAT::MORPHISM (CAT::I-CMPS CAT::F CAT::CRTS-CONTRACTION CAT::G)) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). +; +; compilation unit finished +; caught 2 WARNING conditions +; printed 13 notes + + +; C:/home/quicklisp/local-projects/kenzo/src/ls-twisted-products.fasl written +; compilation finished in 0:00:00.306 +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/lp-space-efhm.lisp" + (written 24 DEC 2014 11:00:46 PM): +; compiling (IN-PACKAGE #:CAT) +; compiling (PROVIDE "lp-space-efhm") +; compiling (DEFUN LS-HAT-U-U ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/lp-space-efhm.lisp +; in: DEFUN LS-HAT-U-U +; (THE CAT::CHAIN-COMPLEX (CAT::TNSR-PRDC CAT::COBAR CAT::SPAC-TNSR-LPSP)) +; +; note: type assertion too complex to check: +; (VALUES CHAIN-COMPLEX &REST T). + +; compiling (DEFUN LS-HAT-LEFT-PERTURBATION-INTR ...) +; compiling (DEFUN LS-HAT-LEFT-PERTURBATION ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/lp-space-efhm.lisp +; in: DEFUN LS-HAT-LEFT-PERTURBATION +; (THE CAT::MORPHISM +; (LET ((CAT::LS-HAT-U-U (CAT::LS-HAT-U-U SPACE))) +; (CAT::BUILD-MRPH :SORC CAT::LS-HAT-U-U :TRGT CAT::LS-HAT-U-U :DEGR +-1 +; :INTR (CAT::LS-HAT-LEFT-PERTURBATION-INTR SPACE) +; :STRT :GNRT :ORGN ...))) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFUN LS-HAT-T-U ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/lp-space-efhm.lisp +; in: DEFUN LS-HAT-T-U +; (THE CAT::CHAIN-COMPLEX +; (PROGN +; (SETF (SLOT-VALUE CAT::LS-HAT-LEFT-PERTURBATION 'CAT::SORC) +; CAT::LS-HAT-U-U +; (SLOT-VALUE CAT::LS-HAT-LEFT-PERTURBATION 'CAT::TRGT) +; CAT::LS-HAT-U-U) +; (CAT::ADD CAT::LS-HAT-U-U CAT::LS-HAT-LEFT-PERTURBATION))) +; +; note: type assertion too complex to check: +; (VALUES CHAIN-COMPLEX &REST T). + +; compiling (DEFUN LS-HAT-RIGHT-PERTURBATION ...) +; compiling (DEFUN LS-HAT-U-T ...) +; compiling (DEFUN LS-LEFT-HMEQ-HAT ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/lp-space-efhm.lisp +; in: DEFUN LS-LEFT-HMEQ-HAT +; (THE CAT::CHAIN-COMPLEX +; (CAT::ADD CAT::LS-HAT-U-T CAT::LS-HAT-LEFT-PERTURBATION)) +; +; note: type assertion too complex to check: +; (VALUES CHAIN-COMPLEX &REST T). + +; compiling (DEFUN LS-PRE-LEFT-HMEQ-LEFT-REDUCTION-INTR-F ...) +; compiling (DEFUN LS-PRE-LEFT-HMEQ-LEFT-REDUCTION-F ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/lp-space-efhm.lisp +; in: DEFUN LS-PRE-LEFT-HMEQ-LEFT-REDUCTION-F +; (THE CAT::MORPHISM +; (CAT::BUILD-MRPH :SORC CAT::LS-HAT-T-U :TRGT CAT::LOOP-SPACE :DEGR 0 +; :INTR #'CAT::LS-PRE-LEFT-HMEQ-LEFT-REDUCTION-INTR-F +; :STRT :CMBN :ORGN ...)) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFUN LS-LEFT-HMEQ-LEFT-REDUCTION-G-INTR ...) +; compiling (DEFUN LS-LEFT-HMEQ-LEFT-REDUCTION-G ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/lp-space-efhm.lisp +; in: DEFUN LS-LEFT-HMEQ-LEFT-REDUCTION-G +; (THE CAT::MORPHISM +; (CAT::BUILD-MRPH :SORC CAT::LOOP-SPACE :TRGT CAT::LS-HAT-T-U :DEGR 0 +; :INTR +; (CAT::LS-LEFT-HMEQ-LEFT-REDUCTION-G-INTR CAT::BSPN) +; :STRT :CMBN :ORGN ...)) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFUN LS-PRE-LEFT-HMEQ-LEFT-REDUCTION-H-INTR ...) +; compiling (DEFUN LS-PRE-LEFT-HMEQ-LEFT-REDUCTION-H ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/lp-space-efhm.lisp +; in: DEFUN LS-PRE-LEFT-HMEQ-LEFT-REDUCTION-H +; (THE CAT::MORPHISM +; (CAT::BUILD-MRPH :SORC CAT::LS-HAT-T-U :TRGT CAT::LS-HAT-T-U :DEGR 1 +; :INTR +; (CAT::LS-PRE-LEFT-HMEQ-LEFT-REDUCTION-H-INTR SPACE) +; :STRT :CMBN :ORGN ...)) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFUN LS-PRE-LEFT-HMEQ-LEFT-REDUCTION ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/lp-space-efhm.lisp +; in: DEFUN LS-PRE-LEFT-HMEQ-LEFT-REDUCTION +; (THE CAT::REDUCTION +; (CAT::BUILD-RDCT :F (CAT::LS-PRE-LEFT-HMEQ-LEFT-REDUCTION-F SPACE) :G + +; (CAT::LS-LEFT-HMEQ-LEFT-REDUCTION-G SPACE) :H +; (CAT::LS-PRE-LEFT-HMEQ-LEFT-REDUCTION-H SPACE) :ORGN + +; `(CAT::LS-PRE-LEFT-HMEQ-LEFT-REDUCTION ,SPACE))) +; +; note: type assertion too complex to check: +; (VALUES REDUCTION &REST T). + +; compiling (DEFUN LS-LEFT-HMEQ-LEFT-REDUCTION ...) +; compiling (DEFUN LS-PRE-LEFT-HMEQ-RIGHT-REDUCTION-INTR-F ...) +; compiling (DEFUN LS-PRE-LEFT-HMEQ-RIGHT-REDUCTION-F ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/lp-space-efhm.lisp +; in: DEFUN LS-PRE-LEFT-HMEQ-RIGHT-REDUCTION-F +; (THE CAT::MORPHISM +; (CAT::BUILD-MRPH :SORC CAT::LS-HAT-U-T :TRGT CAT::COBAR :DEGR 0 :INTR + +; #'CAT::LS-PRE-LEFT-HMEQ-RIGHT-REDUCTION-INTR-F :STRT + +; :CMBN :ORGN ...)) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFUN LS-PRE-LEFT-HMEQ-RIGHT-REDUCTION-INTR-G ...) +; compiling (DEFUN LS-PRE-LEFT-HMEQ-RIGHT-REDUCTION-G ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/lp-space-efhm.lisp +; in: DEFUN LS-PRE-LEFT-HMEQ-RIGHT-REDUCTION-G +; (THE CAT::MORPHISM +; (CAT::BUILD-MRPH :SORC CAT::COBAR :TRGT CAT::LS-HAT-U-T :DEGR 0 :INTR + +; (CAT::LS-PRE-LEFT-HMEQ-RIGHT-REDUCTION-INTR-G +; CAT::BSPN) +; :STRT :CMBN :ORGN ...)) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFUN LS-PRE-LEFT-HMEQ-RIGHT-REDUCTION-H ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/lp-space-efhm.lisp +; in: DEFUN LS-PRE-LEFT-HMEQ-RIGHT-REDUCTION-H +; (THE CAT::MORPHISM +; (CAT::TNSR-PRDC (CAT::IDNT-MRPH CAT::COBAR) CAT::TNPR-CONTRACTION)) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFUN LS-PRE-LEFT-HMEQ-RIGHT-REDUCTION ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/lp-space-efhm.lisp +; in: DEFUN LS-PRE-LEFT-HMEQ-RIGHT-REDUCTION +; (THE CAT::REDUCTION +; (CAT::BUILD-RDCT :F (CAT::LS-PRE-LEFT-HMEQ-RIGHT-REDUCTION-F SPACE) : +G +; (CAT::LS-PRE-LEFT-HMEQ-RIGHT-REDUCTION-G SPACE) :H +; (CAT::LS-PRE-LEFT-HMEQ-RIGHT-REDUCTION-H SPACE) :ORG +N +; `(CAT::LS-PRE-LEFT-HMEQ-RIGHT-REDUCTION ,SPACE))) +; +; note: type assertion too complex to check: +; (VALUES REDUCTION &REST T). + +; compiling (DEFUN LS-LEFT-HMEQ-RIGHT-REDUCTION ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/lp-space-efhm.lisp +; in: DEFUN LS-LEFT-HMEQ-RIGHT-REDUCTION +; (THE CAT::REDUCTION +; (PROGN +; (SETF (SLOT-VALUE CAT::PERTURBATION 'CAT::SORC) +; (CAT::TCC CAT::PRE-REDUCTION) +; (SLOT-VALUE CAT::PERTURBATION 'CAT::TRGT) +; (CAT::TCC CAT::PRE-REDUCTION)) +; (CAT::SPECIAL-BPL CAT::PRE-REDUCTION CAT::PERTURBATION))) +; +; note: type assertion too complex to check: +; (VALUES REDUCTION &REST T). + +; compiling (DEFUN LS-LEFT-HMEQ ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/lp-space-efhm.lisp +; in: DEFUN LS-LEFT-HMEQ +; (THE CAT::HOMOTOPY-EQUIVALENCE +; (CAT::BUILD-HMEQ :LRDCT (CAT::LS-LEFT-HMEQ-LEFT-REDUCTION SPACE) :RRD +CT +; (CAT::LS-LEFT-HMEQ-RIGHT-REDUCTION SPACE) :ORGN +; `(CAT::LS-LEFT-HMEQ ,SPACE))) +; +; note: type assertion too complex to check: +; (VALUES HOMOTOPY-EQUIVALENCE &REST T). + +; compiling (DEFUN LOOP-SPACE-EFHM ...) +; compiling (DEFMETHOD SEARCH-EFHM ...); +; compilation unit finished +; printed 14 notes + + +; C:/home/quicklisp/local-projects/kenzo/src/lp-space-efhm.fasl written +; compilation finished in 0:00:00.328 +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/classifying-spaces. +lisp" (written 25 DEC 2014 09:04:09 PM): +; compiling (IN-PACKAGE #:CAT) +; compiling (PROVIDE "classifying-spaces") +; compiling (DEFPARAMETER +NULL-GBAR+ ...) +; compiling (DEFUN GBAR-PRINT ...) +; compiling (DEFUN NORMALIZE-GBAR ...) +; compiling (DEFUN UNNORMALIZE-GBAR ...) +; compiling (DEFUN GBAR ...) +; compiling (DEFUN CLASSIFYING-SPACE-CMPR ...) +; compiling (DEFUN CLASSIFYING-SPACE-BASIS ...) +; compiling (DEFUN CLASSIFYING-SPACE-FACE ...) +; compiling (DEFMETHOD CLASSIFYING-SPACE ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/classifying-spaces.lisp +; in: DEFMETHOD CLASSIFYING-SPACE (SIMPLICIAL-GROUP) +; (THE CAT::SIMPLICIAL-SET +; (CAT::BUILD-SMST :CMPR +; (CAT::CLASSIFYING-SPACE-CMPR (CAT::CMPR CAT::SMGR)) +; :BASIS +; (CAT::CLASSIFYING-SPACE-BASIS (CAT::BASIS CAT::SMGR) +) +; :BSPN CAT::+NULL-GBAR+ :FACE +; (CAT::CLASSIFYING-SPACE-FACE (CAT::FACE CAT::SMGR) +; (CAT::SINTR (CAT::GRML CAT::SMGR))) +; :ORGN `(CAT::CLASSIFYING-SPACE ,CAT::SMGR))) +; +; note: type assertion too complex to check: +; (VALUES SIMPLICIAL-SET &REST T). + +; compiling (DEFUN CLASSIFYING-SPACE-GRML-SINTR ...) +; compiling (DEFUN CLASSIFYING-SPACE-GRIN-SINTR ...) +; compiling (DEFMETHOD CLASSIFYING-SPACE ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/classifying-spaces.lisp +; in: DEFMETHOD CLASSIFYING-SPACE (AB-SIMPLICIAL-GROUP) +; (THE CAT::AB-SIMPLICIAL-GROUP +; (CHANGE-CLASS +; (CAT::BUILD-SMGR :CMPR +; (CAT::CLASSIFYING-SPACE-CMPR (CAT::CMPR CAT::SMGR)) + +; :BASIS +; (CAT::CLASSIFYING-SPACE-BASIS (CAT::BASIS CAT::SMGR +)) +; :BSPN CAT::+NULL-GBAR+ :FACE +; (CAT::CLASSIFYING-SPACE-FACE (CAT::FACE CAT::SMGR) +; (CAT::SINTR #)) +; :SINTR-GRML +; (CAT::CLASSIFYING-SPACE-GRML-SINTR +; (CAT::BSPN CAT::SMGR) (CAT::SINTR #)) +; :SINTR-GRIN ...) +; 'CAT::AB-SIMPLICIAL-GROUP)) +; +; note: type assertion too complex to check: +; (VALUES AB-SIMPLICIAL-GROUP &REST T). +; +; compilation unit finished +; printed 2 notes + + +; C:/home/quicklisp/local-projects/kenzo/src/classifying-spaces.fasl written +; compilation finished in 0:00:00.167 +STYLE-WARNING: Implicitly creating new generic function CAT::CLASSIFYING-SPACE. +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/k-pi-n.lisp" (writt +en 24 DEC 2014 11:01:38 PM): +; compiling (IN-PACKAGE #:CAT) +; compiling (PROVIDE "k-pi-1") +; compiling (DEFUN K-Z-1-CMPR ...) +; compiling (DEFUN K-Z-1-FACE ...) +; compiling (DEFUN Z-ABSM-BAR ...) +; compiling (DEFUN Z-BAR-ABSM ...) +; compiling (DEFUN K-Z-1-GRML ...) +; compiling (DEFUN K-Z-1-GRIN ...) +; compiling (DEFUN K-Z-1 ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/k-pi-n.lisp +; in: DEFUN K-Z-1 +; (THE CAT::AB-SIMPLICIAL-GROUP +; (CAT::BUILD-AB-SMGR :CMPR #'CAT::K-Z-1-CMPR :BASIS :LOCALLY-EFFECTIVE + +; :BSPN CAT::+EMPTY-LIST+ :FACE #'CAT::K-Z-1-FACE +; :SINTR-GRML #'CAT::K-Z-1-GRML :SINTR-GRIN ...)) +; +; note: type assertion too complex to check: +; (VALUES AB-SIMPLICIAL-GROUP &REST T). + +; compiling (DEFUN K-Z ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/k-pi-n.lisp +; in: DEFUN K-Z +; (THE CAT::AB-SIMPLICIAL-GROUP +; (IF (= CAT::N 1) +; (CAT::K-Z-1) +; (CAT::CLASSIFYING-SPACE (CAT::K-Z (1- CAT::N))))) +; +; note: type assertion too complex to check: +; (VALUES AB-SIMPLICIAL-GROUP &REST T). + +; compiling (DEFUN CIRCLE-CMPR ...) +; compiling (DEFUN CIRCLE-BASIS ...) +; compiling (DEFUN CIRCLE ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/k-pi-n.lisp +; in: DEFUN CIRCLE +; (THE CAT::CHAIN-COMPLEX +; (CAT::BUILD-CHCM :CMPR #'CAT::CIRCLE-CMPR :BASIS #'CAT::CIRCLE-BASIS +; :BSGN '* :INTR-DFFR #'CAT::ZERO-INTR-DFFR :STRT :CMB +N +; :ORGN ...)) +; +; note: type assertion too complex to check: +; (VALUES CHAIN-COMPLEX &REST T). + +; compiling (DEFUN KZ1-RDCT-F-INTR ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/k-pi-n.lisp +; in: DEFUN KZ1-RDCT-F-INTR +; (THE CAT::CMBN +; (CAT::WITH-CMBN (CAT::DEGR LIST) CAT::CMBN +; (CASE CAT::DEGR +; (0 +; (IF LIST +; # +; #)) +; (1 +; (LET # +; #)) +; (OTHERWISE (CAT::ZERO-CMBN CAT::DEGR))))) +; +; note: type assertion too complex to check: +; (VALUES CMBN &REST T). + +; compiling (DEFUN KZ1-RDCT-F ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/k-pi-n.lisp +; in: DEFUN KZ1-RDCT-F +; (THE CAT::MORPHISM +; (CAT::BUILD-MRPH :SORC (CAT::K-Z-1) :TRGT (CAT::CIRCLE) :DEGR 0 :INTR + +; #'CAT::KZ1-RDCT-F-INTR :STRT :CMBN :ORGN ...)) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFUN KZ1-RDCT-G-INTR ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/k-pi-n.lisp +; in: DEFUN KZ1-RDCT-G-INTR +; (THE CAT::CMBN +; (CAT::WITH-CMBN (CAT::DEGR LIST) CAT::CMBN +; (IF LIST +; (ECASE CAT::DEGR (0 #) (1 #)) +; (CAT::ZERO-CMBN CAT::DEGR)))) +; +; note: type assertion too complex to check: +; (VALUES CMBN &REST T). + +; compiling (DEFUN KZ1-RDCT-G ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/k-pi-n.lisp +; in: DEFUN KZ1-RDCT-G +; (THE CAT::MORPHISM +; (CAT::BUILD-MRPH :SORC (CAT::CIRCLE) :TRGT (CAT::K-Z-1) :DEGR 0 :INTR + +; #'CAT::KZ1-RDCT-G-INTR :STRT :CMBN :ORGN ...)) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFUN KZ1-RDCT-H-INTR ...) +; compiling (DEFUN KZ1-RDCT-H ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/k-pi-n.lisp +; in: DEFUN KZ1-RDCT-H +; (THE CAT::MORPHISM +; (CAT::BUILD-MRPH :SORC (CAT::K-Z-1) :TRGT (CAT::K-Z-1) :DEGR 1 :INTR +; #'CAT::KZ1-RDCT-H-INTR :STRT :GNRT :ORGN ...)) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFUN KZ1-RDCT ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/k-pi-n.lisp +; in: DEFUN KZ1-RDCT +; (THE CAT::REDUCTION +; (CAT::BUILD-RDCT :F (CAT::KZ1-RDCT-F) :G (CAT::KZ1-RDCT-G) :H +; (CAT::KZ1-RDCT-H) :ORGN '(CAT::KZ1-RDCT))) +; +; note: type assertion too complex to check: +; (VALUES REDUCTION &REST T). + +; compiling (DEFUN KZ1-EFHM ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/k-pi-n.lisp +; in: DEFUN KZ1-EFHM +; (THE CAT::HOMOTOPY-EQUIVALENCE +; (CAT::BUILD-HMEQ :LRDCT (CAT::TRIVIAL-RDCT (CAT::K-Z-1)) :RRDCT +; (CAT::KZ1-RDCT) :ORGN '(CAT::KZ1-EFHM))) +; +; note: type assertion too complex to check: +; (VALUES HOMOTOPY-EQUIVALENCE &REST T). + +; compiling (DEFMETHOD SEARCH-EFHM ...) +; compiling (DEFUN K-Z2-1-GRML-INTR ...) +; compiling (DEFUN K-Z2-1-GRML ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/k-pi-n.lisp +; in: DEFUN K-Z2-1-GRML +; (THE CAT::SIMPLICIAL-MRPH +; (CAT::BUILD-SMMR :SORC +; (CAT::CRTS-PRDC (CAT::R-PROJ-SPACE) +; (CAT::R-PROJ-SPACE)) +; :TRGT (CAT::R-PROJ-SPACE) :DEGR 0 :SINTR +; #'CAT::K-Z2-1-GRML-INTR :ORGN '(CAT::K-Z2-1-GRML))) +; +; note: type assertion too complex to check: +; (VALUES SIMPLICIAL-MRPH &REST T). + +; compiling (DEFUN K-Z2-1-GRIN-INTR ...) +; compiling (DEFUN K-Z2-1-GRIN ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/k-pi-n.lisp +; in: DEFUN K-Z2-1-GRIN +; (THE CAT::SIMPLICIAL-MRPH +; (CAT::BUILD-SMMR :SORC (CAT::R-PROJ-SPACE) :TRGT (CAT::R-PROJ-SPACE) +; :DEGR 0 :SINTR #'CAT::K-Z2-1-GRIN-INTR :INTR #'IDENT +ITY +; :STRT ...)) +; +; note: type assertion too complex to check: +; (VALUES SIMPLICIAL-MRPH &REST T). + +; compiling (DEFUN K-Z2-1 ...) +; compiling (DEFUN K-Z2 ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/k-pi-n.lisp +; in: DEFUN K-Z2 +; (THE CAT::AB-SIMPLICIAL-GROUP +; (IF (= CAT::N 1) +; (CAT::K-Z2-1) +; (CAT::CLASSIFYING-SPACE (CAT::K-Z2 (1- CAT::N))))) +; +; note: type assertion too complex to check: +; (VALUES AB-SIMPLICIAL-GROUP &REST T). + +; compiling (DEFUN Z2-ABSM-BAR ...) +; compiling (DEFUN Z2-BAR-ABSM ...) +; compiling (DEFUN HOPF-FIBRATION-SINTR ...) +; compiling (DEFUN HOPF-FIBRATION ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/k-pi-n.lisp +; in: DEFUN HOPF-FIBRATION +; (THE CAT::SIMPLICIAL-MRPH +; (CAT::BUILD-SMMR :SORC (CAT::SPHERE 2) :TRGT (CAT::K-Z-1) :DEGR -1 +; :SINTR (CAT::HOPF-FIBRATION-SINTR CAT::N) :ORGN +; `(CAT::HOPF-FIBRATION ,CAT::N))) +; +; note: type assertion too complex to check: +; (VALUES SIMPLICIAL-MRPH &REST T). + +; compiling (DEFUN Z-FUNDAMENTAL-GMSM ...) +; compiling (DEFUN INTERESTING-FACES ...) +; compiling (DEFUN GMSM-COCYCLE ...) +; compiling (DEFUN Z-COCYCLE-GBAR ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/k-pi-n.lisp +; in: DEFUN Z-COCYCLE-GBAR +; (THE CAT::ABSM +; (COND ((= CAT::N 1) (CAT::Z-BAR-ABSM (NREVERSE #))) +; ((= CAT::N CAT::DMNS) +; (LET (#) +; (DECLARE #) +; (IF # +; # +; #))) +; (T +; (LET (# #) +; (DECLARE #) +; (DOLIST # # #) +; (SETF #) +; (MAPC #'# CAT::COCYCLE2) +; (LET # +; # +; #))))) +; +; note: type assertion too complex to check: +; (VALUES ABSM &REST T). + +; compiling (DEFUN Z-COCYCLE-GBAR-HEAD ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/k-pi-n.lisp +; in: DEFUN Z-COCYCLE-GBAR-HEAD +; (THE CAT::ABSM +; (COND +; ((= CAT::N 1) +; (ERROR +; "In Z-COCYCLE-GBAR-HEAD, this point should not have been reached." +)) +; ((= CAT::N CAT::DMNS) +; (LET (#) +; (DECLARE #) +; (IF # +; # +; #))) +; (T +; (LET (# #) +; (DECLARE #) +; (DOLIST # # #) +; (SETF #) +; (MAPC #'# CAT::COCYCLE2) +; (CAT::Z-COCYCLE-GBAR # # CAT::COCYCLE2))))) +; +; note: type assertion too complex to check: +; (VALUES ABSM &REST T). + +; compiling (DEFUN Z2-FUNDAMENTAL-GMSM ...) +; compiling (DEFUN Z2-COCYCLE-GBAR ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/k-pi-n.lisp +; in: DEFUN Z2-COCYCLE-GBAR +; (THE CAT::ABSM +; (PROGN +; (MAPC #'(LAMBDA (CONS) (DECLARE #) (SETF #)) CAT::COCYCLE) +; (COND ((= CAT::N 1) (CAT::Z2-BAR-ABSM #)) +; ((= CAT::N CAT::DMNS) +; (LET # +; # +; #)) +; (T +; (LET # +; # +; # +; # +; # +; #))))) +; +; note: type assertion too complex to check: +; (VALUES ABSM &REST T). + +; compiling (DEFUN Z2-COCYCLE-GBAR-HEAD ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/k-pi-n.lisp +; in: DEFUN Z2-COCYCLE-GBAR-HEAD +; (THE CAT::ABSM +; (PROGN +; (MAPC #'(LAMBDA (CONS) (SETF #)) CAT::COCYCLE) +; (COND +; ((= CAT::N 1) +; (ERROR +; "In Z2-COCYCLE-GBAR-HEAD, this point should not have been reached +.")) +; ((= CAT::N CAT::DMNS) +; (LET # +; # +; #)) +; (T +; (LET # +; # +; # +; # +; # +; #))))) +; +; note: type assertion too complex to check: +; (VALUES ABSM &REST T). + +; compiling (DEFUN K-Z-FUNDAMENTAL-CLASS ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/k-pi-n.lisp +; in: DEFUN K-Z-FUNDAMENTAL-CLASS +; (THE CAT::MORPHISM +; (CAT::BUILD-MRPH :SORC (CAT::K-Z CAT::N) :TRGT (CAT::Z-CHCM) :DEGR +; (- CAT::N) :INTR +; #'(LAMBDA (CAT::DMNS CAT::GMSM) +; (DECLARE (FIXNUM CAT::DMNS) +; (TYPE CAT::GMSM CAT::GMSM)) +; (IF (= CAT::DMNS CAT::N) +; (DO # # #) +; (CAT::ZERO-CMBN #))) +; :STRT :GNRT :ORGN ...)) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFUN K-Z2-FUNDAMENTAL-CLASS ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/k-pi-n.lisp +; in: DEFUN K-Z2-FUNDAMENTAL-CLASS +; (THE CAT::MORPHISM +; (CAT::BUILD-MRPH :SORC (CAT::K-Z2 CAT::N) :TRGT (CAT::Z-CHCM) :DEGR +; (- CAT::N) :INTR +; #'(LAMBDA (CAT::DMNS CAT::GMSM) +; (DECLARE (FIXNUM CAT::DMNS) +; (IGNORE CAT::GMSM)) +; (IF (= CAT::DMNS CAT::N) +; (CAT::TERM-CMBN 0 1 :Z-GNRT) +; (CAT::ZERO-CMBN #))) +; :STRT :GNRT :ORGN ...)) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). +; +; compilation unit finished +; printed 20 notes + + +; C:/home/quicklisp/local-projects/kenzo/src/k-pi-n.fasl written +; compilation finished in 0:00:00.514 +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/serre.lisp" (writte +n 24 DEC 2014 11:01:57 PM): +; compiling (IN-PACKAGE #:CAT) +; compiling (PROVIDE "serre") +; compiling (DEFUN FIBRATION-DTAU-D-INTR ...) +; compiling (DEFUN FIBRATION-DTAU-D ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/serre.lisp +; in: DEFUN FIBRATION-DTAU-D +; (THE CAT::MORPHISM +; (CAT::BUILD-MRPH :SORC CAT::UTOTAL :TRGT CAT::UTOTAL :DEGR -1 :INTR +; (CAT::FIBRATION-DTAU-D-INTR CAT::FIBRATION) :STRT :G +NRT +; :ORGN ...)) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFUN BROWN-REDUCTION ...) +; compiling (DEFUN LEFT-SERRE-EFHM ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/serre.lisp +; in: DEFUN LEFT-SERRE-EFHM +; (THE CAT::HOMOTOPY-EQUIVALENCE +; (CAT::BUILD-HMEQ :LRDCT +; (CAT::TRIVIAL-RDCT +; (CAT::FIBRATION-TOTAL CAT::FIBRATION)) +; :RRDCT (CAT::BROWN-REDUCTION CAT::FIBRATION))) +; +; note: type assertion too complex to check: +; (VALUES HOMOTOPY-EQUIVALENCE &REST T). + +; compiling (DEFUN RIGHT-SERRE-EFHM ...) +; compiling (DEFUN FIBRATION-TOTAL-EFHM ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/serre.lisp +; in: DEFUN FIBRATION-TOTAL-EFHM +; (THE CAT::HOMOTOPY-EQUIVALENCE +; (CAT::CMPS (CAT::LEFT-SERRE-EFHM CAT::FIBRATION) +; (CAT::RIGHT-SERRE-EFHM CAT::FIBRATION))) +; +; note: type assertion too complex to check: +; (VALUES HOMOTOPY-EQUIVALENCE &REST T). + +; compiling (DEFMETHOD SEARCH-EFHM ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/serre.lisp +; in: DEFMETHOD SEARCH-EFHM (T (EQL 'FIBRATION-TOTAL)) +; (THE CAT::HOMOTOPY-EQUIVALENCE +; (CAT::FIBRATION-TOTAL-EFHM (SECOND (CAT::ORGN CAT::SMST)))) +; +; note: type assertion too complex to check: +; (VALUES HOMOTOPY-EQUIVALENCE &REST T). +; +; compilation unit finished +; printed 4 notes + + +; C:/home/quicklisp/local-projects/kenzo/src/serre.fasl written +; compilation finished in 0:00:00.121 +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/cs-twisted-products +.lisp" (written 24 DEC 2014 11:02:17 PM): +; compiling (IN-PACKAGE #:CAT) +; compiling (PROVIDE "cs-twisted-products") +; compiling (DEFUN SMGR-FIBRATION-SINTR ...) +; compiling (DEFUN SMGR-FIBRATION ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/cs-twisted-products.lisp +; in: DEFUN SMGR-FIBRATION +; (THE CAT::FIBRATION +; (CAT::BUILD-SMMR :SORC (CAT::CLASSIFYING-SPACE CAT::SMGR) :TRGT +; CAT::SMGR :DEGR -1 :SINTR #'CAT::SMGR-FIBRATION-SINT +R +; :ORGN `(CAT::SIMPLICIAL-GROUP-FIBRATION ,CAT::SMGR)) +) +; +; note: type assertion too complex to check: +; (VALUES &OPTIONAL (SATISFIES FIBRATION-P) &REST T). + +; compiling (DEFUN SMGR-CRTS-CONTRACTION-INTR ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/cs-twisted-products.lisp +; in: DEFUN SMGR-CRTS-CONTRACTION-INTR +; (THE CAT::CMBN +; (CAT::WITH-CRPR (CAT::ABSM1 CAT::ABSM2) CAT::CRPR +; (IF (= (CAT::DGOP CAT::ABSM2) (CAT::MASK CAT::DEGR)) +; (CAT::ZERO-CMBN CAT::DEGR+1) +; (CAT::TERM-CMBN CAT::DEGR+1 +; (CAT::-1-EXPT-N+1 CAT::DEGR) +; (CAT::CRPR 0 # # CAT::IDNT))))) +; +; note: type assertion too complex to check: +; (VALUES CMBN &REST T). + +; compiling (DEFUN SMGR-CRTS-CONTRACTION ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/cs-twisted-products.lisp +; in: DEFUN SMGR-CRTS-CONTRACTION +; (THE CAT::MORPHISM +; (CAT::BUILD-MRPH :SORC +; (CAT::FIBRATION-TOTAL (CAT::SMGR-FIBRATION CAT::SMGR +)) +; :TRGT +; (CAT::FIBRATION-TOTAL (CAT::SMGR-FIBRATION CAT::SMGR +)) +; :DEGR 1 :INTR +; (CAT::SMGR-CRTS-CONTRACTION-INTR (CAT::BSPN CAT::SMG +R)) +; :STRT :GNRT :ORGN ...)) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFUN SMGR-TNPR-CONTRACTION ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/cs-twisted-products.lisp +; in: DEFUN SMGR-TNPR-CONTRACTION +; (THE CAT::MORPHISM (CAT::I-CMPS CAT::F CAT::CHI CAT::G)) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). +; +; compilation unit finished +; printed 4 notes + + +; C:/home/quicklisp/local-projects/kenzo/src/cs-twisted-products.fasl written +; compilation finished in 0:00:00.096 +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/cl-space-efhm.lisp" + (written 24 DEC 2014 11:02:36 PM): +; compiling (IN-PACKAGE #:CAT) +; compiling (PROVIDE "cl-space-efhm") +; compiling (DEFUN CS-HAT-U-U ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/cl-space-efhm.lisp +; in: DEFUN CS-HAT-U-U +; (THE CAT::CHAIN-COMPLEX (CAT::TNSR-PRDC CAT::CLSP-TNSR-SMGR CAT::BAR)) +; +; note: type assertion too complex to check: +; (VALUES CHAIN-COMPLEX &REST T). + +; compiling (DEFUN CS-HAT-RIGHT-PERTURBATION-INTR ...) +; compiling (DEFUN CS-HAT-RIGHT-PERTURBATION ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/cl-space-efhm.lisp +; in: DEFUN CS-HAT-RIGHT-PERTURBATION +; (THE CAT::MORPHISM +; (CAT::BUILD-MRPH :SORC CAT::HAT-U-U :TRGT CAT::HAT-U-U :DEGR -1 :INTR + +; (CAT::CS-HAT-RIGHT-PERTURBATION-INTR CAT::SMGR) :STR +T +; :GNRT :ORGN ...)) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFUN CS-HAT-U-T ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/cl-space-efhm.lisp +; in: DEFUN CS-HAT-U-T +; (THE CAT::CHAIN-COMPLEX +; (PROGN +; (SETF (SLOT-VALUE CAT::HAT-RIGHT-PERTURBATION 'CAT::SORC) CAT::HAT-U +-U +; (SLOT-VALUE CAT::HAT-RIGHT-PERTURBATION 'CAT::TRGT) CAT::HAT-U +-U) +; (CAT::ADD CAT::HAT-U-U CAT::HAT-RIGHT-PERTURBATION))) +; +; note: type assertion too complex to check: +; (VALUES CHAIN-COMPLEX &REST T). + +; compiling (DEFUN CS-HAT-LEFT-PERTURBATION ...) +; compiling (DEFUN CS-HAT-T-U ...) +; compiling (DEFUN CS-LEFT-HMEQ-HAT ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/cl-space-efhm.lisp +; in: DEFUN CS-LEFT-HMEQ-HAT +; (THE CAT::CHAIN-COMPLEX (CAT::ADD CAT::HAT-T-U CAT::HAT-RIGHT-PERTURBATION +)) +; +; note: type assertion too complex to check: +; (VALUES CHAIN-COMPLEX &REST T). + +; compiling (DEFUN CS-PRE-LEFT-HMEQ-LEFT-REDUCTION-INTR-F ...) +; compiling (DEFUN CS-PRE-LEFT-HMEQ-LEFT-REDUCTION-F ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/cl-space-efhm.lisp +; in: DEFUN CS-PRE-LEFT-HMEQ-LEFT-REDUCTION-F +; (THE CAT::MORPHISM +; (CAT::BUILD-MRPH :SORC CAT::HAT-U-T :TRGT CAT::CLASSIFYING-SPACE :DEG +R 0 +; :INTR #'CAT::CS-PRE-LEFT-HMEQ-LEFT-REDUCTION-INTR-F +; :STRT :CMBN :ORGN ...)) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFUN CS-PRE-LEFT-HMEQ-LEFT-REDUCTION-INTR-G ...) +; compiling (DEFUN CS-PRE-LEFT-HMEQ-LEFT-REDUCTION-G ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/cl-space-efhm.lisp +; in: DEFUN CS-PRE-LEFT-HMEQ-LEFT-REDUCTION-G +; (THE CAT::MORPHISM +; (CAT::BUILD-MRPH :SORC CAT::CLASSIFYING-SPACE :TRGT CAT::HAT-U-T :DEG +R 0 +; :INTR +; (CAT::CS-PRE-LEFT-HMEQ-LEFT-REDUCTION-INTR-G +; (CAT::BSPN CAT::SMGR)) +; :STRT :CMBN :ORGN ...)) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFUN CS-PRE-LEFT-HMEQ-LEFT-REDUCTION-INTR-H ...) +; compiling (DEFUN CS-PRE-LEFT-HMEQ-LEFT-REDUCTION-H ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/cl-space-efhm.lisp +; in: DEFUN CS-PRE-LEFT-HMEQ-LEFT-REDUCTION-H +; (THE CAT::MORPHISM +; (CAT::BUILD-MRPH :SORC CAT::HAT-U-T :TRGT CAT::HAT-U-T :DEGR 1 :INTR +; (CAT::CS-PRE-LEFT-HMEQ-LEFT-REDUCTION-INTR-H +; (CAT::CMPR CAT::HAT-U-T) (CAT::BSPN CAT::SMGR)) +; :STRT :CMBN :ORGN ...)) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFUN CS-PRE-LEFT-HMEQ-LEFT-REDUCTION ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/cl-space-efhm.lisp +; in: DEFUN CS-PRE-LEFT-HMEQ-LEFT-REDUCTION +; (THE CAT::REDUCTION +; (CAT::BUILD-RDCT :F (CAT::CS-PRE-LEFT-HMEQ-LEFT-REDUCTION-F CAT::SMGR +) +; :G (CAT::CS-PRE-LEFT-HMEQ-LEFT-REDUCTION-G CAT::SMGR +) +; :H (CAT::CS-PRE-LEFT-HMEQ-LEFT-REDUCTION-H CAT::SMGR +) +; :ORGN +; `(CAT::CS-PRE-LEFT-HMEQ-LEFT-REDUCTION ,CAT::SMGR))) + +; +; note: type assertion too complex to check: +; (VALUES REDUCTION &REST T). + +; compiling (DEFUN CS-LEFT-HMEQ-LEFT-REDUCTION ...) +; compiling (DEFUN CS-PRE-LEFT-HMEQ-RIGHT-REDUCTION-INTR-F ...) +; compiling (DEFUN CS-PRE-LEFT-HMEQ-RIGHT-REDUCTION-F ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/cl-space-efhm.lisp +; in: DEFUN CS-PRE-LEFT-HMEQ-RIGHT-REDUCTION-F +; (THE CAT::MORPHISM +; (CAT::BUILD-MRPH :SORC CAT::HAT-T-U :TRGT CAT::BAR :DEGR 0 :INTR +; #'CAT::CS-PRE-LEFT-HMEQ-RIGHT-REDUCTION-INTR-F :STRT + +; :CMBN :ORGN ...)) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFUN CS-PRE-LEFT-HMEQ-RIGHT-REDUCTION-INTR-G ...) +; compiling (DEFUN CS-PRE-LEFT-HMEQ-RIGHT-REDUCTION-G ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/cl-space-efhm.lisp +; in: DEFUN CS-PRE-LEFT-HMEQ-RIGHT-REDUCTION-G +; (THE CAT::MORPHISM +; (CAT::BUILD-MRPH :SORC CAT::BAR :TRGT CAT::HAT-T-U :DEGR 0 :INTR +; (CAT::CS-PRE-LEFT-HMEQ-RIGHT-REDUCTION-INTR-G +; CAT::IDNT) +; :STRT :CMBN :ORGN ...)) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFUN CS-PRE-LEFT-HMEQ-RIGHT-REDUCTION-H ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/cl-space-efhm.lisp +; in: DEFUN CS-PRE-LEFT-HMEQ-RIGHT-REDUCTION-H +; (THE CAT::MORPHISM +; (CAT::TNSR-PRDC CAT::TNPR-CONTRACTION (CAT::IDNT-MRPH CAT::BAR))) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). + +; compiling (DEFUN CS-PRE-LEFT-HMEQ-RIGHT-REDUCTION ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/cl-space-efhm.lisp +; in: DEFUN CS-PRE-LEFT-HMEQ-RIGHT-REDUCTION +; (THE CAT::REDUCTION +; (CAT::BUILD-RDCT :F (CAT::CS-PRE-LEFT-HMEQ-RIGHT-REDUCTION-F CAT::SMG +R) +; :G (CAT::CS-PRE-LEFT-HMEQ-RIGHT-REDUCTION-G CAT::SMG +R) +; :H (CAT::CS-PRE-LEFT-HMEQ-RIGHT-REDUCTION-H CAT::SMG +R) +; :ORGN +; `(CAT::CS-PRE-LEFT-HMEQ-RIGHT-REDUCTION ,CAT::SMGR)) +) +; +; note: type assertion too complex to check: +; (VALUES REDUCTION &REST T). + +; compiling (DEFUN CS-LEFT-HMEQ-RIGHT-REDUCTION ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/cl-space-efhm.lisp +; in: DEFUN CS-LEFT-HMEQ-RIGHT-REDUCTION +; (THE CAT::REDUCTION +; (PROGN +; (SETF (SLOT-VALUE CAT::PERTURBATION 'CAT::SORC) +; (CAT::TCC CAT::PRE-REDUCTION) +; (SLOT-VALUE CAT::PERTURBATION 'CAT::TRGT) +; (CAT::TCC CAT::PRE-REDUCTION)) +; (CAT::SPECIAL-BPL-2 CAT::PRE-REDUCTION CAT::PERTURBATION))) +; +; note: type assertion too complex to check: +; (VALUES REDUCTION &REST T). + +; compiling (DEFUN CS-LEFT-HMEQ ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/cl-space-efhm.lisp +; in: DEFUN CS-LEFT-HMEQ +; (THE CAT::HOMOTOPY-EQUIVALENCE +; (CAT::BUILD-HMEQ :LRDCT (CAT::CS-LEFT-HMEQ-LEFT-REDUCTION CAT::SMGR) +; :RRDCT (CAT::CS-LEFT-HMEQ-RIGHT-REDUCTION CAT::SMGR) + +; :ORGN `(CAT::CS-LEFT-HMEQ ,CAT::SMGR))) +; +; note: type assertion too complex to check: +; (VALUES HOMOTOPY-EQUIVALENCE &REST T). + +; compiling (DEFUN CLASSIFYING-SPACE-EFHM ...) +; compiling (DEFMETHOD SEARCH-EFHM ...); +; compilation unit finished +; printed 14 notes + + +; C:/home/quicklisp/local-projects/kenzo/src/cl-space-efhm.fasl written +; compilation finished in 0:00:00.382 +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/whitehead.lisp" (wr +itten 24 DEC 2014 11:02:57 PM): +; compiling (IN-PACKAGE #:CAT) +; compiling (PROVIDE "whitehead") +; compiling (DEFUN Z-WWHITEHEAD-SINTR ...) +; compiling (DEFUN Z-WHITEHEAD-SINTR ...) +; compiling (DEFUN Z-WHITEHEAD ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/whitehead.lisp +; in: DEFUN Z-WHITEHEAD +; (THE CAT::FIBRATION +; (CAT::BUILD-SMMR :SORC CAT::SMST :TRGT (CAT::K-Z (1- CAT::N)) :DEGR - +1 +; :SINTR +; (CAT::Z-WHITEHEAD-SINTR CAT::SMST CAT::N +; CAT::CHML-CLSS) +; :ORGN `(CAT::Z-WHITEHEAD ,CAT::SMST))) +; +; note: type assertion too complex to check: +; (VALUES &OPTIONAL (SATISFIES FIBRATION-P) &REST T). + +; compiling (DEFUN Z2-WWHITEHEAD-SINTR ...) +; compiling (DEFUN Z2-WHITEHEAD-SINTR ...) +; compiling (DEFUN Z2-WHITEHEAD ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/whitehead.lisp +; in: DEFUN Z2-WHITEHEAD +; (THE CAT::FIBRATION +; (CAT::BUILD-SMMR :SORC CAT::SMST :TRGT (CAT::K-Z2 (1- CAT::N)) :DEGR +-1 +; :SINTR +; (CAT::Z2-WHITEHEAD-SINTR CAT::SMST CAT::N +; CAT::CHML-CLSS) +; :ORGN `(CAT::Z2-WHITEHEAD ,CAT::SMST))) +; +; note: type assertion too complex to check: +; (VALUES &OPTIONAL (SATISFIES FIBRATION-P) &REST T). +; +; compilation unit finished +; printed 2 notes + + +; C:/home/quicklisp/local-projects/kenzo/src/whitehead.fasl written +; compilation finished in 0:00:00.084 +; compiling file "C:/home/quicklisp/local-projects/kenzo/src/smith.lisp" (writte +n 24 DEC 2014 11:03:15 PM): +; compiling (IN-PACKAGE #:CAT) +; compiling (PROVIDE "smith") +; compiling (DEFTYPE MATRIX ...) +; compiling (DEFUN RANDOM-MATRIX ...) +; compiling (DEFUN IDNT-MTRX ...) +; compiling (DEFUN COPY-MTRX ...) +; compiling (DEFUN LEFT-SUBMATRIX ...) +; compiling (DEFUN MTRX-PRDC ...) +; compiling (DEFUN CHCM-MTRX ...) +; compiling (DEFUN LINE-OP ...) +; compiling (DEFUN COLUMN-OP ...) +; compiling (DEFUN LINE-SWAP ...) +; compiling (DEFUN COLUMN-SWAP ...) +; compiling (DEFUN LINE-MINUS ...) +; compiling (DEFUN COLUMN-MINUS ...) +; compiling (DEFUN MINIMAL-TERM ...) +; compiling (DEFUN MINIMAL-REST-1 ...) +; compiling (DEFUN MINIMAL-REST-2 ...) +; compiling (DEFUN MINIMAL-TERM-TOP-LEFT ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/smith.lisp +; in: DEFUN MINIMAL-TERM-TOP-LEFT +; (THE CAT::MATRIX +; (PROGN +; (WHEN (< CAT::BEGIN CAT::IL) +; (CAT::LINE-SWAP-5 CAT::MTRX-LIST CAT::BEGIN CAT::BEGIN CAT::IL)) +; (WHEN (< CAT::BEGIN CAT::IC) +; (CAT::COLUMN-SWAP-5 CAT::MTRX-LIST CAT::BEGIN CAT::BEGIN CAT::IC)) + +; (WHEN (MINUSP (AREF # CAT::BEGIN CAT::BEGIN)) +; (CAT::LINE-MINUS-5 CAT::MTRX-LIST CAT::BEGIN CAT::BEGIN)) +; CAT::MTRX-LIST)) +; +; note: deleting unreachable code +; +; caught WARNING: +; Derived type of MTRX-LIST is +; (VALUES LIST &OPTIONAL), +; conflicting with its asserted type +; (ARRAY FIXNUM (* *)). +; See also: +; The SBCL Manual, Node "Handling of Types" + +; compiling (DEFUN PIVOTT ...) +; compiling (DEFUN LIST-SMITH ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/smith.lisp +; in: DEFUN LIST-SMITH +; (PROGN +; (LET ((CAT::MATRIX (THIRD CAT::MTRX-LIST)) (CAT::BEGIN 0)) +; (DECLARE (TYPE CAT::MATRIX CAT::MATRIX) +; (FIXNUM CAT::BEGIN)) +; (LOOP +; (MULTIPLE-VALUE-BIND (CAT::TERM CAT::IL CAT::IC) +; (CAT::MINIMAL-TERM CAT::MATRIX CAT::BEGIN) +; (DECLARE #) +; (WHEN # #) +; (CAT::MINIMAL-TERM-TOP-LEFT CAT::MTRX-LIST CAT::BEGIN CAT::IL CAT::I +C)) +; (LOOP (MULTIPLE-VALUE-BIND # # # #)) +; (INCF CAT::BEGIN))) +; CAT::MTRX-LIST) +; ==> +; CAT::MTRX-LIST +; +; note: deleting unreachable code + +; compiling (DEFUN SMITH ...) +; compiling (UNLESS (FIND-PACKAGE "GNRTS") ...) +; compiling (DEFCONSTANT +GNRTS-PCKG+ ...) +; compiling (DEFUN GNRT-NAME-BASIS ...) +; compiling (DEFUN ECHCM-KILL-EPI-F-INTR ...) +; compiling (DEFUN ECHCM-KILL-EPI-G-INTR ...) +; compiling (DEFUN ECHCM-KILL-EPI-H-INTR ...) +; compiling (DEFUN ECHCM-WITHOUT-EPI ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/smith.lisp +; in: DEFUN ECHCM-WITHOUT-EPI +; (THE CAT::CHAIN-COMPLEX +; (WITH-SLOTS (CAT::CMPR CAT::BASIS CAT::DFFR CAT::ORGN) +; CAT::ECHCM +; (DECLARE (TYPE CAT::CMPRF CAT::CMPR) +; (TYPE CAT::BASIS CAT::BASIS) +; (TYPE CAT::MORPHISM CAT::DFFR) +; (LIST CAT::ORGN)) +; (CAT::BUILD-CHCM :CMPR +; #'(LAMBDA (CAT::GNRT1 CAT::GNRT2) +; (IF # +; # +; #)) +; :BASIS +; #'(LAMBDA (CAT::DEGR) (DECLARE #) (COND # # #)) +; :INTR-DFFR +; #'(LAMBDA (CAT::CMBN) (DECLARE #) (CASE # # # #)) +; :STRT :CMBN :ORGN +; `(CAT::ECHCM-WITHOUT-EPI ,CAT::ECHCM)))) +; +; note: type assertion too complex to check: +; (VALUES CHAIN-COMPLEX &REST T). + +; compiling (DEFUN ECHCM-KILL-EPI ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/smith.lisp +; in: DEFUN ECHCM-KILL-EPI +; (THE CAT::REDUCTION +; (WITH-SLOTS (CAT::CMPR CAT::BASIS) +; CAT::ECHCM +; (DECLARE (TYPE CAT::CMPRF CAT::CMPR) +; (TYPE CAT::BASIS CAT::BASIS)) +; (ASSERT (NOT (EQ CAT::BASIS :LOCALLY-EFFECTIVE))) +; (LET* ((CAT::F-BASIS #) +; (CAT::F+1-BASIS #) +; (CAT::MTRX-LIST #) +; (CAT::SMITH #) +; (CAT::M #) +; (CAT::N #) +; (CAT::INTR-F #) +; (CAT::INTR-G #) +; (CAT::INTR-H #) +; (CAT::ECHCM2 #)) +; (DECLARE (LIST CAT::MTRX-LIST) +; (TYPE CAT::MATRIX CAT::SMITH) +; (FIXNUM CAT::M CAT::N) +; (TYPE CAT::INTR-MRPH CAT::INTR-F CAT::INTR-G CAT::INTR-H +) +; (TYPE CAT::CHAIN-COMPLEX CAT::ECHCM2)) +; (ASSERT (DOTIMES # #)) +; (CAT::BUILD-RDCT :F +; (CAT::BUILD-MRPH :SORC CAT::ECHCM :TRGT CAT::ECH +CM2 +; :DEGR 0 :INTR CAT::INTR-F :STRT + +; :CMBN :ORGN ...) +; :G +; (CAT::BUILD-MRPH :SORC CAT::ECHCM2 :TRGT CAT::EC +HCM +; :DEGR 0 :INTR CAT::INTR-G :STRT + +; :CMBN :ORGN ...) +; :H +; (CAT::BUILD-MRPH :SORC CAT::ECHCM :TRGT CAT::ECH +CM +; :DEGR 1 :INTR CAT::INTR-H :STRT + +; :CMBN :ORGN ...) +; :ORGN `(CAT::ECHCM-KILL-EPI ,CAT::ECHCM))))) +; +; note: type assertion too complex to check: +; (VALUES REDUCTION &REST T). + +; compiling (DEFUN KILL-EPI ...) +; compiling (DEFUN KILL-EPIS ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/smith.lisp +; in: DEFUN KILL-EPIS +; (THE CAT::HOMOTOPY-EQUIVALENCE +; (PROGN +; (DO ((CAT::INDX FIRST #)) +; ((= CAT::INDX CAT::END)) +; (DECLARE (FIXNUM CAT::INDX)) +; (CAT::KILL-EPI CAT::CHCM CAT::INDX)) +; (CAT::EFHM CAT::CHCM))) +; +; note: type assertion too complex to check: +; (VALUES HOMOTOPY-EQUIVALENCE &REST T). + +; compiling (DEFUN CHML-CLSS-INTR ...) +; compiling (DEFUN CHML-CLSS ...) +; file: C:/home/quicklisp/local-projects/kenzo/src/smith.lisp +; in: DEFUN CHML-CLSS +; (THE CAT::MORPHISM +; (CAT::BUILD-MRPH :SORC (CAT::ECHCM CAT::CHCM) :TRGT (CAT::Z-CHCM) :DE +GR +; (- FIRST) :INTR (CAT::CHML-CLSS-INTR CAT::CHCM FIRST +) +; :STRT :CMBN :ORGN ...)) +; +; note: type assertion too complex to check: +; (VALUES MORPHISM &REST T). +; +; compilation unit finished +; caught 1 WARNING condition +; printed 6 notes + + +; C:/home/quicklisp/local-projects/kenzo/src/smith.fasl written +; compilation finished in 0:00:00.451 +("kenzo" "macros" "various" "classes" "combinations" "chain-complexes" + "chcm-elementary-op" "effective-homology" "homology-groups" + "searching-homology" ...) +* (load-cfiles) + +("kenzo" "macros" "various" "classes" "combinations" "chain-complexes" + "chcm-elementary-op" "effective-homology" "homology-groups" + "searching-homology" ...) +* (exit) + +C:\home\quicklisp\local-projects\kenzo\src> diff --git a/kenzo.asd b/kenzo.asd index 91bbc2f..df9bb72 100644 --- a/kenzo.asd +++ b/kenzo.asd @@ -11,9 +11,9 @@ :description "A Symbolic Software for Effective Homology Computation by Francis Sergeraert" :serial t :components ((:file "package") - (:file "kenzo") (:module "src" - :components ((:file "macros") + :components ((:file "kenzo") + (:file "macros") (:file "various") (:file "classes") (:file "combinations") diff --git a/src/cat-init.lisp b/src/cat-init.lisp index a5a7564..39302e8 100644 --- a/src/cat-init.lisp +++ b/src/cat-init.lisp @@ -2,6 +2,9 @@ ;;; FILES FILES FILES FILES FILES FILES FILES FILES FILES FILES ;;; FILES FILES FILES FILES FILES FILES FILES FILES FILES FILES +(DEFPACKAGE :CAT + (:USE CL)) + (IN-PACKAGE "COMMON-LISP-USER") (DEFUN KENZO-VERSION () @@ -11,7 +14,8 @@ (PROCLAIM '(OPTIMIZE (speed 3) (safety 1) (space 0) (debug 0))) (DEFCONSTANT +FILE-LIST+ - '("macros" + '("kenzo" + "macros" "various" "classes" "combinations" @@ -28,16 +32,16 @@ "algebras" "bar" "simplicial-sets" - "simplicial-mrphs" + "simplicial-mrphs" "delta" "special-smsts" "suspensions" "disk-pasting" - "cartesian-products" + "cartesian-products" "eilenberg-zilber" "kan" "simplicial-groups" - "fibrations" + "fibrations" "loop-spaces" "ls-twisted-products" "lp-space-efhm" @@ -57,13 +61,16 @@ (DEFCONSTANT +SOURCE-EXTENSION+ #+(or allegro clisp lispworks) "cl" - #-(or allegro clisp lispworks) - (error "Not an Allegro or CLisp or LispWorks environment.")) + #+(or sbcl) "lisp" + #-(or allegro clisp lispworks sbcl) + (error "Not an Allegro or CLisp or LispWorks or SBCL environment.")) (DEFCONSTANT +COMPILED-EXTENSION+ #+allegro "fasl" #+clisp "fas" - #+lispworks "ofasl") + #+lispworks "ofasl" + #+sbcl "fasl" + ) (DEFUN LOAD-SFILES () (mapc #'(lambda (file-name) diff --git a/kenzo.lisp b/src/kenzo.lisp similarity index 100% rename from kenzo.lisp rename to src/kenzo.lisp