Index: trunk/src/TAGS
===================================================================
--- trunk/src/TAGS	(revision 18)
+++ trunk/src/TAGS	(revision 19)
@@ -11,301 +11,301 @@
 coefficient-ring.lisp,206
 (defpackage "COEFFICIENT-RING"13,698
-(defstruct ring40,1203
-(defvar *ring-of-integers*59,1995
-(defvar *field-of-rationals*74,2313
-(defun field-modulo-prime 91,2748
-(defvar *coefficient-ring* 110,3437
+(defstruct ring39,1146
+(defvar *ring-of-integers*58,1938
+(defvar *field-of-rationals*73,2256
+(defun field-modulo-prime 90,2691
+(defvar *coefficient-ring* 109,3380
 
 
 colored-poly.lisp,1755
 (defpackage "COLORED-POLY"11,623
-(defmacro debug-cgb 31,1387
-(defun make-colored-poly 34,1484
-(defun make-colored-poly-list 75,2972
-(defun color-poly-list 81,3235
-(defun color-poly 92,3845
-(defun colored-poly-to-poly 108,4324
-(defun colored-poly-print 117,4678
-(defun colored-poly-print-list 151,6122
-(defun determine 176,6987
-(defun determine-1 202,8365
-(defun determine-white-term 217,9039
-(defun determine-white-term 267,11026
-(defun cond-system-print 337,13993
-(defun cond-print 361,15097
-(defun add-pairs 370,15395
-(defun cond-part 386,16050
-(defun cond-hm 391,16206
-(defun delete-green-polys 399,16461
-(defun grobner-system 406,16738
-(defun reorder-pairs 495,20156
-(defun colored-Criterion-1 515,20953
-(defun colored-Criterion-2 523,21221
-(defun cond-normal-form 542,21810
-(defun cond-spoly 602,24035
-(defun cond-lm 631,25152
-(defun cond-lc 637,25351
-(defun colored-term-times-poly 643,25503
-(defun colored-scalar-times-poly 648,25694
-(defun colored-term* 656,25944
-(defun color* 663,26192
-(defun color+ 673,26460
-(defun color- 684,26769
-(defun colored-poly+ 688,26835
-(defun colored-poly- 711,27645
-(defun colored-term-uminus 734,28423
-(defun colored-minus-poly 738,28582
-(defun string-grobner-system 742,28728
-(defun string-cond 768,29721
-(defun string-cover 779,30276
-(defun saturate-cover 787,30610
-(defun saturate-cond 794,30970
-(defun string-determine 801,31271
-(defun tidy-grobner-system 819,31968
-(defun tidy-pair 827,32225
-(defun tidy-cond 848,32948
-(defun colored-reduction 854,33203
-(defun green-reduce-colored-poly 901,34882
-(defun green-reduce-colored-list 914,35404
-(defun cond-system-green-reduce 925,35756
-(defun parse-to-colored-poly-list 936,36089
-(defun red-reduction 949,36823
+(defmacro debug-cgb 30,1330
+(defun make-colored-poly 33,1427
+(defun make-colored-poly-list 74,2915
+(defun color-poly-list 80,3178
+(defun color-poly 91,3788
+(defun colored-poly-to-poly 107,4267
+(defun colored-poly-print 116,4621
+(defun colored-poly-print-list 150,6065
+(defun determine 175,6930
+(defun determine-1 201,8308
+(defun determine-white-term 216,8982
+(defun determine-white-term 266,10969
+(defun cond-system-print 336,13936
+(defun cond-print 360,15040
+(defun add-pairs 369,15338
+(defun cond-part 385,15993
+(defun cond-hm 390,16149
+(defun delete-green-polys 398,16404
+(defun grobner-system 405,16681
+(defun reorder-pairs 494,20099
+(defun colored-Criterion-1 514,20896
+(defun colored-Criterion-2 522,21164
+(defun cond-normal-form 541,21753
+(defun cond-spoly 601,23978
+(defun cond-lm 630,25095
+(defun cond-lc 636,25294
+(defun colored-term-times-poly 642,25446
+(defun colored-scalar-times-poly 647,25637
+(defun colored-term* 655,25887
+(defun color* 662,26135
+(defun color+ 672,26403
+(defun color- 683,26712
+(defun colored-poly+ 687,26778
+(defun colored-poly- 710,27588
+(defun colored-term-uminus 733,28366
+(defun colored-minus-poly 737,28525
+(defun string-grobner-system 741,28671
+(defun string-cond 767,29664
+(defun string-cover 778,30219
+(defun saturate-cover 786,30553
+(defun saturate-cond 793,30913
+(defun string-determine 800,31214
+(defun tidy-grobner-system 818,31911
+(defun tidy-pair 826,32168
+(defun tidy-cond 847,32891
+(defun colored-reduction 853,33146
+(defun green-reduce-colored-poly 900,34825
+(defun green-reduce-colored-list 913,35347
+(defun cond-system-green-reduce 924,35699
+(defun parse-to-colored-poly-list 935,36032
+(defun red-reduction 948,36766
 
 
 division.lisp,86
 (defpackage "DIVISION"11,618
-(defun divide 20,879
-(defun poly-exact-divide 47,1882
+(defun divide 19,822
+(defun poly-exact-divide 46,1825
 
 
 dynamics.lisp,1057
 (defpackage "DYNAMICS"13,690
-(defun poly-scalar-composition 33,1365
-(defun poly-composition 44,1831
-(defun poly-dynamic-power 52,2235
-(defun poly-scalar-evaluate 58,2504
-(defun poly-evaluate 75,2944
-(defun factorial 79,3142
-(defun poly-scalar-diff 84,3295
-(defun poly-diff 92,3616
-(defun scalar-partial 98,3851
-(defun partial 103,4055
-(defun determinant 110,4313
-(defun minor 125,4806
-(defun drop-row 129,4985
-(defun drop-column 133,5080
-(defun drop-elt 137,5207
-(defun matrix- 143,5350
-(defun scalar-times-matrix 147,5512
-(defun monom-times-matrix 151,5670
-(defun term-times-matrix 155,5826
-(defun poly-list- 161,6016
-(defun scalar-times-poly-list 166,6208
-(defun monom-times-poly-list 171,6379
-(defun term-times-poly-list 176,6553
-(defun characteristic-combination 184,6817
-(defun characteristic-combination-poly-list 195,7401
-(defun characteristic-matrix 206,7945
-(defun characteristic-polynomial 219,8540
-(defun identity-matrix 228,9020
-(defun print-matrix 237,9403
-(defun jacobi-matrix 242,9587
-(defun jacobian 248,9836
+(defun poly-scalar-composition 32,1308
+(defun poly-composition 43,1774
+(defun poly-dynamic-power 51,2178
+(defun poly-scalar-evaluate 57,2447
+(defun poly-evaluate 74,2887
+(defun factorial 78,3085
+(defun poly-scalar-diff 83,3238
+(defun poly-diff 91,3559
+(defun scalar-partial 97,3794
+(defun partial 102,3998
+(defun determinant 109,4256
+(defun minor 124,4749
+(defun drop-row 128,4928
+(defun drop-column 132,5023
+(defun drop-elt 136,5150
+(defun matrix- 142,5293
+(defun scalar-times-matrix 146,5455
+(defun monom-times-matrix 150,5613
+(defun term-times-matrix 154,5769
+(defun poly-list- 160,5959
+(defun scalar-times-poly-list 165,6151
+(defun monom-times-poly-list 170,6322
+(defun term-times-poly-list 175,6496
+(defun characteristic-combination 183,6760
+(defun characteristic-combination-poly-list 194,7344
+(defun characteristic-matrix 205,7888
+(defun characteristic-polynomial 218,8483
+(defun identity-matrix 227,8963
+(defun print-matrix 236,9346
+(defun jacobi-matrix 241,9530
+(defun jacobian 247,9779
 
 
 example.lisp,137
 (defpackage "CGB-LISP"12,618
-(defun example 22,979
-(defun run-example 28,1204
-(defun all-examples 39,1672
-(defvar *examples*47,1869
+(defun example 21,922
+(defun run-example 27,1147
+(defun all-examples 38,1615
+(defvar *examples*46,1812
 
 
 grobner.lisp,3523
 (defpackage "GROBNER"12,688
-(defvar *grobner-debug* 61,1702
-(defvar *buchberger-merge-pairs* 64,1780
-(defvar *gebauer-moeller-merge-pairs* 68,1983
-(defvar *grobner-function* 72,2202
-(defun select-grobner-algorithm 75,2304
-(defun grobner 87,2752
-(defmacro debug-cgb 109,3873
-(defun spoly 117,4228
-(defun grobner-primitive-part 136,4864
-(defun grobner-content 154,5326
-(defun normal-form 163,5686
-(defun buchberger 206,7541
-(defun grobner-op 255,9601
-(defun buchberger-sort-pairs 319,11390
-(defun mock-spoly 329,11801
-(defun buchberger-merge-pairs-use-mock-spoly 350,12550
-(defun buchberger-merge-pairs-smallest-lcm 374,13648
-(defun buchberger-merge-pairs-use-smallest-degree 390,14422
-(defun buchberger-merge-pairs-use-smallest-length 400,14893
-(defun buchberger-merge-pairs-use-smallest-coefficient-length 410,15353
-(defun buchberger-set-pair-heuristic423,15932
-(defun Criterion-1 442,16800
-(defun Criterion-2 450,17126
-(defun normalize-poly 473,18102
-(defun normalize-basis 484,18516
-(defun reduction 489,18746
-(defun reduced-grobner 513,19421
-(defvar *vars* 523,19847
-(defun monom-depends-p 526,19957
-(defun term-depends-p 531,20107
-(defun poly-depends-p 536,20279
-(defun ring-intersection 540,20430
-(defun elimination-ideal 550,20831
-(defun ideal-intersection 577,21977
-(defun poly-contract 604,22921
-(defun poly-lcm 615,23530
-(defun grobner-gcd 638,24382
-(defun grobner-equal 648,24839
-(defun grobner-subsetp 654,25130
-(defun grobner-member 660,25459
-(defun ideal-equal 665,25744
-(defun ideal-subsetp 672,26030
-(defun ideal-member 680,26353
-(defun ideal-saturation-1 687,26654
-(defun add-variables 706,27375
-(defun extend-polynomials 717,27757
-(defun saturation-extension 735,28646
-(defun polysaturation-extension 753,29584
-(defun saturation-extension-1 769,30480
-(defun ideal-polysaturation-1 777,30848
-(defun ideal-saturation 787,31374
-(defun ideal-polysaturation 808,32255
-(defun buchberger-criterion 817,32711
-(defun grobner-test 828,33084
-(defun minimization 845,33657
-(defun add-minimized 863,34207
-(defun colon-ideal 872,34569
-(defun colon-ideal-1 894,35317
-(defun pseudo-divide 901,35628
-(defun gebauer-moeller 950,37701
-(defun update 988,39076
-(defun gebauer-moeller-merge-pairs-use-mock-spoly 1034,40708
-(defun gebauer-moeller-merge-pairs-smallest-lcm 1048,41274
-(defun gebauer-moeller-merge-pairs-use-smallest-degree 1059,41725
-(defun gebauer-moeller-merge-pairs-use-smallest-length 1071,42183
-(defun gebauer-moeller-merge-pairs-use-smallest-coefficient-length 1085,42674
-(defun gebauer-moeller-set-pair-heuristic1097,43232
-(defun spoly-sugar 1115,44072
-(defun spoly-with-sugar 1141,45426
-(defun normal-form-with-sugar 1158,46104
-(defun buchberger-with-sugar 1206,48312
-(defun buchberger-with-sugar-merge-pairs 1263,50670
-(defun buchberger-with-sugar-sort-pairs 1297,51929
-(defun Criterion-1-with-sugar 1301,52104
-(defun Criterion-2-with-sugar 1307,52404
-(defun gebauer-moeller-with-sugar 1329,53329
-(defun update-with-sugar 1375,55085
-(defun gebauer-moeller-with-sugar-merge-pairs 1426,57206
-(defun grobner-primitive-part-with-sugar 1449,58069
-(defun cached-normal-form 1457,58377
-(defun cached-grobner-op 1496,59912
-(defun cached-buchberger 1504,60285
-(defun cached-spoly 1552,62246
-(defun cached-monom-times-poly 1568,62832
-(defun cached-normal-form-with-sugar 1581,63327
-(defun cached-buchberger-with-sugar 1631,65617
-(defun cached-poly-with-sugar-op 1694,68276
-(defun cached-monom-times-poly-with-sugar 1697,68455
+(defvar *grobner-debug* 60,1645
+(defvar *buchberger-merge-pairs* 63,1723
+(defvar *gebauer-moeller-merge-pairs* 67,1926
+(defvar *grobner-function* 71,2145
+(defun select-grobner-algorithm 74,2247
+(defun grobner 86,2695
+(defmacro debug-cgb 108,3816
+(defun spoly 116,4171
+(defun grobner-primitive-part 135,4807
+(defun grobner-content 153,5269
+(defun normal-form 162,5629
+(defun buchberger 205,7484
+(defun grobner-op 254,9544
+(defun buchberger-sort-pairs 318,11333
+(defun mock-spoly 328,11744
+(defun buchberger-merge-pairs-use-mock-spoly 349,12493
+(defun buchberger-merge-pairs-smallest-lcm 373,13591
+(defun buchberger-merge-pairs-use-smallest-degree 389,14365
+(defun buchberger-merge-pairs-use-smallest-length 399,14836
+(defun buchberger-merge-pairs-use-smallest-coefficient-length 409,15296
+(defun buchberger-set-pair-heuristic422,15875
+(defun Criterion-1 441,16743
+(defun Criterion-2 449,17069
+(defun normalize-poly 472,18045
+(defun normalize-basis 483,18459
+(defun reduction 488,18689
+(defun reduced-grobner 512,19364
+(defvar *vars* 522,19790
+(defun monom-depends-p 525,19900
+(defun term-depends-p 530,20050
+(defun poly-depends-p 535,20222
+(defun ring-intersection 539,20373
+(defun elimination-ideal 549,20774
+(defun ideal-intersection 576,21920
+(defun poly-contract 603,22864
+(defun poly-lcm 614,23473
+(defun grobner-gcd 637,24325
+(defun grobner-equal 647,24782
+(defun grobner-subsetp 653,25073
+(defun grobner-member 659,25402
+(defun ideal-equal 664,25687
+(defun ideal-subsetp 671,25973
+(defun ideal-member 679,26296
+(defun ideal-saturation-1 686,26597
+(defun add-variables 705,27318
+(defun extend-polynomials 716,27700
+(defun saturation-extension 734,28589
+(defun polysaturation-extension 752,29527
+(defun saturation-extension-1 768,30423
+(defun ideal-polysaturation-1 776,30791
+(defun ideal-saturation 786,31317
+(defun ideal-polysaturation 807,32198
+(defun buchberger-criterion 816,32654
+(defun grobner-test 827,33027
+(defun minimization 844,33600
+(defun add-minimized 862,34150
+(defun colon-ideal 871,34512
+(defun colon-ideal-1 893,35260
+(defun pseudo-divide 900,35571
+(defun gebauer-moeller 949,37644
+(defun update 987,39019
+(defun gebauer-moeller-merge-pairs-use-mock-spoly 1033,40651
+(defun gebauer-moeller-merge-pairs-smallest-lcm 1047,41217
+(defun gebauer-moeller-merge-pairs-use-smallest-degree 1058,41668
+(defun gebauer-moeller-merge-pairs-use-smallest-length 1070,42126
+(defun gebauer-moeller-merge-pairs-use-smallest-coefficient-length 1084,42617
+(defun gebauer-moeller-set-pair-heuristic1096,43175
+(defun spoly-sugar 1114,44015
+(defun spoly-with-sugar 1140,45369
+(defun normal-form-with-sugar 1157,46047
+(defun buchberger-with-sugar 1205,48255
+(defun buchberger-with-sugar-merge-pairs 1262,50613
+(defun buchberger-with-sugar-sort-pairs 1296,51872
+(defun Criterion-1-with-sugar 1300,52047
+(defun Criterion-2-with-sugar 1306,52347
+(defun gebauer-moeller-with-sugar 1328,53272
+(defun update-with-sugar 1374,55028
+(defun gebauer-moeller-with-sugar-merge-pairs 1425,57149
+(defun grobner-primitive-part-with-sugar 1448,58012
+(defun cached-normal-form 1456,58320
+(defun cached-grobner-op 1495,59855
+(defun cached-buchberger 1503,60228
+(defun cached-spoly 1551,62189
+(defun cached-monom-times-poly 1567,62775
+(defun cached-normal-form-with-sugar 1580,63270
+(defun cached-buchberger-with-sugar 1630,65560
+(defun cached-poly-with-sugar-op 1693,68219
+(defun cached-monom-times-poly-with-sugar 1696,68398
 
 
 infix.lisp,3615
 (defpackage "INFIX"265,12470
-(defparameter *infix-readtable* 308,14181
-(defparameter *normal-readtable* 309,14235
-(defmacro infix-error 311,14291
-(defun infix-reader 315,14422
-(defun string->prefix 335,15181
-(defun read-infix 344,15473
-(defun read-regular 351,15745
-(defun same-operator-p 360,15959
-(defun same-token-p 363,16011
-(defvar *peeked-token* 370,16159
-(defun read-token 371,16187
-(defun peek-token 375,16292
-(defun fancy-number-format-p 383,16532
-(defun valid-numberp 407,17354
-(defun gather-superiors 421,17735
-(defun get-first-token 442,18658
-(defun apply-token-prefix-operator 450,18882
-(defun get-next-token 456,19085
-(defun apply-token-infix-operator 460,19212
-(defun infix-read-delimited-list 469,19505
-(defparameter *operator-ordering* 489,20255
-(defun operator-lessp 512,20887
-(defparameter *right-associative-operators* 519,21084
-(defun operator-right-associative-p 520,21136
-(defvar *token-operators* 528,21347
-(defvar *token-prefix-operator-table* 529,21378
-(defvar *token-infix-operator-table* 530,21435
-(defun token-operator-p 531,21491
-(defun get-token-prefix-operator 533,21557
-(defun get-token-infix-operator 535,21647
-(define-token-operator and575,22941
-(define-token-operator or577,23026
-(define-token-operator not579,23108
-(define-token-operator if582,23188
-(define-token-operator then604,23868
-(define-token-operator else606,23952
-(define-character-tokenization #\+609,24037
-(define-token-operator +617,24249
-(define-token-operator +=620,24368
-(define-character-tokenization #\-623,24452
-(define-token-operator -631,24664
-(define-token-operator -=634,24789
-(define-character-tokenization #\*637,24873
-(define-token-operator *645,25085
-(define-token-operator *=647,25163
-(define-character-tokenization #\/654,25309
-(define-token-operator /662,25521
-(define-token-operator /=665,25646
-(define-character-tokenization #\^672,25792
-(define-token-operator ^680,26004
-(define-token-operator ^^682,26085
-(define-character-tokenization #\|685,26171
-(define-token-operator \|693,26384
-(define-character-tokenization #\&696,26470
-(define-token-operator \&704,26684
-(define-character-tokenization #\%707,26770
-(define-token-operator \%711,26872
-(define-character-tokenization #\~714,26955
-(define-token-operator \~718,27057
-(define-character-tokenization #\,721,27138
-(define-token-operator \,725,27240
-(define-character-tokenization #\=728,27325
-(define-token-operator ===736,27537
-(define-token-operator ==738,27617
-(define-character-tokenization #\:	745,27750
-(define-token-operator |:=753,28009
-(define-character-tokenization #\<760,28191
-(define-token-operator <771,28502
-(define-token-operator <=773,28580
-(define-token-operator <<775,28661
-(define-character-tokenization #\>778,28744
-(define-token-operator >789,29055
-(define-token-operator >=791,29133
-(define-token-operator >>793,29214
-(define-character-tokenization #\!796,29301
-(define-token-operator !=804,29513
-(define-token-operator !806,29599
-(define-character-tokenization #\[809,29660
-(define-token-operator \[813,29762
-(define-character-tokenization #\(821,30077
-(define-token-operator \(825,30179
-(define-character-tokenization #\]834,30506
-(define-token-operator \]838,30608
-(define-character-tokenization #\)841,30707
-(define-token-operator \)845,30809
-(define-character-tokenization #\$850,30979
-(define-token-operator %infix-end-token%854,31096
-(define-character-tokenization #\;859,31277
-(defun post-process-expression 887,32148
-(defparameter *test-cases*931,33513
-(defun test-infix 1087,40204
-(defun test-infix-case 1096,40476
+(defparameter *infix-readtable* 307,14148
+(defparameter *normal-readtable* 308,14202
+(defmacro infix-error 310,14258
+(defun infix-reader 314,14389
+(defun string->prefix 334,15148
+(defun read-infix 343,15440
+(defun read-regular 350,15712
+(defun same-operator-p 359,15926
+(defun same-token-p 362,15978
+(defvar *peeked-token* 369,16126
+(defun read-token 370,16154
+(defun peek-token 374,16259
+(defun fancy-number-format-p 382,16499
+(defun valid-numberp 406,17321
+(defun gather-superiors 420,17702
+(defun get-first-token 441,18625
+(defun apply-token-prefix-operator 449,18849
+(defun get-next-token 455,19052
+(defun apply-token-infix-operator 459,19179
+(defun infix-read-delimited-list 468,19472
+(defparameter *operator-ordering* 488,20222
+(defun operator-lessp 511,20854
+(defparameter *right-associative-operators* 518,21051
+(defun operator-right-associative-p 519,21103
+(defvar *token-operators* 527,21314
+(defvar *token-prefix-operator-table* 528,21345
+(defvar *token-infix-operator-table* 529,21402
+(defun token-operator-p 530,21458
+(defun get-token-prefix-operator 532,21524
+(defun get-token-infix-operator 534,21614
+(define-token-operator and574,22956
+(define-token-operator or576,23041
+(define-token-operator not578,23123
+(define-token-operator if581,23203
+(define-token-operator then603,23883
+(define-token-operator else605,23967
+(define-character-tokenization #\+608,24052
+(define-token-operator +616,24264
+(define-token-operator +=619,24383
+(define-character-tokenization #\-622,24467
+(define-token-operator -630,24679
+(define-token-operator -=633,24804
+(define-character-tokenization #\*636,24888
+(define-token-operator *644,25100
+(define-token-operator *=646,25178
+(define-character-tokenization #\/653,25324
+(define-token-operator /661,25536
+(define-token-operator /=664,25661
+(define-character-tokenization #\^671,25807
+(define-token-operator ^679,26019
+(define-token-operator ^^681,26100
+(define-character-tokenization #\|684,26186
+(define-token-operator \|692,26399
+(define-character-tokenization #\&695,26485
+(define-token-operator \&703,26699
+(define-character-tokenization #\%706,26785
+(define-token-operator \%710,26887
+(define-character-tokenization #\~713,26970
+(define-token-operator \~717,27072
+(define-character-tokenization #\,720,27153
+(define-token-operator \,724,27255
+(define-character-tokenization #\=727,27340
+(define-token-operator ===735,27552
+(define-token-operator ==737,27632
+(define-character-tokenization #\:	744,27765
+(define-token-operator |:=752,28024
+(define-character-tokenization #\<759,28206
+(define-token-operator <770,28517
+(define-token-operator <=772,28595
+(define-token-operator <<774,28676
+(define-character-tokenization #\>777,28759
+(define-token-operator >788,29070
+(define-token-operator >=790,29148
+(define-token-operator >>792,29229
+(define-character-tokenization #\!795,29316
+(define-token-operator !=803,29528
+(define-token-operator !805,29614
+(define-character-tokenization #\[808,29675
+(define-token-operator \[812,29777
+(define-character-tokenization #\(820,30092
+(define-token-operator \(824,30194
+(define-character-tokenization #\]833,30521
+(define-token-operator \]837,30623
+(define-character-tokenization #\)840,30722
+(define-token-operator \)844,30824
+(define-character-tokenization #\$849,30994
+(define-token-operator %infix-end-token%853,31111
+(define-character-tokenization #\;858,31292
+(defun post-process-expression 886,32163
+(defparameter *test-cases*930,33528
+(defun test-infix 1086,40219
+(defun test-infix-case 1095,40491
 
 
@@ -348,265 +348,265 @@
 modular.lisp,209
 (defpackage "MODULAR"13,689
-(defun modular-inverse 22,923
-(defun modular-division 29,1114
-(defvar *inverse-by-lookup-limit* 33,1220
-(defun make-inverse-table 37,1422
-(defun make-modular-division 43,1731
+(defun modular-inverse 21,866
+(defun modular-division 28,1057
+(defvar *inverse-by-lookup-limit* 32,1163
+(defun make-inverse-table 36,1365
+(defun make-modular-division 42,1674
 
 
 modular-poly.lisp,128
 (defpackage "MODULAR-POLY"13,694
-(defun modular-trace 22,939
-(defun modular-trace-1 26,1103
-(defun frobenius-kernel 32,1294
+(defun modular-trace 21,882
+(defun modular-trace-1 25,1046
+(defun frobenius-kernel 31,1237
 
 
 monom.lisp,278
 (defpackage "MONOM"11,615
-(defun monom/ 36,1447
-(defun monom* 40,1531
-(defun nmonom* 44,1617
-(defun monom-divides-p 49,1805
-(defun monom-divisible-by-p 53,1925
-(defun monom-rel-prime 57,2058
-(defun monom-equal 61,2216
-(defun monom-lcm 65,2318
-(defun monom-gcd 69,2426
+(defun monom/ 35,1390
+(defun monom* 39,1474
+(defun nmonom* 43,1560
+(defun monom-divides-p 48,1748
+(defun monom-divisible-by-p 52,1868
+(defun monom-rel-prime 56,2001
+(defun monom-equal 60,2159
+(defun monom-lcm 64,2261
+(defun monom-gcd 68,2369
 
 
 order.lisp,246
 (defpackage "ORDER"24,1190
-(defun lex> 41,1496
-(defun total-degree 53,1934
-(defun grlex> 58,2131
-(defun revlex> 70,2546
-(defun grevlex> 85,3169
-(defun invlex> 95,3563
-(defun elimination-order 114,4281
-(defun elimination-order-1 127,4828
+(defun lex> 40,1439
+(defun total-degree 52,1877
+(defun grlex> 57,2074
+(defun revlex> 69,2489
+(defun grevlex> 84,3112
+(defun invlex> 94,3506
+(defun elimination-order 113,4224
+(defun elimination-order-1 126,4771
 
 
 parse.lisp,608
 (defpackage "PARSE"12,688
-(defun convert-number 52,2312
-(defun $poly+ 60,2674
-(defun $poly- 66,2974
-(defun $minus-poly 72,3279
-(defun $poly* 78,3533
-(defun $poly/ 84,3838
-(defun $poly-expt 91,4086
-(defun parse 97,4350
-(defun alist-form 133,5496
-(defun alist-form-1 145,5921
-(defun powers 156,6254
-(defun parse-to-alist 170,6761
-(defun parse-string-to-alist 181,7217
-(defun parse-to-sorted-alist 194,7750
-(defun parse-string-to-sorted-alist 208,8336
-(defun sort-poly-1 214,8602
-(defun sort-poly 220,8846
-(defun poly-eval-1 233,9389
-(defun poly-eval 257,10410
-(defun monom-basis 274,11309
+(defun convert-number 51,2255
+(defun $poly+ 59,2617
+(defun $poly- 65,2917
+(defun $minus-poly 71,3222
+(defun $poly* 77,3476
+(defun $poly/ 83,3781
+(defun $poly-expt 90,4029
+(defun parse 96,4293
+(defun alist-form 132,5439
+(defun alist-form-1 144,5864
+(defun powers 155,6197
+(defun parse-to-alist 169,6704
+(defun parse-string-to-alist 180,7160
+(defun parse-to-sorted-alist 193,7693
+(defun parse-string-to-sorted-alist 207,8279
+(defun sort-poly-1 213,8545
+(defun sort-poly 219,8789
+(defun poly-eval-1 232,9332
+(defun poly-eval 256,10353
+(defun monom-basis 273,11252
 
 
 poly-gcd.lisp,281
 (defpackage "POLY-GCD"11,618
-(defun poly-gcd 29,1243
-(defun poly-pseudo-divide 47,1758
-(defun poly-pseudo-remainder 63,2193
-(defun mdeg 67,2315
-(defun lcoeff 70,2412
-(defun lrest 73,2474
-(defun lpart 76,2536
-(defun poly-primitive-part 84,2755
-(defun poly-content 92,2899
+(defun poly-gcd 28,1186
+(defun poly-pseudo-divide 46,1701
+(defun poly-pseudo-remainder 62,2136
+(defun mdeg 66,2258
+(defun lcoeff 69,2355
+(defun lrest 72,2417
+(defun lpart 75,2479
+(defun poly-primitive-part 83,2698
+(defun poly-content 91,2842
 
 
 poly.lisp,509
 (defpackage "POLY"11,614
-(defun scalar-times-poly 45,2025
-(defun term-times-poly 52,2312
-(defun monom-times-poly 56,2510
-(defun minus-poly 60,2674
-(defun sort-poly 65,2916
-(defun poly+ 77,3335
-(defun poly- 101,4095
-(defun poly* 127,4967
-(defun poly-op 138,5487
-(defun poly-expt 144,5714
-(defun poly-mexpt 161,6432
-(defun poly-constant-p 172,6902
-(defun	poly-extend 178,7041
-(defun	poly-extend-end 185,7371
-(defun poly-zerop 189,7560
-(defun lt 193,7636
-(defun lm 198,7744
-(defun lc 203,7864
+(defun scalar-times-poly 44,1968
+(defun term-times-poly 51,2255
+(defun monom-times-poly 55,2453
+(defun minus-poly 59,2617
+(defun sort-poly 64,2859
+(defun poly+ 76,3278
+(defun poly- 100,4038
+(defun poly* 126,4910
+(defun poly-op 137,5430
+(defun poly-expt 143,5657
+(defun poly-mexpt 160,6375
+(defun poly-constant-p 171,6845
+(defun	poly-extend 177,6984
+(defun	poly-extend-end 184,7314
+(defun poly-zerop 188,7503
+(defun lt 192,7579
+(defun lm 197,7687
+(defun lc 202,7807
 
 
 poly-with-sugar.lisp,890
 (defpackage "POLY-WITH-SUGAR"11,625
-(defun poly-with-sugar-poly 48,1758
-(defun poly-with-sugar-sugar 49,1799
-(defun poly-with-sugar-tail 50,1841
-(defsetf poly-with-sugar-poly 52,1899
-(defsetf poly-with-sugar-sugar 55,1967
-(defsetf poly-with-sugar-tail 58,2038
-(defun monom-sugar 65,2301
-(defun coefficient-sugar 68,2345
-(defun term-sugar 71,2414
-(defun poly-add-sugar 78,2686
-(defun scalar-times-poly-with-sugar 83,2847
-(defun term-times-poly-with-sugar 88,3028
-(defun monom-times-poly-with-sugar 93,3241
-(defun minus-poly-with-sugar 99,3442
-(defun poly-with-sugar+ 105,3619
-(defun poly-with-sugar- 111,3856
-(defun poly-with-sugar-op 117,4061
-(defun poly-with-sugar-nreverse 122,4256
-(defun poly-with-sugar-append 128,4487
-(defun poly-with-sugar-zerop 132,4652
-(defun poly-with-sugar-lm 135,4727
-(defun poly-with-sugar-lc 138,4791
-(defun poly-with-sugar-lt 141,4855
+(defun poly-with-sugar-poly 47,1701
+(defun poly-with-sugar-sugar 48,1742
+(defun poly-with-sugar-tail 49,1784
+(defsetf poly-with-sugar-poly 51,1842
+(defsetf poly-with-sugar-sugar 54,1910
+(defsetf poly-with-sugar-tail 57,1981
+(defun monom-sugar 64,2244
+(defun coefficient-sugar 67,2288
+(defun term-sugar 70,2357
+(defun poly-add-sugar 77,2629
+(defun scalar-times-poly-with-sugar 82,2790
+(defun term-times-poly-with-sugar 87,2971
+(defun monom-times-poly-with-sugar 92,3184
+(defun minus-poly-with-sugar 98,3385
+(defun poly-with-sugar+ 104,3562
+(defun poly-with-sugar- 110,3799
+(defun poly-with-sugar-op 116,4004
+(defun poly-with-sugar-nreverse 121,4199
+(defun poly-with-sugar-append 127,4430
+(defun poly-with-sugar-zerop 131,4595
+(defun poly-with-sugar-lm 134,4670
+(defun poly-with-sugar-lc 137,4734
+(defun poly-with-sugar-lt 140,4798
 
 
 printer.lisp,168
 (defpackage "PRINTER"11,617
-(defun poly-print 20,838
-(defun poly-print-1 37,1575
-(defun poly-print-2 71,2721
-(defun print-term 79,3033
-(defun print-monom 93,3574
+(defun poly-print 19,780
+(defun poly-print-1 36,1517
+(defun poly-print-2 70,2663
+(defun print-term 78,2975
+(defun print-monom 92,3516
 
 
 prover.lisp,546
 (defpackage "PROVER"12,687
-(defvar *prover-order* 24,1117
-(defun csym 31,1356
-(defmacro real-identical-points 36,1558
-(defmacro identical-points 52,2216
-(defmacro perpendicular 69,2950
-(defmacro parallel 85,3406
-(defmacro collinear 102,3858
-(defmacro equidistant 117,4303
-(defmacro euclidean-distance 133,4814
-(defmacro midpoint 145,5187
-(defmacro translate-statements 159,5603
-(defmacro translate-assumptions 163,5775
-(defmacro translate-conclusions 169,5963
-(defmacro translate-theorem 172,6059
-(defmacro prove-theorem 187,6950
+(defvar *prover-order* 23,1059
+(defun csym 30,1298
+(defmacro real-identical-points 35,1500
+(defmacro identical-points 51,2158
+(defmacro perpendicular 68,2892
+(defmacro parallel 84,3348
+(defmacro collinear 101,3800
+(defmacro equidistant 116,4245
+(defmacro euclidean-distance 132,4756
+(defmacro midpoint 144,5129
+(defmacro translate-statements 158,5545
+(defmacro translate-assumptions 162,5717
+(defmacro translate-conclusions 168,5905
+(defmacro translate-theorem 171,6001
+(defmacro prove-theorem 186,6892
 
 
 rat.lisp,411
 (defpackage "RAT"22,1062
-(defun num 33,1415
-(defun denom 34,1452
-(defun rat-simplify-2 36,1493
-(defun rat-simplify 41,1638
-(defun rat+ 44,1699
-(defun rat- 51,1874
-(defun rat* 59,2120
-(defun rat/ 64,2217
-(defun scalar-times-rat 69,2314
-(defun scalar-div-rat 73,2428
-(defun rat-zerop 76,2517
-(defun rat-uminus 79,2557
-(defun rat-expt 82,2619
-(defun rat-constant 85,2696
-(defun rat-to-poly 90,2898
+(defun num 32,1357
+(defun denom 33,1394
+(defun rat-simplify-2 35,1435
+(defun rat-simplify 40,1580
+(defun rat+ 43,1641
+(defun rat- 50,1816
+(defun rat* 58,2062
+(defun rat/ 63,2159
+(defun scalar-times-rat 68,2256
+(defun scalar-div-rat 72,2370
+(defun rat-zerop 75,2459
+(defun rat-uminus 78,2499
+(defun rat-expt 81,2561
+(defun rat-constant 84,2638
+(defun rat-to-poly 89,2840
 
 
 ratpoly.lisp,974
 (defpackage "RATPOLY"25,1219
-(defun ratpoly+ 45,2011
-(defun ratpoly- 61,2463
-(defun ratpoly-uminus 77,2952
-(defun ratpoly* 82,3084
-(defun scalar-times-ratpoly 90,3420
-(defun rat-times-ratpoly 97,3644
-(defun ratpoly-divide 104,3861
-(defun ratpoly-remainder 113,4199
-(defun ratpoly-gcd 117,4344
-(defun ratpoly-diff 123,4483
-(defun ratpoly-square-free 130,4698
-(defun ratpoly-normalize 134,4836
-(defun ratpoly-resultant 139,5048
-(defun deg 157,5548
-(defun lead 164,5686
-(defun ratpoly-discriminant 166,5713
-(defun ratpoly-print 172,5929
-(defun poly-to-ratpoly 188,6493
-(defun poly-to-poly1 192,6621
-(defun poly1-to-ratpoly 204,7023
-(defun ratpoly-to-poly1 213,7230
-(defun poly1-to-poly 221,7447
-(defun ratpoly-to-poly 231,7755
-(defun poly-resultant 235,7826
-(defun poly-gcd 246,8241
-(defun content1 259,8630
-(defun content1-aux 268,8901
-(defun content 274,9096
-(defun primitive-part 278,9189
-(defun divide-coeffs 283,9351
-(defun euclid 299,9788
+(defun ratpoly+ 44,1953
+(defun ratpoly- 60,2405
+(defun ratpoly-uminus 76,2894
+(defun ratpoly* 81,3026
+(defun scalar-times-ratpoly 89,3362
+(defun rat-times-ratpoly 96,3586
+(defun ratpoly-divide 103,3803
+(defun ratpoly-remainder 112,4141
+(defun ratpoly-gcd 116,4286
+(defun ratpoly-diff 122,4425
+(defun ratpoly-square-free 129,4640
+(defun ratpoly-normalize 133,4778
+(defun ratpoly-resultant 138,4990
+(defun deg 156,5490
+(defun lead 163,5628
+(defun ratpoly-discriminant 165,5655
+(defun ratpoly-print 171,5871
+(defun poly-to-ratpoly 187,6435
+(defun poly-to-poly1 191,6563
+(defun poly1-to-ratpoly 203,6965
+(defun ratpoly-to-poly1 212,7172
+(defun poly1-to-poly 220,7389
+(defun ratpoly-to-poly 230,7697
+(defun poly-resultant 234,7768
+(defun poly-gcd 245,8183
+(defun content1 258,8572
+(defun content1-aux 267,8843
+(defun content 273,9038
+(defun primitive-part 277,9131
+(defun divide-coeffs 282,9293
+(defun euclid 298,9730
 
 
 string-grobner.lisp,534
 (defpackage "STRING-GROBNER"14,690
-(defun string-normal-form 35,1252
-(defun string-grobner 57,1850
-(defun string-elimination-ideal 85,2688
-(defun string-ideal-intersection 108,3327
-(defun string-poly-lcm 123,3855
-(defun string-ideal-saturation-1 137,4260
-(defun string-ideal-polysaturation-1 152,4797
-(defun string-ideal-saturation 172,5498
-(defun string-ideal-polysaturation 187,6018
-(defun string-colon-ideal 212,6793
-(defun string-read-poly 234,7548
-(defun poly-rational-to-integer 252,8124
-(defun read-vars 256,8319
+(defun string-normal-form 34,1195
+(defun string-grobner 56,1793
+(defun string-elimination-ideal 84,2631
+(defun string-ideal-intersection 107,3270
+(defun string-poly-lcm 122,3798
+(defun string-ideal-saturation-1 136,4203
+(defun string-ideal-polysaturation-1 151,4740
+(defun string-ideal-saturation 171,5441
+(defun string-ideal-polysaturation 186,5961
+(defun string-colon-ideal 211,6736
+(defun string-read-poly 233,7491
+(defun poly-rational-to-integer 251,8067
+(defun read-vars 255,8262
 
 
 svpoly.lisp,652
 (defpackage "SVPOLY"11,616
-(defstruct (svpoly 19,775
-(defun make-svpoly 25,984
-(defun svpoly-sort 42,1539
-(defun make-order 46,1700
-(defun svpoly-add 62,2277
-(defun add-terms 69,2526
-(defun scalar-times-poly 107,3439
-(defun term-times-poly 114,3690
-(defun monom-times-poly 118,3888
-(defun minus-poly 122,4052
-(defun poly+ 128,4295
-(defun poly- 152,5097
-(defun poly* 178,5999
-(defun poly-op 189,6519
-(defun poly-expt 195,6746
-(defun poly-mexpt 212,7464
-(defun poly-constant-p 223,7934
-(defun	poly-extend 229,8073
-(defun	poly-extend-end 236,8403
-(defun poly-zerop 240,8592
-(defun lt 244,8668
-(defun lm 249,8776
-(defun lc 254,8896
+(defstruct (svpoly 18,718
+(defun make-svpoly 24,927
+(defun svpoly-sort 41,1482
+(defun make-order 45,1643
+(defun svpoly-add 61,2220
+(defun add-terms 68,2469
+(defun scalar-times-poly 106,3382
+(defun term-times-poly 113,3633
+(defun monom-times-poly 117,3831
+(defun minus-poly 121,3995
+(defun poly+ 127,4238
+(defun poly- 151,5040
+(defun poly* 177,5942
+(defun poly-op 188,6462
+(defun poly-expt 194,6689
+(defun poly-mexpt 211,7407
+(defun poly-constant-p 222,7877
+(defun	poly-extend 228,8016
+(defun	poly-extend-end 235,8346
+(defun poly-zerop 239,8535
+(defun lt 243,8611
+(defun lm 248,8719
+(defun lc 253,8839
 
 
 term.lisp,264
 (defpackage "TERM"12,615
-(defun term* 35,1431
-(defun term/ 41,1616
-(defun monom-times-term 47,1807
-(defun term-divides-p 51,1923
-(defmacro term-monom 55,2027
-(defmacro term-coefficient 56,2069
-(defsetf term-monom 59,2134
-(defsetf term-coefficient 62,2200
+(defun term* 34,1374
+(defun term/ 40,1559
+(defun monom-times-term 46,1750
+(defun term-divides-p 50,1866
+(defmacro term-monom 54,1970
+(defmacro term-coefficient 55,2012
+(defsetf term-monom 58,2077
+(defsetf term-coefficient 61,2143
 
 
@@ -617,3 +617,3 @@
 xgcd.lisp,46
 (defpackage "XGCD"12,614
-(defun xgcd 20,796
+(defun xgcd 19,739
