File: simp.pro

package info (click to toggle)
spark 2012.0.deb-9
  • links: PTS, VCS
  • area: main
  • in suites: jessie, jessie-kfreebsd
  • size: 29,260 kB
  • ctags: 3,098
  • sloc: ada: 186,243; cpp: 13,497; makefile: 685; yacc: 440; lex: 176; ansic: 119; sh: 16
file content (1100 lines) | stat: -rw-r--r-- 51,102 bytes parent folder | download | duplicates (3)
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
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
% -----------------------------------------------------------------------------
%  (C) Altran Praxis Limited
% -----------------------------------------------------------------------------
% 
%  The SPARK toolset is free software; you can redistribute it and/or modify it
%  under terms of the GNU General Public License as published by the Free
%  Software Foundation; either version 3, or (at your option) any later
%  version. The SPARK toolset is distributed in the hope that it will be
%  useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
%  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
%  Public License for more details. You should have received a copy of the GNU
%  General Public License distributed with the SPARK toolset; see file
%  COPYING3. If not, go to http://www.gnu.org/licenses for a complete copy of
%  the license.
% 
% =============================================================================


/*** SIMPLIFY(in X,out Y) -- simplify expression X to get Y ***/

/* Simplify expressions of the form 'not(A)' where possible */

/* NOT1 */   simplify(not(true),false) :- !.
/* NOT2 */   simplify(not(false),true) :- !.
/* NOT3 */   simplify(not(not(X)),A) :- simplify(X,A), !.
/* NOT4 */   simplify((not X),B) :-
                simplify(X,A),
                (
                   A=true,
                   B=false
                ;
                   A=false,
                   B=true
                ;
                   B=(not A)
                ), !.


/* Simplify expressions of the form 'A and B' where possible */

/* AND1 */   simplify(false and _X,false) :- !.
/* AND2 */   simplify(_X and false,false) :- !.
/* AND3 */   simplify(X and (not X),false) :- !.
/* AND4 */   simplify((not X) and X,false) :- !.
/* AND5 */   simplify(true and X,Y) :- simplify(X,Y), !.
/* AND6 */   simplify(X and true,Y) :- simplify(X,Y), !.
/* AND7 */   simplify(X and X,Y) :- simplify(X,Y), !.
/* AND8 */   simplify(X and Y,Z) :-
                simplify(X,A),
                (
                   A=true,
                   simplify(Y,Z)
                ;
                   A=false,
                   Z=A
                ;
                   simplify(Y,B),
                   (
                      (
                         B=true,
                         Z=A
                      ;
                         B=false,
                         Z=B
                      )
                   ;
                      (
                         A=(not B)
                      ;
                         A=(not Y)
                      ;
                         B=(not A)
                      ;
                         B=(not X)
                      ),
                      Z=false
                   ;
                      A=B,
                      Z=A
                   ;
                      Z=(A and B)
                   )
                ), !.


/* Simplify expressions of the form 'A or B' where possible. */

/* OR1 */    simplify(true or _X,true) :- !.
/* OR2 */    simplify(_X or true,true) :- !.
/* OR3 */    simplify(X or (not X),true) :- !.
/* OR4 */    simplify((not X) or X,true) :- !.
/* OR5 */    simplify(false or X,Y) :- simplify(X,Y), !.
/* OR6 */    simplify(X or false,Y) :- simplify(X,Y), !.
/* OR7 */    simplify(X or X,Y) :- simplify(X,Y), !.
/* OR8 */    simplify(X or Y,Z) :-
                simplify(X,A),
                (
                   A=true,
                   Z=A
                ;
                   A=false,
                   simplify(Y,Z)
                ;
                   simplify(Y,B),
                   (
                      B=true,
                      Z=B
                   ;
                      B=false,
                      Z=A
                   ;
                      (
                         A=(not B)
                      ;
                         A=(not Y)
                      ;
                         B=(not A)
                      ;
                         B=(not X)
                      ),
                      Z=true
                   ;
                      A=B,
                      Z=A
                   ;
                      Z=(A or B)
                   )
                ), !.


/* Simplify expressions of the form 'A -> B' where possible */

