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

12:-module(logicmoo_hyhtn_works,[]). 13 14:-multifile(user:push_env_ctx/0). 15:-dynamic(user:push_env_ctx/0). 16 17/* ***********************************/ 18/* Douglas Miles 2005, 2010, 2014 */ 19/* Denton, TX */ 20/* ***********************************/ 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. 35% [Required] Load the Logicmoo Library Utils 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). 45/* 46 * GIPO COPYRIGHT NOTICE, LICENSE AND DISCLAIMER. 47 * 48 * Copyright 2001 - 2003 by R.M.Simpson W.Zhao T.L.McCLuskey D Liu D. Kitchin 49 * 50 * Permission to use, copy, modify, and distribute this software and its 51 * documentation for any purpose and without fee is hereby granted, 52 * provided that the above copyright notice appear in all copies and that 53 * both the copyright notice and this permission notice and warranty 54 * disclaimer appear in supporting documentation, and that the names of 55 * the authors or their employers not be used in advertising or publicity 56 * pertaining to distribution of the software without specific, written 57 * prior permission. 58 * 59 * The authors and their employers disclaim all warranties with regard to 60 * this software, including all implied warranties of merchantability and 61 * fitness. In no event shall the authors or their employers be liable 62 * for any special, indirect or consequential damages or any damages 63 * whatsoever resulting from loss of use, data or profits, whether in an 64 * action of contract, negligence or other tortious action, arising out of 65 * or in connection with the use or performance of this software. 66 */ 67 /* gipohyhtn.pl */ 68/* HyHTN planning: do preprocess first */ 69/* make all method and operators primitive */ 70:-use_module(library(system)). 71/*********************** initialisation**************/ 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. % Used to store full expanded steps 78:- dynamic opCounter/1, temp/1. % Used for grounding operators 79:- dynamic objectsC/2,atomic_invariantsC/1.% Used only dynamic objects 80:- dynamic objectsOfSort/2. % Used to store all objects of a sort 81% for boot.. 82:- dynamic kill_file/1,solution_file/1. 83% 84%:- prolog_flag(single_var_warnings, _, off). 85%:-set_prolog_flag(unknown,fail). 86%:- unknown(error,fail). 87:- op(100,xfy,'=>'). 88%---------------------structure-------------------- 89% for whole search: 90% node(Nodeid, Precond, Decomps, Temp, Statics) 91% tn(Tnid, Name, Precond, Postcond,Temp, Decomps) 92% tn is a full expanded node, it has fixed decomps and postcondtion 93% step(HPid,ActName,Precond,Postcond,Expansion) 94% for fwsearch achieve(Goal) only: 95% tp_goal(Pre,Goal,Statics) 96% goal_related(se(Sort,Obj,SEpre),Opls,LengthToGoal) 97% tp_node(TPid,Pre,Statics,from(Parentid),Score,Steps) 98% closed_node(TPid,Pre,from(Parentid),Score,Steps) 99%---------------------structure end-------------------- 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]) :- 156% write('method::Description:'),write(';'), 157 nl,write('BEGIN METHOD'),nl,write(TN),write(';'), 158 nl,write('Name:'),write(Name),write(';'), 159 nl,write('Pre-condition:'),write(Pre),write(';'), 160% write('Index Transitions:'),write(Pre),write('=>'),write(Post1),write(';'), 161% write('Static:'),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 216/******************** Nodes *******************/ 217% node(Name, Precond ,Decomps, Temp, Statics) 218% Initial Node: node(root, Init, Decomps, Temp, Statics) 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 226%Ron 21/9/01 - Try to give a closedown method 227start_solve(SOLN,OPNUM,_):- 228 kill_file(Kill), 229 file_exists(Kill). 230% write('Found kill file'),nl. 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), 254% nl,write('processing '),write(Node),nl, 255 % expand/prove its hps 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 265/******************************** MAIN LOOP **********/ 266 267% expand a node.. 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 289/************ expand every step in Dec *********************/ 290% expand_decomp(Dec,Pre,Post,Temps,Temp1,Statics,Statics1,Dec1) 291% Pre and Post here is the current ground states changes 292% starts from Initial states to final ground states 293% 0. end, Post is the final ground states 294expand_decomp([],Post,Post,Temp,Temp,Statics,Statics,[]):-!. 295 296% 1. if the step has expand already, get the state change, go to next 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 303% 2. if it is an achieve goal 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 310% 3. if HP's name and it's Pre meet an operator, return operator's name 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 315% apply operator by known its name and post state 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 330% 4. if HP's name meet an method, and it's precondition achieved 331% expand it and make it to that TNs 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 336% apply an method by its name 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 350% 5. get another step which matchs and not after it before it to give a try 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 357% 6. all failed, expanding failed 358/************ end of expand_decomp *********************/ 359 360% get another step which is not after it before it 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 368% ***********expand the achieve goal*********** 369% 1.if the ACH is achieved already 370% remove it from decomposion and do the next 371expand_decomp_ach([step(HPid,ACH,Pre,Post0,unexp)|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,Decomp1):- 372 state_achieved(Post0,Pre), 373% nl,write('step '),write(HPid), 374% write('is already achieved'),nl, 375 remove_temp(Temp,HPid,Temp,Temp2), 376 expand_decomp(Decomp,Pre,Post,Temp2,Temp1,Statics,Statics1,Decomp1),!. 377 378% 2.do expanding achieve goal 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 383% 3. get another step which matchs and not after it before it to give a try 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 389% 4. all failed, expanding failed 390/************ end of expand_decomp_ach *********************/ 391 392%************ expand an achive goal *********************/ 393% 1. directly achieve goal's Pre and Post by operator,method or tn 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 397% 2. else, nothing directly can achieve HP's Pre and Post 398% assert a temporely node for forward search 399% tp_node(TPid,Pre,Statics,from(Parentid),Score,Steps) 400expand_ach_goal(HPid,TN,ACH,Pre,Post,State,Statics,Statics1):- 401 make_tpnodes(Pre,Post,Statics), 402% tell(fred), 403 fwsearch(TN,State), 404% told, 405% all_achieved(Post,Statics1,State), 406 clean_temp_nodes. 407 408% 3. else, fail expand 409/************ end of expand_ach_goal *********************/ 410 411% -------direct expand an achieve goal----------------------- 412%1. if an achieve action meets an TN Pre and post 413direct_expand_ach_goal(HPid,TN,ACH,Pre,Post,State,Statics,Statics):- 414 apply_tn(TN,HPid,ACH,Pre,Post,State,Statics,Statics). 415%2. if an action's action meets an operator Pre and post 416direct_expand_ach_goal(HPid,OP,ACH,Pre,Post,State,Statics,Statics1):- 417 dir_apply_op(OP,HPid,ACH,Pre,Post,State,Statics,Statics1). 418%3. if an achieve action meets a method's pre and post, 419% expand it and make it to that TNs 420direct_expand_ach_goal(HPid,TN,ACH,Pre,Post,State,Statics,Statics1):- 421 dir_apply_method(TN,HPid,ACH,Pre,Post,State,Statics,Statics1),!. 422%4. else, failed for direct expand an achieve goal------ 423 424% apply an TN to an achieve goal that matches both pre and post conditions 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), 430% nl,write('step '),write(HPid), 431 retract(op_num(N)), 432 N1 is N+1, 433 assert(op_num(N1)),!. 434% write('can be expand by tn '),write(Tn0),nl,!. 435 436% directly apply an operator when its Pre and Post matches 437dir_apply_op(Name,HPid,ACH,Pre,Goal,State,Statics,Statics1):- 438% ACH=..[achieve|Rest], 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), 443% state_achieved(Pre,Pre0,Statics2),% can't say because not full instatiate 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), 449% nl,write('step '),write(HPid), 450% write('can be expand by operator '),write(Name),nl, 451 retract(op_num(N)), 452 N1 is N+1, 453 assert(op_num(N1)),!. 454 455% apply mehtod when Pre and Post condition matchs 456dir_apply_method(TN,HPid,ACH,Pre,Goal,State,Statics,Statics1):- 457% ACH=..[achieve|Rest], 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), 462% state_achieved(Pre0,Pre,Statics2), 463 state_change(Pre,Pre0,Post0,State2), 464% rough_state_change(Pre,Pre0,Post0,State2), 465 may_achieved(Post,Statics2,State2), 466% remove_unneed(Statics2,[],Statics21), 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), 470% nl,write('step '),write(HPid), 471% write('can be expand by method '),write(Name),nl, 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 477% make decomposition steps when expand a method 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),!. 509% --------------------end of dir_apply_method/8--------------------- 510/************ end of direct_expand_ach_goal *********************/ 511 512% ----------------forward searching-------------- 513% make tp_node(TPID, Pre,Statics,from(Parent),Score,Steps) 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), 529% find_all_related_op, 530 assert(tp_node(init,Pre,Statics,from(init),0,[])),!. 531 532%tp_node(TP,Pre,Statics,from(Parent),Score,Steps) 533% forward search for operators can't directly solved 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(_,_),%expand every possible way until find solution 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 559% expand all way possible to achieve the Post 560% if Post is achieved by Pre, finish 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 567% check the Post can be solved by direct expand (Operator or Method) 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), 571% gensym(hp,HP), 572 append_dcut(List,[step(HP,achieve(Goal),Pre,State,exp(TN))],List1),!. 573% -------direct expand ----------------------- 574% if the goal canbe achieved by a method's pre and post, 575% expand it and make it to that TNs 576direct_expand(HPid,TN,ACH,Pre,Post,State,Statics,Statics1):- 577 dir_apply_method(TN,HPid,ACH,Pre,Post,State,Statics,Statics1),!. 578 579% search forwards use ground operators only 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 623% select a tp_node with lowest score 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)),!. 629% tell(user),nl,write('new level'),nl,told,!. 630 631% find the lowest_score of tp_node 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 641% assert assert_tnode(TP,OP,PR,Score,Post,Statics1,Steps1), 642%if goal achieved, assert solved_node 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), 653% op_score(OP,SS), 654% Score is Score1-SS, 655 gensym(tp,TP1), 656% write(TP1),nl, 657% write(Steps),nl, 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 667% get the temperal from an ordered steps 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,_,_,_,_). 682% ------------------related goals------------------ 683 684assert_goal_related_init(Pre,[],Statics):-!. 685%assert_goal_related_init(Pre,[se(Sort,Obj,SE)|Post],Statics):- 686% state_achieved([se(Sort,Obj,SE)],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 696% find_all_related_goals: backward search 697% until all preconditions have found 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 %fail to find out, don't search any more 715 % fwsearch use all the ground ops. 716 717 718% final find the actions to recover initial states: 719% in case the initial states was deleted by other actions 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 726% get all the found goal related states 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 743% all the Precondition states in backward search can reach initial states 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 751% find all the states that can achieve the goal state 752% separete ground operators to related-op and unrelated op 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), 765% assert_op_score(ID,OPs), 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),%Sort is a primitive sort changed at init 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), 784% assert_op_score(ID,OPs), 785 assert_goal_related(Prev,[sc(Sort,Obj,FLHS=>FRHS)|Nec],ID,I). 786 787% filter out invars, is_of_sorts and nes from a state list 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 807% filter out nes from a state list 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 820% State2 can be achieved by State1 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 831% assert:goal_related(Pre,Post,Op,DistanseFromGoal) 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),%because conditional didn't ground, so the Sort maybe nonprim 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 867%assert score for Op, the further from goal, the higher the score 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),%length from Present to Goal 878% length(Pre,Obj_Num), 879 get_length(PR,1,Len), 880% Num1 is Obj_Num*Dis,%distanse the smaller the better 881% Num2 is Obj_Num*Len1,%length of the plan the smaller the better 882% Score is Num1+Num2,!. 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),%if it achieved goal 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),%if it does't change initial state 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 911% the states that can achieve a state 912% that is: 913% for a state in the rhs of operator 914% all the states in the lhs 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). 924% find relate in nec 925% the sorts here are primitive 926assert_related_states1(A,Pre,[],ST):-!. 927%when prev 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),!. 931%when nec 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 936% find relate in conditional 937% the sorts here are not primitive 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 953%------------------------------------------- 954% remove HP1 from the temp list 955% if HP1<HP2, then all HP3<HP1 => HP3<HP2 956% if HP2<HP1, then all HP1<HP3 => HP2<HP3 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 967% if HP1<HP2, remove HP1<HP2, and change all HP3<HP1 => HP3<HP2 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),!. 975% if HP2<HP1, remove HP2<HP1, and change all HP1<HP3 => HP2<HP3 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 990/******************************************************/ 991% State2 is achieved by State1 992% the two states need to be primitive 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 1011/************ states ST matchs ST1 ********/ 1012% state_match: ST is achieved by ST1 1013% ST=ST1 1014state_match(Sort,Obj,ST,ST1):- 1015 not(is_diff(ST,ST1)),!. 1016% when ST is the subset of ST1, 1017% in some domain, one substateclass is anothers's subset 1018% they cann't consider as match each other 1019% for example [on_block(a,b)] and [on_block(a,b),clear(a)] 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)),!. 1024% when ST is not the subset of ST1, 1025% in hierarchical domain, maybe one is inhiered by the upperlevel 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 1032% in_same_sub_states: check if ST1+ST2 in one states 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 1038% in_different_states: check if ST,ST1 in different states 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 1048% find out the biggest same items 1049max_member1(State, [], Num, MSub, MSub):-!. 1050% find it out the biggest set of common items in substateclass and State 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 1059% find it out the same items in two list 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 1068% all the element in list1 are static or in list2 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 1077% check if a predicate is statics or not 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 1087/************ state changes by actions ********/ 1088% on the condition that: 1089% an object's state meet action's precondition 1090% it change to the postcondition 1091% Pre is the current ground states(Sort is primitive) 1092% Pre0 and Post0 are from an Operator or Method( 1093% Sorts are all primitive 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 1104% change the obj's post state with action's post 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):-!. 1114%if the pre state in action's pre, not in post, remove that 1115state_change1([Head|SPre],SPre0,SPost0,STPost):- 1116 member(Head,SPre0), 1117 not(member(Head,SPost0)), 1118 state_change1(SPre,SPre0,SPost0,STPost). 1119% if the pre state is not action's pre, neither in post, add that 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),!. 1124% if the pre state is in post, don't need to add 1125% because it will be add at last 1126state_change1([Head|SPre],SPre0,SPost0,STPost):- 1127 member(Head,SPost0), 1128 state_change1(SPre,SPre0,SPost0,STPost). 1129 1130% rough change the obj's post state with action's post 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 1144% a simple state_change for ground operators 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),!. 1162%------------------------------------------------- 1163/************ state changes by necessery changes ********/ 1164% for all the object's state meet the precondition 1165% it change to the postcondition 1166% this is only used in apply grounded operators 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),!. 1176%------------------------------------------------- 1177/************ state changes by conditions ********/ 1178% for all the object's state meet the precondition 1179% it change to the postcondition 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), 1184% var(Obj1), 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)), 1189% state_match(Sort,Obj,SE,SE0), 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 1205% copy the states so that the Obj won't be instiated 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),!. 1224%------------------------------------------- 1225% every states in List1 is achieved by List2 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). 1240%------------------------------------------- 1241% may_achieved: every states in Pre is not conflict with Post 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 1256% if the ST1 is a subset of ST2 1257state_may_achieved(Sort,Obj,[],ST2):-!. 1258state_may_achieved(Sort,Obj,ST1,ST2):- 1259 is_achieved(ST1,ST2),!. 1260%------------------------------------------- 1261% instantiate a bit 1262% use action's state change include the postcondition 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 1280/********* check for statics consist without instanciate them***/ 1281% only instance the variable when there is one choice of from the ground lists 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 1300/*********check for statics consist and instanciate them***/ 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 1340/*********************Initial process *********************/ 1341%node(Name, Precond, Decomps, Temp, Statics) 1342% When inputting new methods etc filter all statics into 1343% static slot 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 1358% make problem to steps 1359make_problem_up([],[]):-!. 1360make_problem_up([achieve(L)|R],[step(HP,achieve(L1),undefd,[L1],unexp)|RS]):- 1361 %preconditon here is undefd 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 %preconditon here is undefd 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 1386%**************sort steps********************************* 1387% sort steps by temporal constraints. 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 1395% find out the steps in temporal constraints. 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 1401% sort the steps_id(hps) by temporal constraints. 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 1414% sort the steps, put the unordered steps in the front 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),!. 1424%******************************************************* 1425 1426% replace ss to se 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 1433%******************************************************* 1434% extract_solution(Node,.. 1435% recurvise routine to work down tree and 1436% print out a linearisation of it 1437extract_solution(Node,PHPs,SIZE1,TNList) :- 1438 % its the name of a hierarchical op...... 1439 getN_decomp(Node, HPs), 1440 push_to_primitive(HPs,[],PHPs,[],TNList), 1441 pprint(PHPs,1,SIZE), 1442 SIZE1 is SIZE -1,!. 1443 1444/************ change_op_representation ***********/ 1445% make pre and post explicit 1446% filter out statics and put in a new slot 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), 1466% make_sc_primitive(D,D1), 1467 %can't do that because it narrow the conditional change 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 1490% get all achieve goals out 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 1516% get rid of the achievals in temp orders 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 1539% since assumed achieval only happen at first, so only change the after ones 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 1558% change the states to primitive states 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 1568% change the state changes to primitive states 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 1579% ------------ end of change operator ---------------------- 1580/********make_tn: save the expansion results*****/ 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), 1586% tell(user),nl,write(tn(TN,Name,Pre1,Post1,Temp,Dec)),nl,told, 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):-!. 1593% just a lazy check if they are in exactly same sequence 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),!. 1606% other fail. 1607 1608% append_dcut only changed states 1609% state_match here means not changed 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 1616%***********print out solution************************** 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 1626/*********** TEMPORAL AND DECLOBBERING ************/ 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)), 1639% nl,nl,write(Name),write(' RETRACTED'),nl,nl, 1640% tell(user), 1641% nl,nl,write(Name),write(' RETRACTED'),nl,nl, 1642% tell(FF), 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),!. 1649/* 1650is_of_primitive_sort(X,Y) :- 1651 objectsC(Y,L),member(X,L). 1652is_of_sort(X,Y) :- 1653 is_of_primitive_sort(X,Y). 1654is_of_sort(X,Y) :- 1655 sorts(Y,SL),member(Z,SL),is_of_sort(X,Z). 1656*/ 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 1663% find out primitive sorts of a sort. 1664find_prim_sort(Sort,PS):- 1665 subsorts(Sort,Subsorts), 1666 split_prim_noprim(Subsorts,PS,NP),!. 1667 1668% find out the objects of a sort 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 1679% find subsorts of a sort(exclude). 1680subsortse(Sort,Subsorts):- 1681 subsorts(Sort,Subsorts1), 1682 subtract(Subsorts1,[Sort],Subsorts),!. 1683% find subsorts of a sort(include). 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 1699% find uppersorts of a sort(excludes). 1700uppersortse(Sort,Uppersorts):- 1701 uppersorts(Sort,Uppersortsf), 1702 subtract(Uppersortsf,[Sort],Uppersorts),!. 1703% find uppersorts of a sort or object(include). 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 1723% sametree: Sort1 and Sort2 are in same sort tree. 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 1737% split a sortlist to primitive sorts and non-primitive sorts. 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 1745/***************** local utils *****************/ 1746 1747/*********** DOMAIN MODEL FUNCTIONS *****************/ 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 1768% ----------------------utilities--------------------- 1769 1770% not(X):- \+X. 1771isemptylist([]):-!. 1772 1773%instantiate variables 1774/* 1775member(X,[X|_]). 1776member(X,[_|L]) :- member(X,L). 1777*/ 1778 1779member_cut(X,[X|_]) :- !. 1780member_cut(X,[_|Y]) :- member_cut(X,Y),!. 1781 1782% member_e: X is the exact memeber of List 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 1797% u_mem in ob_utils is SLOW!?. 1798% this is a fast impl. 1799u_mem_cut(_,[]):-!,fail. 1800u_mem_cut(X,[Y|_]) :- X == Y,!. 1801u_mem_cut(X,[_|L]) :- u_mem_cut(X,L),!. 1802% check if object X is a member of a objects list 1803% 1. if it is not a variable, check if it is in the list 1804% 2. X is a variable, and the list only has one objects, make X as that obj 1805% 3. X is a variable, but the list has more than one objects, leave X unchange 1806obj_member(X,[X|[]]):-!. 1807obj_member(X,List):- 1808 obj_member0(X,List),!. 1809obj_member0(X,[Y|_]):- 1810 var(X),!.%if X is var, but Y not, the leave X as that variable 1811obj_member0(X,[Y|_]):- 1812 X==Y,!. 1813obj_member0(X,[_|Y]) :- obj_member0(X,Y),!. 1814 1815 1816% check if a predicate is a member of a ground predicate list, 1817% just used in binding the predicates to a sort without instantiate it 1818% for efficiency, instantiate the variable if the list only have one atom 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 1862% append_st: append_dcut two statics 1863% remove the constants that no need 1864% instanciate the viables that all ready been bind 1865% ------------------------------------------ 1866append_st(ST1,ST2,ST):- 1867 append_cut(ST1,ST2,ST0), 1868 remove_unneed(ST0,[],ST),!. 1869 1870% remove the constants that no need 1871% instanciate the variables that all ready been bind 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 1919% two states or lists are equal 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 1945% two states or lists are different 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 1964% set_append: list1 + list2 -> list 1965% no duplicate, do instanciation 1966% ------------------------------------------ 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 1974% set_append_e: list1 + list2 -> list 1975% no duplicate, no instanciation 1976% ------------------------------------------ 1977set_append_e(A,B,C):- 1978 append_cut(A,B,D), 1979 remove_dup(D,[],C),!. 1980 1981% remove duplicate 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 1990% two atom lists equals (without instantiate variables) 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 2003% subtract(A,B,C): subtract B from A 2004% ------------------------------------- 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 2012/* arg1 - arg2 = arg3 */ 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 2021% remove_el: list * el -> list-el 2022% ---------------------------------- 2023remove_el([],_,[]) :- ! . 2024remove_el([A|B],A,B) :- ! . 2025remove_el([A|B],C,[A|D]) :- 2026 remove_el(B,C,D) . 2027 2028/* generate symbol predicate (from file futile)*/ 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):- 2057% write('step '),write(Size0),write(': '), 2058% write(HS),nl, 2059 Size1 is Size0+1, 2060 pprint(TS,Size1,SIZE),!. 2061 2062/* split static and dynamic from states*/ 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 2073% list of lists -> list 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 2089% flatten with no duplicate 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 2105% list: [el1,el2, ...] --> bool 2106% ----------------------------- 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 2121% ***********************for multy tasks***************** 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. 2165% State1 has relation with State2 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 2172% all states in necc are primitive 2173% so does the goal state--State2 2174state_related([se(Sort,Obj,SE1)|State1],State2):- 2175 member(se(Sort,Obj,SE2),State2), 2176 state_related0(SE1,SE2). 2177% states in Cond are not neccessary primitive 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 2187%instatiate abit the variables 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 2195% change_obj_list: narrow down objects 2196% by just using the objects occure in initial states(world state) 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 2209% only keep the dynamic objects that used in tasks 2210change_obj_list2(Sort):- 2211 objectsC(Sort,Objls),!. 2212% statics objects: keep 2213change_obj_list2(Sort):- 2214 objects(Sort,Objls), 2215 assert(objectsC(Sort,Objls)),!. 2216 2217% only keep the dynamic objects in atomic_invariants 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 2258% ******************************************************************** 2259% ground all operators% enumerateOps 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 %Find the atomic_invariants 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 2287% ********************************************************************* 2288% findVarsAndTypes - collect a list of all variables and their 2289% types as they occur in an operator 2290% also collect the list of "ne" constraints 2291% that apply to variables 2292% [<Type>,<Variable>|<Rest>] 2293% 2294% findVarsAndTypes(+Operator,-TypeVarList,-Nes) 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 2304% collect all Vars and types in a changes clause 2305%vtEffects(+EffectsClause,-VarsTypes,-NEClauses). 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 2316% collect all Vars and types in a Prevail clause 2317%vtPrevail(+PrevailClause,-VarsTypes,-NEClauses). 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 2328% Deal with the change predicates in a changes clause 2329% vtPreds(+ChangeProps,-VarsTypes,-NEClauses). 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 2337% Deal with a list of literals 2338% vtPLst(+Literals,-VarTypes,-NEClauses). 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 2355% here is the hard bit, Create a dummy literal - instantiate it with 2356% the OCL predicate list to find the types then 2357% match up the type with the original literal variables. 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 2371% Create a list of new uninstantiated variables 2372% createVarList(+NoOfVariablesNeeded, -ListOfvariables). 2373 2374createVarList(1,[X]) :- 2375 !. 2376 2377createVarList(N,[X|Rest]) :- 2378 Next is N - 1, 2379 createVarList(Next,Rest). 2380 2381% merge the list of variables and the list of types 2382% pair(+TypeList,+VarList,-varTypeList). 2383 2384pair([],[],[]). 2385 2386pair([Type|Types],[Var|Vars],[Type,Var|Rest]) :- 2387 pair(Types,Vars,Rest). 2388 2389 2390 2391% ********************************************************************** 2392% Top Level Routine to instantiate / ground operators in all legal ways 2393% 2394% instOps 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 2433% filterSE - remove ne and is_of_sort clauses 2434 2435filterSE([],[]) :- !. 2436filterSE([se(Sort,Id,Preds)|Rest],[se(Sort,Id,FPreds)|FRest]) :- 2437 filterPreds(Preds,FPreds),!, 2438 filterSE(Rest,FRest). 2439 2440% filterSC - remove ne and is_of_sort clauses 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 2449% FilterPreds - remove ne and is_of_sort clauses 2450 2451filterPreds([],[]). 2452filterPreds([ne(_,_)|Rest],FRest) :- 2453 !, 2454 filterPreds(Rest,FRest). 2455filterPreds([is_of_sort(_,_)|Rest],FRest) :- 2456 !, 2457 filterPreds(Rest,FRest). 2458%filterPreds([Pred|Rest],FRest) :- 2459% atomic_invariantsC(Invars), 2460% member(Pred,Invars), 2461% !, 2462% filterPreds(Rest,FRest). 2463filterPreds([H|T],[H|FT]) :- 2464 filterPreds(T,FT). 2465 2466 2467% Collect all possible ways of instantiating the conditional effects 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 2486% Find the atomic_invariants in the Operator 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 2531% Select values for the variables in the operator 2532% 2533% chooseVals(+TypeVarList,+NEList,+Invariants,-VarValueList) 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 2594% ********************************************************************** 2595% prettyPrinting Routines for ground OCL operators 2596% long and boring 2597 2598 2599% prettyPrintOp(+<Ground Operator>) 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 2736% change substate_class to primary sort level 2737% assert in prolog database as gsubstate_class(Sort,Obj,States) 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 2769% xprod: list * list --> (list X list) 2770% ----------------------------------- 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 2794% :-sleep(1). 2795% :-tell(user),run_header_tests. 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.