mmarco/kenzo
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
testing
kenzo/doc/How-to-Compile-Kenzo-with-SBCL.txt

4653 lines
174 KiB
Plaintext
Raw Permalink Blame History

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 <http://www.sbcl.org/>.
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 <A-B< ...)
; compiling (DEFUN <A-B> ...)
; compiling (DEFUN >A-B< ...)
; compiling (DEFUN >A-B> ...)
; compiling (DEFUN V<A-B> ...)
; 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>
Reference in New Issue View Git Blame Copy Permalink