/* IMP1 */   simplify(false->_X,true) :- !.
/* IMP2 */   simplify(_X->true,true) :- !.
/* IMP3 */   simplify(X->X,true) :- !.
/* IMP4 */   simplify(true->X,Y) :- simplify(X,Y), !.
/* IMP5 */   simplify(X->false,A) :- simplify((not X),A), !.
/* IMP6 */   simplify(X->(not X),Y) :- simplify((not X),Y), !.
/* IMP7 */   simplify((not X)->X,Y) :- simplify(X,Y), !.
/* IMP8 */   simplify(X -> (Y -> Z),A) :- simplify((X and Y) -> Z,A), !.
/* IMP9 */   simplify(X->Y,Z) :-
                simplify(X,A),
                (
                   A=true,
                   simplify(Y,Z)
                ;
                   A=false,
                   Z=true
                ;
                   simplify(Y,B),
                   (
                      B=true,
                      Z=B
                   ;
                      B=false,
                      simplify((not X),Z)
                   ;
                      (
                         A=(not B)
                      ;
                         A=(not Y)
                      ;
                         B=(not A)
                      ;
                         B=(not X)
                      ),
                      Z=B
                   ;
                      A=B,
                      Z=true
                   ;
                      Z=(A->B)
                   )
                ), !.


/* Simplify expressions of the form 'A <-> B' where possible */

/* EQV1  */  simplify(X<->X,true) :- !.
/* EQV2  */  simplify(X<->(not X),false) :- !.
/* EQV3  */  simplify((not X)<->X,false) :- !.
/* EQV4  */  simplify(X<->true,Y) :- simplify(X,Y), !.
/* EQV5  */  simplify(true<->X,Y) :- simplify(X,Y), !.
/* EQV6  */  simplify(X<->false,Y) :- simplify((not X),Y), !.
/* EQV7  */  simplify(false<->X,Y) :- simplify((not X),Y), !.
/* EQV8  */  simplify(X <-> (Y <-> Z),B) :-
                simplify(X <-> Y,A),
                simplify(A <-> Z,B), !.
/* EQV9  */  simplify(X <-> Y <-> Z,B) :-
                simplify(Y <-> Z,A),
                (Y <-> Z)\=A,
                simplify(X <-> A,B), !.
/* EQV10 */  simplify(X <-> Y <-> Z,B) :-
                simplify(X <-> Z,A),
                (X <-> Z)\=A,
                simplify(A <-> Y,B), !.
/* EQV11 */  simplify(X<->Y,Z) :-
                simplify(X,A),
                (
                   A=true,
                   simplify(Y,Z)
                ;
                   A=false,
                   simplify((not Y),Z)
                ;
                   simplify(Y,B),
                   (
                      B=true,
                      Z=A
                   ;
                      B=false,
                      simplify((not X),Z)
                   ;
                      (
                         A=(not B)
                      ;
                         A=(not Y)
                      ;
                         B=(not A)
                      ;
                         B=(not X)
                      ),
                      Z=false
                   ;
                      A=B,
                      Z=true
                   ;
                      Z=(A<->B)
                   )
                ), !.


/* Simplify 'for_all( )' exprs. where possible */

/* ALL3 */   simplify(for_all(V:T,X),NEW) :-
                find_core_type(T, CT),
                (
                   var_const(V, CT, _),
                   STATE = dont_retract
                ;
                   asserta(var_const(V, CT, temp)),
                   STATE = retract
                ),
                simplify(X,Y),
                (
                   Y = true,
                   NEW = true
                ;
                   Y = false,
                   NEW = false
                ;
                   NEW = (for_all(V:T, Y))
                ),
                !,
                (
                   STATE = dont_retract
                ;
                   retract(var_const(V, CT, temp))
                ),
                !.

/* Simplify 'for_some( )' exprs. where possible */

/* EXI3 */   simplify(for_some(V:T,X),NEW) :-
                find_core_type(T, CT),
                (
                   var_const(V, CT, _),
                   STATE = dont_retract
                ;
                   asserta(var_const(V, CT, temp)),
                   STATE = retract
                ),
                simplify(X,Y),
                (
                   Y = true,
                   NEW = true
                ;
                   Y = false,
                   NEW = false
                ;
                   NEW = (for_some(V:T, Y))
                ),
                !,
                (
                   STATE = dont_retract
                ;
                   retract(var_const(V, CT, temp))
                ),
                !.


/* Simplify set-type expressions where possible */

/* SET1 */   simplify(A \/ B, S) :-
                !,
                set_simplify(A \/ B, S),
                !.
/* SET2 */   simplify(A \ B, S) :-
                !,
                set_simplify(A \ B, S),
                !.
/* SET3 */   simplify(A /\ B, S) :-
                !,
                set_simplify(A /\ B, S),
                !.
/* SET4 */   simplify((set A), S) :-
                !,
                set_simplify((set A), S),
                !.
/* SET5 */   simplify(A subset_of B, S) :-
                !,
                set_simplify(A subset_of B, S),
                !.
/* SET6 */   simplify(A strict_subset_of B, S) :-
                !,
                set_simplify(A strict_subset_of B, S),
                !.
/* SET7 */   simplify(A in B, S) :-
                !,
                set_simplify(A in B, S),
                !.
/* SET8 */   simplify(A not_in B, S) :-
                !,
                set_simplify(A not_in B, S),
                !.


