src/algebra/strap/PSETCAT.lsp


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

(/VERSIONCHECK 2) 

(DEFPARAMETER |PolynomialSetCategory;CAT| 'NIL) 

(DEFPARAMETER |PolynomialSetCategory;AL| 'NIL) 

(DEFUN |PolynomialSetCategory;| (|t#1| |t#2| |t#3| |t#4|)
  (PROG (#0=#:G1431)
    (RETURN
      (PROG1 (LETT #0#
                   (|sublisV|
                       (PAIR '(|t#1| |t#2| |t#3| |t#4|)
                             (LIST (|devaluate| |t#1|)
                                   (|devaluate| |t#2|)
                                   (|devaluate| |t#3|)
                                   (|devaluate| |t#4|)))
                       (|sublisV|
                           (PAIR '(#1=#:G1430) (LIST '(|List| |t#4|)))
                           (COND
                             (|PolynomialSetCategory;CAT|)
                             ('T
                              (LETT |PolynomialSetCategory;CAT|
                                    (|Join| (|SetCategory|)
                                     (|Collection| '|t#4|)
                                     (|CoercibleTo| '#1#)
                                     (|mkCategory| '|domain|
                                      '(((|retractIfCan|
                                          ((|Union| $ "failed")
                                           (|List| |t#4|)))
                                         T)
                                        ((|retract| ($ (|List| |t#4|)))
                                         T)
                                        ((|mvar| (|t#3| $)) T)
                                        ((|variables|
                                          ((|List| |t#3|) $))
                                         T)
                                        ((|mainVariables|
                                          ((|List| |t#3|) $))
                                         T)
                                        ((|mainVariable?|
                                          ((|Boolean|) |t#3| $))
                                         T)
                                        ((|collectUnder| ($ $ |t#3|))
                                         T)
                                        ((|collect| ($ $ |t#3|)) T)
                                        ((|collectUpper| ($ $ |t#3|))
                                         T)
                                        ((|sort|
                                          ((|Record| (|:| |under| $)
                                            (|:| |floor| $)
                                            (|:| |upper| $))
                                           $ |t#3|))
                                         T)
                                        ((|trivialIdeal?|
                                          ((|Boolean|) $))
                                         T)
                                        ((|roughBase?| ((|Boolean|) $))
                                         (|has| |t#1|
                                          (|IntegralDomain|)))
                                        ((|roughSubIdeal?|
                                          ((|Boolean|) $ $))
                                         (|has| |t#1|
                                          (|IntegralDomain|)))
                                        ((|roughEqualIdeals?|
                                          ((|Boolean|) $ $))
                                         (|has| |t#1|
                                          (|IntegralDomain|)))
                                        ((|roughUnitIdeal?|
                                          ((|Boolean|) $))
                                         (|has| |t#1|
                                          (|IntegralDomain|)))
                                        ((|headRemainder|
                                          ((|Record| (|:| |num| |t#4|)
                                            (|:| |den| |t#1|))
                                           |t#4| $))
                                         (|has| |t#1|
                                          (|IntegralDomain|)))
                                        ((|remainder|
                                          ((|Record| (|:| |rnum| |t#1|)
                                            (|:| |polnum| |t#4|)
                                            (|:| |den| |t#1|))
                                           |t#4| $))
                                         (|has| |t#1|
                                          (|IntegralDomain|)))
                                        ((|rewriteIdealWithHeadRemainder|
                                          ((|List| |t#4|)
                                           (|List| |t#4|) $))
                                         (|has| |t#1|
                                          (|IntegralDomain|)))
                                        ((|rewriteIdealWithRemainder|
                                          ((|List| |t#4|)
                                           (|List| |t#4|) $))
                                         (|has| |t#1|
                                          (|IntegralDomain|)))
                                        ((|triangular?|
                                          ((|Boolean|) $))
                                         (|has| |t#1|
                                          (|IntegralDomain|))))
                                      '((|finiteAggregate| T))
                                      '((|Boolean|) (|List| |t#4|)
                                        (|List| |t#3|))
                                      NIL))
                                    . #2=(|PolynomialSetCategory|)))))) . #2#)
        (SETELT #0# 0
                (LIST '|PolynomialSetCategory| (|devaluate| |t#1|)
                      (|devaluate| |t#2|) (|devaluate| |t#3|)
                      (|devaluate| |t#4|))))))) 

(DEFUN |PolynomialSetCategory| (&REST #0=#:G1434 &AUX #1=#:G1432)
  (DSETQ #1# #0#)
  (LET (#2=#:G1433)
    (COND
      ((SETQ #2#
             (|assoc| (|devaluateList| #1#) |PolynomialSetCategory;AL|))
       (CDR #2#))
      (T (SETQ |PolynomialSetCategory;AL|
               (|cons5| (CONS (|devaluateList| #1#)
                              (SETQ #2#
                                    (APPLY #'|PolynomialSetCategory;|
                                     #1#)))
                        |PolynomialSetCategory;AL|))
         #2#)))) 

(SETQ |$CategoryFrame|
      (|put| '|PolynomialSetCategory| '|isCategory| T
             (|addModemap| '|PolynomialSetCategory|
                 '(|PolynomialSetCategory| |#1| |#2| |#3| |#4|)
                 '((|Category|) (|Ring|) (|OrderedAbelianMonoidSup|)
                   (|OrderedSet|)
                   (|RecursivePolynomialCategory| |t#1| |t#2| |t#3|))
                 T '|PolynomialSetCategory| |$CategoryFrame|)))