src/algebra/strap/ES.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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

(/VERSIONCHECK 2) 

(DEFPARAMETER |ExpressionSpace;AL| 'NIL) 

(DEFUN |ExpressionSpace| ()
  (LET (#:G1411)
    (COND
      (|ExpressionSpace;AL|)
      (T (SETQ |ExpressionSpace;AL| (|ExpressionSpace;|)))))) 

(DEFUN |ExpressionSpace;| ()
  (PROG (#0=#:G1409)
    (RETURN
      (PROG1 (LETT #0#
                   (|sublisV|
                       (PAIR '(#1=#:G1407 #2=#:G1408)
                             (LIST '(|Kernel| $) '(|Kernel| $)))
                       (|Join| (|OrderedSet|) (|RetractableTo| '#1#)
                               (|InnerEvalable| '#2# '$)
                               (|Evalable| '$)
                               (|mkCategory| '|domain|
                                   '(((|elt| ($ (|BasicOperator|) $))
                                      T)
                                     ((|elt| ($ (|BasicOperator|) $ $))
                                      T)
                                     ((|elt|
                                       ($ (|BasicOperator|) $ $ $))
                                      T)
                                     ((|elt|
                                       ($ (|BasicOperator|) $ $ $ $))
                                      T)
                                     ((|elt|
                                       ($ (|BasicOperator|) (|List| $)))
                                      T)
                                     ((|subst| ($ $ (|Equation| $))) T)
                                     ((|subst|
                                       ($ $ (|List| (|Equation| $))))
                                      T)
                                     ((|subst|
                                       ($ $ (|List| (|Kernel| $))
                                        (|List| $)))
                                      T)
                                     ((|box| ($ $)) T)
                                     ((|box| ($ (|List| $))) T)
                                     ((|paren| ($ $)) T)
                                     ((|paren| ($ (|List| $))) T)
                                     ((|distribute| ($ $)) T)
                                     ((|distribute| ($ $ $)) T)
                                     ((|height|
                                       ((|NonNegativeInteger|) $))
                                      T)
                                     ((|mainKernel|
                                       ((|Union| (|Kernel| $) "failed")
                                        $))
                                      T)
                                     ((|kernels|
                                       ((|List| (|Kernel| $)) $))
                                      T)
                                     ((|tower|
                                       ((|List| (|Kernel| $)) $))
                                      T)
                                     ((|operators|
                                       ((|List| (|BasicOperator|)) $))
                                      T)
                                     ((|operator|
                                       ((|BasicOperator|)
                                        (|BasicOperator|)))
                                      T)
                                     ((|belong?|
                                       ((|Boolean|) (|BasicOperator|)))
                                      T)
                                     ((|is?|
                                       ((|Boolean|) $
                                        (|BasicOperator|)))
                                      T)
                                     ((|is?|
                                       ((|Boolean|) $ (|Symbol|)))
                                      T)
                                     ((|kernel|
                                       ($ (|BasicOperator|) $))
                                      T)
                                     ((|kernel|
                                       ($ (|BasicOperator|) (|List| $)))
                                      T)
                                     ((|map|
                                       ($ (|Mapping| $ $) (|Kernel| $)))
                                      T)
                                     ((|freeOf?| ((|Boolean|) $ $)) T)
                                     ((|freeOf?|
                                       ((|Boolean|) $ (|Symbol|)))
                                      T)
                                     ((|eval|
                                       ($ $ (|List| (|Symbol|))
                                        (|List| (|Mapping| $ $))))
                                      T)
                                     ((|eval|
                                       ($ $ (|List| (|Symbol|))
                                        (|List|
                                         (|Mapping| $ (|List| $)))))
                                      T)
                                     ((|eval|
                                       ($ $ (|Symbol|)
                                        (|Mapping| $ (|List| $))))
                                      T)
                                     ((|eval|
                                       ($ $ (|Symbol|) (|Mapping| $ $)))
                                      T)
                                     ((|eval|
                                       ($ $ (|List| (|BasicOperator|))
                                        (|List| (|Mapping| $ $))))
                                      T)
                                     ((|eval|
                                       ($ $ (|List| (|BasicOperator|))
                                        (|List|
                                         (|Mapping| $ (|List| $)))))
                                      T)
                                     ((|eval|
                                       ($ $ (|BasicOperator|)
                                        (|Mapping| $ (|List| $))))
                                      T)
                                     ((|eval|
                                       ($ $ (|BasicOperator|)
                                        (|Mapping| $ $)))
                                      T)
                                     ((|minPoly|
                                       ((|SparseUnivariatePolynomial|
                                         $)
                                        (|Kernel| $)))
                                      (|has| $ (|Ring|)))
                                     ((|definingPolynomial| ($ $))
                                      (|has| $ (|Ring|)))
                                     ((|even?| ((|Boolean|) $))
                                      (|has| $
                                       (|RetractableTo| (|Integer|))))
                                     ((|odd?| ((|Boolean|) $))
                                      (|has| $
                                       (|RetractableTo| (|Integer|)))))
                                   NIL
                                   '((|Boolean|)
                                     (|SparseUnivariatePolynomial| $)
                                     (|Kernel| $) (|BasicOperator|)
                                     (|List| (|BasicOperator|))
                                     (|List| (|Mapping| $ (|List| $)))
                                     (|List| (|Mapping| $ $))
                                     (|Symbol|) (|List| (|Symbol|))
                                     (|List| $) (|List| (|Kernel| $))
                                     (|NonNegativeInteger|)
                                     (|List| (|Equation| $))
                                     (|Equation| $))
                                   NIL)))
                   |ExpressionSpace|)
        (SETELT #0# 0 '(|ExpressionSpace|)))))) 

(SETQ |$CategoryFrame|
      (|put| '|ExpressionSpace| '|isCategory| T
             (|addModemap| '|ExpressionSpace| '(|ExpressionSpace|)
                 '((|Category|)) T '|ExpressionSpace| |$CategoryFrame|))) 

(MAKEPROP '|ExpressionSpace| 'NILADIC T)