/* Simplify atomic formulae where possible */

/* REL1 */   simplify(X=Y,Z) :-
                checktype(X,T),
                (
                   type(T, set(_)),
                   !,
                   set_simplify(X=Y,Z)
                ;
                   type(T,enumerated),
                   !,
                   enumerated_simplify(X=Y,Z)
                ;
                   simplify(X,A),
                   simplify(Y,B),
                   (
                      A=B,
                      Z=true
                   ;
                      signed_integer(A),
                      (                                         /* CFR050 */
                         signed_integer(B),                     /* CFR050 */
                         A\=B,                                  /* CFR050 */
                         Z=false                                /* CFR050 */
                      ;                                         /* CFR050 */
                         B=P+Q,                                 /* CFR050 */
                         (                                      /* CFR050 */
                            signed_integer(P),                  /* CFR050 */
                            simplify(A-P,R),                    /* CFR050 */
                            Z=(Q=R)                             /* CFR050 */
                         ;                                      /* CFR050 */
                            signed_integer(Q),                  /* CFR050 */
                            simplify(A-Q,R),                    /* CFR050 */
                            Z=(P=R)                             /* CFR050 */
                         )                                      /* CFR050 */
                      ;                                         /* CFR050 */
                         B=P-Q,                                 /* CFR050 */
                         (                                      /* CFR050 */
                            signed_integer(P),                  /* CFR050 */
                            simplify(P-A,R),                    /* CFR050 */
                            Z=(Q=R)                             /* CFR050 */
                         ;                                      /* CFR050 */
                            signed_integer(Q),                  /* CFR050 */
                            simplify(A+Q,R),                    /* CFR050 */
                            Z=(P=R)                             /* CFR050 */
                         )                                      /* CFR050 */
                      )                                         /* CFR050 */
                   ;                                            /* CFR050 */
                      signed_integer(B),                        /* CFR050 */
                      (                                         /* CFR050 */
                         A=P+Q,                                 /* CFR050 */
                         (                                      /* CFR050 */
                            signed_integer(P),                  /* CFR050 */
                            simplify(B-P,R),                    /* CFR050 */
                            Z=(Q=R)                             /* CFR050 */
                         ;                                      /* CFR050 */
                            signed_integer(Q),                  /* CFR050 */
                            simplify(B-Q,R),                    /* CFR050 */
                            Z=(P=R)                             /* CFR050 */
                         )                                      /* CFR050 */
                      ;                                         /* CFR050 */
                         A=P-Q,                                 /* CFR050 */
                         (                                      /* CFR050 */
                            signed_integer(P),                  /* CFR050 */
                            simplify(P-B,R),                    /* CFR050 */
                            Z=(Q=R)                             /* CFR050 */
                         ;                                      /* CFR050 */
                            signed_integer(Q),                  /* CFR050 */
                            simplify(B+Q,R),                    /* CFR050 */
                            Z=(P=R)                             /* CFR050 */
                         )                                      /* CFR050 */
                      )                                         /* CFR050 */
                   ;                                            /* CFR050 */
                      Z=(A=B)                                   /* CFR050 */
                   )                                            /* CFR050 */
                ), !.

