4653 lines
174 KiB
Plaintext
4653 lines
174 KiB
Plaintext
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>
|