
(/VERSIONCHECK 2) 

(DEFPARAMETER |RectangularMatrixCategory;CAT| 'NIL) 

(DEFPARAMETER |RectangularMatrixCategory;AL| 'NIL) 

(DEFUN |RectangularMatrixCategory| (&REST #1=#:G10859)
  (LET (#2=#:G10860)
    (COND
     ((SETQ #2#
              (|assoc| #3=(|devaluateList| #1#)
                       |RectangularMatrixCategory;AL|))
      (CDR #2#))
     (T
      (SETQ |RectangularMatrixCategory;AL|
              (|cons5|
               (CONS #3# (SETQ #2# (APPLY #'|RectangularMatrixCategory;| #1#)))
               |RectangularMatrixCategory;AL|))
      #2#)))) 

(DEFUN |RectangularMatrixCategory;| (|t#1| |t#2| |t#3| |t#4| |t#5|)
  (PROG (#1=#:G10858)
    (RETURN
     (PROG1
         (LETT #1#
               (|sublisV|
                (PAIR '(|t#1| |t#2| |t#3| |t#4| |t#5|)
                      (LIST (|devaluate| |t#1|) (|devaluate| |t#2|)
                            (|devaluate| |t#3|) (|devaluate| |t#4|)
                            (|devaluate| |t#5|)))
                (COND (|RectangularMatrixCategory;CAT|)
                      ('T
                       (LETT |RectangularMatrixCategory;CAT|
                             (|Join| (|BiModule| '|t#3| '|t#3|)
                                     (|HomogeneousAggregate| '|t#3|)
                                     (|finiteAggregate|)
                                     (|mkCategory| '|domain|
                                                   '(((|matrix|
                                                       ($
                                                        (|List|
                                                         (|List| |t#3|))))
                                                      T)
                                                     ((|square?|
                                                       ((|Boolean|) $))
                                                      T)
                                                     ((|diagonal?|
                                                       ((|Boolean|) $))
                                                      T)
                                                     ((|symmetric?|
                                                       ((|Boolean|) $))
                                                      T)
                                                     ((|antisymmetric?|
                                                       ((|Boolean|) $))
                                                      T)
                                                     ((|minRowIndex|
                                                       ((|Integer|) $))
                                                      T)
                                                     ((|maxRowIndex|
                                                       ((|Integer|) $))
                                                      T)
                                                     ((|minColIndex|
                                                       ((|Integer|) $))
                                                      T)
                                                     ((|maxColIndex|
                                                       ((|Integer|) $))
                                                      T)
                                                     ((|nrows|
                                                       ((|NonNegativeInteger|)
                                                        $))
                                                      T)
                                                     ((|ncols|
                                                       ((|NonNegativeInteger|)
                                                        $))
                                                      T)
                                                     ((|listOfLists|
                                                       ((|List| (|List| |t#3|))
                                                        $))
                                                      T)
                                                     ((|elt|
                                                       (|t#3| $ (|Integer|)
                                                        (|Integer|)))
                                                      T)
                                                     ((|qelt|
                                                       (|t#3| $ (|Integer|)
                                                        (|Integer|)))
                                                      T)
                                                     ((|elt|
                                                       (|t#3| $ (|Integer|)
                                                        (|Integer|) |t#3|))
                                                      T)
                                                     ((|row|
                                                       (|t#4| $ (|Integer|)))
                                                      T)
                                                     ((|column|
                                                       (|t#5| $ (|Integer|)))
                                                      T)
                                                     ((|map|
                                                       ($
                                                        (|Mapping| |t#3| |t#3|)
                                                        $))
                                                      T)
                                                     ((|map|
                                                       ($
                                                        (|Mapping| |t#3| |t#3|
                                                                   |t#3|)
                                                        $ $))
                                                      T)
                                                     ((|exquo|
                                                       ((|Union| $ "failed") $
                                                        |t#3|))
                                                      (|has| |t#3|
                                                             (|IntegralDomain|)))
                                                     ((/ ($ $ |t#3|))
                                                      (|has| |t#3| (|Field|)))
                                                     ((|rowEchelon| ($ $))
                                                      (|has| |t#3|
                                                             (|EuclideanDomain|)))
                                                     ((|columnSpace|
                                                       ((|List| |t#5|) $))
                                                      (|has| |t#3|
                                                             (|EuclideanDomain|)))
                                                     ((|rank|
                                                       ((|NonNegativeInteger|)
                                                        $))
                                                      (|has| |t#3|
                                                             (|IntegralDomain|)))
                                                     ((|nullity|
                                                       ((|NonNegativeInteger|)
                                                        $))
                                                      (|has| |t#3|
                                                             (|IntegralDomain|)))
                                                     ((|nullSpace|
                                                       ((|List| |t#5|) $))
                                                      (|has| |t#3|
                                                             (|IntegralDomain|))))
                                                   '(((|Finite|)
                                                      (|has| |t#3| (|Finite|)))
                                                     ((|Module| |t#3|)
                                                      (|has| |t#3|
                                                             (|CommutativeRing|))))
                                                   '((|List| |t#5|)
                                                     (|NonNegativeInteger|)
                                                     (|Integer|)
                                                     (|List| (|List| |t#3|))
                                                     (|Boolean|))
                                                   NIL))
                             . #2=(|RectangularMatrixCategory|)))))
               . #2#)
       (SETELT #1# 0
               (LIST '|RectangularMatrixCategory| (|devaluate| |t#1|)
                     (|devaluate| |t#2|) (|devaluate| |t#3|)
                     (|devaluate| |t#4|) (|devaluate| |t#5|))))))) 