/* REL2 */   simplify(X>Y,Z) :-
                checktype(X,T),
                (
                   type(T,enumerated),
                   !,
                   enumerated_simplify(X>Y,Z)
                ;
                   simplify(X,A),
                   simplify(Y,B),
                   (
                      signed_integer(A),
                      (                                         /* CFR050 */
                         signed_integer(B),                     /* CFR050 */
                         (                                      /* CFR050 */
                            B less_than A,                      /* CFR050 */
                            Z=true                              /* CFR050 */
                         ;                                      /* CFR050 */
                            (                                   /* CFR050 */
                               A=B                              /* CFR050 */
                            ;                                   /* CFR050 */
                               A less_than B                    /* CFR050 */
                            ),                                  /* CFR050 */
                            Z=false                             /* CFR050 */
                         )                                      /* CFR050 */
                      ;                                         /* CFR050 */
                         B=P+Q,                                 /* CFR050 */
                         (                                      /* CFR050 */
                            signed_integer(P),                  /* CFR050 */
                            simplify(A-P,R),                    /* CFR050 */
                            Z=(Q<R)                             /* CFR050 */
                         ;                                      /* CFR050 */
                            signed_integer(Q),                  /* CFR050 */
                            simplify(A-Q,R),                    /* CFR050 */
                            Z=(P<R)                             /* CFR050 */
                         )                                      /* CFR050 */
                      ;                                         /* CFR050 */
                         B=P-Q,                                 /* CFR050 */
                         (                                      /* CFR050 */
                            signed_integer(P),                  /* CFR050 */
                            simplify(P-A,R),                    /* CFR050 */
                            Z=(Q>R)                             /* CFR050 */
                         ;                                      /* CFR050 */
                            signed_integer(Q),                  /* CFR050 */
                            simplify(A+Q,R),                    /* CFR050 */
                            Z=(P<R)                             /* CFR050 */
                         )                                      /* CFR050 */
                      )                                         /* CFR050 */
                   ;                                            /* CFR050 */
                      signed_integer(B),                        /* CFR050 */
                      (                                         /* CFR050 */
                         A=P+Q,                                 /* CFR050 */
                         (                                      /* CFR050 */
                            signed_integer(P),                  /* CFR050 */
                            simplify(B-P,R),                    /* CFR050 */
                            Z=(Q>R)                             /* CFR050 */
                         ;                                      /* CFR050 */
                            signed_integer(Q),                  /* CFR050 */
                            simplify(B-Q,R),                    /* CFR050 */
                            Z=(P>R)                             /* CFR050 */
                         )                                      /* CFR050 */
                      ;                                         /* CFR050 */
                         A=P-Q,                                 /* CFR050 */
                         (                                      /* CFR050 */
                            signed_integer(P),                  /* CFR050 */
                            simplify(P-B,R),                    /* CFR050 */
                            Z=(Q<R)                             /* CFR050 */
                         ;                                      /* CFR050 */
                            signed_integer(Q),                  /* CFR050 */
                            simplify(B+Q,R),                    /* CFR050 */
                            Z=(P>R)                             /* CFR050 */
                         )                                      /* CFR050 */
                      )                                         /* CFR050 */
                   ;                                            /* CFR050 */
                      Z=(A>B)                                   /* CFR050 */
                   )                                            /* CFR050 */
                ), !.

/* REL3 */   simplify(X<Y,Z) :-
                checktype(X,T),
                (
                   type(T,enumerated),
                   !,
                   enumerated_simplify(X<Y,Z)
                ;
                   simplify(X,A),
                   simplify(Y,B),
                   (
                      signed_integer(A),
                      (                                         /* CFR050 */
                         signed_integer(B),                     /* CFR050 */
                         (                                      /* CFR050 */
                            A less_than B,                      /* CFR050 */
                            Z=true                              /* CFR050 */
                         ;                                      /* CFR050 */
                            (                                   /* CFR050 */
                               A=B                              /* CFR050 */
                            ;                                   /* CFR050 */
                               B less_than A                    /* CFR050 */
                            ),                                  /* CFR050 */
                            Z=false                             /* CFR050 */
                         )                                      /* CFR050 */
                      ;                                         /* CFR050 */
                         B=P+Q,                                 /* CFR050 */
                         (                                      /* CFR050 */
                            signed_integer(P),                  /* CFR050 */
                            simplify(A-P,R),                    /* CFR050 */
                            Z=(Q>R)                             /* CFR050 */
                         ;                                      /* CFR050 */
                            signed_integer(Q),                  /* CFR050 */
                            simplify(A-Q,R),                    /* CFR050 */
                            Z=(P>R)                             /* CFR050 */
                         )                                      /* CFR050 */
                      ;                                         /* CFR050 */
                         B=P-Q,                                 /* CFR050 */
                         (                                      /* CFR050 */
                            signed_integer(P),                  /* CFR050 */
                            simplify(P-A,R),                    /* CFR050 */
                            Z=(Q<R)                             /* CFR050 */
                         ;                                      /* CFR050 */
                            signed_integer(Q),                  /* CFR050 */
                            simplify(A+Q,R),                    /* CFR050 */
                            Z=(P>R)                             /* CFR050 */
                         )                                      /* CFR050 */
                      )                                         /* CFR050 */
                   ;                                            /* CFR050 */
                      signed_integer(B),                        /* CFR050 */
                      (                                         /* CFR050 */
                         A=P+Q,                                 /* CFR050 */
                         (                                      /* CFR050 */
                            signed_integer(P),                  /* CFR050 */
                            simplify(B-P,R),                    /* CFR050 */
                            Z=(Q<R)                             /* CFR050 */
                         ;                                      /* CFR050 */
                            signed_integer(Q),                  /* CFR050 */
                            simplify(B-Q,R),                    /* CFR050 */
                            Z=(P<R)                             /* CFR050 */
                         )                                      /* CFR050 */
                      ;                                         /* CFR050 */
                         A=P-Q,                                 /* CFR050 */
                         (                                      /* CFR050 */
                            signed_integer(P),                  /* CFR050 */
                            simplify(P-B,R),                    /* CFR050 */
                            Z=(Q>R)                             /* CFR050 */
                         ;                                      /* CFR050 */
                            signed_integer(Q),                  /* CFR050 */
                            simplify(B+Q,R),                    /* CFR050 */
                            Z=(P<R)                             /* CFR050 */
                         )                                      /* CFR050 */
                      )                                         /* CFR050 */
                   ;                                            /* CFR050 */
                      Z=(A<B)                                   /* CFR050 */
                   )                                            /* CFR050 */
                ), !.

