12:-module(logicmoo_hyhtn_works,[]). 13
14:-multifile(user:push_env_ctx/0). 15:-dynamic(user:push_env_ctx/0). 16
21
22:- style_check(-singleton). 23:- use_module(library(prolog_pack)). 24:- if( \+ prolog_pack:current_pack(logicmoo_planners)). 25:- dynamic user:file_search_path/2. 26:- multifile user:file_search_path/2. 27:- prolog_load_context(directory,Dir),
28 DirFor = planner,
29 (( \+ user:file_search_path(DirFor,Dir)) ->asserta(user:file_search_path(DirFor,Dir));true),
30 absolute_file_name('../../../../',Y,[relative_to(Dir),file_type(directory)]),
31 (( \+ user:file_search_path(pack,Y)) ->asserta(user:file_search_path(pack,Y));true). 32:- attach_packs. 33:- initialization(attach_packs). 34:- endif. 36:- ensure_loaded(library(logicmoo_utils)). 37
38:- kb_shared(baseKB:mpred_prop/3). 39
40:- ensure_loaded(library(logicmoo_util_structs)). 41:- ensure_loaded(library(logicmoo_util_bb_env)). 42:- prolog_load_context(file,File),ain(user:env_source_file(File)). 43
44:-op(500,fx,env_call). 67 70:-use_module(library(system)). 72:- dynamic op_num/1, my_stats/1.
73:- dynamic node/7,final_node/1. 74:- dynamic methodC/7, opParent/6,operatorC/5,gOperator/3. 75:- dynamic tp_goal/3,tp_node/6,closed_node/6,solved_node/5. 76:- dynamic goal_related/4. 77:- dynamic tn/6. 78:- dynamic opCounter/1, temp/1. 79:- dynamic objectsC/2,atomic_invariantsC/1. 80:- dynamic objectsOfSort/2. 82:- dynamic kill_file/1,solution_file/1. 87:- op(100,xfy,'=>'). 100
101op_num(0).
102my_stats(0).
103
104startOCL(Goal,Init):-
105 dmsg('startOCL-PLANNER-TASK'(Goal)),
106 planner_interface(Goal,Init,Sol,_,TNLst),
107 solution_file(F),
108 tell(F),
109 write('TASK '),write(Id),nl,
110 write('SOLUTION'),nl,
111 display_sol(Sol),
112 write('END FILE'),nl,nl,
113 reverse(TNLst,TNForward),
114 display_details(TNForward),
115 write('END PLANNER RESULT'),
116 told,(clean).
117
118solve(Id) :-
119 htn_task(Id,Goal,Init),
120 planner_interface(Goal,Init,Sol,_,TNLst),
121 solution_file(F),
122 tell(F),
123 write('TASK '),write(Id),nl,
124 write('SOLUTION'),nl,
125 display_sol(Sol),
126 write('END FILE'),nl,nl,
127 reverse(TNLst,TNForward),
128 display_details(TNForward),
129 write('END PLANNER RESULT'),
130 told,
131 clean.
132
133solve(Id) :-
134 planner_task(Id,Goal,Init),
135 planner_interface(Goal,Init,Sol,_,TNLst),
136 solution_file(F),
137 tell(F),
138 write('TASK '),write(Id),nl,
139 write('SOLUTION'),nl,
140 display_sol(Sol),
141 write('END FILE'),nl,nl,
142 reverse(TNLst,TNForward),
143 display_details(TNForward),
144 write('END PLANNER RESULT'),
145 told,
146 clean.
147
148display_sol([]).
149display_sol([H|T]) :-
150 write(H),
151 nl,
152 display_sol(T).
153
154display_details([]).
155display_details([tn(TN,Name,Pre,Post,Temp,Dec)|Rest]) :-
157 nl,write('BEGIN METHOD'),nl,write(TN),write(';'),
158 nl,write('Name:'),write(Name),write(';'),
159 nl,write('Pre-condition:'),write(Pre),write(';'),
162 nl,write('Temporal Constraints:'),write(Temp),write(';'),
163 nl,write('Decomposition:'),write(Dec),write(';'),
164 nl,
165 display_details(Rest).
166
167
168clean:-
169 retractall(op_num(_)),
170 retractall(my_stats(_)),
171 retractall(current_num(_,_)),
172 retractall(node(_,_,_,_,_)),
173 retractall(final_node(_)),
174 retractall(tn(_,_,_,_,_,_)),
175 retractall(methodC(_,_,_,_,_,_,_)),
176 retractall(operatorC(_,_,_,_,_)),
177 retractall(gOperator(_,_,_)),
178 retractall(goal_related(_,_,_)),
179 retractall(goal_related_search(_)),
180 retractall(opCounter(_)),
181 retractall(opParent(_,_,_,_,_,_)),
182 retractall(temp(_)),
183 retractall(objectsOfSort(_,_)),
184 retractall(related_op(_)),
185 retractall(op_score(_,_)),
186 retractall(objectsC(_,_)),
187 retractall(solved_node(_,_)),
188 retractall(tp_node(_,_,_,_,_,_)),
189 retractall(closed_node(_,_,_,_,_,_)),
190 retractall(score_list(_)),
191 retractall(atomic_invariantsC(_)),
192 retractall(gsubstate_classes(_,_,_)),
193 retractall(is_of_sort(_,_)),
194 retractall(is_of_primitive_sort(_,_)),
195 retractall(objectsD(_,_)),
196 assert(op_num(0)),
197 assert(my_stats(0)).
198
199planner_interface(G,I, SOLN,OPNUM,TNList):-
200 change_obj_list(I),
201 ground_op,
202 assert_is_of_sort,
203 change_op_representation,
204 prim_substate_class,
205 retract(op_num(_)),
206 assert(op_num(0)),
207 statistics(runtime,[_,Time]),
208 (retract(my_stats(_)) ; true),
209 assert(my_stats(Time)),
210 make_problem_into_node(I, G, Node),
211 assert(Node),
212 start_solve(SOLN,OPNUM,TNList).
213planner_interface(G,I, SOLN,OPNUM,TNList):-
214 tell(user),nl,write('failure in initial node'),!.
215
219
220getN_name(node(Name, _, _, _,_), Name).
221getN_pre(node(_,Pre, _, _, _), Pre).
222getN_decomp(node(_, _, Decomp,_,_), Decomp).
223getH_temp(node(_, _, _,Temps, _), Temps).
224getN_statics(node(_,_,_,_,Statics), Statics).
225
227start_solve(SOLN,OPNUM,_):-
228 kill_file(Kill),
229 file_exists(Kill).
231
232start_solve(Sol,OPNUM,TNList):-
233 retract(final_node(Node)),
234 retractall(current_num(_,_)),
235 getN_statics(Node,Statics),
236 statics_consist(Statics),
237 extract_solution(Node,Sol,SIZE,TNList),
238 statistics(runtime,[_,CP]),
239 TIM is CP/1000, tell(user),
240 retract(op_num(OPNUM)),
241 assert(op_num(0)),
242 nl, nl, write('CPU Time = '),write(CP),nl,
243 write('TIME TAKEN = '),write(TIM),
244 write(' SECONDS'),nl,
245 write('Solution SIZE = '),write(SIZE),nl,
246 write('Operator Used = '),write(OPNUM),nl,
247 write('***************************************'),
248 assert(time_taken(CP)),
249 assert(soln_size(SIZE)),
250 retractall(tn(_,_,_,_,_,_)),
251 !.
252start_solve(Sol,OPNUM,TNList):-
253 select_node(Node),
255 256 process_node(Node),
257 start_solve(Sol,OPNUM,TNList).
258start_solve(Sol,OPNUM,TNList):-
259 tell(user), write('+++ task FAILED +++'),
260 clean.
261
262:- discontiguous expand_decomp/8. 263:- discontiguous expand_node1/8. 264
266
268process_node(Node) :-
269 getN_name(Node, Name),
270 getN_pre(Node, Pre),
271 getN_decomp(Node, Dec),
272 getH_temp(Node, Temps),
273 getN_statics(Node, Statics),
274 expand_decomp(Dec,Pre,Post,Temps,Temp1,Statics,Statics1,Dec1),
275 statics_consist(Statics),
276 assert_node(Name,Pre,Dec1,Temp1,Statics1).
277
278assert_node(Name,Pre,Decomp,Temp,Statics):-
279 all_HP_expanded(Decomp),
280 assert(final_node(node(Name,Pre,Decomp,Temp,Statics))),!.
281assert_node(Name,Pre,Dec,Temp,Statics):-
282 gensym(root,SYM),
283 assert(node(SYM,Pre,Dec,Temp,Statics)),!.
284
285all_HP_expanded([]):-!.
286all_HP_expanded([step(HPid,Name,_,_,exp(TN))|THPS]):-
287 all_HP_expanded(THPS),!.
288
294expand_decomp([],Post,Post,Temp,Temp,Statics,Statics,[]):-!.
295
297expand_decomp([step(HPid,Name,Pre0,Post0,exp(TN))|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,[step(HPid,Name,Pre,State,exp(TN))|Decomp1]):-
298 state_achieved(Pre0,Pre),
299 state_change(Pre,Pre0,Post0,State),
300 statics_consist(Statics),
301 expand_decomp(Decomp,State,Post,Temp,Temp1,Statics,Statics1,Decomp1),!.
302
304expand_decomp([step(HPid,ACH,Pre0,Post0,unexp)|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,Decomp1):-
305 ACH=..[achieve|_],
306 statics_consist(Statics),
307 expand_decomp_ach([step(HPid,ACH,Pre,Post0,unexp)|Decomp],Pre,Post,
308 Temp,Temp1,Statics,Statics1,Decomp1),!.
309
311expand_decomp([step(HPid,Name,undefd,undefd,unexp)|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,[step(HPid,Name,Pre,State,exp(Name))|Decomp1]):-
312 apply_op(Name,HPid,Name,Pre,undefd,State,Statics,Statics2),
313 expand_decomp(Decomp,State,Post,Temp,Temp1,Statics2,Statics1,Decomp1),!.
314
316apply_op(Name,HPid,Name,Pre,Post,State,Statics,Statics1):-
317 operatorC(Name,Pre0,Post0,Cond,Statics0),
318 statics_append(Statics0,Statics,Statics2),
319 state_achieved(Pre,Pre0,Statics2),
320 state_change(Pre,Pre0,Post0,State2),
321 cond_state_change(State2,Cond,State),
322 all_achieved(Post,Statics2,State),
323 remove_unneed(Statics2,[],Statics1),
324 statics_consist_instance(Statics1),
325 statics_consist_instance(Statics0),
326 retract(op_num(N)),
327 N1 is N+1,
328 assert(op_num(N1)),!.
329
332expand_decomp([step(HPid,Name,undefd,undefd,unexp)|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,[step(HPid,Name,Pre,State,exp(TN))|Decomp1]):-
333 apply_method(TN,HPid,Name,Pre,undefd,State,Statics,Statics2),
334 expand_decomp(Decomp,State,Post,Temp,Temp1,Statics2,Statics1,Decomp1),!.
335
337apply_method(TN,HPid,Name,Pre,Post,State,Statics,Statics1):-
338 methodC(Name,Pre0,Post0,Statics0,Temp0,achieve(ACH0),Dec0),
339 statics_append(Statics0,Statics,Statics2),
340 all_achieved(Pre0,Statics2,Pre),
341 remove_unneed(Statics2,[],Statics21),
342 make_dec1(HPid,Pre,ACH0,Statics21,Temp0,Dec0,Temp2,Dec2),
343 expand_decomp(Dec2,Pre,State,Temp2,Temp1,Statics21,Statics1,Dec1),
344 all_achieved(Post,Statics1,State),
345 retract(op_num(N)),
346 N1 is N+1,
347 assert(op_num(N1)),
348 make_tn(TN,Name,Pre,State,Temp1,Dec1),!.
349
351expand_decomp([step(HP,N,Pre0,Post0,unexp)|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,Decomp1):-
352 get_another_step(step(HP2,N2,Pre2,Post2,Exp),Pre,Statics,
353 HP,Temp,Temp2,Decomp,Decomp2),
354 expand_decomp([step(HP2,N2,Pre2,Post2,Exp),step(HP,N,Pre0,Post0,unexp)|Decomp2],
355 Pre,Post,Temp2,Temp1,Statics,Statics1,Decomp1).
356
359
361get_another_step(A,Pre,Statics,HP,Temp,Temp1,[],Dec2):-fail.
362get_another_step(step(HP2,Name2,Pre2,Post2,Exp),Pre,Statics,HP,Temp,[before(HP2,HP)|Temp],Dec,Dec2):-
363 member(step(HP2,Name2,Pre2,Post2,Exp),Dec),
364 not(necessarily_before(HP,HP2, Temp)),
365 state_achieved(Pre2,Pre,Statics),
366 list_take(Dec,[step(HP2,Name2,Pre2,Post2,Exp)],Dec2).
367
371expand_decomp_ach([step(HPid,ACH,Pre,Post0,unexp)|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,Decomp1):-
372 state_achieved(Post0,Pre),
375 remove_temp(Temp,HPid,Temp,Temp2),
376 expand_decomp(Decomp,Pre,Post,Temp2,Temp1,Statics,Statics1,Decomp1),!.
377
379expand_decomp_ach([step(HPid,ACH,Pre,Post0,unexp)|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,[step(HPid,ACH,Pre,Post0,exp(TN))|Decomp1]):-
380 expand_ach_goal(HPid,TN,ACH,Pre,Post0,State,Statics,Statics2),
381 expand_decomp(Decomp,State,Post,Temp,Temp1,Statics2,Statics1,Decomp1),!.
382
384expand_decomp_ach([step(HPid,ACH,Pre,Post0,unexp)|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,[step(HPid,ACH,Pre,Post0,exp(TN))|Decomp1]):-
385 get_another_step(step(HP2,N2,Pre2,Post2,Exp),Pre,Statics,
386 HP,Temp,Temp2,Decomp,Decomp2),
387 expand_decomp([step(HP2,N2,Pre2,Post2,Exp),step(HPid,ACH,Pre,Post0,unexp)|Decomp2], Pre,Post,Temp2,Temp1,Statics,Statics1,Decomp1).
388
391
394expand_ach_goal(HPid,TN,ACH,Pre,Post,State,Statics,Statics1):-
395 direct_expand_ach_goal(HPid,TN,ACH,Pre,Post,State,Statics,Statics1),!.
396
400expand_ach_goal(HPid,TN,ACH,Pre,Post,State,Statics,Statics1):-
401 make_tpnodes(Pre,Post,Statics),
403 fwsearch(TN,State),
406 clean_temp_nodes.
407
410
413direct_expand_ach_goal(HPid,TN,ACH,Pre,Post,State,Statics,Statics):-
414 apply_tn(TN,HPid,ACH,Pre,Post,State,Statics,Statics).
416direct_expand_ach_goal(HPid,OP,ACH,Pre,Post,State,Statics,Statics1):-
417 dir_apply_op(OP,HPid,ACH,Pre,Post,State,Statics,Statics1).
420direct_expand_ach_goal(HPid,TN,ACH,Pre,Post,State,Statics,Statics1):-
421 dir_apply_method(TN,HPid,ACH,Pre,Post,State,Statics,Statics1),!.
423
425apply_tn(Tn0,HPid,ACH,Pre,Post,State,Statics,Statics):-
426 tn(Tn0,Name,Pre0,Post0,Temp0,Decomp0),
427 state_achieved(Pre0,Pre),
428 state_change(Pre,Pre0,Post0,State),
429 all_achieved(Post,Statics,State),
431 retract(op_num(N)),
432 N1 is N+1,
433 assert(op_num(N1)),!.
435
437dir_apply_op(Name,HPid,ACH,Pre,Goal,State,Statics,Statics1):-
439 make_se_primitive(Goal,Post),
440 operatorC(Name,Pre0,Post0,Cond,Statics0),
441 statics_append(Statics0,Statics,Statics2),
442 state_related(Post0,Cond,Post),
444 state_change(Pre,Pre0,Post0,State2),
445 cond_state_change(State2,Cond,State),
446 all_achieved(Post,Statics2,State),
447 remove_unneed(Statics2,[],Statics1),
448 statics_consist(Statics1),
451 retract(op_num(N)),
452 N1 is N+1,
453 assert(op_num(N1)),!.
454
456dir_apply_method(TN,HPid,ACH,Pre,Goal,State,Statics,Statics1):-
458 make_se_primitive(Goal,Post),
459 methodC(Name,Pre0,Post0,Statics0,Temp0,achieve(ACH0),Dec0),
460 statics_append(Statics0,Statics,Statics2),
461 state_related(Post0,Post),
463 state_change(Pre,Pre0,Post0,State2),
465 may_achieved(Post,Statics2,State2),
467 make_dec1(HPid,Pre,ACH0,Statics2,Temp0,Dec0,Temp2,Dec2),
468 expand_decomp(Dec2,Pre,State,Temp2,Temp1,Statics2,Statics1,Dec1),
469 all_achieved(Post,Statics1,State),
472 retract(op_num(N)),
473 N1 is N+1,
474 assert(op_num(N1)),
475 make_tn(TN,Name,Pre,State,Temp1,Dec1),!.
476
478make_dec1(HPid,Pre,ACH,Statics,Temp,Dec,Temp1,Dec1):-
479 var(HPid),
480 gensym(hp,HPid),
481 make_dec1(HPid,Pre,ACH,Statics,Temp,Dec,Temp1,Dec1),!.
482make_dec1(HPid,Pre,ACH,Statics,Temp,Dec,Temp1,Dec1):-
483 all_achieved(ACH,Statics,Pre),
484 make_dec01(HPid,1,Dec,Dec1),
485 change_temp(HPid,Temp,[],Temp1),!.
486make_dec1(HPid,Pre,ACH,Statics,Temp,Dec,[before(STID0,STID1)|Temp1],[step(STID0,achieve(ACH),Pre,ACH,unexp)|Dec1]):-
487 gensym_num(HPid,0,STID0),
488 gensym_num(HPid,1,STID1),
489 make_dec01(HPid,1,Dec,Dec1),
490 change_temp(HPid,Temp,[],Temp1),!.
491
492make_dec01(HPid,_,[],[]):-!.
493make_dec01(HPid,Num,[HDec|TDec],[step(STID,HDec,undefd,undefd,unexp)|TDec0]):-
494 operatorC(HDec,_,_,_,_),
495 gensym_num(HPid,Num,STID),
496 Num1 is Num + 1,
497 make_dec01(HPid,Num1,TDec,TDec0).
498make_dec01(HPid,Num,[HDec|TDec],[step(STID,HDec,undefd,undefd,unexp)|TDec0]):-
499 methodC(HDec,_,_,_,_,_,_),
500 gensym_num(HPid,Num,STID),
501 Num1 is Num + 1,
502 make_dec01(HPid,Num1,TDec,TDec0).
503
504change_temp(HPid,[],Temp2,Temp2):-!.
505change_temp(HPid,[before(N1,N2)|Temp],Temp2,[before(ST1,ST2)|Temp0]):-
506 gensym_num(HPid,N1,ST1),
507 gensym_num(HPid,N2,ST2),
508 change_temp(HPid,Temp,Temp2,Temp0),!.
511
514make_tpnodes(Pre,Post, Statics):-
515 opCounter(Num),
516 Num>=1000,
517 retractall(tp_goal(_,_,_)),
518 retractall(related_op(_,_)),
519 assert(tp_goal(Pre,Post,Statics)),
520 assert(tp_node(init,Pre,Statics,from(init),0,[])),!.
521
522make_tpnodes(Pre,Post, Statics):-
523 retractall(tp_goal(_,_,_)),
524 retractall(related_op(_,_)),
525 assert(tp_goal(Pre,Post,Statics)),
526 assert_goal_related_init(Pre,Post,Statics),
527 assert(op_score(goal,0)),
528 find_all_related_goals(Pre,Statics,1,N),
530 assert(tp_node(init,Pre,Statics,from(init),0,[])),!.
531
534fwsearch(TN,State):-
535 retract(solved_node(_,step(HP,Name,Pre,State,exp(TN)))).
536fwsearch(TN,State):-
537 select_tnode(tp_node(TP,Pre,Statics,from(PR),Score,Steps)),
538 assert(closed_node(TP,Pre,Statics,from(PR),Score,Steps)),
539 expand_node(TP,OP,Statics,Statics1,Pre,Post,from(PR),Steps,Steps1),
540 assert_tnode(TP,OP,PR,Score1,Post,Statics1,Steps1),
541 solved_node(_,_), 542 fwsearch(TN,State).
543fwsearch(TN,State):-
544 tp_node(TP,Pre,Statics,from(PR),Score,Steps),
545 fwsearch(TN,State).
546
547clean_temp_nodes:-
548 retractall(tp_goal(_,_)),
549 retractall(goal_related(_,_,_)),
550 retractall(goal_related_search(_)),
551 retractall(related_op(_)),
552 retractall(op_score(_,_)),
553 retractall(score_list(_)),
554 retractall(solved_node(_,_)),
555 retractall(current_num(tp,_)),
556 retractall(tp_node(_,_,_,_,_,_)),
557 retractall(closed_node(_,_,_,_,_,_)),!.
558
561expand_node(TP,done,Statics,Statics,Pre,Pre,from(PR),List,List):-
562 tp_goal(_,Goal,_),
563 state_achieved(Goal,Pre,Statics),!.
564expand_node(TP,TN,Statics,Statics1,Pre,State,from(PR),List,List1):-
565 expand_node1(TN,Statics,Statics1,Pre,State,from(PR),List,List1).
566
568expand_node1(TN,Statics,Statics1,Pre,State,from(PR),List,List1):-
569 tp_goal(_,Goal,_),
570 direct_expand(HP,TN,achieve(Goal),Pre,Goal,State,Statics,Statics1),
572 append_dcut(List,[step(HP,achieve(Goal),Pre,State,exp(TN))],List1),!.
576direct_expand(HPid,TN,ACH,Pre,Post,State,Statics,Statics1):-
577 dir_apply_method(TN,HPid,ACH,Pre,Post,State,Statics,Statics1),!.
578
580expand_node1(ID,Statics,Statics,Pre,State,from(PR),List,List1):-
581 find_related_op(Pre,[],OPls),
582 member(ID,OPls),
583 gOperator(ID,_,OP),
584 apply_ground_op(OP,Pre,State,List,List1).
585expand_node1(OP,Statics,Statics1,Pre,State,from(PR),List,List1):-
586 not(goal_related(_,_,_)),
587 operatorC(OP,Pre0,Post0,Cond,ST),
588 apply_unground_op(OP,Pre0,Post0,Cond,ST,Statics,Statics1,Pre,State,List,List1).
589
590apply_ground_op(operator(OP,Prev,Nec,Cond),Pre,State,List,List1):-
591 state_achieved(Prev,Pre),
592 nec_state_change(Pre,Nec,State2),
593 cond_state_change(State2,Cond,State),
594 gensym(hp,HP),
595 append_dcut(List,[step(HP,OP,Pre,State,exp(OP))],List1),
596 retract(op_num(N)),
597 N1 is N+1,
598 assert(op_num(N1)),!.
599
600apply_unground_op(OP,Pre0,Post0,Cond,ST,Statics,Statics1,Pre,State,List,List1):-
601 statics_append(ST,Statics,Statics2),
602 state_achieved(Pre0,Pre,Statics2),
603 state_change(Pre,Pre0,Post0,State2),
604 cond_state_change(State2,Cond,State),
605 statics_consist_instance(ST),
606 remove_unneed(Statics2,[],Statics1),
607 gensym(hp,HP),
608 append_dcut(List,[step(HP,OP,Pre,State,exp(OP))],List1),
609 retract(op_num(N)),
610 N1 is N+1,
611 assert(op_num(N1)).
612
613find_related_op([],Ops1,Ops):-
614 remove_dup(Ops1,[],Ops),!.
615find_related_op([Head|Pre],List,Ops):-
616 setof(OPls,Head^Level^goal_related(Head,OPls,Level),OPs0),
617 flatten(OPs0,[],OPs1),
618 append_dcut(List,OPs1,List1),
619 find_related_op(Pre,List1,Ops),!.
620find_related_op([Head|Pre],List,Ops):-
621 find_related_op(Pre,List,Ops),!.
622
624select_tnode(tp_node(TPid,Pre,Statics,Parents,Score,Dec)) :-
625 retractall(score_list(LS)),
626 assert(score_list([])),
627 lowest_score(Score),
628 retract(tp_node(TPid,Pre,Statics,Parents,Score,Dec)),!.
630
632lowest_score(LScore):-
633 tp_node(HPid,Pre,Statics,Parents,Score,Dec),
634 retract(score_list(LS)),
635 assert(score_list([Score|LS])),
636 fail.
637lowest_score(LScore):-
638 retract(score_list(D)),
639 sort(D,[LScore|SD]).
640
643assert_tnode(TP,OP,PR,Score,Post,Statics,[]):-!.
644assert_tnode(TP,OP,PR,Score,Post,Statics,Steps):-
645 tp_goal(Pre,Goal,Statics1),
646 state_achieved(Goal,Post,Statics),
647 combine_exp_steps(Post,Steps,OneStep),
648 assert(solved_node(Statics,OneStep)),!.
649assert_tnode(TP,OP,PR,Score,Post,Statics,Steps):-
650 existing_node(Post,Statics),!.
651assert_tnode(TP,OP,PR,Score,Post,Statics,Steps):-
652 get_score(PR,Post,Steps,Score),
655 gensym(tp,TP1),
658 assert(tp_node(TP1,Post,Statics,from(TP),Score,Steps)),!.
659
660combine_exp_steps(Post,Steps,step(HP,achieve(Goal),Pre,Post,exp(TN))):-
661 tp_goal(Pre,Goal,Statics),
662 get_action_list(Steps,[],ACTls),
663 make_temp(ACTls,[],Temp),
664 gensym(hp,HP),
665 make_tn(TN,achieve(Goal),Pre,Post,Temp,Steps),!.
666
668get_action_list([],ACTls,ACTls):-!.
669get_action_list([step(HP,_,_,_,_)|Steps],List,ACTls):-
670 append_cut(List,[HP],List1),
671 get_action_list(Steps,List1,ACTls),!.
672
673make_temp([HP|[]],Temp,Temp):-!.
674make_temp([HP1|[HP2|Rest]],List,Temp):-
675 append_cut(List,[before(HP1,HP2)],List1),
676 make_temp([HP2|Rest],List,Temp),!.
677
678existing_node(Post,Statics):-
679 tp_node(_,Post,_,_,_,_).
680existing_node(Post,Statics):-
681 closed_node(_,Post,_,_,_,_).
683
684assert_goal_related_init(Pre,[],Statics):-!.
687assert_goal_related_init(Pre,[se(Sort,Obj,SE)|Post],Statics):-
688 ground(Obj),
689 is_of_primitive_sort(Obj,SortP),
690 assert(goal_related(se(SortP,Obj,SE),[],0)),
691 assert_goal_related_init(Pre,Post,Statics),!.
692assert_goal_related_init(Pre,[se(Sort,Obj,SE)|Post],Statics):-
693 assert_related_goals_varible(Sort,Obj,SE,goal,0),
694 assert_goal_related_init(Pre,Post,Statics),!.
695
698find_all_related_goals(Pre,Statics,N,N):-
699 get_all_state(States),
700 all_found(States,Pre,Statics),
701 assert(goal_related_search(succ)),
702 find_all_related_goals_final(Statics,N),!.
703find_all_related_goals(Pre,Statics,I,N):-
704 I1 is I-1,
705 goal_related(_,_,I1),
706 find_related_goal(Statics,I1,I),
707 I2 is I+1,
708 find_all_related_goals(Pre,Statics,I2,N),!.
709find_all_related_goals(Pre,Statics,N,N):-
710 not(goal_related(_,_,N)),
711 assert(goal_related_search(fail)),
712 write('related goal search failed'),
713 retractall(goal_related(_,_,_)),!.
714 715 716
717
720find_all_related_goals_final(Statics,N):-
721 N1 is N-1,
722 goal_related(Pre,_,N1),
723 find_related_goal(Statics,N1,N),!.
724find_all_related_goals_final(Statics,N):-!.
725
727get_all_state(States):-
728 setof(Goal, Statics^Level^OP^goal_related(Goal,OP,Level),States11),
729 put_one_obj_together(States11,[],States),!.
730
731put_one_obj_together([],States,States):-!.
732put_one_obj_together([se(Sort,Obj,ST)|States1],List,States):-
733 put_one_obj_together1(se(Sort,Obj,ST),List,List1),
734 put_one_obj_together(States1,List1,States),!.
735
736put_one_obj_together1(se(Sort,Obj,ST),[],[se(Sort,Obj,ST)]):-!.
737put_one_obj_together1(se(Sort,Obj,ST),[se(Sort,Obj,ST00)|List],[se(Sort,Obj,ST1)|List]):-
738 set_append_e(ST,ST00,ST1),!.
739put_one_obj_together1(se(Sort,Obj,ST),[se(Sort1,Obj1,ST1)|List],[se(Sort1,Obj1,ST1)|List1]):-
740 Obj\==Obj1,
741 put_one_obj_together1(se(Sort,Obj,ST),List,List1),!.
742
744all_found([],States,Statics):-!.
745all_found([se(Sort,Obj,ST)|States],Pre,Statics):-
746 member(se(Sort,Obj,SPre),Pre),
747 subtract(SPre,ST,Diff),
748 isemptylist(Diff),
749 all_found(States,Pre,Statics),!.
750
753find_related_goal(Statics,I1,I):-
754 gOperator(OPID,ID,operator(Name,Prev,Nec,Cond)),
755 find_related_goal_nec(OPID,Name,Prev,Nec,Statics,I1,I),
756 find_related_goal_cond(OPID,Name,Prev,Nec,Cond,Statics,I1,I),
757 fail.
758find_related_goal(Statics,I1,I).
759
760find_related_goal_nec(ID,Name,Prev,Nec,Statics,I1,I):-
761 goal_related(se(Sort,Obj,SE),Ops,I1),
762 member(sc(Sort,Obj,Lhs=>Rhs),Nec),
763 state_match(Sort,Obj,SE,Rhs),
764 statics_consist(Statics),
766 assert_goal_related(Prev,Nec,ID,I).
767find_related_goal_cond(ID,Name,Prev,Nec,[],Statics,I1,I):-
768 !.
769find_related_goal_cond(ID,Name,Prev,Nec,Cond,Statics,I1,I):-
770 goal_related(se(Sort,Obj,SE),Ops,I1),
771 member(sc(Sort0,Obj,LHS=>RHS),Cond),
772 is_of_sort(Obj,Sort0),
773 is_of_sort(Obj,Sort), 774 filterInvars(LHS,LInVars,LIsOfSorts,LNEs,FLHS),
775 filterInvars(RHS,RInVars,RIsOfSorts,RNEs,FRHS),
776 can_achieve_g([se(Sort,Obj,FRHS)],[se(Sort,Obj,SE)],Statics),
777 statics_consist(Statics),
778 checkInVars(LInVars),
779 checkInVars(RInVars),
780 checkIsOfSorts(LIsOfSorts),
781 checkIsOfSorts(RIsOfSorts),
782 obeysNEs(LNEs),
783 obeysNEs(RNEs),
785 assert_goal_related(Prev,[sc(Sort,Obj,FLHS=>FRHS)|Nec],ID,I).
786
788filterInvars([],[],[],[],[]):-!.
789filterInvars([is_of_sort(A,B)|State],InVars,[is_of_sort(A,B)|IsOfSorts],NEs,FState):-
790 !,
791 filterInvars(State,InVars,IsOfSorts,NEs,FState).
792filterInvars([ne(A,B)|State],InVars,IsOfSorts,[ne(A,B)|NEs],FState):-
793 !,
794 filterInvars(State,InVars,IsOfSorts,NEs,FState).
795filterInvars([is_of_primitive_sort(A,B)|State],InVars,[is_of_sort(A,B)|IsOfSorts],NEs,FState):-
796 !,
797 filterInvars(State,InVars,IsOfSorts,NEs,FState).
798filterInvars([Pred|State],[Pred|InVars],IsOfSorts,NEs,FState):-
799 functor(Pred,FF,NN),
800 functor(Pred1,FF,NN),
801 atomic_invariantsC(Atom),
802 member_cut(Pred1,Atom),!,
803 filterInvars(State,InVars,IsOfSorts,NEs,FState).
804filterInvars([Pred|State],InVars,IsOfSorts,NEs,[Pred|FState]):-
805 filterInvars(State,InVars,IsOfSorts,NEs,FState).
806
808filterNes([],[],[]):-!.
809filterNes([ne(A,B)|State],[ne(A,B)|NEs],FState):-
810 !,
811 filterNes(State,NEs,FState).
812filterNes([Pred|State],NEs,[Pred|FState]):-
813 filterNes(State,NEs,FState).
814
815assert_related_op(OP,I):-
816 related_op(OP,_),!.
817assert_related_op(OP,I):-
818 asserta(related_op(OP,I)),!.
819
821can_achieve_g([],State2,Statics):-!.
822can_achieve_g(State1,State2,Statics):-
823 can_achieve_g(State1,State2),
824 statics_consist(Statics).
825
826can_achieve_g([se(Sort,Obj,ST1)|State1],[se(Sort,Obj,ST2)]):-
827 state_match(Sort,Obj,ST2,ST1).
828can_achieve_g([Head|State1],State2):-
829 can_achieve_g(State1,State2).
830
832assert_goal_related(Prev,Nec,OP,I):-
833 assert_goal_related1(Prev,OP,I),!,
834 assert_goal_related1(Nec,OP,I).
835
836assert_goal_related1([],Op,I):-!.
837assert_goal_related1([se(Sort,Obj,SE)|Prev],Op,I):-
838 assert_goal_related2(se(Sort,Obj,SE),Op,I),
839 assert_goal_related1(Prev,Op,I),!.
840assert_goal_related1([sc(Sort,Obj,LH=>RH)|Nec],Op,I):-
841 ground(Obj), 842 is_of_primitive_sort(Obj,PSort),!,
843 assert_goal_related2(se(PSort,Obj,LH),Op,I),
844 assert_goal_related1(Nec,Op,I).
845assert_goal_related1([sc(Sort,Obj,LH=>RH)|Nec],Op,I):-
846 var(Obj),
847 assert_related_goals_varible(Sort,Obj,LH,Op,I),
848 assert_goal_related1(Nec,Op,I).
849
850assert_goal_related2(se(Sort,Obj,SE),goal,I):-
851 assert(goal_related(se(Sort,Obj,SE),[],I)),!.
852assert_goal_related2(se(Sort,Obj,SE),Op,I):-
853 goal_related(se(Sort,Obj,SE1),Ops,I),
854 not(is_diff(SE,SE1)),
855 retract(goal_related(se(Sort,Obj,SE),Ops,I)),
856 assert(goal_related(se(Sort,Obj,SE),[Op|Ops],I)),!.
857assert_goal_related2(se(Sort,Obj,SE),Op,I):-
858 assert(goal_related(se(Sort,Obj,SE),[Op],I)),!.
859
860assert_related_goals_varible(Sort,Obj,SE,Op,I):-
861 find_prim_sort(Sort,PSorts),
862 member(Sort1,PSorts),
863 assert_goal_related2(se(Sort1,Obj,SE),Op,I),
864 fail.
865assert_related_goals_varible(Sort,Obj,SE,Op,I).
866
868assert_op_score(OP,OPB):-
869 op_score(OP,_),!.
870assert_op_score(OP,OPB):-
871 op_score(OPB,I),
872 I1 is I+1,
873 assert(op_score(OP,I1)),!.
874
875get_score(PR,Post,Steps,Score):-
876 tp_goal(Pre,Goal,Statics),
877 get_distance(Pre,Post,Goal,0,Dis), 879 get_length(PR,1,Len),
883 Score is Dis+Len,!.
884
885get_distance(Pre,[],Goal,Dis,Dis):-!.
886get_distance(Pre,[se(Sort,Obj,SE)|Post],Goal,Dis1,Dis):-
887 member(se(Sort,Obj,SE0),Goal),
888 state_match(Sort,Obj,SE0,SE), 889 get_distance(Pre,Post,Goal,Dis1,Dis),!.
890get_distance(Pre,[se(Sort,Obj,SE)|Post],Goal,Dis1,Dis):-
891 goal_related(se(Sort,Obj,SE0),_,Level),
892 state_match(Sort,Obj,SE0,SE),
893 Dis2 is Dis1+Level,
894 get_distance(Pre,Post,Goal,Dis2,Dis),!.
895get_distance(Pre,[se(Sort,Obj,SE)|Post],Goal,Dis1,Dis):-
896 member(se(Sort,Obj,SE0),Pre),
897 state_match(Sort,Obj,SE,SE0), 898 Dis2 is Dis1+1,
899 get_distance(Pre,Post,Goal,Dis2,Dis),!.
900get_distance(Pre,[se(Sort,Obj,SE)|Post],Goal,Dis1,Dis):-
901 Dis2 is Dis1+100,
902 get_distance(Pre,Post,Goal,Dis2,Dis),!.
903
904get_length(init,Len,Len):-!.
905get_length(TP,Len1,Len):-
906 closed_node(TP,_,_,from(PR),_,_),
907 Len2 is Len1+1,
908 get_length(PR,Len2,Len),!.
909
910
915find_relate_state:-
916 operatorC(A,Pre,Post,Cond,ST),
917 assert_related_states(A,Pre,Post,Cond,ST),
918 fail.
919find_relate_state.
920
921assert_related_states(A,Pre,Post,Cond,ST):-
922 assert_related_states1(A,Pre,Post,ST),
923 assert_related_states2(A,Pre,Cond,ST).
926assert_related_states1(A,Pre,[],ST):-!.
928assert_related_states1(A,Pre,[se(Sort,Obj,SE)|Post],ST):-
929 u_mem_cut(se(Sort,Obj,SE),Pre),
930 assert_related_states1(A,Pre,Post,ST),!.
932assert_related_states1(A,Pre,[se(Sort,Obj,SE)|Post],ST):-
933 assert(produce(se(Sort,Obj,SE),A,Pre,ST)),
934 assert_related_states1(A,Pre,Post,ST),!.
935
938assert_related_states2(A,Pre,SC,ST):-
939 make_sc_primitive(SC,PSC),
940 assert_related_states21(A,Pre,PSC,ST).
941
942assert_related_states21(A,Pre,[],ST):-!.
943assert_related_states21(A,Pre,[sc(Sort,Obj,SE=>SS)|Trans],ST):-
944 rem_statics([se(Sort,Obj,SE)],[se(Sort,Obj,SER)],St1),
945 rem_statics([se(Sort,Obj,SS)],[se(Sort,Obj,SSR)],St2),
946 append_cut(ST,St1,ST1),
947 append_cut(ST1,St2,ST21),
948 remove_unneed(ST21,[],ST2),
949 append_cut(Pre,[se(Sort,Obj,SER)],Pre1),
950 assert(produce(se(Sort,Obj,SSR),A,Pre1,ST2)),
951 assert_related_states21(A,Pre,Trans,ST),!.
952
957remove_temp([],HP1,List,List):-!.
958remove_temp([before(HP1,HP2)|Temp],HP1,List,Temp1):-
959 remove_temp_before(List,before(HP1,HP2),List2),
960 remove_temp(Temp,HP1,List2,Temp1),!.
961remove_temp([before(HP2,HP1)|Temp],HP1,List,Temp1):-
962 remove_temp_after(List,before(HP2,HP1),List2),
963 remove_temp(Temp,HP1,List2,Temp1),!.
964remove_temp([before(HPX,HPY)|Temp],HP1,List,Temp1):-
965 remove_temp(Temp,HP1,List,Temp1),!.
966
968remove_temp_before([],before(HP1,HP2),[]):-!.
969remove_temp_before([before(HP1,HP2)|T],before(HP1,HP2),T1):-
970 remove_temp_before(T,before(HP1,HP2),T1),!.
971remove_temp_before([before(HP3,HP1)|T],before(HP1,HP2),[before(HP3,HP2)|T1]):-
972 remove_temp_before(T,before(HP1,HP2),T1),!.
973remove_temp_before([before(HPX,HPY)|T],before(HP1,HP2),[before(HPX,HPY)|T1]):-
974 remove_temp_before(T,before(HP1,HP2),T1),!.
976remove_temp_after([],before(HP1,HP2),[]):-!.
977remove_temp_after([before(HP2,HP1)|T],before(HP2,HP1),T1):-
978 remove_temp_after(T,before(HP2,HP1),T1),!.
979remove_temp_after([before(HP1,HP3)|T],before(HP2,HP1),[before(HP2,HP3)|T1]):-
980 remove_temp_after(T,before(HP2,HP1),T1),!.
981remove_temp_after([before(HPX,HPY)|T],before(HP2,HP1),[before(HPX,HPY)|T1]):-
982 remove_temp_after(T,before(HP2,HP1),T1),!.
983
984remove_dec(HPid,[],[]):-!.
985remove_dec(HPid,[step(HPid,_,_,_,_)|Dec],Dec1):-
986 remove_dec(HPid,Dec,Dec1),!.
987remove_dec(HPid,[step(A,B,C,D,F)|Dec],[step(A,B,C,D,F)|Dec1]):-
988 remove_dec(HPid,Dec,Dec1),!.
989
993state_achieved(undefd,State,Statics):-!.
994state_achieved([],State2,Statics):-!.
995state_achieved(State1,State2,Statics):-
996 state_achieved(State1,State2),
997 statics_consist(Statics).
998
999state_achieved(undefd,State):-!.
1000state_achieved([],State2).
1001state_achieved([se(Sort,Obj,ST1)|State1],State2):-
1002 member(se(Sort,Obj,ST2),State2),
1003 is_of_sort(Obj,Sort),
1004 state_match(Sort,Obj,ST1,ST2),
1005 list_take(State2,[se(Sort,Obj,ST2)],State21),
1006 state_achieved(State1,State21).
1007state_achieved([se(Sort,Obj,ST1)|State1],State2):-
1008 not(member(se(Sort,Obj,ST2),State2)),
1009 state_achieved(State1,State2),!.
1010
1014state_match(Sort,Obj,ST,ST1):-
1015 not(is_diff(ST,ST1)),!.
1020state_match(Sort,Obj,ST,ST1):-
1021 is_achieved(ST,ST1),
1022 gsubstate_classes(Sort,Obj,Substateclasses),
1023 not(in_different_states(ST,ST1,Substateclasses)),!.
1026state_match(Sort,Obj,ST,ST1):-
1027 not(is_achieved(ST,ST1)),
1028 set_append(ST,ST1,ST0),
1029 gsubstate_classes(Sort,Obj,Substateclasses),
1030 in_same_sub_states(ST0,Substateclasses),!.
1031
1033in_same_sub_states(ST0,[State|SCls]):-
1034 is_achieved(ST0,State),!.
1035in_same_sub_states(ST0, [State|SCls]):-
1036 in_same_sub_states(ST0,SCls),!.
1037
1039in_different_states(ST,ST1, [State|SCls]):-
1040 max_member(ST,Substateclasses,MSub, _),
1041 max_member(ST1,Substateclasses,MSub1, _),
1042 MSub\==MSub1,!.
1043
1044max_member(State, Stateclass, MSub, Others):-
1045 max_member1(State, Stateclass, 0, [],MSub),
1046 subtract(State,MSub,Others),!.
1047
1049max_member1(State, [], Num, MSub, MSub):-!.
1051max_member1(State, [State1|SCls], Num, MSub1, MSub):-
1052 same_items(State1,State,MSSt),
1053 length(MSSt,Len),
1054 Len > Num,
1055 max_member1(State, SCls, Len, MSSt, MSub),!.
1056max_member1(State, [State1|SCls], Num, MSub1,MSub):-
1057 max_member1(State, SCls, Num, MSub1,MSub),!.
1058
1060same_items([],List2,[]):-!.
1061same_items([X|List1],List2,[X|Same]):-
1062 member(X,List2),
1063 same_items(List1,List2,Same),!.
1064same_items([X|List1],List2,Same):-
1065 same_items(List1,List2,Same),!.
1066
1067
1069is_achieved([],_):-!.
1070is_achieved([H|T], State) :-
1071 is_statics(H),
1072 is_achieved(T,State),!.
1073is_achieved([H|T], State) :-
1074 member(H,State),
1075 is_achieved(T,State),!.
1076
1078is_statics(ne(A,B)):-!.
1079is_statics(is_of_sort(A,B)):-!.
1080is_statics(is_of_primitive_sort(A,B)):-!.
1081is_statics(Pred):-
1082 functor(Pred,FF,NN),
1083 functor(Pred1,FF,NN),
1084 atomic_invariantsC(Atom),
1085 member_cut(Pred1,Atom),!.
1086
1094state_change([],Pre0,Post0,[]):-!.
1095state_change(Pre,[],[],Pre):-!.
1096state_change([se(Sort,Obj,SPre)|Pre],Pre0,Post0,[se(Sort,Obj,STPost)|Post]):-
1097 state_achieved([se(Sort,Obj,SPre)],Pre0),
1098 state_change0(Sort,Obj,SPre,Pre0,Post0,Pre1,Post1,STPost),
1099 state_change(Pre,Pre1,Post1,Post).
1100state_change([se(Sort,Obj,SPre)|Pre],Pre0,Post0,[se(Sort,Obj,STPost)|Post]):-
1101 not(member(se(Sort,Obj,SPre0),Pre0)),
1102 state_change(Pre,Pre1,Post1,Post).
1103
1105state_change0(Sort,Obj,SPre,[],[],[],[],SPre):-!.
1106state_change0(Sort,Obj,SPre,[se(Sort,Obj,SPre0)|Pre0],[se(Sort,Obj,SPost0)|Post0],Pre0,Post0,STPost):-
1107 state_change1(SPre,SPre0,SPost0,STPost).
1108state_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):-
1109 Obj\==Obj1,
1110 state_change0(Sort,Obj,SPre,Pre0,Post0,Pre1,Post1,STPost).
1111
1112state_change1([],SPre0,SPost0,SPost0):-!.
1113state_change1(Pre,[],[],Pre):-!.
1115state_change1([Head|SPre],SPre0,SPost0,STPost):-
1116 member(Head,SPre0),
1117 not(member(Head,SPost0)),
1118 state_change1(SPre,SPre0,SPost0,STPost).
1120state_change1([Head|SPre],SPre0,SPost0,[Head|STPost]):-
1121 not(member(Head,SPre0)),
1122 not(member(Head,SPost0)),
1123 state_change1(SPre,SPre0,SPost0,STPost),!.
1126state_change1([Head|SPre],SPre0,SPost0,STPost):-
1127 member(Head,SPost0),
1128 state_change1(SPre,SPre0,SPost0,STPost).
1129
1131rough_state_change(Pre,[],[],Pre):-!.
1132rough_state_change([],_,_,[]):-!.
1133rough_state_change([se(Sort,Obj,SE)|Pre],Pre0,Post0,[se(Sort,Obj,SS0)|Post]):-
1134 member(se(Sort,Obj,SE0),Pre0),
1135 member(se(Sort,Obj,SS0),Post0),
1136 is_of_sort(Obj,Sort),
1137 state_achieved([se(Sort,Obj,SE0)],[se(Sort,Obj,SE)]),
1138 list_take(Pre0,[se(Sort,Obj,SE0)],Pre01),
1139 list_take(Post0,[se(Sort,Obj,SS0)],Post01),
1140 rough_state_change(Pre,Pre01,Post01,Post),!.
1141rough_state_change([se(Sort,Obj,SE)|Pre],Pre0,Post0,[se(Sort,Obj,SE)|Post]):-
1142 rough_state_change(Pre,Pre0,Post0,Post),!.
1143
1145state_changeG([],Pre0,Post0,[]):-!.
1146state_changeG([se(Sort,Obj,SE)|Pre],Pre0,Post0,[se(Sort,Obj,RHS)|State]):-
1147 member(se(Sort,Obj,LHS),Pre0),
1148 member(se(Sort,Obj,RHS),Post0),
1149 state_match(Sort,Obj,SE,LHS),
1150 state_changeG(Pre,Pre0,Post0,State),!.
1151state_changeG([se(Sort,Obj,SE)|Pre],Pre0,Post0,[se(Sort,Obj,SE)|State]):-
1152 not(member(se(Sort,Obj,LHS),Pre0)),
1153 state_changeG(Pre,Pre0,Post0,State),!.
1154
1155find_lower_sort(Sort,Sort,Sort):-!.
1156find_lower_sort(Sort,Sort1,Sort1):-
1157 subsorts(Sort,Sortls),
1158 member(Sort1,Sortls),!.
1159find_lower_sort(Sort,Sort1,Sort):-
1160 subsorts(Sort1,Sortls),
1161 member(Sort,Sortls),!.
1167nec_state_change([],Nec,[]):-!.
1168nec_state_change([se(Sort,Obj,SE)|Pre],Nec,[se(Sort,Obj,Post)|State]):-
1169 member(sc(Sort,Obj,Lhs=>Rhs),Nec),
1170 state_match(Sort,Obj,Lhs,SE),
1171 state_change1(SE,Lhs,Rhs,Post),
1172 nec_state_change(Pre,Nec,State),!.
1173nec_state_change([se(Sort,Obj,SE)|Pre],Nec,[se(Sort,Obj,SE)|State]):-
1174 not(member(sc(Sort,Obj,Lhs=>Rhs),Nec)),
1175 nec_state_change(Pre,Nec,State),!.
1180cond_state_change([],Cond,[]):-!.
1181cond_state_change(State,[],State):-!.
1182cond_state_change([se(Sort,Obj,SE)|Pre],Cond,[NewSS|State]):-
1183 member(sc(Sort1,Obj1,SE0=>SS0),Cond),
1185 subsorts(Sort1,Subsorts),
1186 member(Sort,Subsorts),
1187 copy_states(se(Sort1,Obj1,SE0),se(Sort,Obj,SE2)),
1188 copy_states(se(Sort1,Obj1,SS0),se(Sort,Obj,SS2)),
1190 filterInvars(SE2,LInVars,LIsOfSorts,LNEs,FSE),
1191 filterInvars(SS2,RInVars,RIsOfSorts,RNEs,FSS),
1192 state_match(Sort,Obj,SE,FSE),
1193 state_change([se(Sort,Obj,SE)],[se(Sort,Obj,FSE)],
1194 [se(Sort,Obj,FSS)],[NewSS]),
1195 checkInVars(LInVars),
1196 checkInVars(RInVars),
1197 checkIsOfSorts(LIsOfSorts),
1198 checkIsOfSorts(RIsOfSorts),
1199 obeysNEs(LNEs),
1200 obeysNEs(RNEs),
1201 cond_state_change(Pre,Cond,State),!.
1202cond_state_change([se(Sort,Obj,SE)|Pre],Cond,[se(Sort,Obj,SE)|State]):-
1203 cond_state_change(Pre,Cond,State),!.
1204
1206copy_states(se(Sort1,Obj1,SE0),se(Sort,Obj,SE2)):-
1207 copy_states1(Obj1,SE0,Obj,SE2),!.
1208copy_states1(Obj1,[],Obj,[]):-!.
1209copy_states1(Obj1,[Pred|SE0],Obj,[Pred2|SE2]):-
1210 functor(Pred,FF,NN),
1211 functor(Pred2,FF,NN),
1212 Pred=..[Name|Vars],
1213 Pred2=..[Name|Vars2],
1214 copy_pred(Obj1,Obj,Vars,Vars2),
1215 copy_states1(Obj1,SE0,Obj,SE2),!.
1216
1217copy_pred(Obj1,Obj,[],[]):-!.
1218copy_pred(Obj1,Obj,[Var|Vars],[Var2|Vars2]):-
1219 Obj1==Var,
1220 Var2=Obj,
1221 copy_pred(Obj1,Obj,Vars,Vars2),!.
1222copy_pred(Obj1,Obj,[Var|Vars],[Var|Vars2]):-
1223 copy_pred(Obj1,Obj,Vars,Vars2),!.
1226all_achieved(undefd,Statics,List2):-!.
1227all_achieved([],Statics,List2):-!.
1228all_achieved(List1,Statics,List2):-
1229 all_achieved(List1,List2),
1230 statics_consist(Statics).
1231
1232all_achieved([],List2).
1233all_achieved([se(Sort,Obj,SL)|List1],List2):-
1234 member(se(Sort1,Obj,SR),List2),
1235 is_of_sort(Obj,Sort1),
1236 is_of_sort(Obj,Sort),
1237 is_of_primitive_sort(Obj,PSort),
1238 state_match(PSort,Obj,SL,SR),
1239 all_achieved(List1,List2).
1242may_achieved(undefd,Statics,Post):-!.
1243may_achieved([],Statics,Post):-!.
1244may_achieved(Pre,Statics,Post):-
1245 may_achieved(Pre,Post),
1246 statics_consist(Statics),!.
1247may_achieved([],Post).
1248may_achieved([se(Sort,Obj,SL)|Pre],Post):-
1249 member(se(Sort1,Obj,SR),Post),
1250 is_of_sort(Obj,Sort1),
1251 is_of_sort(Obj,Sort),
1252 is_of_primitive_sort(Obj,PSort),
1253 state_may_achieved(PSort,Obj,SL,SR),
1254 may_achieved(Pre,Post),!.
1255
1257state_may_achieved(Sort,Obj,[],ST2):-!.
1258state_may_achieved(Sort,Obj,ST1,ST2):-
1259 is_achieved(ST1,ST2),!.
1263post_instant(Post0,Cond,Statics,undefd):-!.
1264post_instant(Post0,Cond,Statics,[]):-!.
1265post_instant(Post0,Cond,Statics,[se(Sort,Obj,SE)|Post]):-
1266 member(se(Sort,Obj,SE0),Post0),
1267 statics_consist(Statics).
1268post_instant(Post0,Cond,Statics,[se(Sort,Obj,SE)|Post]):-
1269 member(sc(Sort,Obj,SE1=>SS),Cond),
1270 statics_consist(Statics).
1271post_instant(Post0,Cond,Statics,[se(Sort,Obj,SE)|Post]):-
1272 member(sc(Sort0,Obj,SE1=>SS),Cond),
1273 not(objectsC(Sort0,_)),
1274 subsorts(Sort0,Sortls),
1275 not(not(member(Sort,Sortls))),
1276 statics_consist(Statics).
1277post_instant(Post0,Cond,Statics,[se(Sort,Obj,SE)|Post]):-
1278 post_instant(Post0,Cond,Statics,Post),!.
1279
1282statics_consist([]):-!.
1283statics_consist(Statics):-
1284 get_invariants(Invs),
1285 statics_consist(Invs,Statics),!.
1286statics_consist(Invs,[]):-!.
1287statics_consist(Invs,[ne(A,B)|Statics]):-
1288 not(A==B),!,
1289 statics_consist(Invs,Statics).
1290statics_consist(Invs,[is_of_sort(Obj,Sort)|Statics]):-
1291 not(not(is_of_sort(Obj,Sort))),!,
1292 statics_consist(Invs,Statics).
1293statics_consist(Invs,[is_of_primitive_sort(Obj,Sort)|Statics]):-
1294 not(not(is_of_primitive_sort(Obj,Sort))),!,
1295 statics_consist(Invs,Statics).
1296statics_consist(Invs,[Pred|Statics]):-
1297 pred_member(Pred,Invs),!,
1298 statics_consist(Invs,Statics).
1299
1301statics_consist_instance([]):-!.
1302statics_consist_instance(Statics):-
1303 get_invariants(Invs),
1304 statics_consist_instance(Invs,Statics).
1305
1306statics_consist_instance(Invs,[]):-!.
1307statics_consist_instance(Invs,[is_of_sort(Obj,Sort)|Atom]):-
1308 ground(Obj),
1309 is_of_sort(Obj,Sort),!,
1310 statics_consist_instance(Invs,Atom).
1311statics_consist_instance(Invs,[is_of_sort(Obj,Sort)|Atom]):-
1312 var(Obj),
1313 is_of_sort(Obj,Sort),
1314 statics_consist_instance(Invs,Atom).
1315statics_consist_instance(Invs,[is_of_primitive_sort(Obj,Sort)|Atom]):-
1316 ground(Obj),
1317 is_of_primitive_sort(Obj,Sort),!,
1318 statics_consist_instance(Invs,Atom).
1319statics_consist_instance(Invs,[is_of_primitive_sort(Obj,Sort)|Atom]):-
1320 var(Obj),
1321 is_of_primitive_sort(Obj,Sort),
1322 statics_consist_instance(Invs,Atom).
1323statics_consist_instance(Invs,[ne_back(A,B)|Atom]):-
1324 A\==B,
1325 statics_consist_instance(Invs,Atom).
1326statics_consist_instance(Invs,[ne(A,B)|Atom]):-
1327 append_dcut(Atom,[ne_back(A,B)],Atom1),!,
1328 statics_consist_instance(Invs,Atom1).
1329statics_consist_instance(Invs,[Pred|Atom]):-
1330 ground(Pred),
1331 member(Pred,Invs),!,
1332 statics_consist_instance(Invs,Atom).
1333statics_consist_instance(Invs,[Pred|Atom]):-
1334 not(ground(Pred)),
1335 member(Pred,Invs),
1336 statics_consist_instance(Invs,Atom).
1337
1338
1339
1344
1345make_problem_into_node(I,goal(L,TM,STATS), NN) :-
1346 make_problem_up(L, STEPS),
1347 make_num_hp(TM,Temp),
1348 sort_steps(STEPS,Temp,STEPS1),
1349 make_ss_to_se(I,I_Pre),
1350 NN = node(root,I_Pre,STEPS1 ,Temp, STATS),!.
1351make_problem_into_node(I,L, NN) :-
1352 make_problem_up([achieve(L)], STEPS),
1353 make_num_hp(TM,Temp),
1354 sort_steps(STEPS,Temp,STEPS1),
1355 make_ss_to_se(I,I_Pre),
1356 NN = node(root,I_Pre,STEPS1 ,Temp, STATS),!.
1357
1359make_problem_up([],[]):-!.
1360make_problem_up([achieve(L)|R],[step(HP,achieve(L1),undefd,[L1],unexp)|RS]):-
1361 1362 make_ss_to_se([L],[L1]),
1363 gensym(hp,HP),
1364 make_problem_up(R, RS),!.
1365make_problem_up([achieve(L)|R],[step(HP,achieve(L1),undefd,L1,unexp)|RS]):-
1366 1367 make_ss_to_se(L,L1),
1368 gensym(hp,HP),
1369 make_problem_up(R, RS),!.
1370make_problem_up([O|R],[step(HP,O,undefd,undefd,unexp)|RS]):-
1371 methodC(O,Pre,Post,Statics1,Temp,ACH,Dec),
1372 gensym(hp,HP),
1373 make_problem_up(R, RS),!.
1374make_problem_up([O|R],
1375 [step(HP,O,undefd,undefd,unexp)|RS]):-
1376 operatorC(O,Pre,Post,Cond,Statics1),
1377 gensym(hp,HP),
1378 make_problem_up(R, RS),!.
1379
1380make_num_hp([],[]):-!.
1381make_num_hp([before(N1,N2)|TM],[before(H1,H2)|Temp]):-
1382 gensym_num(hp,N1,H1),
1383 gensym_num(hp,N2,H2),
1384 make_num_hp(TM,Temp),!.
1385
1388sort_steps(Steps,[],Steps):-!.
1389sort_steps([Steps|[]],[],[Steps]):-!.
1390sort_steps(Steps,Temp,OrderedST):-
1391 steps_in_temp(Temp,[],ST),
1392 sort_steps1(Temp,ST,OrderedSTID),
1393 sort_steps2(Steps,OrderedSTID,[],OrderedST),!.
1394
1396steps_in_temp([],ST,ST):-!.
1397steps_in_temp([before(H1,H2)|TT],List,ST):-
1398 set_append_e(List,[H1,H2],List1),
1399 steps_in_temp(TT,List1,ST),!.
1400
1402sort_steps1(Temp,[],[]):-!.
1403sort_steps1(Temp,[HP1|TST],[HPF|OST]):-
1404 earliest_step(HP1,HPF,Temp,TST,TST1),
1405 sort_steps1(Temp,TST1,OST),!.
1406
1407earliest_step(HPF,HPF,Temp,[],[]):-!.
1408earliest_step(HP1,HPF,Temp,[HP2|TST],[HP1|TST1]):-
1409 member(before(HP2,HP1),Temp),
1410 earliest_step(HP2,HPF,Temp,TST,TST1),!.
1411earliest_step(HP1,HPF,Temp,[HP2|TST],[HP2|TST1]):-
1412 earliest_step(HP1,HPF,Temp,TST,TST1),!.
1413
1415sort_steps2(OtherST,[],OrderedST1,OrderedST):-
1416 append_dcut(OrderedST1,OtherST,OrderedST),!.
1417sort_steps2(Steps,[HP|THPS],List,OrderedST):-
1418 member(step(HP,N,Pre,Post,F),Steps),
1419 append_dcut(List,[step(HP,N,Pre,Post,F)],List1),
1420 list_take(Steps,[step(HP,N,Pre,Post,F)],Steps1),
1421 sort_steps2(Steps1,THPS,List1,OrderedST),!.
1422sort_steps2(Steps,[HP|THPS],List,OrderedST):-
1423 sort_steps2(Steps,THPS,List,OrderedST),!.
1425
1427make_ss_to_se([],[]):-!.
1428make_ss_to_se([ss(Sort,Obj,Post)|TPost],[se(Sort,Obj,Post)|TPre]):-
1429 make_ss_to_se(TPost,TPre),!.
1430make_ss_to_se([se(Sort,Obj,Post)|TPost],[se(Sort,Obj,Post)|TPre]):-
1431 make_ss_to_se(TPost,TPre),!.
1432
(Node,PHPs,SIZE1,TNList) :-
1438 1439 getN_decomp(Node, HPs),
1440 push_to_primitive(HPs,[],PHPs,[],TNList),
1441 pprint(PHPs,1,SIZE),
1442 SIZE1 is SIZE -1,!.
1443
1447change_op_representation :-
1448 method(A,B,C,Stat,T,Dec),
1449 make_ss_to_se(B,B0),
1450 make_se_primitive(B0,B1),
1451 make_sc_primitive(C,C1),
1452 get_preconditions(C1,B1,Pre,Post),
1453 rem_statics(Post, PostR,St1),
1454 rem_statics(Pre, PreR,St2),
1455 append_cut(St1,St2,Statics),
1456 append_cut(Stat,Statics,Statics1),
1457 remove_unneed(Statics1,[],Statics2),
1458 get_achieval(A,Dec,T,Dec1,T1,ACH),
1459 assert(methodC(A,PreR,PostR,Statics2,T1,achieve(ACH),Dec1)),
1460 fail.
1461change_op_representation :-
1462 operator(A,B,C,D),
1463 make_ss_to_se(B,B0),
1464 make_se_primitive(B0,B1),
1465 make_sc_primitive(C,C1),
1467 1468 get_preconditions(C1,B1,Pre,Post),
1469 rem_statics(Post, PostR,St1),
1470 rem_statics(Pre, PreR,St2),
1471 append_cut(St1,St2,Statics1),
1472 remove_unneed(Statics1,[],Statics),
1473 statics_consist(Statics),
1474 assert(operatorC(A,PreR,PostR,D,Statics)),
1475 fail.
1476change_op_representation:-
1477 retractall(current_num(sm,_)),!.
1478
1479get_preconditions([],Prev,Prev,Prev) :-!.
1480get_preconditions([sc(S,X,From =>To)|Rest],Prev,[se(S,X,From1)|Pre],[se(S,X,To1)|Post]):-
1481 member_e(se(S,X,PSE),Prev),
1482 append_dcut(PSE,From,From1),
1483 append_dcut(PSE,To,To1),
1484 list_take(Prev,[se(S,X,PSE)],Prev1),
1485 get_preconditions(Rest,Prev1, Pre,Post),!.
1486get_preconditions([sc(S,X,From =>To)|Rest],Prev,[se(S,X,From)|Pre],[se(S,X,To)|Post]):-
1487 get_preconditions(Rest,Prev, Pre,Post),!.
1488get_preconditions([],Prev,Prev,Prev) :-!.
1489
1491get_achieval(A,Dec,T,Dec1,T1,Achieval):-
1492 retractall(current_num(sm,_)),
1493 make_dec(A,Dec,Dec1,T,T1,[],Achieval),!.
1494make_dec(A,[],[],Temp,Temp,Achieval,Achieval):-!.
1495make_dec(A,[HD|TD],TD1,Temp,Temp1,Achieval,Achieval1):-
1496 HD=..[achieve|Goal],
1497 current_num(sm,Num),
1498 replace_achieval_temp(Temp,Temp0,Num),
1499 make_ss_to_se(Goal,Goal0),
1500 append_dcut(Achieval,Goal0,Achieval0),
1501 make_dec(A,TD,TD1,Temp0,Temp1,Achieval0,Achieval1),!.
1502make_dec(A,[HD|TD],TD1,Temp,Temp1,Achieval,Achieval1):-
1503 HD=..[achieve|Goal],
1504 not(current_num(sm,Num)),
1505 replace_achieval_temp(Temp,Temp0,1),
1506 make_ss_to_se(Goal,Goal0),
1507 append_dcut(Achieval,Goal0,Achieval0),
1508 make_dec(A,TD,TD1,Temp0,Temp1,Achieval0,Achieval1).
1509make_dec(A,[HD|TD],[HD|TD1],Temp,Temp1,Achieval,Achieval1):-
1510 HD=..[DecName|Goal],
1511 DecName\==achieve,
1512 gensym(sm,SM),
1513 current_num(sm,Num),
1514 make_dec(A,TD,TD1,Temp,Temp1,Achieval,Achieval1),!.
1515
1517replace_achieval_temp(Temp,Temp1,Num):-
1518 change_all_numbers(Temp,Num,Temp00),
1519 tidy_temp(Temp00,Temp1).
1520
1521change_all_numbers([],Num,[]):-!.
1522change_all_numbers([HTemp|TTemp],Num,[HTemp00|TTemp00]):-
1523 HTemp=..[before|Nums],
1524 change_nums(Nums,Num,Nums1),
1525 HTemp00=..[before|Nums1],
1526 change_all_numbers(TTemp,Num,TTemp00).
1527
1528change_nums([],Num,[]):-!.
1529change_nums([Num1|TN],Num,[Num1|TN1]):-
1530 Num1<Num,
1531 change_nums(TN,Num,TN1),!.
1532change_nums([Num1|TN],Num,[Num2|TN1]):-
1533 Num1>Num,
1534 Num2 is Num1-1,
1535 change_nums(TN,Num,TN1),!.
1536change_nums([Num|TN],Num,[0|TN1]):-
1537 change_nums(TN,Num,TN1),!.
1538
1540tidy_temp(Temp,Temp1):-
1541 member(before(Num,0),Temp),
1542 list_take(Temp,[before(Num,0)],Temp0),
1543 change_laters(Temp0,Num,Temp01),
1544 tidy_temp(Temp01,Temp1).
1545tidy_temp([],[]):-!.
1546tidy_temp([before(0,Num)|Temp],Temp0):-
1547 tidy_temp(Temp,Temp0),!.
1548tidy_temp([before(Num1,Num2)|Temp],[before(Num1,Num2)|Temp0]):-
1549 tidy_temp(Temp,Temp0),!.
1550
1551change_laters([before(0,Num2)|Temp],Num,[before(Num,Num2)|Temp0]):-
1552 change_laters(Temp,Num,Temp0).
1553change_laters([before(Num1,0)|Temp],Num,[before(Num1,0)|Temp0]):-
1554 change_laters(Temp,Num,Temp0).
1555change_laters([before(Num1,Num2)|Temp],Num,[before(Num1,Num2)|Temp0]):-
1556 change_laters(Temp,Num,Temp0).
1557
1559make_se_primitive([],[]).
1560make_se_primitive([se(Sort,Obj,ST)|SE],[se(Sort,Obj,ST)|SE0]):-
1561 objectsC(Sort,Objls),!,
1562 make_se_primitive(SE,SE0).
1563make_se_primitive([se(Sort,Obj,ST)|SE],[se(PSort,Obj,ST)|SE0]):-
1564 find_prim_sort(Sort,PSorts),
1565 member(PSort,PSorts),
1566 make_se_primitive(SE,SE0).
1567
1569make_sc_primitive([],[]).
1570make_sc_primitive([sc(Sort,Obj,SE1=>SE2)|ST],[sc(Sort,Obj,SE1=>SE2)|ST0]):-
1571 objectsC(Sort,Objls),!,
1572 make_sc_primitive(ST,ST0).
1573make_sc_primitive([sc(Sort,Obj,SE1=>SE2)|ST],[sc(PSort,Obj,SE1=>SE2)|ST0]):-
1574 find_prim_sort(Sort,PSorts),
1575 member(PSort,PSorts),
1576 make_sc_primitive(ST,ST0).
1577
1578
1581make_tn(TN,Name,Pre,Post,Temp,Dec):-
1582 find_only_changed(Pre,Post,[],Pre1,[],Post1),
1583 not(isemptylist(Post1)),
1584 not(exist_tn(Pre,Post)),
1585 gensym(tn,TN),
1587 assert(tn(TN,Name,Pre1,Post1,Temp,Dec)),!.
1588
1589exist_tn(Pre,Post):-
1590 tn(_,_,Pre,Post1,_,_),
1591 state_achieved(Post,Post1),!.
1592find_only_changed([],[],Pre,Pre,Post,Post):-!.
1594find_only_changed([se(Sort,Obj,ST)|Pre],[se(Sort,Obj,ST)|Post],Pre0,Pre1,Post0,Post1):-
1595 find_only_changed(Pre,Post,Pre0,Pre1,Post0,Post1),!.
1596find_only_changed([se(Sort,Obj,ST)|Pre],Post,Pre0,Pre1,Post0,Post1):-
1597 member(se(Sort,Obj,ST1),Post),
1598 list_take(Post,[se(Sort,Obj,ST1)],Post2),
1599 append_changed(se(Sort,Obj,ST),se(Sort,Obj,ST1),Pre0,Pre3,Post0,Post3),
1600 find_only_changed(Pre,Post2,Pre3,Pre1,Post3,Post1),!.
1601find_only_changed([se(Sort,Obj,ST)|Pre],Post,Pre0,Pre1,Post0,Post1):-
1602 member(se(SortN,Obj,ST1),Post),
1603 list_take(Post,[se(SortN,Obj,ST1)],Post2),
1604 append_changed(se(Sort,Obj,ST),se(SortN,Obj,ST1),Pre0,Pre3,Post0,Post3),
1605 find_only_changed(Pre,Post2,Pre3,Pre1,Post3,Post1),!.
1607
1610append_changed(se(Sort,Obj,ST),se(Sort1,Obj,ST1),Pre0,Pre0,Post0,Post0):-
1611 state_match(Sort,Obj,ST,ST1),!.
1612append_changed(se(Sort,Obj,ST),se(Sort1,Obj,ST1),Pre0,Pre3,Post0,Post3):-
1613 append_dcut(Pre0,[se(Sort,Obj,ST)],Pre3),
1614 append_dcut(Post0,[se(Sort,Obj,ST1)],Post3),!.
1615
1617push_to_primitive([],PHPs,PHPs,TNLst,TNLst) :-!.
1618push_to_primitive([step(HPID,_,_,_,exp(TN))|HPs],List,PHPs,TNSoFar,TNFinal) :-
1619 tn(TN,Name,Pre,Post,Temp,Dec),
1620 push_to_primitive(Dec,List,Dec1,[tn(TN,Name,Pre,Post,Temp,Dec)|TNSoFar],TNNext),
1621 push_to_primitive(HPs,Dec1,PHPs,TNNext,TNFinal),!.
1622push_to_primitive([step(HPID,_,_,_,exp(Name))|HPs],List,PHPs,TNSoFar,TNFinal):-
1623 append_dcut(List,[Name],List1),
1624 push_to_primitive(HPs,List1,PHPs,TNSoFar,TNFinal),!.
1625
1627
1628possibly_before(I,J,Temps) :-
1629 \+ necessarily_before(J,I,Temps), !.
1630
1631necessarily_before(J,I,Temps) :-
1632 member(before(J,I),Temps),!.
1633necessarily_before(J,I,Temps) :-
1634 member(before(J,Z),Temps),
1635 necessarily_before(Z,I,Temps),!.
1636
1637select_node(node(Name,Pre,Temp,Decomp,Statics)) :-
1638 retract(node(Name,Pre,Temp,Decomp,Statics)),
1643 !.
1644
1645get_obj_prim_sort([],[]):-!.
1646get_obj_prim_sort([HSort|TV],[HObj|TS]):-
1647 is_of_primitive_sort(HObj,HSort),
1648 get_obj_prim_sort(TV,TS),!.
1657find_all_upper([],[]).
1658find_all_upper([HVars|TV],[HSorts|TS]):-
1659 uppersorts(HSorts,Upsorts),
1660 member(HVars,Upsorts),
1661 find_all_upper(TV,TS).
1662
1664find_prim_sort(Sort,PS):-
1665 subsorts(Sort,Subsorts),
1666 split_prim_noprim(Subsorts,PS,NP),!.
1667
1669get_sort_objects(Sort,Objs):-
1670 find_prim_sort(Sort,PSorts),
1671 get_objects1(PSorts,Objls),
1672 flatten(Objls,[],Objs),!.
1673
1674get_objects1([],[]):-!.
1675get_objects1([PS1|RS],[Objls1|Objls]):-
1676 objectsC(PS1,Objls1),
1677 get_objects1(RS,Objls),!.
1678
1680subsortse(Sort,Subsorts):-
1681 subsorts(Sort,Subsorts1),
1682 subtract(Subsorts1,[Sort],Subsorts),!.
1684subsorts(Sort,Subsorts):-
1685 sort_down([Sort],[],Subsorts),!.
1686
1687sort_down([],Subsorts,Subsorts):-!.
1688sort_down([HOpen|TOpen],List,Subsorts):-
1689 objectsC(HOpen,Objls),
1690 append_dcut(List,[HOpen],List1),
1691 sort_down(TOpen,List1,Subsorts),!.
1692sort_down([HOpen|TOpen],List,Sortslist):-
1693 sorts(HOpen,Sorts),
1694 sort_down(Sorts,List,List2),
1695 sort_down(TOpen,[HOpen|List2],Sortslist),!.
1696sort_down([HOpen|TOpen],List,Sortslist):-
1697 sort_down(TOpen,List,Sortslist),!.
1698
1700uppersortse(Sort,Uppersorts):-
1701 uppersorts(Sort,Uppersortsf),
1702 subtract(Uppersortsf,[Sort],Uppersorts),!.
1704uppersorts(Sort,Uppersorts):-
1705 objectsC(Sort,Objls),
1706 sort_up(Sort,[Sort],Uppersorts),!.
1707uppersorts(Sort,Uppersorts):-
1708 sorts(Sort,Sortls),
1709 sort_up(Sort,[Sort],Uppersorts),!.
1710uppersorts(Obj,Sortls):-
1711 objectsC(Sort,Objls),
1712 member(Obj, Objls),
1713 sort_up(Sort,[Sort],Sortls),!.
1714
1715sort_up(Sort, List,Sortslist):-
1716 sorts(NPSort, NPSortls),
1717 NPSort \== non_primitive_sorts,
1718 NPSort \== primitive_sorts,
1719 member(Sort,NPSortls),
1720 sort_up(NPSort,[NPSort|List],Sortslist).
1721sort_up(Sort, List,List):-!.
1722
1724sametree(Sort1,Sort2):-
1725 Sort1==Sort2,!.
1726sametree(Sort1,Sort2):-
1727 var(Sort1),!.
1728sametree(Sort1,Sort2):-
1729 var(Sort2),!.
1730sametree(Sort1,Sort2):-
1731 uppersorts(Sort2,Sortls),
1732 member(Sort1,Sortls),!.
1733sametree(Sort1,Sort2):-
1734 uppersorts(Sort1,Sortls),
1735 member(Sort2,Sortls),!.
1736
1738split_prim_noprim([],[],[]):-!.
1739split_prim_noprim([HS|TS],[HS|TP],NP):-
1740 objectsC(HS,Obj),
1741 split_prim_noprim(TS,TP,NP),!.
1742split_prim_noprim([HS|TS],PS,[HS|NP]):-
1743 split_prim_noprim(TS,PS,NP),!.
1744
1746
1748get_invariants(Invs) :-
1749 atomic_invariantsC(Invs),!.
1750
1751rem_statics([sc(S,X,Lhs=>Rhs)|ST], [sc(S,X,LhsR=>RhsR)|STR],Rt1) :-
1752 split_st_dy(Lhs,[],LR, [],LhsR),
1753 split_st_dy(Rhs,[],RR,[],RhsR),
1754 append_dcut(LR,RR,R),
1755 rem_statics(ST, STR,Rt),
1756 append_dcut(Rt,[is_of_sort(X,S)|R],Rt1),!.
1757rem_statics([ss(S,X,Preds)|Post], [ss(S,X,PredR)|PostR],Rt1) :-
1758 split_st_dy(Preds,[],R, [],PredR),
1759 rem_statics(Post, PostR,Rt),
1760 append_dcut(Rt,[is_of_sort(X,S)|R],Rt1),!.
1761rem_statics([se(S,X,Preds)|Post], [se(S,X,PredR)|PostR],Rt1) :-
1762 split_st_dy(Preds,[],R, [],PredR),
1763 rem_statics(Post, PostR,Rt),
1764 append_dcut(Rt,[is_of_sort(X,S)|R],Rt1),!.
1765rem_statics([], [],[]) :-!.
1766
1767
1769
1771isemptylist([]):-!.
1772
1778
1779member_cut(X,[X|_]) :- !.
1780member_cut(X,[_|Y]) :- member_cut(X,Y),!.
1781
1783member_e(X,[Y|_]):-
1784 X==Y,!.
1785member_e(X,[Y|L]):-
1786 var(Y),
1787 member_e(X,L),!.
1788member_e(ss(Sort,Obj,SE),[ss(Sort,Obj1,SE)|_]):-
1789 Obj==Obj1,!.
1790member_e(se(Sort,Obj,SE),[se(Sort,Obj1,SE)|_]):-
1791 Obj==Obj1,!.
1792member_e(sc(Sort,Obj,SE1=>SE2),[sc(Sort,Obj1,SE1=>SE2)|_]):-
1793 Obj==Obj1,!.
1794member_e(X,[Y|L]):- member_e(X,L),!.
1795
1796
1799u_mem_cut(_,[]):-!,fail.
1800u_mem_cut(X,[Y|_]) :- X == Y,!.
1801u_mem_cut(X,[_|L]) :- u_mem_cut(X,L),!.
1806obj_member(X,[X|[]]):-!.
1807obj_member(X,List):-
1808 obj_member0(X,List),!.
1809obj_member0(X,[Y|_]):-
1810 var(X),!. 1811obj_member0(X,[Y|_]):-
1812 X==Y,!.
1813obj_member0(X,[_|Y]) :- obj_member0(X,Y),!.
1814
1815
1819pred_member(X,List):-
1820 ground(X),
1821 member(X,List),!.
1822pred_member(X,List):-
1823 setof(X,member(X,List),Refined),
1824 pred_member0(X,Refined),!.
1825
1826pred_member0(X,[X|[]]):-!.
1827pred_member0(X,Y):-
1828 pred_member1(X,Y),!.
1829pred_member1(X,[Y|_]):-
1830 X=..[H|XLs],
1831 Y=..[H|YLs],
1832 vequal(XLs,YLs),!.
1833pred_member1(X,[_|Y]):- pred_member1(X,Y),!.
1834
1835statics_append([],L,L):-
1836 statics_consist(L),!.
1837statics_append(L,[],L):-
1838 statics_consist(L),!.
1839statics_append(List1,List2,L):-
1840 statics_consist(List1),
1841 statics_consist(List2),
1842 statics_append1(List1,List2,[],L),
1843 statics_consist(L),!.
1844
1845statics_append1([],List2,L1,L):-
1846 append_dcut(List2,L1,L),!.
1847statics_append1([H|List1],List2,L,Z) :-
1848 statics_append0(H,List2,L,L1),
1849 statics_append1(List1,List2,L1,Z),!.
1850
1851statics_append0(H,[],L,[H|L]):-!.
1852statics_append0(H,[H|Z],L,L):-!.
1853statics_append0(H,[X|Z],L1,L):-
1854 statics_append0(H,Z,L1,L),!.
1855
1856append_dcut([],L,L):-!.
1857append_dcut([H|T],L,[H|Z]) :- append_dcut(T,L,Z),!.
1858
1859append_cut([],L,L) :- !.
1860append_cut([H|T],L,[H|Z]) :- append_cut(T,L,Z),!.
1861
1866append_st(ST1,ST2,ST):-
1867 append_cut(ST1,ST2,ST0),
1868 remove_unneed(ST0,[],ST),!.
1869
1872remove_unneed([],C,C):-!.
1873remove_unneed([A|B], Z, C):-
1874 var(A),
1875 member_e(A,Z),
1876 remove_unneed(B, Z, C),! .
1877remove_unneed([A|B], Z, C):-
1878 var(A),
1879 append_dcut(Z,[A],D),
1880 remove_unneed(B, D, C),!.
1881remove_unneed([A|B], Z, C):-
1882 ground(A),
1883 remove_unneed(B, Z, C),!.
1884remove_unneed([A|B], Z, C):-
1885 A=..[ne|Paras],
1886 append_dcut(Z,[A],D),
1887 remove_unneed(B, D, C),!.
1888remove_unneed([A|B], Z, C):-
1889 A=..[Pred|Paras],
1890 same_var_member(A,Z),
1891 remove_unneed(B, Z, C),!.
1892remove_unneed([A|B], Z, C):-
1893 append_dcut(Z,[A],D),
1894 remove_unneed(B, D, C),!.
1895
1896same_var_member(Pred,[Pred1|List]):-
1897 var(Pred1),
1898 same_var_member(Pred,List),!.
1899same_var_member(Pred,[Pred1|List]):-
1900 Pred==Pred1,!.
1901same_var_member(Pred,[Pred1|List]):-
1902 Pred=..[H|T],
1903 Pred1=..[H|T1],
1904 same_var_member1(T,T1),!.
1905same_var_member(Pred,[Pred1|List]):-
1906 same_var_member(Pred,List),!.
1907
1908same_var_member1([],[]):-!.
1909same_var_member1([H1|T],[H2|T]):-
1910 var(H1),
1911 H1==H2,!.
1912same_var_member1([H|T1],[H|T2]):-
1913 var(T1),
1914 T1==T2,!.
1915same_var_member1([H1|T1],[H2|T2]):-
1916 H1==H2,
1917 same_var_member1(T1,T2),!.
1918
1920is_equal_list(List1,List2):-
1921 List1==List2,!.
1922is_equal_list([],[]):-!.
1923is_equal_list(List1,List2):-
1924 length(List1,L),
1925 length(List2,L),
1926 is_equal_list1(List1,List2),!.
1927is_equal_list1([],[]):-!.
1928is_equal_list1([Head1|List1],[Head2|List2]):-
1929 Head1==Head2,
1930 is_equal_list1(List1,List2),!.
1931is_equal_list1([se(Sort,Obj,Head1)|List1],[se(Sort,Obj,Head2)|List2]):-
1932 is_equal_list(Head1,Head2),
1933 is_equal_list1(List1,List2),!.
1934is_equal_list1([Head1|List1],[Head2|List2]):-
1935 Head1=..[FF|Var1],
1936 Head2=..[FF|Var2],
1937 FF\==se,
1938 vequal(Var1,Var2),
1939 is_equal_list1(List1,List2),!.
1940is_equal_list1([Head1|List1],List2):-
1941 member(Head1,List2),
1942 append_cut(List1,[Head1],List10),
1943 is_equal_list1(List10,List2),!.
1944
1946is_diff(List1,List2):-
1947 length(List1,L1),
1948 length(List2,L2),
1949 L1\==L2,!.
1950is_diff([Head|List1],List2):-
1951 not_exist(Head,List2),!.
1952is_diff([Head|List1],List2):-
1953 list_take(List2,[Head],List21),
1954 is_diff(List1,List21),!.
1955
1956not_exist(Pred,List2):-
1957 not(member(Pred,List2)),!.
1958not_exist(se(Sort,Obj,Head1),List2):-
1959 not(member(se(Sort,Obj,Head),List2)),!.
1960not_exist(se(Sort,Obj,Head1),List2):-
1961 member(se(Sort,Obj,Head2),List2),
1962 is_diff(Head1,Head2),!.
1963
1967set_append([], Z, Z):-! .
1968set_append([A|B], Z, C) :-
1969 not(not(member(A, Z))) ,
1970 set_append(B, Z, C),! .
1971set_append([A|B], Z, [A|C]) :-
1972 set_append(B, Z, C) .
1973
1977set_append_e(A,B,C):-
1978 append_cut(A,B,D),
1979 remove_dup(D,[],C),!.
1980
1982remove_dup([],C,C):-!.
1983remove_dup([A|B],Z,C) :-
1984 member_e(A, Z),
1985 remove_dup(B, Z, C),! .
1986remove_dup([A|B], Z, C):-
1987 append_dcut(Z,[A],D),
1988 remove_dup(B, D, C),!.
1989
1991vequal([],[]):-!.
1992vequal([X|XLs],[Y|YLs]):-
1993 X==Y,
1994 vequal(XLs,YLs),!.
1995vequal([X|XLs],[Y|YLs]):-
1996 var(X),
1997 vequal(XLs,YLs),!.
1998vequal([X|XLs],[Y|YLs]):-
1999 var(Y),
2000 vequal(XLs,YLs),!.
2001
2002
2005subtract([],_,[]):-!.
2006subtract([A|B],C,D) :-
2007 member(A,C),
2008 subtract(B,C,D),!.
2009subtract([A|B],C,[A|D]) :-
2010 subtract(B,C,D),!.
2011
2013
2014list_take(R,[E|R1],R2):-
2015 remove_el(R,E,RR),
2016 list_take(RR,R1,R2),!.
2017list_take(R,[_|R1],R2):-
2018 list_take(R,R1,R2),!.
2019list_take(A,[],A) :- !.
2020
2023remove_el([],_,[]) :- ! .
2024remove_el([A|B],A,B) :- ! .
2025remove_el([A|B],C,[A|D]) :-
2026 remove_el(B,C,D) .
2027
2029
2030gensym(Root,Atom) :-
2031 getnum(Root,Num),
2032 name(Root,Name1),
2033 name(Num,Name2),
2034 append_dcut(Name1,Name2,Name),
2035 name(Atom,Name).
2036
2037getnum(Root,Num) :-
2038 retract(current_num(Root,Num1)),!,
2039 Num is Num1+1,
2040 asserta(current_num(Root,Num)).
2041
2042getnum(Root,1) :- asserta(current_num(Root,1)).
2043
2044gensym_num(Root,Num,Atom):-
2045 name(Root,Name),
2046 name(Num,Name1),
2047 append_dcut(Name,Name1,Name2),
2048 name(Atom,Name2),!.
2049
2050
2051pprint([],SIZE,SIZE):-!.
2052pprint([HS|TS],Size0,SIZE):-
2053 list(HS),
2054 pprint(HS,Size0,Size1),
2055 pprint(TS,Size1,SIZE),!.
2056pprint([HS|TS],Size0,SIZE):-
2059 Size1 is Size0+1,
2060 pprint(TS,Size1,SIZE),!.
2061
2063
2064split_st_dy([],ST,ST,DY,DY):-!.
2065split_st_dy([Pred|TStates],ST0,ST,DY0,DY):-
2066 is_statics(Pred),
2067 append_cut(ST0,[Pred],ST1),
2068 split_st_dy(TStates,ST1,ST,DY0,DY),!.
2069split_st_dy([Pred|TStates],ST0,ST,DY0,DY):-
2070 append_cut(DY0,[Pred],DY1),
2071 split_st_dy(TStates,ST0,ST,DY1,DY),!.
2072
2074
2075flatten([HO|TO], List, O_List):-
2076 append_dcut(HO, List, List_tmp),
2077 flatten(TO, List_tmp, O_List),!.
2078flatten([H|TO], List,O_List):-
2079 append_dcut([H], List, List_tmp),
2080 flatten(TO, List_tmp, O_List).
2081flatten([], [HList|T], O_List):-
2082 HList = [],
2083 flatten(T, [], O_List).
2084flatten([], [HList|T], O_List):-
2085 list(HList),
2086 flatten([HList|T],[], O_List),!.
2087flatten([], L,L):-!.
2088
2090set_flatten([HO|TO], List, O_List):-
2091 set_append_e(HO, List, List_tmp),
2092 set_flatten(TO, List_tmp, O_List),!.
2093set_flatten([H|TO], List,O_List):-
2094 set_append_e([H], List, List_tmp),
2095 set_flatten(TO, List_tmp, O_List).
2096set_flatten([], [HList|T], O_List):-
2097 HList = [],
2098 set_flatten(T, [], O_List).
2099set_flatten([], [HList|T], O_List):-
2100 list(HList),
2101 set_flatten([HList|T],[], O_List),!.
2102set_flatten([], L,L):-!.
2103
2104
2107list(A) :-
2108 var(A) ,
2109 ! ,
2110 fail .
2111list(A) :-
2112 functor(A,'.',_).
2113
2114reverse(L,RL) :-
2115 revSlave(L,[],RL).
2116
2117revSlave([],RL,RL).
2118revSlave([H|T],Sofar,Final) :-
2119 revSlave(T,[H|Sofar],Final).
2120
2122:- assert(time_taken(0)). 2123:- assert(soln_size(0)). 2124
2125solve(N,FN):-
2126 N < FN,
2127 nl,write('task '), write(N),write(': '),nl,
2128 solve(N),
2129 Ni is N+1,
2130 solve(Ni,FN).
2131solve(FN,FN):-
2132 nl,write('task '), write(FN),write(': '),nl,
2133 solve(FN),
2134 retractall(sum(_)),
2135 assert(sum(0)),
2136 sum_time(CP),
2137 retractall(sum(_)),
2138 assert(sum(0)),
2139 sum_size(SIZE),
2140 TIM is CP /1000,
2141 retractall(time_taken(_)),
2142 retractall(soln_size(_)),
2143 nl,write('total time '),write(TIM),write(' seconds'),
2144 nl,write('total size '),write(SIZE),nl.
2145solve(N,N).
2146
2147sum_time(TIM):-
2148 time_taken(CP),
2149 retract(sum(N)),
2150 N1 is N +CP,
2151 assert(sum(N1)),
2152 fail.
2153sum_time(TIM):-
2154 sum(TIM).
2155sum_size(SIZE):-
2156 soln_size(S),
2157 retract(sum(N)),
2158 N1 is N +S,
2159 assert(sum(N1)),
2160 fail.
2161sum_size(SIZE):-
2162 sum(SIZE).
2163
2164stoppoint.
2166state_related(Post,Cond,undefd):-!.
2167state_related(Post,Cond,[]):-!.
2168state_related(Post,Cond,State2):-
2169 append_cut(Post,Cond,State1),
2170 state_related(State1,State2).
2171
2174state_related([se(Sort,Obj,SE1)|State1],State2):-
2175 member(se(Sort,Obj,SE2),State2),
2176 state_related0(SE1,SE2).
2178state_related([sc(Sort1,Obj,SE1=>SS1)|State1],State2):-
2179 member(se(Sort,Obj,SE2),State2),
2180 is_of_sort(Obj,Sort1),
2181 is_of_sort(Obj,Sort).
2182state_related([se(Sort,Obj,SE)|State1],State2):-
2183 state_related(State1,State2),!.
2184state_related([sc(Sort,Obj,SE=>SS)|State1],State2):-
2185 state_related(State1,State2),!.
2186
2188state_related0([],SE2):-!.
2189state_related0([Head|SE1],SE2):-
2190 member(Head,SE2),
2191 state_related0(SE1,SE2).
2192state_related0([Head|SE1],SE2):-
2193 state_related0(SE1,SE2).
2194
2197change_obj_list(I):-
2198 find_dynamic_objects(I),
2199 collect_dynamic_obj,
2200 change_obj_list1,
2201 change_atomic_inv,!.
2202
2203change_obj_list1:-
2204 objects(Sort,OBjls),
2205 change_obj_list2(Sort),
2206 fail.
2207change_obj_list1.
2208
2210change_obj_list2(Sort):-
2211 objectsC(Sort,Objls),!.
2213change_obj_list2(Sort):-
2214 objects(Sort,Objls),
2215 assert(objectsC(Sort,Objls)),!.
2216
2218change_atomic_inv:-
2219 atomic_invariants(Atom),
2220 change_atomic_inv1(Atom,Atom1),
2221 assert(atomic_invariantsC(Atom1)),!.
2222change_atomic_inv.
2223
2224change_atomic_inv1([],[]).
2225change_atomic_inv1([Pred|Atom],[Pred|Atom1]):-
2226 Pred=..[Name|Objs],
2227 just_dynamic_objects(Objs),
2228 change_atomic_inv1(Atom,Atom1).
2229change_atomic_inv1([Pred|Atom],Atom1):-
2230 change_atomic_inv1(Atom,Atom1).
2231
2232just_dynamic_objects([]).
2233just_dynamic_objects([Head|Objs]):-
2234 objectsC(Sort,Objls),
2235 member(Head,Objls),!,
2236 just_dynamic_objects(Objs).
2237
2238find_dynamic_objects([]):-!.
2239find_dynamic_objects([SE|Rest]):-
2240 find_dynamic_objects(SE),
2241 find_dynamic_objects(Rest),!.
2242find_dynamic_objects(ss(Sort,Obj,_)):-
2243 assert(objectsD(Sort,Obj)),!.
2244
2245collect_dynamic_obj:-
2246 objectsD(Sort,_),
2247 setof(Obj, objectsD(Sort,Obj), Objls),
2248 retractall(objectsD(Sort,_)),
2249 assert(objectsC(Sort,Objls)),
2250 fail.
2251collect_dynamic_obj.
2252
2253get_preconditions_g([],Prev,Prev,Prev):-!.
2254get_preconditions_g([sc(S,X,From =>To)|Rest],Prev,[se(S,X,From)|Pre],[se(S,X,To)|Post]):-
2255 !,
2256 get_preconditions_g(Rest,Prev, Pre,Post).
2257
2260
2261ground_op :-
2262 assert_sort_objects,
2263 enumerateOps,
2264 instOps,
2265 opCounter(Top),
2266 write(Top),nl.
2267
2268enumerateOps :-
2269 retractall(opCounter),
2270 assert(opCounter(1)),
2271 enumOps.
2272
2273enumOps :-
2274 operator(Name,Prev,Nec,Cond),
2275 retract(opCounter(Count)),
2276 containsInvars(operator(Name,Prev,Nec,Cond),InVars,IsOfSorts,FPrev,FNec),
2277 2278 findVarsAndTypes(operator(Name,Prev,Nec,Cond),VT,NEs),
2279 assert(opParent(Count,operator(Name,FPrev,FNec,Cond),VT,NEs,InVars,IsOfSorts)),
2280 Next is Count + 1,
2281 assert(opCounter(Next)),
2282 fail.
2283
2284enumOps.
2285
2286
2295
2296
2297findVarsAndTypes(operator(_,Pre,Nec,Cond),Vars,NEs) :-
2298 vtPrevail(Pre,PreVars,PreNEs),
2299 vtEffects(Nec,NecVars,NecNEs),
2300 append_dcut(PreVars,NecVars,Vars),
2301 append_dcut(PreNEs,NecNEs,NEs),
2302 !.
2303
2306
2307vtEffects([],[],[]).
2308
2309vtEffects([sc(Type,Obj1,Preds)|Rest],VT,NEs) :-
2310 vtPreds(Preds,Related,NEs1),
2311 append_dcut([Type,Obj1],Related,Obj1VT),
2312 vtEffects(Rest,RestVT,RestNEs),
2313 append_dcut(Obj1VT,RestVT,VT),
2314 append_dcut(NEs1,RestNEs,NEs).
2315
2318
2319vtPrevail([],[],[]).
2320
2321vtPrevail([se(Type,Obj1,Preds)|Rest],VT,NEs) :-
2322 vtPLst(Preds,Related,NEs1),
2323 append_dcut([Type,Obj1],Related,Obj1VT),
2324 vtPrevail(Rest,RestVT,RestNEs),
2325 append_dcut(Obj1VT,RestVT,VT),
2326 append_dcut(NEs1,RestNEs,NEs).
2327
2330
2331vtPreds((Pre => Add),Res,NEs) :-
2332 vtPLst(Pre,VTPre,NEs1),
2333 vtPLst(Add,VTAdd,NEs2),
2334 append_dcut(VTPre,VTAdd,Res),
2335 append_dcut(NEs1,NEs2,NEs).
2336
2339
2340vtPLst([],[],[]).
2341
2342vtPLst([ne(X,Y)|Rest],Res,[ne(X,Y)|RestNEs]) :-
2343 !,
2344 vtPLst(Rest,Res,RestNEs).
2345
2346vtPLst([Pred|Preds],Res,NEs) :-
2347 functor(Pred,_,1),
2348 !,
2349 vtPLst(Preds,Res,NEs).
2350
2351vtPLst([is_of_sort(_,_)|Preds],Res,NEs) :-
2352 !,
2353 vtPLst(Preds,Res,NEs).
2354
2358
2359vtPLst([Pred|Preds],Res,NEs) :-
2360 functor(Pred,Name,Arity),
2361 Pred =.. [Name,Obj1|Rest],
2362 VNeeded is Arity - 1,
2363 createVarList(VNeeded,VN),
2364 DummyPred =.. [Name,X|VN],
2365 predicates(PList),
2366 member(DummyPred,PList),
2367 pair(VN,Rest,This),
2368 vtPLst(Preds,RestPre,NEs),
2369 append_dcut(This,RestPre,Res).
2370
2373
2374createVarList(1,[X]) :-
2375 !.
2376
2377createVarList(N,[X|Rest]) :-
2378 Next is N - 1,
2379 createVarList(Next,Rest).
2380
2383
2384pair([],[],[]).
2385
2386pair([Type|Types],[Var|Vars],[Type,Var|Rest]) :-
2387 pair(Types,Vars,Rest).
2388
2389
2390
2395
2396instOps :-
2397 retractall(opCounter(_)),
2398 assert(opCounter(1)),
2399 opParent(No,Operator,VT,NEs,InVars,IsOfSorts),
2400 checkIsOfSorts(IsOfSorts),
2401 checkInVars(InVars),
2402 chooseVals(VT,NEs,InVars,Vals),
2403 obeysNEs(NEs),
2404 retract(opCounter(Count)),
2405 operator(Name,Prev,Nec,Cond) = Operator,
2406 filterSE(Prev,FPrev),
2407 filterSC(Nec,FNec),
2408 assert(gOperator(Count,No,operator(Name,FPrev,FNec,Cond))),
2409 Next is Count + 1,
2410 assert(opCounter(Next)),
2411 fail.
2412
2413instOps.
2414
2415
2416checkInVars([]):- !.
2417checkInVars(Preds):-
2418 atomic_invariantsC(Invars),
2419 doCheckInvars(Preds,Invars).
2420
2421doCheckInvars([],_).
2422doCheckInvars([Pred|Rest],Invars) :-
2423 member(Pred,Invars),
2424 doCheckInvars(Rest,Invars).
2425
2426checkIsOfSorts([]).
2427checkIsOfSorts([is_of_sort(V,Sort)|Rest]) :-
2428 objectsOfSort(Sort,Objs),
2429 member(V,Objs),
2430 checkIsOfSorts(Rest).
2431
2432
2434
2435filterSE([],[]) :- !.
2436filterSE([se(Sort,Id,Preds)|Rest],[se(Sort,Id,FPreds)|FRest]) :-
2437 filterPreds(Preds,FPreds),!,
2438 filterSE(Rest,FRest).
2439
2441
2442filterSC([],[]) :- !.
2443filterSC([sc(Sort,Id,(Pre => Post))|Rest],[sc(Sort,Id,(FPre => FPost))|FRest]) :-
2444 filterPreds(Pre,FPre),
2445 filterPreds(Post,FPost),
2446 !,
2447 filterSC(Rest,FRest).
2448
2450
2451filterPreds([],[]).
2452filterPreds([ne(_,_)|Rest],FRest) :-
2453 !,
2454 filterPreds(Rest,FRest).
2455filterPreds([is_of_sort(_,_)|Rest],FRest) :-
2456 !,
2457 filterPreds(Rest,FRest).
2463filterPreds([H|T],[H|FT]) :-
2464 filterPreds(T,FT).
2465
2466
2468
2469collectAllConds(_,_,_,_,[],[]) :- !.
2470
2471collectAllConds(CondVT,NEs,InVars,CondVals,Cond,_) :-
2472 retractall(temp(_)),
2473 chooseVals(CondVT,NEs,InVars,Vals),
2474 assertIndivConds(Cond),
2475 fail.
2476
2477collectAllConds(_,_,_,_,_,NewConds) :-
2478 setof(Cond,temp(Cond),NewConds).
2479
2480assertIndivConds([]) :- !.
2481
2482assertIndivConds([H|T]) :-
2483 assert(temp(H)),
2484 assertIndivConds(T).
2485
2487
2488containsInvars(operator(Name,Prev,Nec,Cond),InVars,IsOfSorts,FPrev,FNec) :-
2489 prevInvars(Prev,PInVars,PIsOfSorts,FPrev),
2490 necInvars(Nec,NecInVars,NIsOfSorts,FNec),
2491 append_dcut(NecInVars,PInVars,InVars),
2492 append_dcut(PIsOfSorts,NIsOfSorts,IsOfSorts),
2493 !.
2494
2495prevInvars([],[],[],[]).
2496prevInvars([se(Type,Obj,Props)|Rest],InVars,IsOfSorts,[se(Type,Obj,FProps)|RFPrev]) :-
2497 propsInvars(Props,PInvars,PIsOfSorts,FProps),
2498 prevInvars(Rest,RInVars,RIsOfSorts,RFPrev),
2499 append_dcut(PInVars,RInVars,InVars),
2500 append_dcut([is_of_sort(Obj,Type)|PIsOfSorts],RIsOfSorts,IsOfSorts).
2501
2502necInvars([],[],[],[]).
2503necInvars([sc(Type,Obj,(Props => Adds))|Rest],Invars,IsOfSorts,[sc(Type,Obj,(FProps => FAdds))|RFNec]) :-
2504 propsInvars(Props,PInvars,PIsOfSorts,FProps),
2505 propsInvars(Adds,AInvars,AIsOfSorts,FAdds),
2506 necInvars(Rest,RInvars,RIsOfSorts,RFNec),
2507 append_dcut(AInvars,PInvars,Temp),
2508 append_dcut(Temp,RInvars,Invars),
2509 append_dcut(PIsOfSorts,AIsOfSorts,SortsTemp),
2510 append_dcut([is_of_sort(Obj,Type)|SortsTemp],RIsOfSorts,IsOfSorts).
2511
2512propsInvars([],[],[],[]).
2513propsInvars([Prop|Props],[Prop|Rest],IsOfSorts,FProps) :-
2514 isInvariant(Prop),
2515 !,
2516 propsInvars(Props,Rest,IsOfSorts,FProps).
2517propsInvars([is_of_sort(X,Y)|Props],InVars,[is_of_sort(X,Y)|IsOfSorts],FProps):-
2518 !,
2519 propsInvars(Props,InVars,IsOfSorts,FProps).
2520
2521propsInvars([Pred|Props],Rest,IsOfSorts,[Pred|FProps]) :-
2522 propsInvars(Props,Rest,IsOfSorts,FProps).
2523
2524isInvariant(Prop) :-
2525 atomic_invariantsC(Invars),
2526 functor(Prop,Name,Arity),
2527 createVarList(Arity,VN),
2528 Pred =.. [Name | VN],
2529 member(Pred,Invars).
2530
2534
2535chooseVals([],_,_,[]).
2536
2537chooseVals([Type,Var|TypeVars],NEs,InVars,Vals) :-
2538 ground(Var),
2539 !,
2540 chooseVals(TypeVars,NEs,InVars,Vals).
2541
2542chooseVals([Type,Var|TypeVars],NEs,InVars,[Var|Vals]) :-
2543 objectsOfSort(Type,AllVals),
2544 member(Var,AllVals),
2545 chooseVals(TypeVars,NEs,InVars,Vals).
2552assert_sort_objects :-
2553 objectsC(Type,Objects),
2554 assert(objectsOfSort(Type,Objects)),
2555 fail.
2556
2557assert_sort_objects :-
2558 sorts(Type,SubTypes),
2559 Type \== primitive_sorts,
2560 Type \== non_primitive_sorts,
2561 all_objects(Type,Objs),
2562 assert(objectsOfSort(Type,Objs)),
2563 fail.
2564
2565assert_sort_objects.
2566
2567all_objects(Type,Objs) :-
2568 objectsC(Type,Objs),
2569 !.
2570all_objects(Type,Objs) :-
2571 sorts(Type,SubSorts),
2572 !,
2573 collect_subsort_objects(SubSorts,Objs).
2574
2575collect_subsort_objects([],[]).
2576collect_subsort_objects([Sort|Rest],Objs ) :-
2577 all_objects(Sort,SortObjs),
2578 !,
2579 collect_subsort_objects(Rest,RestObjs),
2580 append_dcut(SortObjs,RestObjs,Objs).
2581
2582obeysNEs([]).
2583
2584obeysNEs([ne(V1,V2)|Rest]) :-
2585 V1 \== V2,
2586 obeysNEs(Rest).
2587
2588obeysInVars([]).
2589obeysInVars([Prop|Rest]) :-
2590 atomic_invariantsC(Invars),
2591 member(Prop,Invars),
2592 !.
2593
2597
2598
2600
2601prettyPrintOp(gOperator(No,Par,Op)) :-
2602 write('gOperator('),
2603 write(No),write(','),
2604 write(Par),write(','),nl,
2605 writeOp(4,Op),
2606 !.
2607
2608writeOp(TabVal,operator(Name,Prev,Nec,Cond)) :-
2609 tab(TabVal),
2610 write('operator('),write(Name),write(','),nl,
2611 tab(8),write('% Prevail'),nl,
2612 tab(8),write('['),nl,
2613 writePrevailLists(8,Prev),
2614 tab(8),write('],'),nl,
2615 tab(8),write('% Necessary'),nl,
2616 tab(8),write('['),nl,
2617 writeChangeLists(10,Nec),
2618 tab(8),write('],'),nl,
2619 tab(8),write('% Conditional'),nl,
2620 tab(8),write('['),nl,
2621 writeChangeLists(10,Cond),
2622 tab(8),write('])).'),nl.
2623
2624writePropList(TabVal,[]) :-
2625 tab(TabVal),
2626 write('[]').
2627
2628writePropList(TabVal,[ne(_,_)|Props]) :-
2629 !,
2630 writePropList(Indent,Props).
2631
2632writePropList(TabVal,[Prop|Props]) :-
2633 atomic_invariantsC(Invars),
2634 member(Prop,Invars),
2635 writePropList(TabVal,Props).
2636
2637writePropList(TabVal,[Prop|Props]) :-
2638 tab(TabVal),
2639 write('['),
2640 write(Prop),
2641 Indent is TabVal + 1,
2642 writePList(Indent,Props).
2643
2644writePList(TabVal,[]) :-
2645 nl,
2646 tab(TabVal),
2647 write(']').
2648
2649writePList(TabVal,[ne(_,_)]) :-
2650 !,
2651 nl,
2652 tab(TabVal),
2653 write(']').
2654
2655writePList(TabVal,[Prop]) :-
2656 atomic_invariantsC(Invars),
2657 member(Prop,Invars),
2658 !,
2659 nl,
2660 tab(TabVal),
2661 write(']').
2662
2663writePList(TabVal,[Prop]) :-
2664 write(','),
2665 nl,
2666 tab(TabVal),
2667 write(Prop),
2668 write(']').
2669
2670writePList(TabVal,[ne(_,_),P2|Rest]) :-
2671 !,
2672 writePList(TabVal,[P2|Rest]).
2673
2674writePList(TabVal,[Prop,P2|Rest]) :-
2675 atomic_invariantsC(Invars),
2676 member(Prop,Invars),
2677 !,
2678 writePList(TabVal,[P2|Rest]).
2679
2680writePList(TabVal,[P1,P2|Rest]) :-
2681 write(','),
2682 nl,
2683 tab(TabVal),
2684 write(P1),
2685 writePList(TabVal,[P2|Rest]).
2686
2687writeChangeLists(_,[]).
2688
2689writeChangeLists(TabVal,[sc(Type,Obj,(Req => Add))|Rest]) :-
2690 tab(TabVal),
2691 write('sc('),write(Type),write(','),write(Obj),write(',('),nl,
2692 Indent is TabVal + 12,
2693 writePropList(Indent,Req),
2694 nl,
2695 tab(Indent),
2696 write('=>'),
2697 nl,
2698 writePropList(Indent,Add),
2699 write('))'),writeComma(Rest),
2700 nl,
2701 writeChangeLists(TabVal,Rest).
2702
2703writeComma([]).
2704writeComma(_) :-
2705 write(',').
2706
2707writePrevailLists(_,[]).
2708
2709writePrevailLists(TabVal,[se(Type,Obj,Props)|Rest]) :-
2710 tab(TabVal),
2711 write('se('),write(Type),write(','),write(Obj),write(','),nl,
2712 Indent is TabVal + 12,
2713 writePropList(Indent,Props),
2714 write(')'),writeComma(Rest),
2715 nl,
2716 writePrevailLists(TabVal,Rest).
2717
2718
2719assert_is_of_sort :-
2720 objectsOfSort(Type,Objects),
2721 member(Obj,Objects),
2722 assert_is_of_sort1(Type,Obj),
2723 fail.
2724assert_is_of_sort :-
2725 objectsC(Type,Objects),
2726 member(Obj,Objects),
2727 assert_is_of_primitive_sort(Type,Obj),
2728 fail.
2729assert_is_of_sort.
2730
2731assert_is_of_sort1(Type,Obj):-
2732 assert(is_of_sort(Obj,Type)),!.
2733assert_is_of_primitive_sort(Type,Obj):-
2734 assert(is_of_primitive_sort(Obj,Type)),!.
2735
2738prim_substate_class:-
2739 substate_classes(Sort,Obj,Substate),
2740 find_prim_sort(Sort,PS),
2741 assert_subclass(PS,Obj,Substate),
2742 fail.
2743prim_substate_class:-
2744 collect_prim_substates.
2745
2746assert_subclass([],Obj,Substate).
2747assert_subclass([HS|TS],Obj,Substate):-
2748 assert(gsstates(HS,Obj,Substate)),
2749 assert_subclass(TS,Obj,Substate).
2750
2751collect_prim_substates:-
2752 gsstates(Sort,Obj,_),
2753 setof(SStates,gsstates(Sort,Obj,SStates),GSStates),
2754 retractall(gsstates(Sort,Obj,_)),
2755 all_combined(GSStates,GSStates0),
2756 assert(gsubstate_classes(Sort,Obj,GSStates0)),
2757 fail.
2758collect_prim_substates.
2759
2760all_combined(SStates,CSStates):-
2761 xprod(SStates,CSStates1),
2762 flat_interal(CSStates1,CSStates),!.
2763
2764flat_interal([],[]):-!.
2765flat_interal([HSS1|TSS1],[HSS|TSS]):-
2766 flatten(HSS1,[],HSS),
2767 flat_interal(TSS1,TSS),!.
2768
2771xprod(A,B,C) :-
2772 xprod([A,B],C) .
2773
2774xprod([],[]).
2775xprod(A,E) :-
2776 xprod(A,B,C,D) ,
2777 F =..[^,C,D] ,
2778 call(setof(B,F,E)) .
2779
2780xprod([X],[A],A,member(A,X)) .
2781xprod([X,Y],[A,B],C,(D,E)) :-
2782 C =..[^,A,B] ,
2783 D =..[member,A,X] ,
2784 E =..[member,B,Y] .
2785xprod([X|Y],[A|E],D,(F,G)) :-
2786 D =..[^,A,C] ,
2787 F =..[member,A,X] ,
2788 xprod(Y,E,C,G).
2789
2790
2791:-retractall(solution_file(_)). 2792:-asserta(solution_file(user)). 2793
2796
2797
2798
2799lws:- listing(ocl:[method,
2800operator,implied_invariant,atomic_invariants,inconsistent_constraint,predicates,objects,substate_classes,sorts,domain_name,planner_task_slow,planner_task,
2801htn_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,
2802objectsOfSort,atomic_invariantsC,objectsD,objectsC,gOperator,operatorC,opParent,methodC,is_of_sort,is_of_primitive_sort,temp_assertIndivConds]).
2803
2804lws(F):-tell(F),lws,told.
2805
2806:-export(rr/0). 2807:-export(rr1/0). 2808rr:- test_ocl('domains_ocl/chameleonWorld.ocl').
2809rr1:- test_ocl('domains_ocl/translog.ocl').
2810:- fixup_exports.
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 % */