12:-module(logicmoo_hyhtn_works,[]). 13
14:-multifile(user:push_env_ctx/0). 15:-dynamic(user:push_env_ctx/0). 16
21
22
23
25:- ensure_loaded(library(logicmoo_common)). 26:- ensure_loaded(library(planner_api)). 27:- use_module(library(logicmoo_planner)). 28
29:- kb_shared(baseKB:mpred_prop/3). 30
31:- ensure_loaded(library(logicmoo/util_structs)). 32:- ensure_loaded(library(logicmoo/util_bb_env)). 33:- prolog_load_context(file,File),ain(user:env_source_file(File)). 34
35:-op(500,fx,env_call). 36
59 62:-use_module(library(system)). 64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115:- dynamic op_num/1, my_stats/1.
116:- dynamic node/7,final_node/1. 117:- dynamic methodC/7, opParent/6,operatorC/5,gOperator/3. 118:- dynamic tp_goal/3,tp_node/6,closed_node/6,solved_node/5,solved_node/2. 119:- dynamic goal_related/4. 120:- dynamic goal_related/3. 121:- dynamic tn/6. 122:- dynamic opCounter/1, temp/1. 123:- dynamic objectsC/2,atomic_invariantsC/1. 124:- dynamic objectsOfSort/2. 126:- dynamic kill_file/1,solution_file/1. 129:- style_check(-singleton). 133:- op(100,xfy,'=>'). 146
147op_num(0).
148my_stats(0).
149
150startOCL(Goal,Init):-
151 dmsg('startOCL-PLANNER-TASK'(Goal)),
152 planner_interface(Goal,Init,Sol,_,TNLst),
153 solution_file(F),
154 tell(F),
155 write('TASK '),write(Id),nl,
156 write('SOLUTION'),nl,
157 display_sol(Sol),
158 write('END FILE'),nl,nl,
159 reverse(TNLst,TNForward),
160 display_details(TNForward),
161 write('END PLANNER RESULT'),
162 told,(clean).
163
164solve(Id) :-
165 htn_task(Id,Goal,Init),
166 planner_interface(Goal,Init,Sol,_,TNLst),
167 solution_file(F),
168 tell(F),
169 write('TASK '),write(Id),nl,
170 write('SOLUTION'),nl,
171 display_sol(Sol),
172 write('END FILE'),nl,nl,
173 reverse(TNLst,TNForward),
174 display_details(TNForward),
175 write('END PLANNER RESULT'),
176 told,
177 clean.
178
179solve(Id) :-
180 planner_task(Id,Goal,Init),
181 planner_interface(Goal,Init,Sol,_,TNLst),
182 solution_file(F),
183 tell(F),
184 write('TASK '),write(Id),nl,
185 write('SOLUTION'),nl,
186 display_sol(Sol),
187 write('END FILE'),nl,nl,
188 reverse(TNLst,TNForward),
189 display_details(TNForward),
190 write('END PLANNER RESULT'),
191 told,
192 clean.
193
194display_sol([]).
195display_sol([H|T]) :-
196 write(H),
197 nl,
198 display_sol(T).
199
200display_details([]).
201display_details([tn(TN,Name,Pre,Post,Temp,Dec)|Rest]) :-
203 nl,write('BEGIN METHOD'),nl,write(TN),write(';'),
204 nl,write('Name:'),write(Name),write(';'),
205 nl,write('Pre-condition:'),write(Pre),write(';'),
208 nl,write('Temporal Constraints:'),write(Temp),write(';'),
209 nl,write('Decomposition:'),write(Dec),write(';'),
210 nl,
211 display_details(Rest).
212
213
214clean:-
215 retractall(op_num(_)),
216 retractall(my_stats(_)),
217 retractall(current_num(_,_)),
218 retractall(node(_,_,_,_,_)),
219 retractall(final_node(_)),
220 retractall(tn(_,_,_,_,_,_)),
221 retractall(methodC(_,_,_,_,_,_,_)),
222 retractall(operatorC(_,_,_,_,_)),
223 retractall(gOperator(_,_,_)),
224 retractall(goal_related(_,_,_)),
225 retractall(goal_related_search(_)),
226 retractall(opCounter(_)),
227 retractall(opParent(_,_,_,_,_,_)),
228 retractall(temp(_)),
229 retractall(objectsOfSort(_,_)),
230 retractall(related_op(_)),
231 retractall(op_score(_,_)),
232 retractall(objectsC(_,_)),
233 retractall(solved_node(_,_)),
234 retractall(tp_node(_,_,_,_,_,_)),
235 retractall(closed_node(_,_,_,_,_,_)),
236 retractall(score_list(_)),
237 retractall(atomic_invariantsC(_)),
238 retractall(gsubstate_classes(_,_,_)),
239 retractall(is_of_sort(_,_)),
240 retractall(is_of_primitive_sort(_,_)),
241 retractall(objectsD(_,_)),
242 assert(op_num(0)),
243 assert(my_stats(0)).
244
245planner_interface(G,I, SOLN,OPNUM,TNList):-
246 change_obj_list(I),
247 ground_op,
248 assert_is_of_sort,
249 change_op_representation,
250 prim_substate_class,
251 retract(op_num(_)),
252 assert(op_num(0)),
253 statistics(runtime,[_,Time]),
254 (retract(my_stats(_)) ; true),
255 assert(my_stats(Time)),
256 make_problem_into_node(I, G, Node),
257 assert(Node),
258 start_solve(SOLN,OPNUM,TNList).
259planner_interface(G,I, SOLN,OPNUM,TNList):-
260 tell(user),nl,write('failure in initial node'),!.
261
265
266getN_name(node(Name, _, _, _,_), Name).
267getN_pre(node(_,Pre, _, _, _), Pre).
268getN_decomp(node(_, _, Decomp,_,_), Decomp).
269getH_temp(node(_, _, _,Temps, _), Temps).
270getN_statics(node(_,_,_,_,Statics), Statics).
271
273start_solve(SOLN,OPNUM,_):-
274 kill_file(Kill),
275 file_exists(Kill).
277
278start_solve(Sol,OPNUM,TNList):-
279 retract(final_node(Node)),
280 retractall(current_num(_,_)),
281 getN_statics(Node,Statics),
282 statics_consist(Statics),
283 extract_solution(Node,Sol,SIZE,TNList),
284 statistics(runtime,[_,CP]),
285 TIM is CP/1000, tell(user),
286 retract(op_num(OPNUM)),
287 assert(op_num(0)),
288 nl, nl, write('CPU Time = '),write(CP),nl,
289 write('TIME TAKEN = '),write(TIM),
290 write(' SECONDS'),nl,
291 write('Solution SIZE = '),write(SIZE),nl,
292 write('Operator Used = '),write(OPNUM),nl,
293 write('***************************************'),
294 assert(time_taken(CP)),
295 assert(soln_size(SIZE)),
296 retractall(tn(_,_,_,_,_,_)),
297 !.
298start_solve(Sol,OPNUM,TNList):-
299 select_node(Node),
301 302 process_node(Node),
303 start_solve(Sol,OPNUM,TNList).
304start_solve(Sol,OPNUM,TNList):-
305 tell(user), write('+++ task FAILED +++'),
306 clean.
307
308:- discontiguous expand_decomp/8. 309:- discontiguous expand_node1/8. 310
312
314process_node(Node) :-
315 getN_name(Node, Name),
316 getN_pre(Node, Pre),
317 getN_decomp(Node, Dec),
318 getH_temp(Node, Temps),
319 getN_statics(Node, Statics),
320 expand_decomp(Dec,Pre,Post,Temps,Temp1,Statics,Statics1,Dec1),
321 statics_consist(Statics),
322 assert_node(Name,Pre,Dec1,Temp1,Statics1).
323
324assert_node(Name,Pre,Decomp,Temp,Statics):-
325 all_HP_expanded(Decomp),
326 assert(final_node(node(Name,Pre,Decomp,Temp,Statics))),!.
327assert_node(Name,Pre,Dec,Temp,Statics):-
328 gensym_special(root,SYM),
329 assert(node(SYM,Pre,Dec,Temp,Statics)),!.
330
331all_HP_expanded([]):-!.
332all_HP_expanded([step(HPid,Name,_,_,exp(TN))|THPS]):-
333 all_HP_expanded(THPS),!.
334
340expand_decomp([],Post,Post,Temp,Temp,Statics,Statics,[]):-!.
341
343expand_decomp([step(HPid,Name,Pre0,Post0,exp(TN))|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,[step(HPid,Name,Pre,State,exp(TN))|Decomp1]):-
344 state_achieved(Pre0,Pre),
345 state_change(Pre,Pre0,Post0,State),
346 statics_consist(Statics),
347 expand_decomp(Decomp,State,Post,Temp,Temp1,Statics,Statics1,Decomp1),!.
348
350expand_decomp([step(HPid,ACH,Pre0,Post0,unexp)|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,Decomp1):-
351 ACH=..[achieve|_],
352 statics_consist(Statics),
353 expand_decomp_ach([step(HPid,ACH,Pre,Post0,unexp)|Decomp],Pre,Post,
354 Temp,Temp1,Statics,Statics1,Decomp1),!.
355
357expand_decomp([step(HPid,Name,undefd,undefd,unexp)|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,[step(HPid,Name,Pre,State,exp(Name))|Decomp1]):-
358 apply_op(Name,HPid,Name,Pre,undefd,State,Statics,Statics2),
359 expand_decomp(Decomp,State,Post,Temp,Temp1,Statics2,Statics1,Decomp1),!.
360
362apply_op(Name,HPid,Name,Pre,Post,State,Statics,Statics1):-
363 operatorC(Name,Pre0,Post0,Cond,Statics0),
364 statics_append(Statics0,Statics,Statics2),
365 state_achieved(Pre,Pre0,Statics2),
366 state_change(Pre,Pre0,Post0,State2),
367 cond_state_change(State2,Cond,State),
368 all_achieved(Post,Statics2,State),
369 remove_unneed(Statics2,[],Statics1),
370 statics_consist_instance(Statics1),
371 statics_consist_instance(Statics0),
372 retract(op_num(N)),
373 N1 is N+1,
374 assert(op_num(N1)),!.
375
378expand_decomp([step(HPid,Name,undefd,undefd,unexp)|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,[step(HPid,Name,Pre,State,exp(TN))|Decomp1]):-
379 apply_method(TN,HPid,Name,Pre,undefd,State,Statics,Statics2),
380 expand_decomp(Decomp,State,Post,Temp,Temp1,Statics2,Statics1,Decomp1),!.
381
383apply_method(TN,HPid,Name,Pre,Post,State,Statics,Statics1):-
384 methodC(Name,Pre0,Post0,Statics0,Temp0,achieve(ACH0),Dec0),
385 statics_append(Statics0,Statics,Statics2),
386 all_achieved(Pre0,Statics2,Pre),
387 remove_unneed(Statics2,[],Statics21),
388 make_dec1(HPid,Pre,ACH0,Statics21,Temp0,Dec0,Temp2,Dec2),
389 expand_decomp(Dec2,Pre,State,Temp2,Temp1,Statics21,Statics1,Dec1),
390 all_achieved(Post,Statics1,State),
391 retract(op_num(N)),
392 N1 is N+1,
393 assert(op_num(N1)),
394 make_tn(TN,Name,Pre,State,Temp1,Dec1),!.
395
397expand_decomp([step(HP,N,Pre0,Post0,unexp)|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,Decomp1):-
398 get_another_step(step(HP2,N2,Pre2,Post2,Exp),Pre,Statics,
399 HP,Temp,Temp2,Decomp,Decomp2),
400 expand_decomp([step(HP2,N2,Pre2,Post2,Exp),step(HP,N,Pre0,Post0,unexp)|Decomp2],
401 Pre,Post,Temp2,Temp1,Statics,Statics1,Decomp1).
402
405
407get_another_step(A,Pre,Statics,HP,Temp,Temp1,[],Dec2):-fail.
408get_another_step(step(HP2,Name2,Pre2,Post2,Exp),Pre,Statics,HP,Temp,[before(HP2,HP)|Temp],Dec,Dec2):-
409 member(step(HP2,Name2,Pre2,Post2,Exp),Dec),
410 not(necessarily_before(HP,HP2, Temp)),
411 state_achieved(Pre2,Pre,Statics),
412 list_take(Dec,[step(HP2,Name2,Pre2,Post2,Exp)],Dec2).
413
417expand_decomp_ach([step(HPid,ACH,Pre,Post0,unexp)|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,Decomp1):-
418 state_achieved(Post0,Pre),
421 remove_temp(Temp,HPid,Temp,Temp2),
422 expand_decomp(Decomp,Pre,Post,Temp2,Temp1,Statics,Statics1,Decomp1),!.
423
425expand_decomp_ach([step(HPid,ACH,Pre,Post0,unexp)|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,[step(HPid,ACH,Pre,Post0,exp(TN))|Decomp1]):-
426 expand_ach_goal(HPid,TN,ACH,Pre,Post0,State,Statics,Statics2),
427 expand_decomp(Decomp,State,Post,Temp,Temp1,Statics2,Statics1,Decomp1),!.
428
430expand_decomp_ach([step(HPid,ACH,Pre,Post0,unexp)|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,[step(HPid,ACH,Pre,Post0,exp(TN))|Decomp1]):-
431 get_another_step(step(HP2,N2,Pre2,Post2,Exp),Pre,Statics,
432 HP,Temp,Temp2,Decomp,Decomp2),
433 expand_decomp([step(HP2,N2,Pre2,Post2,Exp),step(HPid,ACH,Pre,Post0,unexp)|Decomp2], Pre,Post,Temp2,Temp1,Statics,Statics1,Decomp1).
434
437
440expand_ach_goal(HPid,TN,ACH,Pre,Post,State,Statics,Statics1):-
441 direct_expand_ach_goal(HPid,TN,ACH,Pre,Post,State,Statics,Statics1),!.
442
446expand_ach_goal(HPid,TN,ACH,Pre,Post,State,Statics,Statics1):-
447 make_tpnodes(Pre,Post,Statics),
449 fwsearch(TN,State),
452 clean_temp_nodes.
453
456
459direct_expand_ach_goal(HPid,TN,ACH,Pre,Post,State,Statics,Statics):-
460 apply_tn(TN,HPid,ACH,Pre,Post,State,Statics,Statics).
462direct_expand_ach_goal(HPid,OP,ACH,Pre,Post,State,Statics,Statics1):-
463 dir_apply_op(OP,HPid,ACH,Pre,Post,State,Statics,Statics1).
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
504direct_expand_ach_goal(HPid,TN,ACH,Pre,Post,State,Statics,Statics1):-
505 dir_apply_method(TN,HPid,ACH,Pre,Post,State,Statics,Statics1),!.
507
509apply_tn(Tn0,HPid,ACH,Pre,Post,State,Statics,Statics):-
510 tn(Tn0,Name,Pre0,Post0,Temp0,Decomp0),
511 state_achieved(Pre0,Pre),
512 state_change(Pre,Pre0,Post0,State),
513 all_achieved(Post,Statics,State),
515 retract(op_num(N)),
516 N1 is N+1,
517 assert(op_num(N1)),!.
519
521dir_apply_op(Name,HPid,ACH,Pre,Goal,State,Statics,Statics1):-
523 make_se_primitive(Goal,Post),
524 operatorC(Name,Pre0,Post0,Cond,Statics0),
525 statics_append(Statics0,Statics,Statics2),
526 state_related(Post0,Cond,Post),
528 state_change(Pre,Pre0,Post0,State2),
529 cond_state_change(State2,Cond,State),
530 all_achieved(Post,Statics2,State),
531 remove_unneed(Statics2,[],Statics1),
532 statics_consist(Statics1),
535 retract(op_num(N)),
536 N1 is N+1,
537 assert(op_num(N1)),!.
538
540dir_apply_method(TN,HPid,ACH,Pre,Goal,State,Statics,Statics1):-
542 make_se_primitive(Goal,Post),
543 methodC(Name,Pre0,Post0,Statics0,Temp0,achieve(ACH0),Dec0),
544 statics_append(Statics0,Statics,Statics2),
545 state_related(Post0,Post),
547 state_change(Pre,Pre0,Post0,State2),
549 may_achieved(Post,Statics2,State2),
551 make_dec1(HPid,Pre,ACH0,Statics2,Temp0,Dec0,Temp2,Dec2),
552 expand_decomp(Dec2,Pre,State,Temp2,Temp1,Statics2,Statics1,Dec1),
553 all_achieved(Post,Statics1,State),
556 retract(op_num(N)),
557 N1 is N+1,
558 assert(op_num(N1)),
559 make_tn(TN,Name,Pre,State,Temp1,Dec1),!.
560
562make_dec1(HPid,Pre,ACH,Statics,Temp,Dec,Temp1,Dec1):-
563 var(HPid),
564 gensym_special(hp,HPid),
565 make_dec1(HPid,Pre,ACH,Statics,Temp,Dec,Temp1,Dec1),!.
566make_dec1(HPid,Pre,ACH,Statics,Temp,Dec,Temp1,Dec1):-
567 all_achieved(ACH,Statics,Pre),
568 make_dec01(HPid,1,Dec,Dec1),
569 change_temp(HPid,Temp,[],Temp1),!.
570make_dec1(HPid,Pre,ACH,Statics,Temp,Dec,[before(STID0,STID1)|Temp1],[step(STID0,achieve(ACH),Pre,ACH,unexp)|Dec1]):-
571 gensym_num(HPid,0,STID0),
572 gensym_num(HPid,1,STID1),
573 make_dec01(HPid,1,Dec,Dec1),
574 change_temp(HPid,Temp,[],Temp1),!.
575
576make_dec01(HPid,_,[],[]):-!.
577make_dec01(HPid,Num,[HDec|TDec],[step(STID,HDec,undefd,undefd,unexp)|TDec0]):-
578 operatorC(HDec,_,_,_,_),
579 gensym_num(HPid,Num,STID),
580 Num1 is Num + 1,
581 make_dec01(HPid,Num1,TDec,TDec0).
582make_dec01(HPid,Num,[HDec|TDec],[step(STID,HDec,undefd,undefd,unexp)|TDec0]):-
583 methodC(HDec,_,_,_,_,_,_),
584 gensym_num(HPid,Num,STID),
585 Num1 is Num + 1,
586 make_dec01(HPid,Num1,TDec,TDec0).
587
588change_temp(HPid,[],Temp2,Temp2):-!.
589change_temp(HPid,[before(N1,N2)|Temp],Temp2,[before(ST1,ST2)|Temp0]):-
590 gensym_num(HPid,N1,ST1),
591 gensym_num(HPid,N2,ST2),
592 change_temp(HPid,Temp,Temp2,Temp0),!.
595
598make_tpnodes(Pre,Post, Statics):-
599 opCounter(Num),
600 Num>=1000,
601 retractall(tp_goal(_,_,_)),
602 retractall(related_op(_,_)),
603 assert(tp_goal(Pre,Post,Statics)),
604 assert(tp_node(init,Pre,Statics,from(init),0,[])),!.
605
606make_tpnodes(Pre,Post, Statics):-
607 retractall(tp_goal(_,_,_)),
608 retractall(related_op(_,_)),
609 assert(tp_goal(Pre,Post,Statics)),
610 assert_goal_related_init(Pre,Post,Statics),
611 assert(op_score(goal,0)),
612 find_all_related_goals(Pre,Statics,1,N),
614 assert(tp_node(init,Pre,Statics,from(init),0,[])),!.
615
618fwsearch(TN,State):-
619 retract(solved_node(_,step(HP,Name,Pre,State,exp(TN)))).
620fwsearch(TN,State):-
621 select_tnode(tp_node(TP,Pre,Statics,from(PR),Score,Steps)),
622 assert(closed_node(TP,Pre,Statics,from(PR),Score,Steps)),
623 expand_node(TP,OP,Statics,Statics1,Pre,Post,from(PR),Steps,Steps1),
624 assert_tnode(TP,OP,PR,Score1,Post,Statics1,Steps1),
625 solved_node(_,_), 626 fwsearch(TN,State).
627fwsearch(TN,State):-
628 tp_node(TP,Pre,Statics,from(PR),Score,Steps),
629 fwsearch(TN,State).
630
631clean_temp_nodes:-
632 retractall(tp_goal(_,_)),
633 retractall(goal_related(_,_,_)),
634 retractall(goal_related_search(_)),
635 retractall(related_op(_)),
636 retractall(op_score(_,_)),
637 retractall(score_list(_)),
638 retractall(solved_node(_,_)),
639 retractall(current_num(tp,_)),
640 retractall(tp_node(_,_,_,_,_,_)),
641 retractall(closed_node(_,_,_,_,_,_)),!.
642
645expand_node(TP,done,Statics,Statics,Pre,Pre,from(PR),List,List):-
646 tp_goal(_,Goal,_),
647 state_achieved(Goal,Pre,Statics),!.
648expand_node(TP,TN,Statics,Statics1,Pre,State,from(PR),List,List1):-
649 expand_node1(TN,Statics,Statics1,Pre,State,from(PR),List,List1).
650
652expand_node1(TN,Statics,Statics1,Pre,State,from(PR),List,List1):-
653 tp_goal(_,Goal,_),
654 direct_expand(HP,TN,achieve(Goal),Pre,Goal,State,Statics,Statics1),
656 append_dcut(List,[step(HP,achieve(Goal),Pre,State,exp(TN))],List1),!.
660direct_expand(HPid,TN,ACH,Pre,Post,State,Statics,Statics1):-
661 dir_apply_method(TN,HPid,ACH,Pre,Post,State,Statics,Statics1),!.
662
664expand_node1(ID,Statics,Statics,Pre,State,from(PR),List,List1):-
665 find_related_op(Pre,[],OPls),
666 member(ID,OPls),
667 gOperator(ID,_,OP),
668 apply_ground_op(OP,Pre,State,List,List1).
669expand_node1(OP,Statics,Statics1,Pre,State,from(PR),List,List1):-
670 not(goal_related(_,_,_)),
671 operatorC(OP,Pre0,Post0,Cond,ST),
672 apply_unground_op(OP,Pre0,Post0,Cond,ST,Statics,Statics1,Pre,State,List,List1).
673
674apply_ground_op(operator(OP,Prev,Nec,Cond),Pre,State,List,List1):-
675 state_achieved(Prev,Pre),
676 nec_state_change(Pre,Nec,State2),
677 cond_state_change(State2,Cond,State),
678 gensym_special(hp,HP),
679 append_dcut(List,[step(HP,OP,Pre,State,exp(OP))],List1),
680 retract(op_num(N)),
681 N1 is N+1,
682 assert(op_num(N1)),!.
683
684apply_unground_op(OP,Pre0,Post0,Cond,ST,Statics,Statics1,Pre,State,List,List1):-
685 statics_append(ST,Statics,Statics2),
686 state_achieved(Pre0,Pre,Statics2),
687 state_change(Pre,Pre0,Post0,State2),
688 cond_state_change(State2,Cond,State),
689 statics_consist_instance(ST),
690 remove_unneed(Statics2,[],Statics1),
691 gensym_special(hp,HP),
692 append_dcut(List,[step(HP,OP,Pre,State,exp(OP))],List1),
693 retract(op_num(N)),
694 N1 is N+1,
695 assert(op_num(N1)).
696
697find_related_op([],Ops1,Ops):-
698 remove_dup(Ops1,[],Ops),!.
699find_related_op([Head|Pre],List,Ops):-
700 setof(OPls,Head^Level^goal_related(Head,OPls,Level),OPs0),
701 flatten(OPs0,[],OPs1),
702 append_dcut(List,OPs1,List1),
703 find_related_op(Pre,List1,Ops),!.
704find_related_op([Head|Pre],List,Ops):-
705 find_related_op(Pre,List,Ops),!.
706
708select_tnode(tp_node(TPid,Pre,Statics,Parents,Score,Dec)) :-
709 retractall(score_list(LS)),
710 assert(score_list([])),
711 lowest_score(Score),
712 retract(tp_node(TPid,Pre,Statics,Parents,Score,Dec)),!.
714
716lowest_score(LScore):-
717 tp_node(HPid,Pre,Statics,Parents,Score,Dec),
718 retract(score_list(LS)),
719 assert(score_list([Score|LS])),
720 fail.
721lowest_score(LScore):-
722 retract(score_list(D)),
723 sort(D,[LScore|SD]).
724
727assert_tnode(TP,OP,PR,Score,Post,Statics,[]):-!.
728assert_tnode(TP,OP,PR,Score,Post,Statics,Steps):-
729 tp_goal(Pre,Goal,Statics1),
730 state_achieved(Goal,Post,Statics),
731 combine_exp_steps(Post,Steps,OneStep),
732 assert(solved_node(Statics,OneStep)),!.
733assert_tnode(TP,OP,PR,Score,Post,Statics,Steps):-
734 existing_node(Post,Statics),!.
735assert_tnode(TP,OP,PR,Score,Post,Statics,Steps):-
736 get_score(PR,Post,Steps,Score),
739 gensym_special(tp,TP1),
742 assert(tp_node(TP1,Post,Statics,from(TP),Score,Steps)),!.
743
744combine_exp_steps(Post,Steps,step(HP,achieve(Goal),Pre,Post,exp(TN))):-
745 tp_goal(Pre,Goal,Statics),
746 get_action_list(Steps,[],ACTls),
747 make_temp(ACTls,[],Temp),
748 gensym_special(hp,HP),
749 make_tn(TN,achieve(Goal),Pre,Post,Temp,Steps),!.
750
752get_action_list([],ACTls,ACTls):-!.
753get_action_list([step(HP,_,_,_,_)|Steps],List,ACTls):-
754 append_dcut(List,[HP],List1),
755 get_action_list(Steps,List1,ACTls),!.
756
757make_temp([HP|[]],Temp,Temp):-!.
758make_temp([HP1|[HP2|Rest]],List,Temp):-
759 append_cut(List,[before(HP1,HP2)],List1),
760 make_temp([HP2|Rest],List,Temp),!.
761
762existing_node(Post,Statics):-
763 tp_node(_,Post,_,_,_,_).
764existing_node(Post,Statics):-
765 closed_node(_,Post,_,_,_,_).
767
768assert_goal_related_init(Pre,[],Statics):-!.
771assert_goal_related_init(Pre,[se(Sort,Obj,SE)|Post],Statics):-
772 ground(Obj),
773 is_of_primitive_sort(Obj,SortP),
774 assert(goal_related(se(SortP,Obj,SE),[],0)),
775 assert_goal_related_init(Pre,Post,Statics),!.
776assert_goal_related_init(Pre,[se(Sort,Obj,SE)|Post],Statics):-
777 assert_related_goals_varible(Sort,Obj,SE,goal,0),
778 assert_goal_related_init(Pre,Post,Statics),!.
779
782find_all_related_goals(Pre,Statics,N,N):-
783 get_all_state(States),
784 all_found(States,Pre,Statics),
785 assert(goal_related_search(succ)),
786 find_all_related_goals_final(Statics,N),!.
787find_all_related_goals(Pre,Statics,I,N):-
788 I1 is I-1,
789 goal_related(_,_,I1),
790 find_related_goal(Statics,I1,I),
791 I2 is I+1,
792 find_all_related_goals(Pre,Statics,I2,N),!.
793find_all_related_goals(Pre,Statics,N,N):-
794 not(goal_related(_,_,N)),
795 assert(goal_related_search(fail)),
796 write('related goal search failed'),
797 retractall(goal_related(_,_,_)),!.
798 799 800
801
804find_all_related_goals_final(Statics,N):-
805 N1 is N-1,
806 goal_related(Pre,_,N1),
807 find_related_goal(Statics,N1,N),!.
808find_all_related_goals_final(Statics,N):-!.
809
811get_all_state(States):-
812 setof(Goal, Statics^Level^OP^goal_related(Goal,OP,Level),States11),
813 put_one_obj_together(States11,[],States),!.
814
815put_one_obj_together([],States,States):-!.
816put_one_obj_together([se(Sort,Obj,ST)|States1],List,States):-
817 put_one_obj_together1(se(Sort,Obj,ST),List,List1),
818 put_one_obj_together(States1,List1,States),!.
819
820put_one_obj_together1(se(Sort,Obj,ST),[],[se(Sort,Obj,ST)]):-!.
821put_one_obj_together1(se(Sort,Obj,ST),[se(Sort,Obj,ST00)|List],[se(Sort,Obj,ST1)|List]):-
822 set_append_e(ST,ST00,ST1),!.
823put_one_obj_together1(se(Sort,Obj,ST),[se(Sort1,Obj1,ST1)|List],[se(Sort1,Obj1,ST1)|List1]):-
824 Obj\==Obj1,
825 put_one_obj_together1(se(Sort,Obj,ST),List,List1),!.
826
828all_found([],States,Statics):-!.
829all_found([se(Sort,Obj,ST)|States],Pre,Statics):-
830 member(se(Sort,Obj,SPre),Pre),
831 subtract(SPre,ST,Diff),
832 isemptylist(Diff),
833 all_found(States,Pre,Statics),!.
834
837find_related_goal(Statics,I1,I):-
838 gOperator(OPID,ID,operator(Name,Prev,Nec,Cond)),
839 find_related_goal_nec(OPID,Name,Prev,Nec,Statics,I1,I),
840 find_related_goal_cond(OPID,Name,Prev,Nec,Cond,Statics,I1,I),
841 fail.
842find_related_goal(Statics,I1,I).
843
844find_related_goal_nec(ID,Name,Prev,Nec,Statics,I1,I):-
845 goal_related(se(Sort,Obj,SE),Ops,I1),
846 member(sc(Sort,Obj,Lhs=>Rhs),Nec),
847 state_match(Sort,Obj,SE,Rhs),
848 statics_consist(Statics),
850 assert_goal_related(Prev,Nec,ID,I).
851find_related_goal_cond(ID,Name,Prev,Nec,[],Statics,I1,I):-
852 !.
853find_related_goal_cond(ID,Name,Prev,Nec,Cond,Statics,I1,I):-
854 goal_related(se(Sort,Obj,SE),Ops,I1),
855 member(sc(Sort0,Obj,LHS=>RHS),Cond),
856 is_of_sort(Obj,Sort0),
857 is_of_sort(Obj,Sort), 858 filterInvars(LHS,LInVars,LIsOfSorts,LNEs,FLHS),
859 filterInvars(RHS,RInVars,RIsOfSorts,RNEs,FRHS),
860 can_achieve_g([se(Sort,Obj,FRHS)],[se(Sort,Obj,SE)],Statics),
861 statics_consist(Statics),
862 checkInVars(LInVars),
863 checkInVars(RInVars),
864 checkIsOfSorts(LIsOfSorts),
865 checkIsOfSorts(RIsOfSorts),
866 obeysNEs(LNEs),
867 obeysNEs(RNEs),
869 assert_goal_related(Prev,[sc(Sort,Obj,FLHS=>FRHS)|Nec],ID,I).
870
872filterInvars([],[],[],[],[]):-!.
873filterInvars([is_of_sort(A,B)|State],InVars,[is_of_sort(A,B)|IsOfSorts],NEs,FState):-
874 !,
875 filterInvars(State,InVars,IsOfSorts,NEs,FState).
876filterInvars([ne(A,B)|State],InVars,IsOfSorts,[ne(A,B)|NEs],FState):-
877 !,
878 filterInvars(State,InVars,IsOfSorts,NEs,FState).
879filterInvars([is_of_primitive_sort(A,B)|State],InVars,[is_of_sort(A,B)|IsOfSorts],NEs,FState):-
880 !,
881 filterInvars(State,InVars,IsOfSorts,NEs,FState).
882filterInvars([Pred|State],[Pred|InVars],IsOfSorts,NEs,FState):-
883 functor(Pred,FF,NN),
884 functor(Pred1,FF,NN),
885 atomic_invariantsC(Atom),
886 member_cut(Pred1,Atom),!,
887 filterInvars(State,InVars,IsOfSorts,NEs,FState).
888filterInvars([Pred|State],InVars,IsOfSorts,NEs,[Pred|FState]):-
889 filterInvars(State,InVars,IsOfSorts,NEs,FState).
890
892filterNes([],[],[]):-!.
893filterNes([ne(A,B)|State],[ne(A,B)|NEs],FState):-
894 !,
895 filterNes(State,NEs,FState).
896filterNes([Pred|State],NEs,[Pred|FState]):-
897 filterNes(State,NEs,FState).
898
899assert_related_op(OP,I):-
900 related_op(OP,_),!.
901assert_related_op(OP,I):-
902 asserta(related_op(OP,I)),!.
903
905can_achieve_g([],State2,Statics):-!.
906can_achieve_g(State1,State2,Statics):-
907 can_achieve_g(State1,State2),
908 statics_consist(Statics).
909
910can_achieve_g([se(Sort,Obj,ST1)|State1],[se(Sort,Obj,ST2)]):-
911 state_match(Sort,Obj,ST2,ST1).
912can_achieve_g([Head|State1],State2):-
913 can_achieve_g(State1,State2).
914
916assert_goal_related(Prev,Nec,OP,I):-
917 assert_goal_related1(Prev,OP,I),!,
918 assert_goal_related1(Nec,OP,I).
919
920assert_goal_related1([],Op,I):-!.
921assert_goal_related1([se(Sort,Obj,SE)|Prev],Op,I):-
922 assert_goal_related2(se(Sort,Obj,SE),Op,I),
923 assert_goal_related1(Prev,Op,I),!.
924assert_goal_related1([sc(Sort,Obj,LH=>RH)|Nec],Op,I):-
925 ground(Obj), 926 is_of_primitive_sort(Obj,PSort),!,
927 assert_goal_related2(se(PSort,Obj,LH),Op,I),
928 assert_goal_related1(Nec,Op,I).
929assert_goal_related1([sc(Sort,Obj,LH=>RH)|Nec],Op,I):-
930 var(Obj),
931 assert_related_goals_varible(Sort,Obj,LH,Op,I),
932 assert_goal_related1(Nec,Op,I).
933
934assert_goal_related2(se(Sort,Obj,SE),goal,I):-
935 assert(goal_related(se(Sort,Obj,SE),[],I)),!.
936assert_goal_related2(se(Sort,Obj,SE),Op,I):-
937 goal_related(se(Sort,Obj,SE1),Ops,I),
938 not(is_diff(SE,SE1)),
939 retract(goal_related(se(Sort,Obj,SE),Ops,I)),
940 assert(goal_related(se(Sort,Obj,SE),[Op|Ops],I)),!.
941assert_goal_related2(se(Sort,Obj,SE),Op,I):-
942 assert(goal_related(se(Sort,Obj,SE),[Op],I)),!.
943
944assert_related_goals_varible(Sort,Obj,SE,Op,I):-
945 find_prim_sort(Sort,PSorts),
946 member(Sort1,PSorts),
947 assert_goal_related2(se(Sort1,Obj,SE),Op,I),
948 fail.
949assert_related_goals_varible(Sort,Obj,SE,Op,I).
950
952assert_op_score(OP,OPB):-
953 op_score(OP,_),!.
954assert_op_score(OP,OPB):-
955 op_score(OPB,I),
956 I1 is I+1,
957 assert(op_score(OP,I1)),!.
958
959get_score(PR,Post,Steps,Score):-
960 tp_goal(Pre,Goal,Statics),
961 get_distance(Pre,Post,Goal,0,Dis), 963 get_tnode_length(PR,1,Len),
967 Score is Dis+Len,!.
968
969get_distance(Pre,[],Goal,Dis,Dis):-!.
970get_distance(Pre,[se(Sort,Obj,SE)|Post],Goal,Dis1,Dis):-
971 member(se(Sort,Obj,SE0),Goal),
972 state_match(Sort,Obj,SE0,SE), 973 get_distance(Pre,Post,Goal,Dis1,Dis),!.
974get_distance(Pre,[se(Sort,Obj,SE)|Post],Goal,Dis1,Dis):-
975 goal_related(se(Sort,Obj,SE0),_,Level),
976 state_match(Sort,Obj,SE0,SE),
977 Dis2 is Dis1+Level,
978 get_distance(Pre,Post,Goal,Dis2,Dis),!.
979get_distance(Pre,[se(Sort,Obj,SE)|Post],Goal,Dis1,Dis):-
980 member(se(Sort,Obj,SE0),Pre),
981 state_match(Sort,Obj,SE,SE0), 982 Dis2 is Dis1+1,
983 get_distance(Pre,Post,Goal,Dis2,Dis),!.
984get_distance(Pre,[se(Sort,Obj,SE)|Post],Goal,Dis1,Dis):-
985 Dis2 is Dis1+100,
986 get_distance(Pre,Post,Goal,Dis2,Dis),!.
987
988get_tnode_length(init,Len,Len):-!.
989get_tnode_length(TP,Len1,Len):-
990 closed_node(TP,_,_,from(PR),_,_),
991 Len2 is Len1+1,
992 get_tnode_length(PR,Len2,Len),!.
993
994
999find_relate_state:-
1000 operatorC(A,Pre,Post,Cond,ST),
1001 assert_related_states(A,Pre,Post,Cond,ST),
1002 fail.
1003find_relate_state.
1004
1005assert_related_states(A,Pre,Post,Cond,ST):-
1006 assert_related_states1(A,Pre,Post,ST),
1007 assert_related_states2(A,Pre,Cond,ST).
1010assert_related_states1(A,Pre,[],ST):-!.
1012assert_related_states1(A,Pre,[se(Sort,Obj,SE)|Post],ST):-
1013 u_mem_cut(se(Sort,Obj,SE),Pre),
1014 assert_related_states1(A,Pre,Post,ST),!.
1016assert_related_states1(A,Pre,[se(Sort,Obj,SE)|Post],ST):-
1017 assert(produce(se(Sort,Obj,SE),A,Pre,ST)),
1018 assert_related_states1(A,Pre,Post,ST),!.
1019
1022assert_related_states2(A,Pre,SC,ST):-
1023 make_sc_primitive(SC,PSC),
1024 assert_related_states21(A,Pre,PSC,ST).
1025
1026assert_related_states21(A,Pre,[],ST):-!.
1027assert_related_states21(A,Pre,[sc(Sort,Obj,SE=>SS)|Trans],ST):-
1028 rem_statics([se(Sort,Obj,SE)],[se(Sort,Obj,SER)],St1),
1029 rem_statics([se(Sort,Obj,SS)],[se(Sort,Obj,SSR)],St2),
1030 append_cut(ST,St1,ST1),
1031 append_cut(ST1,St2,ST21),
1032 remove_unneed(ST21,[],ST2),
1033 append_cut(Pre,[se(Sort,Obj,SER)],Pre1),
1034 assert(produce(se(Sort,Obj,SSR),A,Pre1,ST2)),
1035 assert_related_states21(A,Pre,Trans,ST),!.
1036
1041remove_temp([],HP1,List,List):-!.
1042remove_temp([before(HP1,HP2)|Temp],HP1,List,Temp1):-
1043 remove_temp_before(List,before(HP1,HP2),List2),
1044 remove_temp(Temp,HP1,List2,Temp1),!.
1045remove_temp([before(HP2,HP1)|Temp],HP1,List,Temp1):-
1046 remove_temp_after(List,before(HP2,HP1),List2),
1047 remove_temp(Temp,HP1,List2,Temp1),!.
1048remove_temp([before(HPX,HPY)|Temp],HP1,List,Temp1):-
1049 remove_temp(Temp,HP1,List,Temp1),!.
1050
1052remove_temp_before([],before(HP1,HP2),[]):-!.
1053remove_temp_before([before(HP1,HP2)|T],before(HP1,HP2),T1):-
1054 remove_temp_before(T,before(HP1,HP2),T1),!.
1055remove_temp_before([before(HP3,HP1)|T],before(HP1,HP2),[before(HP3,HP2)|T1]):-
1056 remove_temp_before(T,before(HP1,HP2),T1),!.
1057remove_temp_before([before(HPX,HPY)|T],before(HP1,HP2),[before(HPX,HPY)|T1]):-
1058 remove_temp_before(T,before(HP1,HP2),T1),!.
1060remove_temp_after([],before(HP1,HP2),[]):-!.
1061remove_temp_after([before(HP2,HP1)|T],before(HP2,HP1),T1):-
1062 remove_temp_after(T,before(HP2,HP1),T1),!.
1063remove_temp_after([before(HP1,HP3)|T],before(HP2,HP1),[before(HP2,HP3)|T1]):-
1064 remove_temp_after(T,before(HP2,HP1),T1),!.
1065remove_temp_after([before(HPX,HPY)|T],before(HP2,HP1),[before(HPX,HPY)|T1]):-
1066 remove_temp_after(T,before(HP2,HP1),T1),!.
1067
1068remove_dec(HPid,[],[]):-!.
1069remove_dec(HPid,[step(HPid,_,_,_,_)|Dec],Dec1):-
1070 remove_dec(HPid,Dec,Dec1),!.
1071remove_dec(HPid,[step(A,B,C,D,F)|Dec],[step(A,B,C,D,F)|Dec1]):-
1072 remove_dec(HPid,Dec,Dec1),!.
1073
1077state_achieved(undefd,State,Statics):-!.
1078state_achieved([],State2,Statics):-!.
1079state_achieved(State1,State2,Statics):-
1080 state_achieved(State1,State2),
1081 statics_consist(Statics).
1082
1083state_achieved(undefd,State):-!.
1084state_achieved([],State2).
1085state_achieved([se(Sort,Obj,ST1)|State1],State2):-
1086 member(se(Sort,Obj,ST2),State2),
1087 is_of_sort(Obj,Sort),
1088 state_match(Sort,Obj,ST1,ST2),
1089 list_take(State2,[se(Sort,Obj,ST2)],State21),
1090 state_achieved(State1,State21).
1091state_achieved([se(Sort,Obj,ST1)|State1],State2):-
1092 not(member(se(Sort,Obj,ST2),State2)),
1093 state_achieved(State1,State2),!.
1094
1098state_match(Sort,Obj,ST,ST1):-
1099 not(is_diff(ST,ST1)),!.
1104state_match(Sort,Obj,ST,ST1):-
1105 is_achieved(ST,ST1),
1106 gsubstate_classes(Sort,Obj,Substateclasses),
1107 not(in_different_states(ST,ST1,Substateclasses)),!.
1110state_match(Sort,Obj,ST,ST1):-
1111 not(is_achieved(ST,ST1)),
1112 set_append(ST,ST1,ST0),
1113 gsubstate_classes(Sort,Obj,Substateclasses),
1114 in_same_sub_states(ST0,Substateclasses),!.
1115
1117in_same_sub_states(ST0,[State|SCls]):-
1118 is_achieved(ST0,State),!.
1119in_same_sub_states(ST0, [State|SCls]):-
1120 in_same_sub_states(ST0,SCls),!.
1121
1123in_different_states(ST,ST1, [State|SCls]):-
1124 max_member(ST,Substateclasses,MSub, _),
1125 max_member(ST1,Substateclasses,MSub1, _),
1126 MSub\==MSub1,!.
1127
1128max_member(State, Stateclass, MSub, Others):-
1129 max_member1(State, Stateclass, 0, [],MSub),
1130 subtract(State,MSub,Others),!.
1131
1133max_member1(State, [], Num, MSub, MSub):-!.
1135max_member1(State, [State1|SCls], Num, MSub1, MSub):-
1136 same_items(State1,State,MSSt),
1137 length(MSSt,Len),
1138 Len > Num,
1139 max_member1(State, SCls, Len, MSSt, MSub),!.
1140max_member1(State, [State1|SCls], Num, MSub1,MSub):-
1141 max_member1(State, SCls, Num, MSub1,MSub),!.
1142
1144same_items([],List2,[]):-!.
1145same_items([X|List1],List2,[X|Same]):-
1146 member(X,List2),
1147 same_items(List1,List2,Same),!.
1148same_items([X|List1],List2,Same):-
1149 same_items(List1,List2,Same),!.
1150
1151
1153is_achieved([],_):-!.
1154is_achieved([H|T], State) :-
1155 is_statics(H),
1156 is_achieved(T,State),!.
1157is_achieved([H|T], State) :-
1158 member(H,State),
1159 is_achieved(T,State),!.
1160
1162is_statics(ne(A,B)):-!.
1163is_statics(is_of_sort(A,B)):-!.
1164is_statics(is_of_primitive_sort(A,B)):-!.
1165is_statics(Pred):-
1166 functor(Pred,FF,NN),
1167 functor(Pred1,FF,NN),
1168 atomic_invariantsC(Atom),
1169 member_cut(Pred1,Atom),!.
1170
1178state_change([],Pre0,Post0,[]):-!.
1179state_change(Pre,[],[],Pre):-!.
1180state_change([se(Sort,Obj,SPre)|Pre],Pre0,Post0,[se(Sort,Obj,STPost)|Post]):-
1181 state_achieved([se(Sort,Obj,SPre)],Pre0),
1182 state_change0(Sort,Obj,SPre,Pre0,Post0,Pre1,Post1,STPost),
1183 state_change(Pre,Pre1,Post1,Post).
1184state_change([se(Sort,Obj,SPre)|Pre],Pre0,Post0,[se(Sort,Obj,STPost)|Post]):-
1185 not(member(se(Sort,Obj,SPre0),Pre0)),
1186 state_change(Pre,Pre1,Post1,Post).
1187
1189state_change0(Sort,Obj,SPre,[],[],[],[],SPre):-!.
1190state_change0(Sort,Obj,SPre,[se(Sort,Obj,SPre0)|Pre0],[se(Sort,Obj,SPost0)|Post0],Pre0,Post0,STPost):-
1191 state_change1(SPre,SPre0,SPost0,STPost).
1192state_change0(Sort,Obj,SPre,[se(Sort1,Obj1,SPre0)|Pre0],[se(Sort1,Obj1,SPost0)|Post0],[se(Sort1,Obj1,SPre0)|Pre1],[se(Sort1,Obj1,SPost0)|Post1],STPost):-
1193 Obj\==Obj1,
1194 state_change0(Sort,Obj,SPre,Pre0,Post0,Pre1,Post1,STPost).
1195
1196state_change1([],SPre0,SPost0,SPost0):-!.
1197state_change1(Pre,[],[],Pre):-!.
1199state_change1([Head|SPre],SPre0,SPost0,STPost):-
1200 member(Head,SPre0),
1201 not(member(Head,SPost0)),
1202 state_change1(SPre,SPre0,SPost0,STPost).
1204state_change1([Head|SPre],SPre0,SPost0,[Head|STPost]):-
1205 not(member(Head,SPre0)),
1206 not(member(Head,SPost0)),
1207 state_change1(SPre,SPre0,SPost0,STPost),!.
1210state_change1([Head|SPre],SPre0,SPost0,STPost):-
1211 member(Head,SPost0),
1212 state_change1(SPre,SPre0,SPost0,STPost).
1213
1215rough_state_change(Pre,[],[],Pre):-!.
1216rough_state_change([],_,_,[]):-!.
1217rough_state_change([se(Sort,Obj,SE)|Pre],Pre0,Post0,[se(Sort,Obj,SS0)|Post]):-
1218 member(se(Sort,Obj,SE0),Pre0),
1219 member(se(Sort,Obj,SS0),Post0),
1220 is_of_sort(Obj,Sort),
1221 state_achieved([se(Sort,Obj,SE0)],[se(Sort,Obj,SE)]),
1222 list_take(Pre0,[se(Sort,Obj,SE0)],Pre01),
1223 list_take(Post0,[se(Sort,Obj,SS0)],Post01),
1224 rough_state_change(Pre,Pre01,Post01,Post),!.
1225rough_state_change([se(Sort,Obj,SE)|Pre],Pre0,Post0,[se(Sort,Obj,SE)|Post]):-
1226 rough_state_change(Pre,Pre0,Post0,Post),!.
1227
1229state_changeG([],Pre0,Post0,[]):-!.
1230state_changeG([se(Sort,Obj,SE)|Pre],Pre0,Post0,[se(Sort,Obj,RHS)|State]):-
1231 member(se(Sort,Obj,LHS),Pre0),
1232 member(se(Sort,Obj,RHS),Post0),
1233 state_match(Sort,Obj,SE,LHS),
1234 state_changeG(Pre,Pre0,Post0,State),!.
1235state_changeG([se(Sort,Obj,SE)|Pre],Pre0,Post0,[se(Sort,Obj,SE)|State]):-
1236 not(member(se(Sort,Obj,LHS),Pre0)),
1237 state_changeG(Pre,Pre0,Post0,State),!.
1238
1239find_lower_sort(Sort,Sort,Sort):-!.
1240find_lower_sort(Sort,Sort1,Sort1):-
1241 subsorts(Sort,Sortls),
1242 member(Sort1,Sortls),!.
1243find_lower_sort(Sort,Sort1,Sort):-
1244 subsorts(Sort1,Sortls),
1245 member(Sort,Sortls),!.
1251nec_state_change([],Nec,[]):-!.
1252nec_state_change([se(Sort,Obj,SE)|Pre],Nec,[se(Sort,Obj,Post)|State]):-
1253 member(sc(Sort,Obj,Lhs=>Rhs),Nec),
1254 state_match(Sort,Obj,Lhs,SE),
1255 state_change1(SE,Lhs,Rhs,Post),
1256 nec_state_change(Pre,Nec,State),!.
1257nec_state_change([se(Sort,Obj,SE)|Pre],Nec,[se(Sort,Obj,SE)|State]):-
1258 not(member(sc(Sort,Obj,Lhs=>Rhs),Nec)),
1259 nec_state_change(Pre,Nec,State),!.
1264cond_state_change([],Cond,[]):-!.
1265cond_state_change(State,[],State):-!.
1266cond_state_change([se(Sort,Obj,SE)|Pre],Cond,[NewSS|State]):-
1267 member(sc(Sort1,Obj1,SE0=>SS0),Cond),
1269 subsorts(Sort1,Subsorts),
1270 member(Sort,Subsorts),
1271 copy_states(se(Sort1,Obj1,SE0),se(Sort,Obj,SE2)),
1272 copy_states(se(Sort1,Obj1,SS0),se(Sort,Obj,SS2)),
1274 filterInvars(SE2,LInVars,LIsOfSorts,LNEs,FSE),
1275 filterInvars(SS2,RInVars,RIsOfSorts,RNEs,FSS),
1276 state_match(Sort,Obj,SE,FSE),
1277 state_change([se(Sort,Obj,SE)],[se(Sort,Obj,FSE)],
1278 [se(Sort,Obj,FSS)],[NewSS]),
1279 checkInVars(LInVars),
1280 checkInVars(RInVars),
1281 checkIsOfSorts(LIsOfSorts),
1282 checkIsOfSorts(RIsOfSorts),
1283 obeysNEs(LNEs),
1284 obeysNEs(RNEs),
1285 cond_state_change(Pre,Cond,State),!.
1286cond_state_change([se(Sort,Obj,SE)|Pre],Cond,[se(Sort,Obj,SE)|State]):-
1287 cond_state_change(Pre,Cond,State),!.
1288
1290copy_states(se(Sort1,Obj1,SE0),se(Sort,Obj,SE2)):-
1291 copy_states1(Obj1,SE0,Obj,SE2),!.
1292copy_states1(Obj1,[],Obj,[]):-!.
1293copy_states1(Obj1,[Pred|SE0],Obj,[Pred2|SE2]):-
1294 functor(Pred,FF,NN),
1295 functor(Pred2,FF,NN),
1296 Pred=..[Name|Vars],
1297 Pred2=..[Name|Vars2],
1298 copy_pred(Obj1,Obj,Vars,Vars2),
1299 copy_states1(Obj1,SE0,Obj,SE2),!.
1300
1301copy_pred(Obj1,Obj,[],[]):-!.
1302copy_pred(Obj1,Obj,[Var|Vars],[Var2|Vars2]):-
1303 Obj1==Var,
1304 Var2=Obj,
1305 copy_pred(Obj1,Obj,Vars,Vars2),!.
1306copy_pred(Obj1,Obj,[Var|Vars],[Var|Vars2]):-
1307 copy_pred(Obj1,Obj,Vars,Vars2),!.
1310all_achieved(undefd,Statics,List2):-!.
1311all_achieved([],Statics,List2):-!.
1312all_achieved(List1,Statics,List2):-
1313 all_achieved(List1,List2),
1314 statics_consist(Statics).
1315
1316all_achieved([],List2).
1317all_achieved([se(Sort,Obj,SL)|List1],List2):-
1318 member(se(Sort1,Obj,SR),List2),
1319 is_of_sort(Obj,Sort1),
1320 is_of_sort(Obj,Sort),
1321 is_of_primitive_sort(Obj,PSort),
1322 state_match(PSort,Obj,SL,SR),
1323 all_achieved(List1,List2).
1326may_achieved(undefd,Statics,Post):-!.
1327may_achieved([],Statics,Post):-!.
1328may_achieved(Pre,Statics,Post):-
1329 may_achieved(Pre,Post),
1330 statics_consist(Statics),!.
1331may_achieved([],Post).
1332may_achieved([se(Sort,Obj,SL)|Pre],Post):-
1333 member(se(Sort1,Obj,SR),Post),
1334 is_of_sort(Obj,Sort1),
1335 is_of_sort(Obj,Sort),
1336 is_of_primitive_sort(Obj,PSort),
1337 state_may_achieved(PSort,Obj,SL,SR),
1338 may_achieved(Pre,Post),!.
1339
1341state_may_achieved(Sort,Obj,[],ST2):-!.
1342state_may_achieved(Sort,Obj,ST1,ST2):-
1343 is_achieved(ST1,ST2),!.
1347post_instant(Post0,Cond,Statics,undefd):-!.
1348post_instant(Post0,Cond,Statics,[]):-!.
1349post_instant(Post0,Cond,Statics,[se(Sort,Obj,SE)|Post]):-
1350 member(se(Sort,Obj,SE0),Post0),
1351 statics_consist(Statics).
1352post_instant(Post0,Cond,Statics,[se(Sort,Obj,SE)|Post]):-
1353 member(sc(Sort,Obj,SE1=>SS),Cond),
1354 statics_consist(Statics).
1355post_instant(Post0,Cond,Statics,[se(Sort,Obj,SE)|Post]):-
1356 member(sc(Sort0,Obj,SE1=>SS),Cond),
1357 not(objectsC(Sort0,_)),
1358 subsorts(Sort0,Sortls),
1359 not(not(member(Sort,Sortls))),
1360 statics_consist(Statics).
1361post_instant(Post0,Cond,Statics,[se(Sort,Obj,SE)|Post]):-
1362 post_instant(Post0,Cond,Statics,Post),!.
1363
1364
1365
1370
1371make_problem_into_node(I,goal(L,TM,STATS), NN) :-
1372 make_problem_up(L, STEPS),
1373 make_num_hp(TM,Temp),
1374 sort_steps(STEPS,Temp,STEPS1),
1375 make_ss_to_se(I,I_Pre),
1376 NN = node(root,I_Pre,STEPS1 ,Temp, STATS),!.
1377make_problem_into_node(I,L, NN) :-
1378 make_problem_up([achieve(L)], STEPS),
1379 make_num_hp(TM,Temp),
1380 sort_steps(STEPS,Temp,STEPS1),
1381 make_ss_to_se(I,I_Pre),
1382 NN = node(root,I_Pre,STEPS1 ,Temp, STATS),!.
1383
1385make_problem_up([],[]):-!.
1386make_problem_up([achieve(L)|R],[step(HP,achieve(L1),undefd,[L1],unexp)|RS]):-
1387 1388 make_ss_to_se([L],[L1]),
1389 gensym_special(hp,HP),
1390 make_problem_up(R, RS),!.
1391make_problem_up([achieve(L)|R],[step(HP,achieve(L1),undefd,L1,unexp)|RS]):-
1392 1393 make_ss_to_se(L,L1),
1394 gensym_special(hp,HP),
1395 make_problem_up(R, RS),!.
1396make_problem_up([O|R],[step(HP,O,undefd,undefd,unexp)|RS]):-
1397 methodC(O,Pre,Post,Statics1,Temp,ACH,Dec),
1398 gensym_special(hp,HP),
1399 make_problem_up(R, RS),!.
1400make_problem_up([O|R],
1401 [step(HP,O,undefd,undefd,unexp)|RS]):-
1402 operatorC(O,Pre,Post,Cond,Statics1),
1403 gensym_special(hp,HP),
1404 make_problem_up(R, RS),!.
1405
1406make_num_hp([],[]):-!.
1407make_num_hp([before(N1,N2)|TM],[before(H1,H2)|Temp]):-
1408 gensym_num(hp,N1,H1),
1409 gensym_num(hp,N2,H2),
1410 make_num_hp(TM,Temp),!.
1411
1414sort_steps(Steps,[],Steps):-!.
1415sort_steps([Steps|[]],[],[Steps]):-!.
1416sort_steps(Steps,Temp,OrderedST):-
1417 steps_in_temp(Temp,[],ST),
1418 sort_steps1(Temp,ST,OrderedSTID),
1419 sort_steps2(Steps,OrderedSTID,[],OrderedST),!.
1420
1422steps_in_temp([],ST,ST):-!.
1423steps_in_temp([before(H1,H2)|TT],List,ST):-
1424 set_append_e(List,[H1,H2],List1),
1425 steps_in_temp(TT,List1,ST),!.
1426
1428sort_steps1(Temp,[],[]):-!.
1429sort_steps1(Temp,[HP1|TST],[HPF|OST]):-
1430 earliest_step(HP1,HPF,Temp,TST,TST1),
1431 sort_steps1(Temp,TST1,OST),!.
1432
1433earliest_step(HPF,HPF,Temp,[],[]):-!.
1434earliest_step(HP1,HPF,Temp,[HP2|TST],[HP1|TST1]):-
1435 member(before(HP2,HP1),Temp),
1436 earliest_step(HP2,HPF,Temp,TST,TST1),!.
1437earliest_step(HP1,HPF,Temp,[HP2|TST],[HP2|TST1]):-
1438 earliest_step(HP1,HPF,Temp,TST,TST1),!.
1439
1441sort_steps2(OtherST,[],OrderedST1,OrderedST):-
1442 append_dcut(OrderedST1,OtherST,OrderedST),!.
1443sort_steps2(Steps,[HP|THPS],List,OrderedST):-
1444 member(step(HP,N,Pre,Post,F),Steps),
1445 append_dcut(List,[step(HP,N,Pre,Post,F)],List1),
1446 list_take(Steps,[step(HP,N,Pre,Post,F)],Steps1),
1447 sort_steps2(Steps1,THPS,List1,OrderedST),!.
1448sort_steps2(Steps,[HP|THPS],List,OrderedST):-
1449 sort_steps2(Steps,THPS,List,OrderedST),!.
1451
1453make_ss_to_se([],[]):-!.
1454make_ss_to_se([ss(Sort,Obj,Post)|TPost],[se(Sort,Obj,Post)|TPre]):-
1455 make_ss_to_se(TPost,TPre),!.
1456make_ss_to_se([se(Sort,Obj,Post)|TPost],[se(Sort,Obj,Post)|TPre]):-
1457 make_ss_to_se(TPost,TPre),!.
1458
(Node,PHPs,SIZE1,TNList) :-
1464 1465 getN_decomp(Node, HPs),
1466 push_to_primitive(HPs,[],PHPs,[],TNList),
1467 pprint(PHPs,1,SIZE),
1468 SIZE1 is SIZE -1,!.
1469
1473change_op_representation :-
1474 method(A,B,C,Stat,T,Dec),
1475 make_ss_to_se(B,B0),
1476 make_se_primitive(B0,B1),
1477 make_sc_primitive(C,C1),
1478 get_preconditions(C1,B1,Pre,Post),
1479 rem_statics(Post, PostR,St1),
1480 rem_statics(Pre, PreR,St2),
1481 append_cut(St1,St2,Statics),
1482 append_cut(Stat,Statics,Statics1),
1483 remove_unneed(Statics1,[],Statics2),
1484 get_achieval(A,Dec,T,Dec1,T1,ACH),
1485 assert(methodC(A,PreR,PostR,Statics2,T1,achieve(ACH),Dec1)),
1486 fail.
1487change_op_representation :-
1488 operator(A,B,C,D),
1489 make_ss_to_se(B,B0),
1490 make_se_primitive(B0,B1),
1491 make_sc_primitive(C,C1),
1493 1494 get_preconditions(C1,B1,Pre,Post),
1495 rem_statics(Post, PostR,St1),
1496 rem_statics(Pre, PreR,St2),
1497 append_cut(St1,St2,Statics1),
1498 remove_unneed(Statics1,[],Statics),
1499 statics_consist(Statics),
1500 assert(operatorC(A,PreR,PostR,D,Statics)),
1501 fail.
1502change_op_representation:-
1503 retractall(current_num(sm,_)),!.
1504
1505get_preconditions([],Prev,Prev,Prev) :-!.
1506get_preconditions([sc(S,X,From =>To)|Rest],Prev,[se(S,X,From1)|Pre],[se(S,X,To1)|Post]):-
1507 member_e(se(S,X,PSE),Prev),
1508 append_dcut(PSE,From,From1),
1509 append_dcut(PSE,To,To1),
1510 list_take(Prev,[se(S,X,PSE)],Prev1),
1511 get_preconditions(Rest,Prev1, Pre,Post),!.
1512get_preconditions([sc(S,X,From =>To)|Rest],Prev,[se(S,X,From)|Pre],[se(S,X,To)|Post]):-
1513 get_preconditions(Rest,Prev, Pre,Post),!.
1514get_preconditions([],Prev,Prev,Prev) :-!.
1515
1517get_achieval(A,Dec,T,Dec1,T1,Achieval):-
1518 retractall(current_num(sm,_)),
1519 make_dec(A,Dec,Dec1,T,T1,[],Achieval),!.
1520make_dec(A,[],[],Temp,Temp,Achieval,Achieval):-!.
1521make_dec(A,[HD|TD],TD1,Temp,Temp1,Achieval,Achieval1):-
1522 HD=..[achieve|Goal],
1523 current_num(sm,Num),
1524 replace_achieval_temp(Temp,Temp0,Num),
1525 make_ss_to_se(Goal,Goal0),
1526 append_dcut(Achieval,Goal0,Achieval0),
1527 make_dec(A,TD,TD1,Temp0,Temp1,Achieval0,Achieval1),!.
1528make_dec(A,[HD|TD],TD1,Temp,Temp1,Achieval,Achieval1):-
1529 HD=..[achieve|Goal],
1530 not(current_num(sm,Num)),
1531 replace_achieval_temp(Temp,Temp0,1),
1532 make_ss_to_se(Goal,Goal0),
1533 append_dcut(Achieval,Goal0,Achieval0),
1534 make_dec(A,TD,TD1,Temp0,Temp1,Achieval0,Achieval1).
1535make_dec(A,[HD|TD],[HD|TD1],Temp,Temp1,Achieval,Achieval1):-
1536 HD=..[DecName|Goal],
1537 DecName\==achieve,
1538 gensym_special(sm,SM),
1539 current_num(sm,Num),
1540 make_dec(A,TD,TD1,Temp,Temp1,Achieval,Achieval1),!.
1541
1543replace_achieval_temp(Temp,Temp1,Num):-
1544 change_all_numbers(Temp,Num,Temp00),
1545 tidy_temp(Temp00,Temp1).
1546
1547change_all_numbers([],Num,[]):-!.
1548change_all_numbers([HTemp|TTemp],Num,[HTemp00|TTemp00]):-
1549 HTemp=..[before|Nums],
1550 change_nums(Nums,Num,Nums1),
1551 HTemp00=..[before|Nums1],
1552 change_all_numbers(TTemp,Num,TTemp00).
1553
1554change_nums([],Num,[]):-!.
1555change_nums([Num1|TN],Num,[Num1|TN1]):-
1556 Num1<Num,
1557 change_nums(TN,Num,TN1),!.
1558change_nums([Num1|TN],Num,[Num2|TN1]):-
1559 Num1>Num,
1560 Num2 is Num1-1,
1561 change_nums(TN,Num,TN1),!.
1562change_nums([Num|TN],Num,[0|TN1]):-
1563 change_nums(TN,Num,TN1),!.
1564
1566tidy_temp(Temp,Temp1):-
1567 member(before(Num,0),Temp),
1568 list_take(Temp,[before(Num,0)],Temp0),
1569 change_laters(Temp0,Num,Temp01),
1570 tidy_temp(Temp01,Temp1).
1571tidy_temp([],[]):-!.
1572tidy_temp([before(0,Num)|Temp],Temp0):-
1573 tidy_temp(Temp,Temp0),!.
1574tidy_temp([before(Num1,Num2)|Temp],[before(Num1,Num2)|Temp0]):-
1575 tidy_temp(Temp,Temp0),!.
1576
1577change_laters([before(0,Num2)|Temp],Num,[before(Num,Num2)|Temp0]):-
1578 change_laters(Temp,Num,Temp0).
1579change_laters([before(Num1,0)|Temp],Num,[before(Num1,0)|Temp0]):-
1580 change_laters(Temp,Num,Temp0).
1581change_laters([before(Num1,Num2)|Temp],Num,[before(Num1,Num2)|Temp0]):-
1582 change_laters(Temp,Num,Temp0).
1583
1585make_se_primitive([],[]).
1586make_se_primitive([se(Sort,Obj,ST)|SE],[se(Sort,Obj,ST)|SE0]):-
1587 objectsC(Sort,Objls),!,
1588 make_se_primitive(SE,SE0).
1589make_se_primitive([se(Sort,Obj,ST)|SE],[se(PSort,Obj,ST)|SE0]):-
1590 find_prim_sort(Sort,PSorts),
1591 member(PSort,PSorts),
1592 make_se_primitive(SE,SE0).
1593
1595make_sc_primitive([],[]).
1596make_sc_primitive([sc(Sort,Obj,SE1=>SE2)|ST],[sc(Sort,Obj,SE1=>SE2)|ST0]):-
1597 objectsC(Sort,Objls),!,
1598 make_sc_primitive(ST,ST0).
1599make_sc_primitive([sc(Sort,Obj,SE1=>SE2)|ST],[sc(PSort,Obj,SE1=>SE2)|ST0]):-
1600 find_prim_sort(Sort,PSorts),
1601 member(PSort,PSorts),
1602 make_sc_primitive(ST,ST0).
1603
1604
1607make_tn(TN,Name,Pre,Post,Temp,Dec):-
1608 find_only_changed(Pre,Post,[],Pre1,[],Post1),
1609 not(isemptylist(Post1)),
1610 not(exist_tn(Pre,Post)),
1611 gensym_special(tn,TN),
1613 assert(tn(TN,Name,Pre1,Post1,Temp,Dec)),!.
1614
1615exist_tn(Pre,Post):-
1616 tn(_,_,Pre,Post1,_,_),
1617 state_achieved(Post,Post1),!.
1618find_only_changed([],[],Pre,Pre,Post,Post):-!.
1620find_only_changed([se(Sort,Obj,ST)|Pre],[se(Sort,Obj,ST)|Post],Pre0,Pre1,Post0,Post1):-
1621 find_only_changed(Pre,Post,Pre0,Pre1,Post0,Post1),!.
1622find_only_changed([se(Sort,Obj,ST)|Pre],Post,Pre0,Pre1,Post0,Post1):-
1623 member(se(Sort,Obj,ST1),Post),
1624 list_take(Post,[se(Sort,Obj,ST1)],Post2),
1625 append_changed(se(Sort,Obj,ST),se(Sort,Obj,ST1),Pre0,Pre3,Post0,Post3),
1626 find_only_changed(Pre,Post2,Pre3,Pre1,Post3,Post1),!.
1627find_only_changed([se(Sort,Obj,ST)|Pre],Post,Pre0,Pre1,Post0,Post1):-
1628 member(se(SortN,Obj,ST1),Post),
1629 list_take(Post,[se(SortN,Obj,ST1)],Post2),
1630 append_changed(se(Sort,Obj,ST),se(SortN,Obj,ST1),Pre0,Pre3,Post0,Post3),
1631 find_only_changed(Pre,Post2,Pre3,Pre1,Post3,Post1),!.
1633
1636append_changed(se(Sort,Obj,ST),se(Sort1,Obj,ST1),Pre0,Pre0,Post0,Post0):-
1637 state_match(Sort,Obj,ST,ST1),!.
1638append_changed(se(Sort,Obj,ST),se(Sort1,Obj,ST1),Pre0,Pre3,Post0,Post3):-
1639 append_dcut(Pre0,[se(Sort,Obj,ST)],Pre3),
1640 append_dcut(Post0,[se(Sort,Obj,ST1)],Post3),!.
1641
1643push_to_primitive([],PHPs,PHPs,TNLst,TNLst) :-!.
1644push_to_primitive([step(HPID,_,_,_,exp(TN))|HPs],List,PHPs,TNSoFar,TNFinal) :-
1645 tn(TN,Name,Pre,Post,Temp,Dec),
1646 push_to_primitive(Dec,List,Dec1,[tn(TN,Name,Pre,Post,Temp,Dec)|TNSoFar],TNNext),
1647 push_to_primitive(HPs,Dec1,PHPs,TNNext,TNFinal),!.
1648push_to_primitive([step(HPID,_,_,_,exp(Name))|HPs],List,PHPs,TNSoFar,TNFinal):-
1649 append_dcut(List,[Name],List1),
1650 push_to_primitive(HPs,List1,PHPs,TNSoFar,TNFinal),!.
1651
1653
1654possibly_before(I,J,Temps) :-
1655 \+ necessarily_before(J,I,Temps), !.
1656
1657necessarily_before(J,I,Temps) :-
1658 member(before(J,I),Temps),!.
1659necessarily_before(J,I,Temps) :-
1660 member(before(J,Z),Temps),
1661 necessarily_before(Z,I,Temps),!.
1662
1663select_node(node(Name,Pre,Temp,Decomp,Statics)) :-
1664 retract(node(Name,Pre,Temp,Decomp,Statics)),
1669 !.
1670
1671get_obj_prim_sort([],[]):-!.
1672get_obj_prim_sort([HSort|TV],[HObj|TS]):-
1673 is_of_primitive_sort(HObj,HSort),
1674 get_obj_prim_sort(TV,TS),!.
1683find_all_upper([],[]).
1684find_all_upper([HVars|TV],[HSorts|TS]):-
1685 uppersorts(HSorts,Upsorts),
1686 member(HVars,Upsorts),
1687 find_all_upper(TV,TS).
1688
1690find_prim_sort(Sort,PS):-
1691 subsorts(Sort,Subsorts),
1692 split_prim_noprim(Subsorts,PS,NP),!.
1693
1695get_sort_objects(Sort,Objs):-
1696 find_prim_sort(Sort,PSorts),
1697 get_objects1(PSorts,Objls),
1698 flatten(Objls,[],Objs),!.
1699
1700get_objects1([],[]):-!.
1701get_objects1([PS1|RS],[Objls1|Objls]):-
1702 objectsC(PS1,Objls1),
1703 get_objects1(RS,Objls),!.
1704
1706subsortse(Sort,Subsorts):-
1707 subsorts(Sort,Subsorts1),
1708 subtract(Subsorts1,[Sort],Subsorts),!.
1710subsorts(Sort,Subsorts):-
1711 sort_down([Sort],[],Subsorts),!.
1712
1713sort_down([],Subsorts,Subsorts):-!.
1714sort_down([HOpen|TOpen],List,Subsorts):-
1715 objectsC(HOpen,Objls),
1716 append_dcut(List,[HOpen],List1),
1717 sort_down(TOpen,List1,Subsorts),!.
1718sort_down([HOpen|TOpen],List,Sortslist):-
1719 sorts(HOpen,Sorts),
1720 sort_down(Sorts,List,List2),
1721 sort_down(TOpen,[HOpen|List2],Sortslist),!.
1722sort_down([HOpen|TOpen],List,Sortslist):-
1723 sort_down(TOpen,List,Sortslist),!.
1724
1726uppersortse(Sort,Uppersorts):-
1727 uppersorts(Sort,Uppersortsf),
1728 subtract(Uppersortsf,[Sort],Uppersorts),!.
1730uppersorts(Sort,Uppersorts):-
1731 objectsC(Sort,Objls),
1732 sort_up(Sort,[Sort],Uppersorts),!.
1733uppersorts(Sort,Uppersorts):-
1734 sorts(Sort,Sortls),
1735 sort_up(Sort,[Sort],Uppersorts),!.
1736uppersorts(Obj,Sortls):-
1737 objectsC(Sort,Objls),
1738 member(Obj, Objls),
1739 sort_up(Sort,[Sort],Sortls),!.
1740
1741
1742sort_up(Sort, List,Sortslist):-
1743 sorts(NPSort, NPSortls),
1744 NPSort \== non_primitive_sorts,
1745 NPSort \== primitive_sorts,
1746 member(Sort,NPSortls),
1747 sort_up(NPSort,[NPSort|List],Sortslist).
1748sort_up(Sort, List,List):-!.
1749
1751sametree(Sort1,Sort2):-
1752 Sort1==Sort2,!.
1753sametree(Sort1,Sort2):-
1754 var(Sort1),!.
1755sametree(Sort1,Sort2):-
1756 var(Sort2),!.
1757sametree(Sort1,Sort2):-
1758 uppersorts(Sort2,Sortls),
1759 member(Sort1,Sortls),!.
1760sametree(Sort1,Sort2):-
1761 uppersorts(Sort1,Sortls),
1762 member(Sort2,Sortls),!.
1763
1765split_prim_noprim([],[],[]):-!.
1766split_prim_noprim([HS|TS],[HS|TP],NP):-
1767 objectsC(HS,Obj),
1768 split_prim_noprim(TS,TP,NP),!.
1769split_prim_noprim([HS|TS],PS,[HS|NP]):-
1770 split_prim_noprim(TS,PS,NP),!.
1771
1772
1774
1775
1777statics_consist([]):-!.
1778statics_consist(Statics):-
1779 get_invariants(Invs),
1780 statics_consist(Invs,Statics),!.
1781statics_consist(Invs,[]):-!.
1782statics_consist(Invs,[ne(A,B)|Statics]):-
1783 not(A==B),!,
1784 statics_consist(Invs,Statics).
1785statics_consist(Invs,[is_of_sort(Obj,Sort)|Statics]):-
1786 not(not(is_of_sort(Obj,Sort))),!,
1787 statics_consist(Invs,Statics).
1788statics_consist(Invs,[is_of_primitive_sort(Obj,Sort)|Statics]):-
1789 not(not(is_of_primitive_sort(Obj,Sort))),!,
1790 statics_consist(Invs,Statics).
1791statics_consist(Invs,[Pred|Statics]):-
1792 pred_member(Pred,Invs),!,
1793 statics_consist(Invs,Statics).
1794
1796statics_consist_instance([]):-!.
1797statics_consist_instance(Statics):-
1798 get_invariants(Invs),
1799 statics_consist_instance(Invs,Statics).
1800
1801statics_consist_instance(Invs,[]):-!.
1802statics_consist_instance(Invs,[is_of_sort(Obj,Sort)|Atom]):-
1803 ground(Obj),
1804 is_of_sort(Obj,Sort),!,
1805 statics_consist_instance(Invs,Atom).
1806statics_consist_instance(Invs,[is_of_sort(Obj,Sort)|Atom]):-
1807 var(Obj),
1808 is_of_sort(Obj,Sort),
1809 statics_consist_instance(Invs,Atom).
1810statics_consist_instance(Invs,[is_of_primitive_sort(Obj,Sort)|Atom]):-
1811 ground(Obj),
1812 is_of_primitive_sort(Obj,Sort),!,
1813 statics_consist_instance(Invs,Atom).
1814statics_consist_instance(Invs,[is_of_primitive_sort(Obj,Sort)|Atom]):-
1815 var(Obj),
1816 is_of_primitive_sort(Obj,Sort),
1817 statics_consist_instance(Invs,Atom).
1818statics_consist_instance(Invs,[ne_back(A,B)|Atom]):-
1819 A\==B,
1820 statics_consist_instance(Invs,Atom).
1821statics_consist_instance(Invs,[ne(A,B)|Atom]):-
1822 append_dcut(Atom,[ne_back(A,B)],Atom1),!,
1823 statics_consist_instance(Invs,Atom1).
1824statics_consist_instance(Invs,[Pred|Atom]):-
1825 ground(Pred),
1826 member(Pred,Invs),!,
1827 statics_consist_instance(Invs,Atom).
1828statics_consist_instance(Invs,[Pred|Atom]):-
1829 not(ground(Pred)),
1830 member(Pred,Invs),
1831 statics_consist_instance(Invs,Atom).
1833
1835get_invariants(Invs) :-
1836 atomic_invariantsC(Invs),!.
1837
1838rem_statics([sc(S,X,Lhs=>Rhs)|ST], [sc(S,X,LhsR=>RhsR)|STR],Rt1) :-
1839 split_st_dy(Lhs,[],LR, [],LhsR),
1840 split_st_dy(Rhs,[],RR,[],RhsR),
1841 append_dcut(LR,RR,R),
1842 rem_statics(ST, STR,Rt),
1843 append_dcut(Rt,[is_of_sort(X,S)|R],Rt1),!.
1844rem_statics([ss(S,X,Preds)|Post], [ss(S,X,PredR)|PostR],Rt1) :-
1845 split_st_dy(Preds,[],R, [],PredR),
1846 rem_statics(Post, PostR,Rt),
1847 append_dcut(Rt,[is_of_sort(X,S)|R],Rt1),!.
1848rem_statics([se(S,X,Preds)|Post], [se(S,X,PredR)|PostR],Rt1) :-
1849 split_st_dy(Preds,[],R, [],PredR),
1850 rem_statics(Post, PostR,Rt),
1851 append_dcut(Rt,[is_of_sort(X,S)|R],Rt1),!.
1852rem_statics([], [],[]) :-!.
1853
1854
1856
1858isemptylist([]):-!.
1859
1865
1866member_cut(X,[X|_]) :- !.
1867member_cut(X,[_|Y]) :- member_cut(X,Y),!.
1868
1870member_e(X,[Y|_]):-
1871 X==Y,!.
1872member_e(X,[Y|L]):-
1873 var(Y),
1874 member_e(X,L),!.
1875member_e(ss(Sort,Obj,SE),[ss(Sort,Obj1,SE)|_]):-
1876 Obj==Obj1,!.
1877member_e(se(Sort,Obj,SE),[se(Sort,Obj1,SE)|_]):-
1878 Obj==Obj1,!.
1879member_e(sc(Sort,Obj,SE1=>SE2),[sc(Sort,Obj1,SE1=>SE2)|_]):-
1880 Obj==Obj1,!.
1881member_e(X,[Y|L]):- member_e(X,L),!.
1882
1883
1886u_mem_cut(_,[]):-!,fail.
1887u_mem_cut(X,[Y|_]) :- X == Y,!.
1888u_mem_cut(X,[_|L]) :- u_mem_cut(X,L),!.
1893obj_member(X,[X|[]]):-!.
1894obj_member(X,List):-
1895 obj_member0(X,List),!.
1896obj_member0(X,[Y|_]):-
1897 var(X),!. 1898obj_member0(X,[Y|_]):-
1899 X==Y,!.
1900obj_member0(X,[_|Y]) :- obj_member0(X,Y),!.
1901
1902
1906pred_member(X,List):-
1907 ground(X),
1908 member(X,List),!.
1909pred_member(X,List):-
1910 setof(X,member(X,List),Refined),
1911 pred_member0(X,Refined),!.
1912
1913pred_member0(X,[X|[]]):-!.
1914pred_member0(X,Y):-
1915 pred_member1(X,Y),!.
1916pred_member1(X,[Y|_]):-
1917 X=..[H|XLs],
1918 Y=..[H|YLs],
1919 vequal(XLs,YLs),!.
1920pred_member1(X,[_|Y]):- pred_member1(X,Y),!.
1921
1922statics_append([],L,L):-
1923 statics_consist(L),!.
1924statics_append(L,[],L):-
1925 statics_consist(L),!.
1926statics_append(List1,List2,L):-
1927 statics_consist(List1),
1928 statics_consist(List2),
1929 statics_append1(List1,List2,[],L),
1930 statics_consist(L),!.
1931
1932statics_append1([],List2,L1,L):-
1933 append_dcut(List2,L1,L),!.
1934statics_append1([H|List1],List2,L,Z) :-
1935 statics_append0(H,List2,L,L1),
1936 statics_append1(List1,List2,L1,Z),!.
1937
1938statics_append0(H,[],L,[H|L]):-!.
1939statics_append0(H,[H|Z],L,L):-!.
1940statics_append0(H,[X|Z],L1,L):-
1941 statics_append0(H,Z,L1,L),!.
1942
1943append_dcut([],L,L):-!.
1944append_dcut([H|T],L,[H|Z]) :- append_dcut(T,L,Z),!.
1945
1946append_cut([],L,L) :- !.
1947append_cut([H|T],L,[H|Z]) :- append_cut(T,L,Z),!.
1948
1953append_st(ST1,ST2,ST):-
1954 append_dcut(ST1,ST2,ST0),
1955 remove_unneed(ST0,[],ST),!.
1956
1959remove_unneed([],C,C):-!.
1960remove_unneed([A|B], Z, C):-
1961 var(A),
1962 member_e(A,Z),
1963 remove_unneed(B, Z, C),! .
1964remove_unneed([A|B], Z, C):-
1965 var(A),
1966 append_dcut(Z,[A],D),
1967 remove_unneed(B, D, C),!.
1968remove_unneed([A|B], Z, C):-
1969 ground(A),
1970 remove_unneed(B, Z, C),!.
1971remove_unneed([A|B], Z, C):-
1972 A=..[ne|Paras],
1973 append_dcut(Z,[A],D),
1974 remove_unneed(B, D, C),!.
1975remove_unneed([A|B], Z, C):-
1976 A=..[Pred|Paras],
1977 same_var_member(A,Z),
1978 remove_unneed(B, Z, C),!.
1979remove_unneed([A|B], Z, C):-
1980 append_dcut(Z,[A],D),
1981 remove_unneed(B, D, C),!.
1982
1983same_var_member(Pred,[Pred1|List]):-
1984 var(Pred1),
1985 same_var_member(Pred,List),!.
1986same_var_member(Pred,[Pred1|List]):-
1987 Pred==Pred1,!.
1988same_var_member(Pred,[Pred1|List]):-
1989 Pred=..[H|T],
1990 Pred1=..[H|T1],
1991 same_var_member1(T,T1),!.
1992same_var_member(Pred,[Pred1|List]):-
1993 same_var_member(Pred,List),!.
1994
1995same_var_member1([],[]):-!.
1996same_var_member1([H1|T],[H2|T]):-
1997 var(H1),
1998 H1==H2,!.
1999same_var_member1([H|T1],[H|T2]):-
2000 var(T1),
2001 T1==T2,!.
2002same_var_member1([H1|T1],[H2|T2]):-
2003 H1==H2,
2004 same_var_member1(T1,T2),!.
2005
2007is_equal_list(List1,List2):-
2008 List1==List2,!.
2009is_equal_list([],[]):-!.
2010is_equal_list(List1,List2):-
2011 length(List1,L),
2012 length(List2,L),
2013 is_equal_list1(List1,List2),!.
2014is_equal_list1([],[]):-!.
2015is_equal_list1([Head1|List1],[Head2|List2]):-
2016 Head1==Head2,
2017 is_equal_list1(List1,List2),!.
2018is_equal_list1([se(Sort,Obj,Head1)|List1],[se(Sort,Obj,Head2)|List2]):-
2019 is_equal_list(Head1,Head2),
2020 is_equal_list1(List1,List2),!.
2021is_equal_list1([Head1|List1],[Head2|List2]):-
2022 Head1=..[FF|Var1],
2023 Head2=..[FF|Var2],
2024 FF\==se,
2025 vequal(Var1,Var2),
2026 is_equal_list1(List1,List2),!.
2027is_equal_list1([Head1|List1],List2):-
2028 member(Head1,List2),
2029 append_cut(List1,[Head1],List10),
2030 is_equal_list1(List10,List2),!.
2031
2033is_diff(List1,List2):-
2034 length(List1,L1),
2035 length(List2,L2),
2036 L1\==L2,!.
2037is_diff([Head|List1],List2):-
2038 not_exist(Head,List2),!.
2039is_diff([Head|List1],List2):-
2040 list_take(List2,[Head],List21),
2041 is_diff(List1,List21),!.
2042
2043not_exist(Pred,List2):-
2044 not(member(Pred,List2)),!.
2045not_exist(se(Sort,Obj,Head1),List2):-
2046 not(member(se(Sort,Obj,Head),List2)),!.
2047not_exist(se(Sort,Obj,Head1),List2):-
2048 member(se(Sort,Obj,Head2),List2),
2049 is_diff(Head1,Head2),!.
2050
2051
2055set_append([], Z, Z):-! .
2056set_append([A|B], Z, C) :-
2057 not(not(member(A, Z))) ,
2058 set_append(B, Z, C),! .
2059set_append([A|B], Z, [A|C]) :-
2060 set_append(B, Z, C) .
2061
2062
2063
2067set_append_e(A,B,C):-
2068 append_cut(A,B,D),
2069 remove_dup(D,[],C),!.
2070
2072remove_dup([],C,C):-!.
2073remove_dup([A|B],Z,C) :-
2074 member_e(A, Z),
2075 remove_dup(B, Z, C),! .
2076remove_dup([A|B], Z, C):-
2077 append_dcut(Z,[A],D),
2078 remove_dup(B, D, C),!.
2079
2081vequal([],[]):-!.
2082vequal([X|XLs],[Y|YLs]):-
2083 X==Y,
2084 vequal(XLs,YLs),!.
2085vequal([X|XLs],[Y|YLs]):-
2086 var(X),
2087 vequal(XLs,YLs),!.
2088vequal([X|XLs],[Y|YLs]):-
2089 var(Y),
2090 vequal(XLs,YLs),!.
2091
2092
2103
2105
2106list_take(R,[E|R1],R2):-
2107 remove_el(R,E,RR),
2108 list_take(RR,R1,R2),!.
2109list_take(R,[_|R1],R2):-
2110 list_take(R,R1,R2),!.
2111list_take(A,[],A) :- !.
2112
2115remove_el([],_,[]) :- ! .
2116remove_el([A|B],A,B) :- ! .
2117remove_el([A|B],C,[A|D]) :-
2118 remove_el(B,C,D) .
2119
2121
2122gensym_special(Root,Atom) :-
2123 getnum(Root,Num),
2124 name(Root,Name1),
2125 name(Num,Name2),
2126 append_dcut(Name1,Name2,Name),
2127 name(Atom,Name).
2128
2129getnum(Root,Num) :-
2130 retract(current_num(Root,Num1)),!,
2131 Num is Num1+1,
2132 asserta(current_num(Root,Num)).
2133
2134getnum(Root,1) :- asserta(current_num(Root,1)).
2135
2136
2137gensym_num(Root,Num,Atom):-
2138 name(Root,Name),
2139 name(Num,Name1),
2140 append_dcut(Name,Name1,Name2),
2141 name(Atom,Name2),!.
2142
2143
2144pprint([],SIZE,SIZE):-!.
2145pprint([HS|TS],Size0,SIZE):-
2146 list(HS),
2147 pprint(HS,Size0,Size1),
2148 pprint(TS,Size1,SIZE),!.
2149pprint([HS|TS],Size0,SIZE):-
2152 Size1 is Size0+1,
2153 pprint(TS,Size1,SIZE),!.
2154
2156
2157split_st_dy([],ST,ST,DY,DY):-!.
2158split_st_dy([Pred|TStates],ST0,ST,DY0,DY):-
2159 is_statics(Pred),
2160 append_cut(ST0,[Pred],ST1),
2161 split_st_dy(TStates,ST1,ST,DY0,DY),!.
2162split_st_dy([Pred|TStates],ST0,ST,DY0,DY):-
2163 append_cut(DY0,[Pred],DY1),
2164 split_st_dy(TStates,ST0,ST,DY1,DY),!.
2165
2167
2168flatten([HO|TO], List, O_List):-
2169 append_dcut(HO, List, List_tmp),
2170 flatten(TO, List_tmp, O_List),!.
2171flatten([H|TO], List,O_List):-
2172 append_dcut([H], List, List_tmp),
2173 flatten(TO, List_tmp, O_List).
2174flatten([], [HList|T], O_List):-
2175 HList = [],
2176 flatten(T, [], O_List).
2177flatten([], [HList|T], O_List):-
2178 list(HList),
2179 flatten([HList|T],[], O_List),!.
2180flatten([], L,L):-!.
2181
2183set_flatten([HO|TO], List, O_List):-
2184 set_append_e(HO, List, List_tmp),
2185 set_flatten(TO, List_tmp, O_List),!.
2186set_flatten([H|TO], List,O_List):-
2187 set_append_e([H], List, List_tmp),
2188 set_flatten(TO, List_tmp, O_List).
2189set_flatten([], [HList|T], O_List):-
2190 HList = [],
2191 set_flatten(T, [], O_List).
2192set_flatten([], [HList|T], O_List):-
2193 list(HList),
2194 set_flatten([HList|T],[], O_List),!.
2195set_flatten([], L,L):-!.
2196
2197
2200list(A) :-
2201 var(A) ,
2202 ! ,
2203 fail .
2204list(A) :-
2205 functor(A,'.',_).
2206
2207reverse(L,RL) :-
2208 revSlave(L,[],RL).
2209
2210revSlave([],RL,RL).
2211revSlave([H|T],Sofar,Final) :-
2212 revSlave(T,[H|Sofar],Final).
2213
2215:- assert(time_taken(0)). 2216:- assert(soln_size(0)). 2217
2218solve(N,FN):-
2219 N < FN,
2220 nl,write('task '), write(N),write(': '),nl,
2221 solve(N),
2222 Ni is N+1,
2223 solve(Ni,FN).
2224solve(FN,FN):-
2225 nl,write('task '), write(FN),write(': '),nl,
2226 solve(FN),
2227 retractall(sum(_)),
2228 assert(sum(0)),
2229 sum_time(CP),
2230 retractall(sum(_)),
2231 assert(sum(0)),
2232 sum_size(SIZE),
2233 TIM is CP /1000,
2234 retractall(time_taken(_)),
2235 retractall(soln_size(_)),
2236 nl,write('total time '),write(TIM),write(' seconds'),
2237 nl,write('total size '),write(SIZE),nl.
2238solve(N,N).
2239
2240sum_time(TIM):-
2241 time_taken(CP),
2242 retract(sum(N)),
2243 N1 is N +CP,
2244 assert(sum(N1)),
2245 fail.
2246sum_time(TIM):-
2247 sum(TIM).
2248sum_size(SIZE):-
2249 soln_size(S),
2250 retract(sum(N)),
2251 N1 is N +S,
2252 assert(sum(N1)),
2253 fail.
2254sum_size(SIZE):-
2255 sum(SIZE).
2256
2257stoppoint.
2259state_related(Post,Cond,undefd):-!.
2260state_related(Post,Cond,[]):-!.
2261state_related(Post,Cond,State2):-
2262 append_dcut(Post,Cond,State1),
2263 state_related(State1,State2).
2264
2267state_related([se(Sort,Obj,SE1)|State1],State2):-
2268 member(se(Sort,Obj,SE2),State2),
2269 state_related0(SE1,SE2).
2271state_related([sc(Sort1,Obj,SE1=>SS1)|State1],State2):-
2272 member(se(Sort,Obj,SE2),State2),
2273 is_of_sort(Obj,Sort1),
2274 is_of_sort(Obj,Sort).
2275state_related([se(Sort,Obj,SE)|State1],State2):-
2276 state_related(State1,State2),!.
2277state_related([sc(Sort,Obj,SE=>SS)|State1],State2):-
2278 state_related(State1,State2),!.
2279
2281state_related0([],SE2):-!.
2282state_related0([Head|SE1],SE2):-
2283 member(Head,SE2),
2284 state_related0(SE1,SE2).
2285state_related0([Head|SE1],SE2):-
2286 state_related0(SE1,SE2).
2287
2290change_obj_list(I):-
2291 find_dynamic_objects(I),
2292 collect_dynamic_obj,
2293 change_obj_list1,
2294 change_atomic_inv,!.
2295
2296change_obj_list1:-
2297 objects(Sort,OBjls),
2298 change_obj_list2(Sort),
2299 fail.
2300change_obj_list1.
2301
2303change_obj_list2(Sort):-
2304 objectsC(Sort,Objls),!.
2306change_obj_list2(Sort):-
2307 objects(Sort,Objls),
2308 assert(objectsC(Sort,Objls)),!.
2309
2311change_atomic_inv:-
2312 atomic_invariants(Atom),
2313 change_atomic_inv1(Atom,Atom1),
2314 assert(atomic_invariantsC(Atom1)),!.
2315change_atomic_inv.
2316
2317change_atomic_inv1([],[]).
2318change_atomic_inv1([Pred|Atom],[Pred|Atom1]):-
2319 Pred=..[Name|Objs],
2320 just_dynamic_objects(Objs),
2321 change_atomic_inv1(Atom,Atom1).
2322change_atomic_inv1([Pred|Atom],Atom1):-
2323 change_atomic_inv1(Atom,Atom1).
2324
2325just_dynamic_objects([]).
2326just_dynamic_objects([Head|Objs]):-
2327 objectsC(Sort,Objls),
2328 member(Head,Objls),!,
2329 just_dynamic_objects(Objs).
2330
2331find_dynamic_objects([]):-!.
2332find_dynamic_objects([SE|Rest]):-
2333 find_dynamic_objects(SE),
2334 find_dynamic_objects(Rest),!.
2335find_dynamic_objects(ss(Sort,Obj,_)):-
2336 assert(objectsD(Sort,Obj)),!.
2337
2338collect_dynamic_obj:-
2339 objectsD(Sort,_),
2340 setof(Obj, objectsD(Sort,Obj), Objls),
2341 retractall(objectsD(Sort,_)),
2342 assert(objectsC(Sort,Objls)),
2343 fail.
2344collect_dynamic_obj.
2345
2346get_preconditions_g([],Prev,Prev,Prev):-!.
2347get_preconditions_g([sc(S,X,From =>To)|Rest],Prev,[se(S,X,From)|Pre],[se(S,X,To)|Post]):-
2348 !,
2349 get_preconditions_g(Rest,Prev, Pre,Post).
2350
2353
2354ground_op :-
2355 assert_sort_objects,
2356 enumerateOps,
2357 instOps,
2358 opCounter(Top),
2359 write(Top),nl.
2360
2361enumerateOps :-
2362 retractall(opCounter),
2363 assert(opCounter(1)),
2364 enumOps.
2365
2366enumOps :-
2367 operator(Name,Prev,Nec,Cond),
2368 retract(opCounter(Count)),
2369 containsInvars(operator(Name,Prev,Nec,Cond),InVars,IsOfSorts,FPrev,FNec),
2370 2371 findVarsAndTypes(operator(Name,Prev,Nec,Cond),VT,NEs),
2372 assert(opParent(Count,operator(Name,FPrev,FNec,Cond),VT,NEs,InVars,IsOfSorts)),
2373 Next is Count + 1,
2374 assert(opCounter(Next)),
2375 fail.
2376
2377enumOps.
2378
2379
2388
2389
2390findVarsAndTypes(operator(_,Pre,Nec,Cond),Vars,NEs) :-
2391 vtPrevail(Pre,PreVars,PreNEs),
2392 vtEffects(Nec,NecVars,NecNEs),
2393 append_dcut(PreVars,NecVars,Vars),
2394 append_dcut(PreNEs,NecNEs,NEs),
2395 !.
2396
2399
2400vtEffects([],[],[]).
2401
2402vtEffects([sc(Type,Obj1,Preds)|Rest],VT,NEs) :-
2403 vtPreds(Preds,Related,NEs1),
2404 append_dcut([Type,Obj1],Related,Obj1VT),
2405 vtEffects(Rest,RestVT,RestNEs),
2406 append_dcut(Obj1VT,RestVT,VT),
2407 append_dcut(NEs1,RestNEs,NEs).
2408
2411
2412vtPrevail([],[],[]).
2413
2414vtPrevail([se(Type,Obj1,Preds)|Rest],VT,NEs) :-
2415 vtPLst(Preds,Related,NEs1),
2416 append_dcut([Type,Obj1],Related,Obj1VT),
2417 vtPrevail(Rest,RestVT,RestNEs),
2418 append_dcut(Obj1VT,RestVT,VT),
2419 append_dcut(NEs1,RestNEs,NEs).
2420
2423
2424vtPreds((Pre => Add),Res,NEs) :-
2425 vtPLst(Pre,VTPre,NEs1),
2426 vtPLst(Add,VTAdd,NEs2),
2427 append_dcut(VTPre,VTAdd,Res),
2428 append_dcut(NEs1,NEs2,NEs).
2429
2432
2433vtPLst([],[],[]).
2434
2435vtPLst([ne(X,Y)|Rest],Res,[ne(X,Y)|RestNEs]) :-
2436 !,
2437 vtPLst(Rest,Res,RestNEs).
2438
2439vtPLst([Pred|Preds],Res,NEs) :-
2440 functor(Pred,_,1),
2441 !,
2442 vtPLst(Preds,Res,NEs).
2443
2444vtPLst([is_of_sort(_,_)|Preds],Res,NEs) :-
2445 !,
2446 vtPLst(Preds,Res,NEs).
2447
2451
2452vtPLst([Pred|Preds],Res,NEs) :-
2453 functor(Pred,Name,Arity),
2454 Pred =.. [Name,Obj1|Rest],
2455 VNeeded is Arity - 1,
2456 createVarList(VNeeded,VN),
2457 DummyPred =.. [Name,X|VN],
2458 predicates(PList),
2459 member(DummyPred,PList),
2460 pair(VN,Rest,This),
2461 vtPLst(Preds,RestPre,NEs),
2462 append_dcut(This,RestPre,Res).
2463
2466
2467createVarList(1,[X]) :-
2468 !.
2469
2470createVarList(N,[X|Rest]) :-
2471 Next is N - 1,
2472 createVarList(Next,Rest).
2473
2476
2477pair([],[],[]).
2478
2479pair([Type|Types],[Var|Vars],[Type,Var|Rest]) :-
2480 pair(Types,Vars,Rest).
2481
2482
2483
2488
2489instOps :-
2490 retractall(opCounter(_)),
2491 assert(opCounter(1)),
2492 opParent(No,Operator,VT,NEs,InVars,IsOfSorts),
2493 checkIsOfSorts(IsOfSorts),
2494 checkInVars(InVars),
2495 chooseVals(VT,NEs,InVars,Vals),
2496 obeysNEs(NEs),
2497 retract(opCounter(Count)),
2498 operator(Name,Prev,Nec,Cond) = Operator,
2499 filterSE(Prev,FPrev),
2500 filterSC(Nec,FNec),
2501 assert(gOperator(Count,No,operator(Name,FPrev,FNec,Cond))),
2502 Next is Count + 1,
2503 assert(opCounter(Next)),
2504 fail.
2505
2506instOps.
2507
2508
2509checkInVars([]):- !.
2510checkInVars(Preds):-
2511 atomic_invariantsC(Invars),
2512 doCheckInvars(Preds,Invars).
2513
2514doCheckInvars([],_).
2515doCheckInvars([Pred|Rest],Invars) :-
2516 member(Pred,Invars),
2517 doCheckInvars(Rest,Invars).
2518
2519checkIsOfSorts([]).
2520checkIsOfSorts([is_of_sort(V,Sort)|Rest]) :-
2521 objectsOfSort(Sort,Objs),
2522 member(V,Objs),
2523 checkIsOfSorts(Rest).
2524
2525
2527
2528filterSE([],[]) :- !.
2529filterSE([se(Sort,Id,Preds)|Rest],[se(Sort,Id,FPreds)|FRest]) :-
2530 filterPreds(Preds,FPreds),!,
2531 filterSE(Rest,FRest).
2532
2534
2535filterSC([],[]) :- !.
2536filterSC([sc(Sort,Id,(Pre => Post))|Rest],[sc(Sort,Id,(FPre => FPost))|FRest]) :-
2537 filterPreds(Pre,FPre),
2538 filterPreds(Post,FPost),
2539 !,
2540 filterSC(Rest,FRest).
2541
2543
2544filterPreds([],[]).
2545filterPreds([ne(_,_)|Rest],FRest) :-
2546 !,
2547 filterPreds(Rest,FRest).
2548filterPreds([is_of_sort(_,_)|Rest],FRest) :-
2549 !,
2550 filterPreds(Rest,FRest).
2556filterPreds([H|T],[H|FT]) :-
2557 filterPreds(T,FT).
2558
2559
2561
2562collectAllConds(_,_,_,_,[],[]) :- !.
2563
2564collectAllConds(CondVT,NEs,InVars,CondVals,Cond,_) :-
2565 retractall(temp(_)),
2566 chooseVals(CondVT,NEs,InVars,Vals),
2567 assertIndivConds(Cond),
2568 fail.
2569
2570collectAllConds(_,_,_,_,_,NewConds) :-
2571 setof(Cond,temp(Cond),NewConds).
2572
2573assertIndivConds([]) :- !.
2574
2575assertIndivConds([H|T]) :-
2576 assert(temp(H)),
2577 assertIndivConds(T).
2578
2580
2581containsInvars(operator(Name,Prev,Nec,Cond),InVars,IsOfSorts,FPrev,FNec) :-
2582 prevInvars(Prev,PInVars,PIsOfSorts,FPrev),
2583 necInvars(Nec,NecInVars,NIsOfSorts,FNec),
2584 append_dcut(NecInVars,PInVars,InVars),
2585 append_dcut(PIsOfSorts,NIsOfSorts,IsOfSorts),
2586 !.
2587
2588prevInvars([],[],[],[]).
2589prevInvars([se(Type,Obj,Props)|Rest],InVars,IsOfSorts,[se(Type,Obj,FProps)|RFPrev]) :-
2590 propsInvars(Props,PInvars,PIsOfSorts,FProps),
2591 prevInvars(Rest,RInVars,RIsOfSorts,RFPrev),
2592 append_dcut(PInVars,RInVars,InVars),
2593 append_dcut([is_of_sort(Obj,Type)|PIsOfSorts],RIsOfSorts,IsOfSorts).
2594
2595necInvars([],[],[],[]).
2596necInvars([sc(Type,Obj,(Props => Adds))|Rest],Invars,IsOfSorts,[sc(Type,Obj,(FProps => FAdds))|RFNec]) :-
2597 propsInvars(Props,PInvars,PIsOfSorts,FProps),
2598 propsInvars(Adds,AInvars,AIsOfSorts,FAdds),
2599 necInvars(Rest,RInvars,RIsOfSorts,RFNec),
2600 append_dcut(AInvars,PInvars,Temp),
2601 append_dcut(Temp,RInvars,Invars),
2602 append_dcut(PIsOfSorts,AIsOfSorts,SortsTemp),
2603 append_dcut([is_of_sort(Obj,Type)|SortsTemp],RIsOfSorts,IsOfSorts).
2604
2605propsInvars([],[],[],[]).
2606propsInvars([Prop|Props],[Prop|Rest],IsOfSorts,FProps) :-
2607 isInvariant(Prop),
2608 !,
2609 propsInvars(Props,Rest,IsOfSorts,FProps).
2610propsInvars([is_of_sort(X,Y)|Props],InVars,[is_of_sort(X,Y)|IsOfSorts],FProps):-
2611 !,
2612 propsInvars(Props,InVars,IsOfSorts,FProps).
2613
2614propsInvars([Pred|Props],Rest,IsOfSorts,[Pred|FProps]) :-
2615 propsInvars(Props,Rest,IsOfSorts,FProps).
2616
2617isInvariant(Prop) :-
2618 atomic_invariantsC(Invars),
2619 functor(Prop,Name,Arity),
2620 createVarList(Arity,VN),
2621 Pred =.. [Name | VN],
2622 member(Pred,Invars).
2623
2627
2628chooseVals([],_,_,[]).
2629
2630chooseVals([Type,Var|TypeVars],NEs,InVars,Vals) :-
2631 ground(Var),
2632 !,
2633 chooseVals(TypeVars,NEs,InVars,Vals).
2634
2635chooseVals([Type,Var|TypeVars],NEs,InVars,[Var|Vals]) :-
2636 objectsOfSort(Type,AllVals),
2637 member(Var,AllVals),
2638 chooseVals(TypeVars,NEs,InVars,Vals).
2645assert_sort_objects :-
2646 objectsC(Type,Objects),
2647 assert(objectsOfSort(Type,Objects)),
2648 fail.
2649
2650assert_sort_objects :-
2651 sorts(Type,SubTypes),
2652 Type \== primitive_sorts,
2653 Type \== non_primitive_sorts,
2654 all_objects(Type,Objs),
2655 assert(objectsOfSort(Type,Objs)),
2656 fail.
2657
2658assert_sort_objects.
2659
2660all_objects(Type,Objs) :-
2661 objectsC(Type,Objs),
2662 !.
2663all_objects(Type,Objs) :-
2664 sorts(Type,SubSorts),
2665 !,
2666 collect_subsort_objects(SubSorts,Objs).
2667
2668collect_subsort_objects([],[]).
2669collect_subsort_objects([Sort|Rest],Objs ) :-
2670 all_objects(Sort,SortObjs),
2671 !,
2672 collect_subsort_objects(Rest,RestObjs),
2673 append_dcut(SortObjs,RestObjs,Objs).
2674
2675obeysNEs([]).
2676
2677obeysNEs([ne(V1,V2)|Rest]) :-
2678 V1 \== V2,
2679 obeysNEs(Rest).
2680
2681obeysInVars([]).
2682obeysInVars([Prop|Rest]) :-
2683 atomic_invariantsC(Invars),
2684 member(Prop,Invars),
2685 !.
2686
2690
2691
2693
2694prettyPrintOp(gOperator(No,Par,Op)) :-
2695 write('gOperator('),
2696 write(No),write(','),
2697 write(Par),write(','),nl,
2698 writeOp(4,Op),
2699 !.
2700
2701writeOp(TabVal,operator(Name,Prev,Nec,Cond)) :-
2702 tab(TabVal),
2703 write('operator('),write(Name),write(','),nl,
2704 tab(8),write('% Prevail'),nl,
2705 tab(8),write('['),nl,
2706 writePrevailLists(8,Prev),
2707 tab(8),write('],'),nl,
2708 tab(8),write('% Necessary'),nl,
2709 tab(8),write('['),nl,
2710 writeChangeLists(10,Nec),
2711 tab(8),write('],'),nl,
2712 tab(8),write('% Conditional'),nl,
2713 tab(8),write('['),nl,
2714 writeChangeLists(10,Cond),
2715 tab(8),write('])).'),nl.
2716
2717writePropList(TabVal,[]) :-
2718 tab(TabVal),
2719 write('[]').
2720
2721writePropList(TabVal,[ne(_,_)|Props]) :-
2722 !,
2723 writePropList(Indent,Props).
2724
2725writePropList(TabVal,[Prop|Props]) :-
2726 atomic_invariantsC(Invars),
2727 member(Prop,Invars),
2728 writePropList(TabVal,Props).
2729
2730writePropList(TabVal,[Prop|Props]) :-
2731 tab(TabVal),
2732 write('['),
2733 write(Prop),
2734 Indent is TabVal + 1,
2735 writePList(Indent,Props).
2736
2737writePList(TabVal,[]) :-
2738 nl,
2739 tab(TabVal),
2740 write(']').
2741
2742writePList(TabVal,[ne(_,_)]) :-
2743 !,
2744 nl,
2745 tab(TabVal),
2746 write(']').
2747
2748writePList(TabVal,[Prop]) :-
2749 atomic_invariantsC(Invars),
2750 member(Prop,Invars),
2751 !,
2752 nl,
2753 tab(TabVal),
2754 write(']').
2755
2756writePList(TabVal,[Prop]) :-
2757 write(','),
2758 nl,
2759 tab(TabVal),
2760 write(Prop),
2761 write(']').
2762
2763writePList(TabVal,[ne(_,_),P2|Rest]) :-
2764 !,
2765 writePList(TabVal,[P2|Rest]).
2766
2767writePList(TabVal,[Prop,P2|Rest]) :-
2768 atomic_invariantsC(Invars),
2769 member(Prop,Invars),
2770 !,
2771 writePList(TabVal,[P2|Rest]).
2772
2773writePList(TabVal,[P1,P2|Rest]) :-
2774 write(','),
2775 nl,
2776 tab(TabVal),
2777 write(P1),
2778 writePList(TabVal,[P2|Rest]).
2779
2780writeChangeLists(_,[]).
2781
2782writeChangeLists(TabVal,[sc(Type,Obj,(Req => Add))|Rest]) :-
2783 tab(TabVal),
2784 write('sc('),write(Type),write(','),write(Obj),write(',('),nl,
2785 Indent is TabVal + 12,
2786 writePropList(Indent,Req),
2787 nl,
2788 tab(Indent),
2789 write('=>'),
2790 nl,
2791 writePropList(Indent,Add),
2792 write('))'),writeComma(Rest),
2793 nl,
2794 writeChangeLists(TabVal,Rest).
2795
2796writeComma([]).
2797writeComma(_) :-
2798 write(',').
2799
2800writePrevailLists(_,[]).
2801
2802writePrevailLists(TabVal,[se(Type,Obj,Props)|Rest]) :-
2803 tab(TabVal),
2804 write('se('),write(Type),write(','),write(Obj),write(','),nl,
2805 Indent is TabVal + 12,
2806 writePropList(Indent,Props),
2807 write(')'),writeComma(Rest),
2808 nl,
2809 writePrevailLists(TabVal,Rest).
2810
2811
2812assert_is_of_sort :-
2813 objectsOfSort(Type,Objects),
2814 member(Obj,Objects),
2815 assert_is_of_sort1(Type,Obj),
2816 fail.
2817assert_is_of_sort :-
2818 objectsC(Type,Objects),
2819 member(Obj,Objects),
2820 assert_is_of_primitive_sort(Type,Obj),
2821 fail.
2822assert_is_of_sort.
2823
2824assert_is_of_sort1(Type,Obj):-
2825 assert(is_of_sort(Obj,Type)),!.
2826assert_is_of_primitive_sort(Type,Obj):-
2827 assert(is_of_primitive_sort(Obj,Type)),!.
2828
2829
2832prim_substate_class:-
2833 substate_classes(Sort,Obj,Substate),
2834 find_prim_sort(Sort,PS),
2835 assert_subclass(PS,Obj,Substate),
2836 fail.
2837prim_substate_class:-
2838 collect_prim_substates.
2839
2840assert_subclass([],Obj,Substate).
2841assert_subclass([HS|TS],Obj,Substate):-
2842 assert(gsstates(HS,Obj,Substate)),
2843 assert_subclass(TS,Obj,Substate).
2844
2845collect_prim_substates:-
2846 gsstates(Sort,Obj,_),
2847 setof(SStates,gsstates(Sort,Obj,SStates),GSStates),
2848 retractall(gsstates(Sort,Obj,_)),
2849 all_combined(GSStates,GSStates0),
2850 assert(gsubstate_classes(Sort,Obj,GSStates0)),
2851 fail.
2852collect_prim_substates.
2853
2854all_combined(SStates,CSStates):-
2855 xprod(SStates,CSStates1),
2856 flat_interal(CSStates1,CSStates),!.
2857
2858flat_interal([],[]):-!.
2859flat_interal([HSS1|TSS1],[HSS|TSS]):-
2860 flatten(HSS1,[],HSS),
2861 flat_interal(TSS1,TSS),!.
2862
2865xprod(A,B,C) :-
2866 xprod([A,B],C) .
2867
2868xprod([],[]).
2869xprod(A,E) :-
2870 xprod(A,B,C,D) ,
2871 F =..[^,C,D] ,
2872 call(setof(B,F,E)) .
2873
2874xprod([X],[A],A,member(A,X)) .
2875xprod([X,Y],[A,B],C,(D,E)) :-
2876 C =..[^,A,B] ,
2877 D =..[member,A,X] ,
2878 E =..[member,B,Y] .
2879xprod([X|Y],[A|E],D,(F,G)) :-
2880 D =..[^,A,C] ,
2881 F =..[member,A,X] ,
2882 xprod(Y,E,C,G).
2883
2884
2885
2886
2887:-retractall(solution_file(_)). 2888:-asserta(solution_file(user)). 2889
2892
2893
2894
2895lws:- listing(ocl:[method,
2896operator,implied_invariant,atomic_invariants,inconsistent_constraint,predicates,objects,substate_classes,sorts,domain_name,planner_task_slow,planner_task,
2897htn_task,tp_node,tn,current_num,goal_related,goal_related_search,solved_node,closed_node,tp_goal,final_node,node,op_score,gsstates,gsubstate_classes,related_op,
2898objectsOfSort,atomic_invariantsC,objectsD,objectsC,gOperator,operatorC,opParent,methodC,is_of_sort,is_of_primitive_sort,temp_assertIndivConds]).
2899
2900lws(F):-tell(F),lws,told.
2901
2902:-export(rr/0). 2903:-export(rr1/0). 2904rr:- test_ocl('domains_ocl/chameleonWorld.ocl').
2905rr1:- test_ocl('domains_ocl/translog.ocl').
2906
2907:- include(translog4). 2908
2909:- fixup_exports. 2910
logicmoo_hyhtn
% Provides a prolog database env % % % % Logicmoo Project PrologMUD: A MUD server written in Prolog % Maintainer: Douglas Miles % Denton, TX 2005, 2010, 2014 % Dec 13, 2035 % */