/* REL4 */   simplify(X<>Y,Z) :-
                checktype(X,T),
                (
                   type(T, set(_)),
                   !,
                   set_simplify(X<>Y,Z)
                ;
                   type(T,enumerated),
                   !,
                   enumerated_simplify(X<>Y,Z)
                ;
                   simplify(X,A),
                   simplify(Y,B),
                   (
                      A=B,
                      Z=false
                   ;
                      signed_integer(A),
                      (                                         /* CFR050 */
                         signed_integer(B),                     /* CFR050 */
                         (                                      /* CFR050 */
                            A\=B,                               /* CFR050 */
                            Z=true                              /* CFR050 */
                         ;                                      /* CFR050 */
                            A=B,                                /* CFR050 */
                            Z=true                              /* CFR050 */
                         )                                      /* CFR050 */
                      ;                                         /* CFR050 */
                         B=P+Q,                                 /* CFR050 */
                         (                                      /* CFR050 */
                            signed_integer(P),                  /* CFR050 */
                            simplify(A-P,R),                    /* CFR050 */
                            Z=(Q<>R)                            /* CFR050 */
                         ;                                      /* CFR050 */
                            signed_integer(Q),                  /* CFR050 */
                            simplify(A-Q,R),                    /* CFR050 */
                            Z=(P<>R)                            /* CFR050 */
                         )                                      /* CFR050 */
                      ;                                         /* CFR050 */
                         B=P-Q,                                 /* CFR050 */
                         (                                      /* CFR050 */
                            signed_integer(P),                  /* CFR050 */
                            simplify(P-A,R),                    /* CFR050 */
                            Z=(Q<>R)                            /* CFR050 */
                         ;                                      /* CFR050 */
                            signed_integer(Q),                  /* CFR050 */
                            simplify(A+Q,R),                    /* CFR050 */
                            Z=(P<>R)                            /* CFR050 */
                         )                                      /* CFR050 */
                      )                                         /* CFR050 */
                   ;                                            /* CFR050 */
                      signed_integer(B),                        /* CFR050 */
                      (                                         /* CFR050 */
                         A=P+Q,                                 /* CFR050 */
                         (                                      /* CFR050 */
                            signed_integer(P),                  /* CFR050 */
                            simplify(B-P,R),                    /* CFR050 */
                            Z=(Q<>R)                            /* CFR050 */
                         ;                                      /* CFR050 */
                            signed_integer(Q),                  /* CFR050 */
                            simplify(B-Q,R),                    /* CFR050 */
                            Z=(P<>R)                            /* CFR050 */
                         )                                      /* CFR050 */
                      ;                                         /* CFR050 */
                         A=P-Q,                                 /* CFR050 */
                         (                                      /* CFR050 */
                            signed_integer(P),                  /* CFR050 */
                            simplify(P-B,R),                    /* CFR050 */
                            Z=(Q<>R)                            /* CFR050 */
                         ;                                      /* CFR050 */
                            signed_integer(Q),                  /* CFR050 */
                            simplify(B+Q,R),                    /* CFR050 */
                            Z=(P<>R)                            /* CFR050 */
                         )                                      /* CFR050 */
                      )                                         /* CFR050 */
                   ;                                            /* CFR050 */
                      Z=(A<>B)                                  /* CFR050 */
                   )                                            /* CFR050 */
                ), !.


