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 23 24% [Required] Load the Logicmoo Library Utils 25:- ensure_loaded(library(logicmoo_common)). 26:- ensure_loaded(library(planner_api)). 27:- use_module(library(logicmoo_planner)). 28 29:- kb_shared(baseKB:mpred_prop/3). 30 31:- ensure_loaded(library(logicmoo/util_structs)). 32:- ensure_loaded(library(logicmoo/util_bb_env)). 33:- prolog_load_context(file,File),ain(user:env_source_file(File)). 34 35:-op(500,fx,env_call). 36 37/* 38 * GIPO COPYRIGHT NOTICE, LICENSE AND DISCLAIMER. 39 * 40 * Copyright 2001 - 2003 by R.M.Simpson W.Zhao T.L.McCLuskey D Liu D. Kitchin 41 * 42 * Permission to use, copy, modify, and distribute this software and its 43 * documentation for any purpose and without fee is hereby granted, 44 * provided that the above copyright notice appear in all copies and that 45 * both the copyright notice and this permission notice and warranty 46 * disclaimer appear in supporting documentation, and that the names of 47 * the authors or their employers not be used in advertising or publicity 48 * pertaining to distribution of the software without specific, written 49 * prior permission. 50 * 51 * The authors and their employers disclaim all warranties with regard to 52 * this software, including all implied warranties of merchantability and 53 * fitness. In no event shall the authors or their employers be liable 54 * for any special, indirect or consequential damages or any damages 55 * whatsoever resulting from loss of use, data or profits, whether in an 56 * action of contract, negligence or other tortious action, arising out of 57 * or in connection with the use or performance of this software. 58 */ 59 /* gipohyhtn.pl */ 60/* HyHTN planning: do preprocess first */ 61/* make all method and operators primitive */ 62:-use_module(library(system)). 63/*********************** initialisation**************/ 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115:- dynamic op_num/1, my_stats/1. 116:- dynamic node/7,final_node/1. 117:- dynamic methodC/7, opParent/6,operatorC/5,gOperator/3. 118:- dynamic tp_goal/3,tp_node/6,closed_node/6,solved_node/5,solved_node/2. 119:- dynamic goal_related/4. 120:- dynamic goal_related/3. 121:- dynamic tn/6. % Used to store full expanded steps 122:- dynamic opCounter/1, temp/1. % Used for grounding operators 123:- dynamic objectsC/2,atomic_invariantsC/1.% Used only dynamic objects 124:- dynamic objectsOfSort/2. % Used to store all objects of a sort 125% for boot.. 126:- dynamic kill_file/1,solution_file/1. 127% 128% :-expects_dialect(sicstus). 129:- style_check(-singleton). 130%:- prolog_flag(single_var_warnings, _, off). 131%:-set_prolog_flag(unknown,fail). 132%:- unknown(error,fail). 133:- op(100,xfy,'=>'). 134%---------------------structure-------------------- 135% for whole search: 136% node(Nodeid, Precond, Decomps, Temp, Statics) 137% tn(Tnid, Name, Precond, Postcond,Temp, Decomps) 138% tn is a full expanded node, it has fixed decomps and postcondtion 139% step(HPid,ActName,Precond,Postcond,Expansion) 140% for fwsearch achieve(Goal) only: 141% tp_goal(Pre,Goal,Statics) 142% goal_related(se(Sort,Obj,SEpre),Opls,LengthToGoal) 143% tp_node(TPid,Pre,Statics,from(Parentid),Score,Steps) 144% closed_node(TPid,Pre,from(Parentid),Score,Steps) 145%---------------------structure end-------------------- 146 147op_num(0). 148my_stats(0). 149 150startOCL(Goal,Init):- 151 dmsg('startOCL-PLANNER-TASK'(Goal)), 152 planner_interface(Goal,Init,Sol,_,TNLst), 153 solution_file(F), 154 tell(F), 155 write('TASK '),write(Id),nl, 156 write('SOLUTION'),nl, 157 display_sol(Sol), 158 write('END FILE'),nl,nl, 159 reverse(TNLst,TNForward), 160 display_details(TNForward), 161 write('END PLANNER RESULT'), 162 told,(clean). 163 164solve(Id) :- 165 htn_task(Id,Goal,Init), 166 planner_interface(Goal,Init,Sol,_,TNLst), 167 solution_file(F), 168 tell(F), 169 write('TASK '),write(Id),nl, 170 write('SOLUTION'),nl, 171 display_sol(Sol), 172 write('END FILE'),nl,nl, 173 reverse(TNLst,TNForward), 174 display_details(TNForward), 175 write('END PLANNER RESULT'), 176 told, 177 clean. 178 179solve(Id) :- 180 planner_task(Id,Goal,Init), 181 planner_interface(Goal,Init,Sol,_,TNLst), 182 solution_file(F), 183 tell(F), 184 write('TASK '),write(Id),nl, 185 write('SOLUTION'),nl, 186 display_sol(Sol), 187 write('END FILE'),nl,nl, 188 reverse(TNLst,TNForward), 189 display_details(TNForward), 190 write('END PLANNER RESULT'), 191 told, 192 clean. 193 194display_sol([]). 195display_sol([H|T]) :- 196 write(H), 197 nl, 198 display_sol(T). 199 200display_details([]). 201display_details([tn(TN,Name,Pre,Post,Temp,Dec)|Rest]) :- 202% write('method::Description:'),write(';'), 203 nl,write('BEGIN METHOD'),nl,write(TN),write(';'), 204 nl,write('Name:'),write(Name),write(';'), 205 nl,write('Pre-condition:'),write(Pre),write(';'), 206% write('Index Transitions:'),write(Pre),write('=>'),write(Post1),write(';'), 207% write('Static:'),write(';'), 208 nl,write('Temporal Constraints:'),write(Temp),write(';'), 209 nl,write('Decomposition:'),write(Dec),write(';'), 210 nl, 211 display_details(Rest). 212 213 214clean:- 215 retractall(op_num(_)), 216 retractall(my_stats(_)), 217 retractall(current_num(_,_)), 218 retractall(node(_,_,_,_,_)), 219 retractall(final_node(_)), 220 retractall(tn(_,_,_,_,_,_)), 221 retractall(methodC(_,_,_,_,_,_,_)), 222 retractall(operatorC(_,_,_,_,_)), 223 retractall(gOperator(_,_,_)), 224 retractall(goal_related(_,_,_)), 225 retractall(goal_related_search(_)), 226 retractall(opCounter(_)), 227 retractall(opParent(_,_,_,_,_,_)), 228 retractall(temp(_)), 229 retractall(objectsOfSort(_,_)), 230 retractall(related_op(_)), 231 retractall(op_score(_,_)), 232 retractall(objectsC(_,_)), 233 retractall(solved_node(_,_)), 234 retractall(tp_node(_,_,_,_,_,_)), 235 retractall(closed_node(_,_,_,_,_,_)), 236 retractall(score_list(_)), 237 retractall(atomic_invariantsC(_)), 238 retractall(gsubstate_classes(_,_,_)), 239 retractall(is_of_sort(_,_)), 240 retractall(is_of_primitive_sort(_,_)), 241 retractall(objectsD(_,_)), 242 assert(op_num(0)), 243 assert(my_stats(0)). 244 245planner_interface(G,I, SOLN,OPNUM,TNList):- 246 change_obj_list(I), 247 ground_op, 248 assert_is_of_sort, 249 change_op_representation, 250 prim_substate_class, 251 retract(op_num(_)), 252 assert(op_num(0)), 253 statistics(runtime,[_,Time]), 254 (retract(my_stats(_)) ; true), 255 assert(my_stats(Time)), 256 make_problem_into_node(I, G, Node), 257 assert(Node), 258 start_solve(SOLN,OPNUM,TNList). 259planner_interface(G,I, SOLN,OPNUM,TNList):- 260 tell(user),nl,write('failure in initial node'),!. 261 262/******************** Nodes *******************/ 263% node(Name, Precond ,Decomps, Temp, Statics) 264% Initial Node: node(root, Init, Decomps, Temp, Statics) 265 266getN_name(node(Name, _, _, _,_), Name). 267getN_pre(node(_,Pre, _, _, _), Pre). 268getN_decomp(node(_, _, Decomp,_,_), Decomp). 269getH_temp(node(_, _, _,Temps, _), Temps). 270getN_statics(node(_,_,_,_,Statics), Statics). 271 272%Ron 21/9/01 - Try to give a closedown method 273start_solve(SOLN,OPNUM,_):- 274 kill_file(Kill), 275 file_exists(Kill). 276% write('Found kill file'),nl. 277 278start_solve(Sol,OPNUM,TNList):- 279 retract(final_node(Node)), 280 retractall(current_num(_,_)), 281 getN_statics(Node,Statics), 282 statics_consist(Statics), 283 extract_solution(Node,Sol,SIZE,TNList), 284 statistics(runtime,[_,CP]), 285 TIM is CP/1000, tell(user), 286 retract(op_num(OPNUM)), 287 assert(op_num(0)), 288 nl, nl, write('CPU Time = '),write(CP),nl, 289 write('TIME TAKEN = '),write(TIM), 290 write(' SECONDS'),nl, 291 write('Solution SIZE = '),write(SIZE),nl, 292 write('Operator Used = '),write(OPNUM),nl, 293 write('***************************************'), 294 assert(time_taken(CP)), 295 assert(soln_size(SIZE)), 296 retractall(tn(_,_,_,_,_,_)), 297 !. 298start_solve(Sol,OPNUM,TNList):- 299 select_node(Node), 300% nl,write('processing '),write(Node),nl, 301 % expand/prove its hps 302 process_node(Node), 303 start_solve(Sol,OPNUM,TNList). 304start_solve(Sol,OPNUM,TNList):- 305 tell(user), write('+++ task FAILED +++'), 306 clean. 307 308:- discontiguous expand_decomp/8. 309:- discontiguous expand_node1/8. 310 311/******************************** MAIN LOOP **********/ 312 313% expand a node.. 314process_node(Node) :- 315 getN_name(Node, Name), 316 getN_pre(Node, Pre), 317 getN_decomp(Node, Dec), 318 getH_temp(Node, Temps), 319 getN_statics(Node, Statics), 320 expand_decomp(Dec,Pre,Post,Temps,Temp1,Statics,Statics1,Dec1), 321 statics_consist(Statics), 322 assert_node(Name,Pre,Dec1,Temp1,Statics1). 323 324assert_node(Name,Pre,Decomp,Temp,Statics):- 325 all_HP_expanded(Decomp), 326 assert(final_node(node(Name,Pre,Decomp,Temp,Statics))),!. 327assert_node(Name,Pre,Dec,Temp,Statics):- 328 gensym_special(root,SYM), 329 assert(node(SYM,Pre,Dec,Temp,Statics)),!. 330 331all_HP_expanded([]):-!. 332all_HP_expanded([step(HPid,Name,_,_,exp(TN))|THPS]):- 333 all_HP_expanded(THPS),!. 334 335/************ expand every step in Dec *********************/ 336% expand_decomp(Dec,Pre,Post,Temps,Temp1,Statics,Statics1,Dec1) 337% Pre and Post here is the current ground states changes 338% starts from Initial states to final ground states 339% 0. end, Post is the final ground states 340expand_decomp([],Post,Post,Temp,Temp,Statics,Statics,[]):-!. 341 342% 1. if the step has expand already, get the state change, go to next 343expand_decomp([step(HPid,Name,Pre0,Post0,exp(TN))|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,[step(HPid,Name,Pre,State,exp(TN))|Decomp1]):- 344 state_achieved(Pre0,Pre), 345 state_change(Pre,Pre0,Post0,State), 346 statics_consist(Statics), 347 expand_decomp(Decomp,State,Post,Temp,Temp1,Statics,Statics1,Decomp1),!. 348 349% 2. if it is an achieve goal 350expand_decomp([step(HPid,ACH,Pre0,Post0,unexp)|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,Decomp1):- 351 ACH=..[achieve|_], 352 statics_consist(Statics), 353 expand_decomp_ach([step(HPid,ACH,Pre,Post0,unexp)|Decomp],Pre,Post, 354 Temp,Temp1,Statics,Statics1,Decomp1),!. 355 356% 3. if HP's name and it's Pre meet an operator, return operator's name 357expand_decomp([step(HPid,Name,undefd,undefd,unexp)|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,[step(HPid,Name,Pre,State,exp(Name))|Decomp1]):- 358 apply_op(Name,HPid,Name,Pre,undefd,State,Statics,Statics2), 359 expand_decomp(Decomp,State,Post,Temp,Temp1,Statics2,Statics1,Decomp1),!. 360 361% apply operator by known its name and post state 362apply_op(Name,HPid,Name,Pre,Post,State,Statics,Statics1):- 363 operatorC(Name,Pre0,Post0,Cond,Statics0), 364 statics_append(Statics0,Statics,Statics2), 365 state_achieved(Pre,Pre0,Statics2), 366 state_change(Pre,Pre0,Post0,State2), 367 cond_state_change(State2,Cond,State), 368 all_achieved(Post,Statics2,State), 369 remove_unneed(Statics2,[],Statics1), 370 statics_consist_instance(Statics1), 371 statics_consist_instance(Statics0), 372 retract(op_num(N)), 373 N1 is N+1, 374 assert(op_num(N1)),!. 375 376% 4. if HP's name meet an method, and it's precondition achieved 377% expand it and make it to that TNs 378expand_decomp([step(HPid,Name,undefd,undefd,unexp)|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,[step(HPid,Name,Pre,State,exp(TN))|Decomp1]):- 379 apply_method(TN,HPid,Name,Pre,undefd,State,Statics,Statics2), 380 expand_decomp(Decomp,State,Post,Temp,Temp1,Statics2,Statics1,Decomp1),!. 381 382% apply an method by its name 383apply_method(TN,HPid,Name,Pre,Post,State,Statics,Statics1):- 384 methodC(Name,Pre0,Post0,Statics0,Temp0,achieve(ACH0),Dec0), 385 statics_append(Statics0,Statics,Statics2), 386 all_achieved(Pre0,Statics2,Pre), 387 remove_unneed(Statics2,[],Statics21), 388 make_dec1(HPid,Pre,ACH0,Statics21,Temp0,Dec0,Temp2,Dec2), 389 expand_decomp(Dec2,Pre,State,Temp2,Temp1,Statics21,Statics1,Dec1), 390 all_achieved(Post,Statics1,State), 391 retract(op_num(N)), 392 N1 is N+1, 393 assert(op_num(N1)), 394 make_tn(TN,Name,Pre,State,Temp1,Dec1),!. 395 396% 5. get another step which matchs and not after it before it to give a try 397expand_decomp([step(HP,N,Pre0,Post0,unexp)|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,Decomp1):- 398 get_another_step(step(HP2,N2,Pre2,Post2,Exp),Pre,Statics, 399 HP,Temp,Temp2,Decomp,Decomp2), 400 expand_decomp([step(HP2,N2,Pre2,Post2,Exp),step(HP,N,Pre0,Post0,unexp)|Decomp2], 401 Pre,Post,Temp2,Temp1,Statics,Statics1,Decomp1). 402 403% 6. all failed, expanding failed 404/************ end of expand_decomp *********************/ 405 406% get another step which is not after it before it 407get_another_step(A,Pre,Statics,HP,Temp,Temp1,[],Dec2):-fail. 408get_another_step(step(HP2,Name2,Pre2,Post2,Exp),Pre,Statics,HP,Temp,[before(HP2,HP)|Temp],Dec,Dec2):- 409 member(step(HP2,Name2,Pre2,Post2,Exp),Dec), 410 not(necessarily_before(HP,HP2, Temp)), 411 state_achieved(Pre2,Pre,Statics), 412 list_take(Dec,[step(HP2,Name2,Pre2,Post2,Exp)],Dec2). 413 414% ***********expand the achieve goal*********** 415% 1.if the ACH is achieved already 416% remove it from decomposion and do the next 417expand_decomp_ach([step(HPid,ACH,Pre,Post0,unexp)|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,Decomp1):- 418 state_achieved(Post0,Pre), 419% nl,write('step '),write(HPid), 420% write('is already achieved'),nl, 421 remove_temp(Temp,HPid,Temp,Temp2), 422 expand_decomp(Decomp,Pre,Post,Temp2,Temp1,Statics,Statics1,Decomp1),!. 423 424% 2.do expanding achieve goal 425expand_decomp_ach([step(HPid,ACH,Pre,Post0,unexp)|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,[step(HPid,ACH,Pre,Post0,exp(TN))|Decomp1]):- 426 expand_ach_goal(HPid,TN,ACH,Pre,Post0,State,Statics,Statics2), 427 expand_decomp(Decomp,State,Post,Temp,Temp1,Statics2,Statics1,Decomp1),!. 428 429% 3. get another step which matchs and not after it before it to give a try 430expand_decomp_ach([step(HPid,ACH,Pre,Post0,unexp)|Decomp],Pre,Post,Temp,Temp1,Statics,Statics1,[step(HPid,ACH,Pre,Post0,exp(TN))|Decomp1]):- 431 get_another_step(step(HP2,N2,Pre2,Post2,Exp),Pre,Statics, 432 HP,Temp,Temp2,Decomp,Decomp2), 433 expand_decomp([step(HP2,N2,Pre2,Post2,Exp),step(HPid,ACH,Pre,Post0,unexp)|Decomp2], Pre,Post,Temp2,Temp1,Statics,Statics1,Decomp1). 434 435% 4. all failed, expanding failed 436/************ end of expand_decomp_ach *********************/ 437 438%************ expand an achive goal *********************/ 439% 1. directly achieve goal's Pre and Post by operator,method or tn 440expand_ach_goal(HPid,TN,ACH,Pre,Post,State,Statics,Statics1):- 441 direct_expand_ach_goal(HPid,TN,ACH,Pre,Post,State,Statics,Statics1),!. 442 443% 2. else, nothing directly can achieve HP's Pre and Post 444% assert a temporely node for forward search 445% tp_node(TPid,Pre,Statics,from(Parentid),Score,Steps) 446expand_ach_goal(HPid,TN,ACH,Pre,Post,State,Statics,Statics1):- 447 make_tpnodes(Pre,Post,Statics), 448% tell(fred), 449 fwsearch(TN,State), 450% told, 451% all_achieved(Post,Statics1,State), 452 clean_temp_nodes. 453 454% 3. else, fail expand 455/************ end of expand_ach_goal *********************/ 456 457% -------direct expand an achieve goal----------------------- 458%1. if an achieve action meets an TN Pre and post 459direct_expand_ach_goal(HPid,TN,ACH,Pre,Post,State,Statics,Statics):- 460 apply_tn(TN,HPid,ACH,Pre,Post,State,Statics,Statics). 461%2. if an action's action meets an operator Pre and post 462direct_expand_ach_goal(HPid,OP,ACH,Pre,Post,State,Statics,Statics1):- 463 dir_apply_op(OP,HPid,ACH,Pre,Post,State,Statics,Statics1). 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502%3. if an achieve action meets a method's pre and post, 503% expand it and make it to that TNs 504direct_expand_ach_goal(HPid,TN,ACH,Pre,Post,State,Statics,Statics1):- 505 dir_apply_method(TN,HPid,ACH,Pre,Post,State,Statics,Statics1),!. 506%4. else, failed for direct expand an achieve goal------ 507 508% apply an TN to an achieve goal that matches both pre and post conditions 509apply_tn(Tn0,HPid,ACH,Pre,Post,State,Statics,Statics):- 510 tn(Tn0,Name,Pre0,Post0,Temp0,Decomp0), 511 state_achieved(Pre0,Pre), 512 state_change(Pre,Pre0,Post0,State), 513 all_achieved(Post,Statics,State), 514% nl,write('step '),write(HPid), 515 retract(op_num(N)), 516 N1 is N+1, 517 assert(op_num(N1)),!. 518% write('can be expand by tn '),write(Tn0),nl,!. 519 520% directly apply an operator when its Pre and Post matches 521dir_apply_op(Name,HPid,ACH,Pre,Goal,State,Statics,Statics1):- 522% ACH=..[achieve|Rest], 523 make_se_primitive(Goal,Post), 524 operatorC(Name,Pre0,Post0,Cond,Statics0), 525 statics_append(Statics0,Statics,Statics2), 526 state_related(Post0,Cond,Post), 527% state_achieved(Pre,Pre0,Statics2),% can't say because not full instatiate 528 state_change(Pre,Pre0,Post0,State2), 529 cond_state_change(State2,Cond,State), 530 all_achieved(Post,Statics2,State), 531 remove_unneed(Statics2,[],Statics1), 532 statics_consist(Statics1), 533% nl,write('step '),write(HPid), 534% write('can be expand by operator '),write(Name),nl, 535 retract(op_num(N)), 536 N1 is N+1, 537 assert(op_num(N1)),!. 538 539% apply mehtod when Pre and Post condition matchs 540dir_apply_method(TN,HPid,ACH,Pre,Goal,State,Statics,Statics1):- 541% ACH=..[achieve|Rest], 542 make_se_primitive(Goal,Post), 543 methodC(Name,Pre0,Post0,Statics0,Temp0,achieve(ACH0),Dec0), 544 statics_append(Statics0,Statics,Statics2), 545 state_related(Post0,Post), 546% state_achieved(Pre0,Pre,Statics2), 547 state_change(Pre,Pre0,Post0,State2), 548% rough_state_change(Pre,Pre0,Post0,State2), 549 may_achieved(Post,Statics2,State2), 550% remove_unneed(Statics2,[],Statics21), 551 make_dec1(HPid,Pre,ACH0,Statics2,Temp0,Dec0,Temp2,Dec2), 552 expand_decomp(Dec2,Pre,State,Temp2,Temp1,Statics2,Statics1,Dec1), 553 all_achieved(Post,Statics1,State), 554% nl,write('step '),write(HPid), 555% write('can be expand by method '),write(Name),nl, 556 retract(op_num(N)), 557 N1 is N+1, 558 assert(op_num(N1)), 559 make_tn(TN,Name,Pre,State,Temp1,Dec1),!. 560 561% make decomposition steps when expand a method 562make_dec1(HPid,Pre,ACH,Statics,Temp,Dec,Temp1,Dec1):- 563 var(HPid), 564 gensym_special(hp,HPid), 565 make_dec1(HPid,Pre,ACH,Statics,Temp,Dec,Temp1,Dec1),!. 566make_dec1(HPid,Pre,ACH,Statics,Temp,Dec,Temp1,Dec1):- 567 all_achieved(ACH,Statics,Pre), 568 make_dec01(HPid,1,Dec,Dec1), 569 change_temp(HPid,Temp,[],Temp1),!. 570make_dec1(HPid,Pre,ACH,Statics,Temp,Dec,[before(STID0,STID1)|Temp1],[step(STID0,achieve(ACH),Pre,ACH,unexp)|Dec1]):- 571 gensym_num(HPid,0,STID0), 572 gensym_num(HPid,1,STID1), 573 make_dec01(HPid,1,Dec,Dec1), 574 change_temp(HPid,Temp,[],Temp1),!. 575 576make_dec01(HPid,_,[],[]):-!. 577make_dec01(HPid,Num,[HDec|TDec],[step(STID,HDec,undefd,undefd,unexp)|TDec0]):- 578 operatorC(HDec,_,_,_,_), 579 gensym_num(HPid,Num,STID), 580 Num1 is Num + 1, 581 make_dec01(HPid,Num1,TDec,TDec0). 582make_dec01(HPid,Num,[HDec|TDec],[step(STID,HDec,undefd,undefd,unexp)|TDec0]):- 583 methodC(HDec,_,_,_,_,_,_), 584 gensym_num(HPid,Num,STID), 585 Num1 is Num + 1, 586 make_dec01(HPid,Num1,TDec,TDec0). 587 588change_temp(HPid,[],Temp2,Temp2):-!. 589change_temp(HPid,[before(N1,N2)|Temp],Temp2,[before(ST1,ST2)|Temp0]):- 590 gensym_num(HPid,N1,ST1), 591 gensym_num(HPid,N2,ST2), 592 change_temp(HPid,Temp,Temp2,Temp0),!. 593% --------------------end of dir_apply_method/8--------------------- 594/************ end of direct_expand_ach_goal *********************/ 595 596% ----------------forward searching-------------- 597% make tp_node(TPID, Pre,Statics,from(Parent),Score,Steps) 598make_tpnodes(Pre,Post, Statics):- 599 opCounter(Num), 600 Num>=1000, 601 retractall(tp_goal(_,_,_)), 602 retractall(related_op(_,_)), 603 assert(tp_goal(Pre,Post,Statics)), 604 assert(tp_node(init,Pre,Statics,from(init),0,[])),!. 605 606make_tpnodes(Pre,Post, Statics):- 607 retractall(tp_goal(_,_,_)), 608 retractall(related_op(_,_)), 609 assert(tp_goal(Pre,Post,Statics)), 610 assert_goal_related_init(Pre,Post,Statics), 611 assert(op_score(goal,0)), 612 find_all_related_goals(Pre,Statics,1,N), 613% find_all_related_op, 614 assert(tp_node(init,Pre,Statics,from(init),0,[])),!. 615 616%tp_node(TP,Pre,Statics,from(Parent),Score,Steps) 617% forward search for operators can't directly solved 618fwsearch(TN,State):- 619 retract(solved_node(_,step(HP,Name,Pre,State,exp(TN)))). 620fwsearch(TN,State):- 621 select_tnode(tp_node(TP,Pre,Statics,from(PR),Score,Steps)), 622 assert(closed_node(TP,Pre,Statics,from(PR),Score,Steps)), 623 expand_node(TP,OP,Statics,Statics1,Pre,Post,from(PR),Steps,Steps1), 624 assert_tnode(TP,OP,PR,Score1,Post,Statics1,Steps1), 625 solved_node(_,_),%expand every possible way until find solution 626 fwsearch(TN,State). 627fwsearch(TN,State):- 628 tp_node(TP,Pre,Statics,from(PR),Score,Steps), 629 fwsearch(TN,State). 630 631clean_temp_nodes:- 632 retractall(tp_goal(_,_)), 633 retractall(goal_related(_,_,_)), 634 retractall(goal_related_search(_)), 635 retractall(related_op(_)), 636 retractall(op_score(_,_)), 637 retractall(score_list(_)), 638 retractall(solved_node(_,_)), 639 retractall(current_num(tp,_)), 640 retractall(tp_node(_,_,_,_,_,_)), 641 retractall(closed_node(_,_,_,_,_,_)),!. 642 643% expand all way possible to achieve the Post 644% if Post is achieved by Pre, finish 645expand_node(TP,done,Statics,Statics,Pre,Pre,from(PR),List,List):- 646 tp_goal(_,Goal,_), 647 state_achieved(Goal,Pre,Statics),!. 648expand_node(TP,TN,Statics,Statics1,Pre,State,from(PR),List,List1):- 649 expand_node1(TN,Statics,Statics1,Pre,State,from(PR),List,List1). 650 651% check the Post can be solved by direct expand (Operator or Method) 652expand_node1(TN,Statics,Statics1,Pre,State,from(PR),List,List1):- 653 tp_goal(_,Goal,_), 654 direct_expand(HP,TN,achieve(Goal),Pre,Goal,State,Statics,Statics1), 655% gensym_special(hp,HP), 656 append_dcut(List,[step(HP,achieve(Goal),Pre,State,exp(TN))],List1),!. 657% -------direct expand ----------------------- 658% if the goal canbe achieved by a method's pre and post, 659% expand it and make it to that TNs 660direct_expand(HPid,TN,ACH,Pre,Post,State,Statics,Statics1):- 661 dir_apply_method(TN,HPid,ACH,Pre,Post,State,Statics,Statics1),!. 662 663% search forwards use ground operators only 664expand_node1(ID,Statics,Statics,Pre,State,from(PR),List,List1):- 665 find_related_op(Pre,[],OPls), 666 member(ID,OPls), 667 gOperator(ID,_,OP), 668 apply_ground_op(OP,Pre,State,List,List1). 669expand_node1(OP,Statics,Statics1,Pre,State,from(PR),List,List1):- 670 not(goal_related(_,_,_)), 671 operatorC(OP,Pre0,Post0,Cond,ST), 672 apply_unground_op(OP,Pre0,Post0,Cond,ST,Statics,Statics1,Pre,State,List,List1). 673 674apply_ground_op(operator(OP,Prev,Nec,Cond),Pre,State,List,List1):- 675 state_achieved(Prev,Pre), 676 nec_state_change(Pre,Nec,State2), 677 cond_state_change(State2,Cond,State), 678 gensym_special(hp,HP), 679 append_dcut(List,[step(HP,OP,Pre,State,exp(OP))],List1), 680 retract(op_num(N)), 681 N1 is N+1, 682 assert(op_num(N1)),!. 683 684apply_unground_op(OP,Pre0,Post0,Cond,ST,Statics,Statics1,Pre,State,List,List1):- 685 statics_append(ST,Statics,Statics2), 686 state_achieved(Pre0,Pre,Statics2), 687 state_change(Pre,Pre0,Post0,State2), 688 cond_state_change(State2,Cond,State), 689 statics_consist_instance(ST), 690 remove_unneed(Statics2,[],Statics1), 691 gensym_special(hp,HP), 692 append_dcut(List,[step(HP,OP,Pre,State,exp(OP))],List1), 693 retract(op_num(N)), 694 N1 is N+1, 695 assert(op_num(N1)). 696 697find_related_op([],Ops1,Ops):- 698 remove_dup(Ops1,[],Ops),!. 699find_related_op([Head|Pre],List,Ops):- 700 setof(OPls,Head^Level^goal_related(Head,OPls,Level),OPs0), 701 flatten(OPs0,[],OPs1), 702 append_dcut(List,OPs1,List1), 703 find_related_op(Pre,List1,Ops),!. 704find_related_op([Head|Pre],List,Ops):- 705 find_related_op(Pre,List,Ops),!. 706 707% select a tp_node with lowest score 708select_tnode(tp_node(TPid,Pre,Statics,Parents,Score,Dec)) :- 709 retractall(score_list(LS)), 710 assert(score_list([])), 711 lowest_score(Score), 712 retract(tp_node(TPid,Pre,Statics,Parents,Score,Dec)),!. 713% tell(user),nl,write('new level'),nl,told,!. 714 715% find the lowest_score of tp_node 716lowest_score(LScore):- 717 tp_node(HPid,Pre,Statics,Parents,Score,Dec), 718 retract(score_list(LS)), 719 assert(score_list([Score|LS])), 720 fail. 721lowest_score(LScore):- 722 retract(score_list(D)), 723 sort(D,[LScore|SD]). 724 725% assert assert_tnode(TP,OP,PR,Score,Post,Statics1,Steps1), 726%if goal achieved, assert solved_node 727assert_tnode(TP,OP,PR,Score,Post,Statics,[]):-!. 728assert_tnode(TP,OP,PR,Score,Post,Statics,Steps):- 729 tp_goal(Pre,Goal,Statics1), 730 state_achieved(Goal,Post,Statics), 731 combine_exp_steps(Post,Steps,OneStep), 732 assert(solved_node(Statics,OneStep)),!. 733assert_tnode(TP,OP,PR,Score,Post,Statics,Steps):- 734 existing_node(Post,Statics),!. 735assert_tnode(TP,OP,PR,Score,Post,Statics,Steps):- 736 get_score(PR,Post,Steps,Score), 737% op_score(OP,SS), 738% Score is Score1-SS, 739 gensym_special(tp,TP1), 740% write(TP1),nl, 741% write(Steps),nl, 742 assert(tp_node(TP1,Post,Statics,from(TP),Score,Steps)),!. 743 744combine_exp_steps(Post,Steps,step(HP,achieve(Goal),Pre,Post,exp(TN))):- 745 tp_goal(Pre,Goal,Statics), 746 get_action_list(Steps,[],ACTls), 747 make_temp(ACTls,[],Temp), 748 gensym_special(hp,HP), 749 make_tn(TN,achieve(Goal),Pre,Post,Temp,Steps),!. 750 751% get the temperal from an ordered steps 752get_action_list([],ACTls,ACTls):-!. 753get_action_list([step(HP,_,_,_,_)|Steps],List,ACTls):- 754 append_dcut(List,[HP],List1), 755 get_action_list(Steps,List1,ACTls),!. 756 757make_temp([HP|[]],Temp,Temp):-!. 758make_temp([HP1|[HP2|Rest]],List,Temp):- 759 append_cut(List,[before(HP1,HP2)],List1), 760 make_temp([HP2|Rest],List,Temp),!. 761 762existing_node(Post,Statics):- 763 tp_node(_,Post,_,_,_,_). 764existing_node(Post,Statics):- 765 closed_node(_,Post,_,_,_,_). 766% ------------------related goals------------------ 767 768assert_goal_related_init(Pre,[],Statics):-!. 769%assert_goal_related_init(Pre,[se(Sort,Obj,SE)|Post],Statics):- 770% state_achieved([se(Sort,Obj,SE)],Pre,Statics),!. 771assert_goal_related_init(Pre,[se(Sort,Obj,SE)|Post],Statics):- 772 ground(Obj), 773 is_of_primitive_sort(Obj,SortP), 774 assert(goal_related(se(SortP,Obj,SE),[],0)), 775 assert_goal_related_init(Pre,Post,Statics),!. 776assert_goal_related_init(Pre,[se(Sort,Obj,SE)|Post],Statics):- 777 assert_related_goals_varible(Sort,Obj,SE,goal,0), 778 assert_goal_related_init(Pre,Post,Statics),!. 779 780% find_all_related_goals: backward search 781% until all preconditions have found 782find_all_related_goals(Pre,Statics,N,N):- 783 get_all_state(States), 784 all_found(States,Pre,Statics), 785 assert(goal_related_search(succ)), 786 find_all_related_goals_final(Statics,N),!. 787find_all_related_goals(Pre,Statics,I,N):- 788 I1 is I-1, 789 goal_related(_,_,I1), 790 find_related_goal(Statics,I1,I), 791 I2 is I+1, 792 find_all_related_goals(Pre,Statics,I2,N),!. 793find_all_related_goals(Pre,Statics,N,N):- 794 not(goal_related(_,_,N)), 795 assert(goal_related_search(fail)), 796 write('related goal search failed'), 797 retractall(goal_related(_,_,_)),!. 798 %fail to find out, don't search any more 799 % fwsearch use all the ground ops. 800 801 802% final find the actions to recover initial states: 803% in case the initial states was deleted by other actions 804find_all_related_goals_final(Statics,N):- 805 N1 is N-1, 806 goal_related(Pre,_,N1), 807 find_related_goal(Statics,N1,N),!. 808find_all_related_goals_final(Statics,N):-!. 809 810% get all the found goal related states 811get_all_state(States):- 812 setof(Goal, Statics^Level^OP^goal_related(Goal,OP,Level),States11), 813 put_one_obj_together(States11,[],States),!. 814 815put_one_obj_together([],States,States):-!. 816put_one_obj_together([se(Sort,Obj,ST)|States1],List,States):- 817 put_one_obj_together1(se(Sort,Obj,ST),List,List1), 818 put_one_obj_together(States1,List1,States),!. 819 820put_one_obj_together1(se(Sort,Obj,ST),[],[se(Sort,Obj,ST)]):-!. 821put_one_obj_together1(se(Sort,Obj,ST),[se(Sort,Obj,ST00)|List],[se(Sort,Obj,ST1)|List]):- 822 set_append_e(ST,ST00,ST1),!. 823put_one_obj_together1(se(Sort,Obj,ST),[se(Sort1,Obj1,ST1)|List],[se(Sort1,Obj1,ST1)|List1]):- 824 Obj\==Obj1, 825 put_one_obj_together1(se(Sort,Obj,ST),List,List1),!. 826 827% all the Precondition states in backward search can reach initial states 828all_found([],States,Statics):-!. 829all_found([se(Sort,Obj,ST)|States],Pre,Statics):- 830 member(se(Sort,Obj,SPre),Pre), 831 subtract(SPre,ST,Diff), 832 isemptylist(Diff), 833 all_found(States,Pre,Statics),!. 834 835% find all the states that can achieve the goal state 836% separete ground operators to related-op and unrelated op 837find_related_goal(Statics,I1,I):- 838 gOperator(OPID,ID,operator(Name,Prev,Nec,Cond)), 839 find_related_goal_nec(OPID,Name,Prev,Nec,Statics,I1,I), 840 find_related_goal_cond(OPID,Name,Prev,Nec,Cond,Statics,I1,I), 841 fail. 842find_related_goal(Statics,I1,I). 843 844find_related_goal_nec(ID,Name,Prev,Nec,Statics,I1,I):- 845 goal_related(se(Sort,Obj,SE),Ops,I1), 846 member(sc(Sort,Obj,Lhs=>Rhs),Nec), 847 state_match(Sort,Obj,SE,Rhs), 848 statics_consist(Statics), 849% assert_op_score(ID,OPs), 850 assert_goal_related(Prev,Nec,ID,I). 851find_related_goal_cond(ID,Name,Prev,Nec,[],Statics,I1,I):- 852 !. 853find_related_goal_cond(ID,Name,Prev,Nec,Cond,Statics,I1,I):- 854 goal_related(se(Sort,Obj,SE),Ops,I1), 855 member(sc(Sort0,Obj,LHS=>RHS),Cond), 856 is_of_sort(Obj,Sort0), 857 is_of_sort(Obj,Sort),%Sort is a primitive sort changed at init 858 filterInvars(LHS,LInVars,LIsOfSorts,LNEs,FLHS), 859 filterInvars(RHS,RInVars,RIsOfSorts,RNEs,FRHS), 860 can_achieve_g([se(Sort,Obj,FRHS)],[se(Sort,Obj,SE)],Statics), 861 statics_consist(Statics), 862 checkInVars(LInVars), 863 checkInVars(RInVars), 864 checkIsOfSorts(LIsOfSorts), 865 checkIsOfSorts(RIsOfSorts), 866 obeysNEs(LNEs), 867 obeysNEs(RNEs), 868% assert_op_score(ID,OPs), 869 assert_goal_related(Prev,[sc(Sort,Obj,FLHS=>FRHS)|Nec],ID,I). 870 871% filter out invars, is_of_sorts and nes from a state list 872filterInvars([],[],[],[],[]):-!. 873filterInvars([is_of_sort(A,B)|State],InVars,[is_of_sort(A,B)|IsOfSorts],NEs,FState):- 874 !, 875 filterInvars(State,InVars,IsOfSorts,NEs,FState). 876filterInvars([ne(A,B)|State],InVars,IsOfSorts,[ne(A,B)|NEs],FState):- 877 !, 878 filterInvars(State,InVars,IsOfSorts,NEs,FState). 879filterInvars([is_of_primitive_sort(A,B)|State],InVars,[is_of_sort(A,B)|IsOfSorts],NEs,FState):- 880 !, 881 filterInvars(State,InVars,IsOfSorts,NEs,FState). 882filterInvars([Pred|State],[Pred|InVars],IsOfSorts,NEs,FState):- 883 functor(Pred,FF,NN), 884 functor(Pred1,FF,NN), 885 atomic_invariantsC(Atom), 886 member_cut(Pred1,Atom),!, 887 filterInvars(State,InVars,IsOfSorts,NEs,FState). 888filterInvars([Pred|State],InVars,IsOfSorts,NEs,[Pred|FState]):- 889 filterInvars(State,InVars,IsOfSorts,NEs,FState). 890 891% filter out nes from a state list 892filterNes([],[],[]):-!. 893filterNes([ne(A,B)|State],[ne(A,B)|NEs],FState):- 894 !, 895 filterNes(State,NEs,FState). 896filterNes([Pred|State],NEs,[Pred|FState]):- 897 filterNes(State,NEs,FState). 898 899assert_related_op(OP,I):- 900 related_op(OP,_),!. 901assert_related_op(OP,I):- 902 asserta(related_op(OP,I)),!. 903 904% State2 can be achieved by State1 905can_achieve_g([],State2,Statics):-!. 906can_achieve_g(State1,State2,Statics):- 907 can_achieve_g(State1,State2), 908 statics_consist(Statics). 909 910can_achieve_g([se(Sort,Obj,ST1)|State1],[se(Sort,Obj,ST2)]):- 911 state_match(Sort,Obj,ST2,ST1). 912can_achieve_g([Head|State1],State2):- 913 can_achieve_g(State1,State2). 914 915% assert:goal_related(Pre,Post,Op,DistanseFromGoal) 916assert_goal_related(Prev,Nec,OP,I):- 917 assert_goal_related1(Prev,OP,I),!, 918 assert_goal_related1(Nec,OP,I). 919 920assert_goal_related1([],Op,I):-!. 921assert_goal_related1([se(Sort,Obj,SE)|Prev],Op,I):- 922 assert_goal_related2(se(Sort,Obj,SE),Op,I), 923 assert_goal_related1(Prev,Op,I),!. 924assert_goal_related1([sc(Sort,Obj,LH=>RH)|Nec],Op,I):- 925 ground(Obj),%because conditional didn't ground, so the Sort maybe nonprim 926 is_of_primitive_sort(Obj,PSort),!, 927 assert_goal_related2(se(PSort,Obj,LH),Op,I), 928 assert_goal_related1(Nec,Op,I). 929assert_goal_related1([sc(Sort,Obj,LH=>RH)|Nec],Op,I):- 930 var(Obj), 931 assert_related_goals_varible(Sort,Obj,LH,Op,I), 932 assert_goal_related1(Nec,Op,I). 933 934assert_goal_related2(se(Sort,Obj,SE),goal,I):- 935 assert(goal_related(se(Sort,Obj,SE),[],I)),!. 936assert_goal_related2(se(Sort,Obj,SE),Op,I):- 937 goal_related(se(Sort,Obj,SE1),Ops,I), 938 not(is_diff(SE,SE1)), 939 retract(goal_related(se(Sort,Obj,SE),Ops,I)), 940 assert(goal_related(se(Sort,Obj,SE),[Op|Ops],I)),!. 941assert_goal_related2(se(Sort,Obj,SE),Op,I):- 942 assert(goal_related(se(Sort,Obj,SE),[Op],I)),!. 943 944assert_related_goals_varible(Sort,Obj,SE,Op,I):- 945 find_prim_sort(Sort,PSorts), 946 member(Sort1,PSorts), 947 assert_goal_related2(se(Sort1,Obj,SE),Op,I), 948 fail. 949assert_related_goals_varible(Sort,Obj,SE,Op,I). 950 951%assert score for Op, the further from goal, the higher the score 952assert_op_score(OP,OPB):- 953 op_score(OP,_),!. 954assert_op_score(OP,OPB):- 955 op_score(OPB,I), 956 I1 is I+1, 957 assert(op_score(OP,I1)),!. 958 959get_score(PR,Post,Steps,Score):- 960 tp_goal(Pre,Goal,Statics), 961 get_distance(Pre,Post,Goal,0,Dis),%length from Present to Goal 962% length(Pre,Obj_Num), 963 get_tnode_length(PR,1,Len), 964% Num1 is Obj_Num*Dis,%distanse the smaller the better 965% Num2 is Obj_Num*Len1,%length of the plan the smaller the better 966% Score is Num1+Num2,!. 967 Score is Dis+Len,!. 968 969get_distance(Pre,[],Goal,Dis,Dis):-!. 970get_distance(Pre,[se(Sort,Obj,SE)|Post],Goal,Dis1,Dis):- 971 member(se(Sort,Obj,SE0),Goal), 972 state_match(Sort,Obj,SE0,SE),%if it achieved goal 973 get_distance(Pre,Post,Goal,Dis1,Dis),!. 974get_distance(Pre,[se(Sort,Obj,SE)|Post],Goal,Dis1,Dis):- 975 goal_related(se(Sort,Obj,SE0),_,Level), 976 state_match(Sort,Obj,SE0,SE), 977 Dis2 is Dis1+Level, 978 get_distance(Pre,Post,Goal,Dis2,Dis),!. 979get_distance(Pre,[se(Sort,Obj,SE)|Post],Goal,Dis1,Dis):- 980 member(se(Sort,Obj,SE0),Pre), 981 state_match(Sort,Obj,SE,SE0),%if it does't change initial state 982 Dis2 is Dis1+1, 983 get_distance(Pre,Post,Goal,Dis2,Dis),!. 984get_distance(Pre,[se(Sort,Obj,SE)|Post],Goal,Dis1,Dis):- 985 Dis2 is Dis1+100, 986 get_distance(Pre,Post,Goal,Dis2,Dis),!. 987 988get_tnode_length(init,Len,Len):-!. 989get_tnode_length(TP,Len1,Len):- 990 closed_node(TP,_,_,from(PR),_,_), 991 Len2 is Len1+1, 992 get_tnode_length(PR,Len2,Len),!. 993 994 995% the states that can achieve a state 996% that is: 997% for a state in the rhs of operator 998% all the states in the lhs 999find_relate_state:- 1000 operatorC(A,Pre,Post,Cond,ST), 1001 assert_related_states(A,Pre,Post,Cond,ST), 1002 fail. 1003find_relate_state. 1004 1005assert_related_states(A,Pre,Post,Cond,ST):- 1006 assert_related_states1(A,Pre,Post,ST), 1007 assert_related_states2(A,Pre,Cond,ST). 1008% find relate in nec 1009% the sorts here are primitive 1010assert_related_states1(A,Pre,[],ST):-!. 1011%when prev 1012assert_related_states1(A,Pre,[se(Sort,Obj,SE)|Post],ST):- 1013 u_mem_cut(se(Sort,Obj,SE),Pre), 1014 assert_related_states1(A,Pre,Post,ST),!. 1015%when nec 1016assert_related_states1(A,Pre,[se(Sort,Obj,SE)|Post],ST):- 1017 assert(produce(se(Sort,Obj,SE),A,Pre,ST)), 1018 assert_related_states1(A,Pre,Post,ST),!. 1019 1020% find relate in conditional 1021% the sorts here are not primitive 1022assert_related_states2(A,Pre,SC,ST):- 1023 make_sc_primitive(SC,PSC), 1024 assert_related_states21(A,Pre,PSC,ST). 1025 1026assert_related_states21(A,Pre,[],ST):-!. 1027assert_related_states21(A,Pre,[sc(Sort,Obj,SE=>SS)|Trans],ST):- 1028 rem_statics([se(Sort,Obj,SE)],[se(Sort,Obj,SER)],St1), 1029 rem_statics([se(Sort,Obj,SS)],[se(Sort,Obj,SSR)],St2), 1030 append_cut(ST,St1,ST1), 1031 append_cut(ST1,St2,ST21), 1032 remove_unneed(ST21,[],ST2), 1033 append_cut(Pre,[se(Sort,Obj,SER)],Pre1), 1034 assert(produce(se(Sort,Obj,SSR),A,Pre1,ST2)), 1035 assert_related_states21(A,Pre,Trans,ST),!. 1036 1037%------------------------------------------- 1038% remove HP1 from the temp list 1039% if HP1<HP2, then all HP3<HP1 => HP3<HP2 1040% if HP2<HP1, then all HP1<HP3 => HP2<HP3 1041remove_temp([],HP1,List,List):-!. 1042remove_temp([before(HP1,HP2)|Temp],HP1,List,Temp1):- 1043 remove_temp_before(List,before(HP1,HP2),List2), 1044 remove_temp(Temp,HP1,List2,Temp1),!. 1045remove_temp([before(HP2,HP1)|Temp],HP1,List,Temp1):- 1046 remove_temp_after(List,before(HP2,HP1),List2), 1047 remove_temp(Temp,HP1,List2,Temp1),!. 1048remove_temp([before(HPX,HPY)|Temp],HP1,List,Temp1):- 1049 remove_temp(Temp,HP1,List,Temp1),!. 1050 1051% if HP1<HP2, remove HP1<HP2, and change all HP3<HP1 => HP3<HP2 1052remove_temp_before([],before(HP1,HP2),[]):-!. 1053remove_temp_before([before(HP1,HP2)|T],before(HP1,HP2),T1):- 1054 remove_temp_before(T,before(HP1,HP2),T1),!. 1055remove_temp_before([before(HP3,HP1)|T],before(HP1,HP2),[before(HP3,HP2)|T1]):- 1056 remove_temp_before(T,before(HP1,HP2),T1),!. 1057remove_temp_before([before(HPX,HPY)|T],before(HP1,HP2),[before(HPX,HPY)|T1]):- 1058 remove_temp_before(T,before(HP1,HP2),T1),!. 1059% if HP2<HP1, remove HP2<HP1, and change all HP1<HP3 => HP2<HP3 1060remove_temp_after([],before(HP1,HP2),[]):-!. 1061remove_temp_after([before(HP2,HP1)|T],before(HP2,HP1),T1):- 1062 remove_temp_after(T,before(HP2,HP1),T1),!. 1063remove_temp_after([before(HP1,HP3)|T],before(HP2,HP1),[before(HP2,HP3)|T1]):- 1064 remove_temp_after(T,before(HP2,HP1),T1),!. 1065remove_temp_after([before(HPX,HPY)|T],before(HP2,HP1),[before(HPX,HPY)|T1]):- 1066 remove_temp_after(T,before(HP2,HP1),T1),!. 1067 1068remove_dec(HPid,[],[]):-!. 1069remove_dec(HPid,[step(HPid,_,_,_,_)|Dec],Dec1):- 1070 remove_dec(HPid,Dec,Dec1),!. 1071remove_dec(HPid,[step(A,B,C,D,F)|Dec],[step(A,B,C,D,F)|Dec1]):- 1072 remove_dec(HPid,Dec,Dec1),!. 1073 1074/******************************************************/ 1075% State2 is achieved by State1 1076% the two states need to be primitive 1077state_achieved(undefd,State,Statics):-!. 1078state_achieved([],State2,Statics):-!. 1079state_achieved(State1,State2,Statics):- 1080 state_achieved(State1,State2), 1081 statics_consist(Statics). 1082 1083state_achieved(undefd,State):-!. 1084state_achieved([],State2). 1085state_achieved([se(Sort,Obj,ST1)|State1],State2):- 1086 member(se(Sort,Obj,ST2),State2), 1087 is_of_sort(Obj,Sort), 1088 state_match(Sort,Obj,ST1,ST2), 1089 list_take(State2,[se(Sort,Obj,ST2)],State21), 1090 state_achieved(State1,State21). 1091state_achieved([se(Sort,Obj,ST1)|State1],State2):- 1092 not(member(se(Sort,Obj,ST2),State2)), 1093 state_achieved(State1,State2),!. 1094 1095/************ states ST matchs ST1 ********/ 1096% state_match: ST is achieved by ST1 1097% ST=ST1 1098state_match(Sort,Obj,ST,ST1):- 1099 not(is_diff(ST,ST1)),!. 1100% when ST is the subset of ST1, 1101% in some domain, one substateclass is anothers's subset 1102% they cann't consider as match each other 1103% for example [on_block(a,b)] and [on_block(a,b),clear(a)] 1104state_match(Sort,Obj,ST,ST1):- 1105 is_achieved(ST,ST1), 1106 gsubstate_classes(Sort,Obj,Substateclasses), 1107 not(in_different_states(ST,ST1,Substateclasses)),!. 1108% when ST is not the subset of ST1, 1109% in hierarchical domain, maybe one is inhiered by the upperlevel 1110state_match(Sort,Obj,ST,ST1):- 1111 not(is_achieved(ST,ST1)), 1112 set_append(ST,ST1,ST0), 1113 gsubstate_classes(Sort,Obj,Substateclasses), 1114 in_same_sub_states(ST0,Substateclasses),!. 1115 1116% in_same_sub_states: check if ST1+ST2 in one states 1117in_same_sub_states(ST0,[State|SCls]):- 1118 is_achieved(ST0,State),!. 1119in_same_sub_states(ST0, [State|SCls]):- 1120 in_same_sub_states(ST0,SCls),!. 1121 1122% in_different_states: check if ST,ST1 in different states 1123in_different_states(ST,ST1, [State|SCls]):- 1124 max_member(ST,Substateclasses,MSub, _), 1125 max_member(ST1,Substateclasses,MSub1, _), 1126 MSub\==MSub1,!. 1127 1128max_member(State, Stateclass, MSub, Others):- 1129 max_member1(State, Stateclass, 0, [],MSub), 1130 subtract(State,MSub,Others),!. 1131 1132% find out the biggest same items 1133max_member1(State, [], Num, MSub, MSub):-!. 1134% find it out the biggest set of common items in substateclass and State 1135max_member1(State, [State1|SCls], Num, MSub1, MSub):- 1136 same_items(State1,State,MSSt), 1137 length(MSSt,Len), 1138 Len > Num, 1139 max_member1(State, SCls, Len, MSSt, MSub),!. 1140max_member1(State, [State1|SCls], Num, MSub1,MSub):- 1141 max_member1(State, SCls, Num, MSub1,MSub),!. 1142 1143% find it out the same items in two list 1144same_items([],List2,[]):-!. 1145same_items([X|List1],List2,[X|Same]):- 1146 member(X,List2), 1147 same_items(List1,List2,Same),!. 1148same_items([X|List1],List2,Same):- 1149 same_items(List1,List2,Same),!. 1150 1151 1152% all the element in list1 are static or in list2 1153is_achieved([],_):-!. 1154is_achieved([H|T], State) :- 1155 is_statics(H), 1156 is_achieved(T,State),!. 1157is_achieved([H|T], State) :- 1158 member(H,State), 1159 is_achieved(T,State),!. 1160 1161% check if a predicate is statics or not 1162is_statics(ne(A,B)):-!. 1163is_statics(is_of_sort(A,B)):-!. 1164is_statics(is_of_primitive_sort(A,B)):-!. 1165is_statics(Pred):- 1166 functor(Pred,FF,NN), 1167 functor(Pred1,FF,NN), 1168 atomic_invariantsC(Atom), 1169 member_cut(Pred1,Atom),!. 1170 1171/************ state changes by actions ********/ 1172% on the condition that: 1173% an object's state meet action's precondition 1174% it change to the postcondition 1175% Pre is the current ground states(Sort is primitive) 1176% Pre0 and Post0 are from an Operator or Method( 1177% Sorts are all primitive 1178state_change([],Pre0,Post0,[]):-!. 1179state_change(Pre,[],[],Pre):-!. 1180state_change([se(Sort,Obj,SPre)|Pre],Pre0,Post0,[se(Sort,Obj,STPost)|Post]):- 1181 state_achieved([se(Sort,Obj,SPre)],Pre0), 1182 state_change0(Sort,Obj,SPre,Pre0,Post0,Pre1,Post1,STPost), 1183 state_change(Pre,Pre1,Post1,Post). 1184state_change([se(Sort,Obj,SPre)|Pre],Pre0,Post0,[se(Sort,Obj,STPost)|Post]):- 1185 not(member(se(Sort,Obj,SPre0),Pre0)), 1186 state_change(Pre,Pre1,Post1,Post). 1187 1188% change the obj's post state with action's post 1189state_change0(Sort,Obj,SPre,[],[],[],[],SPre):-!. 1190state_change0(Sort,Obj,SPre,[se(Sort,Obj,SPre0)|Pre0],[se(Sort,Obj,SPost0)|Post0],Pre0,Post0,STPost):- 1191 state_change1(SPre,SPre0,SPost0,STPost). 1192state_change0(Sort,Obj,SPre,[se(Sort1,Obj1,SPre0)|Pre0],[se(Sort1,Obj1,SPost0)|Post0],[se(Sort1,Obj1,SPre0)|Pre1],[se(Sort1,Obj1,SPost0)|Post1],STPost):- 1193 Obj\==Obj1, 1194 state_change0(Sort,Obj,SPre,Pre0,Post0,Pre1,Post1,STPost). 1195 1196state_change1([],SPre0,SPost0,SPost0):-!. 1197state_change1(Pre,[],[],Pre):-!. 1198%if the pre state in action's pre, not in post, remove that 1199state_change1([Head|SPre],SPre0,SPost0,STPost):- 1200 member(Head,SPre0), 1201 not(member(Head,SPost0)), 1202 state_change1(SPre,SPre0,SPost0,STPost). 1203% if the pre state is not action's pre, neither in post, add that 1204state_change1([Head|SPre],SPre0,SPost0,[Head|STPost]):- 1205 not(member(Head,SPre0)), 1206 not(member(Head,SPost0)), 1207 state_change1(SPre,SPre0,SPost0,STPost),!. 1208% if the pre state is in post, don't need to add 1209% because it will be add at last 1210state_change1([Head|SPre],SPre0,SPost0,STPost):- 1211 member(Head,SPost0), 1212 state_change1(SPre,SPre0,SPost0,STPost). 1213 1214% rough change the obj's post state with action's post 1215rough_state_change(Pre,[],[],Pre):-!. 1216rough_state_change([],_,_,[]):-!. 1217rough_state_change([se(Sort,Obj,SE)|Pre],Pre0,Post0,[se(Sort,Obj,SS0)|Post]):- 1218 member(se(Sort,Obj,SE0),Pre0), 1219 member(se(Sort,Obj,SS0),Post0), 1220 is_of_sort(Obj,Sort), 1221 state_achieved([se(Sort,Obj,SE0)],[se(Sort,Obj,SE)]), 1222 list_take(Pre0,[se(Sort,Obj,SE0)],Pre01), 1223 list_take(Post0,[se(Sort,Obj,SS0)],Post01), 1224 rough_state_change(Pre,Pre01,Post01,Post),!. 1225rough_state_change([se(Sort,Obj,SE)|Pre],Pre0,Post0,[se(Sort,Obj,SE)|Post]):- 1226 rough_state_change(Pre,Pre0,Post0,Post),!. 1227 1228% a simple state_change for ground operators 1229state_changeG([],Pre0,Post0,[]):-!. 1230state_changeG([se(Sort,Obj,SE)|Pre],Pre0,Post0,[se(Sort,Obj,RHS)|State]):- 1231 member(se(Sort,Obj,LHS),Pre0), 1232 member(se(Sort,Obj,RHS),Post0), 1233 state_match(Sort,Obj,SE,LHS), 1234 state_changeG(Pre,Pre0,Post0,State),!. 1235state_changeG([se(Sort,Obj,SE)|Pre],Pre0,Post0,[se(Sort,Obj,SE)|State]):- 1236 not(member(se(Sort,Obj,LHS),Pre0)), 1237 state_changeG(Pre,Pre0,Post0,State),!. 1238 1239find_lower_sort(Sort,Sort,Sort):-!. 1240find_lower_sort(Sort,Sort1,Sort1):- 1241 subsorts(Sort,Sortls), 1242 member(Sort1,Sortls),!. 1243find_lower_sort(Sort,Sort1,Sort):- 1244 subsorts(Sort1,Sortls), 1245 member(Sort,Sortls),!. 1246%------------------------------------------------- 1247/************ state changes by necessery changes ********/ 1248% for all the object's state meet the precondition 1249% it change to the postcondition 1250% this is only used in apply grounded operators 1251nec_state_change([],Nec,[]):-!. 1252nec_state_change([se(Sort,Obj,SE)|Pre],Nec,[se(Sort,Obj,Post)|State]):- 1253 member(sc(Sort,Obj,Lhs=>Rhs),Nec), 1254 state_match(Sort,Obj,Lhs,SE), 1255 state_change1(SE,Lhs,Rhs,Post), 1256 nec_state_change(Pre,Nec,State),!. 1257nec_state_change([se(Sort,Obj,SE)|Pre],Nec,[se(Sort,Obj,SE)|State]):- 1258 not(member(sc(Sort,Obj,Lhs=>Rhs),Nec)), 1259 nec_state_change(Pre,Nec,State),!. 1260%------------------------------------------------- 1261/************ state changes by conditions ********/ 1262% for all the object's state meet the precondition 1263% it change to the postcondition 1264cond_state_change([],Cond,[]):-!. 1265cond_state_change(State,[],State):-!. 1266cond_state_change([se(Sort,Obj,SE)|Pre],Cond,[NewSS|State]):- 1267 member(sc(Sort1,Obj1,SE0=>SS0),Cond), 1268% var(Obj1), 1269 subsorts(Sort1,Subsorts), 1270 member(Sort,Subsorts), 1271 copy_states(se(Sort1,Obj1,SE0),se(Sort,Obj,SE2)), 1272 copy_states(se(Sort1,Obj1,SS0),se(Sort,Obj,SS2)), 1273% state_match(Sort,Obj,SE,SE0), 1274 filterInvars(SE2,LInVars,LIsOfSorts,LNEs,FSE), 1275 filterInvars(SS2,RInVars,RIsOfSorts,RNEs,FSS), 1276 state_match(Sort,Obj,SE,FSE), 1277 state_change([se(Sort,Obj,SE)],[se(Sort,Obj,FSE)], 1278 [se(Sort,Obj,FSS)],[NewSS]), 1279 checkInVars(LInVars), 1280 checkInVars(RInVars), 1281 checkIsOfSorts(LIsOfSorts), 1282 checkIsOfSorts(RIsOfSorts), 1283 obeysNEs(LNEs), 1284 obeysNEs(RNEs), 1285 cond_state_change(Pre,Cond,State),!. 1286cond_state_change([se(Sort,Obj,SE)|Pre],Cond,[se(Sort,Obj,SE)|State]):- 1287 cond_state_change(Pre,Cond,State),!. 1288 1289% copy the states so that the Obj won't be instiated 1290copy_states(se(Sort1,Obj1,SE0),se(Sort,Obj,SE2)):- 1291 copy_states1(Obj1,SE0,Obj,SE2),!. 1292copy_states1(Obj1,[],Obj,[]):-!. 1293copy_states1(Obj1,[Pred|SE0],Obj,[Pred2|SE2]):- 1294 functor(Pred,FF,NN), 1295 functor(Pred2,FF,NN), 1296 Pred=..[Name|Vars], 1297 Pred2=..[Name|Vars2], 1298 copy_pred(Obj1,Obj,Vars,Vars2), 1299 copy_states1(Obj1,SE0,Obj,SE2),!. 1300 1301copy_pred(Obj1,Obj,[],[]):-!. 1302copy_pred(Obj1,Obj,[Var|Vars],[Var2|Vars2]):- 1303 Obj1==Var, 1304 Var2=Obj, 1305 copy_pred(Obj1,Obj,Vars,Vars2),!. 1306copy_pred(Obj1,Obj,[Var|Vars],[Var|Vars2]):- 1307 copy_pred(Obj1,Obj,Vars,Vars2),!. 1308%------------------------------------------- 1309% every states in List1 is achieved by List2 1310all_achieved(undefd,Statics,List2):-!. 1311all_achieved([],Statics,List2):-!. 1312all_achieved(List1,Statics,List2):- 1313 all_achieved(List1,List2), 1314 statics_consist(Statics). 1315 1316all_achieved([],List2). 1317all_achieved([se(Sort,Obj,SL)|List1],List2):- 1318 member(se(Sort1,Obj,SR),List2), 1319 is_of_sort(Obj,Sort1), 1320 is_of_sort(Obj,Sort), 1321 is_of_primitive_sort(Obj,PSort), 1322 state_match(PSort,Obj,SL,SR), 1323 all_achieved(List1,List2). 1324%------------------------------------------- 1325% may_achieved: every states in Pre is not conflict with Post 1326may_achieved(undefd,Statics,Post):-!. 1327may_achieved([],Statics,Post):-!. 1328may_achieved(Pre,Statics,Post):- 1329 may_achieved(Pre,Post), 1330 statics_consist(Statics),!. 1331may_achieved([],Post). 1332may_achieved([se(Sort,Obj,SL)|Pre],Post):- 1333 member(se(Sort1,Obj,SR),Post), 1334 is_of_sort(Obj,Sort1), 1335 is_of_sort(Obj,Sort), 1336 is_of_primitive_sort(Obj,PSort), 1337 state_may_achieved(PSort,Obj,SL,SR), 1338 may_achieved(Pre,Post),!. 1339 1340% if the ST1 is a subset of ST2 1341state_may_achieved(Sort,Obj,[],ST2):-!. 1342state_may_achieved(Sort,Obj,ST1,ST2):- 1343 is_achieved(ST1,ST2),!. 1344%------------------------------------------- 1345% instantiate a bit 1346% use action's state change include the postcondition 1347post_instant(Post0,Cond,Statics,undefd):-!. 1348post_instant(Post0,Cond,Statics,[]):-!. 1349post_instant(Post0,Cond,Statics,[se(Sort,Obj,SE)|Post]):- 1350 member(se(Sort,Obj,SE0),Post0), 1351 statics_consist(Statics). 1352post_instant(Post0,Cond,Statics,[se(Sort,Obj,SE)|Post]):- 1353 member(sc(Sort,Obj,SE1=>SS),Cond), 1354 statics_consist(Statics). 1355post_instant(Post0,Cond,Statics,[se(Sort,Obj,SE)|Post]):- 1356 member(sc(Sort0,Obj,SE1=>SS),Cond), 1357 not(objectsC(Sort0,_)), 1358 subsorts(Sort0,Sortls), 1359 not(not(member(Sort,Sortls))), 1360 statics_consist(Statics). 1361post_instant(Post0,Cond,Statics,[se(Sort,Obj,SE)|Post]):- 1362 post_instant(Post0,Cond,Statics,Post),!. 1363 1364 1365 1366/*********************Initial process *********************/ 1367%node(Name, Precond, Decomps, Temp, Statics) 1368% When inputting new methods etc filter all statics into 1369% static slot 1370 1371make_problem_into_node(I,goal(L,TM,STATS), NN) :- 1372 make_problem_up(L, STEPS), 1373 make_num_hp(TM,Temp), 1374 sort_steps(STEPS,Temp,STEPS1), 1375 make_ss_to_se(I,I_Pre), 1376 NN = node(root,I_Pre,STEPS1 ,Temp, STATS),!. 1377make_problem_into_node(I,L, NN) :- 1378 make_problem_up([achieve(L)], STEPS), 1379 make_num_hp(TM,Temp), 1380 sort_steps(STEPS,Temp,STEPS1), 1381 make_ss_to_se(I,I_Pre), 1382 NN = node(root,I_Pre,STEPS1 ,Temp, STATS),!. 1383 1384% make problem to steps 1385make_problem_up([],[]):-!. 1386make_problem_up([achieve(L)|R],[step(HP,achieve(L1),undefd,[L1],unexp)|RS]):- 1387 %preconditon here is undefd 1388 make_ss_to_se([L],[L1]), 1389 gensym_special(hp,HP), 1390 make_problem_up(R, RS),!. 1391make_problem_up([achieve(L)|R],[step(HP,achieve(L1),undefd,L1,unexp)|RS]):- 1392 %preconditon here is undefd 1393 make_ss_to_se(L,L1), 1394 gensym_special(hp,HP), 1395 make_problem_up(R, RS),!. 1396make_problem_up([O|R],[step(HP,O,undefd,undefd,unexp)|RS]):- 1397 methodC(O,Pre,Post,Statics1,Temp,ACH,Dec), 1398 gensym_special(hp,HP), 1399 make_problem_up(R, RS),!. 1400make_problem_up([O|R], 1401 [step(HP,O,undefd,undefd,unexp)|RS]):- 1402 operatorC(O,Pre,Post,Cond,Statics1), 1403 gensym_special(hp,HP), 1404 make_problem_up(R, RS),!. 1405 1406make_num_hp([],[]):-!. 1407make_num_hp([before(N1,N2)|TM],[before(H1,H2)|Temp]):- 1408 gensym_num(hp,N1,H1), 1409 gensym_num(hp,N2,H2), 1410 make_num_hp(TM,Temp),!. 1411 1412%**************sort steps********************************* 1413% sort steps by temporal constraints. 1414sort_steps(Steps,[],Steps):-!. 1415sort_steps([Steps|[]],[],[Steps]):-!. 1416sort_steps(Steps,Temp,OrderedST):- 1417 steps_in_temp(Temp,[],ST), 1418 sort_steps1(Temp,ST,OrderedSTID), 1419 sort_steps2(Steps,OrderedSTID,[],OrderedST),!. 1420 1421% find out the steps in temporal constraints. 1422steps_in_temp([],ST,ST):-!. 1423steps_in_temp([before(H1,H2)|TT],List,ST):- 1424 set_append_e(List,[H1,H2],List1), 1425 steps_in_temp(TT,List1,ST),!. 1426 1427% sort the steps_id(hps) by temporal constraints. 1428sort_steps1(Temp,[],[]):-!. 1429sort_steps1(Temp,[HP1|TST],[HPF|OST]):- 1430 earliest_step(HP1,HPF,Temp,TST,TST1), 1431 sort_steps1(Temp,TST1,OST),!. 1432 1433earliest_step(HPF,HPF,Temp,[],[]):-!. 1434earliest_step(HP1,HPF,Temp,[HP2|TST],[HP1|TST1]):- 1435 member(before(HP2,HP1),Temp), 1436 earliest_step(HP2,HPF,Temp,TST,TST1),!. 1437earliest_step(HP1,HPF,Temp,[HP2|TST],[HP2|TST1]):- 1438 earliest_step(HP1,HPF,Temp,TST,TST1),!. 1439 1440% sort the steps, put the unordered steps in the front 1441sort_steps2(OtherST,[],OrderedST1,OrderedST):- 1442 append_dcut(OrderedST1,OtherST,OrderedST),!. 1443sort_steps2(Steps,[HP|THPS],List,OrderedST):- 1444 member(step(HP,N,Pre,Post,F),Steps), 1445 append_dcut(List,[step(HP,N,Pre,Post,F)],List1), 1446 list_take(Steps,[step(HP,N,Pre,Post,F)],Steps1), 1447 sort_steps2(Steps1,THPS,List1,OrderedST),!. 1448sort_steps2(Steps,[HP|THPS],List,OrderedST):- 1449 sort_steps2(Steps,THPS,List,OrderedST),!. 1450%******************************************************* 1451 1452% replace ss to se 1453make_ss_to_se([],[]):-!. 1454make_ss_to_se([ss(Sort,Obj,Post)|TPost],[se(Sort,Obj,Post)|TPre]):- 1455 make_ss_to_se(TPost,TPre),!. 1456make_ss_to_se([se(Sort,Obj,Post)|TPost],[se(Sort,Obj,Post)|TPre]):- 1457 make_ss_to_se(TPost,TPre),!. 1458 1459%******************************************************* 1460% extract_solution(Node,.. 1461% recurvise routine to work down tree and 1462% print out a linearisation of it 1463extract_solution(Node,PHPs,SIZE1,TNList) :- 1464 % its the name of a hierarchical op...... 1465 getN_decomp(Node, HPs), 1466 push_to_primitive(HPs,[],PHPs,[],TNList), 1467 pprint(PHPs,1,SIZE), 1468 SIZE1 is SIZE -1,!. 1469 1470/************ change_op_representation ***********/ 1471% make pre and post explicit 1472% filter out statics and put in a new slot 1473change_op_representation :- 1474 method(A,B,C,Stat,T,Dec), 1475 make_ss_to_se(B,B0), 1476 make_se_primitive(B0,B1), 1477 make_sc_primitive(C,C1), 1478 get_preconditions(C1,B1,Pre,Post), 1479 rem_statics(Post, PostR,St1), 1480 rem_statics(Pre, PreR,St2), 1481 append_cut(St1,St2,Statics), 1482 append_cut(Stat,Statics,Statics1), 1483 remove_unneed(Statics1,[],Statics2), 1484 get_achieval(A,Dec,T,Dec1,T1,ACH), 1485 assert(methodC(A,PreR,PostR,Statics2,T1,achieve(ACH),Dec1)), 1486 fail. 1487change_op_representation :- 1488 operator(A,B,C,D), 1489 make_ss_to_se(B,B0), 1490 make_se_primitive(B0,B1), 1491 make_sc_primitive(C,C1), 1492% make_sc_primitive(D,D1), 1493 %can't do that because it narrow the conditional change 1494 get_preconditions(C1,B1,Pre,Post), 1495 rem_statics(Post, PostR,St1), 1496 rem_statics(Pre, PreR,St2), 1497 append_cut(St1,St2,Statics1), 1498 remove_unneed(Statics1,[],Statics), 1499 statics_consist(Statics), 1500 assert(operatorC(A,PreR,PostR,D,Statics)), 1501 fail. 1502change_op_representation:- 1503 retractall(current_num(sm,_)),!. 1504 1505get_preconditions([],Prev,Prev,Prev) :-!. 1506get_preconditions([sc(S,X,From =>To)|Rest],Prev,[se(S,X,From1)|Pre],[se(S,X,To1)|Post]):- 1507 member_e(se(S,X,PSE),Prev), 1508 append_dcut(PSE,From,From1), 1509 append_dcut(PSE,To,To1), 1510 list_take(Prev,[se(S,X,PSE)],Prev1), 1511 get_preconditions(Rest,Prev1, Pre,Post),!. 1512get_preconditions([sc(S,X,From =>To)|Rest],Prev,[se(S,X,From)|Pre],[se(S,X,To)|Post]):- 1513 get_preconditions(Rest,Prev, Pre,Post),!. 1514get_preconditions([],Prev,Prev,Prev) :-!. 1515 1516% get all achieve goals out 1517get_achieval(A,Dec,T,Dec1,T1,Achieval):- 1518 retractall(current_num(sm,_)), 1519 make_dec(A,Dec,Dec1,T,T1,[],Achieval),!. 1520make_dec(A,[],[],Temp,Temp,Achieval,Achieval):-!. 1521make_dec(A,[HD|TD],TD1,Temp,Temp1,Achieval,Achieval1):- 1522 HD=..[achieve|Goal], 1523 current_num(sm,Num), 1524 replace_achieval_temp(Temp,Temp0,Num), 1525 make_ss_to_se(Goal,Goal0), 1526 append_dcut(Achieval,Goal0,Achieval0), 1527 make_dec(A,TD,TD1,Temp0,Temp1,Achieval0,Achieval1),!. 1528make_dec(A,[HD|TD],TD1,Temp,Temp1,Achieval,Achieval1):- 1529 HD=..[achieve|Goal], 1530 not(current_num(sm,Num)), 1531 replace_achieval_temp(Temp,Temp0,1), 1532 make_ss_to_se(Goal,Goal0), 1533 append_dcut(Achieval,Goal0,Achieval0), 1534 make_dec(A,TD,TD1,Temp0,Temp1,Achieval0,Achieval1). 1535make_dec(A,[HD|TD],[HD|TD1],Temp,Temp1,Achieval,Achieval1):- 1536 HD=..[DecName|Goal], 1537 DecName\==achieve, 1538 gensym_special(sm,SM), 1539 current_num(sm,Num), 1540 make_dec(A,TD,TD1,Temp,Temp1,Achieval,Achieval1),!. 1541 1542% get rid of the achievals in temp orders 1543replace_achieval_temp(Temp,Temp1,Num):- 1544 change_all_numbers(Temp,Num,Temp00), 1545 tidy_temp(Temp00,Temp1). 1546 1547change_all_numbers([],Num,[]):-!. 1548change_all_numbers([HTemp|TTemp],Num,[HTemp00|TTemp00]):- 1549 HTemp=..[before|Nums], 1550 change_nums(Nums,Num,Nums1), 1551 HTemp00=..[before|Nums1], 1552 change_all_numbers(TTemp,Num,TTemp00). 1553 1554change_nums([],Num,[]):-!. 1555change_nums([Num1|TN],Num,[Num1|TN1]):- 1556 Num1<Num, 1557 change_nums(TN,Num,TN1),!. 1558change_nums([Num1|TN],Num,[Num2|TN1]):- 1559 Num1>Num, 1560 Num2 is Num1-1, 1561 change_nums(TN,Num,TN1),!. 1562change_nums([Num|TN],Num,[0|TN1]):- 1563 change_nums(TN,Num,TN1),!. 1564 1565% since assumed achieval only happen at first, so only change the after ones 1566tidy_temp(Temp,Temp1):- 1567 member(before(Num,0),Temp), 1568 list_take(Temp,[before(Num,0)],Temp0), 1569 change_laters(Temp0,Num,Temp01), 1570 tidy_temp(Temp01,Temp1). 1571tidy_temp([],[]):-!. 1572tidy_temp([before(0,Num)|Temp],Temp0):- 1573 tidy_temp(Temp,Temp0),!. 1574tidy_temp([before(Num1,Num2)|Temp],[before(Num1,Num2)|Temp0]):- 1575 tidy_temp(Temp,Temp0),!. 1576 1577change_laters([before(0,Num2)|Temp],Num,[before(Num,Num2)|Temp0]):- 1578 change_laters(Temp,Num,Temp0). 1579change_laters([before(Num1,0)|Temp],Num,[before(Num1,0)|Temp0]):- 1580 change_laters(Temp,Num,Temp0). 1581change_laters([before(Num1,Num2)|Temp],Num,[before(Num1,Num2)|Temp0]):- 1582 change_laters(Temp,Num,Temp0). 1583 1584% change the states to primitive states 1585make_se_primitive([],[]). 1586make_se_primitive([se(Sort,Obj,ST)|SE],[se(Sort,Obj,ST)|SE0]):- 1587 objectsC(Sort,Objls),!, 1588 make_se_primitive(SE,SE0). 1589make_se_primitive([se(Sort,Obj,ST)|SE],[se(PSort,Obj,ST)|SE0]):- 1590 find_prim_sort(Sort,PSorts), 1591 member(PSort,PSorts), 1592 make_se_primitive(SE,SE0). 1593 1594% change the state changes to primitive states 1595make_sc_primitive([],[]). 1596make_sc_primitive([sc(Sort,Obj,SE1=>SE2)|ST],[sc(Sort,Obj,SE1=>SE2)|ST0]):- 1597 objectsC(Sort,Objls),!, 1598 make_sc_primitive(ST,ST0). 1599make_sc_primitive([sc(Sort,Obj,SE1=>SE2)|ST],[sc(PSort,Obj,SE1=>SE2)|ST0]):- 1600 find_prim_sort(Sort,PSorts), 1601 member(PSort,PSorts), 1602 make_sc_primitive(ST,ST0). 1603 1604 1605% ------------ end of change operator ---------------------- 1606/********make_tn: save the expansion results*****/ 1607make_tn(TN,Name,Pre,Post,Temp,Dec):- 1608 find_only_changed(Pre,Post,[],Pre1,[],Post1), 1609 not(isemptylist(Post1)), 1610 not(exist_tn(Pre,Post)), 1611 gensym_special(tn,TN), 1612% tell(user),nl,write(tn(TN,Name,Pre1,Post1,Temp,Dec)),nl,told, 1613 assert(tn(TN,Name,Pre1,Post1,Temp,Dec)),!. 1614 1615exist_tn(Pre,Post):- 1616 tn(_,_,Pre,Post1,_,_), 1617 state_achieved(Post,Post1),!. 1618find_only_changed([],[],Pre,Pre,Post,Post):-!. 1619% just a lazy check if they are in exactly same sequence 1620find_only_changed([se(Sort,Obj,ST)|Pre],[se(Sort,Obj,ST)|Post],Pre0,Pre1,Post0,Post1):- 1621 find_only_changed(Pre,Post,Pre0,Pre1,Post0,Post1),!. 1622find_only_changed([se(Sort,Obj,ST)|Pre],Post,Pre0,Pre1,Post0,Post1):- 1623 member(se(Sort,Obj,ST1),Post), 1624 list_take(Post,[se(Sort,Obj,ST1)],Post2), 1625 append_changed(se(Sort,Obj,ST),se(Sort,Obj,ST1),Pre0,Pre3,Post0,Post3), 1626 find_only_changed(Pre,Post2,Pre3,Pre1,Post3,Post1),!. 1627find_only_changed([se(Sort,Obj,ST)|Pre],Post,Pre0,Pre1,Post0,Post1):- 1628 member(se(SortN,Obj,ST1),Post), 1629 list_take(Post,[se(SortN,Obj,ST1)],Post2), 1630 append_changed(se(Sort,Obj,ST),se(SortN,Obj,ST1),Pre0,Pre3,Post0,Post3), 1631 find_only_changed(Pre,Post2,Pre3,Pre1,Post3,Post1),!. 1632% other fail. 1633 1634% append_dcut only changed states 1635% state_match here means not changed 1636append_changed(se(Sort,Obj,ST),se(Sort1,Obj,ST1),Pre0,Pre0,Post0,Post0):- 1637 state_match(Sort,Obj,ST,ST1),!. 1638append_changed(se(Sort,Obj,ST),se(Sort1,Obj,ST1),Pre0,Pre3,Post0,Post3):- 1639 append_dcut(Pre0,[se(Sort,Obj,ST)],Pre3), 1640 append_dcut(Post0,[se(Sort,Obj,ST1)],Post3),!. 1641 1642%***********print out solution************************** 1643push_to_primitive([],PHPs,PHPs,TNLst,TNLst) :-!. 1644push_to_primitive([step(HPID,_,_,_,exp(TN))|HPs],List,PHPs,TNSoFar,TNFinal) :- 1645 tn(TN,Name,Pre,Post,Temp,Dec), 1646 push_to_primitive(Dec,List,Dec1,[tn(TN,Name,Pre,Post,Temp,Dec)|TNSoFar],TNNext), 1647 push_to_primitive(HPs,Dec1,PHPs,TNNext,TNFinal),!. 1648push_to_primitive([step(HPID,_,_,_,exp(Name))|HPs],List,PHPs,TNSoFar,TNFinal):- 1649 append_dcut(List,[Name],List1), 1650 push_to_primitive(HPs,List1,PHPs,TNSoFar,TNFinal),!. 1651 1652/*********** TEMPORAL AND DECLOBBERING ************/ 1653 1654possibly_before(I,J,Temps) :- 1655 \+ necessarily_before(J,I,Temps), !. 1656 1657necessarily_before(J,I,Temps) :- 1658 member(before(J,I),Temps),!. 1659necessarily_before(J,I,Temps) :- 1660 member(before(J,Z),Temps), 1661 necessarily_before(Z,I,Temps),!. 1662 1663select_node(node(Name,Pre,Temp,Decomp,Statics)) :- 1664 retract(node(Name,Pre,Temp,Decomp,Statics)), 1665% nl,nl,write(Name),write(' RETRACTED'),nl,nl, 1666% tell(user), 1667% nl,nl,write(Name),write(' RETRACTED'),nl,nl, 1668% tell(FF), 1669 !. 1670 1671get_obj_prim_sort([],[]):-!. 1672get_obj_prim_sort([HSort|TV],[HObj|TS]):- 1673 is_of_primitive_sort(HObj,HSort), 1674 get_obj_prim_sort(TV,TS),!. 1675/* 1676is_of_primitive_sort(X,Y) :- 1677 objectsC(Y,L),member(X,L). 1678is_of_sort(X,Y) :- 1679 is_of_primitive_sort(X,Y). 1680is_of_sort(X,Y) :- 1681 sorts(Y,SL),member(Z,SL),is_of_sort(X,Z). 1682*/ 1683find_all_upper([],[]). 1684find_all_upper([HVars|TV],[HSorts|TS]):- 1685 uppersorts(HSorts,Upsorts), 1686 member(HVars,Upsorts), 1687 find_all_upper(TV,TS). 1688 1689% find out primitive sorts of a sort. 1690find_prim_sort(Sort,PS):- 1691 subsorts(Sort,Subsorts), 1692 split_prim_noprim(Subsorts,PS,NP),!. 1693 1694% find out the objects of a sort 1695get_sort_objects(Sort,Objs):- 1696 find_prim_sort(Sort,PSorts), 1697 get_objects1(PSorts,Objls), 1698 flatten(Objls,[],Objs),!. 1699 1700get_objects1([],[]):-!. 1701get_objects1([PS1|RS],[Objls1|Objls]):- 1702 objectsC(PS1,Objls1), 1703 get_objects1(RS,Objls),!. 1704 1705% find subsorts of a sort(exclude). 1706subsortse(Sort,Subsorts):- 1707 subsorts(Sort,Subsorts1), 1708 subtract(Subsorts1,[Sort],Subsorts),!. 1709% find subsorts of a sort(include). 1710subsorts(Sort,Subsorts):- 1711 sort_down([Sort],[],Subsorts),!. 1712 1713sort_down([],Subsorts,Subsorts):-!. 1714sort_down([HOpen|TOpen],List,Subsorts):- 1715 objectsC(HOpen,Objls), 1716 append_dcut(List,[HOpen],List1), 1717 sort_down(TOpen,List1,Subsorts),!. 1718sort_down([HOpen|TOpen],List,Sortslist):- 1719 sorts(HOpen,Sorts), 1720 sort_down(Sorts,List,List2), 1721 sort_down(TOpen,[HOpen|List2],Sortslist),!. 1722sort_down([HOpen|TOpen],List,Sortslist):- 1723 sort_down(TOpen,List,Sortslist),!. 1724 1725% find uppersorts of a sort(excludes). 1726uppersortse(Sort,Uppersorts):- 1727 uppersorts(Sort,Uppersortsf), 1728 subtract(Uppersortsf,[Sort],Uppersorts),!. 1729% find uppersorts of a sort or object(include). 1730uppersorts(Sort,Uppersorts):- 1731 objectsC(Sort,Objls), 1732 sort_up(Sort,[Sort],Uppersorts),!. 1733uppersorts(Sort,Uppersorts):- 1734 sorts(Sort,Sortls), 1735 sort_up(Sort,[Sort],Uppersorts),!. 1736uppersorts(Obj,Sortls):- 1737 objectsC(Sort,Objls), 1738 member(Obj, Objls), 1739 sort_up(Sort,[Sort],Sortls),!. 1740 1741 1742sort_up(Sort, List,Sortslist):- 1743 sorts(NPSort, NPSortls), 1744 NPSort \== non_primitive_sorts, 1745 NPSort \== primitive_sorts, 1746 member(Sort,NPSortls), 1747 sort_up(NPSort,[NPSort|List],Sortslist). 1748sort_up(Sort, List,List):-!. 1749 1750% sametree: Sort1 and Sort2 are in same sort tree. 1751sametree(Sort1,Sort2):- 1752 Sort1==Sort2,!. 1753sametree(Sort1,Sort2):- 1754 var(Sort1),!. 1755sametree(Sort1,Sort2):- 1756 var(Sort2),!. 1757sametree(Sort1,Sort2):- 1758 uppersorts(Sort2,Sortls), 1759 member(Sort1,Sortls),!. 1760sametree(Sort1,Sort2):- 1761 uppersorts(Sort1,Sortls), 1762 member(Sort2,Sortls),!. 1763 1764% split a sortlist to primitive sorts and non-primitive sorts. 1765split_prim_noprim([],[],[]):-!. 1766split_prim_noprim([HS|TS],[HS|TP],NP):- 1767 objectsC(HS,Obj), 1768 split_prim_noprim(TS,TP,NP),!. 1769split_prim_noprim([HS|TS],PS,[HS|NP]):- 1770 split_prim_noprim(TS,PS,NP),!. 1771 1772 1773/********* check for statics consist without instanciate them***/ 1774 1775 1776% only instance the variable when there is one choice of from the ground lists 1777statics_consist([]):-!. 1778statics_consist(Statics):- 1779 get_invariants(Invs), 1780 statics_consist(Invs,Statics),!. 1781statics_consist(Invs,[]):-!. 1782statics_consist(Invs,[ne(A,B)|Statics]):- 1783 not(A==B),!, 1784 statics_consist(Invs,Statics). 1785statics_consist(Invs,[is_of_sort(Obj,Sort)|Statics]):- 1786 not(not(is_of_sort(Obj,Sort))),!, 1787 statics_consist(Invs,Statics). 1788statics_consist(Invs,[is_of_primitive_sort(Obj,Sort)|Statics]):- 1789 not(not(is_of_primitive_sort(Obj,Sort))),!, 1790 statics_consist(Invs,Statics). 1791statics_consist(Invs,[Pred|Statics]):- 1792 pred_member(Pred,Invs),!, 1793 statics_consist(Invs,Statics). 1794 1795/*********check for statics consist and instanciate them***/ 1796statics_consist_instance([]):-!. 1797statics_consist_instance(Statics):- 1798 get_invariants(Invs), 1799 statics_consist_instance(Invs,Statics). 1800 1801statics_consist_instance(Invs,[]):-!. 1802statics_consist_instance(Invs,[is_of_sort(Obj,Sort)|Atom]):- 1803 ground(Obj), 1804 is_of_sort(Obj,Sort),!, 1805 statics_consist_instance(Invs,Atom). 1806statics_consist_instance(Invs,[is_of_sort(Obj,Sort)|Atom]):- 1807 var(Obj), 1808 is_of_sort(Obj,Sort), 1809 statics_consist_instance(Invs,Atom). 1810statics_consist_instance(Invs,[is_of_primitive_sort(Obj,Sort)|Atom]):- 1811 ground(Obj), 1812 is_of_primitive_sort(Obj,Sort),!, 1813 statics_consist_instance(Invs,Atom). 1814statics_consist_instance(Invs,[is_of_primitive_sort(Obj,Sort)|Atom]):- 1815 var(Obj), 1816 is_of_primitive_sort(Obj,Sort), 1817 statics_consist_instance(Invs,Atom). 1818statics_consist_instance(Invs,[ne_back(A,B)|Atom]):- 1819 A\==B, 1820 statics_consist_instance(Invs,Atom). 1821statics_consist_instance(Invs,[ne(A,B)|Atom]):- 1822 append_dcut(Atom,[ne_back(A,B)],Atom1),!, 1823 statics_consist_instance(Invs,Atom1). 1824statics_consist_instance(Invs,[Pred|Atom]):- 1825 ground(Pred), 1826 member(Pred,Invs),!, 1827 statics_consist_instance(Invs,Atom). 1828statics_consist_instance(Invs,[Pred|Atom]):- 1829 not(ground(Pred)), 1830 member(Pred,Invs), 1831 statics_consist_instance(Invs,Atom). 1832/***************** local utils *****************/ 1833 1834/*********** DOMAIN MODEL FUNCTIONS *****************/ 1835get_invariants(Invs) :- 1836 atomic_invariantsC(Invs),!. 1837 1838rem_statics([sc(S,X,Lhs=>Rhs)|ST], [sc(S,X,LhsR=>RhsR)|STR],Rt1) :- 1839 split_st_dy(Lhs,[],LR, [],LhsR), 1840 split_st_dy(Rhs,[],RR,[],RhsR), 1841 append_dcut(LR,RR,R), 1842 rem_statics(ST, STR,Rt), 1843 append_dcut(Rt,[is_of_sort(X,S)|R],Rt1),!. 1844rem_statics([ss(S,X,Preds)|Post], [ss(S,X,PredR)|PostR],Rt1) :- 1845 split_st_dy(Preds,[],R, [],PredR), 1846 rem_statics(Post, PostR,Rt), 1847 append_dcut(Rt,[is_of_sort(X,S)|R],Rt1),!. 1848rem_statics([se(S,X,Preds)|Post], [se(S,X,PredR)|PostR],Rt1) :- 1849 split_st_dy(Preds,[],R, [],PredR), 1850 rem_statics(Post, PostR,Rt), 1851 append_dcut(Rt,[is_of_sort(X,S)|R],Rt1),!. 1852rem_statics([], [],[]) :-!. 1853 1854 1855% ----------------------utilities--------------------- 1856 1857% not(X):- \+X. 1858isemptylist([]):-!. 1859 1860%instantiate variables 1861/* 1862member(X,[X|_]). 1863member(X,[_|L]) :- member(X,L). 1864*/ 1865 1866member_cut(X,[X|_]) :- !. 1867member_cut(X,[_|Y]) :- member_cut(X,Y),!. 1868 1869% member_e: X is the exact memeber of List 1870member_e(X,[Y|_]):- 1871 X==Y,!. 1872member_e(X,[Y|L]):- 1873 var(Y), 1874 member_e(X,L),!. 1875member_e(ss(Sort,Obj,SE),[ss(Sort,Obj1,SE)|_]):- 1876 Obj==Obj1,!. 1877member_e(se(Sort,Obj,SE),[se(Sort,Obj1,SE)|_]):- 1878 Obj==Obj1,!. 1879member_e(sc(Sort,Obj,SE1=>SE2),[sc(Sort,Obj1,SE1=>SE2)|_]):- 1880 Obj==Obj1,!. 1881member_e(X,[Y|L]):- member_e(X,L),!. 1882 1883 1884% u_mem in ob_utils is SLOW!?. 1885% this is a fast impl. 1886u_mem_cut(_,[]):-!,fail. 1887u_mem_cut(X,[Y|_]) :- X == Y,!. 1888u_mem_cut(X,[_|L]) :- u_mem_cut(X,L),!. 1889% check if object X is a member of a objects list 1890% 1. if it is not a variable, check if it is in the list 1891% 2. X is a variable, and the list only has one objects, make X as that obj 1892% 3. X is a variable, but the list has more than one objects, leave X unchange 1893obj_member(X,[X|[]]):-!. 1894obj_member(X,List):- 1895 obj_member0(X,List),!. 1896obj_member0(X,[Y|_]):- 1897 var(X),!.%if X is var, but Y not, the leave X as that variable 1898obj_member0(X,[Y|_]):- 1899 X==Y,!. 1900obj_member0(X,[_|Y]) :- obj_member0(X,Y),!. 1901 1902 1903% check if a predicate is a member of a ground predicate list, 1904% just used in binding the predicates to a sort without instantiate it 1905% for efficiency, instantiate the variable if the list only have one atom 1906pred_member(X,List):- 1907 ground(X), 1908 member(X,List),!. 1909pred_member(X,List):- 1910 setof(X,member(X,List),Refined), 1911 pred_member0(X,Refined),!. 1912 1913pred_member0(X,[X|[]]):-!. 1914pred_member0(X,Y):- 1915 pred_member1(X,Y),!. 1916pred_member1(X,[Y|_]):- 1917 X=..[H|XLs], 1918 Y=..[H|YLs], 1919 vequal(XLs,YLs),!. 1920pred_member1(X,[_|Y]):- pred_member1(X,Y),!. 1921 1922statics_append([],L,L):- 1923 statics_consist(L),!. 1924statics_append(L,[],L):- 1925 statics_consist(L),!. 1926statics_append(List1,List2,L):- 1927 statics_consist(List1), 1928 statics_consist(List2), 1929 statics_append1(List1,List2,[],L), 1930 statics_consist(L),!. 1931 1932statics_append1([],List2,L1,L):- 1933 append_dcut(List2,L1,L),!. 1934statics_append1([H|List1],List2,L,Z) :- 1935 statics_append0(H,List2,L,L1), 1936 statics_append1(List1,List2,L1,Z),!. 1937 1938statics_append0(H,[],L,[H|L]):-!. 1939statics_append0(H,[H|Z],L,L):-!. 1940statics_append0(H,[X|Z],L1,L):- 1941 statics_append0(H,Z,L1,L),!. 1942 1943append_dcut([],L,L):-!. 1944append_dcut([H|T],L,[H|Z]) :- append_dcut(T,L,Z),!. 1945 1946append_cut([],L,L) :- !. 1947append_cut([H|T],L,[H|Z]) :- append_cut(T,L,Z),!. 1948 1949% append_st: append_dcut two statics 1950% remove the constants that no need 1951% instanciate the viables that all ready been bind 1952% ------------------------------------------ 1953append_st(ST1,ST2,ST):- 1954 append_dcut(ST1,ST2,ST0), 1955 remove_unneed(ST0,[],ST),!. 1956 1957% remove the constants that no need 1958% instanciate the variables that all ready been bind 1959remove_unneed([],C,C):-!. 1960remove_unneed([A|B], Z, C):- 1961 var(A), 1962 member_e(A,Z), 1963 remove_unneed(B, Z, C),! . 1964remove_unneed([A|B], Z, C):- 1965 var(A), 1966 append_dcut(Z,[A],D), 1967 remove_unneed(B, D, C),!. 1968remove_unneed([A|B], Z, C):- 1969 ground(A), 1970 remove_unneed(B, Z, C),!. 1971remove_unneed([A|B], Z, C):- 1972 A=..[ne|Paras], 1973 append_dcut(Z,[A],D), 1974 remove_unneed(B, D, C),!. 1975remove_unneed([A|B], Z, C):- 1976 A=..[Pred|Paras], 1977 same_var_member(A,Z), 1978 remove_unneed(B, Z, C),!. 1979remove_unneed([A|B], Z, C):- 1980 append_dcut(Z,[A],D), 1981 remove_unneed(B, D, C),!. 1982 1983same_var_member(Pred,[Pred1|List]):- 1984 var(Pred1), 1985 same_var_member(Pred,List),!. 1986same_var_member(Pred,[Pred1|List]):- 1987 Pred==Pred1,!. 1988same_var_member(Pred,[Pred1|List]):- 1989 Pred=..[H|T], 1990 Pred1=..[H|T1], 1991 same_var_member1(T,T1),!. 1992same_var_member(Pred,[Pred1|List]):- 1993 same_var_member(Pred,List),!. 1994 1995same_var_member1([],[]):-!. 1996same_var_member1([H1|T],[H2|T]):- 1997 var(H1), 1998 H1==H2,!. 1999same_var_member1([H|T1],[H|T2]):- 2000 var(T1), 2001 T1==T2,!. 2002same_var_member1([H1|T1],[H2|T2]):- 2003 H1==H2, 2004 same_var_member1(T1,T2),!. 2005 2006% two states or lists are equal 2007is_equal_list(List1,List2):- 2008 List1==List2,!. 2009is_equal_list([],[]):-!. 2010is_equal_list(List1,List2):- 2011 length(List1,L), 2012 length(List2,L), 2013 is_equal_list1(List1,List2),!. 2014is_equal_list1([],[]):-!. 2015is_equal_list1([Head1|List1],[Head2|List2]):- 2016 Head1==Head2, 2017 is_equal_list1(List1,List2),!. 2018is_equal_list1([se(Sort,Obj,Head1)|List1],[se(Sort,Obj,Head2)|List2]):- 2019 is_equal_list(Head1,Head2), 2020 is_equal_list1(List1,List2),!. 2021is_equal_list1([Head1|List1],[Head2|List2]):- 2022 Head1=..[FF|Var1], 2023 Head2=..[FF|Var2], 2024 FF\==se, 2025 vequal(Var1,Var2), 2026 is_equal_list1(List1,List2),!. 2027is_equal_list1([Head1|List1],List2):- 2028 member(Head1,List2), 2029 append_cut(List1,[Head1],List10), 2030 is_equal_list1(List10,List2),!. 2031 2032% two states or lists are different 2033is_diff(List1,List2):- 2034 length(List1,L1), 2035 length(List2,L2), 2036 L1\==L2,!. 2037is_diff([Head|List1],List2):- 2038 not_exist(Head,List2),!. 2039is_diff([Head|List1],List2):- 2040 list_take(List2,[Head],List21), 2041 is_diff(List1,List21),!. 2042 2043not_exist(Pred,List2):- 2044 not(member(Pred,List2)),!. 2045not_exist(se(Sort,Obj,Head1),List2):- 2046 not(member(se(Sort,Obj,Head),List2)),!. 2047not_exist(se(Sort,Obj,Head1),List2):- 2048 member(se(Sort,Obj,Head2),List2), 2049 is_diff(Head1,Head2),!. 2050 2051 2052% set_append: list1 + list2 -> list 2053% no duplicate, do instanciation 2054% ------------------------------------------ 2055set_append([], Z, Z):-! . 2056set_append([A|B], Z, C) :- 2057 not(not(member(A, Z))) , 2058 set_append(B, Z, C),! . 2059set_append([A|B], Z, [A|C]) :- 2060 set_append(B, Z, C) . 2061 2062 2063 2064% set_append_e: list1 + list2 -> list 2065% no duplicate, no instanciation 2066% ------------------------------------------ 2067set_append_e(A,B,C):- 2068 append_cut(A,B,D), 2069 remove_dup(D,[],C),!. 2070 2071% remove duplicate 2072remove_dup([],C,C):-!. 2073remove_dup([A|B],Z,C) :- 2074 member_e(A, Z), 2075 remove_dup(B, Z, C),! . 2076remove_dup([A|B], Z, C):- 2077 append_dcut(Z,[A],D), 2078 remove_dup(B, D, C),!. 2079 2080% two atom lists equals (without instantiate variables) 2081vequal([],[]):-!. 2082vequal([X|XLs],[Y|YLs]):- 2083 X==Y, 2084 vequal(XLs,YLs),!. 2085vequal([X|XLs],[Y|YLs]):- 2086 var(X), 2087 vequal(XLs,YLs),!. 2088vequal([X|XLs],[Y|YLs]):- 2089 var(Y), 2090 vequal(XLs,YLs),!. 2091 2092 2093% subtract(A,B,C): subtract B from A 2094% ------------------------------------- 2095/* 2096subtract([],_,[]):-!. 2097subtract([A|B],C,D) :- 2098 member(A,C), 2099 subtract(B,C,D),!. 2100subtract([A|B],C,[A|D]) :- 2101 subtract(B,C,D),!. 2102*/ 2103 2104/* arg1 - arg2 = arg3 */ 2105 2106list_take(R,[E|R1],R2):- 2107 remove_el(R,E,RR), 2108 list_take(RR,R1,R2),!. 2109list_take(R,[_|R1],R2):- 2110 list_take(R,R1,R2),!. 2111list_take(A,[],A) :- !. 2112 2113% remove_el: list * el -> list-el 2114% ---------------------------------- 2115remove_el([],_,[]) :- ! . 2116remove_el([A|B],A,B) :- ! . 2117remove_el([A|B],C,[A|D]) :- 2118 remove_el(B,C,D) . 2119 2120/* generate symbol predicate (from file futile)*/ 2121 2122gensym_special(Root,Atom) :- 2123 getnum(Root,Num), 2124 name(Root,Name1), 2125 name(Num,Name2), 2126 append_dcut(Name1,Name2,Name), 2127 name(Atom,Name). 2128 2129getnum(Root,Num) :- 2130 retract(current_num(Root,Num1)),!, 2131 Num is Num1+1, 2132 asserta(current_num(Root,Num)). 2133 2134getnum(Root,1) :- asserta(current_num(Root,1)). 2135 2136 2137gensym_num(Root,Num,Atom):- 2138 name(Root,Name), 2139 name(Num,Name1), 2140 append_dcut(Name,Name1,Name2), 2141 name(Atom,Name2),!. 2142 2143 2144pprint([],SIZE,SIZE):-!. 2145pprint([HS|TS],Size0,SIZE):- 2146 list(HS), 2147 pprint(HS,Size0,Size1), 2148 pprint(TS,Size1,SIZE),!. 2149pprint([HS|TS],Size0,SIZE):- 2150% write('step '),write(Size0),write(': '), 2151% write(HS),nl, 2152 Size1 is Size0+1, 2153 pprint(TS,Size1,SIZE),!. 2154 2155/* split static and dynamic from states*/ 2156 2157split_st_dy([],ST,ST,DY,DY):-!. 2158split_st_dy([Pred|TStates],ST0,ST,DY0,DY):- 2159 is_statics(Pred), 2160 append_cut(ST0,[Pred],ST1), 2161 split_st_dy(TStates,ST1,ST,DY0,DY),!. 2162split_st_dy([Pred|TStates],ST0,ST,DY0,DY):- 2163 append_cut(DY0,[Pred],DY1), 2164 split_st_dy(TStates,ST0,ST,DY1,DY),!. 2165 2166% list of lists -> list 2167 2168flatten([HO|TO], List, O_List):- 2169 append_dcut(HO, List, List_tmp), 2170 flatten(TO, List_tmp, O_List),!. 2171flatten([H|TO], List,O_List):- 2172 append_dcut([H], List, List_tmp), 2173 flatten(TO, List_tmp, O_List). 2174flatten([], [HList|T], O_List):- 2175 HList = [], 2176 flatten(T, [], O_List). 2177flatten([], [HList|T], O_List):- 2178 list(HList), 2179 flatten([HList|T],[], O_List),!. 2180flatten([], L,L):-!. 2181 2182% flatten with no duplicate 2183set_flatten([HO|TO], List, O_List):- 2184 set_append_e(HO, List, List_tmp), 2185 set_flatten(TO, List_tmp, O_List),!. 2186set_flatten([H|TO], List,O_List):- 2187 set_append_e([H], List, List_tmp), 2188 set_flatten(TO, List_tmp, O_List). 2189set_flatten([], [HList|T], O_List):- 2190 HList = [], 2191 set_flatten(T, [], O_List). 2192set_flatten([], [HList|T], O_List):- 2193 list(HList), 2194 set_flatten([HList|T],[], O_List),!. 2195set_flatten([], L,L):-!. 2196 2197 2198% list: [el1,el2, ...] --> bool 2199% ----------------------------- 2200list(A) :- 2201 var(A) , 2202 ! , 2203 fail . 2204list(A) :- 2205 functor(A,'.',_). 2206 2207reverse(L,RL) :- 2208 revSlave(L,[],RL). 2209 2210revSlave([],RL,RL). 2211revSlave([H|T],Sofar,Final) :- 2212 revSlave(T,[H|Sofar],Final). 2213 2214% ***********************for multy tasks***************** 2215:- assert(time_taken(0)). 2216:- assert(soln_size(0)). 2217 2218solve(N,FN):- 2219 N < FN, 2220 nl,write('task '), write(N),write(': '),nl, 2221 solve(N), 2222 Ni is N+1, 2223 solve(Ni,FN). 2224solve(FN,FN):- 2225 nl,write('task '), write(FN),write(': '),nl, 2226 solve(FN), 2227 retractall(sum(_)), 2228 assert(sum(0)), 2229 sum_time(CP), 2230 retractall(sum(_)), 2231 assert(sum(0)), 2232 sum_size(SIZE), 2233 TIM is CP /1000, 2234 retractall(time_taken(_)), 2235 retractall(soln_size(_)), 2236 nl,write('total time '),write(TIM),write(' seconds'), 2237 nl,write('total size '),write(SIZE),nl. 2238solve(N,N). 2239 2240sum_time(TIM):- 2241 time_taken(CP), 2242 retract(sum(N)), 2243 N1 is N +CP, 2244 assert(sum(N1)), 2245 fail. 2246sum_time(TIM):- 2247 sum(TIM). 2248sum_size(SIZE):- 2249 soln_size(S), 2250 retract(sum(N)), 2251 N1 is N +S, 2252 assert(sum(N1)), 2253 fail. 2254sum_size(SIZE):- 2255 sum(SIZE). 2256 2257stoppoint. 2258% State1 has relation with State2 2259state_related(Post,Cond,undefd):-!. 2260state_related(Post,Cond,[]):-!. 2261state_related(Post,Cond,State2):- 2262 append_dcut(Post,Cond,State1), 2263 state_related(State1,State2). 2264 2265% all states in necc are primitive 2266% so does the goal state--State2 2267state_related([se(Sort,Obj,SE1)|State1],State2):- 2268 member(se(Sort,Obj,SE2),State2), 2269 state_related0(SE1,SE2). 2270% states in Cond are not neccessary primitive 2271state_related([sc(Sort1,Obj,SE1=>SS1)|State1],State2):- 2272 member(se(Sort,Obj,SE2),State2), 2273 is_of_sort(Obj,Sort1), 2274 is_of_sort(Obj,Sort). 2275state_related([se(Sort,Obj,SE)|State1],State2):- 2276 state_related(State1,State2),!. 2277state_related([sc(Sort,Obj,SE=>SS)|State1],State2):- 2278 state_related(State1,State2),!. 2279 2280%instatiate abit the variables 2281state_related0([],SE2):-!. 2282state_related0([Head|SE1],SE2):- 2283 member(Head,SE2), 2284 state_related0(SE1,SE2). 2285state_related0([Head|SE1],SE2):- 2286 state_related0(SE1,SE2). 2287 2288% change_obj_list: narrow down objects 2289% by just using the objects occure in initial states(world state) 2290change_obj_list(I):- 2291 find_dynamic_objects(I), 2292 collect_dynamic_obj, 2293 change_obj_list1, 2294 change_atomic_inv,!. 2295 2296change_obj_list1:- 2297 objects(Sort,OBjls), 2298 change_obj_list2(Sort), 2299 fail. 2300change_obj_list1. 2301 2302% only keep the dynamic objects that used in tasks 2303change_obj_list2(Sort):- 2304 objectsC(Sort,Objls),!. 2305% statics objects: keep 2306change_obj_list2(Sort):- 2307 objects(Sort,Objls), 2308 assert(objectsC(Sort,Objls)),!. 2309 2310% only keep the dynamic objects in atomic_invariants 2311change_atomic_inv:- 2312 atomic_invariants(Atom), 2313 change_atomic_inv1(Atom,Atom1), 2314 assert(atomic_invariantsC(Atom1)),!. 2315change_atomic_inv. 2316 2317change_atomic_inv1([],[]). 2318change_atomic_inv1([Pred|Atom],[Pred|Atom1]):- 2319 Pred=..[Name|Objs], 2320 just_dynamic_objects(Objs), 2321 change_atomic_inv1(Atom,Atom1). 2322change_atomic_inv1([Pred|Atom],Atom1):- 2323 change_atomic_inv1(Atom,Atom1). 2324 2325just_dynamic_objects([]). 2326just_dynamic_objects([Head|Objs]):- 2327 objectsC(Sort,Objls), 2328 member(Head,Objls),!, 2329 just_dynamic_objects(Objs). 2330 2331find_dynamic_objects([]):-!. 2332find_dynamic_objects([SE|Rest]):- 2333 find_dynamic_objects(SE), 2334 find_dynamic_objects(Rest),!. 2335find_dynamic_objects(ss(Sort,Obj,_)):- 2336 assert(objectsD(Sort,Obj)),!. 2337 2338collect_dynamic_obj:- 2339 objectsD(Sort,_), 2340 setof(Obj, objectsD(Sort,Obj), Objls), 2341 retractall(objectsD(Sort,_)), 2342 assert(objectsC(Sort,Objls)), 2343 fail. 2344collect_dynamic_obj. 2345 2346get_preconditions_g([],Prev,Prev,Prev):-!. 2347get_preconditions_g([sc(S,X,From =>To)|Rest],Prev,[se(S,X,From)|Pre],[se(S,X,To)|Post]):- 2348 !, 2349 get_preconditions_g(Rest,Prev, Pre,Post). 2350 2351% ******************************************************************** 2352% ground all operators% enumerateOps 2353 2354ground_op :- 2355 assert_sort_objects, 2356 enumerateOps, 2357 instOps, 2358 opCounter(Top), 2359 write(Top),nl. 2360 2361enumerateOps :- 2362 retractall(opCounter), 2363 assert(opCounter(1)), 2364 enumOps. 2365 2366enumOps :- 2367 operator(Name,Prev,Nec,Cond), 2368 retract(opCounter(Count)), 2369 containsInvars(operator(Name,Prev,Nec,Cond),InVars,IsOfSorts,FPrev,FNec), 2370 %Find the atomic_invariants 2371 findVarsAndTypes(operator(Name,Prev,Nec,Cond),VT,NEs), 2372 assert(opParent(Count,operator(Name,FPrev,FNec,Cond),VT,NEs,InVars,IsOfSorts)), 2373 Next is Count + 1, 2374 assert(opCounter(Next)), 2375 fail. 2376 2377enumOps. 2378 2379 2380% ********************************************************************* 2381% findVarsAndTypes - collect a list of all variables and their 2382% types as they occur in an operator 2383% also collect the list of "ne" constraints 2384% that apply to variables 2385% [<Type>,<Variable>|<Rest>] 2386% 2387% findVarsAndTypes(+Operator,-TypeVarList,-Nes) 2388 2389 2390findVarsAndTypes(operator(_,Pre,Nec,Cond),Vars,NEs) :- 2391 vtPrevail(Pre,PreVars,PreNEs), 2392 vtEffects(Nec,NecVars,NecNEs), 2393 append_dcut(PreVars,NecVars,Vars), 2394 append_dcut(PreNEs,NecNEs,NEs), 2395 !. 2396 2397% collect all Vars and types in a changes clause 2398%vtEffects(+EffectsClause,-VarsTypes,-NEClauses). 2399 2400vtEffects([],[],[]). 2401 2402vtEffects([sc(Type,Obj1,Preds)|Rest],VT,NEs) :- 2403 vtPreds(Preds,Related,NEs1), 2404 append_dcut([Type,Obj1],Related,Obj1VT), 2405 vtEffects(Rest,RestVT,RestNEs), 2406 append_dcut(Obj1VT,RestVT,VT), 2407 append_dcut(NEs1,RestNEs,NEs). 2408 2409% collect all Vars and types in a Prevail clause 2410%vtPrevail(+PrevailClause,-VarsTypes,-NEClauses). 2411 2412vtPrevail([],[],[]). 2413 2414vtPrevail([se(Type,Obj1,Preds)|Rest],VT,NEs) :- 2415 vtPLst(Preds,Related,NEs1), 2416 append_dcut([Type,Obj1],Related,Obj1VT), 2417 vtPrevail(Rest,RestVT,RestNEs), 2418 append_dcut(Obj1VT,RestVT,VT), 2419 append_dcut(NEs1,RestNEs,NEs). 2420 2421% Deal with the change predicates in a changes clause 2422% vtPreds(+ChangeProps,-VarsTypes,-NEClauses). 2423 2424vtPreds((Pre => Add),Res,NEs) :- 2425 vtPLst(Pre,VTPre,NEs1), 2426 vtPLst(Add,VTAdd,NEs2), 2427 append_dcut(VTPre,VTAdd,Res), 2428 append_dcut(NEs1,NEs2,NEs). 2429 2430% Deal with a list of literals 2431% vtPLst(+Literals,-VarTypes,-NEClauses). 2432 2433vtPLst([],[],[]). 2434 2435vtPLst([ne(X,Y)|Rest],Res,[ne(X,Y)|RestNEs]) :- 2436 !, 2437 vtPLst(Rest,Res,RestNEs). 2438 2439vtPLst([Pred|Preds],Res,NEs) :- 2440 functor(Pred,_,1), 2441 !, 2442 vtPLst(Preds,Res,NEs). 2443 2444vtPLst([is_of_sort(_,_)|Preds],Res,NEs) :- 2445 !, 2446 vtPLst(Preds,Res,NEs). 2447 2448% here is the hard bit, Create a dummy literal - instantiate it with 2449% the OCL predicate list to find the types then 2450% match up the type with the original literal variables. 2451 2452vtPLst([Pred|Preds],Res,NEs) :- 2453 functor(Pred,Name,Arity), 2454 Pred =.. [Name,Obj1|Rest], 2455 VNeeded is Arity - 1, 2456 createVarList(VNeeded,VN), 2457 DummyPred =.. [Name,X|VN], 2458 predicates(PList), 2459 member(DummyPred,PList), 2460 pair(VN,Rest,This), 2461 vtPLst(Preds,RestPre,NEs), 2462 append_dcut(This,RestPre,Res). 2463 2464% Create a list of new uninstantiated variables 2465% createVarList(+NoOfVariablesNeeded, -ListOfvariables). 2466 2467createVarList(1,[X]) :- 2468 !. 2469 2470createVarList(N,[X|Rest]) :- 2471 Next is N - 1, 2472 createVarList(Next,Rest). 2473 2474% merge the list of variables and the list of types 2475% pair(+TypeList,+VarList,-varTypeList). 2476 2477pair([],[],[]). 2478 2479pair([Type|Types],[Var|Vars],[Type,Var|Rest]) :- 2480 pair(Types,Vars,Rest). 2481 2482 2483 2484% ********************************************************************** 2485% Top Level Routine to instantiate / ground operators in all legal ways 2486% 2487% instOps 2488 2489instOps :- 2490 retractall(opCounter(_)), 2491 assert(opCounter(1)), 2492 opParent(No,Operator,VT,NEs,InVars,IsOfSorts), 2493 checkIsOfSorts(IsOfSorts), 2494 checkInVars(InVars), 2495 chooseVals(VT,NEs,InVars,Vals), 2496 obeysNEs(NEs), 2497 retract(opCounter(Count)), 2498 operator(Name,Prev,Nec,Cond) = Operator, 2499 filterSE(Prev,FPrev), 2500 filterSC(Nec,FNec), 2501 assert(gOperator(Count,No,operator(Name,FPrev,FNec,Cond))), 2502 Next is Count + 1, 2503 assert(opCounter(Next)), 2504 fail. 2505 2506instOps. 2507 2508 2509checkInVars([]):- !. 2510checkInVars(Preds):- 2511 atomic_invariantsC(Invars), 2512 doCheckInvars(Preds,Invars). 2513 2514doCheckInvars([],_). 2515doCheckInvars([Pred|Rest],Invars) :- 2516 member(Pred,Invars), 2517 doCheckInvars(Rest,Invars). 2518 2519checkIsOfSorts([]). 2520checkIsOfSorts([is_of_sort(V,Sort)|Rest]) :- 2521 objectsOfSort(Sort,Objs), 2522 member(V,Objs), 2523 checkIsOfSorts(Rest). 2524 2525 2526% filterSE - remove ne and is_of_sort clauses 2527 2528filterSE([],[]) :- !. 2529filterSE([se(Sort,Id,Preds)|Rest],[se(Sort,Id,FPreds)|FRest]) :- 2530 filterPreds(Preds,FPreds),!, 2531 filterSE(Rest,FRest). 2532 2533% filterSC - remove ne and is_of_sort clauses 2534 2535filterSC([],[]) :- !. 2536filterSC([sc(Sort,Id,(Pre => Post))|Rest],[sc(Sort,Id,(FPre => FPost))|FRest]) :- 2537 filterPreds(Pre,FPre), 2538 filterPreds(Post,FPost), 2539 !, 2540 filterSC(Rest,FRest). 2541 2542% FilterPreds - remove ne and is_of_sort clauses 2543 2544filterPreds([],[]). 2545filterPreds([ne(_,_)|Rest],FRest) :- 2546 !, 2547 filterPreds(Rest,FRest). 2548filterPreds([is_of_sort(_,_)|Rest],FRest) :- 2549 !, 2550 filterPreds(Rest,FRest). 2551%filterPreds([Pred|Rest],FRest) :- 2552% atomic_invariantsC(Invars), 2553% member(Pred,Invars), 2554% !, 2555% filterPreds(Rest,FRest). 2556filterPreds([H|T],[H|FT]) :- 2557 filterPreds(T,FT). 2558 2559 2560% Collect all possible ways of instantiating the conditional effects 2561 2562collectAllConds(_,_,_,_,[],[]) :- !. 2563 2564collectAllConds(CondVT,NEs,InVars,CondVals,Cond,_) :- 2565 retractall(temp(_)), 2566 chooseVals(CondVT,NEs,InVars,Vals), 2567 assertIndivConds(Cond), 2568 fail. 2569 2570collectAllConds(_,_,_,_,_,NewConds) :- 2571 setof(Cond,temp(Cond),NewConds). 2572 2573assertIndivConds([]) :- !. 2574 2575assertIndivConds([H|T]) :- 2576 assert(temp(H)), 2577 assertIndivConds(T). 2578 2579% Find the atomic_invariants in the Operator 2580 2581containsInvars(operator(Name,Prev,Nec,Cond),InVars,IsOfSorts,FPrev,FNec) :- 2582 prevInvars(Prev,PInVars,PIsOfSorts,FPrev), 2583 necInvars(Nec,NecInVars,NIsOfSorts,FNec), 2584 append_dcut(NecInVars,PInVars,InVars), 2585 append_dcut(PIsOfSorts,NIsOfSorts,IsOfSorts), 2586 !. 2587 2588prevInvars([],[],[],[]). 2589prevInvars([se(Type,Obj,Props)|Rest],InVars,IsOfSorts,[se(Type,Obj,FProps)|RFPrev]) :- 2590 propsInvars(Props,PInvars,PIsOfSorts,FProps), 2591 prevInvars(Rest,RInVars,RIsOfSorts,RFPrev), 2592 append_dcut(PInVars,RInVars,InVars), 2593 append_dcut([is_of_sort(Obj,Type)|PIsOfSorts],RIsOfSorts,IsOfSorts). 2594 2595necInvars([],[],[],[]). 2596necInvars([sc(Type,Obj,(Props => Adds))|Rest],Invars,IsOfSorts,[sc(Type,Obj,(FProps => FAdds))|RFNec]) :- 2597 propsInvars(Props,PInvars,PIsOfSorts,FProps), 2598 propsInvars(Adds,AInvars,AIsOfSorts,FAdds), 2599 necInvars(Rest,RInvars,RIsOfSorts,RFNec), 2600 append_dcut(AInvars,PInvars,Temp), 2601 append_dcut(Temp,RInvars,Invars), 2602 append_dcut(PIsOfSorts,AIsOfSorts,SortsTemp), 2603 append_dcut([is_of_sort(Obj,Type)|SortsTemp],RIsOfSorts,IsOfSorts). 2604 2605propsInvars([],[],[],[]). 2606propsInvars([Prop|Props],[Prop|Rest],IsOfSorts,FProps) :- 2607 isInvariant(Prop), 2608 !, 2609 propsInvars(Props,Rest,IsOfSorts,FProps). 2610propsInvars([is_of_sort(X,Y)|Props],InVars,[is_of_sort(X,Y)|IsOfSorts],FProps):- 2611 !, 2612 propsInvars(Props,InVars,IsOfSorts,FProps). 2613 2614propsInvars([Pred|Props],Rest,IsOfSorts,[Pred|FProps]) :- 2615 propsInvars(Props,Rest,IsOfSorts,FProps). 2616 2617isInvariant(Prop) :- 2618 atomic_invariantsC(Invars), 2619 functor(Prop,Name,Arity), 2620 createVarList(Arity,VN), 2621 Pred =.. [Name | VN], 2622 member(Pred,Invars). 2623 2624% Select values for the variables in the operator 2625% 2626% chooseVals(+TypeVarList,+NEList,+Invariants,-VarValueList) 2627 2628chooseVals([],_,_,[]). 2629 2630chooseVals([Type,Var|TypeVars],NEs,InVars,Vals) :- 2631 ground(Var), 2632 !, 2633 chooseVals(TypeVars,NEs,InVars,Vals). 2634 2635chooseVals([Type,Var|TypeVars],NEs,InVars,[Var|Vals]) :- 2636 objectsOfSort(Type,AllVals), 2637 member(Var,AllVals), 2638 chooseVals(TypeVars,NEs,InVars,Vals).

2645assert_sort_objects :- 2646 objectsC(Type,Objects), 2647 assert(objectsOfSort(Type,Objects)), 2648 fail. 2649 2650assert_sort_objects :- 2651 sorts(Type,SubTypes), 2652 Type \== primitive_sorts, 2653 Type \== non_primitive_sorts, 2654 all_objects(Type,Objs), 2655 assert(objectsOfSort(Type,Objs)), 2656 fail. 2657 2658assert_sort_objects. 2659 2660all_objects(Type,Objs) :- 2661 objectsC(Type,Objs), 2662 !. 2663all_objects(Type,Objs) :- 2664 sorts(Type,SubSorts), 2665 !, 2666 collect_subsort_objects(SubSorts,Objs). 2667 2668collect_subsort_objects([],[]). 2669collect_subsort_objects([Sort|Rest],Objs ) :- 2670 all_objects(Sort,SortObjs), 2671 !, 2672 collect_subsort_objects(Rest,RestObjs), 2673 append_dcut(SortObjs,RestObjs,Objs). 2674 2675obeysNEs([]). 2676 2677obeysNEs([ne(V1,V2)|Rest]) :- 2678 V1 \== V2, 2679 obeysNEs(Rest). 2680 2681obeysInVars([]). 2682obeysInVars([Prop|Rest]) :- 2683 atomic_invariantsC(Invars), 2684 member(Prop,Invars), 2685 !. 2686 2687% ********************************************************************** 2688% prettyPrinting Routines for ground OCL operators 2689% long and boring 2690 2691 2692% prettyPrintOp(+<Ground Operator>) 2693 2694prettyPrintOp(gOperator(No,Par,Op)) :- 2695 write('gOperator('), 2696 write(No),write(','), 2697 write(Par),write(','),nl, 2698 writeOp(4,Op), 2699 !. 2700 2701writeOp(TabVal,operator(Name,Prev,Nec,Cond)) :- 2702 tab(TabVal), 2703 write('operator('),write(Name),write(','),nl, 2704 tab(8),write('% Prevail'),nl, 2705 tab(8),write('['),nl, 2706 writePrevailLists(8,Prev), 2707 tab(8),write('],'),nl, 2708 tab(8),write('% Necessary'),nl, 2709 tab(8),write('['),nl, 2710 writeChangeLists(10,Nec), 2711 tab(8),write('],'),nl, 2712 tab(8),write('% Conditional'),nl, 2713 tab(8),write('['),nl, 2714 writeChangeLists(10,Cond), 2715 tab(8),write('])).'),nl. 2716 2717writePropList(TabVal,[]) :- 2718 tab(TabVal), 2719 write('[]'). 2720 2721writePropList(TabVal,[ne(_,_)|Props]) :- 2722 !, 2723 writePropList(Indent,Props). 2724 2725writePropList(TabVal,[Prop|Props]) :- 2726 atomic_invariantsC(Invars), 2727 member(Prop,Invars), 2728 writePropList(TabVal,Props). 2729 2730writePropList(TabVal,[Prop|Props]) :- 2731 tab(TabVal), 2732 write('['), 2733 write(Prop), 2734 Indent is TabVal + 1, 2735 writePList(Indent,Props). 2736 2737writePList(TabVal,[]) :- 2738 nl, 2739 tab(TabVal), 2740 write(']'). 2741 2742writePList(TabVal,[ne(_,_)]) :- 2743 !, 2744 nl, 2745 tab(TabVal), 2746 write(']'). 2747 2748writePList(TabVal,[Prop]) :- 2749 atomic_invariantsC(Invars), 2750 member(Prop,Invars), 2751 !, 2752 nl, 2753 tab(TabVal), 2754 write(']'). 2755 2756writePList(TabVal,[Prop]) :- 2757 write(','), 2758 nl, 2759 tab(TabVal), 2760 write(Prop), 2761 write(']'). 2762 2763writePList(TabVal,[ne(_,_),P2|Rest]) :- 2764 !, 2765 writePList(TabVal,[P2|Rest]). 2766 2767writePList(TabVal,[Prop,P2|Rest]) :- 2768 atomic_invariantsC(Invars), 2769 member(Prop,Invars), 2770 !, 2771 writePList(TabVal,[P2|Rest]). 2772 2773writePList(TabVal,[P1,P2|Rest]) :- 2774 write(','), 2775 nl, 2776 tab(TabVal), 2777 write(P1), 2778 writePList(TabVal,[P2|Rest]). 2779 2780writeChangeLists(_,[]). 2781 2782writeChangeLists(TabVal,[sc(Type,Obj,(Req => Add))|Rest]) :- 2783 tab(TabVal), 2784 write('sc('),write(Type),write(','),write(Obj),write(',('),nl, 2785 Indent is TabVal + 12, 2786 writePropList(Indent,Req), 2787 nl, 2788 tab(Indent), 2789 write('=>'), 2790 nl, 2791 writePropList(Indent,Add), 2792 write('))'),writeComma(Rest), 2793 nl, 2794 writeChangeLists(TabVal,Rest). 2795 2796writeComma([]). 2797writeComma(_) :- 2798 write(','). 2799 2800writePrevailLists(_,[]). 2801 2802writePrevailLists(TabVal,[se(Type,Obj,Props)|Rest]) :- 2803 tab(TabVal), 2804 write('se('),write(Type),write(','),write(Obj),write(','),nl, 2805 Indent is TabVal + 12, 2806 writePropList(Indent,Props), 2807 write(')'),writeComma(Rest), 2808 nl, 2809 writePrevailLists(TabVal,Rest). 2810 2811 2812assert_is_of_sort :- 2813 objectsOfSort(Type,Objects), 2814 member(Obj,Objects), 2815 assert_is_of_sort1(Type,Obj), 2816 fail. 2817assert_is_of_sort :- 2818 objectsC(Type,Objects), 2819 member(Obj,Objects), 2820 assert_is_of_primitive_sort(Type,Obj), 2821 fail. 2822assert_is_of_sort. 2823 2824assert_is_of_sort1(Type,Obj):- 2825 assert(is_of_sort(Obj,Type)),!. 2826assert_is_of_primitive_sort(Type,Obj):- 2827 assert(is_of_primitive_sort(Obj,Type)),!. 2828 2829 2830% change substate_class to primary sort level 2831% assert in prolog database as gsubstate_class(Sort,Obj,States) 2832prim_substate_class:- 2833 substate_classes(Sort,Obj,Substate), 2834 find_prim_sort(Sort,PS), 2835 assert_subclass(PS,Obj,Substate), 2836 fail. 2837prim_substate_class:- 2838 collect_prim_substates. 2839 2840assert_subclass([],Obj,Substate). 2841assert_subclass([HS|TS],Obj,Substate):- 2842 assert(gsstates(HS,Obj,Substate)), 2843 assert_subclass(TS,Obj,Substate). 2844 2845collect_prim_substates:- 2846 gsstates(Sort,Obj,_), 2847 setof(SStates,gsstates(Sort,Obj,SStates),GSStates), 2848 retractall(gsstates(Sort,Obj,_)), 2849 all_combined(GSStates,GSStates0), 2850 assert(gsubstate_classes(Sort,Obj,GSStates0)), 2851 fail. 2852collect_prim_substates. 2853 2854all_combined(SStates,CSStates):- 2855 xprod(SStates,CSStates1), 2856 flat_interal(CSStates1,CSStates),!. 2857 2858flat_interal([],[]):-!. 2859flat_interal([HSS1|TSS1],[HSS|TSS]):- 2860 flatten(HSS1,[],HSS), 2861 flat_interal(TSS1,TSS),!. 2862 2863% xprod: list * list --> (list X list) 2864% ----------------------------------- 2865xprod(A,B,C) :- 2866 xprod([A,B],C) . 2867 2868xprod([],[]). 2869xprod(A,E) :- 2870 xprod(A,B,C,D) , 2871 F =..[^,C,D] , 2872 call(setof(B,F,E)) . 2873 2874xprod([X],[A],A,member(A,X)) . 2875xprod([X,Y],[A,B],C,(D,E)) :- 2876 C =..[^,A,B] , 2877 D =..[member,A,X] , 2878 E =..[member,B,Y] . 2879xprod([X|Y],[A|E],D,(F,G)) :- 2880 D =..[^,A,C] , 2881 F =..[member,A,X] , 2882 xprod(Y,E,C,G). 2883 2884 2885 2886 2887:-retractall(solution_file(_)). 2888:-asserta(solution_file(user)). 2889 2890% :-sleep(1). 2891% :-tell(user),run_header_tests. 2892 2893 2894 2895lws:- listing(ocl:[method, 2896operator,implied_invariant,atomic_invariants,inconsistent_constraint,predicates,objects,substate_classes,sorts,domain_name,planner_task_slow,planner_task, 2897htn_task,tp_node,tn,current_num,goal_related,goal_related_search,solved_node,closed_node,tp_goal,final_node,node,op_score,gsstates,gsubstate_classes,related_op, 2898objectsOfSort,atomic_invariantsC,objectsD,objectsC,gOperator,operatorC,opParent,methodC,is_of_sort,is_of_primitive_sort,temp_assertIndivConds]). 2899 2900lws(F):-tell(F),lws,told. 2901 2902:-export(rr/0). 2903:-export(rr1/0). 2904rr:- test_ocl('domains_ocl/chameleonWorld.ocl'). 2905rr1:- test_ocl('domains_ocl/translog.ocl'). 2906 2907:- include(translog4). 2908 2909:- fixup_exports. 2910 2911% :-rr.