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
10243% ectest/ec_reader_test_ecnet.e:3914
10244% 
10245% ectest/ec_reader_test_ecnet.e:3915
10246% [diver,time] % Happens(Panic(diver),time) ->
10247% HoldsAt(Disoriented(diver),time) |
10248% HoldsAt(UncontrolledBuoyancy(diver),time) |
10249% ({equipment} Happens(Lose(diver,equipment),time-1)) |
10250% Happens(Vomit(diver),time-1).
10251 /*
10252(   ( happens(panic(Diver), Time)->holds_at(disoriented(Diver), Time)
10253    )
10254;   holds_at(uncontrolledBuoyancy(Diver), Time)
10255;   exists([Equipment],
10256           happens(lose(Diver, Equipment), Time-1))
10257;   happens(vomit(Diver), Time-1)
10258).
10259*/