/* REL5 */   simplify(X<=Y,Z) :-
                checktype(X,T),
                (
                   type(T,enumerated),
                   !,
                   enumerated_simplify(X<=Y,Z)
                ;
                   simplify(X,A),
                   simplify(Y,B),
                   (
                      A=B,                                      /* CFR050 */
                      Z=true                                    /* CFR050 */
                   ;                                            /* CFR050 */
                      signed_integer(A),                        /* CFR050 */
                      (                                         /* CFR050 */
                         signed_integer(B),                     /* CFR050 */
                         (                                      /* CFR050 */
                            A less_than B,                      /* CFR050 */
                            Z=true                              /* CFR050 */
                         ;                                      /* CFR050 */
                            B less_than A,                      /* CFR050 */
                            Z=false                             /* CFR050 */
                         )                                      /* CFR050 */
                      ;                                         /* CFR050 */
                         B=P+Q,                                 /* CFR050 */
                         (                                      /* CFR050 */
                            signed_integer(P),                  /* CFR050 */
                            simplify(A-P,R),                    /* CFR050 */
                            Z=(R<=Q)                            /* CFR050 */
                         ;                                      /* CFR050 */
                            signed_integer(Q),                  /* CFR050 */
                            simplify(A-Q,R),                    /* CFR050 */
                            Z=(R<=P)                            /* CFR050 */
                         )                                      /* CFR050 */
                      ;                                         /* CFR050 */
                         B=P-Q,                                 /* CFR050 */
                         (                                      /* CFR050 */
                            signed_integer(P),                  /* CFR050 */
                            simplify(P-A,R),                    /* CFR050 */
                            Z=(Q<=R)                            /* CFR050 */
                         ;                                      /* CFR050 */
                            signed_integer(Q),                  /* CFR050 */
                            simplify(A+Q,R),                    /* CFR050 */
                            Z=(R<=P)                            /* CFR050 */
                         )                                      /* CFR050 */
                      )                                         /* CFR050 */
                   ;                                            /* CFR050 */
                      signed_integer(B),                        /* CFR050 */
                      (                                         /* CFR050 */
                         A=P+Q,                                 /* CFR050 */
                         (                                      /* CFR050 */
                            signed_integer(P),                  /* CFR050 */
                            simplify(B-P,R),                    /* CFR050 */
                            Z=(Q<=R)                            /* CFR050 */
                         ;                                      /* CFR050 */
                            signed_integer(Q),                  /* CFR050 */
                            simplify(B-Q,R),                    /* CFR050 */
                            Z=(P<=R)                            /* CFR050 */
                         )                                      /* CFR050 */
                      ;                                         /* CFR050 */
                         A=P-Q,                                 /* CFR050 */
                         (                                      /* CFR050 */
                            signed_integer(P),                  /* CFR050 */
                            simplify(P-B,R),                    /* CFR050 */
                            Z=(R<=Q)                            /* CFR050 */
                         ;                                      /* CFR050 */
                            signed_integer(Q),                  /* CFR050 */
                            simplify(B+Q,R),                    /* CFR050 */
                            Z=(P<=R)                            /* CFR050 */
                         )                                      /* CFR050 */
                      )                                         /* CFR050 */
                   ;                                            /* CFR050 */
                      Z=(A<=B)                                  /* CFR050 */
                   )                                            /* CFR050 */
                ), !.

/* REL6 */   simplify(X>=Y,Z) :-
                checktype(X,T),
                (
                   type(T,enumerated),
                   !,
                   enumerated_simplify(X>=Y,Z)
                ;
                   simplify(X,A),
                   simplify(Y,B),
                   (
                      A=B,
                      Z=true
                   ;
                      signed_integer(A),
                      (                                         /* CFR050 */
                         signed_integer(B),                     /* CFR050 */
                         (                                      /* CFR050 */
                            B less_than A,                      /* CFR050 */
                            Z=true                              /* CFR050 */
                         ;                                      /* CFR050 */
                            A less_than B,                      /* CFR050 */
                            Z=false                             /* CFR050 */
                         )                                      /* CFR050 */
                      ;                                         /* CFR050 */
                         B=P+Q,                                 /* CFR050 */
                         (                                      /* CFR050 */
                            signed_integer(P),                  /* CFR050 */
                            simplify(A-P,R),                    /* CFR050 */
                            Z=(Q<=R)                            /* CFR050 */
                         ;                                      /* CFR050 */
                            signed_integer(Q),                  /* CFR050 */
                            simplify(A-Q,R),                    /* CFR050 */
                            Z=(P<=R)                            /* CFR050 */
                         )                                      /* CFR050 */
                      ;                                         /* CFR050 */
                         B=P-Q,                                 /* CFR050 */
                         (                                      /* CFR050 */
                            signed_integer(P),                  /* CFR050 */
                            simplify(P-A,R),                    /* CFR050 */
                            Z=(Q>=R)                            /* CFR050 */
                         ;                                      /* CFR050 */
                            signed_integer(Q),                  /* CFR050 */
                            simplify(A+Q,R),                    /* CFR050 */
                            Z=(P<=R)                            /* CFR050 */
                         )                                      /* CFR050 */
                      )                                         /* CFR050 */
                   ;                                            /* CFR050 */
                      signed_integer(B),                        /* CFR050 */
                      (                                         /* CFR050 */
                         A=P+Q,                                 /* CFR050 */
                         (                                      /* CFR050 */
                            signed_integer(P),                  /* CFR050 */
                            simplify(B-P,R),                    /* CFR050 */
                            Z=(Q>=R)                            /* CFR050 */
                         ;                                      /* CFR050 */
                            signed_integer(Q),                  /* CFR050 */
                            simplify(B-Q,R),                    /* CFR050 */
                            Z=(P>=R)                            /* CFR050 */
                         )                                      /* CFR050 */
                      ;                                         /* CFR050 */
                         A=P-Q,                                 /* CFR050 */
                         (                                      /* CFR050 */
                            signed_integer(P),                  /* CFR050 */
                            simplify(P-B,R),                    /* CFR050 */
                            Z=(Q<=R)                            /* CFR050 */
                         ;                                      /* CFR050 */
                            signed_integer(Q),                  /* CFR050 */
                            simplify(B+Q,R),                    /* CFR050 */
                            Z=(P>=R)                            /* CFR050 */
                         )                                      /* CFR050 */
                      )                                         /* CFR050 */
                   ;                                            /* CFR050 */
                      Z=(A>=B)                                  /* CFR050 */
                   )                                            /* CFR050 */
                ), !.


