2:-include(library('ec_planner/ec_test_incl')). 3%
4% ectest/ec_reader_test_ecnet.e:1
5%
6%
7%
8%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
9%; FILE: foundations/Root.e
10%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
11% ectest/ec_reader_test_ecnet.e:7
12%
13%;
14%; Copyright (c) 2005 IBM Corporation and others.
15%; All rights reserved. This program and the accompanying materials
16%; are made available under the terms of the Common Public License v1.0
17%; which accompanies this distribution, and is available at
18%; http://www.eclipse.org/legal/cpl-v10.html
19%;
20%; Contributors:
21%; IBM - Initial implementation
22%;
23% ectest/ec_reader_test_ecnet.e:18
24% sort boolean
25 /*
26.
27*/
28.
29
30% sort integer
31 /*
32.
33*/
34.
35
36% reified sort predicate
37 /*
38.
39*/
40.
41
42% reified sort function
43 /*
44.
45*/
46.
47
48%
49%; End of file.
50% ectest/ec_reader_test_ecnet.e:24
51%
52%
53%
54%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
55%; FILE: foundations/EC.e
56%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
57% ectest/ec_reader_test_ecnet.e:30
58%
59%;
60%; Copyright (c) 2005 IBM Corporation and others.
61%; All rights reserved. This program and the accompanying materials
62%; are made available under the terms of the Common Public License v1.0
63%; which accompanies this distribution, and is available at
64%; http://www.eclipse.org/legal/cpl-v10.html
65%;
66%; Contributors:
67%; IBM - Initial implementation
68%;
69%; Event Calculus (EC)
70%;
71%; @incollection{MillerShanahan:2002,
72%; author = "Rob Miller and Murray Shanahan",
73%; year = "2002",
74%; title = "Some alternative formulations of the event calculus",
75%; editor = "Antonis C. Kakas and Fariba Sadri",
76%; booktitle = "Computational Logic: Logic Programming and Beyond: Essays in Honour of \uppercase{R}obert \uppercase{A}. \uppercase{K}owalski, Part \uppercase{II}",
77%; series = "Lecture Notes in Computer Science",
78%; volume = "2408",
79%; pages = "452--490",
80%; address = "Berlin",
81%; publisher = "Springer",
82%; }
83%;
84% ectest/ec_reader_test_ecnet.e:56
85%
86% sort time: integer
87 /*
88.
89*/
90.
91.
92.
93
94% sort offset: integer
95 /*
96.
97*/
98.
99.
100.
101
102%
103% reified sort fluent
104 /*
105.
106*/
107.
108
109% reified sort event
110 /*
111.
112*/
113.
114
115% ectest/ec_reader_test_ecnet.e:62
116%
117% predicate Happens(event,time)
118 /*
119.
120*/
121.
122
123% predicate HoldsAt(fluent,time)
124 /*
125.
126*/
127.
128
129% predicate ReleasedAt(fluent,time)
130 /*
131.
132*/
133.
134
135% predicate Initiates(event,fluent,time)
136 /*
137.
138*/
139.
140
141% predicate Terminates(event,fluent,time)
142 /*
143.
144*/
145.
146
147% ectest/ec_reader_test_ecnet.e:68
148% predicate Releases(event,fluent,time)
149 /*
150.
151*/
152.
153
154% predicate Trajectory(fluent,time,fluent,offset)
155 /*
156.
157*/
158.
159
160%
161%; End of file.
162%
163%
164% ectest/ec_reader_test_ecnet.e:74
165%
166%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
167%; FILE: foundations/DEC.e
168%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
169%
170%;
171%; Copyright (c) 2005 IBM Corporation and others.
172%; All rights reserved. This program and the accompanying materials
173%; are made available under the terms of the Common Public License v1.0
174%; which accompanies this distribution, and is available at
175%; http://www.eclipse.org/legal/cpl-v10.html
176%;
177%; Contributors:
178%; IBM - Initial implementation
179%;
180%; Discrete Event Calculus (DEC)
181%;
182%; @article{Mueller:2004a,
183%; author = "Erik T. Mueller",
184%; year = "2004",
185%; title = "Event calculus reasoning through satisfiability",
186%; journal = "Journal of Logic and Computation",
187%; volume = "14",
188%; number = "5",
189%; pages = "703--730",
190%; }
191%;
192% ectest/ec_reader_test_ecnet.e:101
193%
194% sort time: integer
195 /*
196.
197*/
198.
199.
200.
201
202% sort offset: integer
203 /*
204.
205*/
206.
207.
208.
209
210%
211% reified sort fluent
212 /*
213.
214*/
215.
216
217% reified sort event
218 /*
219.
220*/
221.
222
223% ectest/ec_reader_test_ecnet.e:107
224%
225% predicate Happens(event,time)
226 /*
227.
228*/
229.
230
231% predicate HoldsAt(fluent,time)
232 /*
233.
234*/
235.
236
237% predicate ReleasedAt(fluent,time)
238 /*
239.
240*/
241.
242
243%
244% predicate Initiates(event,fluent,time)
245 /*
246.
247*/
248.
249
250% ectest/ec_reader_test_ecnet.e:113
251% predicate Terminates(event,fluent,time)
252 /*
253.
254*/
255.
256
257% predicate Releases(event,fluent,time)
258 /*
259.
260*/
261.
262
263%
264% ectest/ec_reader_test_ecnet.e:116
265% [fluent,time]%
266% (HoldsAt(fluent,time) &
267% !ReleasedAt(fluent,time+1) &
268% !({event} Happens(event,time) & Terminates(event,fluent,time))) ->
269% HoldsAt(fluent,time+1).
270 /*
271holds_at(Fluent, Time), not(releasedAt(Fluent, Time+1)), not(exists([Event], (happens(Event, Time), terminates(Event, Fluent, Time)))) ->
272 holds_at(Fluent, Time+1).
273*/
274.
275
276%
277%
278% ectest/ec_reader_test_ecnet.e:122
279% [fluent,time]%
280% (!HoldsAt(fluent,time) &
281% !ReleasedAt(fluent,time+1) &
282% !({event} Happens(event,time) & Initiates(event,fluent,time))) ->
283% !HoldsAt(fluent,time+1).
284 /*
285not(holds_at(Fluent, Time)), not(releasedAt(Fluent, Time+1)), not(exists([Event], (happens(Event, Time), initiates(Event, Fluent, Time)))) ->
286 not(holds_at(Fluent, Time+1)).
287*/
288.
289
290%
291%
292% ectest/ec_reader_test_ecnet.e:128
293% [fluent,time]%
294% (!ReleasedAt(fluent,time) &
295% !({event} Happens(event,time) & Releases(event,fluent,time))) ->
296% !ReleasedAt(fluent,time+1).
297 /*
298not(releasedAt(Fluent, Time)), not(exists([Event], (happens(Event, Time), releases(Event, Fluent, Time)))) ->
299 not(releasedAt(Fluent, Time+1)).
300*/
301.
302
303%
304%
305% ectest/ec_reader_test_ecnet.e:133
306% [fluent,time]%
307% (ReleasedAt(fluent,time) &
308% !({event} Happens(event,time) &
309% (Initiates(event,fluent,time) |
310% Terminates(event,fluent,time)))) ->
311% ReleasedAt(fluent,time+1).
312 /*
313releasedAt(Fluent, Time), not(exists([Event], (happens(Event, Time), (initiates(Event, Fluent, Time);terminates(Event, Fluent, Time))))) ->
314 releasedAt(Fluent, Time+1).
315*/
316.
317
318%
319% ectest/ec_reader_test_ecnet.e:139
320%
321% ectest/ec_reader_test_ecnet.e:140
322% [event,fluent,time]%
323% (Happens(event,time) & Initiates(event,fluent,time)) ->
324% (HoldsAt(fluent,time+1) & !ReleasedAt(fluent,time+1)).
325 /*
326happens(Event, Time), initiates(Event, Fluent, Time) ->
327 holds_at(Fluent, Time+1),
328 not(releasedAt(Fluent, Time+1)).
329*/
330.
331
332%
333%
334% ectest/ec_reader_test_ecnet.e:144
335% [event,fluent,time]%
336% (Happens(event,time) & Terminates(event,fluent,time)) ->
337% (!HoldsAt(fluent,time+1) & !ReleasedAt(fluent,time+1)).
338 /*
339happens(Event, Time), terminates(Event, Fluent, Time) ->
340 not(holds_at(Fluent, Time+1)),
341 not(releasedAt(Fluent, Time+1)).
342*/
343.
344
345%
346%
347% ectest/ec_reader_test_ecnet.e:148
348% [event,fluent,time]%
349% (Happens(event,time) & Releases(event,fluent,time)) ->
350% ReleasedAt(fluent,time+1).
351 /*
352happens(Event, Time), releases(Event, Fluent, Time) ->
353 releasedAt(Fluent, Time+1).
354*/
355.
356
357%
358%
359%; End of file.
360%
361% ectest/ec_reader_test_ecnet.e:154
362%
363%
364%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
365%; FILE: foundations/ECCausal.e
366%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
367%
368%;
369%; Copyright (c) 2005 IBM Corporation and others.
370%; All rights reserved. This program and the accompanying materials
371%; are made available under the terms of the Common Public License v1.0
372%; which accompanies this distribution, and is available at
373%; http://www.eclipse.org/legal/cpl-v10.html
374%;
375%; Contributors:
376%; IBM - Initial implementation
377%;
378%; Causal Constraints
379%;
380%; @inproceedings{Shanahan:1999a,
381%; author = "Murray Shanahan",
382%; year = "1999",
383%; title = "The ramification problem in the event calculus",
384%; booktitle = "\uppercase{P}roceedings of the \uppercase{S}ixteenth \uppercase{I}nternational \uppercase{J}oint \uppercase{C}onference on \uppercase{A}rtificial \uppercase{I}ntelligence",
385%; pages = "140--146",
386%; address = "San Mateo, CA",
387%; publisher = "Morgan Kaufmann",
388%; }
389%;
390% ectest/ec_reader_test_ecnet.e:182
391%
392% predicate Started(fluent,time)
393 /*
394.
395*/
396.
397
398% predicate Stopped(fluent,time)
399 /*
400.
401*/
402.
403
404%
405% ectest/ec_reader_test_ecnet.e:186
406% [fluent,time]%
407% Started(fluent,time) <->
408% (HoldsAt(fluent,time) |
409% ({event} Happens(event,time) & Initiates(event,fluent,time))).
410 /*
411started(Fluent, Time) <->
412 ( holds_at(Fluent, Time)
413 ; exists([Event],
414 (happens(Event, Time), initiates(Event, Fluent, Time)))
415 ).
416*/
417.
418.
419
420%
421%
422% ectest/ec_reader_test_ecnet.e:191
423% [fluent,time]%
424% Stopped(fluent,time) <->
425% (!HoldsAt(fluent,time) |
426% ({event} Happens(event,time) & Terminates(event,fluent,time))).
427 /*
428stopped(Fluent, Time) <->
429 ( not(holds_at(Fluent, Time))
430 ; exists([Event],
431 (happens(Event, Time), terminates(Event, Fluent, Time)))
432 ).
433*/
434.
435.
436
437%
438%
439% predicate Initiated(fluent,time)
440 /*
441.
442*/
443.
444
445% ectest/ec_reader_test_ecnet.e:197
446% predicate Terminated(fluent,time)
447 /*
448.
449*/
450.
451
452%
453% ectest/ec_reader_test_ecnet.e:199
454% [fluent,time]%
455% Initiated(fluent,time) <->
456% (Started(fluent,time) &
457% !({event} Happens(event,time) & Terminates(event,fluent,time))).
458 /*
459initiated(Fluent, Time) <->
460 started(Fluent, Time),
461 not(exists([Event],
462 (happens(Event, Time), terminates(Event, Fluent, Time)))).
463*/
464.
465.
466
467%
468%
469% ectest/ec_reader_test_ecnet.e:204
470% [fluent,time]%
471% Terminated(fluent,time) <->
472% (Stopped(fluent,time) &
473% !({event} Happens(event,time) & Initiates(event,fluent,time))).
474 /*
475terminated(Fluent, Time) <->
476 stopped(Fluent, Time),
477 not(exists([Event],
478 (happens(Event, Time), initiates(Event, Fluent, Time)))).
479*/
480.
481.
482
483%
484%
485%; End of file.
486% ectest/ec_reader_test_ecnet.e:210
487%
488%
489%
490%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
491%; FILE: foundations/ECTraj.e
492%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
493% ectest/ec_reader_test_ecnet.e:216
494%
495%;
496%; Copyright (c) 2005 IBM Corporation and others.
497%; All rights reserved. This program and the accompanying materials
498%; are made available under the terms of the Common Public License v1.0
499%; which accompanies this distribution, and is available at
500%; http://www.eclipse.org/legal/cpl-v10.html
501%;
502%; Contributors:
503%; IBM - Initial implementation
504%;
505%; @incollection{MillerShanahan:2002,
506%; author = "Rob Miller and Murray Shanahan",
507%; year = "2002",
508%; title = "Some alternative formulations of the event calculus",
509%; editor = "Antonis C. Kakas and Fariba Sadri",
510%; booktitle = "Computational Logic: Logic Programming and Beyond: Essays in Honour of \uppercase{R}obert \uppercase{A}. \uppercase{K}owalski, Part \uppercase{II}",
511%; series = "Lecture Notes in Computer Science",
512%; volume = "2408",
513%; pages = "452--490",
514%; address = "Berlin",
515%; publisher = "Springer",
516%; }
517%;
518% ectest/ec_reader_test_ecnet.e:240
519%
520% predicate Clipped(time,fluent,time)
521 /*
522.
523*/
524.
525
526% predicate Declipped(time,fluent,time)
527 /*
528.
529*/
530.
531
532%
533% predicate Trajectory(fluent,time,fluent,offset)
534 /*
535.
536*/
537.
538
539% predicate AntiTrajectory(fluent,time,fluent,offset)
540 /*
541.
542*/
543.
544
545% ectest/ec_reader_test_ecnet.e:246
546%
547% ectest/ec_reader_test_ecnet.e:247
548% [event,fluent,fluent2,offset,time]%
549% Happens(event,time) &
550% Initiates(event,fluent,time) &
551% 0 < offset &
552% Trajectory(fluent,time,fluent2,offset) &
553% !Clipped(time,fluent,time+offset) ->
554% HoldsAt(fluent2,time+offset).
555 /*
556happens(Event, Time), initiates(Event, Fluent, Time), 0<Offset, trajectory(Fluent, Time, Fluent2, Offset), not(clipped(Time, Fluent, Time+Offset)) ->
557 holds_at(Fluent2, Time+Offset).
558*/
559.
560
561% ectest/ec_reader_test_ecnet.e:253
562%
563%
564% ectest/ec_reader_test_ecnet.e:255
565% [event,fluent,fluent2,offset,time]%
566% Happens(event,time) &
567% Terminates(event,fluent,time) &
568% 0 < offset &
569% AntiTrajectory(fluent,time,fluent2,offset) &
570% !Declipped(time,fluent,time+offset) ->
571% HoldsAt(fluent2,time+offset).
572 /*
573happens(Event, Time), terminates(Event, Fluent, Time), 0<Offset, antiTrajectory(Fluent, Time, Fluent2, Offset), not(declipped(Time, Fluent, Time+Offset)) ->
574 holds_at(Fluent2, Time+Offset).
575*/
576.
577
578% ectest/ec_reader_test_ecnet.e:261
579%
580%
581%; End of file.
582%
583%
584%
585%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
586%; FILE: ecnet/Ontology.e
587%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
588% ectest/ec_reader_test_ecnet.e:270
589%
590%;
591%; Copyright (c) 2005 IBM Corporation and others.
592%; All rights reserved. This program and the accompanying materials
593%; are made available under the terms of the Common Public License v1.0
594%; which accompanies this distribution, and is available at
595%; http://www.eclipse.org/legal/cpl-v10.html
596%;
597%; Contributors:
598%; IBM - Initial implementation
599%;
600%; integer
601%;
602% ectest/ec_reader_test_ecnet.e:283
603%
604% sort diameter: integer
605 /*
606.
607*/
608.
609.
610.
611
612%
613%; object
614%
615% sort object
616 /*
617.
618*/
619.
620
621% ectest/ec_reader_test_ecnet.e:289
622%
623% sort agent: object
624 /*
625.
626*/
627.
628.
629.
630
631%
632% sort physobj: object
633 /*
634.
635*/
636.
637.
638.
639
640% sort bed: physobj
641 /*
642.
643*/
644.
645.
646.
647
648% sort snowflake: physobj
649 /*
650.
651*/
652.
653.
654.
655
656% ectest/ec_reader_test_ecnet.e:295
657% sort sky: physobj
658 /*
659.
660*/
661.
662.
663.
664
665%
666% sort stuff: physobj
667 /*
668.
669*/
670.
671.
672.
673
674%
675% sort surface: physobj
676 /*
677.
678*/
679.
680.
681.
682
683% sort ground: surface
684 /*
685.
686*/
687.
688.
689.
690
691% ectest/ec_reader_test_ecnet.e:301
692%
693% sort snow: stuff
694 /*
695.
696*/
697.
698.
699.
700
701% sort ball
702 /*
703.
704*/
705.
706
707%
708% sort food: physobj
709 /*
710.
711*/
712.
713.
714.
715
716% sort fruit: food
717 /*
718.
719*/
720.
721.
722.
723
724% ectest/ec_reader_test_ecnet.e:307
725% sort orange: fruit
726 /*
727.
728*/
729.
730.
731.
732
733% sort salad: food
734 /*
735.
736*/
737.
738.
739.
740
741%
742% sort clothing: physobj
743 /*
744.
745*/
746.
747.
748.
749
750% sort scarf: clothing
751 /*
752.
753*/
754.
755.
756.
757
758% sort hat: clothing
759 /*
760.
761*/
762.
763.
764.
765
766% ectest/ec_reader_test_ecnet.e:313
767%
768% sort vegetablematter: physobj
769 /*
770.
771*/
772.
773.
774.
775
776% sort coal: vegetablematter
777 /*
778.
779*/
780.
781.
782.
783
784%
785% sort bodypart: physobj
786 /*
787.
788*/
789.
790.
791.
792
793% sort hand: bodypart
794 /*
795.
796*/
797.
798.
799.
800
801% ectest/ec_reader_test_ecnet.e:319
802%
803% sort papertowels: physobj
804 /*
805.
806*/
807.
808.
809.
810
811% sort device: physobj
812 /*
813.
814*/
815.
816.
817.
818
819% sort electronicdevice: device
820 /*
821.
822*/
823.
824.
825.
826
827% sort lamp: electronicdevice
828 /*
829.
830*/
831.
832.
833.
834
835%
836% ectest/ec_reader_test_ecnet.e:325
837% sort cat: physobj
838 /*
839.
840*/
841.
842.
843.
844
845% sort horse: physobj
846 /*
847.
848*/
849.
850.
851.
852
853%
854% sort weapon: physobj
855 /*
856.
857*/
858.
859.
860.
861
862% sort gun: weapon
863 /*
864.
865*/
866.
867.
868.
869
870% sort bomb: weapon
871 /*
872.
873*/
874.
875.
876.
877
878% ectest/ec_reader_test_ecnet.e:331
879% sort bullet: weapon
880 /*
881.
882*/
883.
884.
885.
886
887%
888%; location
889%
890% sort location
891 /*
892.
893*/
894.
895
896% sort room: location, outside: location
897 /*
898.
899*/
900.
901.
902.
903
904 /*
905.
906*/
907.
908.
909.
910
911% ectest/ec_reader_test_ecnet.e:337
912%
913%; portal
914%
915% sort portal
916 /*
917.
918*/
919.
920
921% sort door: portal, staircase: portal
922 /*
923.
924*/
925.
926.
927.
928
929 /*
930.
931*/
932.
933.
934.
935
936% sort street: portal
937 /*
938.
939*/
940.
941.
942.
943
944% ectest/ec_reader_test_ecnet.e:343
945% sort track: portal
946 /*
947.
948*/
949.
950.
951.
952
953%
954% sort building
955 /*
956.
957*/
958.
959
960%
961% sort fire: object
962 /*
963.
964*/
965.
966.
967.
968
969% sort smoke: physobj
970 /*
971.
972*/
973.
974.
975.
976
977% ectest/ec_reader_test_ecnet.e:349
978%
979% sort furniture: physobj
980 /*
981.
982*/
983.
984.
985.
986
987% sort chair: furniture
988 /*
989.
990*/
991.
992.
993.
994
995% sort table: furniture
996 /*
997.
998*/
999.
1000.
1001.
1002
1003%
1004% sort bill: physobj
1005 /*
1006.
1007*/
1008.
1009.
1010.
1011
1012% ectest/ec_reader_test_ecnet.e:355
1013% sort ticket: physobj
1014 /*
1015.
1016*/
1017.
1018.
1019.
1020
1021% sort envelope: physobj
1022 /*
1023.
1024*/
1025.
1026.
1027.
1028
1029%
1030% sort text: physobj
1031 /*
1032.
1033*/
1034.
1035.
1036.
1037
1038% sort book: text
1039 /*
1040.
1041*/
1042.
1043.
1044.
1045
1046% sort letter: text
1047 /*
1048.
1049*/
1050.
1051.
1052.
1053
1054% ectest/ec_reader_test_ecnet.e:361
1055% sort menu: text
1056 /*
1057.
1058*/
1059.
1060.
1061.
1062
1063%
1064% sort paper: physobj
1065 /*
1066.
1067*/
1068.
1069.
1070.
1071
1072%
1073% sort content
1074 /*
1075.
1076*/
1077.
1078
1079% sort script
1080 /*
1081.
1082*/
1083.
1084
1085% ectest/ec_reader_test_ecnet.e:367
1086%
1087% sort container: physobj
1088 /*
1089.
1090*/
1091.
1092.
1093.
1094
1095% sort cigarette: physobj
1096 /*
1097.
1098*/
1099.
1100.
1101.
1102
1103% sort ashtray: physobj
1104 /*
1105.
1106*/
1107.
1108.
1109.
1110
1111% sort umbrella: physobj
1112 /*
1113.
1114*/
1115.
1116.
1117.
1118
1119%
1120% ectest/ec_reader_test_ecnet.e:373
1121% sort pen: physobj
1122 /*
1123.
1124*/
1125.
1126.
1127.
1128
1129%
1130%; End of file.
1131%
1132%
1133%
1134%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1135%; FILE: ecnet/RTSpace.e
1136%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1137% ectest/ec_reader_test_ecnet.e:382
1138%
1139%;
1140%; Copyright (c) 2005 IBM Corporation and others.
1141%; All rights reserved. This program and the accompanying materials
1142%; are made available under the terms of the Common Public License v1.0
1143%; which accompanies this distribution, and is available at
1144%; http://www.eclipse.org/legal/cpl-v10.html
1145%;
1146%; Contributors:
1147%; IBM - Initial implementation
1148%;
1149%; RTSpace: room-scale topological space
1150%;
1151%; We use topological and metric representations of space,
1152%; at two levels of granularity---room-scale and object-scale.
1153%; The RTSpace representation deals with topological space at
1154%; the scale of rooms and outdoor locations.
1155%; This representation of space consists of locations, which
1156%; are connected by portals. There are two types of locations:
1157%; rooms and outside areas (outsides).
1158%;
1159% ectest/ec_reader_test_ecnet.e:403
1160%
1161%; object is at location.
1162% fluent At(object,location)
1163 /*
1164.
1165*/
1166.
1167
1168% manualrelease At
1169 /*
1170.
1171*/
1172.
1173
1174%
1175% ectest/ec_reader_test_ecnet.e:408
1176% [object1,location,time]%
1177% (
1178% ectest/ec_reader_test_ecnet.e:409
1179% {object2} PartOf(object1,object2)) ->
1180% ReleasedAt(At(object1,location),time).
1181 /*
1182exists([Object2], (partOf(Object1, Object2)->releasedAt(at(Object1, Location), Time))).
1183*/
1184.
1185
1186%
1187%
1188%; A state constraint says that an object
1189%; is at one location at a time:
1190% ectest/ec_reader_test_ecnet.e:414
1191% [object,location1,location2,time]%
1192% HoldsAt(At(object,location1),time) &
1193% HoldsAt(At(object,location2),time) ->
1194% location1=location2.
1195 /*
1196holds_at(at(Object, Location1), Time), holds_at(at(Object, Location2), Time) ->
1197 Location1=Location2.
1198*/
1199.
1200
1201%
1202%
1203%; connectivity
1204% ectest/ec_reader_test_ecnet.e:420
1205%
1206%; Side one of portal is location.
1207% function Side1(portal): location
1208 /*
1209.
1210*/
1211.
1212
1213%; Side two of portal is location.
1214% function Side2(portal): location
1215 /*
1216.
1217*/
1218.
1219
1220%
1221%; The building of room is building.
1222% ectest/ec_reader_test_ecnet.e:427
1223% function BuildingOf(room): building
1224 /*
1225.
1226*/
1227.
1228
1229%
1230%; object is at a location that has portal.
1231% fluent NearPortal(object,portal)
1232 /*
1233.
1234*/
1235.
1236
1237% noninertial NearPortal
1238 /*
1239.
1240*/
1241.
1242
1243%
1244%; A state constraint says that an object is near
1245%; a portal if and only if there is a location such that
1246%; the object is at the location and one of the sides
1247%; of the portal is the location:
1248% ectest/ec_reader_test_ecnet.e:437
1249% [object,portal,time]%
1250% HoldsAt(NearPortal(object,portal),time) <->
1251% ectest/ec_reader_test_ecnet.e:439
1252% {location}%
1253% (Side1(portal)=location|
1254% Side2(portal)=location) &
1255% HoldsAt(At(object,location),time).
1256 /*
1257exists([Location], (holds_at(nearPortal(Object, Portal), Time)<->(side1(Portal)=Location;side2(Portal)=Location), holds_at(at(Object, Location), Time))).
1258*/
1259.
1260.
1261
1262%
1263%
1264%; locking and unlocking doors
1265% ectest/ec_reader_test_ecnet.e:445
1266%
1267%; agent unlocks door.
1268% event DoorUnlock(agent,door)
1269 /*
1270.
1271*/
1272.
1273
1274%; agent locks door.
1275% event DoorLock(agent,door)
1276 /*
1277.
1278*/
1279.
1280
1281%; door is unlocked.
1282% ectest/ec_reader_test_ecnet.e:451
1283% fluent DoorUnlocked(door)
1284 /*
1285.
1286*/
1287.
1288
1289%
1290%; A precondition axiom states that
1291%; for an agent to unlock a door,
1292%; the agent must be awake,
1293%; the door must not already be unlocked, and
1294%; the agent must be near the door:
1295% ectest/ec_reader_test_ecnet.e:458
1296% [agent,door,time]%
1297% Happens(DoorUnlock(agent,door),time) ->
1298% HoldsAt(Awake(agent),time) &
1299% !HoldsAt(DoorUnlocked(door),time) &
1300% HoldsAt(NearPortal(agent,door),time).
1301 /*
1302happens(doorUnlock(Agent, Door), Time) ->
1303 holds_at(awake(Agent), Time),
1304 not(holds_at(doorUnlocked(Door), Time)),
1305 holds_at(nearPortal(Agent, Door), Time).
1306*/
1307.
1308
1309%
1310%
1311%; An effect axiom states that
1312%; if an agent unlocks a door,
1313%; the door will be unlocked:
1314% ectest/ec_reader_test_ecnet.e:467
1315% [agent,door,time]%
1316% Initiates(DoorUnlock(agent,door),DoorUnlocked(door),time).
1317 /*
1318.
1319*/
1320.
1321
1322%
1323%
1324%; A precondition axiom states that
1325%; for an agent to lock a door,
1326%; the agent must be awake,
1327%; the door must be unlocked, and
1328%; the agent must be near the door:
1329% ectest/ec_reader_test_ecnet.e:475
1330% [agent,door,time]%
1331% Happens(DoorLock(agent,door),time) ->
1332% HoldsAt(Awake(agent),time) &
1333% HoldsAt(DoorUnlocked(door),time) &
1334% HoldsAt(NearPortal(agent,door),time).
1335 /*
1336happens(doorLock(Agent, Door), Time) ->
1337 holds_at(awake(Agent), Time),
1338 holds_at(doorUnlocked(Door), Time),
1339 holds_at(nearPortal(Agent, Door), Time).
1340*/
1341.
1342
1343%
1344%
1345%; An effect axiom states that
1346%; if an agent locks a door,
1347%; the door will no longer be unlocked.
1348% ectest/ec_reader_test_ecnet.e:484
1349% [agent,door,time]%
1350% Terminates(DoorLock(agent,door),DoorUnlocked(door),time).
1351 /*
1352.
1353*/
1354.
1355
1356%
1357%
1358%; A state constraint says that if a door is open,
1359%; it is unlocked:
1360% ectest/ec_reader_test_ecnet.e:489
1361% [door,time]%
1362% HoldsAt(DoorIsOpen(door),time) -> HoldsAt(DoorUnlocked(door),time).
1363 /*
1364holds_at(doorIsOpen(Door), Time) ->
1365 holds_at(doorUnlocked(Door), Time).
1366*/
1367.
1368
1369%
1370%
1371%; opening and closing doors
1372%
1373%; agent opens door.
1374% ectest/ec_reader_test_ecnet.e:495
1375% event DoorOpen(agent,door)
1376 /*
1377.
1378*/
1379.
1380
1381%; agent closes door.
1382% event DoorClose(agent,door)
1383 /*
1384.
1385*/
1386.
1387
1388%; door is open.
1389% fluent DoorIsOpen(door)
1390 /*
1391.
1392*/
1393.
1394
1395%
1396%; A precondition axiom states that
1397%; for an agent to open a door,
1398%; the agent must be awake,
1399%; the door must not already be open,
1400%; the door must be unlocked, and
1401%; the agent must be near the door:
1402% ectest/ec_reader_test_ecnet.e:507
1403% [agent,door,time]%
1404% Happens(DoorOpen(agent,door),time) ->
1405% HoldsAt(Awake(agent),time) &
1406% !HoldsAt(DoorIsOpen(door),time) &
1407% HoldsAt(DoorUnlocked(door),time) &
1408% HoldsAt(NearPortal(agent,door),time).
1409 /*
1410happens(doorOpen(Agent, Door), Time) ->
1411 holds_at(awake(Agent), Time),
1412 not(holds_at(doorIsOpen(Door), Time)),
1413 holds_at(doorUnlocked(Door), Time),
1414 holds_at(nearPortal(Agent, Door), Time).
1415*/
1416.
1417
1418%
1419% ectest/ec_reader_test_ecnet.e:513
1420%
1421%; An effect axiom states that
1422%; if an agent opens a door,
1423%; the door will be open:
1424% ectest/ec_reader_test_ecnet.e:517
1425% [agent,door,time]%
1426% Initiates(DoorOpen(agent,door),DoorIsOpen(door),time).
1427 /*
1428.
1429*/
1430.
1431
1432%
1433%
1434%; A precondition axiom states that
1435%; for an agent to close a door,
1436%; the agent must be awake,
1437%; the door must be open,
1438%; the door must be unlocked, and
1439%; the agent must be near the door:
1440% ectest/ec_reader_test_ecnet.e:526
1441% [agent,door,time]%
1442% Happens(DoorClose(agent,door),time) ->
1443% HoldsAt(Awake(agent),time) &
1444% HoldsAt(DoorIsOpen(door),time) &
1445% HoldsAt(DoorUnlocked(door),time) &
1446% HoldsAt(NearPortal(agent,door),time).
1447 /*
1448happens(doorClose(Agent, Door), Time) ->
1449 holds_at(awake(Agent), Time),
1450 holds_at(doorIsOpen(Door), Time),
1451 holds_at(doorUnlocked(Door), Time),
1452 holds_at(nearPortal(Agent, Door), Time).
1453*/
1454.
1455
1456%
1457% ectest/ec_reader_test_ecnet.e:532
1458%
1459%; An effect axiom states that
1460%; if an agent closes a door,
1461%; the door will no longer be open:
1462% ectest/ec_reader_test_ecnet.e:536
1463% [agent,door,time]%
1464% Terminates(DoorClose(agent,door),DoorIsOpen(door),time).
1465 /*
1466.
1467*/
1468.
1469
1470%
1471%
1472%; passing through doors
1473%
1474%; agent walks through side one of door.
1475% ectest/ec_reader_test_ecnet.e:542
1476% event WalkThroughDoor12(agent,door)
1477 /*
1478.
1479*/
1480.
1481
1482%; agent walks through side two of door.
1483% event WalkThroughDoor21(agent,door)
1484 /*
1485.
1486*/
1487.
1488
1489%
1490%; Precondition axioms state that
1491%; for an agent to walk through a side of a door,
1492%; the agent must be awake and standing,
1493%; the door must be open, and
1494%; the agent must be at the side of the door that
1495%; the agent walks through:
1496% ectest/ec_reader_test_ecnet.e:552
1497% [agent,door,time]%
1498% Happens(WalkThroughDoor12(agent,door),time) ->
1499% HoldsAt(Awake(agent),time) &
1500% HoldsAt(Standing(agent),time) &
1501% HoldsAt(DoorIsOpen(door),time) &
1502% HoldsAt(At(agent,Side1(door)),time).
1503 /*
1504happens(walkThroughDoor12(Agent, Door), Time) ->
1505 holds_at(awake(Agent), Time),
1506 holds_at(standing(Agent), Time),
1507 holds_at(doorIsOpen(Door), Time),
1508 holds_at(at(Agent, side1(Door)), Time).
1509*/
1510.
1511
1512%
1513% ectest/ec_reader_test_ecnet.e:558
1514%
1515% ectest/ec_reader_test_ecnet.e:559
1516% [agent,door,time]%
1517% Happens(WalkThroughDoor21(agent,door),time) ->
1518% HoldsAt(Awake(agent),time) &
1519% HoldsAt(Standing(agent),time) &
1520% HoldsAt(DoorIsOpen(door),time) &
1521% HoldsAt(At(agent,Side2(door)),time).
1522 /*
1523happens(walkThroughDoor21(Agent, Door), Time) ->
1524 holds_at(awake(Agent), Time),
1525 holds_at(standing(Agent), Time),
1526 holds_at(doorIsOpen(Door), Time),
1527 holds_at(at(Agent, side2(Door)), Time).
1528*/
1529.
1530
1531%
1532% ectest/ec_reader_test_ecnet.e:565
1533%
1534%; Effect axioms state that
1535%; if an agent walks through one side of a door,
1536%; the agent will be at the other side of the door:
1537% ectest/ec_reader_test_ecnet.e:569
1538% [agent,door,location,time]%
1539% Side2(door)=location ->
1540% Initiates(WalkThroughDoor12(agent,door),At(agent,location),time).
1541 /*
1542side2(Door)=Location ->
1543 initiates(walkThroughDoor12(Agent, Door),
1544 at(Agent, Location),
1545 Time).
1546*/
1547.
1548
1549%
1550%
1551% ectest/ec_reader_test_ecnet.e:573
1552% [agent,door,location,time]%
1553% Side1(door)=location ->
1554% Initiates(WalkThroughDoor21(agent,door),At(agent,location),time).
1555 /*
1556side1(Door)=Location ->
1557 initiates(walkThroughDoor21(Agent, Door),
1558 at(Agent, Location),
1559 Time).
1560*/
1561.
1562
1563%
1564%
1565% ectest/ec_reader_test_ecnet.e:577
1566% [agent,door,location,time]%
1567% Side1(door)=location ->
1568% Terminates(WalkThroughDoor12(agent,door),At(agent,location),time).
1569 /*
1570side1(Door)=Location ->
1571 terminates(walkThroughDoor12(Agent, Door),
1572 at(Agent, Location),
1573 Time).
1574*/
1575.
1576
1577%
1578%
1579% ectest/ec_reader_test_ecnet.e:581
1580% [agent,door,location,time]%
1581% Side2(door)=location ->
1582% Terminates(WalkThroughDoor21(agent,door),At(agent,location),time).
1583 /*
1584side2(Door)=Location ->
1585 terminates(walkThroughDoor21(Agent, Door),
1586 at(Agent, Location),
1587 Time).
1588*/
1589.
1590
1591%
1592%
1593%; walking from one end of a street to another
1594%
1595%; agent walks from the first end of street to the second end.
1596% ectest/ec_reader_test_ecnet.e:588
1597% event WalkStreet12(agent,street)
1598 /*
1599.
1600*/
1601.
1602
1603%; agent walks from the second end of street to the first end.
1604% event WalkStreet21(agent,street)
1605 /*
1606.
1607*/
1608.
1609
1610%
1611%; Precondition axioms state that
1612%; for an agent to walk from one end of a street to another,
1613%; the agent must be awake,
1614%; the agent must be standing, and
1615%; the agent must be at the first end of the street:
1616% ectest/ec_reader_test_ecnet.e:597
1617% [agent,street,time]%
1618% Happens(WalkStreet12(agent,street),time) ->
1619% HoldsAt(Awake(agent),time) &
1620% HoldsAt(Standing(agent),time) &
1621% HoldsAt(At(agent,Side1(street)),time).
1622 /*
1623happens(walkStreet12(Agent, Street), Time) ->
1624 holds_at(awake(Agent), Time),
1625 holds_at(standing(Agent), Time),
1626 holds_at(at(Agent, side1(Street)), Time).
1627*/
1628.
1629
1630%
1631%
1632% ectest/ec_reader_test_ecnet.e:603
1633% [agent,street,time]%
1634% Happens(WalkStreet21(agent,street),time) ->
1635% HoldsAt(Awake(agent),time) &
1636% HoldsAt(Standing(agent),time) &
1637% HoldsAt(At(agent,Side2(street)),time).
1638 /*
1639happens(walkStreet21(Agent, Street), Time) ->
1640 holds_at(awake(Agent), Time),
1641 holds_at(standing(Agent), Time),
1642 holds_at(at(Agent, side2(Street)), Time).
1643*/
1644.
1645
1646%
1647%
1648%; Effect axioms state that
1649%; if an agent walks from one end of a street to another,
1650%; the agent will be at the other end of the street:
1651% ectest/ec_reader_test_ecnet.e:612
1652% [agent,street,location,time]%
1653% Side2(street)=location ->
1654% Initiates(WalkStreet12(agent,street),At(agent,location),time).
1655 /*
1656side2(Street)=Location ->
1657 initiates(walkStreet12(Agent, Street),
1658 at(Agent, Location),
1659 Time).
1660*/
1661.
1662
1663%
1664%
1665% ectest/ec_reader_test_ecnet.e:616
1666% [agent,street,location,time]%
1667% Side1(street)=location ->
1668% Initiates(WalkStreet21(agent,street),At(agent,location),time).
1669 /*
1670side1(Street)=Location ->
1671 initiates(walkStreet21(Agent, Street),
1672 at(Agent, Location),
1673 Time).
1674*/
1675.
1676
1677%
1678%
1679% ectest/ec_reader_test_ecnet.e:620
1680% [agent,street,location,time]%
1681% Side1(street)=location ->
1682% Terminates(WalkStreet12(agent,street),At(agent,location),time).
1683 /*
1684side1(Street)=Location ->
1685 terminates(walkStreet12(Agent, Street),
1686 at(Agent, Location),
1687 Time).
1688*/
1689.
1690
1691%
1692%
1693% ectest/ec_reader_test_ecnet.e:624
1694% [agent,street,location,time]%
1695% Side2(street)=location ->
1696% Terminates(WalkStreet21(agent,street),At(agent,location),time).
1697 /*
1698side2(Street)=Location ->
1699 terminates(walkStreet21(Agent, Street),
1700 at(Agent, Location),
1701 Time).
1702*/
1703.
1704
1705%
1706%
1707%; floors
1708%
1709%; The floor of room is integer.
1710% ectest/ec_reader_test_ecnet.e:631
1711% function Floor(room): integer
1712 /*
1713.
1714*/
1715.
1716
1717%
1718%; walking up and down staircases
1719%
1720%; agent walks down staircase.
1721% event WalkDownStaircase(agent,staircase)
1722 /*
1723.
1724*/
1725.
1726
1727% ectest/ec_reader_test_ecnet.e:637
1728%; agent walks up staircase.
1729% event WalkUpStaircase(agent,staircase)
1730 /*
1731.
1732*/
1733.
1734
1735%
1736%; Precondition axioms state that
1737%; for an agent to walk down (up) a staircase,
1738%; the agent must be awake, standing, and
1739%; at the top (bottom) of the staircase:
1740% ectest/ec_reader_test_ecnet.e:644
1741% [agent,staircase,time]%
1742% Happens(WalkDownStaircase(agent,staircase),time) ->
1743% HoldsAt(Awake(agent),time) &
1744% HoldsAt(Standing(agent),time) &
1745% HoldsAt(At(agent,Side2(staircase)),time).
1746 /*
1747happens(walkDownStaircase(Agent, Staircase), Time) ->
1748 holds_at(awake(Agent), Time),
1749 holds_at(standing(Agent), Time),
1750 holds_at(at(Agent, side2(Staircase)), Time).
1751*/
1752.
1753
1754%
1755%
1756% ectest/ec_reader_test_ecnet.e:650
1757% [agent,staircase,time]%
1758% Happens(WalkUpStaircase(agent,staircase),time) ->
1759% HoldsAt(Awake(agent),time) &
1760% HoldsAt(Standing(agent),time) &
1761% HoldsAt(At(agent,Side1(staircase)),time).
1762 /*
1763happens(walkUpStaircase(Agent, Staircase), Time) ->
1764 holds_at(awake(Agent), Time),
1765 holds_at(standing(Agent), Time),
1766 holds_at(at(Agent, side1(Staircase)), Time).
1767*/
1768.
1769
1770%
1771%
1772%; Effect axioms state that
1773%; if an agent walks down (up) a staircase,
1774%; the agent will be at the bottom (top) of the staircase:
1775% ectest/ec_reader_test_ecnet.e:659
1776% [agent,staircase,room,time]%
1777% Side1(staircase)=room ->
1778% Initiates(WalkDownStaircase(agent,staircase),At(agent,room),time).
1779 /*
1780side1(Staircase)=Room ->
1781 initiates(walkDownStaircase(Agent, Staircase),
1782 at(Agent, Room),
1783 Time).
1784*/
1785.
1786
1787%
1788%
1789% ectest/ec_reader_test_ecnet.e:663
1790% [agent,staircase,room,time]%
1791% Side2(staircase)=room ->
1792% Terminates(WalkDownStaircase(agent,staircase),At(agent,room),time).
1793 /*
1794side2(Staircase)=Room ->
1795 terminates(walkDownStaircase(Agent, Staircase),
1796 at(Agent, Room),
1797 Time).
1798*/
1799.
1800
1801%
1802%
1803% ectest/ec_reader_test_ecnet.e:667
1804% [agent,staircase,room,time]%
1805% Side2(staircase)=room ->
1806% Initiates(WalkUpStaircase(agent,staircase),At(agent,room),time).
1807 /*
1808side2(Staircase)=Room ->
1809 initiates(walkUpStaircase(Agent, Staircase),
1810 at(Agent, Room),
1811 Time).
1812*/
1813.
1814
1815%
1816%
1817% ectest/ec_reader_test_ecnet.e:671
1818% [agent,staircase,room,time]%
1819% Side1(staircase)=room ->
1820% Terminates(WalkUpStaircase(agent,staircase),At(agent,room),time).
1821 /*
1822side1(Staircase)=Room ->
1823 terminates(walkUpStaircase(Agent, Staircase),
1824 at(Agent, Room),
1825 Time).
1826*/
1827.
1828
1829%
1830%
1831%; A state constraint says that if an agent is outside,
1832%; the agent is dressed.
1833% ectest/ec_reader_test_ecnet.e:677
1834% [agent,outside,time]%
1835% HoldsAt(At(agent,outside),time) ->
1836% HoldsAt(Dressed(agent),time).
1837 /*
1838holds_at(at(Agent, Outside), Time) ->
1839 holds_at(dressed(Agent), Time).
1840*/
1841.
1842
1843%
1844%
1845%; room looks out onto outside.
1846% function LookOutOnto(room): outside
1847 /*
1848.
1849*/
1850.
1851
1852% ectest/ec_reader_test_ecnet.e:683
1853%
1854%; location1 is adjacent to location2.
1855% predicate Adjacent(location,location)
1856 /*
1857.
1858*/
1859.
1860
1861%
1862%; A state constraint says that
1863%; two locations are adjacent if and only if
1864%; they have a portal in common:
1865% ectest/ec_reader_test_ecnet.e:690
1866% [location1,location2] % Adjacent(location1,location2) <->
1867% ectest/ec_reader_test_ecnet.e:691
1868% {portal}%
1869% (Side1(portal)=location1 &
1870% Side2(portal)=location2) |
1871% (Side2(portal)=location1 &
1872% Side1(portal)=location2).
1873 /*
1874exists([Portal], (adjacent(Location1, Location2)<->side1(Portal)=Location1, side2(Portal)=Location2;side2(Portal)=Location1, side1(Portal)=Location2)).
1875*/
1876.
1877.
1878
1879%
1880%
1881%; The ground of outside is ground.
1882% ectest/ec_reader_test_ecnet.e:698
1883% function GroundOf(outside): ground
1884 /*
1885.
1886*/
1887.
1888
1889%; The sky of outside is sky.
1890% function SkyOf(outside): sky
1891 /*
1892.
1893*/
1894.
1895
1896%
1897%; State constraints fix the location of ground and sky:
1898% ectest/ec_reader_test_ecnet.e:703
1899% [outside,ground,time]%
1900% GroundOf(outside) = ground ->
1901% HoldsAt(At(ground,outside),time).
1902 /*
1903groundOf(Outside)=Ground ->
1904 holds_at(at(Ground, Outside), Time).
1905*/
1906.
1907
1908%
1909%
1910% ectest/ec_reader_test_ecnet.e:707
1911% [outside,sky,time]%
1912% SkyOf(outside) = sky ->
1913% HoldsAt(At(sky,outside),time).
1914 /*
1915skyOf(Outside)=Sky ->
1916 holds_at(at(Sky, Outside), Time).
1917*/
1918.
1919
1920%
1921%
1922%; End of file.
1923%
1924% ectest/ec_reader_test_ecnet.e:713
1925%
1926%
1927%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1928%; FILE: ecnet/OTSpace.e
1929%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1930%
1931%;
1932%; Copyright (c) 2005 IBM Corporation and others.
1933%; All rights reserved. This program and the accompanying materials
1934%; are made available under the terms of the Common Public License v1.0
1935%; which accompanies this distribution, and is available at
1936%; http://www.eclipse.org/legal/cpl-v10.html
1937%;
1938%; Contributors:
1939%; IBM - Initial implementation
1940%;
1941%; OTSpace: object-scale topological space
1942%;
1943%; The OTSpace representation deals with topological space at
1944%; the scale of objects such as agents (humans and animals)
1945%; and physical objects.
1946%;
1947% ectest/ec_reader_test_ecnet.e:735
1948%
1949%; PartOf
1950%
1951%; physobj is a part of object.
1952% predicate PartOf(physobj,object)
1953 /*
1954.
1955*/
1956.
1957
1958%
1959%; A state constraint says that if a physical object
1960%; is part of an object, the location of the
1961%; physical object is the same as the location of the object:
1962% ectest/ec_reader_test_ecnet.e:744
1963% [physobj,object,location,time]%
1964% PartOf(physobj,object) &
1965% HoldsAt(At(object,location),time) ->
1966% HoldsAt(At(physobj,location),time).
1967 /*
1968partOf(Physobj, Object), holds_at(at(Object, Location), Time) ->
1969 holds_at(at(Physobj, Location), Time).
1970*/
1971.
1972
1973%
1974%
1975%; rolling a snowball bigger
1976% ectest/ec_reader_test_ecnet.e:750
1977%
1978%; agent rolls stuff1 along stuff2.
1979% event RollAlong(agent,stuff,stuff)
1980 /*
1981.
1982*/
1983.
1984
1985%; The diameter of ball is diameter.
1986% fluent Diameter(ball,diameter)
1987 /*
1988.
1989*/
1990.
1991
1992%
1993%; A state constraint says that a ball has a unique diameter:
1994% ectest/ec_reader_test_ecnet.e:757
1995% [ball,diameter1,diameter2,time]%
1996% HoldsAt(Diameter(ball,diameter1),time) &
1997% HoldsAt(Diameter(ball,diameter2),time) ->
1998% diameter1=diameter2.
1999 /*
2000holds_at(diameter(Ball, Diameter1), Time), holds_at(diameter(Ball, Diameter2), Time) ->
2001 Diameter1=Diameter2.
2002*/
2003.
2004
2005%
2006%
2007%; Effect axiom state that if an agent rolls some snow along
2008%; some other snow, the diameter of the first snow will increase:
2009% ectest/ec_reader_test_ecnet.e:764
2010% [agent,snow1,snow2,diameter1,diameter2,time]%
2011% HoldsAt(Diameter(snow1,diameter1),time) &
2012% diameter2 = diameter1+1 ->
2013% Initiates(RollAlong(agent,snow1,snow2),
2014% Diameter(snow1,diameter2),
2015% time).
2016 /*
2017holds_at(diameter(Snow1, Diameter1), Time), Diameter2=Diameter1+1 ->
2018 initiates(rollAlong(Agent, Snow1, Snow2),
2019 diameter(Snow1, Diameter2),
2020 Time).
2021*/
2022.
2023
2024%
2025% ectest/ec_reader_test_ecnet.e:770
2026%
2027% ectest/ec_reader_test_ecnet.e:771
2028% [agent,snow1,snow2,diameter1,time]%
2029% HoldsAt(Diameter(snow1,diameter1),time) ->
2030% Terminates(RollAlong(agent,snow1,snow2),
2031% Diameter(snow1,diameter1),
2032% time).
2033 /*
2034holds_at(diameter(Snow1, Diameter1), Time) ->
2035 terminates(rollAlong(Agent, Snow1, Snow2),
2036 diameter(Snow1, Diameter1),
2037 Time).
2038*/
2039.
2040
2041%
2042%
2043%; A precondition axiom states that
2044%; for an agent to roll some snow along some other snow,
2045%; there must be a location such that
2046%; the agent is at the location,
2047%; the first snow is at the location, and
2048%; the second snow is at the location:
2049%;[agent,snow1,snow2,time]
2050%;Happens(RollAlong(agent,snow1,snow2),time) ->
2051%;{location}
2052%;HoldsAt(At(agent,location),time) &
2053%;HoldsAt(At(snow1,location),time) &
2054%;HoldsAt(At(snow2,location),time).
2055% ectest/ec_reader_test_ecnet.e:789
2056%
2057%; motion
2058%
2059%; object moves (in place).
2060% event Move(object)
2061 /*
2062.
2063*/
2064.
2065
2066%
2067%; Holding
2068% ectest/ec_reader_test_ecnet.e:796
2069%
2070%; agent is holding physobj.
2071% fluent Holding(agent,physobj)
2072 /*
2073.
2074*/
2075.
2076
2077%; agent holds or picks up physobj.
2078% event Hold(agent,physobj)
2079 /*
2080.
2081*/
2082.
2083
2084%; agent picks up some stuff1 from stuff2.
2085% ectest/ec_reader_test_ecnet.e:802
2086% event HoldSome(agent,stuff,stuff)
2087 /*
2088.
2089*/
2090.
2091
2092%; agent releases or lets go of physobj.
2093% event LetGoOf(agent,physobj)
2094 /*
2095.
2096*/
2097.
2098
2099%
2100%; An effect axiom states that if an agent holds
2101%; a physical object, the agent will be holding the
2102%; physical object:
2103% ectest/ec_reader_test_ecnet.e:809
2104% [agent,physobj,time]%
2105% Initiates(Hold(agent,physobj),Holding(agent,physobj),time).
2106 /*
2107.
2108*/
2109.
2110
2111%
2112%
2113%; A precondition axiom states that
2114%; for an agent to hold a physical object,
2115%; there must be a location such that
2116%; the agent is at the location and
2117%; the physical object is at the location:
2118%;[agent,physobj,time]
2119%;Happens(Hold(agent,physobj),time) ->
2120%;{location}
2121%; HoldsAt(At(agent,location),time) &
2122%; HoldsAt(At(physobj,location),time).
2123% ectest/ec_reader_test_ecnet.e:822
2124%
2125%; An effect axiom states that if an agent
2126%; lets go of a physical object, the agent is no longer holding
2127%; the physical object:
2128% ectest/ec_reader_test_ecnet.e:826
2129% [agent,physobj,time]%
2130% Terminates(LetGoOf(agent,physobj),Holding(agent,physobj),time).
2131 /*
2132.
2133*/
2134.
2135
2136%
2137%
2138%; A precondition axiom states that
2139%; for an agent to let go of a physical object,
2140%; the agent must be holding the physical object:
2141% ectest/ec_reader_test_ecnet.e:832
2142% [agent,physobj,time]%
2143% Happens(LetGoOf(agent,physobj),time) ->
2144% HoldsAt(Holding(agent,physobj),time).
2145 /*
2146happens(letGoOf(Agent, Physobj), Time) ->
2147 holds_at(holding(Agent, Physobj), Time).
2148*/
2149.
2150
2151%
2152%
2153%; A releases axiom states that if an agent holds
2154%; a physical object,
2155%; the physical object's location will be released
2156%; from inertia:
2157% ectest/ec_reader_test_ecnet.e:840
2158% [agent,physobj,location,time]%
2159% Releases(Hold(agent,physobj),At(physobj,location),time).
2160 /*
2161.
2162*/
2163.
2164
2165%
2166%
2167%; A state constraint says that if an agent is holding
2168%; a physical object and the agent is at a location,
2169%; the physical object is also at the location:
2170% ectest/ec_reader_test_ecnet.e:846
2171% [agent,physobj,location,time]%
2172% HoldsAt(Holding(agent,physobj),time) &
2173% HoldsAt(At(agent,location),time) ->
2174% HoldsAt(At(physobj,location),time).
2175 /*
2176holds_at(holding(Agent, Physobj), Time), holds_at(at(Agent, Location), Time) ->
2177 holds_at(at(Physobj, Location), Time).
2178*/
2179.
2180
2181%
2182%
2183%; A releases axiom states that if an agent holds
2184%; a physical object,
2185%; the locations of the parts of the physical object
2186%; will be released from inertia:
2187% ectest/ec_reader_test_ecnet.e:855
2188% [agent,physobj1,physobj2,location,time]%
2189% PartOf(physobj1,physobj2) ->
2190% Releases(Hold(agent,physobj2),At(physobj1,location),time).
2191 /*
2192partOf(Physobj1, Physobj2) ->
2193 releases(hold(Agent, Physobj2),
2194 at(Physobj1, Location),
2195 Time).
2196*/
2197.
2198
2199%
2200%
2201%; Further, if an agent holds a physical object,
2202%; the locations of the physical objects of which
2203%; the physical object is a part
2204%; will be released from inertia:
2205% ectest/ec_reader_test_ecnet.e:863
2206% [agent,physobj1,physobj2,location,time]%
2207% PartOf(physobj1,physobj2) ->
2208% Releases(Hold(agent,physobj1),At(physobj2,location),time).
2209 /*
2210partOf(Physobj1, Physobj2) ->
2211 releases(hold(Agent, Physobj1),
2212 at(Physobj2, Location),
2213 Time).
2214*/
2215.
2216
2217%
2218%
2219%;[agent,physobj,location1,location2,time]
2220%;(!{object} PartOf(physobj,object)) &
2221%;HoldsAt(At(agent,location1),time) &
2222%;location1 != location2 ->
2223%;Terminates(LetGoOf(agent,physobj),At(physobj,location2),time).
2224% ectest/ec_reader_test_ecnet.e:872
2225%
2226% ectest/ec_reader_test_ecnet.e:873
2227% [agent,physobj,location,time]%
2228% (!{object} PartOf(physobj,object)) &
2229% HoldsAt(At(agent,location),time) ->
2230% Initiates(LetGoOf(agent,physobj),At(physobj,location),time).
2231 /*
2232not(exists([Object], partOf(Physobj, Object))), holds_at(at(Agent, Location), Time) ->
2233 initiates(letGoOf(Agent, Physobj),
2234 at(Physobj, Location),
2235 Time).
2236*/
2237.
2238
2239%
2240%
2241%;[agent,physobj1,physobj2,location1,location2,time]
2242%;PartOf(physobj1,physobj2) &
2243%;(!{object} PartOf(physobj2,object)) &
2244%;HoldsAt(At(agent,location1),time) &
2245%;location1 != location2 ->
2246%;Terminates(LetGoOf(agent,physobj1),At(physobj2,location2),time).
2247% ectest/ec_reader_test_ecnet.e:884
2248%
2249% ectest/ec_reader_test_ecnet.e:885
2250% [agent,physobj1,physobj2,location,time]%
2251% PartOf(physobj1,physobj2) &
2252% (!{object} PartOf(physobj2,object)) &
2253% HoldsAt(At(agent,location),time) ->
2254% Initiates(LetGoOf(agent,physobj1),At(physobj2,location),time).
2255 /*
2256partOf(Physobj1, Physobj2), not(exists([Object], partOf(Physobj2, Object))), holds_at(at(Agent, Location), Time) ->
2257 initiates(letGoOf(Agent, Physobj1),
2258 at(Physobj2, Location),
2259 Time).
2260*/
2261.
2262
2263%
2264%
2265%; An effect axiom states that if an agent is at a location
2266%; and lets go of a physical object, the physical object
2267%; will be at the location:
2268% ectest/ec_reader_test_ecnet.e:894
2269% [agent,physobj,location,time]%
2270% HoldsAt(At(agent,location),time) ->
2271% Initiates(LetGoOf(agent,physobj),At(physobj,location),time).
2272 /*
2273holds_at(at(Agent, Location), Time) ->
2274 initiates(letGoOf(Agent, Physobj),
2275 at(Physobj, Location),
2276 Time).
2277*/
2278.
2279
2280%
2281%
2282%; An effect axiom states that if an agent picks up
2283%; some stuff out of some other stuff, the agent will
2284%; be holding the first stuff:
2285% ectest/ec_reader_test_ecnet.e:901
2286% [agent,stuff1,stuff2,time]%
2287% Initiates(HoldSome(agent,stuff1,stuff2),
2288% Holding(agent,stuff1),
2289% time).
2290 /*
2291.
2292*/
2293.
2294
2295%
2296%
2297%; A precondition axiom states that
2298%; for an agent to pick up some stuff out of some other stuff,
2299%; the first stuff must be a part of the second stuff and
2300%; there must be a location such that the agent is at the location,
2301%; the first stuff is at the location, and the second stuff is
2302%; at the location:
2303% ectest/ec_reader_test_ecnet.e:912
2304% [agent,stuff1,stuff2,time]%
2305% Happens(HoldSome(agent,stuff1,stuff2),time) ->
2306% PartOf(stuff1,stuff2) &
2307% ectest/ec_reader_test_ecnet.e:915
2308% {location}%
2309% HoldsAt(At(agent,location),time) &
2310% HoldsAt(At(stuff1,location),time) &
2311% HoldsAt(At(stuff2,location),time).
2312 /*
2313exists([Location], (happens(holdSome(Agent, Stuff1, Stuff2), Time)->partOf(Stuff1, Stuff2), holds_at(at(Agent, Location), Time), holds_at(at(Stuff1, Location), Time), holds_at(at(Stuff2, Location), Time))).
2314*/
2315.
2316
2317%
2318%
2319%; A releases axiom states that if an agent picks up some
2320%; stuff out of some other stuff,
2321%; the first stuff's location will be released
2322%; from inertia:
2323% ectest/ec_reader_test_ecnet.e:924
2324% [agent,stuff1,stuff2,location,time]%
2325% Releases(HoldSome(agent,stuff1,stuff2),At(stuff1,location),time).
2326 /*
2327.
2328*/
2329.
2330
2331%
2332%
2333%; Inside
2334%
2335%; physobj1 is inside physobj2.
2336% ectest/ec_reader_test_ecnet.e:930
2337% fluent Inside(physobj,physobj)
2338 /*
2339.
2340*/
2341.
2342
2343%; agent puts physobj1 inside physobj2.
2344% event PutInside(agent,physobj,physobj)
2345 /*
2346.
2347*/
2348.
2349
2350%; agent takes physobj1 out of physobj2.
2351% event TakeOutOf(agent,physobj,physobj)
2352 /*
2353.
2354*/
2355.
2356
2357%
2358%; A state constraint says that a physical object cannot
2359%; be inside itself:
2360% ectest/ec_reader_test_ecnet.e:938
2361% [physobj1,physobj2,time]%
2362% HoldsAt(Inside(physobj1,physobj2),time) ->
2363% physobj1!=physobj2.
2364 /*
2365holds_at(inside(Physobj1, Physobj2), Time) ->
2366 Physobj1\=Physobj2.
2367*/
2368.
2369
2370%
2371%
2372%; A state constraint says that if a physical object is
2373%; inside another physical object, the second physical object
2374%; is not inside the first physical object:
2375% ectest/ec_reader_test_ecnet.e:945
2376% [physobj1,physobj2,time]%
2377% HoldsAt(Inside(physobj1,physobj2),time) ->
2378% !HoldsAt(Inside(physobj2,physobj1),time).
2379 /*
2380holds_at(inside(Physobj1, Physobj2), Time) ->
2381 not(holds_at(inside(Physobj2, Physobj1), Time)).
2382*/
2383.
2384
2385%
2386%
2387%; An effect axiom states that if an agent puts a physical
2388%; object inside another physical object, the first
2389%; physical object will be inside the second physical object:
2390% ectest/ec_reader_test_ecnet.e:952
2391% [agent,physobj1,physobj2,time]%
2392% Initiates(PutInside(agent,physobj1,physobj2),
2393% Inside(physobj1,physobj2),time).
2394 /*
2395.
2396*/
2397.
2398
2399%
2400%
2401%; An effect axiom states that if an agent puts a physical
2402%; object inside another physical object, the agent will
2403%; no longer be holding the first physical object:
2404% ectest/ec_reader_test_ecnet.e:959
2405% [agent,physobj1,physobj2,time]%
2406% Terminates(PutInside(agent,physobj1,physobj2),
2407% Holding(agent,physobj1),time).
2408 /*
2409.
2410*/
2411.
2412
2413%
2414%
2415%; A precondition axiom states that
2416%; for an agent to put a physical object inside another
2417%; physical object,
2418%; the agent must be holding the first physical object
2419%; and there must be a location such that
2420%; the agent is at the location and
2421%; the second physical object is at the location:
2422%;[agent,physobj1,physobj2,time]
2423%;Happens(PutInside(agent,physobj1,physobj2),time) ->
2424%;HoldsAt(Holding(agent,physobj1),time) &
2425%;{location}
2426%; HoldsAt(At(agent,location),time) &
2427%; HoldsAt(At(physobj2,location),time).
2428% ectest/ec_reader_test_ecnet.e:976
2429%
2430%; An effect axiom states that
2431%; if an agent takes a physical object out of another
2432%; physical object, the first physical object
2433%; will no longer be inside the second physical object:
2434% ectest/ec_reader_test_ecnet.e:981
2435% [agent,physobj1,physobj2,time]%
2436% Terminates(TakeOutOf(agent,physobj1,physobj2),
2437% Inside(physobj1,physobj2),time).
2438 /*
2439.
2440*/
2441.
2442
2443%
2444%
2445%; A precondition axiom states that
2446%; for an agent to take a physical object out of another
2447%; physical object,
2448%; the first physical object must be inside the second physical object
2449%; and there must be a location such that
2450%; the agent is at the location,
2451%; the first physical object is at the location, and
2452%; the second physical object is at the location:
2453% ectest/ec_reader_test_ecnet.e:993
2454% [agent,physobj1,physobj2,time]%
2455% Happens(TakeOutOf(agent,physobj1,physobj2),time) ->
2456% HoldsAt(Inside(physobj1,physobj2),time) &
2457% ectest/ec_reader_test_ecnet.e:996
2458% {location}%
2459% HoldsAt(At(agent,location),time) &
2460% HoldsAt(At(physobj1,location),time) &
2461% HoldsAt(At(physobj2,location),time).
2462 /*
2463exists([Location], (happens(takeOutOf(Agent, Physobj1, Physobj2), Time)->holds_at(inside(Physobj1, Physobj2), Time), holds_at(at(Agent, Location), Time), holds_at(at(Physobj1, Location), Time), holds_at(at(Physobj2, Location), Time))).
2464*/
2465.
2466
2467%
2468%
2469%; A releases axiom states that if an agent puts a physical
2470%; object inside another physical object,
2471%; the first physical object's location will be released
2472%; from inertia:
2473% ectest/ec_reader_test_ecnet.e:1005
2474% [agent,physobj1,physobj2,location,time]%
2475% Releases(PutInside(agent,physobj1,physobj2),
2476% At(physobj1,location),time).
2477 /*
2478.
2479*/
2480.
2481
2482%
2483%
2484%; A state constraint says that if a physical object is inside
2485%; another physical object and the second physical object is
2486%; at a location, the first physical object is also at the location:
2487% ectest/ec_reader_test_ecnet.e:1012
2488% [physobj1,physobj2,location,time]%
2489% HoldsAt(Inside(physobj1,physobj2),time) &
2490% HoldsAt(At(physobj2,location),time) ->
2491% HoldsAt(At(physobj1,location),time).
2492 /*
2493holds_at(inside(Physobj1, Physobj2), Time), holds_at(at(Physobj2, Location), Time) ->
2494 holds_at(at(Physobj1, Location), Time).
2495*/
2496.
2497
2498%
2499%
2500%; An effect axiom states that if an agent takes a physical
2501%; object out of another physical object,
2502%; the agent will be holding the first physical object:
2503% ectest/ec_reader_test_ecnet.e:1020
2504% [agent,physobj1,physobj2,time]%
2505% Initiates(TakeOutOf(agent,physobj1,physobj2),
2506% Holding(agent,physobj1),
2507% time).
2508 /*
2509.
2510*/
2511.
2512
2513%
2514%
2515%; On
2516% ectest/ec_reader_test_ecnet.e:1026
2517%
2518%; physobj1 is on physobj2.
2519% fluent On(physobj,physobj)
2520 /*
2521.
2522*/
2523.
2524
2525%
2526%; agent places physobj1 on physobj2.
2527% event PlaceOn(agent,physobj,physobj)
2528 /*
2529.
2530*/
2531.
2532
2533% ectest/ec_reader_test_ecnet.e:1032
2534%; agent takes physobj1 off of physobj2.
2535% event TakeOffOf(agent,physobj,physobj)
2536 /*
2537.
2538*/
2539.
2540
2541%
2542%; A state constraint says that a physical object cannot
2543%; be on itself:
2544% ectest/ec_reader_test_ecnet.e:1037
2545% [physobj1,physobj2,time]%
2546% HoldsAt(On(physobj1,physobj2),time) ->
2547% physobj1!=physobj2.
2548 /*
2549holds_at(on(Physobj1, Physobj2), Time) ->
2550 Physobj1\=Physobj2.
2551*/
2552.
2553
2554%
2555%
2556%; A state constraint says that if a physical object is
2557%; on another physical object, the second physical object
2558%; is not on the first physical object:
2559% ectest/ec_reader_test_ecnet.e:1044
2560% [physobj1,physobj2,time]%
2561% HoldsAt(On(physobj1,physobj2),time) ->
2562% !HoldsAt(On(physobj2,physobj1),time).
2563 /*
2564holds_at(on(Physobj1, Physobj2), Time) ->
2565 not(holds_at(on(Physobj2, Physobj1), Time)).
2566*/
2567.
2568
2569%
2570%
2571%; An effect axiom states that if an agent places a physical
2572%; object on another physical object, the first
2573%; physical object will be on the second physical object:
2574% ectest/ec_reader_test_ecnet.e:1051
2575% [agent,physobj1,physobj2,time]%
2576% Initiates(PlaceOn(agent,physobj1,physobj2),
2577% On(physobj1,physobj2),time).
2578 /*
2579.
2580*/
2581.
2582
2583%
2584%
2585%; An effect axiom states that if an agent places a physical
2586%; object on another physical object, the agent will
2587%; no longer be holding the first physical object:
2588% ectest/ec_reader_test_ecnet.e:1058
2589% [agent,physobj1,physobj2,time]%
2590% Terminates(PlaceOn(agent,physobj1,physobj2),
2591% Holding(agent,physobj1),time).
2592 /*
2593.
2594*/
2595.
2596
2597%
2598%
2599%; A precondition axiom states that
2600%; for an agent to place a physical object on another
2601%; physical object,
2602%; the agent must be holding the first physical object
2603%; and there must be a location such that
2604%; the agent is at the location and
2605%; the second physical object is at the location:
2606%;[agent,physobj1,physobj2,time]
2607%;Happens(PlaceOn(agent,physobj1,physobj2),time) ->
2608%;HoldsAt(Holding(agent,physobj1),time) &
2609%;{location}
2610%; HoldsAt(At(agent,location),time) &
2611%; HoldsAt(At(physobj2,location),time).
2612% ectest/ec_reader_test_ecnet.e:1075
2613%
2614%; An effect axiom states that
2615%; if an agent takes a physical object off of another
2616%; physical object, the first physical object
2617%; will no longer be on the second physical object:
2618% ectest/ec_reader_test_ecnet.e:1080
2619% [agent,physobj1,physobj2,time]%
2620% Terminates(TakeOffOf(agent,physobj1,physobj2),
2621% On(physobj1,physobj2),time).
2622 /*
2623.
2624*/
2625.
2626
2627%
2628%
2629%; An effect axiom states that if an agent takes a physical
2630%; object off of another physical object,
2631%; the agent will be holding the first physical object:
2632% ectest/ec_reader_test_ecnet.e:1087
2633% [agent,physobj1,physobj2,time]%
2634% Initiates(TakeOffOf(agent,physobj1,physobj2),
2635% Holding(agent,physobj1),time).
2636 /*
2637.
2638*/
2639.
2640
2641%
2642%
2643%; A precondition axiom states that
2644%; for an agent to take a physical object off of another
2645%; physical object,
2646%; the first physical object must be on the second physical object
2647%; and there must be a location such that
2648%; the agent is at the location and
2649%; the first physical object is at the location:
2650%; the second physical object is at the location:
2651% ectest/ec_reader_test_ecnet.e:1099
2652% [agent,physobj1,physobj2,time]%
2653% Happens(TakeOffOf(agent,physobj1,physobj2),time) ->
2654% HoldsAt(On(physobj1,physobj2),time) &
2655% ectest/ec_reader_test_ecnet.e:1102
2656% {location}%
2657% HoldsAt(At(agent,location),time) &
2658% HoldsAt(At(physobj1,location),time) &
2659% HoldsAt(At(physobj2,location),time).
2660 /*
2661exists([Location], (happens(takeOffOf(Agent, Physobj1, Physobj2), Time)->holds_at(on(Physobj1, Physobj2), Time), holds_at(at(Agent, Location), Time), holds_at(at(Physobj1, Location), Time), holds_at(at(Physobj2, Location), Time))).
2662*/
2663.
2664
2665%
2666%
2667%; A releases axiom states that if an agent places a physical
2668%; object on another physical object,
2669%; the first physical object's location will be released
2670%; from inertia:
2671% ectest/ec_reader_test_ecnet.e:1111
2672% [agent,physobj1,physobj2,location,time]%
2673% Releases(PlaceOn(agent,physobj1,physobj2),
2674% At(physobj1,location),
2675% time).
2676 /*
2677.
2678*/
2679.
2680
2681%
2682%
2683%; A state constraint says that if a physical object is on
2684%; another physical object and the second physical object is
2685%; at a location, the first physical object is also at the location:
2686% ectest/ec_reader_test_ecnet.e:1119
2687% [physobj1,physobj2,location,time]%
2688% HoldsAt(On(physobj1,physobj2),time) &
2689% HoldsAt(At(physobj2,location),time) ->
2690% HoldsAt(At(physobj1,location),time).
2691 /*
2692holds_at(on(Physobj1, Physobj2), Time), holds_at(at(Physobj2, Location), Time) ->
2693 holds_at(at(Physobj1, Location), Time).
2694*/
2695.
2696
2697%
2698%
2699% fluent Near(agent,object)
2700 /*
2701.
2702*/
2703.
2704
2705% ectest/ec_reader_test_ecnet.e:1125
2706% event WalkFromTo(agent,object,object)
2707 /*
2708.
2709*/
2710.
2711
2712% event WalkFrom(agent,object)
2713 /*
2714.
2715*/
2716.
2717
2718% event RunFromTo(agent,object,object)
2719 /*
2720.
2721*/
2722.
2723
2724%
2725% ectest/ec_reader_test_ecnet.e:1129
2726% [agent,object1,object2,time]%
2727% Initiates(WalkFromTo(agent,object1,object2),
2728% Near(agent,object2),
2729% time).
2730 /*
2731.
2732*/
2733.
2734
2735%
2736%
2737% ectest/ec_reader_test_ecnet.e:1134
2738% [agent,object1,object2,time]%
2739% Terminates(WalkFromTo(agent,object1,object2),
2740% Near(agent,object1),
2741% time).
2742 /*
2743.
2744*/
2745.
2746
2747%
2748%
2749% ectest/ec_reader_test_ecnet.e:1139
2750% [agent,object1,object2,time]%
2751% Happens(WalkFromTo(agent,object1,object2),time) ->
2752% ectest/ec_reader_test_ecnet.e:1141
2753% {location}%
2754% HoldsAt(At(agent,location),time) &
2755% HoldsAt(At(object1,location),time) &
2756% HoldsAt(At(object2,location),time).
2757 /*
2758exists([Location], (happens(walkFromTo(Agent, Object1, Object2), Time)->holds_at(at(Agent, Location), Time), holds_at(at(Object1, Location), Time), holds_at(at(Object2, Location), Time))).
2759*/
2760.
2761
2762%
2763%
2764% ectest/ec_reader_test_ecnet.e:1146
2765% [agent,object1,object2,time]%
2766% Initiates(RunFromTo(agent,object1,object2),
2767% Near(agent,object2),
2768% time).
2769 /*
2770.
2771*/
2772.
2773
2774%
2775%
2776% ectest/ec_reader_test_ecnet.e:1151
2777% [agent,object1,object2,time]%
2778% Terminates(RunFromTo(agent,object1,object2),
2779% Near(agent,object1),
2780% time).
2781 /*
2782.
2783*/
2784.
2785
2786%
2787%
2788% ectest/ec_reader_test_ecnet.e:1156
2789% [agent,object1,object2,time]%
2790% Happens(RunFromTo(agent,object1,object2),time) ->
2791% ectest/ec_reader_test_ecnet.e:1158
2792% {location}%
2793% HoldsAt(At(agent,location),time) &
2794% HoldsAt(At(object1,location),time) &
2795% HoldsAt(At(object2,location),time).
2796 /*
2797exists([Location], (happens(runFromTo(Agent, Object1, Object2), Time)->holds_at(at(Agent, Location), Time), holds_at(at(Object1, Location), Time), holds_at(at(Object2, Location), Time))).
2798*/
2799.
2800
2801%
2802%
2803% ectest/ec_reader_test_ecnet.e:1163
2804% [agent,object,time]%
2805% Terminates(WalkFrom(agent,object),
2806% Near(agent,object),
2807% time).
2808 /*
2809.
2810*/
2811.
2812
2813%
2814%
2815% ectest/ec_reader_test_ecnet.e:1168
2816% [agent,object,location,door,time]%
2817% HoldsAt(Near(agent,object),time) &
2818% HoldsAt(At(agent,location),time) &
2819% HoldsAt(At(object,location),time) &
2820% Side1(door)=location &
2821% Happens(WalkThroughDoor12(agent,door),time) ->
2822% Happens(WalkFrom(agent,object),time).
2823 /*
2824holds_at(near(Agent, Object), Time), holds_at(at(Agent, Location), Time), holds_at(at(Object, Location), Time), side1(Door)=Location, happens(walkThroughDoor12(Agent, Door), Time) ->
2825 happens(walkFrom(Agent, Object), Time).
2826*/
2827.
2828
2829% ectest/ec_reader_test_ecnet.e:1174
2830%
2831%
2832% ectest/ec_reader_test_ecnet.e:1176
2833% [agent,object,location,door,time]%
2834% HoldsAt(Near(agent,object),time) &
2835% HoldsAt(At(agent,location),time) &
2836% HoldsAt(At(object,location),time) &
2837% Side2(door)=location &
2838% Happens(WalkThroughDoor21(agent,door),time) ->
2839% Happens(WalkFrom(agent,object),time).
2840 /*
2841holds_at(near(Agent, Object), Time), holds_at(at(Agent, Location), Time), holds_at(at(Object, Location), Time), side2(Door)=Location, happens(walkThroughDoor21(Agent, Door), Time) ->
2842 happens(walkFrom(Agent, Object), Time).
2843*/
2844.
2845
2846% ectest/ec_reader_test_ecnet.e:1182
2847%
2848%
2849% ectest/ec_reader_test_ecnet.e:1184
2850% [agent,object,room,staircase,time]%
2851% HoldsAt(Near(agent,object),time) &
2852% HoldsAt(At(agent,room),time) &
2853% HoldsAt(At(object,room),time) &
2854% Side1(staircase)=room &
2855% Happens(WalkUpStaircase(agent,staircase),time) ->
2856% Happens(WalkFrom(agent,object),time).
2857 /*
2858holds_at(near(Agent, Object), Time), holds_at(at(Agent, Room), Time), holds_at(at(Object, Room), Time), side1(Staircase)=Room, happens(walkUpStaircase(Agent, Staircase), Time) ->
2859 happens(walkFrom(Agent, Object), Time).
2860*/
2861.
2862
2863% ectest/ec_reader_test_ecnet.e:1190
2864%
2865%
2866% ectest/ec_reader_test_ecnet.e:1192
2867% [agent,object,room,staircase,time]%
2868% HoldsAt(Near(agent,object),time) &
2869% HoldsAt(At(agent,room),time) &
2870% HoldsAt(At(object,room),time) &
2871% Side2(staircase)=room &
2872% Happens(WalkDownStaircase(agent,staircase),time) ->
2873% Happens(WalkFrom(agent,object),time).
2874 /*
2875holds_at(near(Agent, Object), Time), holds_at(at(Agent, Room), Time), holds_at(at(Object, Room), Time), side2(Staircase)=Room, happens(walkDownStaircase(Agent, Staircase), Time) ->
2876 happens(walkFrom(Agent, Object), Time).
2877*/
2878.
2879
2880% ectest/ec_reader_test_ecnet.e:1198
2881%
2882%
2883%; End of file.
2884%
2885%
2886%
2887%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2888%; FILE: ecnet/OMSpace.e
2889%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2890% ectest/ec_reader_test_ecnet.e:1207
2891%
2892%;
2893%; Copyright (c) 2005 IBM Corporation and others.
2894%; All rights reserved. This program and the accompanying materials
2895%; are made available under the terms of the Common Public License v1.0
2896%; which accompanies this distribution, and is available at
2897%; http://www.eclipse.org/legal/cpl-v10.html
2898%;
2899%; Contributors:
2900%; IBM - Initial implementation
2901%;
2902%; OMSpace: object-scale metric space
2903%;
2904%; The OMSpace representation deals with metric space at
2905%; the scale of objects.
2906%;
2907%; @article{Morgenstern:2001,
2908%; author = "Morgenstern, Leora",
2909%; year = "2001",
2910%; title = "Mid-sized axiomatizations of commonsense problems: A case study in egg cracking",
2911%; journal = "Studia Logica",
2912%; volume = "67",
2913%; pages = "333--384",
2914%; }
2915%;
2916%; @article{Shanahan:2003,
2917%; author = "Shanahan, Murray",
2918%; year = "2004",
2919%; title = "An attempt to formalise a non-trivial benchmark problem in common sense reasoning",
2920%; journal = "Artificial Intelligence",
2921%; volume = "153",
2922%; pages = "141--165",
2923%; }
2924%;
2925% ectest/ec_reader_test_ecnet.e:1241
2926%
2927% sort height: integer
2928 /*
2929.
2930*/
2931.
2932.
2933.
2934
2935% sort distance: integer
2936 /*
2937.
2938*/
2939.
2940.
2941.
2942
2943%
2944%; Height
2945%
2946%; The height of object is height.
2947% ectest/ec_reader_test_ecnet.e:1248
2948% fluent Height(object,height)
2949 /*
2950.
2951*/
2952.
2953
2954%
2955%; State constraint represent the fact that each
2956%; object has a unique height:
2957% ectest/ec_reader_test_ecnet.e:1252
2958% [object,height1,height2,time]%
2959% HoldsAt(Height(object,height1),time) &
2960% HoldsAt(Height(object,height2),time) ->
2961% height1=height2.
2962 /*
2963holds_at(height(Object, Height1), Time), holds_at(height(Object, Height2), Time) ->
2964 Height1=Height2.
2965*/
2966.
2967
2968%
2969%
2970% ectest/ec_reader_test_ecnet.e:1257
2971% [object,time]%
2972% ectest/ec_reader_test_ecnet.e:1258
2973% {height}%
2974% HoldsAt(Height(object,height),time).
2975 /*
2976.
2977*/
2978.
2979
2980%
2981%
2982%; falling
2983%
2984%; physobj1 is falling from physobj2 to physobj3.
2985% ectest/ec_reader_test_ecnet.e:1264
2986% fluent FallingFromTo(physobj,physobj,physobj)
2987 /*
2988.
2989*/
2990.
2991
2992%; physobj1 starts falling from physobj2 to physobj3.
2993% event StartFallingFromTo(physobj,physobj,physobj)
2994 /*
2995.
2996*/
2997.
2998
2999%; physobj1 collides with physobj2.
3000% event CollideWith(physobj,physobj)
3001 /*
3002.
3003*/
3004.
3005
3006%
3007%; An effect axiom states that if a first physical object starts
3008%; falling from a second physical object to a third physical
3009%; object, the first physical object will be falling from the
3010%; second physical object to the third physical object:
3011% ectest/ec_reader_test_ecnet.e:1274
3012% [physobj1,physobj2,physobj3,time]%
3013% Initiates(StartFallingFromTo(physobj1,physobj2,physobj3),
3014% FallingFromTo(physobj1,physobj2,physobj3),
3015% time).
3016 /*
3017.
3018*/
3019.
3020
3021%
3022%
3023%; A precondition axiom states that for
3024%; a first physical object to start
3025%; falling from a second physical object to a third physical
3026%; object,
3027%; the height of the first physical object and the
3028%; second physical object must be the same.
3029% ectest/ec_reader_test_ecnet.e:1285
3030% [physobj1,physobj2,physobj3,height1,height2,time]%
3031% Happens(StartFallingFromTo(physobj1,physobj2,physobj3),time) &
3032% HoldsAt(Height(physobj1,height1),time) &
3033% HoldsAt(Height(physobj2,height2),time) ->
3034% height1=height2.
3035 /*
3036happens(startFallingFromTo(Physobj1, Physobj2, Physobj3), Time), holds_at(height(Physobj1, Height1), Time), holds_at(height(Physobj2, Height2), Time) ->
3037 Height1=Height2.
3038*/
3039.
3040
3041%
3042%
3043%; A state constraint says that a physical object
3044%; cannot fall from itself, cannot fall to itself,
3045%; and cannot fall from and to the same physical object:
3046% ectest/ec_reader_test_ecnet.e:1294
3047% [physobj1,physobj2,physobj3,time]%
3048% HoldsAt(FallingFromTo(physobj1,physobj2,physobj3),time) ->
3049% physobj1!=physobj2 &
3050% physobj1!=physobj3 &
3051% physobj2!=physobj3.
3052 /*
3053holds_at(fallingFromTo(Physobj1, Physobj2, Physobj3), Time) ->
3054 Physobj1\=Physobj2,
3055 Physobj1\=Physobj3,
3056 Physobj2\=Physobj3.
3057*/
3058.
3059
3060%
3061%
3062%; A state constraint says that the sky cannot fall:
3063% ectest/ec_reader_test_ecnet.e:1301
3064% [sky,physobj1,physobj2,time]%
3065% !HoldsAt(FallingFromTo(sky,physobj1,physobj2),time).
3066 /*
3067.
3068*/
3069.
3070
3071%
3072%
3073%; A releases axiom states that if
3074%; if a first physical object starts
3075%; falling from a second physical object to a third physical
3076%; object, the height of the first physical object
3077%; will be released from inertia:
3078% ectest/ec_reader_test_ecnet.e:1309
3079% [physobj1,physobj2,physobj3,height,time]%
3080% Releases(StartFallingFromTo(physobj1,physobj2,physobj3),
3081% Height(physobj1,height),
3082% time).
3083 /*
3084.
3085*/
3086.
3087
3088%
3089%
3090%; A trajectory axiom states that
3091%; if a first physical object starts falling
3092%; from a second physical object
3093%; to a third physical object
3094%; at a time and
3095%; the first physical object has a height at the time,
3096%; then the first physical object will have a height
3097%; equal to the height minus an offset
3098%; at a time equal to the time plus the offset:
3099% ectest/ec_reader_test_ecnet.e:1323
3100% [physobj1,physobj2,physobj3,height1,height2,offset,time]%
3101% HoldsAt(Height(physobj1,height1),time) &
3102% height2=height1-offset ->
3103% Trajectory(FallingFromTo(physobj1,physobj2,physobj3),time,
3104% Height(physobj1,height2),offset).
3105 /*
3106holds_at(height(Physobj1, Height1), Time), Height2=Height1-Offset ->
3107 trajectory(fallingFromTo(Physobj1, Physobj2, Physobj3),
3108 Time,
3109 height(Physobj1, Height2),
3110 Offset).
3111*/
3112.
3113
3114%
3115%
3116%; A trigger axiom states that
3117%; if a first physical object is falling
3118%; from a second physical object
3119%; to a third physical object and
3120%; the height of the first physical object
3121%; is the same as the height of the third physical object,
3122%; the first physical object collides with the
3123%; third physical object:
3124% ectest/ec_reader_test_ecnet.e:1337
3125% [physobj1,physobj2,physobj3,height,time]%
3126% HoldsAt(FallingFromTo(physobj1,physobj2,physobj3),time) &
3127% HoldsAt(Height(physobj1,height),time) &
3128% HoldsAt(Height(physobj3,height),time) ->
3129% Happens(CollideWith(physobj1,physobj3),time).
3130 /*
3131holds_at(fallingFromTo(Physobj1, Physobj2, Physobj3), Time), holds_at(height(Physobj1, Height), Time), holds_at(height(Physobj3, Height), Time) ->
3132 happens(collideWith(Physobj1, Physobj3), Time).
3133*/
3134.
3135
3136%
3137%
3138%; An effect axiom states that
3139%; if a first physical object is falling
3140%; from a second physical object
3141%; to a third physical object and
3142%; the first physical object collides with
3143%; the third physical object,
3144%; the first physical object will be on the third physical object:
3145% ectest/ec_reader_test_ecnet.e:1350
3146% [physobj1,physobj2,physobj3,time]%
3147% HoldsAt(FallingFromTo(physobj1,physobj2,physobj3),time) ->
3148% Initiates(CollideWith(physobj1,physobj3),
3149% On(physobj1,physobj3),
3150% time).
3151 /*
3152holds_at(fallingFromTo(Physobj1, Physobj2, Physobj3), Time) ->
3153 initiates(collideWith(Physobj1, Physobj3),
3154 on(Physobj1, Physobj3),
3155 Time).
3156*/
3157.
3158
3159%
3160%
3161%; An effect axiom states that
3162%; if a physical object collides with another
3163%; physical object,
3164%; the height of the first physical object will
3165%; be the height of the second physical object:
3166% ectest/ec_reader_test_ecnet.e:1361
3167% [physobj1,physobj2,height,time]%
3168% HoldsAt(Height(physobj2,height),time) ->
3169% Initiates(CollideWith(physobj1,physobj2),
3170% Height(physobj1,height),
3171% time).
3172 /*
3173holds_at(height(Physobj2, Height), Time) ->
3174 initiates(collideWith(Physobj1, Physobj2),
3175 height(Physobj1, Height),
3176 Time).
3177*/
3178.
3179
3180%
3181%
3182%;[physobj1,physobj2,height1,height2,time]
3183%;HoldsAt(Height(physobj2,height1),time) &
3184%;height1 != height2 ->
3185%;Terminates(CollideWith(physobj1,physobj2),
3186%; Height(physobj1,height2),
3187%; time).
3188% ectest/ec_reader_test_ecnet.e:1373
3189%
3190%; An effect axiom states that
3191%; if a first physical object is falling
3192%; from a second physical object
3193%; to a third physical object and
3194%; the first physical object collides with
3195%; the third physical object,
3196%; the first physical object will no longer be
3197%; falling from the second physical object to the
3198%; third physical object:
3199% ectest/ec_reader_test_ecnet.e:1383
3200% [physobj1,physobj2,physobj3,time]%
3201% HoldsAt(FallingFromTo(physobj1,physobj2,physobj3),time) ->
3202% Terminates(CollideWith(physobj1,physobj3),
3203% FallingFromTo(physobj1,physobj2,physobj3),
3204% time).
3205 /*
3206holds_at(fallingFromTo(Physobj1, Physobj2, Physobj3), Time) ->
3207 terminates(collideWith(Physobj1, Physobj3),
3208 fallingFromTo(Physobj1, Physobj2, Physobj3),
3209 Time).
3210*/
3211.
3212
3213%
3214%
3215%; flying
3216% ectest/ec_reader_test_ecnet.e:1390
3217%
3218%; agent is flying from physobj1 to physobj2.
3219% fluent FlyingFromTo(agent,physobj,physobj)
3220 /*
3221.
3222*/
3223.
3224
3225%; agent starts flying from physobj1 to physobj2.
3226% event StartFlyingFromTo(agent,physobj,physobj)
3227 /*
3228.
3229*/
3230.
3231
3232%; agent reaches physobj.
3233% ectest/ec_reader_test_ecnet.e:1396
3234% event Reach(agent,physobj)
3235 /*
3236.
3237*/
3238.
3239
3240%
3241%; An effect axiom states that if an agent starts
3242%; flying from a physical object to another physical object,
3243%; the agent will be flying from the first physical object
3244%; to the second physical object:
3245% ectest/ec_reader_test_ecnet.e:1402
3246% [agent,physobj1,physobj2,time]%
3247% Initiates(StartFlyingFromTo(agent,physobj1,physobj2),
3248% FlyingFromTo(agent,physobj1,physobj2),
3249% time).
3250 /*
3251.
3252*/
3253.
3254
3255%
3256%
3257%; A precondition axiom states that for
3258%; an agent to start flying from a physical object to
3259%; another physical object,
3260%; the height of the agent and
3261%; the first physical object must be the same:
3262% ectest/ec_reader_test_ecnet.e:1412
3263% [agent,physobj1,physobj2,height1,height2,time]%
3264% Happens(StartFlyingFromTo(agent,physobj1,physobj2),time) &
3265% HoldsAt(Height(agent,height1),time) &
3266% HoldsAt(Height(physobj1,height2),time) ->
3267% height1=height2.
3268 /*
3269happens(startFlyingFromTo(Agent, Physobj1, Physobj2), Time), holds_at(height(Agent, Height1), Time), holds_at(height(Physobj1, Height2), Time) ->
3270 Height1=Height2.
3271*/
3272.
3273
3274%
3275%
3276%; A state constraint says that an agent
3277%; cannot fly from and to the same physical object:
3278% ectest/ec_reader_test_ecnet.e:1420
3279% [agent,physobj1,physobj2,time]%
3280% HoldsAt(FlyingFromTo(agent,physobj1,physobj2),time) ->
3281% physobj1!=physobj2.
3282 /*
3283holds_at(flyingFromTo(Agent, Physobj1, Physobj2), Time) ->
3284 Physobj1\=Physobj2.
3285*/
3286.
3287
3288%
3289%
3290%; A releases axiom states that if an agent
3291%; starts flying from a physical object to another
3292%; physical object, the height of the agent will
3293%; be released from inertia:
3294% ectest/ec_reader_test_ecnet.e:1428
3295% [agent,physobj1,physobj2,height,time]%
3296% Releases(StartFlyingFromTo(agent,physobj1,physobj2),
3297% Height(agent,height),
3298% time).
3299 /*
3300.
3301*/
3302.
3303
3304%
3305%
3306%; A trajectory axiom states that
3307%; if an agent starts flying from
3308%; from a physical object
3309%; to another physical object
3310%; at a time and
3311%; the agent has a height at the time,
3312%; then the agent will have a height
3313%; equal to the height plus an offset
3314%; at a time equal to the time plus the offset:
3315% ectest/ec_reader_test_ecnet.e:1442
3316% [agent,physobj1,physobj2,height1,height2,offset,time]%
3317% HoldsAt(Height(agent,height1),time) &
3318% height2=height1+offset ->
3319% Trajectory(FlyingFromTo(agent,physobj1,physobj2),time,
3320% Height(agent,height2),offset).
3321 /*
3322holds_at(height(Agent, Height1), Time), Height2=Height1+Offset ->
3323 trajectory(flyingFromTo(Agent, Physobj1, Physobj2),
3324 Time,
3325 height(Agent, Height2),
3326 Offset).
3327*/
3328.
3329
3330%
3331%
3332%; A trigger axiom states that
3333%; if an agent is flying
3334%; from a physical object
3335%; to another physical object and
3336%; the height of the agent
3337%; is the same as the height of the second physical object,
3338%; the agent reaches the second physical object:
3339% ectest/ec_reader_test_ecnet.e:1455
3340% [agent,physobj1,physobj2,height,time]%
3341% HoldsAt(FlyingFromTo(agent,physobj1,physobj2),time) &
3342% HoldsAt(Height(agent,height),time) &
3343% HoldsAt(Height(physobj2,height),time) ->
3344% Happens(Reach(agent,physobj2),time).
3345 /*
3346holds_at(flyingFromTo(Agent, Physobj1, Physobj2), Time), holds_at(height(Agent, Height), Time), holds_at(height(Physobj2, Height), Time) ->
3347 happens(reach(Agent, Physobj2), Time).
3348*/
3349.
3350
3351%
3352%
3353%; An effect axiom states that
3354%; if an agent reaches a physical object,
3355%; the height of the agent will be the
3356%; height of the physical object:
3357% ectest/ec_reader_test_ecnet.e:1465
3358% [agent,physobj,height,time]%
3359% HoldsAt(Height(physobj,height),time) ->
3360% Initiates(Reach(agent,physobj),Height(agent,height),time).
3361 /*
3362holds_at(height(Physobj, Height), Time) ->
3363 initiates(reach(Agent, Physobj),
3364 height(Agent, Height),
3365 Time).
3366*/
3367.
3368
3369%
3370%
3371%;[agent,physobj,height1,height2,time]
3372%;HoldsAt(Height(physobj,height1),time) &
3373%;height1!=height2 ->
3374%;Terminates(Reach(agent,physobj),Height(agent,height2),time).
3375% ectest/ec_reader_test_ecnet.e:1473
3376%
3377%; An effect axiom states that
3378%; if an agent is flying
3379%; from a physical object
3380%; to another physical object and
3381%; the agent reaches the second physical object,
3382%; the agent will no longer be
3383%; flying from the first physical object
3384%; to the second physical object:
3385% ectest/ec_reader_test_ecnet.e:1482
3386% [agent,physobj1,physobj2,time]%
3387% HoldsAt(FlyingFromTo(agent,physobj1,physobj2),time) ->
3388% Terminates(Reach(agent,physobj2),
3389% FlyingFromTo(agent,physobj1,physobj2),
3390% time).
3391 /*
3392holds_at(flyingFromTo(Agent, Physobj1, Physobj2), Time) ->
3393 terminates(reach(Agent, Physobj2),
3394 flyingFromTo(Agent, Physobj1, Physobj2),
3395 Time).
3396*/
3397.
3398
3399%
3400%
3401%; A releases axiom states that
3402%; if an agent holds a physical object,
3403%; the height of the physical object is released from inertia:
3404% ectest/ec_reader_test_ecnet.e:1491
3405% [agent,physobj,height,time]%
3406% Releases(Hold(agent,physobj),Height(physobj,height),time).
3407 /*
3408.
3409*/
3410.
3411
3412%
3413%
3414%;[agent,physobj,height1,height2,time]
3415%;(!{object} PartOf(physobj,object)) &
3416%;HoldsAt(Height(physobj,height1),time) &
3417%;height1 != height2 ->
3418%;Terminates(LetGoOf(agent,physobj),Height(physobj,height2),time).
3419% ectest/ec_reader_test_ecnet.e:1499
3420%
3421% ectest/ec_reader_test_ecnet.e:1500
3422% [agent,physobj,height,time]%
3423% (!{object} PartOf(physobj,object)) &
3424% HoldsAt(Height(physobj,height),time) ->
3425% Initiates(LetGoOf(agent,physobj),Height(physobj,height),time).
3426 /*
3427not(exists([Object], partOf(Physobj, Object))), holds_at(height(Physobj, Height), Time) ->
3428 initiates(letGoOf(Agent, Physobj),
3429 height(Physobj, Height),
3430 Time).
3431*/
3432.
3433
3434%
3435%
3436%; A state constraint says that
3437%; if an agent is holding a physical object and
3438%; the height of the agent is height,
3439%; the height of the physical object is height:
3440% ectest/ec_reader_test_ecnet.e:1509
3441% [agent,physobj,height,time]%
3442% HoldsAt(Holding(agent,physobj),time) &
3443% HoldsAt(Height(agent,height),time) ->
3444% HoldsAt(Height(physobj,height),time).
3445 /*
3446holds_at(holding(Agent, Physobj), Time), holds_at(height(Agent, Height), Time) ->
3447 holds_at(height(Physobj, Height), Time).
3448*/
3449.
3450
3451%
3452%
3453%; A state constraint says that if a physical object
3454%; is part of an object,
3455%; the height of the physical object
3456%; is the same as the height of the object:
3457% ectest/ec_reader_test_ecnet.e:1518
3458% [physobj,object,height,time]%
3459% PartOf(physobj,object) &
3460% HoldsAt(Height(object,height),time) ->
3461% HoldsAt(Height(physobj,height),time).
3462 /*
3463partOf(Physobj, Object), holds_at(height(Object, Height), Time) ->
3464 holds_at(height(Physobj, Height), Time).
3465*/
3466.
3467
3468%
3469%
3470%;event Catch(agent,physobj)
3471%;event HitFromTo(agent,physobj,object,object)
3472%;fluent Distance(physobj,physobj,distance)
3473%;fluent FlyingAcrossFromTo(physobj,object,object)
3474% ectest/ec_reader_test_ecnet.e:1527
3475%
3476%;[agent,physobj1,physobj2,physobj3,time]
3477%;Initiates(HitFromTo(agent,physobj1,physobj2,physobj3),
3478%; FlyingAcrossFromTo(physobj1,physobj2,physobj3),
3479%; time).
3480%
3481%;[agent,physobj1,physobj2,physobj3,distance,time]
3482%;Releases(HitFromTo(agent,physobj1,physobj2,physobj3),
3483%; Distance(physobj1,physobj2,distance),
3484%; time).
3485% ectest/ec_reader_test_ecnet.e:1537
3486%
3487%;[agent,physobj1,physobj2,physobj3,distance,time]
3488%;Releases(HitFromTo(agent,physobj1,physobj2,physobj3),
3489%; Distance(physobj1,physobj3,distance),
3490%; time).
3491%
3492%;[physobj1,physobj2,physobj3,offset,time]
3493%;Trajectory(FlyingAcrossFromTo(physobj1,physobj2,physobj3),time,
3494%; Distance(physobj1,physobj2,offset),offset).
3495% ectest/ec_reader_test_ecnet.e:1546
3496%
3497%;[physobj1,physobj2,physobj3,distance1,distance2,offset,time]
3498%;HoldsAt(Distance(physobj2,physobj3,distance1),time) &
3499%;distance2 = distance1 - time ->
3500%;Trajectory(FlyingAcrossFromTo(physobj1,physobj2,physobj3),time,
3501%; Distance(physobj1,physobj3,distance2),offset).
3502% ectest/ec_reader_test_ecnet.e:1552
3503%
3504%;[agent,physobj1,physobj2,physobj3,time]
3505%;HoldsAt(FlyingAcrossFromTo(physobj1,physobj2,physobj3),time) ->
3506%;Initiates(Catch(agent,physobj1),
3507%; Holding(agent,physobj1),
3508%; time).
3509% ectest/ec_reader_test_ecnet.e:1558
3510%
3511%;[agent,physobj1,physobj2,physobj3,time]
3512%;HoldsAt(FlyingAcrossFromTo(physobj1,physobj2,physobj3),time) ->
3513%;Terminates(Catch(agent,physobj1),
3514%; FlyingAcrossFromTo(physobj1,physobj2,physobj3),
3515%; time).
3516% ectest/ec_reader_test_ecnet.e:1564
3517%
3518%; End of file.
3519%
3520%
3521%
3522%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3523%; FILE: ecnet/GSpace.e
3524%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3525% ectest/ec_reader_test_ecnet.e:1572
3526%
3527%;
3528%; Copyright (c) 2005 IBM Corporation and others.
3529%; All rights reserved. This program and the accompanying materials
3530%; are made available under the terms of the Common Public License v1.0
3531%; which accompanies this distribution, and is available at
3532%; http://www.eclipse.org/legal/cpl-v10.html
3533%;
3534%; Contributors:
3535%; IBM - Initial implementation
3536%;
3537%; GSpace: grid space
3538%;
3539%; @book{Mueller:1998,
3540%; author = "Erik T. Mueller",
3541%; year = "1998",
3542%; title = "Natural Language Processing with \uppercase{T}hought\uppercase{T}reasure",
3543%; address = "New York",
3544%; publisher = "Signiform",
3545%; }
3546%;
3547% ectest/ec_reader_test_ecnet.e:1593
3548%
3549% sort coord: integer
3550 /*
3551.
3552*/
3553.
3554.
3555.
3556
3557% sort grid
3558 /*
3559.
3560*/
3561.
3562
3563%
3564%; object is at (coord1, coord2) in grid.
3565% fluent GridAt(grid,object,coord,coord)
3566 /*
3567.
3568*/
3569.
3570
3571% ectest/ec_reader_test_ecnet.e:1599
3572%
3573%; agent walks from (coord1, coord2)
3574%; to (coord3, coord4) in grid.
3575% event GridWalk(grid,agent,coord,coord,coord,coord)
3576 /*
3577.
3578*/
3579.
3580
3581%
3582%; A state constraint says that for a given grid an
3583%; object is at one cell in that grid at a time:
3584% ectest/ec_reader_test_ecnet.e:1606
3585% [grid,object,coord1,coord2,coord3,coord4,time]%
3586% HoldsAt(GridAt(grid,object,coord1,coord2),time) &
3587% HoldsAt(GridAt(grid,object,coord3,coord4),time) ->
3588% coord1=coord3 & coord2=coord4.
3589 /*
3590holds_at(gridAt(Grid, Object, Coord1, Coord2), Time), holds_at(gridAt(Grid, Object, Coord3, Coord4), Time) ->
3591 Coord1=Coord3,
3592 Coord2=Coord4.
3593*/
3594.
3595
3596%
3597%
3598%; An effect axiom states that
3599%; if an agent walks from one cell in a grid to another cell,
3600%; the agent will be at second cell:
3601% ectest/ec_reader_test_ecnet.e:1614
3602% [grid,agent,coord1,coord2,coord3,coord4,time]%
3603% Initiates(GridWalk(grid,agent,coord1,coord2,coord3,coord4),
3604% GridAt(grid,agent,coord3,coord4),
3605% time).
3606 /*
3607.
3608*/
3609.
3610
3611%
3612%
3613%; An effect axiom states that
3614%; if an agent walks from one cell in a grid to another cell,
3615%; the agent will no longer be at the first cell:
3616% ectest/ec_reader_test_ecnet.e:1622
3617% [grid,agent,coord1,coord2,coord3,coord4,time]%
3618% Terminates(GridWalk(grid,agent,coord1,coord2,coord3,coord4),
3619% GridAt(grid,agent,coord1,coord2),
3620% time).
3621 /*
3622.
3623*/
3624.
3625
3626%
3627%
3628%; A precondition axiom states that for an agent to walk
3629%; from one cell in a grid to another cell, the agent
3630%; must be at the first cell, the second cell must not
3631%; be occupied, and the first cell must be adjacent to
3632%; the second cell:
3633% ectest/ec_reader_test_ecnet.e:1632
3634% [grid,agent,coord1,coord2,coord3,coord4,time]%
3635% Happens(GridWalk(grid,agent,coord1,coord2,coord3,coord4),time) ->
3636% HoldsAt(GridAt(grid,agent,coord1,coord2),time) &
3637% (!{object} HoldsAt(GridAt(grid,object,coord3,coord4),time)) &
3638% (coord1=coord3 |
3639% coord1=coord3+1 |
3640% coord1=coord3-1) &
3641% (coord2=coord4 |
3642% coord2=coord4+1 |
3643% coord2=coord4-1).
3644 /*
3645happens(gridWalk(Grid, Agent, Coord1, Coord2, Coord3, Coord4), Time) ->
3646 holds_at(gridAt(Grid, Agent, Coord1, Coord2),
3647 Time),
3648 not(exists([Object],
3649 holds_at(gridAt(Grid,
3650 Object,
3651 Coord3,
3652 Coord4),
3653 Time))),
3654 ( Coord1=Coord3
3655 ; Coord1=Coord3+1
3656 ; Coord1=Coord3-1
3657 ),
3658 ( Coord2=Coord4
3659 ; Coord2=Coord4+1
3660 ; Coord2=Coord4-1
3661 ).
3662*/
3663.
3664
3665% ectest/ec_reader_test_ecnet.e:1641
3666%
3667%
3668%; End of file.
3669%
3670%
3671%
3672%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3673%; FILE: ecnet/PolySpace.e
3674%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3675% ectest/ec_reader_test_ecnet.e:1650
3676%
3677%;
3678%; Copyright (c) 2005 IBM Corporation and others.
3679%; All rights reserved. This program and the accompanying materials
3680%; are made available under the terms of the Common Public License v1.0
3681%; which accompanies this distribution, and is available at
3682%; http://www.eclipse.org/legal/cpl-v10.html
3683%;
3684%; Contributors:
3685%; IBM - Initial implementation
3686%;
3687%; @phdthesis{Cassimatis:2002,
3688%; author = "Nicholas L. Cassimatis",
3689%; year = "2002",
3690%; title = "Polyscheme: A Cognitive Architecture for Integrating Multiple Representation and Inference Schemes",
3691%; address = "Cambridge, MA",
3692%; school = "Program in Media Arts and Sciences, School of Architecture and Planning, Massachusetts Institute of Technology",
3693%; }
3694%;
3695% ectest/ec_reader_test_ecnet.e:1669
3696%
3697%; sorts
3698% sort object
3699 /*
3700.
3701*/
3702.
3703
3704% sort xcoord: integer
3705 /*
3706.
3707*/
3708.
3709.
3710.
3711
3712% sort ycoord: integer
3713 /*
3714.
3715*/
3716.
3717.
3718.
3719
3720% sort grid
3721 /*
3722.
3723*/
3724.
3725
3726% ectest/ec_reader_test_ecnet.e:1675
3727% sort shape
3728 /*
3729.
3730*/
3731.
3732
3733% sort color
3734 /*
3735.
3736*/
3737.
3738
3739%
3740%; constants
3741% shape Round,Square
3742 /*
3743.
3744*/
3745.
3746.
3747
3748 /*
3749.
3750*/
3751.
3752.
3753
3754% color Red,Green
3755 /*
3756.
3757*/
3758.
3759.
3760
3761 /*
3762.
3763*/
3764.
3765.
3766
3767% ectest/ec_reader_test_ecnet.e:1681
3768%
3769%; predicates, fluents, and events
3770% predicate Equal(object,object)
3771 /*
3772.
3773*/
3774.
3775
3776% predicate Shape(object,shape)
3777 /*
3778.
3779*/
3780.
3781
3782% predicate Color(object,color)
3783 /*
3784.
3785*/
3786.
3787
3788% fluent Location(grid,object,xcoord,ycoord)
3789 /*
3790.
3791*/
3792.
3793
3794% ectest/ec_reader_test_ecnet.e:1687
3795% event Move(grid,object,xcoord,ycoord,xcoord,ycoord)
3796 /*
3797.
3798*/
3799.
3800
3801%
3802%; axioms
3803%
3804% ectest/ec_reader_test_ecnet.e:1691
3805% [object1,object2] % Equal(object1,object2) -> Equal(object2,object1).
3806 /*
3807equal(Object1, Object2) ->
3808 equal(Object2, Object1).
3809*/
3810.
3811
3812%
3813%
3814%; objects have unique shape
3815% ectest/ec_reader_test_ecnet.e:1694
3816% [object,shape1,shape2]%
3817% Shape(object,shape1) & Shape(object,shape2) ->
3818% shape1=shape2.
3819 /*
3820shape(Object, Shape1), shape(Object, Shape2) ->
3821 Shape1=Shape2.
3822*/
3823.
3824
3825%
3826%
3827%; objects have unique color
3828% ectest/ec_reader_test_ecnet.e:1699
3829% [object,color1,color2]%
3830% Color(object,color1) & Color(object,color2) ->
3831% color1=color2.
3832 /*
3833color(Object, Color1), color(Object, Color2) ->
3834 Color1=Color2.
3835*/
3836.
3837
3838%
3839%
3840%; if objects are the same, they have the same shape
3841% ectest/ec_reader_test_ecnet.e:1704
3842% [object1,object2]%
3843% Equal(object1,object2) ->
3844% ({shape} Shape(object1,shape) & Shape(object2,shape)).
3845 /*
3846equal(Object1, Object2) ->
3847 exists([Shape],
3848 (shape(Object1, Shape), shape(Object2, Shape))).
3849*/
3850.
3851
3852%
3853%
3854%; if objects are the same, they have the same color
3855% ectest/ec_reader_test_ecnet.e:1709
3856% [object1,object2]%
3857% Equal(object1,object2) ->
3858% ({color} Color(object1,color) & Color(object2,color)).
3859 /*
3860equal(Object1, Object2) ->
3861 exists([Color],
3862 (color(Object1, Color), color(Object2, Color))).
3863*/
3864.
3865
3866%
3867%
3868%; if objects are the same, they have the same location
3869% ectest/ec_reader_test_ecnet.e:1714
3870% [grid,object1,object2,xcoord1,ycoord1,xcoord2,ycoord2,time]%
3871% Equal(object1,object2) ->
3872% (HoldsAt(Location(grid,object1,xcoord1,ycoord1),time) &
3873% HoldsAt(Location(grid,object2,xcoord2,ycoord2),time) ->
3874% xcoord1=xcoord2 & ycoord1=ycoord2).
3875 /*
3876equal(Object1, Object2) ->
3877 ( holds_at(location(Grid, Object1, Xcoord1, Ycoord1), Time), holds_at(location(Grid, Object2, Xcoord2, Ycoord2), Time)->Xcoord1=Xcoord2, Ycoord1=Ycoord2
3878 ).
3879*/
3880.
3881
3882%
3883%
3884%; object in one location at a time
3885% ectest/ec_reader_test_ecnet.e:1721
3886% [grid,object,xcoord1,ycoord1,xcoord2,ycoord2,time]%
3887% HoldsAt(Location(grid,object,xcoord1,ycoord1),time) &
3888% HoldsAt(Location(grid,object,xcoord2,ycoord2),time) ->
3889% xcoord1=xcoord2 & ycoord1=ycoord2.
3890 /*
3891holds_at(location(Grid, Object, Xcoord1, Ycoord1), Time), holds_at(location(Grid, Object, Xcoord2, Ycoord2), Time) ->
3892 Xcoord1=Xcoord2,
3893 Ycoord1=Ycoord2.
3894*/
3895.
3896
3897%
3898%
3899%; objects have locations
3900% ectest/ec_reader_test_ecnet.e:1727
3901% [grid,object,time]%
3902% (
3903% ectest/ec_reader_test_ecnet.e:1728
3904% {xcoord,ycoord} HoldsAt(Location(grid,object,xcoord,ycoord),time)).
3905 /*
3906.
3907*/
3908.
3909
3910%
3911%
3912%; different objects are not at same location
3913% ectest/ec_reader_test_ecnet.e:1731
3914% [grid,object1,object2,xcoord1,ycoord1,time]%
3915% HoldsAt(Location(grid,object1,xcoord1,ycoord1),time) &
3916% HoldsAt(Location(grid,object2,xcoord1,ycoord1),time) ->
3917% Equal(object1,object2).
3918 /*
3919holds_at(location(Grid, Object1, Xcoord1, Ycoord1), Time), holds_at(location(Grid, Object2, Xcoord1, Ycoord1), Time) ->
3920 equal(Object1, Object2).
3921*/
3922.
3923
3924%
3925%
3926%; moving to a location causes an object to be at that location
3927% ectest/ec_reader_test_ecnet.e:1737
3928% [grid,object,xcoord1,ycoord1,xcoord2,ycoord2,time]%
3929% Initiates(Move(grid,object,xcoord1,ycoord1,xcoord2,ycoord2),
3930% Location(grid,object,xcoord2,ycoord2),
3931% time).
3932 /*
3933.
3934*/
3935.
3936
3937%
3938%
3939%; moving to a location causes the object no longer to be at its previous
3940%; location
3941% ectest/ec_reader_test_ecnet.e:1744
3942% [grid,object,xcoord1,ycoord1,xcoord2,ycoord2,time]%
3943% Terminates(Move(grid,object,xcoord1,ycoord1,xcoord2,ycoord2),
3944% Location(grid,object,xcoord1,ycoord1),
3945% time).
3946 /*
3947.
3948*/
3949.
3950
3951%
3952%
3953%;; allow diagonal movements
3954%;[grid,object,xcoord1,ycoord1,xcoord2,ycoord2,time]
3955%;Happens(Move(grid,object,xcoord1,ycoord1,xcoord2,ycoord2),time) ->
3956%;HoldsAt(Location(grid,object,xcoord1,ycoord1),time) &
3957%;(xcoord1=xcoord2 |
3958%; xcoord1=xcoord2+1 |
3959%; xcoord1=xcoord2-1) &
3960%;(ycoord1=ycoord2 |
3961%; ycoord1=ycoord2+1 |
3962%; ycoord1=ycoord2-1).
3963% ectest/ec_reader_test_ecnet.e:1759
3964%
3965%; only allow right angle movements
3966% ectest/ec_reader_test_ecnet.e:1761
3967% [grid,object,xcoord1,ycoord1,xcoord2,ycoord2,time]%
3968% Happens(Move(grid,object,xcoord1,ycoord1,xcoord2,ycoord2),time) ->
3969% HoldsAt(Location(grid,object,xcoord1,ycoord1),time) &
3970% ((xcoord1=xcoord2 & (ycoord1=ycoord2+1 | ycoord1=ycoord2-1)) |
3971% (ycoord1=ycoord2 & (xcoord1=xcoord2+1 | xcoord1=xcoord2-1))).
3972 /*
3973happens(move(Grid, Object, Xcoord1, Ycoord1, Xcoord2, Ycoord2), Time) ->
3974 holds_at(location(Grid, Object, Xcoord1, Ycoord1),
3975 Time),
3976 ( Xcoord1=Xcoord2,
3977 ( Ycoord1=Ycoord2+1
3978 ; Ycoord1=Ycoord2-1
3979 )
3980 ; Ycoord1=Ycoord2,
3981 ( Xcoord1=Xcoord2+1
3982 ; Xcoord1=Xcoord2-1
3983 )
3984 ).
3985*/
3986.
3987
3988%
3989%
3990%; End of file.
3991% ectest/ec_reader_test_ecnet.e:1768
3992%
3993%
3994%
3995%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3996%; FILE: ecnet/HandTo.e
3997%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3998% ectest/ec_reader_test_ecnet.e:1774
3999%
4000%;
4001%; Copyright (c) 2005 IBM Corporation and others.
4002%; All rights reserved. This program and the accompanying materials
4003%; are made available under the terms of the Common Public License v1.0
4004%; which accompanies this distribution, and is available at
4005%; http://www.eclipse.org/legal/cpl-v10.html
4006%;
4007%; Contributors:
4008%; IBM - Initial implementation
4009%;
4010% ectest/ec_reader_test_ecnet.e:1785
4011%
4012% event HandTo(agent,agent,physobj)
4013 /*
4014.
4015*/
4016.
4017
4018%
4019% ectest/ec_reader_test_ecnet.e:1788
4020% [agent1,agent2,physobj,time]%
4021% Initiates(HandTo(agent1,agent2,physobj),
4022% Holding(agent2,physobj),
4023% time).
4024 /*
4025.
4026*/
4027.
4028
4029%
4030%
4031% ectest/ec_reader_test_ecnet.e:1793
4032% [agent1,agent2,physobj,time]%
4033% Terminates(HandTo(agent1,agent2,physobj),
4034% Holding(agent1,physobj),
4035% time).
4036 /*
4037.
4038*/
4039.
4040
4041%
4042%
4043% ectest/ec_reader_test_ecnet.e:1798
4044% [agent1,agent2,physobj,time]%
4045% Happens(HandTo(agent1,agent2,physobj),time) ->
4046% HoldsAt(Holding(agent1,physobj),time).
4047 /*
4048happens(handTo(Agent1, Agent2, Physobj), Time) ->
4049 holds_at(holding(Agent1, Physobj), Time).
4050*/
4051.
4052
4053%
4054%
4055% event ShakeHands(agent,agent)
4056 /*
4057.
4058*/
4059.
4060
4061%
4062% ectest/ec_reader_test_ecnet.e:1804
4063% event WriteOn(agent,paper,pen)
4064 /*
4065.
4066*/
4067.
4068
4069%
4070%
4071%
4072%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4073%; FILE: ecnet/Container.e
4074%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4075% ectest/ec_reader_test_ecnet.e:1811
4076%
4077%;
4078%; Copyright (c) 2005 IBM Corporation and others.
4079%; All rights reserved. This program and the accompanying materials
4080%; are made available under the terms of the Common Public License v1.0
4081%; which accompanies this distribution, and is available at
4082%; http://www.eclipse.org/legal/cpl-v10.html
4083%;
4084%; Contributors:
4085%; IBM - Initial implementation
4086%;
4087%;
4088%; Container: container
4089%;
4090% ectest/ec_reader_test_ecnet.e:1825
4091%
4092%; linkage to OTSpace(M):
4093% ectest/ec_reader_test_ecnet.e:1827
4094% [agent,container1,container2,time]%
4095% Happens(TakeOutOf(agent,container1,container2),time) ->
4096% HoldsAt(ContainerIsOpen(container2),time).
4097 /*
4098happens(takeOutOf(Agent, Container1, Container2), Time) ->
4099 holds_at(containerIsOpen(Container2), Time).
4100*/
4101.
4102
4103%
4104%
4105% ectest/ec_reader_test_ecnet.e:1831
4106% [agent,container1,container2,time]%
4107% Happens(PutInside(agent,container1,container2),time) ->
4108% HoldsAt(ContainerIsOpen(container2),time).
4109 /*
4110happens(putInside(Agent, Container1, Container2), Time) ->
4111 holds_at(containerIsOpen(Container2), Time).
4112*/
4113.
4114
4115%
4116%
4117%; agent opens container.
4118% event ContainerOpen(agent,container)
4119 /*
4120.
4121*/
4122.
4123
4124% ectest/ec_reader_test_ecnet.e:1837
4125%
4126%; agent closes container.
4127% event ContainerClose(agent,container)
4128 /*
4129.
4130*/
4131.
4132
4133%
4134%; container is open.
4135% fluent ContainerIsOpen(container)
4136 /*
4137.
4138*/
4139.
4140
4141% ectest/ec_reader_test_ecnet.e:1843
4142%
4143% fluent ContainerClosed(container)
4144 /*
4145.
4146*/
4147.
4148
4149% noninertial ContainerClosed
4150 /*
4151.
4152*/
4153.
4154
4155%
4156% ectest/ec_reader_test_ecnet.e:1847
4157% [container,time]%
4158% HoldsAt(ContainerClosed(container),time) <->
4159% !HoldsAt(ContainerIsOpen(container),time).
4160 /*
4161holds_at(containerClosed(Container), Time) <->
4162 not(holds_at(containerIsOpen(Container), Time)).
4163*/
4164.
4165.
4166
4167%
4168%
4169%; A precondition axiom states that
4170%; for an agent to open a container,
4171%; the agent must be awake,
4172%; the container must not already be open, and
4173%; the agent must be holding the container.
4174% ectest/ec_reader_test_ecnet.e:1856
4175% [agent,container,time]%
4176% Happens(ContainerOpen(agent,container),time) ->
4177% HoldsAt(Awake(agent),time) &
4178% !HoldsAt(ContainerIsOpen(container),time) &
4179% HoldsAt(Holding(agent,container),time).
4180 /*
4181happens(containerOpen(Agent, Container), Time) ->
4182 holds_at(awake(Agent), Time),
4183 not(holds_at(containerIsOpen(Container), Time)),
4184 holds_at(holding(Agent, Container), Time).
4185*/
4186.
4187
4188%
4189%
4190%; An effect axiom states that
4191%; if an agent opens a container,
4192%; the container will be open:
4193% ectest/ec_reader_test_ecnet.e:1865
4194% [agent,container,time]%
4195% Initiates(ContainerOpen(agent,container),ContainerIsOpen(container),time).
4196 /*
4197.
4198*/
4199.
4200
4201%
4202%
4203%; A precondition axiom states that
4204%; for an agent to close a container,
4205%; the agent must be awake,
4206%; the container must be open, and
4207%; the agent must be holding the container.
4208% ectest/ec_reader_test_ecnet.e:1873
4209% [agent,container,time]%
4210% Happens(ContainerClose(agent,container),time) ->
4211% HoldsAt(Awake(agent),time) &
4212% HoldsAt(ContainerIsOpen(container),time) &
4213% HoldsAt(Holding(agent,container),time).
4214 /*
4215happens(containerClose(Agent, Container), Time) ->
4216 holds_at(awake(Agent), Time),
4217 holds_at(containerIsOpen(Container), Time),
4218 holds_at(holding(Agent, Container), Time).
4219*/
4220.
4221
4222%
4223%
4224%; An effect axiom states that
4225%; if an agent closes a container,
4226%; the container will no longer be open:
4227% ectest/ec_reader_test_ecnet.e:1882
4228% [agent,container,time]%
4229% Terminates(ContainerClose(agent,container),ContainerIsOpen(container),time).
4230 /*
4231.
4232*/
4233.
4234
4235%
4236%
4237%; End of file.
4238%
4239%
4240% ectest/ec_reader_test_ecnet.e:1888
4241%
4242%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4243%; FILE: ecnet/SpeechAct.e
4244%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4245%
4246%;
4247%; Copyright (c) 2005 IBM Corporation and others.
4248%; All rights reserved. This program and the accompanying materials
4249%; are made available under the terms of the Common Public License v1.0
4250%; which accompanies this distribution, and is available at
4251%; http://www.eclipse.org/legal/cpl-v10.html
4252%;
4253%; Contributors:
4254%; IBM - Initial implementation
4255%;
4256%; The SpeechAct representation deals with a few speech acts
4257%; \fullcite{Searle:1969}.
4258%;
4259%; @book{Searle:1969,
4260%; author = "John R. Searle",
4261%; year = "1969",
4262%; title = "Speech Acts: An Essay in the Philosophy of Language",
4263%; address = "Cambridge",
4264%; publisher = "Cambridge University Press",
4265%; }
4266%;
4267%; We handle
4268%; the illocutionary acts of
4269%; inviting someone into one's house (a form of request) and
4270%; greeting someone,
4271%; and the expressive speech act of crying for joy.
4272%;
4273% ectest/ec_reader_test_ecnet.e:1920
4274%
4275%; inviting in
4276%
4277%; agent1 invites agent2 into room.
4278% event InviteIn(agent,agent,room)
4279 /*
4280.
4281*/
4282.
4283
4284%; agent1 is invited into room by agent2.
4285% ectest/ec_reader_test_ecnet.e:1926
4286% fluent InvitedIn(agent,room,agent)
4287 /*
4288.
4289*/
4290.
4291
4292%
4293%; A precondition axiom states that for
4294%; an agent to invite another agent into a room,
4295%; the first agent must be in the room and
4296%; there must be an outside area such that
4297%; the second agent is at the outside area and
4298%; the outside area is adjacent to the room:
4299% ectest/ec_reader_test_ecnet.e:1934
4300% [agent1,agent2,room,time]%
4301% Happens(InviteIn(agent1,agent2,room),time) ->
4302% HoldsAt(At(agent1,room),time) &
4303% ectest/ec_reader_test_ecnet.e:1937
4304% {outside}%
4305% HoldsAt(At(agent2,outside),time) &
4306% Adjacent(room,outside).
4307 /*
4308exists([Outside], (happens(inviteIn(Agent1, Agent2, Room), Time)->holds_at(at(Agent1, Room), Time), holds_at(at(Agent2, Outside), Time), adjacent(Room, Outside))).
4309*/
4310.
4311
4312%
4313%
4314%; An effect axiom states that if
4315%; an agent invites another agent into a room,
4316%; the second agent will be invited into the room by the first agent:
4317% ectest/ec_reader_test_ecnet.e:1944
4318% [agent1,agent2,room,time]%
4319% Initiates(InviteIn(agent1,agent2,room),
4320% InvitedIn(agent2,room,agent1),
4321% time).
4322 /*
4323.
4324*/
4325.
4326
4327%
4328%
4329%; agent intends to walk into room.
4330% ectest/ec_reader_test_ecnet.e:1950
4331% event IntendToWalkIn(agent,room)
4332 /*
4333.
4334*/
4335.
4336
4337%; agent has the intention to walk into room.
4338% fluent IntentionToWalkIn(agent,room)
4339 /*
4340.
4341*/
4342.
4343
4344%; agent acts on the intention to walk into room.
4345% fluent ActOnIntentionToWalkIn(agent,room)
4346 /*
4347.
4348*/
4349.
4350
4351% noninertial ActOnIntentionToWalkIn
4352 /*
4353.
4354*/
4355.
4356
4357% ectest/ec_reader_test_ecnet.e:1956
4358%
4359%; A trigger axiom states that
4360%; if an agent is invited into a room by another agent,
4361%; the first agent likes the second agent, and
4362%; the first agent does not already have the intention to
4363%; walk into the room,
4364%; the first agent intends to walk into the room:
4365% ectest/ec_reader_test_ecnet.e:1963
4366% [agent1,agent2,room,time]%
4367% HoldsAt(InvitedIn(agent1,room,agent2),time) &
4368% HoldsAt(Like(agent1,agent2),time) &
4369% !HoldsAt(IntentionToWalkIn(agent1,room),time) ->
4370% Happens(IntendToWalkIn(agent1,room),time).
4371 /*
4372holds_at(invitedIn(Agent1, Room, Agent2), Time), holds_at(like(Agent1, Agent2), Time), not(holds_at(intentionToWalkIn(Agent1, Room), Time)) ->
4373 happens(intendToWalkIn(Agent1, Room), Time).
4374*/
4375.
4376
4377%
4378%
4379%; An effect axiom states that
4380%; if an agent intends to walk into a room,
4381%; the agent will have the intention to walk into the room:
4382% ectest/ec_reader_test_ecnet.e:1972
4383% [agent,room,time]%
4384% Initiates(IntendToWalkIn(agent,room),
4385% IntentionToWalkIn(agent,room),
4386% time).
4387 /*
4388.
4389*/
4390.
4391
4392%
4393%
4394%; Two trigger axioms state that
4395%; if an agent has the intention to walk into a room,
4396%; the agent acts on the intention to walk into the room,
4397%; the agent is at a location,
4398%; side one (two) of a door is the room,
4399%; side two (one) of the door is the location,
4400%; agent will walk through side two (one) of the door:
4401% ectest/ec_reader_test_ecnet.e:1984
4402% [agent,room,location,door,time]%
4403% HoldsAt(IntentionToWalkIn(agent,room),time) &
4404% HoldsAt(ActOnIntentionToWalkIn(agent,room),time) &
4405% HoldsAt(At(agent,location),time) &
4406% Side1(door)=room &
4407% Side2(door)=location ->
4408% Happens(WalkThroughDoor21(agent,door),time).
4409 /*
4410holds_at(intentionToWalkIn(Agent, Room), Time), holds_at(actOnIntentionToWalkIn(Agent, Room), Time), holds_at(at(Agent, Location), Time), side1(Door)=Room, side2(Door)=Location ->
4411 happens(walkThroughDoor21(Agent, Door), Time).
4412*/
4413.
4414
4415% ectest/ec_reader_test_ecnet.e:1990
4416%
4417%
4418% ectest/ec_reader_test_ecnet.e:1992
4419% [agent,room,location,door,time]%
4420% HoldsAt(IntentionToWalkIn(agent,room),time) &
4421% HoldsAt(ActOnIntentionToWalkIn(agent,room),time) &
4422% HoldsAt(At(agent,location),time) &
4423% Side2(door)=room &
4424% Side1(door)=location ->
4425% Happens(WalkThroughDoor12(agent,door),time).
4426 /*
4427holds_at(intentionToWalkIn(Agent, Room), Time), holds_at(actOnIntentionToWalkIn(Agent, Room), Time), holds_at(at(Agent, Location), Time), side2(Door)=Room, side1(Door)=Location ->
4428 happens(walkThroughDoor12(Agent, Door), Time).
4429*/
4430.
4431
4432% ectest/ec_reader_test_ecnet.e:1998
4433%
4434%
4435%; Two effect axioms state that
4436%; if side one (two) of a door is a room and
4437%; an agent walks through side two (one) of the door,
4438%; the agent will no longer have the intention to
4439%; walk into the room:
4440% ectest/ec_reader_test_ecnet.e:2005
4441% [agent,room,door,time]%
4442% Side1(door)=room ->
4443% Terminates(WalkThroughDoor21(agent,door),
4444% IntentionToWalkIn(agent,room),
4445% time).
4446 /*
4447side1(Door)=Room ->
4448 terminates(walkThroughDoor21(Agent, Door),
4449 intentionToWalkIn(Agent, Room),
4450 Time).
4451*/
4452.
4453
4454%
4455%
4456% ectest/ec_reader_test_ecnet.e:2011
4457% [agent,room,door,time]%
4458% Side2(door)=room ->
4459% Terminates(WalkThroughDoor12(agent,door),
4460% IntentionToWalkIn(agent,room),
4461% time).
4462 /*
4463side2(Door)=Room ->
4464 terminates(walkThroughDoor12(Agent, Door),
4465 intentionToWalkIn(Agent, Room),
4466 Time).
4467*/
4468.
4469
4470%
4471%
4472%; agent greets object.
4473% ectest/ec_reader_test_ecnet.e:2018
4474% event Greet(agent,object)
4475 /*
4476.
4477*/
4478.
4479
4480%
4481% event SayPleasedToMeet(agent,agent)
4482 /*
4483.
4484*/
4485.
4486
4487%
4488%; agent says goodbye to object.
4489% event SayGoodbye(agent,object)
4490 /*
4491.
4492*/
4493.
4494
4495% ectest/ec_reader_test_ecnet.e:2024
4496%
4497% event TalkAbout(agent,content)
4498 /*
4499.
4500*/
4501.
4502
4503%
4504% event Converse(agent,agent)
4505 /*
4506.
4507*/
4508.
4509
4510%
4511% ectest/ec_reader_test_ecnet.e:2029
4512% [agent1,agent2,time]%
4513% Happens(Converse(agent1,agent2),time) ->
4514% ectest/ec_reader_test_ecnet.e:2031
4515% {location}%
4516% HoldsAt(At(agent1,location),time) &
4517% HoldsAt(At(agent2,location),time).
4518 /*
4519exists([Location], (happens(converse(Agent1, Agent2), Time)->holds_at(at(Agent1, Location), Time), holds_at(at(Agent2, Location), Time))).
4520*/
4521.
4522
4523%
4524%
4525%; A precondition axiom states that for
4526%; an agent to greet an object,
4527%; there must be a location such that
4528%; the agent is at the location and
4529%; the object is at the location:
4530% ectest/ec_reader_test_ecnet.e:2040
4531% [agent,object,time]%
4532% Happens(Greet(agent,object),time) ->
4533% ectest/ec_reader_test_ecnet.e:2042
4534% {location}%
4535% HoldsAt(At(agent,location),time) &
4536% HoldsAt(At(object,location),time).
4537 /*
4538exists([Location], (happens(greet(Agent, Object), Time)->holds_at(at(Agent, Location), Time), holds_at(at(Object, Location), Time))).
4539*/
4540.
4541
4542%
4543%
4544% ectest/ec_reader_test_ecnet.e:2046
4545% [agent,object,time]%
4546% Happens(SayGoodbye(agent,object),time) ->
4547% ectest/ec_reader_test_ecnet.e:2048
4548% {location}%
4549% HoldsAt(At(agent,location),time) &
4550% HoldsAt(At(object,location),time).
4551 /*
4552exists([Location], (happens(sayGoodbye(Agent, Object), Time)->holds_at(at(Agent, Location), Time), holds_at(at(Object, Location), Time))).
4553*/
4554.
4555
4556%
4557%
4558%; speech: expression of emotions
4559%
4560%; agent cries for joy.
4561% ectest/ec_reader_test_ecnet.e:2055
4562% event CryForJoy(agent)
4563 /*
4564.
4565*/
4566.
4567
4568%
4569%; A precondition axiom states that for
4570%; an agent to cry for joy,
4571%; the agent must be happy:
4572% ectest/ec_reader_test_ecnet.e:2060
4573% [agent,time]%
4574% Happens(CryForJoy(agent),time) ->
4575% HoldsAt(Happy(agent),time).
4576 /*
4577happens(cryForJoy(Agent), Time) ->
4578 holds_at(happy(Agent), Time).
4579*/
4580.
4581
4582%
4583%
4584% event Threaten(agent,agent,weapon)
4585 /*
4586.
4587*/
4588.
4589
4590%
4591% ectest/ec_reader_test_ecnet.e:2066
4592% event ReleaseFromThreat(agent,agent)
4593 /*
4594.
4595*/
4596.
4597
4598%
4599% fluent ThreatenedBy(agent,agent)
4600 /*
4601.
4602*/
4603.
4604
4605%
4606% ectest/ec_reader_test_ecnet.e:2070
4607% [agent1,agent2,weapon,time]%
4608% Happens(Threaten(agent1,agent2,weapon), time) ->
4609% HoldsAt(Holding(agent1,weapon),time) &
4610% ectest/ec_reader_test_ecnet.e:2073
4611% {location}%
4612% HoldsAt(At(agent1,location),time) &
4613% HoldsAt(At(agent2,location),time).
4614 /*
4615exists([Location], (happens(threaten(Agent1, Agent2, Weapon), Time)->holds_at(holding(Agent1, Weapon), Time), holds_at(at(Agent1, Location), Time), holds_at(at(Agent2, Location), Time))).
4616*/
4617.
4618
4619%
4620%
4621% ectest/ec_reader_test_ecnet.e:2077
4622% [agent1,agent2,weapon,time]%
4623% Happens(Threaten(agent1,agent2,weapon), time) ->
4624% Happens(BecomeAngryAt(agent2,agent1),time).
4625 /*
4626happens(threaten(Agent1, Agent2, Weapon), Time) ->
4627 happens(becomeAngryAt(Agent2, Agent1), Time).
4628*/
4629.
4630
4631%
4632%
4633% ectest/ec_reader_test_ecnet.e:2081
4634% [agent1,agent2,weapon,time]%
4635% Initiates(Threaten(agent1,agent2,weapon),
4636% ThreatenedBy(agent2,agent1),
4637% time).
4638 /*
4639.
4640*/
4641.
4642
4643%
4644%
4645% ectest/ec_reader_test_ecnet.e:2086
4646% [agent1,agent2,time]%
4647% Terminates(ReleaseFromThreat(agent1,agent2),
4648% ThreatenedBy(agent2,agent1),
4649% time).
4650 /*
4651.
4652*/
4653.
4654
4655%
4656%
4657% event Order(agent,agent,physobj)
4658 /*
4659.
4660*/
4661.
4662
4663% ectest/ec_reader_test_ecnet.e:2092
4664%
4665% fluent KnowOrder(agent,agent,physobj)
4666 /*
4667.
4668*/
4669.
4670
4671%
4672% ectest/ec_reader_test_ecnet.e:2095
4673% [agent1,agent2,physobj,time]%
4674% Initiates(Order(agent1,agent2,physobj),
4675% KnowOrder(agent2,agent1,physobj),
4676% time).
4677 /*
4678.
4679*/
4680.
4681
4682%
4683%
4684% ectest/ec_reader_test_ecnet.e:2100
4685% [agent1,agent2,physobj,time]%
4686% Happens(Order(agent1,agent2,physobj),time) ->
4687% ectest/ec_reader_test_ecnet.e:2102
4688% {location}%
4689% HoldsAt(At(agent1,location),time) &
4690% HoldsAt(At(agent2,location),time).
4691 /*
4692exists([Location], (happens(order(Agent1, Agent2, Physobj), Time)->holds_at(at(Agent1, Location), Time), holds_at(at(Agent2, Location), Time))).
4693*/
4694.
4695
4696%
4697%
4698% event Request(agent,agent,physobj)
4699 /*
4700.
4701*/
4702.
4703
4704%
4705% ectest/ec_reader_test_ecnet.e:2108
4706% fluent KnowRequest(agent,agent,physobj)
4707 /*
4708.
4709*/
4710.
4711
4712%
4713% ectest/ec_reader_test_ecnet.e:2110
4714% [agent1,agent2,physobj,time]%
4715% Initiates(Request(agent1,agent2,physobj),
4716% KnowRequest(agent2,agent1,physobj),
4717% time).
4718 /*
4719.
4720*/
4721.
4722
4723%
4724%
4725% ectest/ec_reader_test_ecnet.e:2115
4726% [agent1,agent2,physobj,time]%
4727% Happens(Request(agent1,agent2,physobj),time) ->
4728% ectest/ec_reader_test_ecnet.e:2117
4729% {location}%
4730% HoldsAt(At(agent1,location),time) &
4731% HoldsAt(At(agent2,location),time).
4732 /*
4733exists([Location], (happens(request(Agent1, Agent2, Physobj), Time)->holds_at(at(Agent1, Location), Time), holds_at(at(Agent2, Location), Time))).
4734*/
4735.
4736
4737%
4738%
4739%; End of file.
4740%
4741% ectest/ec_reader_test_ecnet.e:2123
4742%
4743%
4744%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4745%; FILE: ecnet/Sleep.e
4746%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4747%
4748%;
4749%; Copyright (c) 2005 IBM Corporation and others.
4750%; All rights reserved. This program and the accompanying materials
4751%; are made available under the terms of the Common Public License v1.0
4752%; which accompanies this distribution, and is available at
4753%; http://www.eclipse.org/legal/cpl-v10.html
4754%;
4755%; Contributors:
4756%; IBM - Initial implementation
4757%;
4758%; The Sleep representation deals with the activity of sleeping and
4759%; body posture.
4760%; It is similar to the finite automaton representation of sleep
4761%; used in ThoughtTreasure \fullcite[chap. 7]{Mueller:1998}.
4762%;
4763%; @book{Mueller:1998,
4764%; author = "Erik T. Mueller",
4765%; year = "1998",
4766%; title = "Natural Language Processing with \uppercase{T}hought\uppercase{T}reasure",
4767%; address = "New York",
4768%; publisher = "Signiform",
4769%; }
4770%;
4771% ectest/ec_reader_test_ecnet.e:2152
4772%
4773%; sleep
4774%
4775%; agent wakes up.
4776% event WakeUp(agent)
4777 /*
4778.
4779*/
4780.
4781
4782%
4783%; agent gets tired.
4784% ectest/ec_reader_test_ecnet.e:2159
4785% event GetTired(agent)
4786 /*
4787.
4788*/
4789.
4790
4791%
4792%; agent falls asleep.
4793% event FallAsleep(agent)
4794 /*
4795.
4796*/
4797.
4798
4799%
4800%; agent is asleep.
4801% ectest/ec_reader_test_ecnet.e:2165
4802% fluent Sleep0(agent)
4803 /*
4804.
4805*/
4806.
4807
4808%; agent is awake and in bed.
4809% fluent Sleep1(agent)
4810 /*
4811.
4812*/
4813.
4814
4815%; agent is awake, out of bed, and undressed.
4816% fluent Sleep2(agent)
4817 /*
4818.
4819*/
4820.
4821
4822%; agent is awake and dressed.
4823% ectest/ec_reader_test_ecnet.e:2171
4824% fluent Sleep3(agent)
4825 /*
4826.
4827*/
4828.
4829
4830%; agent is tired and dressed.
4831% fluent Sleep4(agent)
4832 /*
4833.
4834*/
4835.
4836
4837%; agent is tired and undressed.
4838% fluent Sleep5(agent)
4839 /*
4840.
4841*/
4842.
4843
4844%; agent is in bed, waiting to fall asleep.
4845% ectest/ec_reader_test_ecnet.e:2177
4846% fluent Sleep6(agent)
4847 /*
4848.
4849*/
4850.
4851
4852%
4853%; At any time, an agent is in one of seven sleep states:
4854% xor Sleep0, Sleep1, Sleep2, Sleep3, Sleep4, Sleep5, Sleep6
4855 /*
4856.
4857*/
4858.
4859
4860%
4861%; constraints
4862% ectest/ec_reader_test_ecnet.e:2183
4863%
4864%; agent is asleep.
4865% fluent Asleep(agent)
4866 /*
4867.
4868*/
4869.
4870
4871%; agent is awake.
4872% fluent Awake(agent)
4873 /*
4874.
4875*/
4876.
4877
4878% noninertial Asleep
4879 /*
4880.
4881*/
4882.
4883
4884% ectest/ec_reader_test_ecnet.e:2189
4885% noninertial Awake
4886 /*
4887.
4888*/
4889.
4890
4891%
4892%; Sleep0 indicates that the agent is asleep:
4893% ectest/ec_reader_test_ecnet.e:2192
4894% [agent,time] % HoldsAt(Asleep(agent),time) <-> HoldsAt(Sleep0(agent),time).
4895 /*
4896holds_at(asleep(Agent), Time) <->
4897 holds_at(sleep0(Agent), Time).
4898*/
4899.
4900.
4901
4902%
4903%
4904%; In all other sleep states, the agent is awake:
4905% ectest/ec_reader_test_ecnet.e:2195
4906% [agent,time]%
4907% HoldsAt(Awake(agent),time) <->
4908% HoldsAt(Sleep1(agent),time) |
4909% HoldsAt(Sleep2(agent),time) |
4910% HoldsAt(Sleep3(agent),time) |
4911% HoldsAt(Sleep4(agent),time) |
4912% HoldsAt(Sleep5(agent),time) |
4913% HoldsAt(Sleep6(agent),time).
4914 /*
4915holds_at(awake(Agent), Time) <->
4916 ( holds_at(sleep1(Agent), Time)
4917 ; holds_at(sleep2(Agent), Time)
4918 ; holds_at(sleep3(Agent), Time)
4919 ; holds_at(sleep4(Agent), Time)
4920 ; holds_at(sleep5(Agent), Time)
4921 ; holds_at(sleep6(Agent), Time)
4922 ).
4923*/
4924.
4925.
4926
4927% ectest/ec_reader_test_ecnet.e:2202
4928%
4929%
4930%; A number of axioms are used to specify the transitions of
4931%; a finite automaton.
4932%;--
4933%
4934%; Waking up causes a transition from Sleep0
4935%; to Sleep1:
4936% ectest/ec_reader_test_ecnet.e:2210
4937% [agent,time] % Terminates(WakeUp(agent),Sleep0(agent),time).
4938 /*
4939.
4940*/
4941.
4942
4943%
4944%
4945% ectest/ec_reader_test_ecnet.e:2212
4946% [agent,time] % Initiates(WakeUp(agent),Sleep1(agent),time).
4947 /*
4948.
4949*/
4950.
4951
4952%
4953%
4954% ectest/ec_reader_test_ecnet.e:2214
4955% [agent,time] % Happens(WakeUp(agent),time) -> HoldsAt(Sleep0(agent),time).
4956 /*
4957happens(wakeUp(Agent), Time) ->
4958 holds_at(sleep0(Agent), Time).
4959*/
4960.
4961
4962%
4963%
4964%;--
4965%
4966%; Getting out of bed causes a transition from Sleep1
4967%; to Sleep2:
4968% ectest/ec_reader_test_ecnet.e:2220
4969% [agent,bed,time] % Terminates(RiseFrom(agent,bed),Sleep1(agent),time).
4970 /*
4971.
4972*/
4973.
4974
4975%
4976%
4977% ectest/ec_reader_test_ecnet.e:2222
4978% [agent,bed,time] % Initiates(RiseFrom(agent,bed),Sleep2(agent),time).
4979 /*
4980.
4981*/
4982.
4983
4984%
4985%
4986% ectest/ec_reader_test_ecnet.e:2224
4987% [agent,bed,time]%
4988% Happens(RiseFrom(agent,bed),time) -> HoldsAt(Sleep1(agent),time).
4989 /*
4990happens(riseFrom(Agent, Bed), Time) ->
4991 holds_at(sleep1(Agent), Time).
4992*/
4993.
4994
4995%
4996%
4997%;--
4998%
4999%; Getting dressed causes a transition from Sleep2
5000%; to Sleep3, the normal state of awakeness:
5001% ectest/ec_reader_test_ecnet.e:2231
5002% [agent,time] % Terminates(GetDressed(agent),Sleep2(agent),time).
5003 /*
5004.
5005*/
5006.
5007
5008%
5009%
5010% ectest/ec_reader_test_ecnet.e:2233
5011% [agent,time] % Initiates(GetDressed(agent),Sleep3(agent),time).
5012 /*
5013.
5014*/
5015.
5016
5017%
5018%
5019% ectest/ec_reader_test_ecnet.e:2235
5020% [agent,time] % Happens(GetDressed(agent),time) -> HoldsAt(Sleep2(agent),time).
5021 /*
5022happens(getDressed(Agent), Time) ->
5023 holds_at(sleep2(Agent), Time).
5024*/
5025.
5026
5027%
5028%
5029%;--
5030%
5031%; Getting tired causes a transition from Sleep3
5032%; to Sleep4:
5033% ectest/ec_reader_test_ecnet.e:2241
5034% [agent,time] % Terminates(GetTired(agent),Sleep3(agent),time).
5035 /*
5036.
5037*/
5038.
5039
5040%
5041%
5042% ectest/ec_reader_test_ecnet.e:2243
5043% [agent,time] % Initiates(GetTired(agent),Sleep4(agent),time).
5044 /*
5045.
5046*/
5047.
5048
5049%
5050%
5051% ectest/ec_reader_test_ecnet.e:2245
5052% [agent,time] % Happens(GetTired(agent),time) -> HoldsAt(Sleep3(agent),time).
5053 /*
5054happens(getTired(Agent), Time) ->
5055 holds_at(sleep3(Agent), Time).
5056*/
5057.
5058
5059%
5060%
5061%;--
5062%
5063%; Getting undressed causes a transition from Sleep4
5064%; to Sleep5:
5065% ectest/ec_reader_test_ecnet.e:2251
5066% [agent,time] % Terminates(GetUndressed(agent),Sleep4(agent),time).
5067 /*
5068.
5069*/
5070.
5071
5072%
5073%
5074% ectest/ec_reader_test_ecnet.e:2253
5075% [agent,time] % Initiates(GetUndressed(agent),Sleep5(agent),time).
5076 /*
5077.
5078*/
5079.
5080
5081%
5082%
5083% ectest/ec_reader_test_ecnet.e:2255
5084% [agent,time] % Happens(GetUndressed(agent),time) -> HoldsAt(Sleep4(agent),time).
5085 /*
5086happens(getUndressed(Agent), Time) ->
5087 holds_at(sleep4(Agent), Time).
5088*/
5089.
5090
5091%
5092%
5093%;--
5094%
5095%; Lying on a bed causes a transition from Sleep5
5096%; to Sleep6:
5097% ectest/ec_reader_test_ecnet.e:2261
5098% [agent,bed,time] % Terminates(LieOn(agent,bed),Sleep5(agent),time).
5099 /*
5100.
5101*/
5102.
5103
5104%
5105%
5106% ectest/ec_reader_test_ecnet.e:2263
5107% [agent,bed,time] % Initiates(LieOn(agent,bed),Sleep6(agent),time).
5108 /*
5109.
5110*/
5111.
5112
5113%
5114%
5115% ectest/ec_reader_test_ecnet.e:2265
5116% [agent,bed,time] % Happens(LieOn(agent,bed),time) -> HoldsAt(Sleep5(agent),time).
5117 /*
5118happens(lieOn(Agent, Bed), Time) ->
5119 holds_at(sleep5(Agent), Time).
5120*/
5121.
5122
5123%
5124%
5125%;--
5126%
5127%; Falling asleep causes a transition from Sleep6
5128%; to Sleep0:
5129% ectest/ec_reader_test_ecnet.e:2271
5130% [agent,time] % Terminates(FallAsleep(agent),Sleep6(agent),time).
5131 /*
5132.
5133*/
5134.
5135
5136%
5137%
5138% ectest/ec_reader_test_ecnet.e:2273
5139% [agent,time] % Initiates(FallAsleep(agent),Sleep0(agent),time).
5140 /*
5141.
5142*/
5143.
5144
5145%
5146%
5147% ectest/ec_reader_test_ecnet.e:2275
5148% [agent,time] % Happens(FallAsleep(agent),time) -> HoldsAt(Sleep6(agent),time).
5149 /*
5150happens(fallAsleep(Agent), Time) ->
5151 holds_at(sleep6(Agent), Time).
5152*/
5153.
5154
5155%
5156%
5157%;--
5158%
5159%; agent acts on being in state Sleep5.
5160% fluent ActOnSleep5(agent)
5161 /*
5162.
5163*/
5164.
5165
5166% ectest/ec_reader_test_ecnet.e:2281
5167% noninertial ActOnSleep5
5168 /*
5169.
5170*/
5171.
5172
5173%
5174%; We reduce the number of models by asserting that
5175%; an agent only acts on being in state Sleep5 while in
5176%; that state:
5177% ectest/ec_reader_test_ecnet.e:2286
5178% [agent,time]%
5179% !HoldsAt(Sleep5(agent),time) ->
5180% !HoldsAt(ActOnSleep5(agent),time).
5181 /*
5182not(holds_at(sleep5(Agent), Time)) ->
5183 not(holds_at(actOnSleep5(Agent), Time)).
5184*/
5185.
5186
5187%
5188%
5189%; Undressed is like IntentionToPlay
5190%; ActOnSleep5 is like ActOnIntentionToPlay
5191% ectest/ec_reader_test_ecnet.e:2292
5192%
5193%; A trigger axiom states that if an agent is in state Sleep5,
5194%; the agent acts on this state, the agent is in a room, and
5195%; a bed is at the room, the agent lies on the bed:
5196% ectest/ec_reader_test_ecnet.e:2296
5197% [agent,room,bed,time]%
5198% HoldsAt(Sleep5(agent),time) &
5199% HoldsAt(ActOnSleep5(agent),time) &
5200% HoldsAt(At(agent,room),time) &
5201% HoldsAt(At(bed,room),time) ->
5202% Happens(LieOn(agent,bed),time).
5203 /*
5204holds_at(sleep5(Agent), Time), holds_at(actOnSleep5(Agent), Time), holds_at(at(Agent, Room), Time), holds_at(at(Bed, Room), Time) ->
5205 happens(lieOn(Agent, Bed), Time).
5206*/
5207.
5208
5209%
5210% ectest/ec_reader_test_ecnet.e:2302
5211%
5212%; A precondition axiom states that for
5213%; an agent to lie on a bed,
5214%; the agent must be in state Sleep5,
5215%; the agent must act on this state, and
5216%; there must be a room such that
5217%; the agent is in the room and the bed is in the room:
5218% ectest/ec_reader_test_ecnet.e:2309
5219% [agent,bed,time]%
5220% Happens(LieOn(agent,bed),time) ->
5221% HoldsAt(Sleep5(agent),time) &
5222% HoldsAt(ActOnSleep5(agent),time) &
5223% ectest/ec_reader_test_ecnet.e:2313
5224% {room}%
5225% HoldsAt(At(agent,room),time) &
5226% HoldsAt(At(bed,room),time).
5227 /*
5228exists([Room], (happens(lieOn(Agent, Bed), Time)->holds_at(sleep5(Agent), Time), holds_at(actOnSleep5(Agent), Time), holds_at(at(Agent, Room), Time), holds_at(at(Bed, Room), Time))).
5229*/
5230.
5231
5232%
5233%
5234%; (body) posture
5235%
5236%; agent lies on physobj.
5237% ectest/ec_reader_test_ecnet.e:2320
5238% event LieOn(agent,physobj)
5239 /*
5240.
5241*/
5242.
5243
5244%
5245%; agent sits on physobj.
5246% event SitOn(agent,physobj)
5247 /*
5248.
5249*/
5250.
5251
5252%
5253% ectest/ec_reader_test_ecnet.e:2325
5254% [agent,physobj,time]%
5255% Happens(SitOn(agent,physobj),time) ->
5256% ectest/ec_reader_test_ecnet.e:2327
5257% {location}%
5258% HoldsAt(At(agent,location),time) &
5259% HoldsAt(At(physobj,location),time).
5260 /*
5261exists([Location], (happens(sitOn(Agent, Physobj), Time)->holds_at(at(Agent, Location), Time), holds_at(at(Physobj, Location), Time))).
5262*/
5263.
5264
5265%
5266%
5267%; agent rises from physobj.
5268% event RiseFrom(agent,physobj)
5269 /*
5270.
5271*/
5272.
5273
5274% ectest/ec_reader_test_ecnet.e:2333
5275%
5276%; agent is lying on physobj.
5277% fluent LyingOn(agent,physobj)
5278 /*
5279.
5280*/
5281.
5282
5283%; agent is sitting on physobj.
5284% fluent SittingOn(agent,physobj)
5285 /*
5286.
5287*/
5288.
5289
5290%; agent is standing.
5291% ectest/ec_reader_test_ecnet.e:2339
5292% fluent Standing(agent)
5293 /*
5294.
5295*/
5296.
5297
5298%
5299%; agent is lying down.
5300% fluent Lying(agent)
5301 /*
5302.
5303*/
5304.
5305
5306%; agent is sitting.
5307% fluent Sitting(agent)
5308 /*
5309.
5310*/
5311.
5312
5313% ectest/ec_reader_test_ecnet.e:2345
5314% noninertial Lying
5315 /*
5316.
5317*/
5318.
5319
5320% noninertial Sitting
5321 /*
5322.
5323*/
5324.
5325
5326%
5327%; At any time, an agent is either lying, sitting, or standing:
5328% xor Lying, Sitting, Standing
5329 /*
5330.
5331*/
5332.
5333
5334%
5335% ectest/ec_reader_test_ecnet.e:2351
5336% [agent,physobj,time]%
5337% HoldsAt(LyingOn(agent,physobj),time) ->
5338% HoldsAt(Lying(agent),time).
5339 /*
5340holds_at(lyingOn(Agent, Physobj), Time) ->
5341 holds_at(lying(Agent), Time).
5342*/
5343.
5344
5345%
5346%
5347% ectest/ec_reader_test_ecnet.e:2355
5348% [agent,physobj,time]%
5349% HoldsAt(SittingOn(agent,physobj),time) ->
5350% HoldsAt(Sitting(agent),time).
5351 /*
5352holds_at(sittingOn(Agent, Physobj), Time) ->
5353 holds_at(sitting(Agent), Time).
5354*/
5355.
5356
5357%
5358%
5359%; State constraints represent that an agent can lie or sit
5360%; on at most one object at a time:
5361% ectest/ec_reader_test_ecnet.e:2361
5362% [agent,physobj1,physobj2,time]%
5363% HoldsAt(LyingOn(agent,physobj1),time) &
5364% HoldsAt(LyingOn(agent,physobj2),time) ->
5365% physobj1=physobj2.
5366 /*
5367holds_at(lyingOn(Agent, Physobj1), Time), holds_at(lyingOn(Agent, Physobj2), Time) ->
5368 Physobj1=Physobj2.
5369*/
5370.
5371
5372%
5373%
5374% ectest/ec_reader_test_ecnet.e:2366
5375% [agent,physobj1,physobj2,time]%
5376% HoldsAt(SittingOn(agent,physobj1),time) &
5377% HoldsAt(SittingOn(agent,physobj2),time) ->
5378% physobj1=physobj2.
5379 /*
5380holds_at(sittingOn(Agent, Physobj1), Time), holds_at(sittingOn(Agent, Physobj2), Time) ->
5381 Physobj1=Physobj2.
5382*/
5383.
5384
5385%
5386%
5387%; An effect axiom states that if an agent is standing and
5388%; lies on a physical object, the agent will be lying on
5389%; the physical object:
5390% ectest/ec_reader_test_ecnet.e:2374
5391% [agent,physobj,time]%
5392% HoldsAt(Standing(agent),time) ->
5393% Initiates(LieOn(agent,physobj),
5394% LyingOn(agent,physobj),
5395% time).
5396 /*
5397holds_at(standing(Agent), Time) ->
5398 initiates(lieOn(Agent, Physobj),
5399 lyingOn(Agent, Physobj),
5400 Time).
5401*/
5402.
5403
5404%
5405%
5406%; An effect axiom states that if an agent
5407%; lies on a physical object, the agent will no longer
5408%; be standing:
5409% ectest/ec_reader_test_ecnet.e:2383
5410% [agent,physobj,time]%
5411% Terminates(LieOn(agent,physobj),
5412% Standing(agent),
5413% time).
5414 /*
5415.
5416*/
5417.
5418
5419%
5420%
5421%; An effect axiom states that if an agent is standing and
5422%; sits on a physical object, the agent will be sitting on
5423%; the physical object:
5424% ectest/ec_reader_test_ecnet.e:2391
5425% [agent,physobj,time]%
5426% HoldsAt(Standing(agent),time) ->
5427% Initiates(SitOn(agent,physobj),
5428% SittingOn(agent,physobj),
5429% time).
5430 /*
5431holds_at(standing(Agent), Time) ->
5432 initiates(sitOn(Agent, Physobj),
5433 sittingOn(Agent, Physobj),
5434 Time).
5435*/
5436.
5437
5438%
5439%
5440%; An effect axiom states that if an agent
5441%; sits on a physical object, the agent will no longer
5442%; be standing:
5443% ectest/ec_reader_test_ecnet.e:2400
5444% [agent,physobj,time]%
5445% Terminates(SitOn(agent,physobj),
5446% Standing(agent),
5447% time).
5448 /*
5449.
5450*/
5451.
5452
5453%
5454%
5455%; An effect axiom states that if an agent
5456%; is sitting or lying on a physical object and
5457%; the agent rises from the physical object,
5458%; the agent will be standing:
5459% ectest/ec_reader_test_ecnet.e:2409
5460% [agent,physobj,time]%
5461% (HoldsAt(SittingOn(agent,physobj),time) |
5462% HoldsAt(LyingOn(agent,physobj),time)) ->
5463% Initiates(RiseFrom(agent,physobj),
5464% Standing(agent),
5465% time).
5466 /*
5467holds_at(sittingOn(Agent, Physobj), Time);holds_at(lyingOn(Agent, Physobj), Time) ->
5468 initiates(riseFrom(Agent, Physobj),
5469 standing(Agent),
5470 Time).
5471*/
5472.
5473
5474%
5475% ectest/ec_reader_test_ecnet.e:2415
5476%
5477%; An effect axiom states that if an agent is sitting on
5478%; a physical object and the agent rises from the physical
5479%; object, the agent will no longer be sitting on the
5480%; physical object:
5481% ectest/ec_reader_test_ecnet.e:2420
5482% [agent,physobj,time]%
5483% HoldsAt(SittingOn(agent,physobj),time) ->
5484% Terminates(RiseFrom(agent,physobj),
5485% SittingOn(agent,physobj),
5486% time).
5487 /*
5488holds_at(sittingOn(Agent, Physobj), Time) ->
5489 terminates(riseFrom(Agent, Physobj),
5490 sittingOn(Agent, Physobj),
5491 Time).
5492*/
5493.
5494
5495%
5496%
5497%; An effect axiom states that if an agent is lying on
5498%; a physical object and the agent rises from the physical
5499%; object, the agent will no longer be lying on the
5500%; physical object:
5501% ectest/ec_reader_test_ecnet.e:2430
5502% [agent,physobj,time]%
5503% HoldsAt(LyingOn(agent,physobj),time) ->
5504% Terminates(RiseFrom(agent,physobj),
5505% LyingOn(agent,physobj),
5506% time).
5507 /*
5508holds_at(lyingOn(Agent, Physobj), Time) ->
5509 terminates(riseFrom(Agent, Physobj),
5510 lyingOn(Agent, Physobj),
5511 Time).
5512*/
5513.
5514
5515%
5516%
5517%; dressing
5518% ectest/ec_reader_test_ecnet.e:2437
5519%
5520%; agent gets undressed.
5521% event GetDressed(agent)
5522 /*
5523.
5524*/
5525.
5526
5527%; agent gets dressed.
5528% event GetUndressed(agent)
5529 /*
5530.
5531*/
5532.
5533
5534%; agent is dressed.
5535% ectest/ec_reader_test_ecnet.e:2443
5536% fluent Dressed(agent)
5537 /*
5538.
5539*/
5540.
5541
5542%
5543%; Effect axioms deal with getting dressed and undressed:
5544% ectest/ec_reader_test_ecnet.e:2446
5545% [agent,time] % Initiates(GetDressed(agent),Dressed(agent),time).
5546 /*
5547.
5548*/
5549.
5550
5551%
5552% ectest/ec_reader_test_ecnet.e:2447
5553% [agent,time] % Terminates(GetUndressed(agent),Dressed(agent),time).
5554 /*
5555.
5556*/
5557.
5558
5559%
5560%
5561%; End of file.
5562%
5563%
5564%
5565%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5566%; FILE: ecnet/Sleeping.e
5567%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5568% ectest/ec_reader_test_ecnet.e:2456
5569%
5570%;
5571%; Copyright (c) 2005 IBM Corporation and others.
5572%; All rights reserved. This program and the accompanying materials
5573%; are made available under the terms of the Common Public License v1.0
5574%; which accompanies this distribution, and is available at
5575%; http://www.eclipse.org/legal/cpl-v10.html
5576%;
5577%; Contributors:
5578%; IBM - Initial implementation
5579%;
5580%; @article{Mueller:2004c,
5581%; author = "Erik T. Mueller",
5582%; year = "2004",
5583%; title = "Understanding script-based stories using commonsense reasoning",
5584%; journal = "Cognitive Systems Research",
5585%; volume = "5",
5586%; number = "4",
5587%; pages = "307--340",
5588%; }
5589%;
5590% ectest/ec_reader_test_ecnet.e:2477
5591%
5592% option modeldiff on
5593 /*
5594.
5595*/
5596
5597%
5598% ignore Love, ThreatenedBy
5599 /*
5600.
5601*/
5602.
5603
5604 /*
5605.
5606*/
5607.
5608
5609% ignore LookOutOnto, Floor, BuildingOf, SkyOf, GroundOf
5610 /*
5611.
5612*/
5613.
5614
5615 /*
5616.
5617*/
5618.
5619
5620 /*
5621.
5622*/
5623.
5624
5625 /*
5626.
5627*/
5628.
5629
5630 /*
5631.
5632*/
5633.
5634
5635% ignore Inside, Near
5636 /*
5637.
5638*/
5639.
5640
5641 /*
5642.
5643*/
5644.
5645
5646% ectest/ec_reader_test_ecnet.e:2483
5647% ignore See
5648 /*
5649.
5650*/
5651.
5652
5653%
5654% ignore ActOnSleep5
5655 /*
5656.
5657*/
5658.
5659
5660%
5661% option renaming off
5662 /*
5663.
5664*/
5665
5666%
5667% ectest/ec_reader_test_ecnet.e:2489
5668% load foundations/Root.e
5669% load foundations/EC.e
5670% load answers/Mueller2003/Ontology.e
5671 /*
5672.
5673*/
5674.
5675
5676% load answers/Mueller2004c/RTSpaceM.e
5677 /*
5678.
5679*/
5680.
5681
5682% load answers/Mueller2004c/OTSpaceM.e
5683 /*
5684.
5685*/
5686.
5687
5688% load answers/Mueller2004c/Cognition.e
5689 /*
5690.
5691*/
5692.
5693
5694% ectest/ec_reader_test_ecnet.e:2495
5695% load answers/Mueller2003/Sleep.e
5696 /*
5697.
5698*/
5699.
5700
5701%
5702% door Door1
5703 /*
5704.
5705*/
5706.
5707.
5708
5709%
5710% room Room0
5711 /*
5712.
5713*/
5714.
5715.
5716
5717%
5718% ectest/ec_reader_test_ecnet.e:2501
5719% room Room1
5720 /*
5721.
5722*/
5723.
5724.
5725
5726%
5727% Side1(Door1)=Room0.
5728 /*
5729.
5730*/
5731.
5732
5733%
5734% Side2(Door1)=Room1.
5735 /*
5736.
5737*/
5738.
5739
5740%
5741%
5742% agent Sleeper1
5743 /*
5744.
5745*/
5746.
5747.
5748
5749% ectest/ec_reader_test_ecnet.e:2507
5750%
5751% bed Bed1
5752 /*
5753.
5754*/
5755.
5756.
5757
5758%
5759% outside Outside1
5760 /*
5761.
5762*/
5763.
5764.
5765
5766%
5767%; initial state
5768% ectest/ec_reader_test_ecnet.e:2513
5769% [agent,object] % !HoldsAt(Holding(agent,object),0).
5770 /*
5771.
5772*/
5773.
5774
5775%
5776% ectest/ec_reader_test_ecnet.e:2514
5777% [agent,physobj] % !HoldsAt(SittingOn(agent,physobj),0).
5778 /*
5779.
5780*/
5781.
5782
5783%
5784% ectest/ec_reader_test_ecnet.e:2515
5785% [agent,physobj] % !HoldsAt(LyingOn(agent,physobj),0).
5786 /*
5787.
5788*/
5789.
5790
5791%
5792% HoldsAt(Dressed(Sleeper1),0).
5793 /*
5794.
5795*/
5796.
5797
5798%
5799% HoldsAt(Awake(Sleeper1),0).
5800 /*
5801.
5802*/
5803.
5804
5805%
5806% HoldsAt(Sleep3(Sleeper1),0).
5807 /*
5808.
5809*/
5810.
5811
5812%
5813% HoldsAt(Standing(Sleeper1),0).
5814 /*
5815.
5816*/
5817.
5818
5819%
5820% HoldsAt(DoorUnlocked(Door1),0).
5821 /*
5822.
5823*/
5824.
5825
5826%
5827% ectest/ec_reader_test_ecnet.e:2521
5828% HoldsAt(DoorIsOpen(Door1),0).
5829 /*
5830.
5831*/
5832.
5833
5834%
5835% HoldsAt(At(Sleeper1,Room0),0).
5836 /*
5837.
5838*/
5839.
5840
5841%
5842% HoldsAt(At(Bed1,Room1),0).
5843 /*
5844.
5845*/
5846.
5847
5848%
5849%
5850%; narrative
5851% Happens(GetTired(Sleeper1),0).
5852 /*
5853.
5854*/
5855.
5856
5857%
5858% ectest/ec_reader_test_ecnet.e:2527
5859% Happens(WalkThroughDoor12(Sleeper1,Door1),1).
5860 /*
5861.
5862*/
5863.
5864
5865%
5866% Happens(GetUndressed(Sleeper1),2).
5867 /*
5868.
5869*/
5870.
5871
5872%
5873% Happens(LieOn(Sleeper1,Bed1),3).
5874 /*
5875.
5876*/
5877.
5878
5879%
5880% Happens(FallAsleep(Sleeper1),4).
5881 /*
5882.
5883*/
5884.
5885
5886%
5887% Happens(Dream(Sleeper1),5).
5888 /*
5889.
5890*/
5891.
5892
5893%
5894% Happens(WakeUp(Sleeper1),6).
5895 /*
5896.
5897*/
5898.
5899
5900%
5901% ectest/ec_reader_test_ecnet.e:2533
5902% Happens(RiseFrom(Sleeper1,Bed1),7).
5903 /*
5904.
5905*/
5906.
5907
5908%
5909% Happens(GetDressed(Sleeper1),8).
5910 /*
5911.
5912*/
5913.
5914
5915%
5916% Happens(WalkThroughDoor21(Sleeper1,Door1),9).
5917 /*
5918.
5919*/
5920.
5921
5922%
5923%
5924% range time 0 10
5925 /*
5926.
5927*/
5928.
5929
5930% range offset 0 0
5931 /*
5932.
5933*/
5934.
5935
5936% ectest/ec_reader_test_ecnet.e:2539
5937% range diameter 0 0
5938 /*
5939.
5940*/
5941.
5942
5943%
5944% completion Happens
5945 /*
5946.
5947*/
5948.
5949
5950%
5951%; End of file.
5952%
5953% ectest/ec_reader_test_ecnet.e:2545
5954%
5955%
5956%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5957%; FILE: ecnet/Rest.e
5958%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5959%
5960%;
5961%; Copyright (c) 2005 IBM Corporation and others.
5962%; All rights reserved. This program and the accompanying materials
5963%; are made available under the terms of the Common Public License v1.0
5964%; which accompanies this distribution, and is available at
5965%; http://www.eclipse.org/legal/cpl-v10.html
5966%;
5967%; Contributors:
5968%; IBM - Initial implementation
5969%;
5970%; @article{Mueller:InPress,
5971%; author = "Erik T. Mueller",
5972%; year = "in press",
5973%; title = "Modelling space and time in narratives about restaurants",
5974%; journal = "Literary and Linguistic Computing",
5975%; }
5976%;
5977% ectest/ec_reader_test_ecnet.e:2568
5978%
5979% option renaming off
5980 /*
5981.
5982*/
5983
5984% option encoding 3
5985 /*
5986.
5987*/
5988
5989%
5990% load foundations/Root.e
5991% load foundations/EC.e
5992% ectest/ec_reader_test_ecnet.e:2574
5993% load answers/Mueller2003/Ontology.e
5994 /*
5995.
5996*/
5997.
5998
5999% load answers/MuellerInPress/RepRest.e
6000 /*
6001.
6002*/
6003.
6004
6005%
6006% door MainEntrance1
6007 /*
6008.
6009*/
6010.
6011.
6012
6013%
6014%; room-scale topological space
6015% ectest/ec_reader_test_ecnet.e:2580
6016% outside Street1
6017 /*
6018.
6019*/
6020.
6021.
6022
6023% room DiningRoom1
6024 /*
6025.
6026*/
6027.
6028.
6029
6030% door KitchenDoor1
6031 /*
6032.
6033*/
6034.
6035.
6036
6037% room Kitchen1
6038 /*
6039.
6040*/
6041.
6042.
6043
6044% Side1(MainEntrance1)=Street1.
6045 /*
6046.
6047*/
6048.
6049
6050%
6051% Side2(MainEntrance1)=DiningRoom1.
6052 /*
6053.
6054*/
6055.
6056
6057%
6058% ectest/ec_reader_test_ecnet.e:2586
6059% Side1(KitchenDoor1)=DiningRoom1.
6060 /*
6061.
6062*/
6063.
6064
6065%
6066% Side2(KitchenDoor1)=Kitchen1.
6067 /*
6068.
6069*/
6070.
6071
6072%
6073%
6074% agent Customer1
6075 /*
6076.
6077*/
6078.
6079.
6080
6081% menu Menu1
6082 /*
6083.
6084*/
6085.
6086.
6087
6088% chair Chair1
6089 /*
6090.
6091*/
6092.
6093.
6094
6095% ectest/ec_reader_test_ecnet.e:2592
6096% food Food1
6097 /*
6098.
6099*/
6100.
6101.
6102
6103% HoldsAt(At(Customer1,Street1),0).
6104 /*
6105.
6106*/
6107.
6108
6109%
6110% HoldsAt(Hungry(Customer1),0).
6111 /*
6112.
6113*/
6114.
6115
6116%
6117% HoldsAt(At(Chair1,DiningRoom1),0).
6118 /*
6119.
6120*/
6121.
6122
6123%
6124% HoldsAt(At(Menu1,DiningRoom1),0).
6125 /*
6126.
6127*/
6128.
6129
6130%
6131% HoldsAt(On(Menu1,Table1),0).
6132 /*
6133.
6134*/
6135.
6136
6137%
6138% ectest/ec_reader_test_ecnet.e:2598
6139% HoldsAt(At(Food1,Kitchen1),0).
6140 /*
6141.
6142*/
6143.
6144
6145%
6146%
6147% waiter Waiter1
6148 /*
6149.
6150*/
6151.
6152.
6153
6154% cook Cook1
6155 /*
6156.
6157*/
6158.
6159.
6160
6161%
6162%; props
6163% ectest/ec_reader_test_ecnet.e:2604
6164% table Table1
6165 /*
6166.
6167*/
6168.
6169.
6170
6171% bill Bill1
6172 /*
6173.
6174*/
6175.
6176.
6177
6178%
6179%; restaurant
6180% restaurant Restaurant1
6181 /*
6182.
6183*/
6184.
6185.
6186
6187% CookOf(Restaurant1)=Cook1.
6188 /*
6189.
6190*/
6191.
6192
6193%
6194% ectest/ec_reader_test_ecnet.e:2610
6195% TableOf(Restaurant1)=Table1.
6196 /*
6197.
6198*/
6199.
6200
6201%
6202% WaiterOf(Restaurant1)=Waiter1.
6203 /*
6204.
6205*/
6206.
6207
6208%
6209% KitchenDoorOf(Restaurant1)=KitchenDoor1.
6210 /*
6211.
6212*/
6213.
6214
6215%
6216% BillOf(Restaurant1)=Bill1.
6217 /*
6218.
6219*/
6220.
6221
6222%
6223%
6224%; prune
6225% ectest/ec_reader_test_ecnet.e:2616
6226% sort ona, onb
6227 /*
6228.
6229*/
6230.
6231
6232 /*
6233.
6234*/
6235.
6236
6237% fluent! On(ona,onb)
6238 /*
6239.
6240*/
6241.
6242
6243% event! PlaceOn(agent,ona,onb)
6244 /*
6245.
6246*/
6247.
6248
6249% event! TakeOffOf(agent,ona,onb)
6250 /*
6251.
6252*/
6253.
6254
6255%
6256% sort ordera, orderb, orderc
6257 /*
6258.
6259*/
6260.
6261
6262 /*
6263.
6264*/
6265.
6266
6267 /*
6268.
6269*/
6270.
6271
6272% ectest/ec_reader_test_ecnet.e:2622
6273% event! Order(ordera,orderb,orderc)
6274 /*
6275.
6276*/
6277.
6278
6279% fluent! KnowOrder(orderb,ordera,orderc)
6280 /*
6281.
6282*/
6283.
6284
6285%
6286% sort requesta, requestb, requestc
6287 /*
6288.
6289*/
6290.
6291
6292 /*
6293.
6294*/
6295.
6296
6297 /*
6298.
6299*/
6300.
6301
6302% event! Request(requesta,requestb,requestc)
6303 /*
6304.
6305*/
6306.
6307
6308% fluent! KnowRequest(requestb,requesta,requestc)
6309 /*
6310.
6311*/
6312.
6313
6314% ectest/ec_reader_test_ecnet.e:2628
6315%
6316% sort holda, holdb, holdc
6317 /*
6318.
6319*/
6320.
6321
6322 /*
6323.
6324*/
6325.
6326
6327 /*
6328.
6329*/
6330.
6331
6332% event! TakeOffOf(holda,holdb,holdc)
6333 /*
6334.
6335*/
6336.
6337
6338% event! PickUp(holda,holdb)
6339 /*
6340.
6341*/
6342.
6343
6344% event! LetGoOf(holda,holdb)
6345 /*
6346.
6347*/
6348.
6349
6350% event! Hold(holda,holdb)
6351 /*
6352.
6353*/
6354.
6355
6356% ectest/ec_reader_test_ecnet.e:2634
6357% fluent! Holding(holda,holdb)
6358 /*
6359.
6360*/
6361.
6362
6363%
6364% sort sita, sitb
6365 /*
6366.
6367*/
6368.
6369
6370 /*
6371.
6372*/
6373.
6374
6375% event! LieOn(sita,sitb)
6376 /*
6377.
6378*/
6379.
6380
6381% event! SitOn(sita,sitb)
6382 /*
6383.
6384*/
6385.
6386
6387% event! RiseFrom(sita,sitb)
6388 /*
6389.
6390*/
6391.
6392
6393% ectest/ec_reader_test_ecnet.e:2640
6394% fluent! LyingOn(sita,sitb)
6395 /*
6396.
6397*/
6398.
6399
6400% fluent! SittingOn(sita,sitb)
6401 /*
6402.
6403*/
6404.
6405
6406%
6407% sort greeta, greetb
6408 /*
6409.
6410*/
6411.
6412
6413 /*
6414.
6415*/
6416.
6417
6418% event! Greet(greeta,greetb)
6419 /*
6420.
6421*/
6422.
6423
6424%
6425% ectest/ec_reader_test_ecnet.e:2646
6426% ona! Menu1, Food1, Bill1
6427 /*
6428.
6429*/
6430.
6431.
6432
6433 /*
6434.
6435*/
6436.
6437.
6438
6439 /*
6440.
6441*/
6442.
6443.
6444
6445% onb! Table1
6446 /*
6447.
6448*/
6449.
6450.
6451
6452% ordera! Customer1, Waiter1
6453 /*
6454.
6455*/
6456.
6457.
6458
6459 /*
6460.
6461*/
6462.
6463.
6464
6465% orderb! Waiter1, Cook1
6466 /*
6467.
6468*/
6469.
6470.
6471
6472 /*
6473.
6474*/
6475.
6476.
6477
6478% orderc! Food1
6479 /*
6480.
6481*/
6482.
6483.
6484
6485% requesta! Customer1
6486 /*
6487.
6488*/
6489.
6490.
6491
6492% ectest/ec_reader_test_ecnet.e:2652
6493% requestb! Waiter1
6494 /*
6495.
6496*/
6497.
6498.
6499
6500% requestc! Bill1
6501 /*
6502.
6503*/
6504.
6505.
6506
6507% holda! Customer1, Waiter1
6508 /*
6509.
6510*/
6511.
6512.
6513
6514 /*
6515.
6516*/
6517.
6518.
6519
6520% holdb! Menu1, Food1, Bill1
6521 /*
6522.
6523*/
6524.
6525.
6526
6527 /*
6528.
6529*/
6530.
6531.
6532
6533 /*
6534.
6535*/
6536.
6537.
6538
6539% holdc! Table1
6540 /*
6541.
6542*/
6543.
6544.
6545
6546% sita! Customer1
6547 /*
6548.
6549*/
6550.
6551.
6552
6553% ectest/ec_reader_test_ecnet.e:2658
6554% sitb! Chair1
6555 /*
6556.
6557*/
6558.
6559.
6560
6561% greeta! Customer1, Waiter1
6562 /*
6563.
6564*/
6565.
6566.
6567
6568 /*
6569.
6570*/
6571.
6572.
6573
6574% greetb! Customer1, Waiter1
6575 /*
6576.
6577*/
6578.
6579.
6580
6581 /*
6582.
6583*/
6584.
6585.
6586
6587%
6588%; initial situation
6589% HoldsAt(At(Waiter1,DiningRoom1),0).
6590 /*
6591.
6592*/
6593.
6594
6595%
6596% ectest/ec_reader_test_ecnet.e:2664
6597% HoldsAt(At(Cook1,Kitchen1),0).
6598 /*
6599.
6600*/
6601.
6602
6603%
6604% HoldsAt(At(Table1,DiningRoom1),0).
6605 /*
6606.
6607*/
6608.
6609
6610%
6611% !HoldsAt(On(Bill1,Table1),0).
6612 /*
6613.
6614*/
6615.
6616
6617%
6618% HoldsAt(At(Bill1,DiningRoom1),0).
6619 /*
6620.
6621*/
6622.
6623
6624%
6625% ectest/ec_reader_test_ecnet.e:2668
6626% [agent] % HoldsAt(Standing(agent),0).
6627 /*
6628.
6629*/
6630.
6631
6632%
6633% ectest/ec_reader_test_ecnet.e:2669
6634% [agent,object] % !HoldsAt(Holding(agent,object),0).
6635 /*
6636.
6637*/
6638.
6639
6640%
6641% ectest/ec_reader_test_ecnet.e:2670
6642% [agent1,agent2,physobj] % !HoldsAt(KnowOrder(agent1,agent2,physobj),0).
6643 /*
6644.
6645*/
6646.
6647
6648%
6649% ectest/ec_reader_test_ecnet.e:2671
6650% [agent1,agent2,physobj] % !HoldsAt(KnowRequest(agent1,agent2,physobj),0).
6651 /*
6652.
6653*/
6654.
6655
6656%
6657% HoldsAt(BeWaiter0(Waiter1),0).
6658 /*
6659.
6660*/
6661.
6662
6663%
6664% HoldsAt(BeCook0(Cook1),0).
6665 /*
6666.
6667*/
6668.
6669
6670%
6671% ectest/ec_reader_test_ecnet.e:2674
6672% [food] % !HoldsAt(FoodPrepared(food),0).
6673 /*
6674.
6675*/
6676.
6677
6678%
6679% !HoldsAt(Hungry(Cook1),0).
6680 /*
6681.
6682*/
6683.
6684
6685%
6686% !HoldsAt(Hungry(Waiter1),0).
6687 /*
6688.
6689*/
6690.
6691
6692%
6693%
6694% Happens(WalkThroughDoor12(Customer1,MainEntrance1),0).
6695 /*
6696.
6697*/
6698.
6699
6700%
6701% Happens(Greet(Waiter1,Customer1),1).
6702 /*
6703.
6704*/
6705.
6706
6707%
6708% ectest/ec_reader_test_ecnet.e:2680
6709% Happens(SitOn(Customer1,Chair1),2).
6710 /*
6711.
6712*/
6713.
6714
6715%
6716% Happens(TakeOffOf(Customer1,Menu1,Table1),3).
6717 /*
6718.
6719*/
6720.
6721
6722%
6723% Happens(Order(Customer1,Waiter1,Food1),4).
6724 /*
6725.
6726*/
6727.
6728
6729%
6730% Happens(PlaceOn(Customer1,Menu1,Table1),5).
6731 /*
6732.
6733*/
6734.
6735
6736%
6737% Happens(Eat(Customer1,Food1),11).
6738 /*
6739.
6740*/
6741.
6742
6743%
6744% Happens(Request(Customer1,Waiter1,Bill1),12).
6745 /*
6746.
6747*/
6748.
6749
6750%
6751% ectest/ec_reader_test_ecnet.e:2686
6752% Happens(Pay(Customer1,Waiter1),15).
6753 /*
6754.
6755*/
6756.
6757
6758%
6759% Happens(Tip(Customer1,Waiter1),15).
6760 /*
6761.
6762*/
6763.
6764
6765%
6766% Happens(RiseFrom(Customer1,Chair1),16).
6767 /*
6768.
6769*/
6770.
6771
6772%
6773% Happens(SayGoodbye(Customer1,Waiter1),17).
6774 /*
6775.
6776*/
6777.
6778
6779%
6780% Happens(WalkThroughDoor21(Customer1,MainEntrance1),18).
6781 /*
6782.
6783*/
6784.
6785
6786%
6787%
6788% ectest/ec_reader_test_ecnet.e:2692
6789% range time 0 19
6790 /*
6791.
6792*/
6793.
6794
6795% range offset 0 0
6796 /*
6797.
6798*/
6799.
6800
6801% range diameter 0 0
6802 /*
6803.
6804*/
6805.
6806
6807%
6808% completion Happens
6809 /*
6810.
6811*/
6812.
6813
6814%
6815%; End of file.
6816% ectest/ec_reader_test_ecnet.e:2699
6817%
6818%
6819%
6820%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6821%; FILE: ecnet/RepRest.e
6822%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6823% ectest/ec_reader_test_ecnet.e:2705
6824%
6825%;
6826%; Copyright (c) 2005 IBM Corporation and others.
6827%; All rights reserved. This program and the accompanying materials
6828%; are made available under the terms of the Common Public License v1.0
6829%; which accompanies this distribution, and is available at
6830%; http://www.eclipse.org/legal/cpl-v10.html
6831%;
6832%; Contributors:
6833%; IBM - Initial implementation
6834%;
6835%; @article{Mueller:InPress,
6836%; author = "Erik T. Mueller",
6837%; year = "in press",
6838%; title = "Modelling space and time in narratives about restaurants",
6839%; journal = "Literary and Linguistic Computing",
6840%; }
6841%;
6842% ectest/ec_reader_test_ecnet.e:2723
6843%
6844%;sort boolean
6845%;sort integer
6846%;reified sort predicate
6847%;reified sort function
6848%;
6849%;sort time: integer
6850%;sort offset: integer
6851%;
6852%;reified sort fluent
6853%;reified sort event
6854%;
6855%;predicate Happens(event,time)
6856%;predicate HoldsAt(fluent,time)
6857%;predicate ReleasedAt(fluent,time)
6858%;predicate Initiates(event,fluent,time)
6859%;predicate Terminates(event,fluent,time)
6860%;predicate Releases(event,fluent,time)
6861%;
6862%;sort diameter: integer
6863%;
6864%;sort object
6865%;
6866%;sort agent: object
6867%;
6868%;sort physobj: object
6869%;sort bed: physobj
6870%;sort snowflake: physobj
6871%;sort sky: physobj
6872%;
6873%;sort stuff: physobj
6874%;
6875%;sort surface: physobj
6876%;sort ground: surface
6877%;
6878%;sort snow: stuff
6879%;sort ball
6880%;
6881%;sort food: physobj
6882%;sort fruit: food
6883%;sort orange: fruit
6884%;sort salad: food
6885%;
6886%;sort clothing: physobj
6887%;sort scarf: clothing
6888%;sort hat: clothing
6889%;
6890%;sort vegetablematter: physobj
6891%;sort coal: vegetablematter
6892%;
6893%;sort bodypart: physobj
6894%;sort hand: bodypart
6895%;
6896%;sort papertowels: physobj
6897%;sort device: physobj
6898%;sort electronicdevice: device
6899%;sort lamp: electronicdevice
6900%;
6901%;sort cat: physobj
6902%;
6903%;sort weapon: physobj
6904%;sort gun: weapon
6905%;sort bomb: weapon
6906%;sort bullet: weapon
6907%;
6908%;sort location
6909%;sort room: location, outside: location
6910%;
6911%;sort portal
6912%;sort door: portal, staircase: portal
6913%;sort street: portal
6914%;
6915%;sort building
6916%;
6917%;sort fire: object
6918%;
6919%;sort furniture: physobj
6920%;sort chair: furniture
6921%;sort table: furniture
6922%;
6923%;sort menu: physobj
6924%;sort bill: physobj
6925%;
6926%;sort script
6927%;
6928% ectest/ec_reader_test_ecnet.e:2808
6929% fluent Holding(agent,physobj)
6930 /*
6931.
6932*/
6933.
6934
6935% event PickUp(agent,physobj)
6936 /*
6937.
6938*/
6939.
6940
6941% event LetGoOf(agent,physobj)
6942 /*
6943.
6944*/
6945.
6946
6947%
6948% ectest/ec_reader_test_ecnet.e:2812
6949% [agent,physobj,time]%
6950% Initiates(PickUp(agent,physobj),Holding(agent,physobj),time).
6951 /*
6952.
6953*/
6954.
6955
6956%
6957%
6958% ectest/ec_reader_test_ecnet.e:2815
6959% [agent,physobj,time]%
6960% Happens(PickUp(agent,physobj),time) ->
6961% ectest/ec_reader_test_ecnet.e:2817
6962% {location}%
6963% HoldsAt(At(agent,location),time) &
6964% HoldsAt(At(physobj,location),time).
6965 /*
6966exists([Location], (happens(pickUp(Agent, Physobj), Time)->holds_at(at(Agent, Location), Time), holds_at(at(Physobj, Location), Time))).
6967*/
6968.
6969
6970%
6971%
6972% ectest/ec_reader_test_ecnet.e:2821
6973% [agent,physobj,time]%
6974% Terminates(LetGoOf(agent,physobj),Holding(agent,physobj),time).
6975 /*
6976.
6977*/
6978.
6979
6980%
6981%
6982% ectest/ec_reader_test_ecnet.e:2824
6983% [agent,physobj,time]%
6984% Happens(LetGoOf(agent,physobj),time) ->
6985% HoldsAt(Holding(agent,physobj),time).
6986 /*
6987happens(letGoOf(Agent, Physobj), Time) ->
6988 holds_at(holding(Agent, Physobj), Time).
6989*/
6990.
6991
6992%
6993%
6994% ectest/ec_reader_test_ecnet.e:2828
6995% [agent,physobj,location,time]%
6996% Releases(PickUp(agent,physobj),At(physobj,location),time).
6997 /*
6998.
6999*/
7000.
7001
7002%
7003%
7004% ectest/ec_reader_test_ecnet.e:2831
7005% [agent,physobj,location,time]%
7006% HoldsAt(Holding(agent,physobj),time) &
7007% HoldsAt(At(agent,location),time) ->
7008% HoldsAt(At(physobj,location),time).
7009 /*
7010holds_at(holding(Agent, Physobj), Time), holds_at(at(Agent, Location), Time) ->
7011 holds_at(at(Physobj, Location), Time).
7012*/
7013.
7014
7015%
7016%
7017%;[agent,physobj,location1,location2,time]
7018%;HoldsAt(At(agent,location1),time) &
7019%;location1!=location2 ->
7020%;Terminates(LetGoOf(agent,physobj),At(physobj,location2),time).
7021% ectest/ec_reader_test_ecnet.e:2840
7022%
7023% ectest/ec_reader_test_ecnet.e:2841
7024% [agent,physobj,location,time]%
7025% HoldsAt(At(agent,location),time) ->
7026% Initiates(LetGoOf(agent,physobj),At(physobj,location),time).
7027 /*
7028holds_at(at(Agent, Location), Time) ->
7029 initiates(letGoOf(Agent, Physobj),
7030 at(Physobj, Location),
7031 Time).
7032*/
7033.
7034
7035%
7036%
7037% fluent On(physobj,physobj)
7038 /*
7039.
7040*/
7041.
7042
7043%
7044% ectest/ec_reader_test_ecnet.e:2847
7045% event PlaceOn(agent,physobj,physobj)
7046 /*
7047.
7048*/
7049.
7050
7051%
7052% event TakeOffOf(agent,physobj,physobj)
7053 /*
7054.
7055*/
7056.
7057
7058%
7059% ectest/ec_reader_test_ecnet.e:2851
7060% [physobj1,physobj2,time]%
7061% HoldsAt(On(physobj1,physobj2),time) ->
7062% physobj1!=physobj2.
7063 /*
7064holds_at(on(Physobj1, Physobj2), Time) ->
7065 Physobj1\=Physobj2.
7066*/
7067.
7068
7069%
7070%
7071% ectest/ec_reader_test_ecnet.e:2855
7072% [physobj1,physobj2,time]%
7073% HoldsAt(On(physobj1,physobj2),time) ->
7074% !HoldsAt(On(physobj2,physobj1),time).
7075 /*
7076holds_at(on(Physobj1, Physobj2), Time) ->
7077 not(holds_at(on(Physobj2, Physobj1), Time)).
7078*/
7079.
7080
7081%
7082%
7083% ectest/ec_reader_test_ecnet.e:2859
7084% [agent,physobj1,physobj2,time]%
7085% Initiates(PlaceOn(agent,physobj1,physobj2),
7086% On(physobj1,physobj2),time).
7087 /*
7088.
7089*/
7090.
7091
7092%
7093%
7094% ectest/ec_reader_test_ecnet.e:2863
7095% [agent,physobj1,physobj2,time]%
7096% Terminates(PlaceOn(agent,physobj1,physobj2),
7097% Holding(agent,physobj1),time).
7098 /*
7099.
7100*/
7101.
7102
7103%
7104%
7105% ectest/ec_reader_test_ecnet.e:2867
7106% [agent,physobj1,physobj2,time]%
7107% Happens(PlaceOn(agent,physobj1,physobj2),time) ->
7108% HoldsAt(Holding(agent,physobj1),time) &
7109% ectest/ec_reader_test_ecnet.e:2870
7110% {location}%
7111% HoldsAt(At(agent,location),time) &
7112% HoldsAt(At(physobj2,location),time).
7113 /*
7114exists([Location], (happens(placeOn(Agent, Physobj1, Physobj2), Time)->holds_at(holding(Agent, Physobj1), Time), holds_at(at(Agent, Location), Time), holds_at(at(Physobj2, Location), Time))).
7115*/
7116.
7117
7118%
7119%
7120% ectest/ec_reader_test_ecnet.e:2874
7121% [agent,physobj1,physobj2,time]%
7122% Terminates(TakeOffOf(agent,physobj1,physobj2),
7123% On(physobj1,physobj2),time).
7124 /*
7125.
7126*/
7127.
7128
7129%
7130%
7131% ectest/ec_reader_test_ecnet.e:2878
7132% [agent,physobj1,physobj2,time]%
7133% Initiates(TakeOffOf(agent,physobj1,physobj2),
7134% Holding(agent,physobj1),time).
7135 /*
7136.
7137*/
7138.
7139
7140%
7141%
7142% ectest/ec_reader_test_ecnet.e:2882
7143% [agent,physobj1,physobj2,location,time]%
7144% Releases(TakeOffOf(agent,physobj1,physobj2),
7145% At(physobj1,location),
7146% time).
7147 /*
7148.
7149*/
7150.
7151
7152%
7153%
7154% ectest/ec_reader_test_ecnet.e:2887
7155% [agent,physobj1,physobj2,time]%
7156% Happens(TakeOffOf(agent,physobj1,physobj2),time) ->
7157% HoldsAt(On(physobj1,physobj2),time) &
7158% ectest/ec_reader_test_ecnet.e:2890
7159% {location}%
7160% HoldsAt(At(agent,location),time) &
7161% HoldsAt(At(physobj1,location),time) &
7162% HoldsAt(At(physobj2,location),time).
7163 /*
7164exists([Location], (happens(takeOffOf(Agent, Physobj1, Physobj2), Time)->holds_at(on(Physobj1, Physobj2), Time), holds_at(at(Agent, Location), Time), holds_at(at(Physobj1, Location), Time), holds_at(at(Physobj2, Location), Time))).
7165*/
7166.
7167
7168%
7169%
7170% ectest/ec_reader_test_ecnet.e:2895
7171% [agent,physobj1,physobj2,location,time]%
7172% Releases(PlaceOn(agent,physobj1,physobj2),
7173% At(physobj1,location),
7174% time).
7175 /*
7176.
7177*/
7178.
7179
7180%
7181%
7182% ectest/ec_reader_test_ecnet.e:2900
7183% [physobj1,physobj2,location,time]%
7184% HoldsAt(On(physobj1,physobj2),time) &
7185% HoldsAt(At(physobj2,location),time) ->
7186% HoldsAt(At(physobj1,location),time).
7187 /*
7188holds_at(on(Physobj1, Physobj2), Time), holds_at(at(Physobj2, Location), Time) ->
7189 holds_at(at(Physobj1, Location), Time).
7190*/
7191.
7192
7193%
7194%
7195% fluent At(object,location)
7196 /*
7197.
7198*/
7199.
7200
7201% ectest/ec_reader_test_ecnet.e:2906
7202%
7203% ectest/ec_reader_test_ecnet.e:2907
7204% [object,time]%
7205% ectest/ec_reader_test_ecnet.e:2908
7206% {location} % HoldsAt(At(object,location),time).
7207 /*
7208.
7209*/
7210.
7211
7212%
7213%
7214% ectest/ec_reader_test_ecnet.e:2910
7215% [object,location1,location2,time]%
7216% HoldsAt(At(object,location1),time) &
7217% HoldsAt(At(object,location2),time) ->
7218% location1=location2.
7219 /*
7220holds_at(at(Object, Location1), Time), holds_at(at(Object, Location2), Time) ->
7221 Location1=Location2.
7222*/
7223.
7224
7225%
7226%
7227% function Side1(portal): location
7228 /*
7229.
7230*/
7231.
7232
7233% ectest/ec_reader_test_ecnet.e:2916
7234% function Side2(portal): location
7235 /*
7236.
7237*/
7238.
7239
7240%
7241% fluent NearPortal(object,portal)
7242 /*
7243.
7244*/
7245.
7246
7247% noninertial NearPortal
7248 /*
7249.
7250*/
7251.
7252
7253%
7254% ectest/ec_reader_test_ecnet.e:2921
7255% [object,portal,time]%
7256% HoldsAt(NearPortal(object,portal),time) <->
7257% ectest/ec_reader_test_ecnet.e:2923
7258% {location}%
7259% (Side1(portal)=location|
7260% Side2(portal)=location) &
7261% HoldsAt(At(object,location),time).
7262 /*
7263exists([Location], (holds_at(nearPortal(Object, Portal), Time)<->(side1(Portal)=Location;side2(Portal)=Location), holds_at(at(Object, Location), Time))).
7264*/
7265.
7266.
7267
7268%
7269%
7270% event WalkThroughDoor12(agent,door)
7271 /*
7272.
7273*/
7274.
7275
7276% ectest/ec_reader_test_ecnet.e:2929
7277% event WalkThroughDoor21(agent,door)
7278 /*
7279.
7280*/
7281.
7282
7283%
7284% ectest/ec_reader_test_ecnet.e:2931
7285% [agent,door,time]%
7286% Happens(WalkThroughDoor12(agent,door),time) ->
7287% HoldsAt(Standing(agent),time) &
7288% HoldsAt(At(agent,Side1(door)),time).
7289 /*
7290happens(walkThroughDoor12(Agent, Door), Time) ->
7291 holds_at(standing(Agent), Time),
7292 holds_at(at(Agent, side1(Door)), Time).
7293*/
7294.
7295
7296%
7297%
7298% ectest/ec_reader_test_ecnet.e:2936
7299% [agent,door,time]%
7300% Happens(WalkThroughDoor21(agent,door),time) ->
7301% HoldsAt(Standing(agent),time) &
7302% HoldsAt(At(agent,Side2(door)),time).
7303 /*
7304happens(walkThroughDoor21(Agent, Door), Time) ->
7305 holds_at(standing(Agent), Time),
7306 holds_at(at(Agent, side2(Door)), Time).
7307*/
7308.
7309
7310%
7311%
7312% ectest/ec_reader_test_ecnet.e:2941
7313% [agent,door,location,time]%
7314% Side2(door)=location ->
7315% Initiates(WalkThroughDoor12(agent,door),At(agent,location),time).
7316 /*
7317side2(Door)=Location ->
7318 initiates(walkThroughDoor12(Agent, Door),
7319 at(Agent, Location),
7320 Time).
7321*/
7322.
7323
7324%
7325%
7326% ectest/ec_reader_test_ecnet.e:2945
7327% [agent,door,location,time]%
7328% Side1(door)=location ->
7329% Initiates(WalkThroughDoor21(agent,door),At(agent,location),time).
7330 /*
7331side1(Door)=Location ->
7332 initiates(walkThroughDoor21(Agent, Door),
7333 at(Agent, Location),
7334 Time).
7335*/
7336.
7337
7338%
7339%
7340% ectest/ec_reader_test_ecnet.e:2949
7341% [agent,door,location,time]%
7342% Side1(door)=location ->
7343% Terminates(WalkThroughDoor12(agent,door),At(agent,location),time).
7344 /*
7345side1(Door)=Location ->
7346 terminates(walkThroughDoor12(Agent, Door),
7347 at(Agent, Location),
7348 Time).
7349*/
7350.
7351
7352%
7353%
7354% ectest/ec_reader_test_ecnet.e:2953
7355% [agent,door,location,time]%
7356% Side2(door)=location ->
7357% Terminates(WalkThroughDoor21(agent,door),At(agent,location),time).
7358 /*
7359side2(Door)=Location ->
7360 terminates(walkThroughDoor21(Agent, Door),
7361 at(Agent, Location),
7362 Time).
7363*/
7364.
7365
7366%
7367%
7368% fluent Hungry(agent)
7369 /*
7370.
7371*/
7372.
7373
7374%
7375% ectest/ec_reader_test_ecnet.e:2959
7376% fluent Satiated(agent)
7377 /*
7378.
7379*/
7380.
7381
7382% noninertial Satiated
7383 /*
7384.
7385*/
7386.
7387
7388%
7389% ectest/ec_reader_test_ecnet.e:2962
7390% [agent,time] % HoldsAt(Hungry(agent),time) <-> !HoldsAt(Satiated(agent),time).
7391 /*
7392holds_at(hungry(Agent), Time) <->
7393 not(holds_at(satiated(Agent), Time)).
7394*/
7395.
7396.
7397
7398%
7399%
7400% event Eat(agent,food)
7401 /*
7402.
7403*/
7404.
7405
7406%
7407% ectest/ec_reader_test_ecnet.e:2966
7408% [agent,food,time]%
7409% Happens(Eat(agent,food),time) ->
7410% ectest/ec_reader_test_ecnet.e:2968
7411% {location}%
7412% HoldsAt(At(agent,location),time) &
7413% HoldsAt(At(food,location),time).
7414 /*
7415exists([Location], (happens(eat(Agent, Food), Time)->holds_at(at(Agent, Location), Time), holds_at(at(Food, Location), Time))).
7416*/
7417.
7418
7419%
7420%
7421% ectest/ec_reader_test_ecnet.e:2972
7422% [agent,food,time]%
7423% Terminates(Eat(agent,food),Hungry(agent),time).
7424 /*
7425.
7426*/
7427.
7428
7429%
7430%
7431% sort restaurant: script
7432 /*
7433.
7434*/
7435.
7436.
7437.
7438
7439% sort waiter: agent
7440 /*
7441.
7442*/
7443.
7444.
7445.
7446
7447% sort cook: agent
7448 /*
7449.
7450*/
7451.
7452.
7453.
7454
7455% ectest/ec_reader_test_ecnet.e:2978
7456%
7457% function BillOf(restaurant): bill
7458 /*
7459.
7460*/
7461.
7462
7463% function CookOf(restaurant): cook
7464 /*
7465.
7466*/
7467.
7468
7469% function TableOf(restaurant): table
7470 /*
7471.
7472*/
7473.
7474
7475% function WaiterOf(restaurant): waiter
7476 /*
7477.
7478*/
7479.
7480
7481% function KitchenDoorOf(restaurant): door
7482 /*
7483.
7484*/
7485.
7486
7487% ectest/ec_reader_test_ecnet.e:2984
7488%
7489% fluent BeWaiter0(waiter)
7490 /*
7491.
7492*/
7493.
7494
7495%
7496% fluent BeWaiter1(waiter)
7497 /*
7498.
7499*/
7500.
7501
7502%
7503% fluent BeWaiter2(waiter)
7504 /*
7505.
7506*/
7507.
7508
7509% ectest/ec_reader_test_ecnet.e:2990
7510%
7511% fluent BeWaiter3(waiter)
7512 /*
7513.
7514*/
7515.
7516
7517%
7518% fluent BeWaiter4(waiter)
7519 /*
7520.
7521*/
7522.
7523
7524%
7525% fluent BeWaiter5(waiter)
7526 /*
7527.
7528*/
7529.
7530
7531% ectest/ec_reader_test_ecnet.e:2996
7532%
7533% fluent BeWaiter6(waiter)
7534 /*
7535.
7536*/
7537.
7538
7539%
7540% fluent BeWaiter7(waiter)
7541 /*
7542.
7543*/
7544.
7545
7546%
7547% fluent BeWaiter8(waiter)
7548 /*
7549.
7550*/
7551.
7552
7553% ectest/ec_reader_test_ecnet.e:3002
7554%
7555% fluent BeWaiter9(waiter)
7556 /*
7557.
7558*/
7559.
7560
7561%
7562% xor BeWaiter0, BeWaiter1, BeWaiter2, BeWaiter3, BeWaiter4, BeWaiter5, BeWaiter6, BeWaiter7, BeWaiter8, BeWaiter9
7563 /*
7564.
7565*/
7566.
7567
7568%
7569% ectest/ec_reader_test_ecnet.e:3007
7570% [waiter,agent,time]%
7571% HoldsAt(BeWaiter0(waiter),time) ->
7572% Terminates(Greet(waiter,agent),
7573% BeWaiter0(waiter),
7574% time).
7575 /*
7576holds_at(beWaiter0(Waiter), Time) ->
7577 terminates(greet(Waiter, Agent),
7578 beWaiter0(Waiter),
7579 Time).
7580*/
7581.
7582
7583%
7584%
7585% ectest/ec_reader_test_ecnet.e:3013
7586% [waiter,agent,time]%
7587% HoldsAt(BeWaiter0(waiter),time) ->
7588% Initiates(Greet(waiter,agent),
7589% BeWaiter1(waiter),
7590% time).
7591 /*
7592holds_at(beWaiter0(Waiter), Time) ->
7593 initiates(greet(Waiter, Agent),
7594 beWaiter1(Waiter),
7595 Time).
7596*/
7597.
7598
7599%
7600%
7601% ectest/ec_reader_test_ecnet.e:3019
7602% [waiter,agent,food,time]%
7603% HoldsAt(BeWaiter1(waiter),time) ->
7604% Terminates(Order(agent,waiter,food),
7605% BeWaiter1(waiter),
7606% time).
7607 /*
7608holds_at(beWaiter1(Waiter), Time) ->
7609 terminates(order(Agent, Waiter, Food),
7610 beWaiter1(Waiter),
7611 Time).
7612*/
7613.
7614
7615%
7616%
7617% ectest/ec_reader_test_ecnet.e:3025
7618% [waiter,agent,food,time]%
7619% HoldsAt(BeWaiter1(waiter),time) ->
7620% Initiates(Order(agent,waiter,food),
7621% BeWaiter2(waiter),
7622% time).
7623 /*
7624holds_at(beWaiter1(Waiter), Time) ->
7625 initiates(order(Agent, Waiter, Food),
7626 beWaiter2(Waiter),
7627 Time).
7628*/
7629.
7630
7631%
7632%
7633% ectest/ec_reader_test_ecnet.e:3031
7634% [restaurant,waiter,time]%
7635% WaiterOf(restaurant)=waiter &
7636% HoldsAt(BeWaiter2(waiter),time) ->
7637% Happens(WalkThroughDoor12(waiter,KitchenDoorOf(restaurant)),time).
7638 /*
7639waiterOf(Restaurant)=Waiter, holds_at(beWaiter2(Waiter), Time) ->
7640 happens(walkThroughDoor12(Waiter, kitchenDoorOf(Restaurant)),
7641 Time).
7642*/
7643.
7644
7645%
7646%
7647% ectest/ec_reader_test_ecnet.e:3036
7648% [restaurant,waiter,door,time]%
7649% HoldsAt(BeWaiter2(waiter),time) &
7650% WaiterOf(restaurant)=waiter &
7651% KitchenDoorOf(restaurant)=door ->
7652% Terminates(WalkThroughDoor12(waiter,door),
7653% BeWaiter2(waiter),
7654% time).
7655 /*
7656holds_at(beWaiter2(Waiter), Time), waiterOf(Restaurant)=Waiter, kitchenDoorOf(Restaurant)=Door ->
7657 terminates(walkThroughDoor12(Waiter, Door),
7658 beWaiter2(Waiter),
7659 Time).
7660*/
7661.
7662
7663% ectest/ec_reader_test_ecnet.e:3042
7664%
7665%
7666% ectest/ec_reader_test_ecnet.e:3044
7667% [restaurant,waiter,door,time]%
7668% HoldsAt(BeWaiter2(waiter),time) &
7669% WaiterOf(restaurant)=waiter &
7670% KitchenDoorOf(restaurant)=door ->
7671% Initiates(WalkThroughDoor12(waiter,door),
7672% BeWaiter3(waiter),
7673% time).
7674 /*
7675holds_at(beWaiter2(Waiter), Time), waiterOf(Restaurant)=Waiter, kitchenDoorOf(Restaurant)=Door ->
7676 initiates(walkThroughDoor12(Waiter, Door),
7677 beWaiter3(Waiter),
7678 Time).
7679*/
7680.
7681
7682% ectest/ec_reader_test_ecnet.e:3050
7683%
7684%
7685% ectest/ec_reader_test_ecnet.e:3052
7686% [restaurant,food,time]%
7687% HoldsAt(BeWaiter3(WaiterOf(restaurant)),time) &
7688% ({agent} HoldsAt(KnowOrder(WaiterOf(restaurant),agent,food),time)) ->
7689% Happens(Order(WaiterOf(restaurant),CookOf(restaurant),food),time).
7690 /*
7691holds_at(beWaiter3(waiterOf(Restaurant)), Time), exists([Agent], holds_at(knowOrder(waiterOf(Restaurant), Agent, Food), Time)) ->
7692 happens(order(waiterOf(Restaurant),
7693 cookOf(Restaurant),
7694 Food),
7695 Time).
7696*/
7697.
7698
7699%
7700%
7701% ectest/ec_reader_test_ecnet.e:3057
7702% [restaurant,waiter,cook,food,time]%
7703% WaiterOf(restaurant)=waiter &
7704% CookOf(restaurant)=cook &
7705% HoldsAt(BeWaiter3(waiter),time) ->
7706% Terminates(Order(waiter,cook,food),
7707% BeWaiter3(waiter),
7708% time).
7709 /*
7710waiterOf(Restaurant)=Waiter, cookOf(Restaurant)=Cook, holds_at(beWaiter3(Waiter), Time) ->
7711 terminates(order(Waiter, Cook, Food),
7712 beWaiter3(Waiter),
7713 Time).
7714*/
7715.
7716
7717% ectest/ec_reader_test_ecnet.e:3063
7718%
7719%
7720% ectest/ec_reader_test_ecnet.e:3065
7721% [restaurant,waiter,cook,food,time]%
7722% WaiterOf(restaurant)=waiter &
7723% CookOf(restaurant)=cook &
7724% HoldsAt(BeWaiter3(waiter),time) ->
7725% Initiates(Order(waiter,cook,food),
7726% BeWaiter4(waiter),
7727% time).
7728 /*
7729waiterOf(Restaurant)=Waiter, cookOf(Restaurant)=Cook, holds_at(beWaiter3(Waiter), Time) ->
7730 initiates(order(Waiter, Cook, Food),
7731 beWaiter4(Waiter),
7732 Time).
7733*/
7734.
7735
7736% ectest/ec_reader_test_ecnet.e:3071
7737%
7738%
7739% ectest/ec_reader_test_ecnet.e:3073
7740% [waiter,food,time]%
7741% HoldsAt(BeWaiter4(waiter),time) &
7742% ({agent} HoldsAt(KnowOrder(waiter,agent,food),time)) &
7743% HoldsAt(FoodPrepared(food),time) ->
7744% Happens(PickUp(waiter,food),time).
7745 /*
7746holds_at(beWaiter4(Waiter), Time), exists([Agent], holds_at(knowOrder(Waiter, Agent, Food), Time)), holds_at(foodPrepared(Food), Time) ->
7747 happens(pickUp(Waiter, Food), Time).
7748*/
7749.
7750
7751%
7752%
7753% ectest/ec_reader_test_ecnet.e:3079
7754% [waiter,food,time]%
7755% HoldsAt(BeWaiter4(waiter),time) &
7756% ({agent} HoldsAt(KnowOrder(waiter,agent,food),time)) ->
7757% Terminates(PickUp(waiter,food),
7758% BeWaiter4(waiter),
7759% time).
7760 /*
7761holds_at(beWaiter4(Waiter), Time), exists([Agent], holds_at(knowOrder(Waiter, Agent, Food), Time)) ->
7762 terminates(pickUp(Waiter, Food),
7763 beWaiter4(Waiter),
7764 Time).
7765*/
7766.
7767
7768%
7769% ectest/ec_reader_test_ecnet.e:3085
7770%
7771% ectest/ec_reader_test_ecnet.e:3086
7772% [waiter,food,time]%
7773% HoldsAt(BeWaiter4(waiter),time) &
7774% ({agent} HoldsAt(KnowOrder(waiter,agent,food),time)) ->
7775% Initiates(PickUp(waiter,food),
7776% BeWaiter5(waiter),
7777% time).
7778 /*
7779holds_at(beWaiter4(Waiter), Time), exists([Agent], holds_at(knowOrder(Waiter, Agent, Food), Time)) ->
7780 initiates(pickUp(Waiter, Food),
7781 beWaiter5(Waiter),
7782 Time).
7783*/
7784.
7785
7786%
7787% ectest/ec_reader_test_ecnet.e:3092
7788%
7789% ectest/ec_reader_test_ecnet.e:3093
7790% [restaurant,waiter,time]%
7791% WaiterOf(restaurant)=waiter &
7792% HoldsAt(BeWaiter5(waiter),time) ->
7793% Happens(WalkThroughDoor21(waiter,KitchenDoorOf(restaurant)),time).
7794 /*
7795waiterOf(Restaurant)=Waiter, holds_at(beWaiter5(Waiter), Time) ->
7796 happens(walkThroughDoor21(Waiter, kitchenDoorOf(Restaurant)),
7797 Time).
7798*/
7799.
7800
7801%
7802%
7803% ectest/ec_reader_test_ecnet.e:3098
7804% [restaurant,waiter,door,time]%
7805% HoldsAt(BeWaiter5(waiter),time) &
7806% WaiterOf(restaurant)=waiter &
7807% KitchenDoorOf(restaurant)=door ->
7808% Terminates(WalkThroughDoor21(waiter,door),
7809% BeWaiter5(waiter),
7810% time).
7811 /*
7812holds_at(beWaiter5(Waiter), Time), waiterOf(Restaurant)=Waiter, kitchenDoorOf(Restaurant)=Door ->
7813 terminates(walkThroughDoor21(Waiter, Door),
7814 beWaiter5(Waiter),
7815 Time).
7816*/
7817.
7818
7819% ectest/ec_reader_test_ecnet.e:3104
7820%
7821%
7822% ectest/ec_reader_test_ecnet.e:3106
7823% [restaurant,waiter,door,time]%
7824% HoldsAt(BeWaiter5(waiter),time) &
7825% WaiterOf(restaurant)=waiter &
7826% KitchenDoorOf(restaurant)=door ->
7827% Initiates(WalkThroughDoor21(waiter,door),
7828% BeWaiter6(waiter),
7829% time).
7830 /*
7831holds_at(beWaiter5(Waiter), Time), waiterOf(Restaurant)=Waiter, kitchenDoorOf(Restaurant)=Door ->
7832 initiates(walkThroughDoor21(Waiter, Door),
7833 beWaiter6(Waiter),
7834 Time).
7835*/
7836.
7837
7838% ectest/ec_reader_test_ecnet.e:3112
7839%
7840%
7841% ectest/ec_reader_test_ecnet.e:3114
7842% [restaurant,waiter,table,food,time]%
7843% WaiterOf(restaurant)=waiter &
7844% TableOf(restaurant)=table &
7845% HoldsAt(BeWaiter6(waiter),time) &
7846% HoldsAt(Holding(waiter,food),time) ->
7847% Happens(PlaceOn(waiter,food,table),time).
7848 /*
7849waiterOf(Restaurant)=Waiter, tableOf(Restaurant)=Table, holds_at(beWaiter6(Waiter), Time), holds_at(holding(Waiter, Food), Time) ->
7850 happens(placeOn(Waiter, Food, Table), Time).
7851*/
7852.
7853
7854%
7855% ectest/ec_reader_test_ecnet.e:3120
7856%
7857% ectest/ec_reader_test_ecnet.e:3121
7858% [waiter,food,table,time]%
7859% HoldsAt(BeWaiter6(waiter),time) ->
7860% Terminates(PlaceOn(waiter,food,table),
7861% BeWaiter6(waiter),
7862% time).
7863 /*
7864holds_at(beWaiter6(Waiter), Time) ->
7865 terminates(placeOn(Waiter, Food, Table),
7866 beWaiter6(Waiter),
7867 Time).
7868*/
7869.
7870
7871%
7872%
7873% ectest/ec_reader_test_ecnet.e:3127
7874% [waiter,food,table,time]%
7875% HoldsAt(BeWaiter6(waiter),time) ->
7876% Initiates(PlaceOn(waiter,food,table),
7877% BeWaiter7(waiter),
7878% time).
7879 /*
7880holds_at(beWaiter6(Waiter), Time) ->
7881 initiates(placeOn(Waiter, Food, Table),
7882 beWaiter7(Waiter),
7883 Time).
7884*/
7885.
7886
7887%
7888%
7889% ectest/ec_reader_test_ecnet.e:3133
7890% [waiter,agent,bill,time]%
7891% HoldsAt(BeWaiter7(waiter),time) ->
7892% Terminates(Request(agent,waiter,bill),
7893% BeWaiter7(waiter),
7894% time).
7895 /*
7896holds_at(beWaiter7(Waiter), Time) ->
7897 terminates(request(Agent, Waiter, Bill),
7898 beWaiter7(Waiter),
7899 Time).
7900*/
7901.
7902
7903%
7904%
7905% ectest/ec_reader_test_ecnet.e:3139
7906% [waiter,agent,bill,time]%
7907% HoldsAt(BeWaiter7(waiter),time) ->
7908% Initiates(Request(agent,waiter,bill),
7909% BeWaiter8(waiter),
7910% time).
7911 /*
7912holds_at(beWaiter7(Waiter), Time) ->
7913 initiates(request(Agent, Waiter, Bill),
7914 beWaiter8(Waiter),
7915 Time).
7916*/
7917.
7918
7919%
7920%
7921% ectest/ec_reader_test_ecnet.e:3145
7922% [restaurant,waiter,bill,time]%
7923% WaiterOf(restaurant)=waiter &
7924% BillOf(restaurant)=bill &
7925% HoldsAt(BeWaiter8(waiter),time) ->
7926% Happens(PickUp(waiter,bill),time).
7927 /*
7928waiterOf(Restaurant)=Waiter, billOf(Restaurant)=Bill, holds_at(beWaiter8(Waiter), Time) ->
7929 happens(pickUp(Waiter, Bill), Time).
7930*/
7931.
7932
7933%
7934%
7935% ectest/ec_reader_test_ecnet.e:3151
7936% [waiter,bill,time]%
7937% HoldsAt(BeWaiter8(waiter),time) ->
7938% Terminates(PickUp(waiter,bill),
7939% BeWaiter8(waiter),
7940% time).
7941 /*
7942holds_at(beWaiter8(Waiter), Time) ->
7943 terminates(pickUp(Waiter, Bill),
7944 beWaiter8(Waiter),
7945 Time).
7946*/
7947.
7948
7949%
7950%
7951% ectest/ec_reader_test_ecnet.e:3157
7952% [waiter,bill,time]%
7953% HoldsAt(BeWaiter8(waiter),time) ->
7954% Initiates(PickUp(waiter,bill),
7955% BeWaiter9(waiter),
7956% time).
7957 /*
7958holds_at(beWaiter8(Waiter), Time) ->
7959 initiates(pickUp(Waiter, Bill),
7960 beWaiter9(Waiter),
7961 Time).
7962*/
7963.
7964
7965%
7966%
7967% ectest/ec_reader_test_ecnet.e:3163
7968% [restaurant,waiter,bill,table,time]%
7969% WaiterOf(restaurant)=waiter &
7970% BillOf(restaurant)=bill &
7971% TableOf(restaurant)=table &
7972% HoldsAt(BeWaiter9(waiter),time) ->
7973% Happens(PlaceOn(waiter,bill,table),time).
7974 /*
7975waiterOf(Restaurant)=Waiter, billOf(Restaurant)=Bill, tableOf(Restaurant)=Table, holds_at(beWaiter9(Waiter), Time) ->
7976 happens(placeOn(Waiter, Bill, Table), Time).
7977*/
7978.
7979
7980%
7981% ectest/ec_reader_test_ecnet.e:3169
7982%
7983% ectest/ec_reader_test_ecnet.e:3170
7984% [waiter,bill,table,time]%
7985% HoldsAt(BeWaiter9(waiter),time) ->
7986% Terminates(PlaceOn(waiter,bill,table),
7987% BeWaiter9(waiter),
7988% time).
7989 /*
7990holds_at(beWaiter9(Waiter), Time) ->
7991 terminates(placeOn(Waiter, Bill, Table),
7992 beWaiter9(Waiter),
7993 Time).
7994*/
7995.
7996
7997%
7998%
7999% ectest/ec_reader_test_ecnet.e:3176
8000% [waiter,bill,table,time]%
8001% HoldsAt(BeWaiter9(waiter),time) ->
8002% Initiates(PlaceOn(waiter,bill,table),
8003% BeWaiter0(waiter),
8004% time).
8005 /*
8006holds_at(beWaiter9(Waiter), Time) ->
8007 initiates(placeOn(Waiter, Bill, Table),
8008 beWaiter0(Waiter),
8009 Time).
8010*/
8011.
8012
8013%
8014%
8015% ectest/ec_reader_test_ecnet.e:3182
8016% fluent BeCook0(cook)
8017 /*
8018.
8019*/
8020.
8021
8022%
8023% fluent BeCook1(cook)
8024 /*
8025.
8026*/
8027.
8028
8029%
8030% xor BeCook0, BeCook1
8031 /*
8032.
8033*/
8034.
8035
8036%
8037% ectest/ec_reader_test_ecnet.e:3188
8038% [cook,agent,food,time]%
8039% HoldsAt(BeCook0(cook),time) ->
8040% Terminates(Order(agent,cook,food),
8041% BeCook0(cook),
8042% time).
8043 /*
8044holds_at(beCook0(Cook), Time) ->
8045 terminates(order(Agent, Cook, Food),
8046 beCook0(Cook),
8047 Time).
8048*/
8049.
8050
8051%
8052%
8053% ectest/ec_reader_test_ecnet.e:3194
8054% [cook,agent,food,time]%
8055% HoldsAt(BeCook0(cook),time) ->
8056% Initiates(Order(agent,cook,food),
8057% BeCook1(cook),
8058% time).
8059 /*
8060holds_at(beCook0(Cook), Time) ->
8061 initiates(order(Agent, Cook, Food),
8062 beCook1(Cook),
8063 Time).
8064*/
8065.
8066
8067%
8068%
8069% ectest/ec_reader_test_ecnet.e:3200
8070% event FoodPrepare(agent,food)
8071 /*
8072.
8073*/
8074.
8075
8076%
8077% fluent FoodPrepared(food)
8078 /*
8079.
8080*/
8081.
8082
8083%
8084% ectest/ec_reader_test_ecnet.e:3204
8085% [agent,food,time]%
8086% Initiates(FoodPrepare(agent,food),
8087% FoodPrepared(food),
8088% time).
8089 /*
8090.
8091*/
8092.
8093
8094%
8095%
8096% ectest/ec_reader_test_ecnet.e:3209
8097% [agent,food,time]%
8098% Happens(FoodPrepare(agent,food),time) ->
8099% ectest/ec_reader_test_ecnet.e:3211
8100% {location}%
8101% HoldsAt(At(agent,location),time) &
8102% HoldsAt(At(food,location),time).
8103 /*
8104exists([Location], (happens(foodPrepare(Agent, Food), Time)->holds_at(at(Agent, Location), Time), holds_at(at(Food, Location), Time))).
8105*/
8106.
8107
8108%
8109%
8110% ectest/ec_reader_test_ecnet.e:3215
8111% [cook,agent,food,time]%
8112% HoldsAt(BeCook1(cook),time) &
8113% HoldsAt(KnowOrder(cook,agent,food),time) ->
8114% Happens(FoodPrepare(cook,food),time).
8115 /*
8116holds_at(beCook1(Cook), Time), holds_at(knowOrder(Cook, Agent, Food), Time) ->
8117 happens(foodPrepare(Cook, Food), Time).
8118*/
8119.
8120
8121%
8122%
8123% ectest/ec_reader_test_ecnet.e:3220
8124% [cook,food,time]%
8125% HoldsAt(BeCook1(cook),time) ->
8126% Terminates(FoodPrepare(cook,food),
8127% BeCook1(cook),
8128% time).
8129 /*
8130holds_at(beCook1(Cook), Time) ->
8131 terminates(foodPrepare(Cook, Food),
8132 beCook1(Cook),
8133 Time).
8134*/
8135.
8136
8137%
8138%
8139% ectest/ec_reader_test_ecnet.e:3226
8140% [cook,food,time]%
8141% HoldsAt(BeCook1(cook),time) ->
8142% Initiates(FoodPrepare(cook,food),
8143% BeCook0(cook),
8144% time).
8145 /*
8146holds_at(beCook1(Cook), Time) ->
8147 initiates(foodPrepare(Cook, Food),
8148 beCook0(Cook),
8149 Time).
8150*/
8151.
8152
8153%
8154%
8155% ectest/ec_reader_test_ecnet.e:3232
8156% event Pay(agent,agent)
8157 /*
8158.
8159*/
8160.
8161
8162%
8163% event Tip(agent,agent)
8164 /*
8165.
8166*/
8167.
8168
8169%
8170% ectest/ec_reader_test_ecnet.e:3236
8171% [agent,physobj,time]%
8172% Happens(LieOn(agent,physobj),time) ->
8173% ectest/ec_reader_test_ecnet.e:3238
8174% {room}%
8175% HoldsAt(At(agent,room),time) &
8176% HoldsAt(At(physobj,room),time).
8177 /*
8178exists([Room], (happens(lieOn(Agent, Physobj), Time)->holds_at(at(Agent, Room), Time), holds_at(at(Physobj, Room), Time))).
8179*/
8180.
8181
8182%
8183%
8184% ectest/ec_reader_test_ecnet.e:3242
8185% [agent,physobj,time]%
8186% Happens(SitOn(agent,physobj),time) ->
8187% ectest/ec_reader_test_ecnet.e:3244
8188% {room}%
8189% HoldsAt(At(agent,room),time) &
8190% HoldsAt(At(physobj,room),time).
8191 /*
8192exists([Room], (happens(sitOn(Agent, Physobj), Time)->holds_at(at(Agent, Room), Time), holds_at(at(Physobj, Room), Time))).
8193*/
8194.
8195
8196%
8197%
8198% event LieOn(agent,physobj)
8199 /*
8200.
8201*/
8202.
8203
8204%
8205% ectest/ec_reader_test_ecnet.e:3250
8206% event SitOn(agent,physobj)
8207 /*
8208.
8209*/
8210.
8211
8212%
8213% event RiseFrom(agent,physobj)
8214 /*
8215.
8216*/
8217.
8218
8219%
8220% fluent LyingOn(agent,physobj)
8221 /*
8222.
8223*/
8224.
8225
8226% fluent SittingOn(agent,physobj)
8227 /*
8228.
8229*/
8230.
8231
8232% ectest/ec_reader_test_ecnet.e:3256
8233% fluent Standing(agent)
8234 /*
8235.
8236*/
8237.
8238
8239%
8240% fluent Lying(agent)
8241 /*
8242.
8243*/
8244.
8245
8246% fluent Sitting(agent)
8247 /*
8248.
8249*/
8250.
8251
8252% noninertial Lying
8253 /*
8254.
8255*/
8256.
8257
8258% noninertial Sitting
8259 /*
8260.
8261*/
8262.
8263
8264% ectest/ec_reader_test_ecnet.e:3262
8265%
8266% xor Lying, Sitting, Standing
8267 /*
8268.
8269*/
8270.
8271
8272%
8273% ectest/ec_reader_test_ecnet.e:3265
8274% [agent,physobj,time]%
8275% HoldsAt(LyingOn(agent,physobj),time) ->
8276% HoldsAt(Lying(agent),time).
8277 /*
8278holds_at(lyingOn(Agent, Physobj), Time) ->
8279 holds_at(lying(Agent), Time).
8280*/
8281.
8282
8283%
8284%
8285% ectest/ec_reader_test_ecnet.e:3269
8286% [agent,physobj,time]%
8287% HoldsAt(SittingOn(agent,physobj),time) ->
8288% HoldsAt(Sitting(agent),time).
8289 /*
8290holds_at(sittingOn(Agent, Physobj), Time) ->
8291 holds_at(sitting(Agent), Time).
8292*/
8293.
8294
8295%
8296%
8297% ectest/ec_reader_test_ecnet.e:3273
8298% [agent,physobj1,physobj2,time]%
8299% HoldsAt(LyingOn(agent,physobj1),time) &
8300% HoldsAt(LyingOn(agent,physobj2),time) ->
8301% physobj1=physobj2.
8302 /*
8303holds_at(lyingOn(Agent, Physobj1), Time), holds_at(lyingOn(Agent, Physobj2), Time) ->
8304 Physobj1=Physobj2.
8305*/
8306.
8307
8308%
8309%
8310% ectest/ec_reader_test_ecnet.e:3278
8311% [agent,physobj1,physobj2,time]%
8312% HoldsAt(SittingOn(agent,physobj1),time) &
8313% HoldsAt(SittingOn(agent,physobj2),time) ->
8314% physobj1=physobj2.
8315 /*
8316holds_at(sittingOn(Agent, Physobj1), Time), holds_at(sittingOn(Agent, Physobj2), Time) ->
8317 Physobj1=Physobj2.
8318*/
8319.
8320
8321%
8322%
8323% ectest/ec_reader_test_ecnet.e:3283
8324% [agent,physobj,time]%
8325% HoldsAt(Standing(agent),time) ->
8326% Initiates(LieOn(agent,physobj),
8327% LyingOn(agent,physobj),
8328% time).
8329 /*
8330holds_at(standing(Agent), Time) ->
8331 initiates(lieOn(Agent, Physobj),
8332 lyingOn(Agent, Physobj),
8333 Time).
8334*/
8335.
8336
8337%
8338%
8339% ectest/ec_reader_test_ecnet.e:3289
8340% [agent,physobj,time]%
8341% Terminates(LieOn(agent,physobj),
8342% Standing(agent),
8343% time).
8344 /*
8345.
8346*/
8347.
8348
8349%
8350%
8351% ectest/ec_reader_test_ecnet.e:3294
8352% [agent,physobj,time]%
8353% HoldsAt(Standing(agent),time) ->
8354% Initiates(SitOn(agent,physobj),
8355% SittingOn(agent,physobj),
8356% time).
8357 /*
8358holds_at(standing(Agent), Time) ->
8359 initiates(sitOn(Agent, Physobj),
8360 sittingOn(Agent, Physobj),
8361 Time).
8362*/
8363.
8364
8365%
8366%
8367% ectest/ec_reader_test_ecnet.e:3300
8368% [agent,physobj,time]%
8369% Terminates(SitOn(agent,physobj),
8370% Standing(agent),
8371% time).
8372 /*
8373.
8374*/
8375.
8376
8377%
8378%
8379% ectest/ec_reader_test_ecnet.e:3305
8380% [agent,physobj,time]%
8381% (HoldsAt(SittingOn(agent,physobj),time) |
8382% HoldsAt(LyingOn(agent,physobj),time)) ->
8383% Initiates(RiseFrom(agent,physobj),
8384% Standing(agent),
8385% time).
8386 /*
8387holds_at(sittingOn(Agent, Physobj), Time);holds_at(lyingOn(Agent, Physobj), Time) ->
8388 initiates(riseFrom(Agent, Physobj),
8389 standing(Agent),
8390 Time).
8391*/
8392.
8393
8394%
8395% ectest/ec_reader_test_ecnet.e:3311
8396%
8397% ectest/ec_reader_test_ecnet.e:3312
8398% [agent,physobj,time]%
8399% HoldsAt(LyingOn(agent,physobj),time) ->
8400% Terminates(RiseFrom(agent,physobj),
8401% LyingOn(agent,physobj),
8402% time).
8403 /*
8404holds_at(lyingOn(Agent, Physobj), Time) ->
8405 terminates(riseFrom(Agent, Physobj),
8406 lyingOn(Agent, Physobj),
8407 Time).
8408*/
8409.
8410
8411%
8412%
8413% ectest/ec_reader_test_ecnet.e:3318
8414% [agent,physobj,time]%
8415% HoldsAt(SittingOn(agent,physobj),time) ->
8416% Terminates(RiseFrom(agent,physobj),
8417% SittingOn(agent,physobj),
8418% time).
8419 /*
8420holds_at(sittingOn(Agent, Physobj), Time) ->
8421 terminates(riseFrom(Agent, Physobj),
8422 sittingOn(Agent, Physobj),
8423 Time).
8424*/
8425.
8426
8427%
8428%
8429% ectest/ec_reader_test_ecnet.e:3324
8430% event Greet(agent,agent)
8431 /*
8432.
8433*/
8434.
8435
8436%
8437% event SayGoodbye(agent,agent)
8438 /*
8439.
8440*/
8441.
8442
8443%
8444% ectest/ec_reader_test_ecnet.e:3328
8445% [agent1,agent2,time]%
8446% Happens(Greet(agent1,agent2),time) ->
8447% ectest/ec_reader_test_ecnet.e:3330
8448% {location}%
8449% HoldsAt(At(agent1,location),time) &
8450% HoldsAt(At(agent2,location),time).
8451 /*
8452exists([Location], (happens(greet(Agent1, Agent2), Time)->holds_at(at(Agent1, Location), Time), holds_at(at(Agent2, Location), Time))).
8453*/
8454.
8455
8456%
8457%
8458% ectest/ec_reader_test_ecnet.e:3334
8459% [agent1,agent2,time]%
8460% Happens(SayGoodbye(agent1,agent2),time) ->
8461% ectest/ec_reader_test_ecnet.e:3336
8462% {location}%
8463% HoldsAt(At(agent1,location),time) &
8464% HoldsAt(At(agent2,location),time).
8465 /*
8466exists([Location], (happens(sayGoodbye(Agent1, Agent2), Time)->holds_at(at(Agent1, Location), Time), holds_at(at(Agent2, Location), Time))).
8467*/
8468.
8469
8470%
8471%
8472% event Order(agent,agent,physobj)
8473 /*
8474.
8475*/
8476.
8477
8478%
8479% ectest/ec_reader_test_ecnet.e:3342
8480% fluent KnowOrder(agent,agent,physobj)
8481 /*
8482.
8483*/
8484.
8485
8486%
8487% ectest/ec_reader_test_ecnet.e:3344
8488% [agent1,agent2,physobj,time]%
8489% Initiates(Order(agent1,agent2,physobj),
8490% KnowOrder(agent2,agent1,physobj),
8491% time).
8492 /*
8493.
8494*/
8495.
8496
8497%
8498%
8499% ectest/ec_reader_test_ecnet.e:3349
8500% [agent1,agent2,physobj,time]%
8501% Happens(Order(agent1,agent2,physobj),time) ->
8502% ectest/ec_reader_test_ecnet.e:3351
8503% {location}%
8504% HoldsAt(At(agent1,location),time) &
8505% HoldsAt(At(agent2,location),time).
8506 /*
8507exists([Location], (happens(order(Agent1, Agent2, Physobj), Time)->holds_at(at(Agent1, Location), Time), holds_at(at(Agent2, Location), Time))).
8508*/
8509.
8510
8511%
8512%
8513% event Request(agent,agent,physobj)
8514 /*
8515.
8516*/
8517.
8518
8519%
8520% ectest/ec_reader_test_ecnet.e:3357
8521% fluent KnowRequest(agent,agent,physobj)
8522 /*
8523.
8524*/
8525.
8526
8527%
8528% ectest/ec_reader_test_ecnet.e:3359
8529% [agent1,agent2,physobj,time]%
8530% Initiates(Request(agent1,agent2,physobj),
8531% KnowRequest(agent2,agent1,physobj),
8532% time).
8533 /*
8534.
8535*/
8536.
8537
8538%
8539%
8540% ectest/ec_reader_test_ecnet.e:3364
8541% [agent1,agent2,physobj,time]%
8542% Happens(Request(agent1,agent2,physobj),time) ->
8543% ectest/ec_reader_test_ecnet.e:3366
8544% {location}%
8545% HoldsAt(At(agent1,location),time) &
8546% HoldsAt(At(agent2,location),time).
8547 /*
8548exists([Location], (happens(request(Agent1, Agent2, Physobj), Time)->holds_at(at(Agent1, Location), Time), holds_at(at(Agent2, Location), Time))).
8549*/
8550.
8551
8552%
8553%
8554%; End of file.
8555%
8556% ectest/ec_reader_test_ecnet.e:3372
8557%
8558%
8559%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
8560%; FILE: ecnet/Diving.e
8561%; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
8562%
8563%;
8564%; Copyright (c) 2005 IBM Corporation and others.
8565%; All rights reserved. This program and the accompanying materials
8566%; are made available under the terms of the Common Public License v1.0
8567%; which accompanies this distribution, and is available at
8568%; http://www.eclipse.org/legal/cpl-v10.html
8569%;
8570%; Contributors:
8571%; IBM - Initial implementation
8572%;
8573%; scuba diving
8574%;
8575% ectest/ec_reader_test_ecnet.e:3390
8576%
8577% sort object
8578 /*
8579.
8580*/
8581.
8582
8583% sort agent: object
8584 /*
8585.
8586*/
8587.
8588.
8589.
8590
8591% sort diver: agent
8592 /*
8593.
8594*/
8595.
8596.
8597.
8598
8599% sort depth: integer
8600 /*
8601.
8602*/
8603.
8604.
8605.
8606
8607% sort boat: object
8608 /*
8609.
8610*/
8611.
8612.
8613.
8614
8615% ectest/ec_reader_test_ecnet.e:3396
8616%
8617%; reference line, anchor line, shotline, SMB line, ...
8618% sort line: object
8619 /*
8620.
8621*/
8622.
8623.
8624.
8625
8626%
8627% sort equipment: object
8628 /*
8629.
8630*/
8631.
8632.
8633.
8634
8635% sort weight: equipment
8636 /*
8637.
8638*/
8639.
8640.
8641.
8642
8643% ectest/ec_reader_test_ecnet.e:3402
8644% sort fin: equipment
8645 /*
8646.
8647*/
8648.
8649.
8650.
8651
8652% sort airtank: equipment
8653 /*
8654.
8655*/
8656.
8657.
8658.
8659
8660%
8661%; buoyancy compensator (BC)
8662%; buoyancy control device (BCD)
8663% sort computer: equipment
8664 /*
8665.
8666*/
8667.
8668.
8669.
8670
8671% ectest/ec_reader_test_ecnet.e:3408
8672% sort bc: equipment
8673 /*
8674.
8675*/
8676.
8677.
8678.
8679
8680%
8681% fluent AtDepth(object,depth)
8682 /*
8683.
8684*/
8685.
8686
8687%
8688% ectest/ec_reader_test_ecnet.e:3412
8689% [object,depth1,depth2,time]%
8690% HoldsAt(AtDepth(object,depth1),time) &
8691% HoldsAt(AtDepth(object,depth2),time) ->
8692% depth1 = depth2.
8693 /*
8694holds_at(atDepth(Object, Depth1), Time), holds_at(atDepth(Object, Depth2), Time) ->
8695 Depth1=Depth2.
8696*/
8697.
8698
8699%
8700%
8701% event Ascend(diver,depth)
8702 /*
8703.
8704*/
8705.
8706
8707% ectest/ec_reader_test_ecnet.e:3418
8708%
8709% event Descend(diver,depth)
8710 /*
8711.
8712*/
8713.
8714
8715%
8716% ectest/ec_reader_test_ecnet.e:3421
8717% [diver,depth1,depth2,time]%
8718% HoldsAt(AtDepth(diver,depth1),time) &
8719% Happens(Descend(diver,depth2),time) ->
8720% depth2>depth1.
8721 /*
8722holds_at(atDepth(Diver, Depth1), Time), happens(descend(Diver, Depth2), Time) ->
8723 Depth2>Depth1.
8724*/
8725.
8726
8727%
8728%
8729% ectest/ec_reader_test_ecnet.e:3426
8730% [diver,depth1,depth2,time]%
8731% HoldsAt(AtDepth(diver,depth1),time) &
8732% Happens(Ascend(diver,depth2),time) ->
8733% depth2<depth1.
8734 /*
8735holds_at(atDepth(Diver, Depth1), Time), happens(ascend(Diver, Depth2), Time) ->
8736 Depth2<Depth1.
8737*/
8738.
8739
8740%
8741%
8742% ectest/ec_reader_test_ecnet.e:3431
8743% [diver,depth,time]%
8744% Initiates(Descend(diver,depth),AtDepth(diver,depth),time).
8745 /*
8746.
8747*/
8748.
8749
8750%
8751%
8752% ectest/ec_reader_test_ecnet.e:3434
8753% [diver,depth1,depth2,time]%
8754% HoldsAt(AtDepth(diver,depth1),time) ->
8755% Terminates(Descend(diver,depth2),AtDepth(diver,depth1),time).
8756 /*
8757holds_at(atDepth(Diver, Depth1), Time) ->
8758 terminates(descend(Diver, Depth2),
8759 atDepth(Diver, Depth1),
8760 Time).
8761*/
8762.
8763
8764%
8765%
8766% ectest/ec_reader_test_ecnet.e:3438
8767% [diver,depth,time]%
8768% Initiates(Ascend(diver,depth),AtDepth(diver,depth),time).
8769 /*
8770.
8771*/
8772.
8773
8774%
8775%
8776% ectest/ec_reader_test_ecnet.e:3441
8777% [diver,depth1,depth2,time]%
8778% HoldsAt(AtDepth(diver,depth1),time) ->
8779% Terminates(Ascend(diver,depth2),AtDepth(diver,depth1),time).
8780 /*
8781holds_at(atDepth(Diver, Depth1), Time) ->
8782 terminates(ascend(Diver, Depth2),
8783 atDepth(Diver, Depth1),
8784 Time).
8785*/
8786.
8787
8788%
8789%
8790% fluent Wearing(diver,equipment)
8791 /*
8792.
8793*/
8794.
8795
8796%
8797% ectest/ec_reader_test_ecnet.e:3447
8798% event PutOn(diver,equipment)
8799 /*
8800.
8801*/
8802.
8803
8804%
8805% event TakeOff(diver,equipment)
8806 /*
8807.
8808*/
8809.
8810
8811%
8812% event Lose(diver,equipment)
8813 /*
8814.
8815*/
8816.
8817
8818%
8819% ectest/ec_reader_test_ecnet.e:3453
8820% [diver,equipment,depth,time]%
8821% Releases(PutOn(diver,equipment),AtDepth(equipment,depth),time).
8822 /*
8823.
8824*/
8825.
8826
8827%
8828%
8829% ectest/ec_reader_test_ecnet.e:3456
8830% [diver,equipment,time]%
8831% Releases(PutOn(diver,equipment),UnderWater(equipment),time).
8832 /*
8833.
8834*/
8835.
8836
8837%
8838%
8839% ectest/ec_reader_test_ecnet.e:3459
8840% [diver,equipment,time]%
8841% Happens(PutOn(diver,equipment),time) ->
8842% !{diver1} HoldsAt(Wearing(diver1,equipment),time).
8843 /*
8844happens(putOn(Diver, Equipment), Time) ->
8845 not(exists([Diver1],
8846 holds_at(wearing(Diver1, Equipment), Time))).
8847*/
8848.
8849
8850%
8851%
8852% ectest/ec_reader_test_ecnet.e:3463
8853% [diver,depth,equipment,time]%
8854% HoldsAt(Wearing(diver,equipment),time) ->
8855% (HoldsAt(AtDepth(diver,depth),time) <->
8856% HoldsAt(AtDepth(equipment,depth),time)).
8857 /*
8858holds_at(wearing(Diver, Equipment), Time) ->
8859 ( holds_at(atDepth(Diver, Depth), Time)<->holds_at(atDepth(Equipment, Depth), Time)
8860 ).
8861*/
8862.
8863.
8864
8865%
8866%
8867% ectest/ec_reader_test_ecnet.e:3468
8868% [diver,depth,object,time]%
8869% HoldsAt(Holding(diver,object),time) ->
8870% (HoldsAt(AtDepth(diver,depth),time) <->
8871% HoldsAt(AtDepth(object,depth),time)).
8872 /*
8873holds_at(holding(Diver, Object), Time) ->
8874 ( holds_at(atDepth(Diver, Depth), Time)<->holds_at(atDepth(Object, Depth), Time)
8875 ).
8876*/
8877.
8878.
8879
8880%
8881%
8882% ectest/ec_reader_test_ecnet.e:3473
8883% [diver,equipment,time]%
8884% HoldsAt(Wearing(diver,equipment),time) ->
8885% (HoldsAt(UnderWater(diver),time) <->
8886% HoldsAt(UnderWater(equipment),time)).
8887 /*
8888holds_at(wearing(Diver, Equipment), Time) ->
8889 ( holds_at(underWater(Diver), Time)<->holds_at(underWater(Equipment), Time)
8890 ).
8891*/
8892.
8893.
8894
8895%
8896%
8897% ectest/ec_reader_test_ecnet.e:3478
8898% [diver,object,time]%
8899% HoldsAt(Holding(diver,object),time) ->
8900% (HoldsAt(UnderWater(diver),time) <->
8901% HoldsAt(UnderWater(object),time)).
8902 /*
8903holds_at(holding(Diver, Object), Time) ->
8904 ( holds_at(underWater(Diver), Time)<->holds_at(underWater(Object), Time)
8905 ).
8906*/
8907.
8908.
8909
8910%
8911%
8912% ectest/ec_reader_test_ecnet.e:3483
8913% [diver,depth,equipment,time]%
8914% HoldsAt(AtDepth(diver,depth),time) &
8915% HoldsAt(Wearing(diver,equipment),time) ->
8916% Initiates(TakeOff(diver,equipment),AtDepth(equipment,depth),time).
8917 /*
8918holds_at(atDepth(Diver, Depth), Time), holds_at(wearing(Diver, Equipment), Time) ->
8919 initiates(takeOff(Diver, Equipment),
8920 atDepth(Equipment, Depth),
8921 Time).
8922*/
8923.
8924
8925%
8926%
8927% ectest/ec_reader_test_ecnet.e:3488
8928% [diver,depth,equipment,time]%
8929% !HoldsAt(AtDepth(diver,depth),time) &
8930% HoldsAt(Wearing(diver,equipment),time) ->
8931% Terminates(TakeOff(diver,equipment),AtDepth(equipment,depth),time).
8932 /*
8933not(holds_at(atDepth(Diver, Depth), Time)), holds_at(wearing(Diver, Equipment), Time) ->
8934 terminates(takeOff(Diver, Equipment),
8935 atDepth(Equipment, Depth),
8936 Time).
8937*/
8938.
8939
8940%
8941%
8942% ectest/ec_reader_test_ecnet.e:3493
8943% [diver,equipment,time]%
8944% HoldsAt(UnderWater(diver),time) ->
8945% Initiates(TakeOff(diver,equipment),UnderWater(equipment),time).
8946 /*
8947holds_at(underWater(Diver), Time) ->
8948 initiates(takeOff(Diver, Equipment),
8949 underWater(Equipment),
8950 Time).
8951*/
8952.
8953
8954%
8955%
8956% ectest/ec_reader_test_ecnet.e:3497
8957% [diver,equipment,time]%
8958% !HoldsAt(UnderWater(diver),time) ->
8959% Terminates(TakeOff(diver,equipment),UnderWater(equipment),time).
8960 /*
8961not(holds_at(underWater(Diver), Time)) ->
8962 terminates(takeOff(Diver, Equipment),
8963 underWater(Equipment),
8964 Time).
8965*/
8966.
8967
8968%
8969%
8970% ectest/ec_reader_test_ecnet.e:3501
8971% [diver,equipment,depth,time]%
8972% HoldsAt(AtDepth(diver,depth),time) &
8973% HoldsAt(Wearing(diver,equipment),time) ->
8974% Initiates(Lose(diver,equipment),AtDepth(equipment,depth),time).
8975 /*
8976holds_at(atDepth(Diver, Depth), Time), holds_at(wearing(Diver, Equipment), Time) ->
8977 initiates(lose(Diver, Equipment),
8978 atDepth(Equipment, Depth),
8979 Time).
8980*/
8981.
8982
8983%
8984%
8985% ectest/ec_reader_test_ecnet.e:3506
8986% [diver,equipment,depth,time]%
8987% !HoldsAt(AtDepth(diver,depth),time) &
8988% HoldsAt(Wearing(diver,equipment),time) ->
8989% Terminates(Lose(diver,equipment),AtDepth(equipment,depth),time).
8990 /*
8991not(holds_at(atDepth(Diver, Depth), Time)), holds_at(wearing(Diver, Equipment), Time) ->
8992 terminates(lose(Diver, Equipment),
8993 atDepth(Equipment, Depth),
8994 Time).
8995*/
8996.
8997
8998%
8999%
9000% ectest/ec_reader_test_ecnet.e:3511
9001% [diver,equipment,time]%
9002% HoldsAt(UnderWater(diver),time) ->
9003% Initiates(Lose(diver,equipment),UnderWater(equipment),time).
9004 /*
9005holds_at(underWater(Diver), Time) ->
9006 initiates(lose(Diver, Equipment),
9007 underWater(Equipment),
9008 Time).
9009*/
9010.
9011
9012%
9013%
9014% ectest/ec_reader_test_ecnet.e:3515
9015% [diver,equipment,time]%
9016% !HoldsAt(UnderWater(diver),time) ->
9017% Terminates(Lose(diver,equipment),UnderWater(equipment),time).
9018 /*
9019not(holds_at(underWater(Diver), Time)) ->
9020 terminates(lose(Diver, Equipment),
9021 underWater(Equipment),
9022 Time).
9023*/
9024.
9025
9026%
9027%
9028% fluent Holding(diver,object)
9029 /*
9030.
9031*/
9032.
9033
9034%
9035% ectest/ec_reader_test_ecnet.e:3521
9036% [diver1,diver2,time]%
9037% HoldsAt(Holding(diver1,diver2),time) ->
9038% !HoldsAt(Holding(diver2,diver1),time).
9039 /*
9040holds_at(holding(Diver1, Diver2), Time) ->
9041 not(holds_at(holding(Diver2, Diver1), Time)).
9042*/
9043.
9044
9045%
9046%
9047% event Grab(diver,object)
9048 /*
9049.
9050*/
9051.
9052
9053%
9054% ectest/ec_reader_test_ecnet.e:3527
9055% event LetGoOf(diver,object)
9056 /*
9057.
9058*/
9059.
9060
9061%
9062% ectest/ec_reader_test_ecnet.e:3529
9063% [diver,object,time]%
9064% Initiates(Grab(diver,object),Holding(diver,object),time).
9065 /*
9066.
9067*/
9068.
9069
9070%
9071%
9072% ectest/ec_reader_test_ecnet.e:3532
9073% [diver,object,time]%
9074% Terminates(LetGoOf(diver,object),Holding(diver,object),time).
9075 /*
9076.
9077*/
9078.
9079
9080%
9081%
9082% ectest/ec_reader_test_ecnet.e:3535
9083% [diver,object,depth,time]%
9084% Releases(Grab(diver,object),AtDepth(object,depth),time).
9085 /*
9086.
9087*/
9088.
9089
9090%
9091%
9092% ectest/ec_reader_test_ecnet.e:3538
9093% [diver,object,time]%
9094% Releases(Grab(diver,object),UnderWater(object),time).
9095 /*
9096.
9097*/
9098.
9099
9100%
9101%
9102% ectest/ec_reader_test_ecnet.e:3541
9103% [diver,object,depth,time]%
9104% HoldsAt(AtDepth(diver,depth),time) &
9105% HoldsAt(Holding(diver,object),time) ->
9106% Initiates(LetGoOf(diver,object),AtDepth(object,depth),time).
9107 /*
9108holds_at(atDepth(Diver, Depth), Time), holds_at(holding(Diver, Object), Time) ->
9109 initiates(letGoOf(Diver, Object),
9110 atDepth(Object, Depth),
9111 Time).
9112*/
9113.
9114
9115%
9116%
9117% ectest/ec_reader_test_ecnet.e:3546
9118% [diver,object,depth,time]%
9119% !HoldsAt(AtDepth(diver,depth),time) &
9120% HoldsAt(Holding(diver,object),time) ->
9121% Terminates(LetGoOf(diver,object),AtDepth(object,depth),time).
9122 /*
9123not(holds_at(atDepth(Diver, Depth), Time)), holds_at(holding(Diver, Object), Time) ->
9124 terminates(letGoOf(Diver, Object),
9125 atDepth(Object, Depth),
9126 Time).
9127*/
9128.
9129
9130%
9131%
9132% ectest/ec_reader_test_ecnet.e:3551
9133% [diver,object,time]%
9134% HoldsAt(UnderWater(diver),time) ->
9135% Initiates(LetGoOf(diver,object),UnderWater(object),time).
9136 /*
9137holds_at(underWater(Diver), Time) ->
9138 initiates(letGoOf(Diver, Object),
9139 underWater(Object),
9140 Time).
9141*/
9142.
9143
9144%
9145%
9146% ectest/ec_reader_test_ecnet.e:3555
9147% [diver,object,time]%
9148% !HoldsAt(UnderWater(diver),time) ->
9149% Terminates(LetGoOf(diver,object),UnderWater(object),time).
9150 /*
9151not(holds_at(underWater(Diver), Time)) ->
9152 terminates(letGoOf(Diver, Object),
9153 underWater(Object),
9154 Time).
9155*/
9156.
9157
9158%
9159%
9160% ectest/ec_reader_test_ecnet.e:3559
9161% [diver,equipment,time]%
9162% Initiates(PutOn(diver,equipment),Wearing(diver,equipment),time).
9163 /*
9164.
9165*/
9166.
9167
9168%
9169%
9170% ectest/ec_reader_test_ecnet.e:3562
9171% [diver,equipment,time]%
9172% Happens(PutOn(diver,equipment),time) ->
9173% !HoldsAt(UnderWater(diver),time).
9174 /*
9175happens(putOn(Diver, Equipment), Time) ->
9176 not(holds_at(underWater(Diver), Time)).
9177*/
9178.
9179
9180%
9181%
9182% ectest/ec_reader_test_ecnet.e:3566
9183% [diver,equipment,time]%
9184% Terminates(TakeOff(diver,equipment),Wearing(diver,equipment),time).
9185 /*
9186.
9187*/
9188.
9189
9190%
9191%
9192% ectest/ec_reader_test_ecnet.e:3569
9193% [diver,equipment,time]%
9194% Terminates(Lose(diver,equipment),Wearing(diver,equipment),time).
9195 /*
9196.
9197*/
9198.
9199
9200%
9201%
9202% fluent Vertical(diver)
9203 /*
9204.
9205*/
9206.
9207
9208%
9209% fluent HorizontalDown(diver)
9210 /*
9211.
9212*/
9213.
9214
9215% ectest/ec_reader_test_ecnet.e:3575
9216%
9217% fluent Inverted(diver)
9218 /*
9219.
9220*/
9221.
9222
9223%
9224% fluent HorizontalUp(diver)
9225 /*
9226.
9227*/
9228.
9229
9230%
9231% xor Vertical, HorizontalDown, Inverted, HorizontalUp
9232 /*
9233.
9234*/
9235.
9236
9237% ectest/ec_reader_test_ecnet.e:3581
9238%
9239% event RotatePitch(diver)
9240 /*
9241.
9242*/
9243.
9244
9245%
9246% ectest/ec_reader_test_ecnet.e:3584
9247% [diver,time]%
9248% HoldsAt(Vertical(diver),time) ->
9249% Initiates(RotatePitch(diver),HorizontalDown(diver),time).
9250 /*
9251holds_at(vertical(Diver), Time) ->
9252 initiates(rotatePitch(Diver), horizontalDown(Diver), Time).
9253*/
9254.
9255
9256%
9257%
9258% ectest/ec_reader_test_ecnet.e:3588
9259% [diver,time]%
9260% HoldsAt(HorizontalDown(diver),time) ->
9261% Initiates(RotatePitch(diver),Inverted(diver),time).
9262 /*
9263holds_at(horizontalDown(Diver), Time) ->
9264 initiates(rotatePitch(Diver), inverted(Diver), Time).
9265*/
9266.
9267
9268%
9269%
9270% ectest/ec_reader_test_ecnet.e:3592
9271% [diver,time]%
9272% HoldsAt(HorizontalDown(diver),time) ->
9273% Terminates(RotatePitch(diver),HorizontalDown(diver),time).
9274 /*
9275holds_at(horizontalDown(Diver), Time) ->
9276 terminates(rotatePitch(Diver),
9277 horizontalDown(Diver),
9278 Time).
9279*/
9280.
9281
9282%
9283%
9284% ectest/ec_reader_test_ecnet.e:3596
9285% [diver,time]%
9286% HoldsAt(Inverted(diver),time) ->
9287% Initiates(RotatePitch(diver),HorizontalUp(diver),time).
9288 /*
9289holds_at(inverted(Diver), Time) ->
9290 initiates(rotatePitch(Diver), horizontalUp(Diver), Time).
9291*/
9292.
9293
9294%
9295%
9296% ectest/ec_reader_test_ecnet.e:3600
9297% [diver,time]%
9298% HoldsAt(Inverted(diver),time) ->
9299% Terminates(RotatePitch(diver),Inverted(diver),time).
9300 /*
9301holds_at(inverted(Diver), Time) ->
9302 terminates(rotatePitch(Diver), inverted(Diver), Time).
9303*/
9304.
9305
9306%
9307%
9308% ectest/ec_reader_test_ecnet.e:3604
9309% [diver,time]%
9310% HoldsAt(HorizontalUp(diver),time) ->
9311% Initiates(RotatePitch(diver),Vertical(diver),time).
9312 /*
9313holds_at(horizontalUp(Diver), Time) ->
9314 initiates(rotatePitch(Diver), vertical(Diver), Time).
9315*/
9316.
9317
9318%
9319%
9320% ectest/ec_reader_test_ecnet.e:3608
9321% [diver,time]%
9322% HoldsAt(HorizontalUp(diver),time) ->
9323% Terminates(RotatePitch(diver),HorizontalUp(diver),time).
9324 /*
9325holds_at(horizontalUp(Diver), Time) ->
9326 terminates(rotatePitch(Diver), horizontalUp(Diver), Time).
9327*/
9328.
9329
9330%
9331%
9332% event RotateYaw(diver)
9333 /*
9334.
9335*/
9336.
9337
9338%
9339%; try taking out Holding condition here
9340% ectest/ec_reader_test_ecnet.e:3615
9341% [diver,time]%
9342% Happens(Ascend1(diver),time) &
9343% !Happens(RapidAscendToSurface(diver),time) &
9344% !({diver1} HoldsAt(Holding(diver,diver1),time)) ->
9345% Happens(RotateYaw(diver),time).
9346 /*
9347happens(ascend1(Diver), Time), not(happens(rapidAscendToSurface(Diver), Time)), not(exists([Diver1], holds_at(holding(Diver, Diver1), Time))) ->
9348 happens(rotateYaw(Diver), Time).
9349*/
9350.
9351
9352%
9353%
9354% ectest/ec_reader_test_ecnet.e:3621
9355% fluent UnderWater(object)
9356 /*
9357.
9358*/
9359.
9360
9361%
9362% ectest/ec_reader_test_ecnet.e:3623
9363% [object,depth,time]%
9364% depth>% 0 &
9365% HoldsAt(AtDepth(object,depth),time) ->
9366% HoldsAt(UnderWater(object),time).
9367 /*
9368Depth>0, holds_at(atDepth(Object, Depth), Time) ->
9369 holds_at(underWater(Object), Time).
9370*/
9371.
9372
9373%
9374%
9375% event EnterWater(object)
9376 /*
9377.
9378*/
9379.
9380
9381% ectest/ec_reader_test_ecnet.e:3629
9382%
9383% event Surface(object)
9384 /*
9385.
9386*/
9387.
9388
9389%
9390% ectest/ec_reader_test_ecnet.e:3632
9391% [object,time]%
9392% Initiates(EnterWater(object),UnderWater(object),time).
9393 /*
9394.
9395*/
9396.
9397
9398%
9399%
9400% ectest/ec_reader_test_ecnet.e:3635
9401% [diver,time]%
9402% Happens(EnterWater(diver),time) ->
9403% !{diver1} HoldsAt(Holding(diver1,diver),time).
9404 /*
9405happens(enterWater(Diver), Time) ->
9406 not(exists([Diver1],
9407 holds_at(holding(Diver1, Diver), Time))).
9408*/
9409.
9410
9411%
9412%
9413% ectest/ec_reader_test_ecnet.e:3639
9414% [object,depth,time]%
9415% depth=% 0 ->
9416% Initiates(EnterWater(object),AtDepth(object,depth),time).
9417 /*
9418Depth=0 ->
9419 initiates(enterWater(Object),
9420 atDepth(Object, Depth),
9421 Time).
9422*/
9423.
9424
9425%
9426%
9427% ectest/ec_reader_test_ecnet.e:3643
9428% [object,time]%
9429% Terminates(Surface(object),UnderWater(object),time).
9430 /*
9431.
9432*/
9433.
9434
9435%
9436%
9437% ectest/ec_reader_test_ecnet.e:3646
9438% [diver,time]%
9439% Terminates(Surface(diver),PositivelyBuoyant(diver),time).
9440 /*
9441.
9442*/
9443.
9444
9445%
9446%
9447% ectest/ec_reader_test_ecnet.e:3649
9448% [diver,time]%
9449% Terminates(Surface(diver),NegativelyBuoyant(diver),time).
9450 /*
9451.
9452*/
9453.
9454
9455%
9456%
9457% ectest/ec_reader_test_ecnet.e:3652
9458% [diver,time]%
9459% Terminates(Surface(diver),NeutrallyBuoyant(diver),time).
9460 /*
9461.
9462*/
9463.
9464
9465%
9466%
9467% ectest/ec_reader_test_ecnet.e:3655
9468% [object,depth,time]%
9469% Terminates(Surface(object),AtDepth(object,depth),time).
9470 /*
9471.
9472*/
9473.
9474
9475%
9476%
9477% ectest/ec_reader_test_ecnet.e:3658
9478% [diver,time] % Happens(EnterWater(diver),time) ->
9479% HoldsAt(Vertical(diver),time).
9480 /*
9481happens(enterWater(Diver), Time) ->
9482 holds_at(vertical(Diver), Time).
9483*/
9484.
9485
9486%
9487%
9488% fluent StandingOn(diver,boat)
9489 /*
9490.
9491*/
9492.
9493
9494%
9495% event StandOn(diver,boat)
9496 /*
9497.
9498*/
9499.
9500
9501% ectest/ec_reader_test_ecnet.e:3664
9502%
9503% ectest/ec_reader_test_ecnet.e:3665
9504% [diver,boat,time]%
9505% Terminates(EnterWater(diver),StandingOn(diver,boat),time).
9506 /*
9507.
9508*/
9509.
9510
9511%
9512%
9513% ectest/ec_reader_test_ecnet.e:3668
9514% [diver,boat,time]%
9515% Initiates(StandOn(diver,boat),StandingOn(diver,boat),time).
9516 /*
9517.
9518*/
9519.
9520
9521%
9522%
9523% fluent PositivelyBuoyant(diver)
9524 /*
9525.
9526*/
9527.
9528
9529%
9530% fluent NeutrallyBuoyant(diver)
9531 /*
9532.
9533*/
9534.
9535
9536% ectest/ec_reader_test_ecnet.e:3674
9537%
9538% fluent NegativelyBuoyant(diver)
9539 /*
9540.
9541*/
9542.
9543
9544%
9545% mutex PositivelyBuoyant, NeutrallyBuoyant, NegativelyBuoyant
9546 /*
9547.
9548*/
9549.
9550
9551 /*
9552.
9553*/
9554.
9555
9556 /*
9557.
9558*/
9559.
9560
9561%
9562% ectest/ec_reader_test_ecnet.e:3679
9563% [diver,time]%
9564% HoldsAt(PositivelyBuoyant(diver),time) ->
9565% HoldsAt(UnderWater(diver),time).
9566 /*
9567holds_at(positivelyBuoyant(Diver), Time) ->
9568 holds_at(underWater(Diver), Time).
9569*/
9570.
9571
9572%
9573%
9574% ectest/ec_reader_test_ecnet.e:3683
9575% [diver,time]%
9576% HoldsAt(NeutrallyBuoyant(diver),time) ->
9577% HoldsAt(UnderWater(diver),time).
9578 /*
9579holds_at(neutrallyBuoyant(Diver), Time) ->
9580 holds_at(underWater(Diver), Time).
9581*/
9582.
9583
9584%
9585%
9586% ectest/ec_reader_test_ecnet.e:3687
9587% [diver,time]%
9588% HoldsAt(NegativelyBuoyant(diver),time) ->
9589% HoldsAt(UnderWater(diver),time).
9590 /*
9591holds_at(negativelyBuoyant(Diver), Time) ->
9592 holds_at(underWater(Diver), Time).
9593*/
9594.
9595
9596%
9597%
9598% event PressDeflateButton(diver,bc)
9599 /*
9600.
9601*/
9602.
9603
9604%
9605% ectest/ec_reader_test_ecnet.e:3693
9606% event PressDumpButton(diver,bc)
9607 /*
9608.
9609*/
9610.
9611
9612%
9613% event PressInflateButton(diver,bc)
9614 /*
9615.
9616*/
9617.
9618
9619%
9620% ectest/ec_reader_test_ecnet.e:3697
9621% [diver,bc,time]%
9622% Happens(PressDeflateButton(diver,bc),time) ->
9623% HoldsAt(Vertical(diver),time) &
9624% HoldsAt(UnderWater(bc),time).
9625 /*
9626happens(pressDeflateButton(Diver, Bc), Time) ->
9627 holds_at(vertical(Diver), Time),
9628 holds_at(underWater(Bc), Time).
9629*/
9630.
9631
9632%
9633%
9634% ectest/ec_reader_test_ecnet.e:3702
9635% [diver,bc,time]%
9636% Happens(PressDumpButton(diver,bc),time) ->
9637% HoldsAt(Vertical(diver),time) &
9638% HoldsAt(UnderWater(bc),time).
9639 /*
9640happens(pressDumpButton(Diver, Bc), Time) ->
9641 holds_at(vertical(Diver), Time),
9642 holds_at(underWater(Bc), Time).
9643*/
9644.
9645
9646%
9647%
9648% ectest/ec_reader_test_ecnet.e:3707
9649% [diver,bc,time] % Happens(PressDumpButton(diver,bc),time) ->
9650% HoldsAt(UncontrolledBuoyancy(diver),time).
9651 /*
9652happens(pressDumpButton(Diver, Bc), Time) ->
9653 holds_at(uncontrolledBuoyancy(Diver), Time).
9654*/
9655.
9656
9657%
9658%
9659% ectest/ec_reader_test_ecnet.e:3710
9660% [diver,bc,time]%
9661% HoldsAt(Wearing(diver,bc),time) ->
9662% Initiates(PressDeflateButton(diver,bc),NegativelyBuoyant(diver),time).
9663 /*
9664holds_at(wearing(Diver, Bc), Time) ->
9665 initiates(pressDeflateButton(Diver, Bc),
9666 negativelyBuoyant(Diver),
9667 Time).
9668*/
9669.
9670
9671%
9672%
9673% ectest/ec_reader_test_ecnet.e:3714
9674% [diver,bc,time]%
9675% HoldsAt(Wearing(diver,bc),time) ->
9676% Terminates(PressDeflateButton(diver,bc),NeutrallyBuoyant(diver),time).
9677 /*
9678holds_at(wearing(Diver, Bc), Time) ->
9679 terminates(pressDeflateButton(Diver, Bc),
9680 neutrallyBuoyant(Diver),
9681 Time).
9682*/
9683.
9684
9685%
9686%
9687% ectest/ec_reader_test_ecnet.e:3718
9688% [diver,bc,time]%
9689% HoldsAt(Wearing(diver,bc),time) ->
9690% Terminates(PressDeflateButton(diver,bc),PositivelyBuoyant(diver),time).
9691 /*
9692holds_at(wearing(Diver, Bc), Time) ->
9693 terminates(pressDeflateButton(Diver, Bc),
9694 positivelyBuoyant(Diver),
9695 Time).
9696*/
9697.
9698
9699%
9700%
9701% ectest/ec_reader_test_ecnet.e:3722
9702% [diver,bc,time]%
9703% HoldsAt(Wearing(diver,bc),time) ->
9704% Initiates(PressDumpButton(diver,bc),NegativelyBuoyant(diver),time).
9705 /*
9706holds_at(wearing(Diver, Bc), Time) ->
9707 initiates(pressDumpButton(Diver, Bc),
9708 negativelyBuoyant(Diver),
9709 Time).
9710*/
9711.
9712
9713%
9714%
9715% ectest/ec_reader_test_ecnet.e:3726
9716% [diver,bc,time]%
9717% HoldsAt(Wearing(diver,bc),time) ->
9718% Terminates(PressDumpButton(diver,bc),NeutrallyBuoyant(diver),time).
9719 /*
9720holds_at(wearing(Diver, Bc), Time) ->
9721 terminates(pressDumpButton(Diver, Bc),
9722 neutrallyBuoyant(Diver),
9723 Time).
9724*/
9725.
9726
9727%
9728%
9729% ectest/ec_reader_test_ecnet.e:3730
9730% [diver,bc,time]%
9731% HoldsAt(Wearing(diver,bc),time) ->
9732% Terminates(PressDumpButton(diver,bc),PositivelyBuoyant(diver),time).
9733 /*
9734holds_at(wearing(Diver, Bc), Time) ->
9735 terminates(pressDumpButton(Diver, Bc),
9736 positivelyBuoyant(Diver),
9737 Time).
9738*/
9739.
9740
9741%
9742%
9743% ectest/ec_reader_test_ecnet.e:3734
9744% [diver,bc,time]%
9745% HoldsAt(Wearing(diver,bc),time) ->
9746% Initiates(PressInflateButton(diver,bc),NeutrallyBuoyant(diver),time).
9747 /*
9748holds_at(wearing(Diver, Bc), Time) ->
9749 initiates(pressInflateButton(Diver, Bc),
9750 neutrallyBuoyant(Diver),
9751 Time).
9752*/
9753.
9754
9755%
9756%
9757% ectest/ec_reader_test_ecnet.e:3738
9758% [diver,bc,time]%
9759% HoldsAt(Wearing(diver,bc),time) ->
9760% Terminates(PressInflateButton(diver,bc),PositivelyBuoyant(diver),time).
9761 /*
9762holds_at(wearing(Diver, Bc), Time) ->
9763 terminates(pressInflateButton(Diver, Bc),
9764 positivelyBuoyant(Diver),
9765 Time).
9766*/
9767.
9768
9769%
9770%
9771% ectest/ec_reader_test_ecnet.e:3742
9772% [diver,bc,time]%
9773% HoldsAt(Wearing(diver,bc),time) ->
9774% Terminates(PressInflateButton(diver,bc),NegativelyBuoyant(diver),time).
9775 /*
9776holds_at(wearing(Diver, Bc), Time) ->
9777 terminates(pressInflateButton(Diver, Bc),
9778 negativelyBuoyant(Diver),
9779 Time).
9780*/
9781.
9782
9783%
9784%
9785% ectest/ec_reader_test_ecnet.e:3746
9786% [diver,weight,time]%
9787% HoldsAt(Wearing(diver,weight),time) ->
9788% Initiates(TakeOff(diver,weight),PositivelyBuoyant(diver),time).
9789 /*
9790holds_at(wearing(Diver, Weight), Time) ->
9791 initiates(takeOff(Diver, Weight),
9792 positivelyBuoyant(Diver),
9793 Time).
9794*/
9795.
9796
9797%
9798%
9799% ectest/ec_reader_test_ecnet.e:3750
9800% [diver,weight,time]%
9801% HoldsAt(Wearing(diver,weight),time) ->
9802% Terminates(TakeOff(diver,weight),NegativelyBuoyant(diver),time).
9803 /*
9804holds_at(wearing(Diver, Weight), Time) ->
9805 terminates(takeOff(Diver, Weight),
9806 negativelyBuoyant(Diver),
9807 Time).
9808*/
9809.
9810
9811%
9812%
9813% ectest/ec_reader_test_ecnet.e:3754
9814% [diver,weight,time]%
9815% HoldsAt(Wearing(diver,weight),time) ->
9816% Terminates(TakeOff(diver,weight),NeutrallyBuoyant(diver),time).
9817 /*
9818holds_at(wearing(Diver, Weight), Time) ->
9819 terminates(takeOff(Diver, Weight),
9820 neutrallyBuoyant(Diver),
9821 Time).
9822*/
9823.
9824
9825%
9826%
9827% fluent UncontrolledBuoyancy(diver)
9828 /*
9829.
9830*/
9831.
9832
9833%
9834% ectest/ec_reader_test_ecnet.e:3760
9835% event LoseBuoyancyControl(diver)
9836 /*
9837.
9838*/
9839.
9840
9841%
9842% predicate IsInexperiencedDiver(diver)
9843 /*
9844.
9845*/
9846.
9847
9848%
9849% ectest/ec_reader_test_ecnet.e:3764
9850% [diver,time]%
9851% Happens(LoseBuoyancyControl(diver),time) ->
9852% IsInexperiencedDiver(diver).
9853 /*
9854happens(loseBuoyancyControl(Diver), Time) ->
9855 isInexperiencedDiver(Diver).
9856*/
9857.
9858
9859%
9860%
9861% ectest/ec_reader_test_ecnet.e:3768
9862% [diver,time]%
9863% Initiates(LoseBuoyancyControl(diver),UncontrolledBuoyancy(diver),time).
9864 /*
9865.
9866*/
9867.
9868
9869%
9870%
9871% ectest/ec_reader_test_ecnet.e:3771
9872% [diver,time]%
9873% Initiates(LoseBuoyancyControl(diver),PositivelyBuoyant(diver),time).
9874 /*
9875.
9876*/
9877.
9878
9879%
9880%
9881% ectest/ec_reader_test_ecnet.e:3774
9882% [diver,time]%
9883% Terminates(LoseBuoyancyControl(diver),NegativelyBuoyant(diver),time).
9884 /*
9885.
9886*/
9887.
9888
9889%
9890%
9891% ectest/ec_reader_test_ecnet.e:3777
9892% [diver,time]%
9893% Terminates(LoseBuoyancyControl(diver),NeutrallyBuoyant(diver),time).
9894 /*
9895.
9896*/
9897.
9898
9899%
9900%
9901%; determining fluent
9902% fluent AscendDescendAmount(diver,depth)
9903 /*
9904.
9905*/
9906.
9907
9908% noninertial AscendDescendAmount
9909 /*
9910.
9911*/
9912.
9913
9914% ectest/ec_reader_test_ecnet.e:3783
9915%
9916% ectest/ec_reader_test_ecnet.e:3784
9917% [diver,depth1,depth2,time]%
9918% HoldsAt(AscendDescendAmount(diver,depth1),time) &
9919% HoldsAt(AscendDescendAmount(diver,depth2),time) ->
9920% depth1=depth2.
9921 /*
9922holds_at(ascendDescendAmount(Diver, Depth1), Time), holds_at(ascendDescendAmount(Diver, Depth2), Time) ->
9923 Depth1=Depth2.
9924*/
9925.
9926
9927%
9928%
9929% ectest/ec_reader_test_ecnet.e:3789
9930% [diver,depth,time]%
9931% Happens(Descend(diver,depth),time) ->
9932% HoldsAt(NegativelyBuoyant(diver),time) &
9933% ({depth1}
9934% HoldsAt(AscendDescendAmount(diver,depth1),time) &
9935% HoldsAt(AtDepth(diver,depth-depth1),time)).
9936 /*
9937happens(descend(Diver, Depth), Time) ->
9938 holds_at(negativelyBuoyant(Diver), Time),
9939 exists([Depth1],
9940 (holds_at(ascendDescendAmount(Diver, Depth1), Time), holds_at(atDepth(Diver, Depth-Depth1), Time))).
9941*/
9942.
9943
9944%
9945% ectest/ec_reader_test_ecnet.e:3795
9946%
9947% event KickUp(diver)
9948 /*
9949.
9950*/
9951.
9952
9953%
9954% ectest/ec_reader_test_ecnet.e:3798
9955% [diver,depth,time]%
9956% Happens(Ascend(diver,depth),time) ->
9957% (HoldsAt(PositivelyBuoyant(diver),time) |
9958% (HoldsAt(NeutrallyBuoyant(diver),time) & Happens(KickUp(diver),time))) &
9959% ({depth1}
9960% HoldsAt(AscendDescendAmount(diver,depth1),time) &
9961% HoldsAt(AtDepth(diver,depth+depth1),time)).
9962 /*
9963happens(ascend(Diver, Depth), Time) ->
9964 ( holds_at(positivelyBuoyant(Diver), Time)
9965 ; holds_at(neutrallyBuoyant(Diver), Time),
9966 happens(kickUp(Diver), Time)
9967 ),
9968 exists([Depth1],
9969 (holds_at(ascendDescendAmount(Diver, Depth1), Time), holds_at(atDepth(Diver, Depth+Depth1), Time))).
9970*/
9971.
9972
9973% ectest/ec_reader_test_ecnet.e:3804
9974%
9975%
9976% ectest/ec_reader_test_ecnet.e:3806
9977% [diver,time]%
9978% Happens(KickUp(diver),time) ->
9979% HoldsAt(Vertical(diver),time).
9980 /*
9981happens(kickUp(Diver), Time) ->
9982 holds_at(vertical(Diver), Time).
9983*/
9984.
9985
9986%
9987%
9988% event SwimAround(diver)
9989 /*
9990.
9991*/
9992.
9993
9994%
9995% ectest/ec_reader_test_ecnet.e:3812
9996% [diver,time]%
9997% Happens(SwimAround(diver),time) ->
9998% HoldsAt(HorizontalDown(diver),time).
9999 /*
10000happens(swimAround(Diver), Time) ->
10001 holds_at(horizontalDown(Diver), Time).
10002*/
10003.
10004
10005%
10006%
10007%; signaling
10008%
10009% ectest/ec_reader_test_ecnet.e:3818
10010% event SignalDescend(diver,diver)
10011 /*
10012.
10013*/
10014.
10015
10016%
10017% event SignalOutOfTime(diver,diver)
10018 /*
10019.
10020*/
10021.
10022
10023%
10024% event SignalAscend(diver,diver)
10025 /*
10026.
10027*/
10028.
10029
10030%
10031%;[diver1,diver2,time]
10032%;Happens(SignalAscend(diver1,diver2),time) ->
10033%;Happens(SignalOutOfTime(diver1,diver2),time-1).
10034% ectest/ec_reader_test_ecnet.e:3827
10035%
10036%;[diver1,diver2,time]
10037%;Happens(SignalDescend(diver1,diver2),time) ->
10038%;HoldsAt(See(diver1,diver2),time) &
10039%;HoldsAt(See(diver2,diver1),time).
10040%
10041%;[diver1,diver2,time]
10042%;Happens(SignalOutOfTime(diver1,diver2),time) ->
10043%;HoldsAt(See(diver1,diver2),time) &
10044%;HoldsAt(See(diver2,diver1),time).
10045% ectest/ec_reader_test_ecnet.e:3837
10046%
10047%;[diver1,diver2,time]
10048%;Happens(SignalAscend(diver1,diver2),time) ->
10049%;HoldsAt(See(diver1,diver2),time) &
10050%;HoldsAt(See(diver2,diver1),time).
10051%
10052%;event LookAt(agent,object)
10053% ectest/ec_reader_test_ecnet.e:3844
10054%
10055%;fluent See(agent,object)
10056%
10057%;[agent,object,time]
10058%;Initiates(LookAt(agent,object),See(agent,object),time).
10059%
10060%;[agent,object1,object2,time]
10061%;object1!=object2 ->
10062%;Terminates(LookAt(agent,object1),
10063%; See(agent,object2),
10064%; time).
10065% ectest/ec_reader_test_ecnet.e:3855
10066%
10067% event Descend1(diver)
10068 /*
10069.
10070*/
10071.
10072
10073%
10074% event Ascend1(diver)
10075 /*
10076.
10077*/
10078.
10079
10080%
10081%;[diver,object,time]
10082%;Terminates(Descend1(diver),See(diver,object),time).
10083% ectest/ec_reader_test_ecnet.e:3862
10084%
10085%;[diver,object,time]
10086%;Terminates(Ascend1(diver),See(diver,object),time).
10087%
10088%;[diver,object,time]
10089%;Terminates(RotateYaw(diver),See(diver,object),time).
10090% ectest/ec_reader_test_ecnet.e:3868
10091%
10092% event RapidAscendToSurface(diver)
10093 /*
10094.
10095*/
10096.
10097
10098%
10099% ectest/ec_reader_test_ecnet.e:3871
10100% [diver,time]%
10101% Happens(Descend1(diver),time) <->
10102% ({depth} Happens(Descend(diver,depth),time)).
10103 /*
10104happens(descend1(Diver), Time) <->
10105 exists([Depth], happens(descend(Diver, Depth), Time)).
10106*/
10107.
10108.
10109
10110%
10111%
10112% ectest/ec_reader_test_ecnet.e:3875
10113% [diver,time]%
10114% Happens(Ascend1(diver),time) <->
10115% ({depth} Happens(Ascend(diver,depth),time)).
10116 /*
10117happens(ascend1(Diver), Time) <->
10118 exists([Depth], happens(ascend(Diver, Depth), Time)).
10119*/
10120.
10121.
10122
10123%
10124%
10125% ectest/ec_reader_test_ecnet.e:3879
10126% [diver,time]%
10127% Happens(RapidAscendToSurface(diver),time) ->
10128% Happens(Ascend(diver,0),time).
10129 /*
10130happens(rapidAscendToSurface(Diver), Time) ->
10131 happens(ascend(Diver, 0), Time).
10132*/
10133.
10134
10135%
10136%
10137% event AscendLine(diver,line)
10138 /*
10139.
10140*/
10141.
10142
10143%
10144% ectest/ec_reader_test_ecnet.e:3885
10145% [diver,line,time]%
10146% Happens(AscendLine(diver,line),time) ->
10147% Happens(Ascend1(diver),time).
10148 /*
10149happens(ascendLine(Diver, Line), Time) ->
10150 happens(ascend1(Diver), Time).
10151*/
10152.
10153
10154%
10155%
10156% fluent Disoriented(diver)
10157 /*
10158.
10159*/
10160.
10161
10162%
10163% ectest/ec_reader_test_ecnet.e:3891
10164% event BecomeDisoriented(diver)
10165 /*
10166.
10167*/
10168.
10169
10170%
10171% event BecomeReoriented(diver)
10172 /*
10173.
10174*/
10175.
10176
10177%
10178% ectest/ec_reader_test_ecnet.e:3895
10179% [diver,time]%
10180% Initiates(BecomeDisoriented(diver),Disoriented(diver),time).
10181 /*
10182.
10183*/
10184.
10185
10186%
10187%
10188% ectest/ec_reader_test_ecnet.e:3898
10189% [diver,time]%
10190% Terminates(BecomeReoriented(diver),Disoriented(diver),time).
10191 /*
10192.
10193*/
10194.
10195
10196%
10197%
10198% fluent DisturbedSilt()
10199 /*
10200.
10201*/
10202.
10203
10204%
10205% event DisturbSilt(diver)
10206 /*
10207.
10208*/
10209.
10210
10211% ectest/ec_reader_test_ecnet.e:3904
10212%
10213% ectest/ec_reader_test_ecnet.e:3905
10214% [diver,time]%
10215% Initiates(DisturbSilt(diver),DisturbedSilt(),time).
10216 /*
10217.
10218*/
10219.
10220
10221%
10222%
10223% ectest/ec_reader_test_ecnet.e:3908
10224% [diver,time]%
10225% Happens(BecomeDisoriented(diver),time) ->
10226% (!HoldsAt(DisturbedSilt(),time-1) &
10227% HoldsAt(DisturbedSilt(),time)).
10228 /*
10229happens(becomeDisoriented(Diver), Time) ->
10230 not(holds_at(disturbedSilt(), Time-1)),
10231 holds_at(disturbedSilt(), Time).
10232*/
10233.
10234
10235%
10236%
10237% event Panic(diver)
10238 /*
10239.
10240*/
10241.
10242
10251