htncode

% 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 % */

12:-module(htncode,[]). 13 14 15:-multifile(user:push_env_ctx/0). 16:-dynamic(user:push_env_ctx/0). 17 18/* ***********************************/ 19/* Douglas Miles 2005, 2010, 2014 */ 20/* Denton, TX */ 21/* ***********************************/ 22 23 24 25% [Required] Load the Logicmoo Library Utils 26:- ensure_loaded(library(logicmoo_common)). 27:- ensure_loaded(library(planner_api)). 28:- use_module(library(logicmoo_planner)). 29 30:- kb_shared(baseKB:mpred_prop/3). 31 32:- ensure_loaded(library(logicmoo/util_structs)). 33:- ensure_loaded(library(logicmoo/util_bb_env)). 34:- prolog_load_context(file,File),ain(user:env_source_file(File)). 35 36:-op(500,fx,env_call). 37/* htncode.pl */ 38 39/* ***********************************/ 40/* Donghong Liu */ 41/* University of Huddersfield */ 42/* September 2002 */ 43/* **********************************/ 44 45:- style_check(-singleton). 46:-use_module(library(system)). 47 48/*********************** initialisation**************/ 49:- dynamic op_num/1. 50:- dynamic sum/1. 51%:- dynamic initial_node/1, final_node/1. 52:- dynamic methodC/7, operatorC/5, my_stats/1. 53%%:- dynamic node/7,,solved_node/5. 54:- dynamic tp_node/6,tn/6. 55:- dynamic solved_node/2. 56:- dynamic closed_node/6. 57:- dynamic gsubstate_classes/3. 58:- dynamic current_num/2. 59:- dynamic produce/4,goal_related/1. %%,achieved_goal/1. 60%:- unknown(error,fail). 61:- dynamic gsstates/3,gpred/2. 62% for boot.. 63:- dynamic kill_file/1,solution_file/1. 64% 65:- op(100,xfy,'=>'). 66 67:- dynamic htn_task/3. 68:- multifile htn_task/3. 69:- dynamic planner_task/3. 70htn_task(Id,Goal,Init):-planner_task(Id,Goal,Init). 71 72% The following elements are expected in the sort engineered domain model 73% 74:-dynamic sorts/2, 75 objects/2, 76 predicates/1, 77 atomic_invariants/1, 78 substate_classes/3, 79 method/6, 80 operator/4, 81 inconsistent_constraint/1. 82 83% ss class expressions 84% invariants: 85% atomic invariants 86% -ve invariants 87% +ve invariants 88% operators 89% foo. 90 91op_num(0). 92my_stats(0). 93solution_file(fred). 94 95%:-set_prolog_flag(unknown,fail). 96solve(Id) :- 97 htn_task(Id,Goal,Init), 98 once(planner_interface(Goal,Init,Sol,_)), 99% solution_file(F), 100% gensym_num(F,Id,TRF), 101% tell(user), 102% write('TASK '),write(Id),nl, 103% write('SOLUTION'),nl, 104% display_sol(Sol), 105% write('END FILE'),nl, 106% told, 107 clean. 108 109display_sol([]). 110display_sol([H|T]) :- 111 write(H), 112 nl, 113 display_sol(T). 114 115clean:- 116 retractall(op_num(_)), 117 retractall(current_num(_,_)), 118 retractall(node(_,_,_,_,_)), 119 retractall(tn(_,_,_,_,_,_)), 120 retractall(gpredicates(_,_)), 121 retractall(gsubstate_classes(_,_,_)), 122 retractall(methodC(_,_,_,_,_,_,_)), 123 retractall(operatorC(_,_,_,_,_)), 124 retractall(goal_related(_)), 125 retractall(produce(_,_,_,_)), 126 retractall(solved_node(_,_)), 127 retractall(tp_node(_,_,_,_,_,_)), 128 retractall(closed_node(_,_,_,_,_,_)), 129 retractall(score_list(_)), 130 assert(op_num(0)), 131 assert(my_stats(0)). 132 133planner_interface(G,I, SOLN,NODES):- 134 time(ground_hierarchy), 135 change_op_representation, 136 find_relate_state, 137 retract(op_num(_)), 138 assert(op_num(0)), 139 statistics(runtime,[_,Time]), 140 (retract(my_stats(_)) ; true), 141 assert(my_stats(Time)), 142 make_problem_into_node(I, G, Node), 143 assert(Node), 144 start_solve(SOLN,NODES). 145planner_interface(G,I, SOLN,NODES):- 146 tell(user),nl,write('failure in initial node'),!. 147 148 149 150/******************** HP ADT *********************/ 151 152% node(Name, Precond ,Decomps, Temp, Statics) 153getN_name(node(Name, _, _, _,_), Name). 154getN_pre(node(_,Pre, _, _, _), Pre). 155getN_decomp(node(_, _, Decomp,_,_), Decomp). 156getH_temp(node(_, _, _,Temps, _), Temps). 157getN_statics(node(_,_,_,_,Statics), Statics). 158 159%Ron 21/9/01 - Try to give a closedown method 160start_solve(SOLN,NODES):- 161 kill_file(Kill), 162 file_exists(Kill). 163% write('Found kill file'),nl. 164 165start_solve(Sol,OPNUM):- 166 retract(final_node(Node)), 167 retractall(current_num(_,_)), 168 getN_statics(Node,Statics), 169 statics_consist(Statics), 170 extract_solution(Node,Sol,SIZE), 171 statistics(runtime,[_,CP]), 172 TIM is CP/1000, 173 retract(op_num(OPNUM)), 174 assert(op_num(0)), 175 nl, nl, write('CPU Time = '),write(CP),nl, 176 write('TIME TAKEN = '),write(TIM), 177 write(' SECONDS'),nl, 178 write('Solution SIZE = '),write(SIZE),nl, 179 write('Operator Used = '),write(OPNUM),nl, 180 write('Solution:\n '),writeq(Sol),nl, 181 write('***************************************'), 182 assert(time_taken(CP)), 183 assert(soln_size(SIZE)), 184 assert(plan_used(OPNUM)), 185 retractall(tn(_,_,_,_,_,_)),!. 186 187start_solve(Sol,OPNUM):- 188 select_node(Node), 189% nl,write('processing '),write(Node),nl, 190 % expand/prove its hps 191 process_node(Node), 192 start_solve(Sol,OPNUM),!. 193start_solve(Sol,OPNUM):- 194 tell(user), write('+++ task FAILED +++'), 195 clean. 196 197/******************************** MAIN LOOP **********/ 198 199% expand a node.. 200process_node(Node) :- 201 getN_name(Node, Name), 202 getN_pre(Node, Pre), 203 getN_decomp(Node, Dec), 204 getH_temp(Node, Temps), 205 getN_statics(Node, Statics), 206 expand_decomp(Dec,Pre,Post,Temps,Temp1,Statics,Statics1,Dec1), 207 statics_consist(Statics), 208 assert_node(Name,Pre,Dec1,Temp1,Statics1). 209 210assert_node(Name,Pre,Decomp,Temp,Statics):- 211 all_HP_expanded(Decomp), 212 assert(final_node(node(Name,Pre,Decomp,Temp,Statics))),!. 213assert_node(Name,Pre,Dec,Temp,Statics):- 214 gensym_special(root,SYM), 215 assert(node(SYM,Pre,Dec,Temp,Statics)),!. 216 217all_HP_expanded([]):-!. 218all_HP_expanded([step(HPid,Name,_,_,exp(TN))|THPS]):- 219 all_HP_expanded(THPS),!. 220/************ expand every step *********************/ 221expand_decomp([],Post,Post,Temp,Temp,Statics,Statics,[]):-!. 222%0-1 if the step has expand already, get the state change, go to next 223expand_decomp([step(HPid,Name,Pre0,Post0,exp(TN))|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,[step(HPid,Name,State1,Post1,exp(TN))|Decomp1]):- 224 state_achieved(Pre0,Pre,State1), 225 state_change(State1,Pre0,Post0,Post1), 226 statics_consist(Statics), 227 expand_decomp(Decomp,Post1,Post,Temp,Temp1,Statics,Statics1,Decomp1),!. 228 229%0-2. if it is an achieve action 230expand_decomp([step(HPid,ACH,Pre0,Post0,unexp)|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,Decomp1):- 231 ACH=..[achieve|_], 232 state_achieved(Pre0,Pre,State), 233 statics_consist(Statics), 234 expand_decomp_ach([step(HPid,ACH,State,Post0,unexp)|Decomp],State,Post,Temp,Temp1,Statics,Statics1,Decomp1),!. 235/* 236% 1. if the step's Name is match a exist TN also Pre meet, return TN 237% tn(Tn0,Name,Pre0,Post0,Temp0,Decomp)is a task network 238% which was generated by previous process, 239% it has been decomposed to ordered primitive operators 240% and has all states changes defiend 241expand_decomp([step(HPid,Name,undefd,undefd,unexp)|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,[step(HPid,Name,Pre0,Post0,exp(Tn0))|Decomp1]):- 242 tn(Tn0,Name,Pre0,Post0,Temp0,Decomp0), 243 state_achieved(Pre0,Pre,State1), 244 statics_consist(Statics), 245 state_change(State1,Pre0,Post0,State), 246% nl,write('step '),write(HPid), 247 retract(op_num(N)), 248 N1 is N+1, 249 assert(op_num(N1)), 250% write('can be expand by tn '),write(Tn0),nl, 251 expand_decomp(Decomp,State,Post,Temp,Temp1,Statics,Statics1,Decomp1),!. 252*/ 253% 2. if HP's name meet an method, 254% and it's precondition and achieve goals are achieved 255% expand it and make it to that TNs

261expand_decomp([step(HPid,Name,undefd,undefd,unexp)|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,[step(HPid,Name,Pre0,Post0,exp(TN))|Decomp1]):- 262 methodC(Name,Pre0,Post0,Statics0,Temp0,achieve(ACH),Dec0), 263 append_cut(Statics0,Statics,Statics2), 264 statics_consist(Statics2), 265 remove_unneed(Statics2,[],Statics3), 266 state_achieved(Pre0,Pre,State1), 267% state_achieved(ACH,State1,State11), 268 statics_consist(Statics3), 269 apply_method1(HPid,TN,Name,State1,Pre0,ACH,Post0,State,Statics3,Temp0,Dec0), 270% apply_method(HPid,TN,Name,State11,Pre0,Post0,State,Statics21,Temp0,Dec0), 271% changed here for if there are too many unordered tasks 272% apply_method1 is directly apply method even it's achieve goal not achieved 273% nl,write('step '),write(HPid), 274 retract(op_num(N)), 275 N1 is N+1, 276 assert(op_num(N1)), 277% write('can be expand by method '),write(Name),nl, 278 expand_decomp(Decomp,State,Post,Temp,Temp1,Statics2,Statics1,Decomp1),!. 279 280 281 282 283 284 285 286 287% 3. if HP's name and it's Pre meet an operator, return operator's name 288expand_decomp([step(HPid,Name,undefd,undefd,unexp)|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,[step(HPid,Name,Pre0,Post0,exp(Name))|Decomp1]):- 289 operatorC(Name,Pre0,Post0,Cond,Statics0), 290 append_cut(Statics0,Statics,Statics2), 291 statics_consist(Statics2), 292 remove_unneed(Statics2,[],Statics21), 293 state_achieved(Pre0,Pre,State1), 294 state_change(State1,Pre0,Post0,State2), 295 cond_state_change(State2,Cond,State), 296% nl,write('step '),write(HPid), 297 statics_consist_instance(Statics0), 298% write('can be expand by operator '),write(Name),nl, 299 retract(op_num(N)), 300 N1 is N+1, 301 assert(op_num(N1)), 302 expand_decomp(Decomp,State,Post,Temp,Temp1,Statics21,Statics1,Decomp1),!. 303 304% 4. get another step which matchs and not after it before it to give a try 305expand_decomp([step(HP,N,Pre0,Post0,unexp)|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,Decomp1):- 306 get_another_step(step(HP2,N2,Pre2,Post2,Exp),Pre,Statics, 307 HP,Temp,Temp2,Decomp,Decomp2), 308 expand_decomp([step(HP2,N2,Pre2,Post2,Exp),step(HP,N,Pre0,Post0,unexp)|Decomp2],Pre,Post,Temp2,Temp1,Statics,Statics1,Decomp1). 309 310/* 311% 5. if HP's name meet an method, 312% and it's precondition achieved 313% but failed to match achieve_goals 314% expand it and make it to that TNs 315expand_decomp([step(HPid,Name,undefd,undefd,unexp)|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,[step(HPid,Name,Pre0,Post0,exp(TN))|Decomp1]):- 316 methodC(Name,Pre0,Post0,Statics0,Temp0,achieve(ACH),Dec0), 317 append_cut(Statics0,Statics,Statics2), 318 statics_consist(Statics2), 319 remove_unneed(Statics2,[],Statics3), 320 state_achieved(Pre0,Pre,State1), 321 statics_consist(Statics3), 322 apply_method1(HPid,TN,Name,State1,Pre0,ACH,Post0,State,Statics3,Temp0,Dec0), 323 % need to expand achieve goals first 324 expand_decomp(Decomp,State,Post,Temp,Temp1,Statics3,Statics1,Decomp1),!. 325 326% 6. if all above failed 327% get another step which matchs and not after it before it to give a try 328expand_decomp([step(HP,N,Pre0,Post0,unexp)|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,Decomp1):- 329 get_another_step(step(HP2,N2,Pre2,Post2,Exp),Pre,Statics, 330 HP,Temp,Temp2,Decomp,Decomp2), 331 expand_decomp([step(HP2,N2,Pre2,Post2,Exp),step(HP,N,Pre0,Post0,unexp)|Decomp2],Pre,Post,Temp2,Temp1,Statics,Statics1,Decomp1). 332*/ 333% Else fail expand 334 335% get another step which is not after it before it 336get_another_step(A,Pre,Statics,HP,Temp,Temp1,[],Dec2):-fail. 337get_another_step(step(HP2,Name2,Pre2,Post2,Exp),Pre,Statics,HP,Temp,[before(HP2,HP)|Temp],Dec,Dec2):- 338 member(step(HP2,Name2,Pre2,Post2,Exp),Dec), 339 not(necessarily_before(HP,HP2, Temp)), 340 state_achieved(Pre2,Pre,_), 341 statics_consist(Statics), 342 list_take(Dec,[step(HP2,Name2,Pre2,Post2,Exp)],Dec2). 343 344% expand the achieve goal 345% 1.if the ACH is achieved already 346% remove it from decomposion and do the next 347expand_decomp_ach([step(HPid,ACH,Pre,Post0,unexp)|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,Decomp1):- 348 state_achieved(Post0,Pre,State), 349 statics_consist(Statics), 350% nl,write('step '),write(HPid), 351% write('is already achieved'),nl, 352 remove_temp(Temp,HPid,Temp,Temp2), 353 expand_decomp(Decomp,State,Post,Temp2,Temp1,Statics,Statics1,Decomp1),!. 354 355% 2.take out the already achieved states before expanding 356expand_decomp_ach([step(HPid,ACH,Pre,Post0,unexp)|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,[step(HPid,ACH,Pre,Post0,exp(TN))|Decomp1]):- 357 expand_hp(HPid,TN,ACH,Pre,Post0,State,Statics,Statics2), 358 expand_decomp(Decomp,State,Post,Temp,Temp1,Statics2,Statics1,Decomp1),!. 359 360% directly achieve HP's Pre and Post by operator,method or tn 361expand_hp(HPid,TN,ACH,Pre,Post,State,Statics,Statics1):- 362 direct_expand_hp(HPid,TN,ACH,Pre,Post,State,Statics,Statics1),!. 363% else, nothing directly can achieve HP's Pre and Post 364% assert a temporely node for forward search 365% tp_node(Name, Precond, Postcond, Statics,Score,Temp,Decomps) 366expand_hp(HPid,TN,ACH,Pre,Post,State,Statics,Statics1):- 367 make_to_steps1(Pre,Post,Steps), 368 gensym_special(tp,TP), 369 get_all_related_goal(Post), 370 get_score(100,[],Steps,Score), 371 assert(tp_node(TP,Pre,Post,Statics,Score,Steps)), 372 fwsearch(TN,Statics1,State), 373 clean_temp_nodes. 374 375% make the achieve goal states [se(..),se(..),..] to separate steps 376% remove states that have been achieved by precondition 377% by same them for declobber 378make_to_steps1(Pre,[],[]):-!. 379make_to_steps1(Pre,[se(Sort,Obj,SE)|Post],Steps):- 380 state_achieved([se(Sort,Obj,SE)],Pre,_), 381 make_to_steps1(Pre,Post,Steps),!. 382make_to_steps1(Pre,[se(Sort,Obj,SE)|Post],[step(HP,achieve(se(Sort,Obj,SE)),undefd,[se(Sort,Obj,SE)],unexp)|Steps]):- 383 objects(Sort,Objls),%Sort is primitive 384 gensym_special(hp,HP), 385 make_to_steps1(Pre,Post,Steps),!. 386make_to_steps1(Pre,[se(Sort,Obj,SE)|Post],[step(HP,achieve(se(Sort,Obj,SE)),undefd,[se(Sort,Obj,SE)],unexp)|Steps]):- 387 var(Obj), 388 gensym_special(hp,HP), 389 make_to_steps1(Pre,Post,Steps),!. 390make_to_steps1(Pre,[se(SortN,Obj,SE)|Post],[step(HP,achieve(se(PSort,Obj,SE)),undefd,[se(PSort,Obj,SE)],unexp)|Steps]):- 391 not(var(Obj)), 392 find_prim_sort(SortN,PSortls), 393 member(PSort,PSortls), 394 objects(PSort,Objls), 395 member(Obj,Objls), 396 gensym_special(hp,HP), 397 make_to_steps1(Pre,Post,Steps),!. 398 399 400% get all the states that can achieve the goal state 401get_all_related_goal(Goal):- 402 retractall(goal_related(_)), 403 assert(goal_related(Goal)), 404 get_all_related_goal1(Goal,States), 405 retractall(goal_related(_)), 406 assert(goal_related(States)),!. 407% tell(user),write(States),nl,told,!. 408 409get_all_related_goal1([],States):- 410 setof(State,goal_related(State),States1), 411 set_flatten(States1,[],States),!. 412get_all_related_goal1([se(Sort,Obj,SE)|Rest],States):- 413 produce(se(Sort,Obj,SE1),A,OPre,ST), 414 state_achieved([se(Sort,Obj,SE)],[se(Sort,Obj,SE1)],_), 415 retract(goal_related(List)), 416 set_append_e(List,OPre,List1), 417 assert(goal_related(List1)), 418 fail. 419get_all_related_goal1([se(SortN,Obj,SE)|Rest],States):- 420 nonvar(Obj), 421 objects(Sort,Objls), 422 not(not(member(Obj,Objls))), 423 produce(se(Sort,Obj,SE1),A,OPre,ST), 424 state_achieved([se(Sort,Obj,SE)],[se(Sort,Obj,SE1)],_), 425 retract(goal_related(List)), 426 set_append_e(List,OPre,List1), 427 assert(goal_related(List1)), 428 fail. 429get_all_related_goal1([se(SortN,Obj,SE)|Rest],States):- 430 var(Obj), 431 find_prim_sort(SortN,Sortls), 432 member(Sort,Sortls), 433 produce(se(Sort,Obj,SE1),A,OPre,ST), 434 state_achieved([se(Sort,Obj,SE)],[se(Sort,Obj,SE1)],_), 435 retract(goal_related(List)), 436 set_append_e(List,OPre,List1), 437 assert(goal_related(List1)), 438 fail. 439get_all_related_goal1([se(Sort,Obj,SE)|Rest],States):- 440 get_all_related_goal1(Rest,States). 441 442% find out the difference of Pre and Post0 to expand 443% if only one Obj in Post, don't do check. 444take_out_achieved(Pre,[se(Sort,Obj,SE)],[],[se(Sort,Obj,SE)]):-!. 445take_out_achieved(Pre,[],Post,Post):-!. 446% Pre conditions are all instantiated states 447% only Post conditions have variables 448take_out_achieved(Pre,[se(Sort,Obj,ST)|Post],Post0,Post1):- 449 var(Obj), 450 append(Post0,[se(Sort,Obj,ST)],Post2), 451 take_out_achieved(Pre,Post,Post2,Post1),!. 452take_out_achieved(Pre,[se(Sort,Obj,ST)|Post],Post0,Post1):- 453 member(se(Sort,Obj,ST1),Pre), 454 append_diff(Sort,Obj,ST,ST1,Post0,Post2), 455 list_take(Pre,[se(Sort,Obj,ST1)],Pre2), 456 take_out_achieved(Pre2,Post,Post2,Post1),!. 457 458% append only the different one 459append_diff(Sort,Obj,ST,ST1,Post0,Post0):- 460 not_conflict(Sort,Obj,ST,ST1,STN),!. 461append_diff(Sort,Obj,ST,ST1,Post0,Post1):- 462 append(Post0,[se(Sort,Obj,ST)],Post1),!. 463% --------------------------------------------------- 464 465%1. if an achieve action meets an TN Pre and post meet 466direct_expand_hp(HPid,Tn0,ACH,Pre,Post,Pre1,Statics,Statics):- 467 tn(Tn0,Name,Pre0,Post0,Temp0,Decomp0), 468 state_achieved(Pre0,Pre,State1), 469 state_achieved(Post,Post0,_), 470 state_change(State1,Pre0,Post0,Pre1), 471 statics_consist(Statics), 472% nl,write('step '),write(HPid), 473 retract(op_num(N)), 474 N1 is N+1, 475 assert(op_num(N1)),!. 476% write('can be expand by tn '),write(Tn0),nl,!. 477 478%2. if an action's name meets is an operator's, 479% return 480direct_expand_hp(HPid,Name,Name,Pre,Post,State,Statics,Statics1):- 481 operatorC(Name,Pre0,Post0,Cond,Statics0), 482 append_cut(Statics0,Statics,Statics1), 483 statics_consist(Statics11), 484 remove_unneed(Statics11,[],Statics1), 485 post_instant(Post0,Cond,Statics1,Post), 486 state_achieved(Pre0,Pre,State1), 487 state_change(State1,Pre0,Post0,State2), 488 cond_state_change(State2,Cond,State3), 489 state_achieved(Post,State3,State), 490 statics_consist_instance(Statics0), 491% nl,write('step '),write(HPid), 492% write('can be expand by operator '),write(Name),nl, 493 retract(op_num(N)), 494 N1 is N+1, 495 assert(op_num(N1)),!. 496 497%2. if an achieve action meets an operator's Pre and post meet, 498% return 499direct_expand_hp(HPid,Name,ACH,Pre,Post,State,Statics,Statics1):- 500 operatorC(Name,Pre0,Post0,Cond,Statics0), 501 append_cut(Statics0,Statics,Statics2), 502 statics_consist(Statics2), 503 remove_unneed(Statics2,[],Statics1), 504 post_instant(Post0,Cond,Statics1,Post), 505 state_achieved(Pre0,Pre,State1), 506 state_change(State1,Pre0,Post0,State2), 507 cond_state_change(State2,Cond,State3), 508 state_achieved(Post,State3,State), 509 statics_consist(Statics1), 510% nl,write('step '),write(HPid), 511% write('can be expand by operator '),write(Name),nl, 512 retract(op_num(N)), 513 N1 is N+1, 514 assert(op_num(N1)),!. 515 516%3. if an achieve action meets a method's pre and post, 517% expand it and make it to that TNs 518direct_expand_hp(HPid,TN,ACH,Pre,Post,State1,Statics,Statics1):- 519 methodC(Name,Pre0,Post0,Statics0,Temp0,achieve(ACH0),Dec0), 520 append_cut(Statics0,Statics,Statics2), 521 statics_consist(Statics2), 522 remove_unneed(Statics2,[],Statics1), 523 post_instant(Post0,[],Statics1,Post), 524 state_achieved(Pre0,Pre,Pre1), 525 state_achieved(Post,Post0,Post01), 526 statics_consist(Statics1), 527 apply_method1(HPid,TN,Name,Pre1,Pre0,ACH0,Post01,State1,Statics1,Temp0,Dec0),!. 528 529% apply_method/10: apply method in the HP 530% when the method name's precondition and achieve goals are achieved 531% no extra operators are bring in while expansion 532apply_method(HPid,TN,Name,Pre,Pre0,Post0,State,Statics,Temp,Dec):- 533 make_dec0(HPid,Dec,Temp,Dec0,Temp0), 534 expand_method(Dec0,Pre,Post,Temp0,Temp1,Statics,Statics1,Dec1), 535 state_achieved(Post0,Post,State), 536 statics_consist(Statics), 537% nl,write('step '),write(HPid), 538% write('can be expand by method '),write(Name),nl, 539 retract(op_num(N)), 540 N1 is N+1, 541 assert(op_num(N1)), 542 make_tn(TN,Name,Pre,State,Temp1,Dec1),!. 543 544make_dec0(HPid,Dec,Temp,Dec0,Temp0):- 545 make_dec01(HPid,1,Dec,Dec0), 546 change_temp(HPid,Temp,[],Temp0),!. 547make_dec1(HPid,Pre,ACH,Statics,Temp,Dec,Temp1,Dec1):- 548 state_achieved(ACH,Pre,_), 549 make_dec01(HPid,1,Dec,Dec1), 550 change_temp(HPid,Temp,[],Temp1). 551make_dec1(HPid,Pre,ACH,Statics,Temp,Dec,[before(STID0,STID1)|Temp1],[step(STID0,achieve(ACH),Pre,ACH,unexp)|Dec1]):- 552 gensym_num(HPid,0,STID0), 553 gensym_num(HPid,1,STID1), 554 make_dec01(HPid,1,Dec,Dec1), 555 change_temp(HPid,Temp,[],Temp1),!. 556 557make_dec01(HPid,_,[],[]):-!. 558make_dec01(HPid,Num,[HDec|TDec],[step(STID,HDec,undefd,undefd,unexp)|TDec0]):- 559 operatorC(HDec,_,_,_,_), 560 gensym_num(HPid,Num,STID), 561 Num1 is Num + 1, 562 make_dec01(HPid,Num1,TDec,TDec0). 563make_dec01(HPid,Num,[HDec|TDec],[step(STID,HDec,undefd,undefd,unexp)|TDec0]):- 564 methodC(HDec,_,_,_,_,_,_), 565 gensym_num(HPid,Num,STID), 566 Num1 is Num + 1, 567 make_dec01(HPid,Num1,TDec,TDec0). 568 569change_temp(HPid,[],Temp2,Temp2):-!. 570change_temp(HPid,[before(N1,N2)|Temp],Temp2,[before(ST1,ST2)|Temp0]):- 571 gensym_num(HPid,N1,ST1), 572 gensym_num(HPid,N2,ST2), 573 change_temp(HPid,Temp,Temp2,Temp0),!. 574 575% expand_method/8 expand method without bring in any other operators 576% that is: all achieve goals are achieved 577expand_method([],Post,Post,Temp,Temp,Statics,Statics,[]):-!. 578expand_method([step(HPid,Name,undefd,undefd,unexp)|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,[step(HPid,Name,Pre0,Post0,exp(TN))|Decomp1]):- 579 tn(TN,Name,Pre0,Post0,Temp0,Decomp0), 580 state_achieved(Pre0,Pre,State1), 581 state_change(State1,Pre0,Post0,State), 582 statics_consist(Statics), 583% nl,write('step '),write(HPid), 584 retract(op_num(N)), 585 N1 is N+1, 586 assert(op_num(N1)), 587% write('can be expand by tn '),write(TN), 588 expand_method(Decomp,State,Post,Temp,Temp1,Statics,Statics1,Decomp1). 589expand_method([step(HPid,Name,undefd,undefd,unexp)|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,[step(HPid,Name,Pre0,Post0,exp(Name))|Decomp1]):- 590 operatorC(Name,Pre0,Post0,Cond,Statics0), 591 append_cut(Statics0,Statics,Statics2), 592 statics_consist(Statics2), 593 remove_unneed(Statics2,[],Statics21), 594 post_instant(Post0,Cond,Statics21,Post0), 595 state_achieved(Pre0,Pre,State1), 596 state_change(State1,Pre0,Post0,State2), 597 cond_state_change(State2,Cond,State3), 598 state_achieved(Post0,State3,State), 599 statics_consist_instance(Statics0), 600% nl,write('step '),write(HPid), 601% write('can be expand by operator '),write(Name),nl, 602 retract(op_num(N)), 603 N1 is N+1, 604 assert(op_num(N1)), 605 expand_method(Decomp,State,Post,Temp,Temp1,Statics21,Statics1,Decomp1). 606expand_method([step(HPid,Name,undefd,undefd,unexp)|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,[step(HPid,Name,Pre0,Post0,exp(TN))|Decomp1]):- 607 methodC(Name,Pre0,Post0,Statics0,Temp0,ACH,Dec0), 608 append_cut(Statics0,Statics,Statics2), 609 statics_consist(Statics2), 610 remove_unneed(Statics2,[],Statics21), 611 post_instant(Post0,[],Statics21,Post0), 612 state_achieved(Pre0,Pre,State1), 613 statics_consist(Statics21), 614 apply_method(HPid,TN,Name,State1,Pre0,Post0,State,Statics21,Temp0,Dec0), 615 expand_method(Decomp,State,Post,Temp,Temp1,Statics21,Statics1,Decomp1). 616% --------------------end of apply_method/10--------------------- 617 618% apply_method1/11: apply method in the HP 619% when the method name's precondition achieved 620% but need bring in operators while expansion 621apply_method1(HPid,TN,Name,Pre,Pre0,ACH,Post0,State,Statics,Temp,Dec):- 622 make_dec1(HPid,Pre,ACH,Statics,Temp,Dec,Temp2,Dec2), 623 expand_decomp(Dec2,Pre,Post,Temp2,Temp1,Statics,Statics1,Dec1), 624 state_achieved(Post0,Post,State), 625% nl,write('step '),write(HPid), 626% write('can be expand by method '),write(Name),nl, 627 retract(op_num(N)), 628 N1 is N+1, 629 assert(op_num(N1)), 630 make_tn(TN,Name,Pre,State,Temp1,Dec1),!. 631 632 633% --------------------end of apply_method1/11--------------------- 634 635% forward search for operators can't directly solved 636fwsearch(TN,ST,State):- 637 retract(solved_node(ST,step(HP,Name,Pre,State,exp(TN)))). 638fwsearch(TN,ST,State):- 639 select_tnode(tp_node(TP,Pre,Post,Statics,Score,Dec)), 640 assert(closed_node(TP,Pre,Post,Statics,Score,Dec)), 641 expand_node(Statics,Statics1,Pre,Post,Dec,[],Dec1), 642 assert_tnode(TP,Pre,Post,Statics1,Score,Dec1), 643 solved_node(_,_),%expand every possible way until find solution 644 fwsearch(TN,ST,State). 645fwsearch(TN,ST,State):- 646 tp_node(TP,Pre,Post,Statics,Score,Dec), 647 fwsearch(TN,ST,State). 648 649clean_temp_nodes:- 650 retractall(current_num(tp,_)), 651 retractall(tp_node(_,_,_,_,_,_)), 652 retractall(closed_node(_,_,_,_,_,_)),!. 653 654% expand all way possible to achieve the Post 655expand_node(Statics,Statics,Pre,Post,[],List,List):- 656 state_achieved(Post,Pre,_),!. 657expand_node(Statics,Statics1,Pre,Post,[step(HP,Name,_,Post0,unexp)|Rest],List,Dec1):- 658 state_achieved(Post0,Pre,_), 659 expand_node(Statics,Statics1,Pre,Post,Rest,List,Dec1),!. 660expand_node(Statics,Statics1,Pre,Post,[step(HP,Name,_,Post0,unexp)|Rest],List,Dec1):- 661 direct_expand_hp(HP,TN,Name,Pre,Post0,State,Statics,Statics2), 662 append(List,[step(HP,Name,Pre,State,exp(TN))],List2), 663 remove_achieved_rest(State,Statics2,Rest,Rest1), 664 make_to_steps(State,Post,Steps,Rest1), 665 append(Rest1,Steps,Rest2), 666 expand_node(Statics2,Statics1,State,Post,Rest2,List2,Dec1). 667expand_node(Statics,Statics1,Pre,Post,[step(HP,Name,_,Post0,unexp)|Rest],List,Dec1):- 668 apply_op(Statics,Statics1,[step(HP,Name,Pre,Post0,unexp)|Rest],List,Dec1). 669expand_node(Statics,Statics1,Pre,Post,[step(HP,Name,Pre0,Post0,exp(TN))|TDec],List,Dec1):- 670 append(List,[step(HP,Name,Pre0,Post0,exp(TN))],List2), 671 expand_node(Statics,Statics1,Post0,Post,TDec,List2,Dec1),!. 672 673remove_achieved_rest(State,Statics,[],[]):-!. 674remove_achieved_rest(State,Statics,[step(HP,Name,_,Post0,unexp)|Rest],Rest1):- 675 state_achieved(Post0,State,_), 676 remove_achieved_rest(State,Statics,Rest,Rest1),!. 677remove_achieved_rest(State,Statics,[HP|Rest],[HP|Rest1]):- 678 remove_achieved_rest(State,Statics,Rest,Rest1),!. 679 680/* add an operator that can achieve the goal related states*/ 681% This is only applied when it can't be directly achieved 682apply_op(Statics,Statics1,[step(HP,Name,Pre,[se(Sort,Obj,SE)],unexp)|Rest],List,Dec):- 683 produce(se(Sort,Obj,SE1),OP,OPre,ST), 684 append_cut(Statics,ST,Statics2), 685 statics_consist(Statics2), 686 remove_unneed(Statics2,[],Statics1), 687 state_achieved([se(Sort,Obj,SE)],[se(Sort,Obj,SE1)],_), 688 instantiate(OPre,Statics1), 689 not(member(step(_,OP,_,_,_),Rest)), 690 make_to_steps(Pre,OPre,Steps,Rest), 691 change_head_state(Pre,Steps,Steps1), 692 append(List,Steps1,List2), 693 append(List2,[step(HP,OP,undefd,[se(Sort,Obj,SE)],unexp)|Rest],Dec). 694% tell(user),write('+'),told. 695apply_op(Statics,Statics1,[step(HP,Name,Pre,[se(SortN,Obj,SE)],unexp)|Rest],List,Dec):- 696 find_prim_sort(SortN,PSortls), 697 member(Sort,PSortls), 698 produce(se(Sort,Obj,SE1),OP,OPre,ST), 699 append_cut(Statics,ST,Statics2), 700 statics_consist(Statics2), 701 remove_unneed(Statics2,[],Statics1), 702 state_achieved([se(Sort,Obj,SE)],[se(Sort,Obj,SE1)],_), 703 instantiate(OPre,Statics1), 704 not(member(step(_,OP,_,_,_),Rest)), 705 make_to_steps(Pre,OPre,Steps,Rest), 706 change_head_state(Pre,Steps,Steps1), 707 append(List,Steps1,List2), 708 append(List2,[step(HP,OP,undefd,[se(Sort,Obj,SE)],unexp)|Rest],Dec). 709% tell(user),write('+'),told. 710 711% make the achieve goal states [se(..),se(..),..] to separate steps 712% remove the states that have been achieved by precondition 713make_to_steps(Pre,[],[],Rest):-!. 714make_to_steps(Pre,[se(Sort,Obj,SE)|Post],Steps,Rest):- 715 state_achieved([se(Sort,Obj,SE)],Pre,_), 716 make_to_steps(Pre,Post,Steps,Rest),!. 717make_to_steps(Pre,[se(Sort,Obj,SE)|Post],Steps,Rest):- 718 member(step(_,achieve(se(Sort,Obj,SE)),_,_),Rest), 719 make_to_steps(Pre,Post,Steps,Rest),!. 720make_to_steps(Pre,[se(Sort,Obj,SE)|Post],[step(HP,achieve(se(Sort,Obj,SE)),undefd,[se(Sort,Obj,SE)],unexp)|Steps],Rest):- 721 gensym_special(hp,HP), 722 make_to_steps(Pre,Post,Steps,Rest),!. 723 724change_head_state(Pre,[step(HP,A,undefd,B,unexp)|Steps],[step(HP,A,Pre,B,unexp)|Steps]):-!. 725 726% instantiate the object in lhs states 727instantiate([],Statics). 728instantiate([se(Sort,Obj,SE)|States],Statics):- 729 nonvar(Obj), 730 instantiate(States,Statics),!. 731instantiate([se(Sort,Obj,SE)|States],Statics):- 732 ground(SE), 733 instantiate(States,Statics),!. 734instantiate([se(Sort,Obj,SE)|States],Statics):- 735 var(Obj), 736 get_sort_objects(Sort,Objls), 737 member(Obj,Objls), 738 statics_consist_instance(Statics), 739 instantiate(States,Statics). 740 741 742% select a tp_node with lowest score 743select_tnode(tp_node(HPid,Pre,Post,Statics,Score,Dec)) :- 744 retractall(score_list(LS)), 745 assert(score_list([])), 746 lowest_score(Score), 747 retract(tp_node(HPid,Pre,Post,Statics,Score,Dec)),!. 748% tell(user),nl,write('new level'),nl,told,!. 749 750% find the lowest_score of tp_node 751lowest_score(LScore):- 752 tp_node(HPid,Pre,Post,Statics,Score,Dec), 753 retract(score_list(LS)), 754 assert(score_list([Score|LS])), 755 fail. 756lowest_score(LScore):- 757 retract(score_list(D)), 758 sort(D,[LScore|SD]). 759 760:- style_check(-discontiguous). 761% assert tp_node if all HP expand, assert solved_node 762assert_tnode(TP,Pre,Post,Statics,Score1,Dec):- 763 all_HP_expanded(Dec), 764 combine_exp_steps2(Dec,OneDec), 765 assert(solved_node(Statics,OneDec)),!. 766 767combine_exp_steps2([OneDec],OneDec):-!. 768combine_exp_steps2([Dec1,Dec2|Rest],OneDec):- 769 combine_steps1(Dec1,Dec2,OneDec1), 770 combine_exp_steps2([OneDec1|Rest],OneDec),!. 771% else combine the steps of expanded steps 772% make it to [step(_,...,exp()),step(_,...,unexp)] 773% that makes possible to find the repeated nodes 774% also makes possible to make operator chains for later use 775assert_tnode(TP,Pre,Post,Statics,Score,Dec):- 776 combine_exp_steps(Dec,ExpDec,UnexpDec), 777 assert_tnode1(TP,Pre,Post,Statics,Score,ExpDec,UnexpDec),!. 778 779:- style_check(+discontiguous). 780 781assert_tnode1(TP,Pre,Post,Statics,Score,ExpDec,UnexpDec):- 782 existing_node(ExpDec,UnexpDec,Statics). 783assert_tnode1(TP,Pre,Post,Statics,Score,ExpDec,UnexpDec):- 784 get_score(Score,ExpDec,UnexpDec,Score1), 785 gensym_special(tp,TP1), 786 append(ExpDec,UnexpDec,Dec), 787 assert(tp_node(TP1,Pre,Post,Statics,Score1,Dec)),!. 788 789% combine the expanded steps to one 790combine_exp_steps([step(A,B,C,D,unexp)|Rest],[],[step(A,B,C,D,unexp)|Rest]):-!. 791combine_exp_steps([step(A,B,C,D,exp(TN)),step(A1,B1,C1,D1,unexp)|Rest],[step(A,B,C,D,exp(TN))],[step(A1,B1,C1,D1,unexp)|Rest]):-!. 792combine_exp_steps([step(A1,B1,C1,D1,exp(TN1)),step(A2,B2,C2,D2,exp(TN2))|Rest],ExpDec,UnexpDec):- 793 combine_steps1(step(A1,B1,C1,D1,exp(TN1)),step(A2,B2,C2,D2,exp(TN2)),ExpDec1), 794 combine_exp_steps([ExpDec1|Rest],ExpDec,UnexpDec),!. 795 796combine_steps1(step(HP1,Name1,Pre1,Post1,exp(TN1)),step(HP2,Name2,Pre2,Post2,exp(TN2)),step(HP,achieve(Post2),Pre1,Post2,exp(TN))):- 797 find_only_changed(Pre1,Post2,[],Pre0,[],Post0), 798 not(isemptylist(Post0)), 799 gensym_special(hp,HP), 800 gensym_special(tn,TN), 801 assert(tn(TN,achieve(Post0),Pre0,Post0,[before(TN1,TN2)],[step(HP1,Name1,Pre1,Post1,exp(TN1)),step(HP2,Name2,Pre2,Post2,exp(TN2))])),!. 802 803% already been. 804existing_node([step(_,_,Pre,Post,exp(TN))],UnexpDec,Statics):- 805 tp_node(_,_,_,Statics0,_,[step(_,_,Pre0,Post0,exp(TN0))|Rest]), 806 append_st(Statics,Statics0,Statics1), 807 all_equal(Pre,Pre0,Statics1), 808 all_equal(Post,Post0,Statics1), 809 existing_node([],UnexpDec,Statics1). 810existing_node([step(_,_,Pre,Post,exp(TN))],UnexpDec,Statics):- 811 closed_node(_,_,_,Statics0,_,[step(_,_,Pre0,Post0,exp(TN0))|Rest]), 812 append_st(Statics,Statics0,Statics1), 813 all_equal(Pre,Pre0,Statics1), 814 all_equal(Post,Post0,Statics1), 815 existing_node([],UnexpDec,Statics1). 816existing_node([],[step(_,Name,Pre,_,unexp)|Rest],Statics):- 817 tp_node(_,_,_,Statics0,_,[step(_,Name,Pre0,_,_,unexp)|Rest]), 818 append_st(Statics,Statics0,Statics1), 819 all_equal(Pre,Pre0,Statics1). 820existing_node([],[step(_,Name,Pre,_,unexp)|Rest],Statics):- 821 closed_node(_,_,_,Statics0,_,[step(_,Name,Pre0,_,_,unexp)|Rest]), 822 append_st(Statics,Statics0,Statics1), 823 all_equal(Pre,Pre0,Statics1). 824 825 826 827 828 829 830 831all_equal([],[],Statics):- 832 statics_consist(Statics),!. 833all_equal([se(Sort,Obj,SE)|Pre],[se(Sort,Obj,SE1)|Pre1],Statics):- 834 is_achieved(SE,SE1), 835 all_equal(Pre,Pre1,Statics),!. 836all_equal([se(Sort,Obj,SE)|Pre],Pre1,Statics):- 837 member(se(Sort,Obj,SE1),Pre1), 838 list_take(Pre1,[se(Sort1,Obj1,SE1)],Pre2), 839 all_equal(Pre,Pre1,Statics),!. 840 841get_score(Score,[],UnExpDec,Score1):- 842 length(UnExpDec,Len), 843 Score1 is Score+Len,!. 844get_score(Score,[step(HP,Name,Pre0,Post0,exp(TN))],UnExpDec,Score1):- 845 goal_related(States), 846 state_achieved_Num(Post0,States,0,Num), 847 length(UnExpDec,Len), 848 Score1 is Score-Num,!. 849 850%------------------------------------------- 851% the number of postcondition achieved 852% the more the better 853state_achieved_Num([],Pre0,Num,Num):-!. 854state_achieved_Num([se(Sort,Obj,SE)|Post],Pre0,N,Num):- 855 member(se(Sort,Obj,SE0),Pre0), 856 state_achieved([se(Sort,Obj,SE0)],[se(Sort,Obj,SE)],_), 857 N1 is N+1, 858 state_achieved_Num(Post,Pre0,N1,Num),!. 859state_achieved_Num([se(Sort,Obj,SE)|Post],Pre0,N,Num):- 860 state_achieved_Num(Post,Pre0,N,Num),!. 861 862% the states that can achieve a state 863% that is: 864% for a state in the rhs of operator 865% all the states in the lhs 866find_relate_state:- 867 operatorC(A,Pre,Post,Cond,ST), 868 assert_related_states(A,Pre,Post,Cond,ST), 869 fail. 870find_relate_state. 871 872assert_related_states(A,Pre,Post,Cond,ST):- 873 assert_related_states1(A,Pre,Post,ST), 874 assert_related_states2(A,Pre,Cond,ST). 875 876% find relate in nec 877% the sorts here are primitive 878assert_related_states1(A,Pre,[],ST):-!. 879%when prev 880assert_related_states1(A,Pre,[se(Sort,Obj,SE)|Post],ST):- 881 member_e(se(Sort,Obj,SE),Pre), 882 assert_related_states1(A,Pre,Post,ST),!. 883%when nec 884assert_related_states1(A,Pre,[se(Sort,Obj,SE)|Post],ST):- 885 assert(produce(se(Sort,Obj,SE),A,Pre,ST)), 886 assert_related_states1(A,Pre,Post,ST),!. 887 888% find relate in conditional 889% the sorts here are not primitive 890assert_related_states2(A,Pre,SC,ST):- 891 make_sc_primitive(SC,PSC), 892 assert_related_states21(A,Pre,PSC,ST). 893 894assert_related_states21(A,Pre,[],ST):-!. 895assert_related_states21(A,Pre,[sc(Sort,Obj,SE=>SS)|Trans],ST):- 896 rem_statics([se(Sort,Obj,SE)],[se(Sort,Obj,SER)],St1), 897 rem_statics([se(Sort,Obj,SS)],[se(Sort,Obj,SSR)],St2), 898 append_cut(ST,St1,ST1), 899 append_cut(ST1,St2,ST21), 900 remove_unneed(ST21,[],ST2), 901 append_cut(Pre,[se(Sort,Obj,SER)],Pre1), 902 assert(produce(se(Sort,Obj,SSR),A,Pre1,ST2)), 903 assert_related_states21(A,Pre,Trans,ST),!. 904 905%------------------------------------------- 906% the number of state change compare with precondition 907% the less the better 908pre_changed_Num([],Pre0,Num,Num):-!. 909pre_changed_Num([se(Sort,Obj,SE)|Pre],Pre0,N,Num):- 910 state_achieved([se(Sort,Obj,SE)],Pre0,_), 911 N1 is N+1, 912 pre_changed_Num(Pre,Pre0,N1,Num),!. 913pre_changed_Num([se(Sort,Obj,SE)|Pre],Pre0,N,Num):- 914 pre_changed_Num(Pre,Pre0,N,Num),!. 915 916 917 918%------------------------------------------- 919% remove HP1 from the temp list 920% if HP1<HP2, then all HP3<HP1 => HP3<HP2 921% if HP2<HP1, then all HP1<HP3 => HP2<HP3 922remove_temp([],HP1,List,List):-!. 923remove_temp([before(HP1,HP2)|Temp],HP1,List,Temp1):- 924 remove_temp_before(List,before(HP1,HP2),List2), 925 remove_temp(Temp,HP1,List2,Temp1),!. 926remove_temp([before(HP2,HP1)|Temp],HP1,List,Temp1):- 927 remove_temp_after(List,before(HP2,HP1),List2), 928 remove_temp(Temp,HP1,List2,Temp1),!. 929remove_temp([before(HPX,HPY)|Temp],HP1,List,Temp1):- 930 remove_temp(Temp,HP1,List,Temp1),!. 931 932% if HP1<HP2, remove HP1<HP2, and change all HP3<HP1 => HP3<HP2 933remove_temp_before([],before(HP1,HP2),[]):-!. 934remove_temp_before([before(HP1,HP2)|T],before(HP1,HP2),T1):- 935 remove_temp_before(T,before(HP1,HP2),T1),!. 936remove_temp_before([before(HP3,HP1)|T],before(HP1,HP2),[before(HP3,HP2)|T1]):- 937 remove_temp_before(T,before(HP1,HP2),T1),!. 938remove_temp_before([before(HPX,HPY)|T],before(HP1,HP2),[before(HPX,HPY)|T1]):- 939 remove_temp_before(T,before(HP1,HP2),T1),!. 940% if HP2<HP1, remove HP2<HP1, and change all HP1<HP3 => HP2<HP3 941remove_temp_after([],before(HP1,HP2),[]):-!. 942remove_temp_after([before(HP2,HP1)|T],before(HP2,HP1),T1):- 943 remove_temp_after(T,before(HP2,HP1),T1),!. 944remove_temp_after([before(HP1,HP3)|T],before(HP2,HP1),[before(HP2,HP3)|T1]):- 945 remove_temp_after(T,before(HP2,HP1),T1),!. 946remove_temp_after([before(HPX,HPY)|T],before(HP2,HP1),[before(HPX,HPY)|T1]):- 947 remove_temp_after(T,before(HP2,HP1),T1),!. 948 949remove_dec(HPid,[],[]):-!. 950remove_dec(HPid,[step(HPid,_,_,_,_)|Dec],Dec1):- 951 remove_dec(HPid,Dec,Dec1),!. 952remove_dec(HPid,[step(A,B,C,D,F)|Dec],[step(A,B,C,D,F)|Dec1]):- 953 remove_dec(HPid,Dec,Dec1),!. 954 955/******************************************************/ 956% state2 is achieved by state1(or they are not conflict) 957% the output state is the combination of the two states 958state_achieved(undefd,State,State):-!. 959state_achieved(State1,State2,State3):- 960 state_achieved1(State1,State2,State3). 961 962state_achieved1([],State2,State2). 963state_achieved1([se(Sort,Obj,ST1)|State1],State2,[se(Sort,Obj,STN)|State]):- 964 get_sort_objects(Sort,Objls), 965 member(Obj,Objls), 966 member(se(Sort,Obj,ST2),State2), 967 not_conflict(Sort,Obj,ST1,ST2,STN), 968 list_take(State2,[se(Sort,Obj,ST2)],State21), 969 state_achieved1(State1,State21,State). 970state_achieved1([se(Sort1,Obj,ST1)|State1],State2,[se(Sort,Obj,STN)|State]):- 971 not(objects(Sort1,Objls)), 972 find_prim_sort(Sort1,Sortls), 973 member(se(Sort,Obj,ST2),State2), 974 member(Sort,Sortls), 975 not_conflict(Sort,Obj,ST1,ST2,STN), 976 list_take(State2,[se(Sort,Obj,ST2)],State21), 977 state_achieved1(State1,State21,State). 978 979% two states not conflict 980not_conflict(Sort,Obj,ST,ST1,NewST):- 981 gsubstate_classes(Sort,Obj,Substateclasses), 982 member(State0,Substateclasses), 983 is_achieved(ST,State0), 984 is_achieved(ST1,State0), 985 set_append_e(ST,ST1,NewST),!. 986 987% all the element in list1 are static or in list2 988is_achieved([],_):-!. 989is_achieved([H|T], State) :- 990 is_statics(H), 991 is_achieved(T,State),!. 992is_achieved([H|T], State) :- 993 member(H,State), 994 is_achieved(T,State),!. 995 996% check if a predicate is statics or not 997is_statics(ne(A,B)):-!. 998is_statics(is_of_sort(A,B)):-!. 999is_statics(is_of_primitive_sort(A,B)):-!. 1000is_statics(Pred):- 1001 functor(Pred,FF,NN), 1002 functor(Pred1,FF,NN), 1003 atomic_invariants(Atom), 1004 member(Pred1,Atom),!. 1005 1006 1007%------------------------------------------- 1008 1009/************ state changes by actions ********/ 1010% if an object's state meet the precondition 1011% it change to the postcondition 1012state_change([],Pre0,Post0,[]):-!. 1013state_change(Pre,[],[],Pre):-!. 1014% if a obj pre achieves action's pre 1015% change the obj's post state with action's post 1016state_change([se(Sort,Obj,SE)|Pre],Pre0,Post0,[se(Sort,Obj,NewSS)|State]):- 1017 member(se(Sort,Obj,SE0),Pre0), 1018 member(se(Sort,Obj,SS0),Post0), 1019 not_conflict(Sort,Obj,SE,SE0,_), 1020 state_change1(SE,SE0,SS0,NewSS), 1021 list_take(Pre0,[se(Sort,Obj,SE0)],Pre1), 1022 list_take(Post0,[se(Sort,Obj,SS0)],Post1), 1023 state_change(Pre,Pre1,Post1,State),!. 1024% if a obj state not defined in action's pre 1025% move it to its post 1026state_change([se(Sort,Obj,SE)|Pre],Pre0,Post0,[se(Sort,Obj,SE)|State]):- 1027 state_change(Pre,Pre0,Post0,State),!. 1028 1029state_change1([],SE0,SS0,SS0):-!. 1030state_change1([HSE|TSE],SE0,SS0,SS1):- 1031 member(HSE,SE0), 1032 state_change1(TSE,SE0,SS0,SS1),!. 1033state_change1([HSE|TSE],SE0,SS0,[HSE|SS1]):- 1034 state_change1(TSE,SE0,SS0,SS1),!. 1035%------------------------------------------- 1036%------------------------------------------- 1037/************ state changes by conditions ********/ 1038% for all the object's state meet the precondition 1039% it change to the postcondition 1040cond_state_change([],Cond,[]):-!. 1041cond_state_change(State,[],State):-!. 1042cond_state_change([se(Sort,Obj,SE)|Pre],Cond,[se(Sort,Obj,NewSS)|State]):- 1043 member(sc(Sort1,Obj,SE0=>SS0),Cond), 1044 statics_consist([is_of_sort(Obj,Sort1),is_of_sort(Obj,Sort)]), 1045 not_conflict(Sort,Obj,SE,SE0,_), 1046 state_change1(SE,SE0,SS0,NewSS), 1047 cond_state_change(Pre,Cond,State),!. 1048cond_state_change([se(Sort,Obj,SE)|Pre],Cond,[se(Sort,Obj,SE)|State]):- 1049 cond_state_change(Pre,Cond,State),!. 1050 1051%------------------------------------------- 1052% check that an action's state change 1053% included changes of the goal states need to be achieved 1054post_changed(Post0,Cond,Statics,[se(Sort,Obj,SE)|Post]):- 1055 member(se(Sort,Obj,SE0),Post0), 1056 state_achieved([se(Sort,Obj,SE0)],[se(Sort,Obj,SE)],_), 1057 statics_consist(Statics). 1058post_changed(Post0,Cond,Statics,[se(Sort,Obj,SE)|Post]):- 1059 member(sc(Sort,Obj,SE1=>SS),Cond), 1060 state_achieved([se(Sort,Obj,SS)],[se(Sort,Obj,SE)],_), 1061 statics_consist(Statics). 1062post_changed(Post0,Cond,Statics,[se(Sort,Obj,SE)|Post]):- 1063 post_changed(Post0,Cond,Statics,Post). 1064 1065all_achieved([],Statics,Post). 1066all_achieved([se(Sort,Obj,SL)|Pre],Statics,Post):- 1067 not(member(se(Sort,Obj,SR),Post)), 1068 all_achieved(Pre,Statics,Post). 1069all_achieved([se(Sort,Obj,SL)|Pre],Statics,Post):- 1070 member(se(Sort,Obj,SR),Post), 1071 is_achieved(SL,SR), 1072 statics_consist_instance(Statics), 1073 all_achieved(Pre,Statics,Post). 1074 1075 1076%------------------------------------------- 1077% instantiate a bit 1078% use action's state change include the postcondition 1079post_instant(Post0,Cond,Statics,[]):-!. 1080post_instant(Post0,Cond,Statics,[se(Sort,Obj,SE)|Post]):- 1081 member(se(Sort,Obj,SE0),Post0), 1082 statics_consist(Statics). 1083post_instant(Post0,Cond,Statics,[se(Sort,Obj,SE)|Post]):- 1084 member(sc(Sort,Obj,SE1=>SS),Cond), 1085 statics_consist(Statics). 1086post_instant(Post0,Cond,Statics,[se(Sort,Obj,SE)|Post]):- 1087 member(sc(Sort0,Obj,SE1=>SS),Cond), 1088 not(objects(Sort0,_)), 1089 subsorts(Sort0,Sortls), 1090 not(not(member(Sort,Sortls))), 1091 statics_consist(Statics). 1092post_instant(Post0,Cond,Statics,[se(Sort,Obj,SE)|Post]):- 1093 post_instant(Post0,Cond,Statics,Post),!. 1094/******************************* NODE ADT *********************/ 1095 1096%node(Name, Precond, Decomps, Temp, Statics) 1097% When inputting new methods etc filter all statics into 1098% static slot 1099 1100make_problem_into_node(I,goal(L,TM,STATS), NN) :- 1101 make_problem_up(L, STEPS), 1102 make_num_hp(TM,Temp), 1103 sort_steps(STEPS,Temp,STEPS1), 1104 make_ss_to_se(I,I_Pre), 1105 NN = node(root,I_Pre,STEPS1 ,Temp, STATS),!. 1106 1107% make problem to steps 1108make_problem_up([],[]):-!. 1109make_problem_up([achieve(L)|R],[step(HP,achieve(L1),undefd,[L1],unexp)|RS]):- 1110 %preconditon here is undefd 1111 make_ss_to_se([L],[L1]), 1112 gensym_special(hp,HP), 1113 make_problem_up(R, RS),!. 1114make_problem_up([achieve(L)|R],[step(HP,achieve(L1),undefd,L1,unexp)|RS]):- 1115 %preconditon here is undefd 1116 make_ss_to_se(L,L1), 1117 gensym_special(hp,HP), 1118 make_problem_up(R, RS),!. 1119make_problem_up([O|R],[step(HP,O,undefd,undefd,unexp)|RS]):- 1120 methodC(O,Pre,Post,Statics1,Temp,ACH,Dec), 1121 gensym_special(hp,HP), 1122 make_problem_up(R, RS),!. 1123make_problem_up([O|R], 1124 [step(HP,O,undefd,undefd,unexp)|RS]):- 1125 operatorC(O,Pre,Post,Cond,Statics1), 1126 gensym_special(hp,HP), 1127 make_problem_up(R, RS),!. 1128 1129make_num_hp([],[]):-!. 1130make_num_hp([before(N1,N2)|TM],[before(H1,H2)|Temp]):- 1131 gensym_num(hp,N1,H1), 1132 gensym_num(hp,N2,H2), 1133 make_num_hp(TM,Temp),!. 1134 1135%**************sort steps********************************* 1136% sort steps by temporal constraints. 1137sort_steps(Steps,[],Steps):-!. 1138sort_steps([Steps|[]],[],[Steps]):-!. 1139sort_steps(Steps,Temp,OrderedST):- 1140 steps_in_temp(Temp,[],ST), 1141 sort_steps1(Temp,ST,OrderedSTID), 1142 sort_steps2(Steps,OrderedSTID,[],OrderedST),!. 1143 1144% find out the steps in temporal constraints. 1145steps_in_temp([],ST,ST):-!. 1146steps_in_temp([before(H1,H2)|TT],List,ST):- 1147 set_append_e(List,[H1,H2],List1), 1148 steps_in_temp(TT,List1,ST),!. 1149 1150% sort the steps_id(hps) by temporal constraints. 1151sort_steps1(Temp,[],[]):-!. 1152sort_steps1(Temp,[HP1|TST],[HPF|OST]):- 1153 earliest_step(HP1,HPF,Temp,TST,TST1), 1154 sort_steps1(Temp,TST1,OST),!. 1155 1156earliest_step(HPF,HPF,Temp,[],[]):-!. 1157earliest_step(HP1,HPF,Temp,[HP2|TST],[HP1|TST1]):- 1158 member(before(HP2,HP1),Temp), 1159 earliest_step(HP2,HPF,Temp,TST,TST1),!. 1160earliest_step(HP1,HPF,Temp,[HP2|TST],[HP2|TST1]):- 1161 earliest_step(HP1,HPF,Temp,TST,TST1),!. 1162 1163% sort the steps, put the unordered steps in the front 1164sort_steps2(OtherST,[],OrderedST1,OrderedST):- 1165 append(OrderedST1,OtherST,OrderedST),!. 1166sort_steps2(Steps,[HP|THPS],List,OrderedST):- 1167 member(step(HP,N,Pre,Post,F),Steps), 1168 append(List,[step(HP,N,Pre,Post,F)],List1), 1169 list_take(Steps,[step(HP,N,Pre,Post,F)],Steps1), 1170 sort_steps2(Steps1,THPS,List1,OrderedST),!. 1171sort_steps2(Steps,[HP|THPS],List,OrderedST):- 1172 sort_steps2(Steps,THPS,List,OrderedST),!. 1173%******************************************************* 1174 1175% replace ss to se 1176make_ss_to_se([],[]):-!. 1177make_ss_to_se([ss(Sort,Obj,Post)|TPost],[se(Sort,Obj,Post)|TPre]):- 1178 make_ss_to_se(TPost,TPre),!. 1179make_ss_to_se([se(Sort,Obj,Post)|TPost],[se(Sort,Obj,Post)|TPre]):- 1180 make_ss_to_se(TPost,TPre),!. 1181 1182%******************************************************* 1183% extract_solution(Node,.. 1184% recurvise routine to work down tree and 1185% print out a linearisation of it 1186extract_solution(Node,PHPs,SIZE1) :- 1187 % its the name of a hierarchical op...... 1188 getN_decomp(Node, HPs), 1189 push_to_primitive(HPs,[],PHPs), 1190 pprint(PHPs,1,SIZE), 1191 SIZE1 is SIZE -1,!. 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212/************ change_op_representation ***********/ 1213% make pre and post explicit 1214% filter out statics and put in a new slot 1215change_op_representation :- 1216 method(A,B,C,Stat,T,Dec), 1217 make_ss_to_se(B,B0), 1218 make_se_primitive(B0,B1), 1219 make_sc_primitive(C,C1), 1220 get_preconditions(C1,B1,Pre,Post), 1221 rem_statics(Post, PostR,St1), 1222 rem_statics(Pre, PreR,St2), 1223 append_cut(St1,St2,Statics), 1224 append_cut(Stat,Statics,Statics1), 1225 remove_unneed(Statics1,[],Statics2), 1226 get_achieval(A,Dec,T,Dec1,T1,ACH), 1227 assert(methodC(A,PreR,PostR,Statics2,T1,achieve(ACH),Dec1)), 1228 fail. 1229change_op_representation :- 1230 operator(A,B,C,D), 1231 make_ss_to_se(B,B0), 1232 make_se_primitive(B0,B1), 1233 make_sc_primitive(C,C1), 1234% make_sc_primitive(D,D1), 1235 %can't do that because it narrow the conditional change 1236 get_preconditions(C1,B1,Pre,Post), 1237 rem_statics(Post, PostR,St1), 1238 rem_statics(Pre, PreR,St2), 1239 append_cut(St1,St2,Statics1), 1240 remove_unneed(Statics1,[],Statics), 1241 statics_consist(Statics), 1242 assert(operatorC(A,PreR,PostR,D,Statics)), 1243 fail. 1244change_op_representation:- 1245 retractall(current_num(sm,_)),!. 1246 1247get_preconditions([],Prev,Prev,Prev) :-!. 1248get_preconditions([sc(S,X,From =>To)|Rest],Prev,[se(S,X,From1)|Pre],[se(S,X,To1)|Post]):- 1249 member_e(se(S,X,PSE),Prev), 1250 append(PSE,From,From1), 1251 append(PSE,To,To1), 1252 list_take(Prev,[se(S,X,PSE)],Prev1), 1253 get_preconditions(Rest,Prev1, Pre,Post),!. 1254get_preconditions([sc(S,X,From =>To)|Rest],Prev,[se(S,X,From)|Pre],[se(S,X,To)|Post]):- 1255 get_preconditions(Rest,Prev, Pre,Post),!. 1256get_preconditions([],Prev,Prev,Prev) :-!. 1257 1258% get all achieve goals out 1259get_achieval(A,Dec,T,Dec1,T1,Achieval):- 1260 retractall(current_num(sm,_)), 1261 make_dec(A,Dec,Dec1,T,T1,[],Achieval),!. 1262make_dec(A,[],[],Temp,Temp,Achieval,Achieval):-!. 1263make_dec(A,[HD|TD],TD1,Temp,Temp1,Achieval,Achieval1):- 1264 HD=..[achieve|Goal], 1265 current_num(sm,Num), 1266 replace_achieval_temp(Temp,Temp0,Num), 1267 make_ss_to_se(Goal,Goal0), 1268 append(Achieval,Goal0,Achieval0), 1269 make_dec(A,TD,TD1,Temp0,Temp1,Achieval0,Achieval1),!. 1270make_dec(A,[HD|TD],TD1,Temp,Temp1,Achieval,Achieval1):- 1271 HD=..[achieve|Goal], 1272 not(current_num(sm,Num)), 1273 replace_achieval_temp(Temp,Temp0,1), 1274 make_ss_to_se(Goal,Goal0), 1275 append(Achieval,Goal0,Achieval0), 1276 make_dec(A,TD,TD1,Temp0,Temp1,Achieval0,Achieval1). 1277make_dec(A,[HD|TD],[HD|TD1],Temp,Temp1,Achieval,Achieval1):- 1278 HD=..[DecName|Goal], 1279 DecName\==achieve, 1280 gensym_special(sm,SM), 1281 current_num(sm,Num), 1282 make_dec(A,TD,TD1,Temp,Temp1,Achieval,Achieval1),!. 1283 1284% get rid of the achievals in temp orders 1285replace_achieval_temp(Temp,Temp1,Num):- 1286 change_all_numbers(Temp,Num,Temp00), 1287 tidy_temp(Temp00,Temp1). 1288 1289change_all_numbers([],Num,[]):-!. 1290change_all_numbers([HTemp|TTemp],Num,[HTemp00|TTemp00]):- 1291 HTemp=..[before|Nums], 1292 change_nums(Nums,Num,Nums1), 1293 HTemp00=..[before|Nums1], 1294 change_all_numbers(TTemp,Num,TTemp00). 1295 1296change_nums([],Num,[]):-!. 1297change_nums([Num1|TN],Num,[Num1|TN1]):- 1298 Num1<Num, 1299 change_nums(TN,Num,TN1),!. 1300change_nums([Num1|TN],Num,[Num2|TN1]):- 1301 Num1>Num, 1302 Num2 is Num1-1, 1303 change_nums(TN,Num,TN1),!. 1304change_nums([Num|TN],Num,[0|TN1]):- 1305 change_nums(TN,Num,TN1),!. 1306 1307% since assumed achieval only happen at first, so only change the after ones 1308tidy_temp(Temp,Temp1):- 1309 member(before(Num,0),Temp), 1310 list_take(Temp,[before(Num,0)],Temp0), 1311 change_laters(Temp0,Num,Temp01), 1312 tidy_temp(Temp01,Temp1). 1313tidy_temp([],[]):-!. 1314tidy_temp([before(0,Num)|Temp],Temp0):- 1315 tidy_temp(Temp,Temp0),!. 1316tidy_temp([before(Num1,Num2)|Temp],[before(Num1,Num2)|Temp0]):- 1317 tidy_temp(Temp,Temp0),!. 1318 1319change_laters([before(0,Num2)|Temp],Num,[before(Num,Num2)|Temp0]):- 1320 change_laters(Temp,Num,Temp0). 1321change_laters([before(Num1,0)|Temp],Num,[before(Num1,0)|Temp0]):- 1322 change_laters(Temp,Num,Temp0). 1323change_laters([before(Num1,Num2)|Temp],Num,[before(Num1,Num2)|Temp0]):- 1324 change_laters(Temp,Num,Temp0). 1325 1326% change the states to primitive states 1327make_se_primitive([],[]). 1328make_se_primitive([se(Sort,Obj,ST)|SE],[se(Sort,Obj,ST)|SE0]):- 1329 find_prim_sort(Sort,[Sort]),!, 1330 make_se_primitive(SE,SE0). 1331make_se_primitive([se(Sort,Obj,ST)|SE],[se(PSort,Obj,ST)|SE0]):- 1332 find_prim_sort(Sort,PSorts), 1333 member(PSort,PSorts), 1334 make_se_primitive(SE,SE0). 1335 1336% change the state changes to primitive states 1337make_sc_primitive([],[]). 1338make_sc_primitive([sc(Sort,Obj,SE1=>SE2)|ST],[sc(Sort,Obj,SE1=>SE2)|ST0]):- 1339 find_prim_sort(Sort,[Sort]),!, 1340 make_sc_primitive(ST,ST0). 1341make_sc_primitive([sc(Sort,Obj,SE1=>SE2)|ST],[sc(PSort,Obj,SE1=>SE2)|ST0]):- 1342 find_prim_sort(Sort,PSorts), 1343 member(PSort,PSorts), 1344 make_sc_primitive(ST,ST0). 1345% ------------ end of change operator ---------------------- 1346make_tn(TN,Name,Pre,Post,Temp,Dec):- 1347 gensym_special(tn,TN), 1348 find_only_changed(Pre,Post,[],Pre1,[],Post1), 1349% tell(user),nl,write(tn(TN,Name,Pre1,Post1,Temp,Dec)),nl,told, 1350 assert(tn(TN,Name,Pre1,Post1,Temp,Dec)),!. 1351 1352find_only_changed([],[],Pre,Pre,Post,Post):-!. 1353% just a lazy check if they are in exactly same sequence 1354find_only_changed([se(Sort,Obj,ST)|Pre],[se(Sort,Obj,ST)|Post],Pre0,Pre1,Post0,Post1):- 1355 find_only_changed(Pre,Post,Pre0,Pre1,Post0,Post1),!. 1356find_only_changed([se(Sort,Obj,ST)|Pre],Post,Pre0,Pre1,Post0,Post1):- 1357 member(se(Sort,Obj,ST1),Post), 1358 list_take(Post,[se(Sort,Obj,ST1)],Post2), 1359 append_changed(se(Sort,Obj,ST),se(Sort,Obj,ST1),Pre0,Pre3,Post0,Post3), 1360 find_only_changed(Pre,Post2,Pre3,Pre1,Post3,Post1),!. 1361find_only_changed([se(Sort,Obj,ST)|Pre],Post,Pre0,Pre1,Post0,Post1):- 1362 member(se(SortN,Obj,ST1),Post), 1363 list_take(Post,[se(SortN,Obj,ST1)],Post2), 1364 append_changed(se(Sort,Obj,ST),se(SortN,Obj,ST1),Pre0,Pre3,Post0,Post3), 1365 find_only_changed(Pre,Post2,Pre3,Pre1,Post3,Post1),!. 1366% other fail. 1367 1368% append only changed states 1369% not_conflict here means not changed 1370append_changed(se(Sort,Obj,ST),se(Sort1,Obj,ST1),Pre0,Pre0,Post0,Post0):- 1371 not_conflict(Sort,Obj,ST,ST1,_),!. 1372append_changed(se(Sort,Obj,ST),se(Sort1,Obj,ST1),Pre0,Pre3,Post0,Post3):- 1373 append(Pre0,[se(Sort,Obj,ST)],Pre3), 1374 append(Post0,[se(Sort,Obj,ST1)],Post3),!. 1375 1376 1377 1378%***********print out solution************************** 1379push_to_primitive([],PHPs,PHPs) :-!. 1380push_to_primitive([step(HPID,_,_,_,exp(TN))|HPs],List,PHPs) :- 1381 tn(TN,Name,Pre,Post,Temp,Dec), 1382 push_to_primitive(Dec,List,Dec1), 1383 push_to_primitive(HPs,Dec1,PHPs),!. 1384push_to_primitive([step(HPID,_,_,_,exp(Name))|HPs],List,PHPs):- 1385 append(List,[Name],List1), 1386 push_to_primitive(HPs,List1,PHPs),!. 1387 1388 1389/*********** TEMPORAL AND DECLOBBERING ************/ 1390 1391possibly_before(I,J,Temps) :- 1392 \+ necessarily_before(J,I,Temps), !. 1393 1394necessarily_before(J,I,Temps) :- 1395 member(before(J,I),Temps),!. 1396necessarily_before(J,I,Temps) :- 1397 member(before(J,Z),Temps), 1398 necessarily_before(Z,I,Temps),!. 1399 1400/********** retracting, asserting and reporting nodes *****************/ 1401 1402/***** SOLUTION ******/ 1403select_node(node(Name,Pre,Temp,Decomp,Statics)) :- 1404 retract(node(Name,Pre,Temp,Decomp,Statics)), 1405% nl,nl,write(Name),write(' RETRACTED'),nl,nl, 1406% tell(user), 1407% nl,nl,write(Name),write(' RETRACTED'),nl,nl, 1408% tell(FF), 1409 !. 1410 1411is_of_primitive_sort(X,Y) :- 1412 objects(Y,L),member(X,L). 1413is_of_sort(X,Y) :- 1414 is_of_primitive_sort(X,Y). 1415is_of_sort(X,Y) :- 1416 sorts(Y,SL),member(Z,SL),is_of_sort(X,Z). 1417 1418find_all_upper([],[]). 1419find_all_upper([HVars|TV],[HSorts|TS]):- 1420 uppersorts(HSorts,Upsorts), 1421 member(HVars,Upsorts), 1422 find_all_upper(TV,TS). 1423 1424% find out primitive sorts of a sort. 1425find_prim_sort(Sort,PS):- 1426 subsorts(Sort,Subsorts), 1427 split_prim_noprim(Subsorts,PS,NP),!. 1428 1429% find out the objects of a sort 1430get_sort_objects(Sort,Objs):- 1431 find_prim_sort(Sort,PSorts), 1432 get_objects1(PSorts,Objls), 1433 flatten(Objls,[],Objs),!. 1434 1435get_objects1([],[]):-!. 1436get_objects1([PS1|RS],[Objls1|Objls]):- 1437 objects(PS1,Objls1), 1438 get_objects1(RS,Objls),!. 1439 1440% find subsorts of a sort(include). 1441subsorts(Sort,Subsorts):- 1442 sort_down([Sort],[Sort],Subsorts),!. 1443 1444sort_down([],Subsorts,Subsorts):-!. 1445sort_down([HOpen|TOpen],List,Sortslist):- 1446 sorts(HOpen,Sorts), 1447 append(List,Sorts,List1), 1448 append(TOpen,Sorts,Open1), 1449 sort_down(Open1,List1,Sortslist),!. 1450sort_down([HOpen|TOpen],List,Sortslist):- 1451 sort_down(TOpen,List,Sortslist),!. 1452 1453% find uppersorts of a sort or object(include). 1454uppersorts(Sort,Uppersorts):- 1455 objects(Sort,Objls), 1456 sort_up(Sort,[Sort],Uppersorts),!. 1457uppersorts(Sort,Uppersorts):- 1458 sorts(Sort,Sortls), 1459 sort_up(Sort,[Sort],Uppersorts),!. 1460uppersorts(Obj,Sortls):- 1461 objects(Sort,Objls), 1462 member(Obj, Objls), 1463 sort_up(Sort,[Sort],Sortls),!. 1464 1465sort_up(Sort, List,Sortslist):- 1466 sorts(non_primitive_sorts,NPSorts), 1467 sort_up1(Sort,NPSorts,NPSorts,List,Sortslist),!. 1468 1469sort_up1(Sort,[],NPSorts,Sortslist,Sortslist):-!. 1470sort_up1(Sort,[HNPSorts|TNPSorts],NPSorts,List,Sortslist):- 1471 sorts(HNPSorts,Sorts), 1472 member(Sort,Sorts), 1473 append(List, [HNPSorts], List1), 1474 sort_up(HNPSorts,List1,Sortslist),!. 1475sort_up1(Sort,[HNPSorts|TNPSorts],NPSorts,List,Sortslist):- 1476 sort_up1(Sort,TNPSorts,NPSorts,List,Sortslist),!. 1477 1478% find out primitive sorts from a sorts list. 1479split_prim_noprim([],[],[]):-!. 1480split_prim_noprim([HS|TS],[HS|TP],NP):- 1481 objects(HS,Obj), 1482 split_prim_noprim(TS,TP,NP),!. 1483split_prim_noprim([HS|TS],PS,[HS|NP]):- 1484 split_prim_noprim(TS,PS,NP),!. 1485 1486 1487 1488 1489 1490% check for statics consist and instanciate them 1491statics_consist_instance([]):-!. 1492statics_consist_instance(Statics) :- 1493 get_invariants(Invs), 1494 statics_consist_instance0(Invs,Statics). 1495 1496statics_consist_instance0(Invs,[]):-!. 1497statics_consist_instance0(Invs,[ne_back(A,B)|TStatics]):- 1498 not(A==B), 1499 statics_consist_instance0(Invs,TStatics). 1500statics_consist_instance0(Invs,[ne(A,B)|TStatics]):- 1501 append(TStatics,[ne_back(A,B)],TStatics1), 1502 statics_consist_instance0(Invs,TStatics1),!. 1503statics_consist_instance0(Invs,[is_of_sort(Obj,Sort)|TStatics]):- 1504 is_of_sort(Obj,Sort), 1505 statics_consist_instance0(Invs,TStatics). 1506statics_consist_instance0(Invs,[is_of_primitive_sort(Obj,Sort)|TStatics]):- 1507 is_of_primitive_sort(Obj,Sort), 1508 statics_consist_instance0(Invs,TStatics). 1509statics_consist_instance0(Invs,[Pred|TStatics]):- 1510 member(Pred,Invs), 1511 statics_consist_instance0(Invs,TStatics). 1512 1513% check for statics consist without instanciate them 1514% only instance the variable when there is one choice of from the ground lists 1515statics_consist([]):-!. 1516statics_consist(Statics):- 1517 get_invariants(Invs), 1518 statics_consist1(Invs,Statics),!. 1519 1520statics_consist1(Invs,[]):-!. 1521statics_consist1(Invs,[ne_back(A,B)|TStatics]):- 1522 not(A==B), 1523 statics_consist1(Invs,TStatics),!. 1524statics_consist1(Invs,[ne(A,B)|TStatics]):- 1525 append(TStatics,[ne_back(A,B)],TStatics1), 1526 statics_consist1(Invs,TStatics1),!. 1527statics_consist1(Invs,[is_of_sort(Obj,Sort)|TStatics]):- 1528 get_sort_objects(Sort,Objs), 1529 obj_member(Obj,Objs), 1530 statics_consist1(Invs,TStatics),!. 1531statics_consist1(Invs,[is_of_primitive_sort(Obj,Sort)|TStatics]):- 1532 objects(Sort,Objs), 1533 obj_member(Obj,Objs), 1534 statics_consist1(Invs,TStatics),!. 1535statics_consist1(Invs,[Pred|TStatics]):- 1536 pred_member(Pred,Invs), 1537 statics_consist1(Invs,TStatics),!. 1538 1539/***************** local utils *****************/ 1540 1541/*********** DOMAIN MODEL FUNCTIONS *****************/ 1542get_invariants(Invs) :- 1543 atomic_invariants(Invs),!. 1544 1545rem_statics([ss(S,X,Preds)|Post], [ss(S,X,PredR)|PostR],Rt1) :- 1546 filter_list(Preds, is_a_dynamic_pred,PredR), 1547 filter_list(Preds, is_a_static_pred, R), 1548 rem_statics(Post, PostR,Rt), 1549 append(Rt,[is_of_sort(X,S)|R],Rt1),!. 1550rem_statics([se(S,X,Preds)|Post], [se(S,X,PredR)|PostR],Rt1) :- 1551 filter_list(Preds, is_a_dynamic_pred,PredR), 1552 filter_list(Preds, is_a_static_pred, R), 1553 rem_statics(Post, PostR,Rt), 1554 append(Rt,[is_of_sort(X,S)|R],Rt1),!. 1555rem_statics([], [],[]) :-!. 1556 1557 1558 1559/***************** STATICS ************************/ 1560 1561isemptylist([]):-!. 1562 1563 1564member_cut(X,[X|_]) :- !. 1565member_cut(X,[_|Y]) :- member_cut(X,Y),!. 1566 1567member_e(X,[Y|_]):- 1568 X==Y,!. 1569member_e(X,[Y|L]):- 1570 var(Y), 1571 member_e(X,L),!. 1572member_e(ss(Sort,Obj,SE),[ss(Sort,Obj1,SE)|_]):- 1573 Obj==Obj1,!. 1574member_e(se(Sort,Obj,SE),[se(Sort,Obj1,SE)|_]):- 1575 Obj==Obj1,!. 1576member_e(sc(Sort,Obj,SE1=>SE2),[sc(Sort,Obj1,SE1=>SE2)|_]):- 1577 Obj==Obj1,!. 1578member_e(X,[Y|L]):- member_e(X,L),!. 1579% u_mem in ob_utils is SLOW!?. 1580% this is a fast impl. 1581u_mem_cut(_,[]):-!,fail. 1582u_mem_cut(X,[Y|_]) :- X == Y,!. 1583u_mem_cut(X,[_|L]) :- u_mem_cut(X,L),!. 1584 1585 1586% check if object X is a member of a objects list 1587% 1. if it is not a variable, check if it is in the list 1588% 2. X is a variable, and the list only has one objects, make X as that obj 1589% 3. X is a variable, but the list has more than one objects, leave X unchange 1590obj_member(X,[X|[]]):-!. 1591obj_member(X,List):- 1592 obj_member0(X,List),!. 1593obj_member0(X,[Y|_]):- 1594 var(X),!.%if X is var, but Y not, the leave X as that variable 1595obj_member0(X,[Y|_]):- 1596 X==Y,!. 1597obj_member0(X,[_|Y]) :- obj_member0(X,Y),!. 1598 1599% check if a predicate is a member of a ground predicate list, 1600% 1. when only one predicates found 1601% just used in binding the predicates to a sort without instantiate it 1602% for efficiency, instantiate the variable if the list only have one atom 1603pred_member(ne(A,B),List):- 1604 A\==B,!. 1605pred_member(is_of_sort(A,B),List):- 1606 get_sort_objects(B,Objls), 1607 obj_member(A,Objls),!. 1608pred_member(is_of_primitive_sort(A,B),List):- 1609 objects(B,Objls), 1610 obj_member(A,Objls),!. 1611pred_member(X,List):- 1612 setof(X,member(X,List),Refined), 1613 pred_member0(X,Refined),!. 1614pred_member0(X,[X|[]]):-!. 1615pred_member0(X,Y):- 1616 pred_member1(X,Y),!. 1617pred_member1(X,[Y|_]):- 1618 X=..[H|XLs], 1619 Y=..[H|YLs], 1620 vequal(XLs,YLs),!. 1621pred_member1(X,[_|Y]):- pred_member1(X,Y),!. 1622 1623 1624 1625append_cut([],L,L) :- !. 1626append_cut([H|T],L,[H|Z]) :- append_cut(T,L,Z),!. 1627 1628% remove the constants that no need 1629% instanciate the viables that all ready been bind 1630% ------------------------------------------ 1631append_st(ST1,ST2,ST):- 1632 append_cut(ST1,ST2,ST0), 1633 remove_unneed(ST0,[],ST),!. 1634 1635% remove the constants that no need 1636% instanciate the variables that all ready been bind 1637remove_unneed([],C,C):-!. 1638remove_unneed([A|B], Z, C):- 1639 var(A), 1640 member_e(A,Z), 1641 remove_unneed(B, Z, C),! . 1642remove_unneed([A|B], Z, C):- 1643 var(A), 1644 append(Z,[A],D), 1645 remove_unneed(B, D, C),!. 1646remove_unneed([A|B], Z, C):- 1647 ground(A), 1648 remove_unneed(B, Z, C),!. 1649remove_unneed([A|B], Z, C):- 1650 A=..[ne|Paras], 1651 append(Z,[A],D), 1652 remove_unneed(B, D, C),!. 1653remove_unneed([A|B], Z, C):- 1654 A=..[Pred|Paras], 1655 same_var_member(A,Z), 1656 remove_unneed(B, Z, C),!. 1657remove_unneed([A|B], Z, C):- 1658 append(Z,[A],D), 1659 remove_unneed(B, D, C),!. 1660 1661same_var_member(Pred,[Pred1|List]):- 1662 var(Pred1), 1663 same_var_member(Pred,List),!. 1664same_var_member(Pred,[Pred1|List]):- 1665 Pred==Pred1,!. 1666same_var_member(Pred,[Pred1|List]):- 1667 Pred=..[H|T], 1668 Pred1=..[H|T1], 1669 same_var_member1(T,T1),!. 1670same_var_member(Pred,[Pred1|List]):- 1671 same_var_member(Pred,List),!. 1672 1673same_var_member1([],[]):-!. 1674same_var_member1([H1|T],[H2|T]):- 1675 var(H1), 1676 H1==H2,!. 1677same_var_member1([H|T1],[H|T2]):- 1678 var(T1), 1679 T1==T2,!. 1680same_var_member1([H1|T1],[H2|T2]):- 1681 H1==H2, 1682 same_var_member1(T1,T2),!. 1683 1684 1685% set_append_e: list1 + list2 -> list 1686% no duplicate, no instanciation 1687% ------------------------------------------ 1688set_append_e(A,B,C):- 1689 append_cut(A,B,D), 1690 remove_dup(D,[],C),!. 1691 1692% remove duplicate 1693remove_dup([],C,C):-!. 1694remove_dup([A|B],Z,C) :- 1695 member_e(A, Z), 1696 remove_dup(B, Z, C),! . 1697remove_dup([A|B], Z, C):- 1698 append(Z,[A],D), 1699 remove_dup(B, D, C),!. 1700 1701vequal([],[]):-!. 1702vequal([X|XLs],[Y|YLs]):- 1703 var(X), 1704 vequal(XLs,YLs),!. 1705vequal([X|XLs],[Y|YLs]):- 1706 var(Y), 1707 vequal(XLs,YLs),!. 1708vequal([X|XLs],[Y|YLs]):- 1709 X==Y, 1710 vequal(XLs,YLs),!. 1711 1712 1713% append_st: append two statics 1714 1715/* is X is in the atomic_invariants then by defn its a static. */ 1716is_a_static_pred(X) :- 1717 atomic_invariants( A ), 1718 not( not( member(X,A) )),!. 1719is_a_static_pred(ne(_,_)) :-!. 1720is_a_static_pred(is_of_sort(_,_)) :-!. 1721 1722is_a_dynamic_pred(X) :- 1723 not( is_a_static_pred(X) ),!. 1724 1725/* filter_list(X,condition(args),XO) 1726 1727 XO is reduced list */ 1728 ([X|Rest],Op,[X|Rest1]) :- 1730 Op =.. OL, 1731 append(OL,[X],OL1), 1732 Pred =.. OL1, 1733 call(Pred), 1734 filter_list(Rest,Op,Rest1),!. 1735filter_list([_|Rest],Op,Rest1) :- 1736 filter_list(Rest,Op,Rest1),!. 1737filter_list([],_,[]). 1738 1739 1740 1741% ----------------------utilities--------------------- 1742/* 1743not(X):- \+X. 1744member(X,[X|_]). 1745member(X,[_|L]) :- member(X,L). 1746append([],L,L):-!. 1747append([H|T],L,[H|Z]) :- append(T,L,Z),!. 1748 */ 1749 1750file_exists(Filename):-exists_file(Filename). 1751 1752% subtract(A,B,C): subtract B from A 1753% ------------------------------------- 1754subtract([],_,[]):-!. 1755subtract([A|B],C,D) :- 1756 member(A,C), 1757 subtract(B,C,D),!. 1758subtract([A|B],C,[A|D]) :- 1759 subtract(B,C,D),!. 1760 1761/* arg1 - arg2 = arg3 */ 1762 1763list_take(R,[E|R1],R2):- 1764 remove_el(R,E,RR), 1765 list_take(RR,R1,R2),!. 1766list_take(R,[_|R1],R2):- 1767 list_take(R,R1,R2),!. 1768list_take(A,[],A) :- !. 1769 1770 % remove_el: list * el -> list-el 1771% ---------------------------------- 1772remove_el([],_,[]) :- ! . 1773remove_el([A|B],A,B) :- ! . 1774remove_el([A|B],C,[A|D]) :- 1775 remove_el(B,C,D) . 1776 1777/* generate symbol predicate (from file futile)*/ 1778 1779gensym_special(Root,Atom) :- 1780 getnum(Root,Num), 1781 name(Root,Name1), 1782 name(Num,Name2), 1783 append(Name1,Name2,Name), 1784 name(Atom,Name). 1785 1786getnum(Root,Num) :- 1787 retract(current_num(Root,Num1)),!, 1788 Num is Num1+1, 1789 asserta(current_num(Root,Num)). 1790 1791getnum(Root,1) :- asserta(current_num(Root,1)). 1792 1793 1794/************ end of change_op_representation ***********/ 1795 1796gensym_num(Root,Num,Atom):- 1797 name(Root,Name), 1798 name(Num,Name1), 1799 append(Name,Name1,Name2), 1800 name(Atom,Name2),!. 1801 1802 1803%******************************************************* 1804pprint([],SIZE,SIZE):-!. 1805pprint([HS|TS],Size0,SIZE):- 1806 list(HS), 1807 pprint(HS,Size0,Size1), 1808 pprint(TS,Size1,SIZE),!. 1809pprint([HS|TS],Size0,SIZE):- 1810% write('step '),write(Size0),write(': '), 1811% write(HS),nl, 1812 Size1 is Size0+1, 1813 pprint(TS,Size1,SIZE),!. 1814 1815 1816% list of lists -> list 1817 1818flatten([HO|TO], List, O_List):- 1819 append(HO, List, List_tmp), 1820 flatten(TO, List_tmp, O_List),!. 1821flatten([H|TO], List,O_List):- 1822 append([H], List, List_tmp), 1823 flatten(TO, List_tmp, O_List). 1824flatten([], [HList|T], O_List):- 1825 HList = [], 1826 flatten(T, [], O_List). 1827flatten([], [HList|T], O_List):- 1828 list(HList), 1829 flatten([HList|T],[], O_List),!. 1830flatten([], L,L):-!. 1831 1832% flatten with no duplicate 1833set_flatten([HO|TO], List, O_List):- 1834 set_append_e(HO, List, List_tmp), 1835 set_flatten(TO, List_tmp, O_List),!. 1836set_flatten([H|TO], List,O_List):- 1837 set_append_e([H], List, List_tmp), 1838 set_flatten(TO, List_tmp, O_List). 1839set_flatten([], [HList|T], O_List):- 1840 HList = [], 1841 set_flatten(T, [], O_List). 1842set_flatten([], [HList|T], O_List):- 1843 list(HList), 1844 set_flatten([HList|T],[], O_List),!. 1845set_flatten([], L,L):-!. 1846 1847% list: [el1,el2, ...] --> bool 1848% ----------------------------- 1849list(A) :- 1850 var(A) , 1851 ! , 1852 fail . 1853list(A) :- 1854 functor(A,'.',_). 1855% ***********************for multy tasks***************** 1856:- assert(time_taken(0)). 1857:- assert(soln_size(0)). 1858:- assert(plan_used(0)). 1859 1860solve(N,FN):- 1861 N < FN, 1862 tell(user), 1863 nl,write('task '), write(N),write(': '),nl, 1864 solution_file(F), 1865 tell(F), 1866 nl,write('task '), write(N),write(': '),nl, 1867 solve(N), 1868 Ni is N+1, 1869 solve(Ni,FN). 1870solve(FN,FN):- 1871 tell(user),nl,write('task '), 1872 write(FN),write(': '),nl, 1873 solution_file(F), 1874 tell(F), 1875 nl,write('task '), 1876 write(FN),write(': '),nl, 1877 solve(FN), 1878 retractall(sum(_)), 1879 assert(sum(0)), 1880 sum_time(CP), 1881 retractall(sum(_)), 1882 assert(sum(0)), 1883 sum_size(SIZE), 1884 TIM is CP /1000, 1885 retractall(sum(_)), 1886 assert(sum(0)), 1887 sum_plan(PLAN), 1888 retractall(time_taken(_)), 1889 retractall(soln_size(_)), 1890 retractall(plan_used(_)), 1891 nl,write('total time '),write(TIM),write(' seconds'), 1892 nl,write('total size '),write(SIZE), 1893 nl,write('plan used '),write(PLAN), 1894 nl, 1895 told. 1896 1897sum_time(TIM):- 1898 time_taken(CP), 1899 retract(sum(N)), 1900 N1 is N +CP, 1901 assert(sum(N1)), 1902 fail. 1903sum_time(TIM):- 1904 sum(TIM). 1905sum_size(SIZE):- 1906 soln_size(S), 1907 retract(sum(N)), 1908 N1 is N +S, 1909 assert(sum(N1)), 1910 fail. 1911sum_size(SIZE):- 1912 sum(SIZE). 1913 1914 1915sum_plan(Plan):- 1916 plan_used(PL), 1917 retract(sum(N)), 1918 N1 is N +PL, 1919 assert(sum(N1)), 1920 fail. 1921sum_plan(Plan):- 1922 sum(Plan). 1923 1924 1925%ground the hierarchy structure of HTN planning domain 1926ground_hierarchy:- 1927 ground_predicates, 1928 ground_substate_class,!. 1929 1930% grounding predicates to object level 1931% assert in prolog database as gpredicates(Pred,GPredls) 1932ground_predicates:- 1933 predicates(Preds), 1934 grounding_preds(Preds), 1935 collect_grounded_pred,!. 1936 1937grounding_preds([]). 1938% if it is statics, only choose within atomic_invariants 1939grounding_preds([HPred|TP]):- 1940 functor(HPred,FF,NN), 1941 functor(APred,FF,NN), 1942 atomic_invariants(Atom), 1943 member(APred,Atom), 1944 ground_all_var_atom(HPred), 1945 grounding_preds(TP). 1946% else, combine all the objects 1947grounding_preds([HPred|TP]):- 1948 functor(HPred,FF,NN), 1949 functor(GPred,FF,NN), 1950 ground_all_var(GPred,HPred), 1951 grounding_preds(TP). 1952 1953% collect all the grounded predicates together 1954collect_grounded_pred:- 1955 gpred(Pred,_), 1956 setof(GPred,gpred(Pred,GPred),GPredls), 1957 retractall(gpred(Pred,_)), 1958 assert(gpredicates(Pred,GPredls)), 1959 fail. 1960collect_grounded_pred. 1961 1962% grounding substate_class to primary sort level 1963% assert in prolog database as gsubstate_class(Sort,Obj,States) 1964ground_substate_class:- 1965 substate_classes(Sort,Obj,Substate), 1966 find_prim_sort(Sort,PS), 1967 assert_subclass(PS,Obj,Substate), 1968 fail. 1969ground_substate_class:- 1970 collect_grounded_substates. 1971 1972assert_subclass([],Obj,Substate). 1973assert_subclass([HS|TS],Obj,Substate):- 1974 assert(gsstates(HS,Obj,Substate)), 1975 assert_subclass(TS,Obj,Substate). 1976 1977collect_grounded_substates:- 1978 gsstates(Sort,Obj,_), 1979 setof(SStates,gsstates(Sort,Obj,SStates),GSStates), 1980 retractall(gsstates(Sort,Obj,_)), 1981 all_combined(GSStates,GSStates0), 1982 assert(gsubstate_classes(Sort,Obj,GSStates0)), 1983 fail. 1984collect_grounded_substates. 1985 1986all_combined(SStates,CSStates):- 1987 xprod(SStates,CSStates1), 1988 flat_interal(CSStates1,CSStates),!. 1989 1990flat_interal([],[]):-!. 1991flat_interal([HSS1|TSS1],[HSS|TSS]):- 1992 flatten(HSS1,[],HSS), 1993 flat_interal(TSS1,TSS),!. 1994 1995ground_all_var_atom(HPred):- 1996 functor(HPred,FF,NN), 1997 functor(GPred,FF,NN), 1998 functor(APred,FF,NN), 1999 atomic_invariants(Atom), 2000 member(APred,Atom), 2001 GPred=..[Name|Vars], 2002 APred=..[Name|Sorts], 2003 ground_all_var_atom0(Vars,Sorts), 2004 assert_gpred(GPred), 2005 fail. 2006ground_all_var_atom(HPred). 2007 2008ground_all_var_atom0([],[]). 2009ground_all_var_atom0([HVars|TV],[HSorts|TS]):- 2010 subsorts(HSorts,Subsorts), 2011 split_prim_noprim(Subsorts,PSorts,NPSorts), 2012 member(LS,PSorts), 2013 objects(LS,Objls), 2014 member(HVars,Objls), 2015 ground_all_var_atom0(TV,TS). 2016ground_all_var_atom0([HVar|TV],[HASorts|TS]):- 2017 objects(Sorts,Objls), 2018 member(HASorts,Objls), 2019 HVar=HASorts, 2020 ground_all_var_atom0(TV,TS). 2021 2022ground_all_var(GPred,HPred):- 2023 GPred=..[Name|Vars], 2024 HPred=..[Name|Sorts], 2025 ground_all_var0(Vars,Sorts), 2026 not(inconsistent_constraint([GPred])), 2027 assert_gpred(GPred), 2028 fail. 2029ground_all_var(GPred,HPred). 2030 2031ground_all_var0([],[]). 2032ground_all_var0([HVars|TV],[HSorts|TS]):- 2033 objects(HSorts,Objls), 2034 member(HVars,Objls), 2035 ground_all_var0(TV,TS). 2036ground_all_var0([HVars|TV],[HSorts|TS]):- 2037 subsorts(HSorts,Subsorts), 2038 split_prim_noprim(Subsorts,PSorts,NPSorts), 2039 member(LS,PSorts), 2040 objects(LS,Objls), 2041 member(HVars,Objls), 2042 ground_all_var0(TV,TS). 2043 2044% assert grounded predicates with related upper level predicates 2045 2046assert_gpred(GPred):- 2047 functor(GPred,FF,NN), 2048 functor(UPred,FF,NN), 2049 assert_gpred0(GPred,UPred),!. 2050 2051assert_gpred0(GPred,UPred):- 2052 GPred=..[Name|PSorts], 2053 UPred=..[Name|Vars], 2054 get_obj_sort(Vars,PSorts), 2055 assert(gpred(UPred,GPred)), 2056 fail. 2057assert_gpred0(GPred,UPred). 2058 2059get_obj_sort([],[]):-!. 2060get_obj_sort([HVars|TV],[HObj|TS]):- 2061 objects(HVars,Objls), 2062 member(HObj,Objls), 2063 get_obj_sort(TV,TS),!. 2064 2065delete_all_nodes :- 2066 retractall(node(_,_,_,_,_)), 2067 retractall(final_node(_)), 2068 retractall(tp_node(_,_,_,_,_,_)), 2069 retractall(closed_node(_,_,_,_,_,_)), 2070 retractall(solved_node(_,_,_)). 2071delete_all_nodes :- !. 2072 2073 2074% xprod: list * list --> (list X list) 2075% ----------------------------------- 2076xprod(A,B,C) :- 2077 xprod([A,B],C) . 2078 2079xprod([],[]). 2080xprod(A,E) :- 2081 xprod(A,B,C,D) , 2082 F =..[^,C,D] , 2083 call(setof(B,F,E)) . 2084 2085xprod([X],[A],A,member(A,X)) . 2086xprod([X,Y],[A,B],C,(D,E)) :- 2087 C =..[^,A,B] , 2088 D =..[member,A,X] , 2089 E =..[member,B,Y] . 2090xprod([X|Y],[A|E],D,(F,G)) :- 2091 D =..[^,A,C] , 2092 F =..[member,A,X] , 2093 xprod(Y,E,C,G). 2094 2095 2096:- include(translog4). 2097 2098:- fixup_exports.