/* ODD */    simplify(odd(X), ODD) :-
                simplify(X, NEWX),
                (
                   signed_integer(NEWX),
                   X1 iss NEWX*NEWX,
                   (
                      X2 iss (X1 div 2)*2,
                      X1 =:= X2,
                      ODD=false
                   ;
                      X2 iss (X1 div 2)*2,
                      X1 =\= X2,
                      ODD=true
                   )
                ;
                   NEWX=A*B,
                   simplify(odd(A), TFA),
                   simplify(odd(B), TFB),
                   (
                      (
                         TFA = false
                      ;
                         TFB = false
                      ),
                      ODD = false
                   ;
                      TFA = true,
                      ODD = TFB
                   ;
                      TFB = true,
                      ODD = TFA
                   )
                ;
                   (
                      NEWX=A+B
                   ;
                      NEWX=A-B
                   ),
                   simplify(odd(A), TFA),
                   simplify(odd(B), TFB),
                   (
                      TFA = true,
                      (
                         TFB = true,
                         ODD = false
                      ;
                         TFB = false,
                         ODD = true
                      ;
                         ODD = (not TFB)
                      )
                   ;
                      TFA = false,
                      ODD = TFB
                   ;
                      TFB = true,
                      ODD = (not TFA)
                   ;
                      TFB = false,
                      ODD = TFA
                   )
                ;
                   NEWX = (-A),
                   simplify(odd(A), ODD)
                ;
                   ODD = odd(NEWX)
                ), !.

/* SQR1*/    simplify(sqr(abs(X)), SQR) :- simplify(X*X, SQR), !.
/* SQR2*/    simplify(sqr(X), SQR) :- simplify(X*X, SQR), !.

/* ABS */    simplify(abs(X), ABS) :-
                simplify(X, NEWX),
                (
                   signed_integer(NEWX),
                   (
                      NEWX >= 0,
                      ABS = NEWX
                   ;
                      NEWX < 0,
                      ABS is -NEWX
                   )
                ;
                   NEWX = A*A,
                   ABS = NEWX
                ;
                   NEWX = A*B,
                   simplify(abs(A), ABSA),
                   simplify(abs(B), ABSB),
                   ABS = ABSA*ABSB
                ;
                   NEWX = abs(_EXPR),
                   ABS = NEWX
                ;
                   ABS = abs(NEWX)
                ), !.


/* Simplify array, record & sequence type objects if possible */

/* ARR */    simplify(X, Y) :- array_simplify(X, Y), !.
/* REC */    simplify(X, Y) :- record_simplify(X, Y), !.
/* SEQ */    simplify(X, Y) :- sequence_simplify(X, Y), !.
/* ENU1 */   simplify(succ(X), Y) :- enumerated_simplify(succ(X), Y), !.
/* ENU2 */   simplify(pred(X), Y) :- enumerated_simplify(pred(X), Y), !.

/* Final catch-all */

/* EVAL */   simplify(X,Y) :- evaluate(X,Y), !.


/*** EVALUATE(in X,out Y) -- evaluate (non-boolean) X to get Y ***/

/* EVAL_BASE1 */ evaluate(X,X) :-
                    (
                       signed_integer(X)
                    ;
                       X=true
                    ;
                       X=false
                    ), !.
/* EVAL_BASE2 */ evaluate(X,Y) :-
                    integer(X), X<0,
                    Y iss X, !.

/* UMIN1 */  evaluate(-(-X),A) :- simplify(X,A), !.
/* UMIN2 */  evaluate(-X,A) :-
                simplify(X,B),
                (
                   signed_integer(B),
                   A iss -B
                ;
                   A=(-B)
                ), !.

/* UPLUS */  evaluate(+X, A) :- simplify(X, A), !.              /* CFR039 */

/*SPECIAL*/  evaluate(X+N-N,Y) :- simplify(X,Y), !.
             evaluate(X-N+N,Y) :- simplify(X,Y), !.

/* PLUS  */  evaluate(X+Y,Z) :-
                simplify(X,A),
                simplify(Y,B),
                (
                   signed_integer(A),
                   signed_integer(B),
                   Z iss A+B
                ;
                   A=0,
                   Z=B
                ;
                   B=0,
                   Z=A
                ;
                   Z=A+B
                ), !.

/* MINUS */  evaluate(X-Y,Z) :-
                simplify(X,A),
                simplify(Y,B),
                (
                   signed_integer(A),
                   signed_integer(B),
                   Z iss A-B
                ;
                   B=0,
                   Z=A
                ;
                   A=0,
                   simplify(-Y,Z)
                ;
                   Z=A-B
                ), !.

/* MULT  */  evaluate(X*Y,Z) :-
                simplify(X,A),
                simplify(Y,B),
                (
                   signed_integer(A),
                   signed_integer(B),
                   Z iss A*B
                ;
                   (
                      A=0
                   ;
                      B=0
                   ),
                   Z=0
                ;
                   A=1,
                   Z=B
                ;
                   B=1,
                   Z=A
                ;
                   Z=A*B
                ), !.

/* DIV   */  evaluate(X div Y,Z) :-
                simplify(X,A),
                simplify(Y,B),
                (
                   signed_integer(A),
                   signed_integer(B),
                   B\=0,
                   Z iss A div B
                ;
                   B=1,
                   Z=A
                ;
                   Z=A div B
                ), !.

/*  /    */  evaluate(X / Y,Z) :-                               /*1.4*/
                simplify(X,A),                                  /*1.4*/
                simplify(Y,B),                                  /*1.4*/
                (                                               /*1.4*/
                   signed_integer(A),                           /*1.4*/
                   signed_integer(B),                           /*1.4*/
                   B\=0,                                        /*1.4*/
                   Z iss A div B,                               /*1.4*/
                   A =:= Z * B                                  /*1.4*/
                ;                                               /*1.4*/
                   B=1,                                         /*1.4*/
                   Z=A                                          /*1.4*/
                ;                                               /*1.4*/
                   Z=A / B                                      /*1.4*/
                ), !.                                           /*1.4*/

/* MOD   */  evaluate(X mod Y,A mod B) :-
                simplify(X,A),
                simplify(Y,B),
                !.   /* TEMPORARILY */
/* OLD MOD STUFF:
                (
                   signed_integer(A),
                   signed_integer(B),
                   B\=0,
                   Z iss A mod B
                ;
                   B=1,
                   Z=0
                ;
                   Z=(A mod B)
                ), !.   DELETED */

/*  EXP  */  evaluate(X**Y,Z) :-                                /* CFR038 */
                simplify(X,A),                                  /* CFR038 */
                simplify(Y,B),                                  /* CFR038 */
                (                                               /* CFR038 */
                   signed_integer(A),                           /* CFR038 */
                   signed_integer(B),                           /* CFR038 */
                   Z iss A**B                                   /* CFR038 */
                ;                                               /* CFR038 */
                   B=0,                                         /* CFR038 */
                   Z=1                                          /* CFR038 */
                ;                                               /* CFR038 */
                   B=1,                                         /* CFR038 */
                   Z=A                                          /* CFR038 */
                ;                                               /* CFR038 */
                   B=2,                                         /* CFR038 */
                   Z=A*A                                        /* CFR038 */
                ;                                               /* CFR038 */
                   Z=A**B                                       /* CFR038 */
                ), !.                                           /* CFR038 */

/* EVAL_VAL */     evaluate(X,Y) :- val(X,Y), !.

/* FUNC_SPLIT */   evaluate(X,Z) :-
                      (\+ atomic(X)),
                      X=..[H|T],
                      eval_list(T,U),
                      Z=..[H|U],
                      !.


/*** EVAL_LIST(in XL,out YL) -- simplify/evaluate each element
        of XL to get YL ***/

/* EVL1 */   eval_list([],[]) :- !.
/* EVL2 */   eval_list([H1|T1],[H2|T2]) :-
                simplify(H1,H2),
                eval_list(T1,T2),
                !.


/*** VAL(in X,out Y) -- additional simplification rules slot in here ***/

val(X,X) :- atomic(X), !.


/*** SIGNED_INTEGER(I) -- is I an integer (with an optional -)? ***/

signed_integer(I) :-
        (
           integer(I), I>=0
        ;
           I=(-I1), integer(I1), I1>0
        ).


/*** X LESS_THAN Y -- compare two signed_integers ***/

-X less_than -Y :- integer(X), X>0, integer(Y), Y>0, Y less_than X.
-X less_than Y :- integer(X), X>0, integer(Y), Y>=0.
X less_than Y :- integer(X), X>=0, integer(Y), Y>X.
%###############################################################################
%END-OF-FILE