2:-module(slipcover,[set_sc/2,setting_sc/2,
3 induce/2,induce_par/2,test/7,list2or/2,list2and/2,
4 sample/4,learn_params/5,
5 op(500,fx,#),op(500,fx,'-#'),
6 test_prob/6,rules2terms/2,
7 get_sc_var_n/6,
8 process_clauses/6,
9 generate_clauses/6,
10 generate_clauses_bg/2,
11 generate_body/3,
12 make_dynamic/1,
13 extract_fancy_vars/2,
14 linked_clause/3,
15 banned_clause/3,
16 take_var_args/3,
17 remove_duplicates/2,
18 extract_type_vars/3,
19 delete_one/3,
20 get_next_rule_number/2,
21 tab/3,
22 zero_clause/3,
23 member_eq/2,
24 retract_all/1,assert_all/3,
25 write2/2,write3/2,format2/3,format3/3,
26 write_rules2/3,write_rules3/3,
27 nl2/1,nl3/1]).
45/* 46 47SLIPCOVER 48 49Copyright (c) 2016, Fabrizio Riguzzi and Elena Bellodi 50 51*/ 52:-reexport(library(bddem)). 53:-use_module(library(auc)). 54:-use_module(library(lists)). 55:-use_module(library(random)). 56:-use_module(library(system)). 57:-use_module(library(terms)). 58:-use_module(library(apply)). 59:-use_module(cplint_util). 60:-set_prolog_flag(unknown,warning). 61 62 63:- dynamic db/1. 64 65:- dynamic sc_input_mod/1. 66 67:- thread_local sc_input_mod/1. 68 69:- meta_predicate induce( , ). 70:- meta_predicate induce_rules( , ). 71:- meta_predicate induce_par( , ). 72:- meta_predicate induce_parameters( , ). 73:- meta_predicate test( , , , , , , ). 74:- meta_predicate test_prob( , , , , , ). 75:- meta_predicate set_sc( , ). 76:- meta_predicate setting_sc( , ). 77 78default_setting_sc(epsilon_em,0.0001). 79default_setting_sc(epsilon_em_fraction,0.00001). 80default_setting_sc(eps,0.0001). 81default_setting_sc(eps_f,0.00001). 82 83/* if the difference in log likelihood in two successive em iteration is smaller 84than epsilon_em, then EM stops */ 85default_setting_sc(epsilon_sem,2). 86 87/* number of random restarts of em */ 88default_setting_sc(random_restarts_REFnumber,1). 89default_setting_sc(random_restarts_number,1). 90default_setting_sc(iterREF,-1). 91default_setting_sc(iter,-1). 92default_setting_sc(examples,atoms). 93default_setting_sc(group,1). 94default_setting_sc(d,1). 95default_setting_sc(verbosity,1). 96default_setting_sc(logzero,log(0.000001)). 97default_setting_sc(megaex_bottom,1). 98default_setting_sc(initial_clauses_per_megaex,1). 99default_setting_sc(max_iter,10). 100default_setting_sc(max_iter_structure,10000). 101default_setting_sc(max_var,4). 102default_setting_sc(max_rules,10). 103default_setting_sc(maxdepth_var,2). 104default_setting_sc(beamsize,100). 105default_setting_sc(max_body_length,100). 106default_setting_sc(neg_literals,false). 107default_setting_sc(background_clauses,50). 108 109default_setting_sc(specialization,bottom). 110/* allowed values: mode,bottom */ 111default_setting_sc(specialize_head,false). 112 113default_setting_sc(seed,seed(3032)). 114default_setting_sc(c_seed,21344). 115default_setting_sc(score,ll). 116/* allowed values: ll aucpr */ 117default_setting_sc(neg_ex,cw). 118 119 120default_setting_sc(epsilon_parsing, 1e-5). 121default_setting_sc(tabling,auto). 122/* values: 123 auto 124 explicit 125*/ 126 127default_setting_sc(bagof,false). 128/* values: false, intermediate, all, extra */ 129 130default_setting_sc(compiling,off). 131 132 133default_setting_sc(depth_bound,true). %if true, it limits the derivation of the example to the value of 'depth' 134default_setting_sc(depth,2). 135default_setting_sc(single_var,true). %false:1 variable for every grounding of a rule; true: 1 variable for rule (even if a rule has more groundings),simpler. 136 137default_setting_sc(prob_approx,false). %if true, it limits the number of different solutions found when computing the probability 138default_setting_sc(approx_value,100). 139 140default_setting_sc(alpha,0.0). 141% Sets the type of parameter initialization for EM on Environment: 142% if alpha is 0.0, it uses a truncated Dirichlet process 143% if alpha is a float > 0.0, it uses a symmetric Dirichlet distribution 144% with that value as parameter
153induce(M:TrainFolds,P):-
154 must_be(list,TrainFolds),
155 must_be(var,P),
156 induce_rules(M:TrainFolds,P0),
157 rules2terms(P0,P).
169test(M:P,TestFolds,LL,AUCROC,ROC,AUCPR,PR):-
170 must_be(nonvar,P),
171 must_be(list,TestFolds),
172 must_be(var,LL),
173 must_be(var,AUCROC),
174 must_be(var,ROC),
175 must_be(var,AUCPR),
176 must_be(var,PR),
177 test_prob(M:P,TestFolds,_NPos,_NNeg,LL,LG),
178 compute_areas_diagrams(LG,AUCROC,ROC,AUCPR,PR).
189test_prob(M:P,TestFolds,NPos,NNeg,CLL,Results) :- 190 must_be(nonvar,P), 191 must_be(list,TestFolds), 192 must_be(var,NNeg), 193 must_be(var,CLL), 194 must_be(var,NPos), 195 must_be(var,Results), 196 write2(M,'Testing\n'), 197 findall(Exs,(member(F,TestFolds),M:fold(F,Exs)),L), 198 append(L,TE), 199 reset_next_rule_number(M), 200 set_sc(M:compiling,on), 201 process_clauses(P,M,[],_,[],PRules), 202 generate_clauses(PRules,M,RuleFacts,0,[],Th), 203 assert_all(Th,M,ThRef), 204 assert_all(RuleFacts,M,RFRef), 205 (M:bg(RBG0)-> 206 process_clauses(RBG0,M,[],_,[],RBG), 207 generate_clauses(RBG,M,_RBGRF,0,[],ThBG), 208 generate_clauses_bg(RBG,ClBG), 209 assert_all(ClBG,M,ClBGRef), 210 assert_all(ThBG,ThBGRef) 211 ; 212 true 213 ), 214 set_sc(M:compiling,off), 215 test_no_area([TE],M,NPos,NNeg,CLL,Results), 216 (M:bg(RBG0)-> 217 retract_all(ThBGRef), 218 retract_all(ClBGRef) 219 ; 220 true 221 ), 222 retract_all(ThRef), 223 retract_all(RFRef). 224 225induce_rules(M:Folds,R):- 226 set_sc(M:compiling,on), 227 M:local_setting(seed,Seed), 228 set_random(Seed), 229 M:local_setting(c_seed,CSeed), 230 rand_seed(CSeed), 231 findall(Exs,(member(F,Folds),M:fold(F,Exs)),L), 232 append(L,DB), 233 assert(M:database(DB)), 234 (M:bg(RBG0)-> 235 process_clauses(RBG0,M,[],_,[],RBG), 236 generate_clauses(RBG,M,_RBG1,0,[],ThBG), 237 generate_clauses_bg(RBG,ClBG), 238 assert_all(ThBG,M,ThBGRef), 239 assert_all(ClBG,M,ClBGRef) 240 ; 241 true 242 ), 243 length(DB,NMegaEx), 244 M:local_setting(megaex_bottom, NumMB), 245 (NMegaEx >= NumMB -> 246 true 247 ; 248 format2(M,"~nWARN: Number of required bottom clauses is greater than the number of training examples!~n. The number of required bottom clauses will be equal to the number of training examples", []), 249 set_sc(M:megaex_bottom, NMegaEx) 250 ), 251 252 statistics(walltime,[_,_]), 253 (M:local_setting(specialization,bottom)-> 254 M:local_setting(megaex_bottom,MB), 255 deduct(MB,M,DB,[],InitialTheory), 256 length(InitialTheory,_LI), 257 remove_duplicates(InitialTheory,R1) 258 ; 259 get_head_atoms(O,M), 260 generate_top_cl(O,M,R1) 261 ), 262 learn_struct(DB,M,R1,R2,Score2), 263 learn_params(DB,M,R2,R,Score), 264 format2(M,"~nRefinement score ~f - score after EMBLEM ~f~n",[Score2,Score]), 265 statistics(walltime,[_,WT]), 266 WTS is WT/1000.0, 267 write2(M,'\n\n'), 268 format2(M,'/* SLIPCOVER Final score ~f~n',[Score]), 269 format2(M,'Wall time ~f */~n',[WTS]), 270 write_rules2(M,R,user_output), 271 set_sc(M:compiling,off), 272 (M:bg(RBG0)-> 273 retract_all(ThBGRef), 274 retract_all(ClBGRef) 275 ; 276 true 277 ), 278 clean_up_db_structure(M). 279 280clean_up_db_structure(M):- 281 retractall(M:ref(_)), 282 retractall(M:ref_clause(_)), 283 clean_up_db(M).
290make_dynamic(M):- 291 M:(dynamic int/1), 292 findall(O,M:output(O),LO), 293 findall(I,M:input(I),LI), 294 findall(I,M:input_cw(I),LIC), 295 findall(D,M:determination(D,_DD),LDH), 296 findall(DD,M:determination(_D,DD),LDD), 297 findall(DH,(M:modeh(_,_,_,LD),member(DH,LD)),LDDH), 298 append([LO,LI,LIC,LDH,LDD,LDDH],L0), 299 remove_duplicates(L0,L), 300 maplist(to_dyn(M),L). 301 302to_dyn(M,P/A):- 303 A1 is A+1, 304 M:(dynamic P/A1), 305 A2 is A1+2, 306 M:(dynamic P/A2), 307 A3 is A2+1, 308 M:(dynamic P/A3). 309 310 311 312gen_fixed([],_M,[]). 313 314gen_fixed([(H,B,BL)|T],M,[rule(R,H,B,BL,tunable)|T1]):- 315 get_next_rule_number(M,R), 316 gen_fixed(T,M,T1). 317 318 319learn_struct(DB,Mod,R1,R,Score):- %+R1:initial theory of the form [rule(NR,[h],[b]],...], -R:final theory of the same form, -CLL 320 format2(Mod,"Clause search~n~n",[]), 321 Mod:local_setting(max_iter,M), 322 Mod:local_setting(depth_bound,DepthB), 323 set_sc(Mod:depth_bound,false), 324 findall((H,B,BL),Mod:fixed_rule(H,B,BL),LF), 325 length(LF,LLF), 326 gen_fixed(LF,Mod,LFR), 327 format2(Mod,"Scoring fixed clauses: ~d clauses~n~n",[LLF]), 328 score_clause_refinements(LFR,Mod,1,LLF,DB,[],NB1,[],CL0,[],CLBG0), 329 append(NB1,R1,Beam), 330 cycle_beam(Beam,Mod,DB,CL0,CL,CLBG0,BG,M), 331 learn_params(DB,Mod,[],REmpty,S), 332 set_sc(Mod:depth_bound,DepthB), 333 format2(Mod,"Theory search~n~n",[]), 334 Mod:local_setting(max_iter_structure,MS), 335 cycle_structure(CL,Mod,REmpty,S,-1e20,DB,R2,Score,MS), 336 format2(Mod,"Best target theory~n~n",[]), 337 write_rules2(Mod,R2,user_output), 338 Mod:local_setting(background_clauses,NBG1), 339 length(BG,NBG), 340 format2(Mod,"Background search: ~d of ~d clauses~n~n",[NBG1,NBG]), 341 pick_first(NBG1,BG,BG1), 342 remove_score(BG,BG2), 343 write_rules2(Mod,BG2,user_output), 344 write2(Mod,'\n'), 345 append(R2,BG1,R). 346 347pick_first(0,_,[]):-!. 348 349pick_first(_,[],[]):-!. 350 351pick_first(N,[(H,_S)|T],[H|T1]):- 352 N1 is N-1, 353 pick_first(N1,T,T1). 354 355remove_score([],[]). 356 357remove_score([(H,_S)|T],[H|T1]):- 358 remove_score(T,T1). 359 360cycle_structure([],_Mod,R,S,_SP,_DB,R,S,_I):-!. %empty beam 361 362cycle_structure(_CL,_Mod,R,S,_SP,_DB,R,S,0):-!. %0 iterations 363 364cycle_structure([(RH,_CLL)|RT],Mod,R0,S0,SP0,DB,R,S,M):- 365 already_scored(Mod,[RH|R0],R3,Score),!, 366 format2(Mod,"Theory iteration ~d~n~n",[M]), 367 write3(Mod,'Already scored, updated refinement\n'), 368 write_rules3(Mod,R3,user_output), 369 write3(Mod,'Score '),write3(Mod,Score),write3(Mod,'\n\n\n'), 370 (Score>S0-> 371 R4=R3, 372 S4=Score, 373 SP1=S0 374 ; 375 R4=R0, 376 S4=S0, 377 SP1=SP0 378 ), 379 M1 is M-1, 380 cycle_structure(RT,Mod,R4,S4,SP1,DB,R,S,M1). 381 382cycle_structure([(RH,_Score)|RT],Mod,R0,S0,SP0,DB,R,S,M):- 383 format2(Mod,"Theory iteration ~d~n~n",[M]), 384 reset_next_rule_number(Mod), 385 generate_clauses([RH|R0],Mod,R2,0,[],Th1), 386 format3(Mod,"Initial theory~n~n",[]), 387 write_rules3(Mod,[RH|R0],user_output), 388 assert_all(Th1,Mod,Th1Ref), 389 assert_all(R2,Mod,R2Ref),!, 390 init_em(ExData), 391 retractall(Mod:v(_,_,_)), 392 length(DB,NEx), 393 abolish_all_tables, 394 (Mod:local_setting(examples,atoms)-> 395 Mod:local_setting(group,G), 396 derive_bdd_nodes_groupatoms(DB,Mod,ExData,NEx,G,[],Nodes,0,CLL0,LE,[]),! % 1 BDD per example if G=1 397 ; 398 derive_bdd_nodes(DB,Mod,ExData,NEx,[],Nodes,0,CLL0),! % 1 BDD per model 399 ), 400 Mod:local_setting(random_restarts_number,N), 401 format3(Mod,"~nInitial CLL ~f~n~n",[CLL0]), 402 random_restarts(N,Mod,ExData,Nodes,CLL0,Score,initial,Par,LE), %output:CLL,Par 403 format3(Mod,"Score after EMBLEM = ~f~n",[Score]), 404 retract_all(Th1Ref), 405 retract_all(R2Ref),!, 406 end_ex(ExData), 407 update_theory(R2,Par,R3), 408 write3(Mod,'Updated Theory\n'), 409 write_rules3(Mod,R3,user_output), %definite rules without probabilities in the head are not written 410 (Score>S0-> 411 R4=R3, 412 S4=Score, 413 SP1=S0, 414 write3(Mod,'New best score\n') 415 ; 416 R4=R0, 417 S4=S0, 418 SP1=SP0 419 ), 420 store_refinement(Mod,[RH|R0],R3,Score), 421 M1 is M-1, 422 cycle_structure(RT,Mod,R4,S4,SP1,DB,R,S,M1).
431induce_par(M:Folds,ROut):- 432 must_be(list,Folds), 433 must_be(var,ROut), 434 induce_parameters(M:Folds,R), 435 rules2terms(R,ROut). 436 437induce_parameters(M:Folds,R):- 438 set_sc(M:compiling,on), 439 M:local_setting(seed,Seed), 440 set_random(Seed), 441 M:local_setting(c_seed,CSeed), 442 rand_seed(CSeed), 443 findall(Exs,(member(F,Folds),M:fold(F,Exs)),L), 444 append(L,DB), 445 assert(M:database(DB)), 446 statistics(walltime,[_,_]), 447 (M:bg(RBG0)-> 448 process_clauses(RBG0,M,[],_,[],RBG), 449 generate_clauses(RBG,M,_RBG1,0,[],ThBG), 450 generate_clauses_bg(RBG,ClBG), 451 assert_all(ClBG,M,ClBGRef), 452 assert_all(ThBG,ThBGRef) 453 ; 454 true 455 ), 456 M:in(R00), 457 process_clauses(R00,M,[],_,[],R0), 458 statistics(walltime,[_,_]), 459 learn_params(DB,M,R0,R,Score), 460 statistics(walltime,[_,CT]), 461 CTS is CT/1000.0, 462 format2(M,'/* EMBLEM Final score ~f~n',[Score]), 463 format2(M,'Wall time ~f */~n',[CTS]), 464 write_rules2(M,R,user_output), 465 set_sc(M:compiling,off), 466 (M:bg(RBG0)-> 467 retract_all(ThBGRef), 468 retract_all(ClBGRef) 469 ; 470 true 471 ), 472 clean_up_db(M). 473 474clean_up_db(M):- 475 retract(M:rule_sc_n(_)), 476 assert(M:rule_sc_n(0)), 477 retract(M:rule_ng_sc_n(_)), 478 assert(M:rule_ng_sc_n(0)), 479 retractall(M:v(_,_,_)), 480 retractall(M:database(_)). 481 482get_rule_info(M,RI-Info):- 483 M:rule(R,HL,_BL,_Lit,Tun), 484 R\= ng(_,_), 485 (R=g(RI)-> 486 true 487 ; 488 RI=R 489 ), 490 length(HL,N), 491 ((Tun=tunable;Tun=initial)-> 492 Info=N 493 ; 494 Info=[N] 495 ). 496 497get_rule_info_rand(M,RI-Info):- 498 M:rule(R,HL,_BL,_Lit,Tun), 499 R\= ng(_,_), 500 (R=g(RI)-> 501 true 502 ; 503 RI=R 504 ), 505 length(HL,N), 506 (Tun=tunable-> 507 Info=N 508 ; 509 get_probs(HL,Info0), 510 (Tun=initial-> 511 Info=Info0 512 ; % fixed parameters 513 Info=[Info0] 514 ) 515 ).
527learn_params(DB,M,R0,R,Score):- %Parameter Learning 528 reset_next_rule_number(M), 529 reset_next_nonground_rule_number(M), 530 generate_clauses(R0,M,R1,0,[],Th0), 531 format2(M,"Initial theory~n",[]), 532 write_rules2(M,R1,user_output), 533 assert_all(Th0,M,Th0Ref), 534 assert_all(R1,M,R1Ref),!, 535 init_em(ExData), 536 retractall(M:v(_,_,_)), 537 length(DB,NEx), 538 abolish_all_tables, 539 (M:local_setting(examples,atoms)-> 540 M:local_setting(group,G), 541 derive_bdd_nodes_groupatoms(DB,M,ExData,NEx,G,[],Nodes,0,CLL0,LE,[]),! 542 ; 543 derive_bdd_nodes(DB,M,ExData,NEx,[],Nodes,0,CLL0),! 544 ), 545 format3(M,"Initial score ~f~n",[CLL0]), 546 M:local_setting(random_restarts_number,N), 547 random_restarts(N,M,ExData,Nodes,-1e20,Score,initial,Par,LE), %computes new parameters Par 548 end_ex(ExData), 549 update_theory_par(M,R1,Par,R), 550 retract_all(Th0Ref), 551 retract_all(R1Ref),!, 552 retractall(M:rule(_,_,_,_,_)). 553 554 555update_theory_par(M,OldR,Par,Rules):- 556 findall(def_rule(H,B,L),member(def_rule(H,B,L),OldR),DefRules0), 557 findall((H:-B),member((H:-B),OldR),DefRules1), 558 new_rules(Par,M,DisjRules0), 559 sort(DisjRules0,DisjRules), 560 append([DefRules0,DefRules1,DisjRules],Rules). 561 562new_rules([],_M,[]). 563 564new_rules([[_N,[1.0|_]]|T],M,R):-!, 565 new_rules(T,M,R). 566 567 568new_rules([[N,P]|T],M,[rule(N,H1,B,L,Tun)|R]):- 569 reverse(P,P1), 570 (M:rule(N,H,B,L,Tun);M:rule(g(N),H,B,L,Tun)), 571 update_head_par(H,P1,H1), 572 new_rules(T,M,R). 573 574 575update_theory(R,initial,R):-!. 576 577update_theory([],_Par,[]). 578 579update_theory([def_rule(H,B,L)|T0],Par,[def_rule(H,B,L)|T]):-!, 580 update_theory(T0,Par,T). 581 582update_theory([(H:-B)|T0],Par,[(H:-B)|T]):-!, 583 update_theory(T0,Par,T). 584 585update_theory([rule(N,H,B,L,Tun)|T0],Par,[rule(N,H1,B,L,Tun)|T]):- 586 member([N,P],Par),!, 587 reverse(P,P1), 588 update_head_par(H,P1,H1), 589 update_theory(T0,Par,T). 590 591update_head_par([],[],[]). 592 593update_head_par([H:_P|T0],[HP|TP],[H:HP|T]):- 594 update_head_par(T0,TP,T). 595 596cycle_beam([],_Mod,_DB,CL,CL,CLBG,CLBG,_M):-!. 597 598cycle_beam(_Beam,_Mod,_DB,CL,CL,CLBG,CLBG,0):-!. 599 600cycle_beam(Beam,Mod,DB,CL0,CL,CLBG0,CLBG,M):- 601 format2(Mod,"Clause iteration ~d~n~n",[M]), 602 cycle_clauses(Beam,Mod,DB,[],NB,CL0,CL1,CLBG0,CLBG1), 603 M1 is M-1,%decreases the number of max_iter M 604 cycle_beam(NB,Mod,DB,CL1,CL,CLBG1,CLBG,M1). 605 606cycle_clauses([],_M,_DB,NB,NB,CL,CL,CLBG,CLBG):-!. 607 608cycle_clauses([(RH,_ScoreH)|T],M,DB,NB0,NB,CL0,CL,CLBG0,CLBG):- 609 findall(RS,specialize_rule(RH,M,RS,_L),LR),!, %-LR:list of lists, each one correponding to a different revised theory; specialize_rule defined in revise.pl 610 length(LR,NR), 611 write3(M,'Number of revisions '),write3(M,NR),write3(M,'\n'), 612 score_clause_refinements(LR,M,1,NR,DB,NB0,NB1,CL0,CL1,CLBG0,CLBG1), 613 cycle_clauses(T,M,DB,NB1,NB,CL1,CL,CLBG1,CLBG). 614 615score_clause_refinements([],_M,_N,_NR,_DB,NB,NB,CL,CL,CLBG,CLBG). 616 617score_clause_refinements([R1|T],M,Nrev,NRef,DB,NB0,NB,CL0,CL,CLBG0,CLBG):- %scans the list of revised theories 618 already_scored_clause(M,R1,R3,Score),!, 619 format3(M,'Score ref. ~d of ~d~n',[Nrev,NRef]), 620 write3(M,'Already scored, updated refinement\n'), 621 write_rules3(M,[R3],user_output), 622 write3(M,'Score '),write3(M,Score),write3(M,'\n\n\n'), 623 M:local_setting(beamsize,BS), 624 insert_in_order(NB0,(R3,Score),BS,NB1), 625 Nrev1 is Nrev+1, 626 score_clause_refinements(T,M,Nrev1,NRef,DB,NB1,NB,CL0,CL,CLBG0,CLBG). 627 628score_clause_refinements([R1|T],M,Nrev,NRef,DB,NB0,NB,CL0,CL,CLBG0,CLBG):- 629 format3(M,'Score ref. ~d of ~d~n',[Nrev,NRef]), 630 write_rules3(M,[R1],user_output), 631 generate_clauses_cw([R1],M,[R2],0,[],Th1), 632 assert_all(Th1,M,Th1Ref), 633 assert_all([R2],M,[R2Ref]),!, 634 init_em(ExData), 635 retractall(M:v(_,_,_)), 636 length(DB,NEx), 637 get_output_preds(R1,O), 638 abolish_all_tables, 639 (M:local_setting(examples,atoms)-> 640 M:local_setting(group,G), 641 derive_bdd_nodes_groupatoms_output_atoms(DB,M,ExData,O,NEx,G,[],Nodes,0,CLL0,LE,[]),! 642 ; 643 derive_bdd_nodes(DB,M,ExData,NEx,[],Nodes,0,CLL0),! 644 ), 645 format3(M,"Initial CLL ~f~n",[CLL0]), 646 M:local_setting(random_restarts_REFnumber,N), 647 random_restarts_ref(N,M,ExData,Nodes,CLL0,Score,initial,Par,LE), 648 end_ex(ExData), 649 update_theory([R2],Par,[R3]), 650 write3(M,'Updated refinement\n'), 651 write_rules3(M,[R3],user_output), 652 write3(M,'Score (CLL) '),write3(M,Score),write3(M,'\n\n\n'), 653 retract_all(Th1Ref), 654 retract_all([R2Ref]),!, 655 M:local_setting(beamsize,BS), 656 insert_in_order(NB0,(R3,Score),BS,NB1), 657 (target(R3,M)-> 658 insert_in_order(CL0,(R3,Score),+1e20,CL1), 659 length(CL1,LCL1), 660 format2(M,"N. of target clauses ~d~n~n",[LCL1]), 661 CLBG1=CLBG0 662 ; 663 (range_restricted(R3)-> 664 insert_in_order(CLBG0,(R3,Score),+1e20,CLBG1), 665 length(CLBG1,LCL1), 666 format2(M,"N. of background clauses ~d~n~n",[LCL1]), 667 CL1=CL0 668 ; 669 format2(M,"Not range restricted~n~n",[]), 670 CL1=CL0, 671 CLBG1=CLBG0 672 ) 673 ), 674 store_clause_refinement(M,R1,R3,Score), 675 Nrev1 is Nrev+1, 676 score_clause_refinements(T,M,Nrev1,NRef,DB,NB1,NB,CL1,CL,CLBG1,CLBG). 677 678range_restricted(rule(_N,HL,BL,_Lit,_Tun)):- 679 term_variables(HL,VH), 680 term_variables(BL,VB), 681 sublisteq(VH,VB). 682 683sublisteq([],_). 684 685sublisteq([H|T],L):- 686 member_eq(H,L), 687 sublisteq(T,L). 688 689target(R,M):- 690 get_output_preds(R,O), 691 member(T,O), 692 M:output(T),!. 693 694get_output_preds(rule(_N,HL,_BL,_Lit,_Tun),O):- 695 scan_head(HL,[],O). 696 697scan_head(['':_],O,O):-!. 698scan_head([],O,O):-!. 699scan_head([H:_P|T],O0,O):- 700 functor(H,F,N), 701 (member(F/N,O0)-> 702 O1=O0 703 ; 704 O1=[F/N|O0] 705 ), 706 scan_head(T,O1,O). 707 708 709 710store_clause_refinement(M,Ref,RefP,Score):- 711 elab_clause_ref(Ref,Ref1), 712 assert(M:ref_clause(r(Ref1,RefP,Score))). 713 714store_refinement(M,Ref,RefP,Score):- 715 elab_ref(Ref,Ref1), 716 assert(M:ref(r(Ref1,RefP,Score))). 717 718already_scored_clause(M,R,R1,Score):- 719 elab_ref([R],[rule(H,B)]), 720 M:ref_clause(r(rule(H,B1),R1,Score)), 721 permutation(B,B1). 722 723already_scored(M,R,R1,Score):- 724 elab_ref(R,RR), 725 M:ref(r(RR,R1,Score)). 726 727 728elab_clause_ref(rule(_NR,H,B,_Lits,_Tun),rule(H1,B1)):- 729 copy_term((H,B),(H1,B1)). 730 731elab_ref([],[]). 732 733elab_ref([rule(_NR,H,B,_Lits,_Tun)|T],[rule(H1,B1)|T1]):-!, 734 copy_term((H,B),(H1,B1)), 735 numbervars((H1,B1),0,_N), 736 elab_ref(T,T1). 737 738elab_ref([def_rule(H,B,_Lits)|T],[rule(H1,B1)|T1]):- 739 copy_term((H,B),(H1,B1)), 740 numbervars((H1,B1),0,_N), 741 elab_ref(T,T1). 742 743% insertion in the beam 744insert_in_order([],C,BeamSize,[C]):- 745 BeamSize>0,!. 746 747insert_in_order(Beam,_New,0,Beam):-!. 748 749insert_in_order([(Th1,Heuristic1)|RestBeamIn],(Th,Heuristic),BeamSize,BeamOut):- 750 Heuristic>Heuristic1,!, 751 % larger heuristic, insert here 752 NewBeam=[(Th,Heuristic),(Th1,Heuristic1)|RestBeamIn], 753 length(NewBeam,L), 754 (L>BeamSize-> 755 nth1(L,NewBeam,_Last,BeamOut) 756 ; 757 BeamOut=NewBeam 758 ). 759 760insert_in_order([(Th1,Heuristic1)|RestBeamIn],(Th,Heuristic),BeamSize, 761[(Th1,Heuristic1)|RestBeamOut]):- 762 BeamSize1 is BeamSize -1, 763 insert_in_order(RestBeamIn,(Th,Heuristic),BeamSize1, 764 RestBeamOut). 765 766 767 768remove_int_atom_list([],[]). 769 770remove_int_atom_list([\+ A|T],[\+ A1|T1]):-!, 771 A=..[F,_|Arg], 772 A1=..[F|Arg], 773 remove_int_atom_list(T,T1). 774 775remove_int_atom_list([A|T],[A1|T1]):- 776 A=..[F,_|Arg], 777 A1=..[F|Arg], 778 remove_int_atom_list(T,T1). 779 780 781 782remove_int_atom(\+ A,\+ A1):-!, 783 A=..[F,_|T], 784 A1=..[F|T]. 785 786remove_int_atom(A,A1):- 787 A=..[F,_|T], 788 A1=..[F|T]. 789 790 791get_heads([],[]). 792 793get_heads([_-H|T],[H|TN]):- 794 795 get_heads(T,TN). 796 797derive_bdd_nodes([],_M,_ExData,_E,Nodes,Nodes,CLL,CLL). 798 799derive_bdd_nodes([H|T],M,ExData,E,Nodes0,Nodes,CLL0,CLL):- 800 get_output_atoms(O,M), 801 generate_goal(O,M,H,[],GL), 802 (M:'$prob'(H,P)-> 803 CardEx is P*E 804 805 ; 806 CardEx is 1.0 807 ), 808 init_ex(ExData,Env), 809 one(Env,One), 810 get_node_list(GL,M,Env,One,BDD,CardEx), 811 ret_prob(Env,BDD,HP), 812 (HP=:=0.0-> 813 setting_sc(logzero,LZ), 814 CLL1 is CLL0+LZ*CardEx 815 ; 816 CLL1 is CLL0+log(HP)*CardEx 817 ), 818 end_ex(ExData), 819 append(Nodes0,[[BDD,CardEx]],Nodes1), 820 derive_bdd_nodes(T,M,ExData,E,Nodes1,Nodes,CLL1,CLL). 821 822 823get_node_list([],_M,_Env,BDD,BDD,_CE). 824 825 826get_node_list([H|T],M,Env,BDD0,BDD,CE):- 827 get_node(H,M,Env,BDD1), 828 and(Env,BDD0,BDD1,BDD2), 829 get_node_list(T,M,Env,BDD2,BDD,CE). 830 831 832derive_bdd_nodes_groupatoms_output_atoms([],_M,_ExData,_O,_E,_G,Nodes,Nodes,CLL,CLL,LE,LE). 833 834derive_bdd_nodes_groupatoms_output_atoms([H|T],M,ExData,O,E,G,Nodes0,Nodes,CLL0,CLL,LE0,LE):- 835 generate_goal(O,M,H,[],GL), 836 length(GL,NA), 837 (M:'$prob'(H,P)-> 838 CardEx is P*E/NA 839 ; 840 CardEx is 1.0 841 ), 842 get_node_list_groupatoms(GL,M,ExData,BDDs,CardEx,G,CLL0,CLL1,LE0,LE1), 843 append(Nodes0,BDDs,Nodes1), 844 derive_bdd_nodes_groupatoms_output_atoms(T,M,ExData,O,E,G,Nodes1,Nodes,CLL1,CLL,LE1,LE). 845 846 847derive_bdd_nodes_groupatoms([],_M,_ExData,_E,_G,Nodes,Nodes,CLL,CLL,LE,LE). 848 849derive_bdd_nodes_groupatoms([H|T],M,ExData,E,G,Nodes0,Nodes,CLL0,CLL,LE0,LE):- 850 get_output_atoms(O,M), 851 generate_goal(O,M,H,[],GL), 852 length(GL,NA), 853 (M:'$prob'(H,P)-> 854 CardEx is P*E/NA 855 ; 856 CardEx is 1.0 857 ), 858 get_node_list_groupatoms(GL,M,ExData,BDDs,CardEx,G,CLL0,CLL1,LE0,LE1), 859 append(Nodes0,BDDs,Nodes1), 860 derive_bdd_nodes_groupatoms(T,M,ExData,E,G,Nodes1,Nodes,CLL1,CLL,LE1,LE). 861 862get_node_list_groupatoms([],_M,_ExData,[],_CE,_Gmax,CLL,CLL,LE,LE). 863 864get_node_list_groupatoms([H|T],M,ExData,[[BDD,CE1]|BDDT],CE,Gmax,CLL0,CLL,LE0,LE):- 865 init_ex(ExData,Env), 866 one(Env,One), 867 get_bdd_group([H|T],M,Env,T1,Gmax,G,One,BDD,CE,LE0,LE1), %output:BDD,CLL 868 CE1 is CE*(Gmax-G), 869 ret_prob(Env,BDD,HP), 870 end_ex(ExData), 871 (HP =:=0.0-> 872 M:local_setting(logzero,LZ), 873 CLL2 is CLL0+LZ*CE1 874 ; 875 CLL2 is CLL0+log(HP)*CE1 876 ), 877 get_node_list_groupatoms(T1,M,ExData,BDDT,CE,Gmax,CLL2,CLL,LE1,LE). 878 879 880get_bdd_group([],_M,_Env,[],G,G,BDD,BDD,_CE,LE,LE):-!. 881 882get_bdd_group(T,_M,_Env,T,0,0,BDD,BDD,_CE,LE,LE):- !. 883 884get_bdd_group([H|T],M,Env,T1,Gmax,G1,BDD0,BDD,CE,[H|LE0],LE):- 885 get_node(H,M,Env,BDD1), %creates the BDD for atom H 886 and(Env,BDD0,BDD1,BDD2), 887 G is Gmax-1, 888 get_bdd_group(T,M,Env,T1,G,G1,BDD2,BDD,CE,LE0,LE). 889 890get_arg(_-A,A). 891 892/* EM start */ 893random_restarts(0,_M,_ExData,_Nodes,Score,Score,Par,Par,_LE):-!. 894 895random_restarts(N,M,ExData,Nodes,Score0,Score,Par0,Par,LE):- 896 M:local_setting(random_restarts_number,NMax), 897 Num is NMax-N+1, 898 format3(M,"Restart number ~d~n~n",[Num]), 899 findall(R-Info,get_rule_info_rand(M,R-Info),L), 900 keysort(L,LS), 901 maplist(get_arg,LS,LS1), 902 M:local_setting(epsilon_em,EA), 903 M:local_setting(epsilon_em_fraction,ER), 904 M:local_setting(iter,Iter), 905 M:local_setting(alpha,Alpha), 906 initial_values(ExData,Alpha), 907 em(ExData,LS1,Nodes,EA,ER,Iter,CLL,Par1,ExP), 908 score(M,LE,ExP,CLL,ScoreR), 909 format3(M,"Random_restart: Score ~f~n",[ScoreR]), 910 N1 is N-1, 911 (ScoreR>Score0-> 912 random_restarts(N1,M,ExData,Nodes,ScoreR,Score,Par1,Par,LE) 913 ; 914 random_restarts(N1,M,ExData,Nodes,Score0,Score,Par0,Par,LE) 915 ). 916 917random_restarts_ref(0,_M,_ExData,_Nodes,Score,Score,Par,Par,_LE):-!. 918 919random_restarts_ref(N,M,ExData,Nodes,Score0,Score,Par0,Par,LE):- 920 M:local_setting(random_restarts_REFnumber,NMax), 921 Num is NMax-N+1, 922 format3(M,"Restart number ~d~n~n",[Num]), 923 findall(R-Info,get_rule_info_rand(M,R-Info),L), 924 keysort(L,LS), 925 maplist(get_arg,LS,LS1), 926 M:local_setting(epsilon_em,EA), 927 M:local_setting(epsilon_em_fraction,ER), 928 M:local_setting(iterREF,Iter), 929 M:local_setting(alpha,Alpha), 930 initial_values(ExData,Alpha), 931 em(ExData,LS1,Nodes,EA,ER,Iter,CLLR,Par1,ExP), 932 score(M,LE,ExP,CLLR,ScoreR), 933 format3(M,"Random_restart: Score ~f~n",[ScoreR]), 934 N1 is N-1, 935 (ScoreR>Score0-> 936 random_restarts_ref(N1,M,ExData,Nodes,ScoreR,Score,Par1,Par,LE) 937 ; 938 random_restarts_ref(N1,M,ExData,Nodes,Score0,Score,Par0,Par,LE) 939 ). 940 941 942score(M,_LE,_ExP,CLL,CLL):- 943 M:local_setting(score,ll),!. 944 945score(_M,LE,ExP,_CLL,Score):- 946 compute_prob(LE,ExP,LPU,0,Pos,0,Neg), 947 keysort(LPU,LPO), 948 reverse(LPO,LP), 949 compute_aucpr(LP,Pos,Neg,Score). 950 951 952compute_prob([],[],[],Pos,Pos,Neg,Neg). 953 954compute_prob([\+ HE|TE],[HP|TP],[P- (\+ HE)|T],Pos0,Pos,Neg0,Neg):-!, 955 P is 1.0-HP, 956 Neg1 is Neg0+1, 957 compute_prob(TE,TP,T,Pos0,Pos,Neg1,Neg). 958 959compute_prob([ HE|TE],[HP|TP],[HP- HE|T],Pos0,Pos,Neg0,Neg):- 960 Pos1 is Pos0+1, 961 compute_prob(TE,TP,T,Pos1,Pos,Neg0,Neg). 962 963 964compute_aucpr(L,Pos,Neg,A):- 965 L=[P_0-E|TL], 966 (E= (\+ _ )-> 967 FP=1, 968 TP=0, 969 FN=Pos, 970 TN is Neg -1 971 ; 972 FP=0, 973 TP=1, 974 FN is Pos -1, 975 TN=Neg 976 ), 977 compute_curve_points(TL,P_0,TP,FP,FN,TN,Points), 978 Points=[R0-P0|_TPoints], 979 (R0=:=0,P0=:=0-> 980 Flag=true 981 ; 982 Flag=false 983 ), 984 area(Points,Flag,Pos,0,0,0,A). 985 986compute_curve_points([],_P0,TP,FP,_FN,_TN,[1.0-Prec]):-!, 987 Prec is TP/(TP+FP). 988 989compute_curve_points([P- (\+ _)|T],P0,TP,FP,FN,TN,Pr):-!, 990 (P<P0-> 991 Prec is TP/(TP+FP), 992 Rec is TP/(TP+FN), 993 Pr=[Rec-Prec|Pr1], 994 P1=P 995 ; 996 Pr=Pr1, 997 P1=P0 998 ), 999 FP1 is FP+1, 1000 TN1 is TN-1, 1001 compute_curve_points(T,P1,TP,FP1,FN,TN1,Pr1). 1002 1003compute_curve_points([P- _|T],P0,TP,FP,FN,TN,Pr):-!, 1004 (P<P0-> 1005 Prec is TP/(TP+FP), 1006 Rec is TP/(TP+FN), 1007 Pr=[Rec-Prec|Pr1], 1008 P1=P 1009 ; 1010 Pr=Pr1, 1011 P1=P0 1012 ), 1013 TP1 is TP+1, 1014 FN1 is FN-1, 1015 compute_curve_points(T,P1,TP1,FP,FN1,TN,Pr1). 1016 1017area([],_Flag,_Pos,_TPA,_FPA,A,A). 1018 1019area([R0-P0|T],Flag,Pos,TPA,FPA,A0,A):- 1020 TPB is R0*Pos, 1021 (TPB=:=0-> 1022 A1=A0, 1023 FPB=0 1024 ; 1025 R_1 is TPA/Pos, 1026 (TPA=:=0-> 1027 (Flag=false-> 1028 P_1=P0 1029 ; 1030 P_1=0.0 1031 ) 1032 ; 1033 P_1 is TPA/(TPA+FPA) 1034 ), 1035 FPB is TPB*(1.0-P0)/P0, 1036 N is TPB-TPA+0.5, 1037 interpolate(1,N,Pos,R_1,P_1,TPA,FPA,TPB,FPB,A0,A1) 1038 ), 1039 area(T,Flag,Pos,TPB,FPB,A1,A). 1040 1041interpolate(I,N,_Pos,_R0,_P0,_TPA,_FPA,_TPB,_FPB,A,A):-I>N,!. 1042 1043interpolate(I,N,Pos,R0,P0,TPA,FPA,TPB,FPB,A0,A):- 1044 R is (TPA+I)/Pos, 1045 P is (TPA+I)/(TPA+I+FPA+(FPB-FPA)/(TPB-TPA)*I), 1046 A1 is A0+(R-R0)*(P+P0)/2, 1047 I1 is I+1, 1048 interpolate(I1,N,Pos,R,P,TPA,FPA,TPB,FPB,A1,A). 1049 1050 1051 1052update_head([],[],_N,[]):-!. 1053 1054update_head([H:_P|T],[PU|TP],N,[H:P|T1]):- 1055 P is PU/N, 1056 update_head(T,TP,N,T1). 1057 1058 1059/* EM end */ 1060 1061 1062/* utilities */
1070rules2terms(R,T):- 1071 maplist(rule2term,R,T). 1072 1073rule2term(rule(_N,HL,BL,_Lit,_Tun),(H:-B)):- 1074 list2or(HL,H), 1075 list2and(BL,B). 1076 1077rule2term(def_rule(H,BL,_Lit),((H:1.0):-B)):- 1078 list2and(BL,B). 1079 1080 1081write_rules([],_S). 1082 1083write_rules([rule(_N,HL,BL,Lit,_Tun)|T],S):-!, 1084 copy_term((HL,BL,Lit),(HL1,BL1,Lit1)), 1085 numbervars((HL1,BL1,Lit1),0,_M), 1086 write_disj_clause(S,(HL1:-BL1)), 1087 write_rules(T,S). 1088 1089write_rules([def_rule(H,BL,Lit)|T],S):- 1090 copy_term((H,BL,Lit),(H1,BL1,Lit1)), 1091 numbervars((H1,BL1,Lit1),0,_M), 1092 write_disj_clause(S,([H1:1.0]:-BL1)), 1093 write_rules(T,S). 1094 1095 1096new_par([],[],[]). 1097 1098new_par([HP|TP],[Head:_|TO],[Head:HP|TN]):- 1099 new_par(TP,TO,TN). 1100 1101 1102 1103write_disj_clause(S,(H:-[])):-!, 1104 write_head(S,H), 1105 format(S,".~n~n",[]). 1106 1107write_disj_clause(S,(H:-B)):- 1108 write_head(S,H), 1109 format(S,' :-',[]), 1110 nl(S), 1111 write_body(S,B). 1112 1113 1114write_head(S,[A:1.0|_Rest]):-!, 1115 format(S,"~q:1.0",[A]). 1116 1117write_head(S,[A:P,'':_P]):-!, 1118 format(S,"~q:~g",[A,P]). 1119 1120write_head(S,[A:P]):-!, 1121 format(S,"~q:~g",[A,P]). 1122 1123write_head(S,[A:P|Rest]):- 1124 format(S,"~q:~g ; ",[A,P]), 1125 write_head(S,Rest). 1126 1127write_body(S,[]):-!, 1128 format(S," true.~n~n",[]). 1129 1130write_body(S,[A]):-!, 1131 format(S," ~q.~n~n",[A]). 1132 1133write_body(S,[A|T]):- 1134 format(S," ~q,~n",[A]), 1135 write_body(S,T).
1144list2or([],true):-!. 1145 1146list2or([X],X):- 1147 X\=;(_,_),!. 1148 1149list2or([H|T],(H ; Ta)):-!, 1150 list2or(T,Ta).
1160list2and([],true):-!. 1161 1162list2and([X],X):- 1163 X\=(_,_),!. 1164 1165list2and([H|T],(H,Ta)):-!, 1166 list2and(T,Ta). 1167 1168 1169deduct(0,_Mod,_DB,Th,Th):-!. 1170 1171deduct(NM,Mod,DB,InTheory0,InTheory):- 1172 get_head_atoms(O,Mod), 1173 sample(1,DB,Sampled,DB1), 1174 (Sampled=[M]-> 1175 generate_head(O,M,Mod,[],HL), 1176 NM1 is NM-1, 1177 ( HL \== [] -> 1178 (generate_body(HL,Mod,InTheory1), 1179 append(InTheory0,InTheory1,InTheory2), 1180 deduct(NM1,Mod,DB1,InTheory2,InTheory) 1181 ) 1182 ; 1183 deduct(NM1,Mod,DB1,InTheory0,InTheory) 1184 ) 1185 ; 1186 InTheory=InTheory0 1187 ). 1188 1189 1190get_head_atoms(O,M):- 1191 findall(A,M:modeh(_,A),O0), 1192 findall((A,B,D),M:modeh(_,A,B,D),O1), 1193 append(O0,O1,O). 1194 1195generate_top_cl([],_M,[]):-!. 1196 1197generate_top_cl([A|T],M,[(rule(R,[A1:0.5,'':0.5],[],true,tunable),-1e20)|TR]):- 1198 A=..[F|ArgM], 1199 keep_const(ArgM,Arg), 1200 A1=..[F|Arg], 1201 get_next_rule_number(M,R), 1202 generate_top_cl(T,M,TR). 1203 1204 1205generate_head([],_M,_Mod,HL,HL):-!. 1206 1207generate_head([(A,G,D)|T],M,Mod,H0,H1):-!, 1208 generate_head_goal(G,M,Goals), 1209 findall((A,Goals,D),(member(Goal,Goals),call(Mod:Goal),ground(Goals)),L), 1210 Mod:local_setting(initial_clauses_per_megaex,IC), %IC: represents how many samples are extracted from the list L of example 1211 sample(IC,L,L1), 1212 append(H0,L1,H2), 1213 generate_head(T,M,Mod,H2,H1). 1214 1215generate_head([A|T],M,Mod,H0,H1):- 1216 functor(A,F,N), 1217 functor(F1,F,N), 1218 F1=..[F|Arg], 1219 Pred1=..[F,M|Arg], 1220 A=..[F|ArgM], 1221 keep_const(ArgM,Arg), 1222 findall((A,Pred1),call(Mod:Pred1),L), 1223 Mod:local_setting(initial_clauses_per_megaex,IC), 1224 sample(IC,L,L1), 1225 append(H0,L1,H2), 1226 generate_head(T,M,Mod,H2,H1). 1227 1228generate_head_goal([],_M,[]). 1229 1230generate_head_goal([H|T],M,[H1|T1]):- 1231 H=..[F|Arg], 1232 H1=..[F,M|Arg], 1233 generate_head_goal(T,M,T1). 1234 1235keep_const([],[]). 1236 1237keep_const([- _|T],[_|T1]):-!, 1238 keep_const(T,T1). 1239 1240keep_const([+ _|T],[_|T1]):-!, 1241 keep_const(T,T1). 1242 1243keep_const([-# _|T],[_|T1]):-!, 1244 keep_const(T,T1). 1245 1246keep_const([H|T],[H1|T1]):- 1247 H=..[F|Args], 1248 keep_const(Args,Args1), 1249 H1=..[F|Args1], 1250 keep_const(T,T1).
1261sample(0,List,[],List):-!. 1262 1263sample(N,List,List,[]):- 1264 length(List,L), 1265 L=<N,!. 1266 1267sample(N,List,[El|List1],Li):- 1268 length(List,L), 1269 random(0,L,Pos), 1270 nth0(Pos,List,El,Rest), 1271 N1 is N-1, 1272 sample(N1,Rest,List1,Li). 1273 1274sample(0,_List,[]):-!. 1275 1276sample(N,List,List):- 1277 length(List,L), 1278 L=<N,!. 1279 1280sample(N,List,[El|List1]):- 1281 length(List,L), 1282 random(0,L,Pos), 1283 nth0(Pos,List,El,Rest), 1284 N1 is N-1, 1285 sample(N1,Rest,List1). 1286 1287get_args([],[],[],A,A,AT,AT,_). 1288 1289get_args([HM|TM],[H|TH],[(H,HM)|TP],A0,A,AT0,AT,M):- 1290 HM=..[F|ArgsTypes], 1291 H=..[F,M|Args], 1292 append(A0,Args,A1), 1293 append(AT0,ArgsTypes,AT1), 1294 get_args(TM,TH,TP,A1,A,AT1,AT,M). 1295 1296/* Generation of the bottom clauses */ 1297 1298gen_head([],P,['':P]). 1299 1300gen_head([H|T],P,[H:P|TH]):- 1301 gen_head(T,P,TH). 1302 1303get_modeb([],_Mod,B,B). 1304 1305get_modeb([F/AA|T],Mod,B0,B):- 1306 findall((R,B),(Mod:modeb(R,B),functor(B,F,AA)),BL), 1307 (Mod:local_setting(neg_literals,true)-> 1308 findall((R,(\+ B)),(Mod:modeb(R,B),functor(B,F,AA),all_plus(B)),BNL) 1309 ; 1310 BNL=[] 1311 ), 1312 append([B0,BL,BNL],B1), 1313 get_modeb(T,Mod,B1,B). 1314 1315all_plus(B):- 1316 B=..[_|Args], 1317 all_plus_args(Args). 1318 1319all_plus_args([]). 1320 1321all_plus_args([+ _ |T]):-!, 1322 all_plus_args(T). 1323 1324all_plus_args([H|T]):- 1325 H \= - _, 1326 H \= # _, 1327 H \= -# _, 1328 H=..[_|Args], 1329 all_plus_args(Args), 1330 all_plus_args(T).
/
1337generate_body([],_Mod,[]):-!. 1338 1339generate_body([(A,H,Det)|T],Mod,[(rule(R,HP,[],BodyList,tunable),-1e20)|CL0]):-!, 1340 get_modeb(Det,Mod,[],BL), 1341 get_args(A,H,Pairs,[],Args,[],ArgsTypes,M), 1342 Mod:local_setting(d,D), 1343 cycle_modeb(ArgsTypes,Args,[],[],Mod,BL,a,[],BLout0,D,M), 1344 variabilize((Pairs:-BLout0),CLV), %+(Head):-Bodylist; -CLV:(Head):-Bodylist with variables _num in place of constants 1345 CLV=(Head1:-BodyList1), 1346 remove_int_atom_list(Head1,Head), 1347 remove_int_atom_list(BodyList1,BodyList2), 1348 remove_duplicates(BodyList2,BodyList), 1349 get_next_rule_number(Mod,R), 1350 length(Head,LH), 1351 Prob is 1.0/(LH+1), 1352 gen_head(Head,Prob,HP), 1353 copy_term((HP,BodyList),(HeadV,BodyListV)), 1354 numbervars((HeadV,BodyListV),0,_V), 1355 format2(Mod,"Bottom clause: example ~q~nClause~n",[H]), 1356 write_disj_clause2(Mod,user_output,(HeadV:-BodyListV)), 1357 generate_body(T,Mod,CL0). 1358 1359generate_body([(A,H)|T],Mod,[(rule(R,[Head:0.5,'':0.5],[],BodyList,tunable),-1e20)|CL0]):- 1360 functor(A,F,AA), 1361 findall(FB/AB,Mod:determination(F/AA,FB/AB),Det), 1362 get_modeb(Det,Mod,[],BL), 1363 A=..[F|ArgsTypes], 1364 H=..[F,M|Args], 1365 Mod:local_setting(d,D), 1366 cycle_modeb(ArgsTypes,Args,[],[],Mod,BL,a,[],BLout0,D,M), 1367 variabilize(([(H,A)]:-BLout0),CLV), %+(Head):-Bodylist; -CLV:(Head):-Bodylist with variables _num in place of constants 1368 CLV=([Head1]:-BodyList1), 1369 remove_int_atom(Head1,Head), 1370 remove_int_atom_list(BodyList1,BodyList2), 1371 remove_duplicates(BodyList2,BodyList), 1372 get_next_rule_number(Mod,R), 1373 copy_term((Head,BodyList),(HeadV,BodyListV)), 1374 numbervars((HeadV,BodyListV),0,_V), 1375 format2(Mod,"Bottom clause: example ~q~nClause~n~q:0.5 :-~n",[H,HeadV]), 1376 write_body2(Mod,user_output,BodyListV), 1377 generate_body(T,Mod,CL0). 1378 1379 1380variabilize((H:-B),(H1:-B1)):- 1381 variabilize_list(H,H1,[],AS,M), 1382 variabilize_list(B,B1,AS,_AS,M). 1383 1384 1385variabilize_list([],[],A,A,_M). 1386 1387variabilize_list([(\+ H,Mode)|T],[\+ H1|T1],A0,A,M):- 1388 builtin(H),!, 1389 H=..[F|Args], 1390 Mode=..[F|ArgTypes], 1391 variabilize_args(Args,ArgTypes, Args1,A0,A1), 1392 H1=..[F,M|Args1], 1393 variabilize_list(T,T1,A1,A,M). 1394 1395variabilize_list([(\+ H,Mode)|T],[\+ H1|T1],A0,A,M):-!, 1396 H=..[F,_M|Args], 1397 Mode=..[F|ArgTypes], 1398 variabilize_args(Args,ArgTypes, Args1,A0,A1), 1399 H1=..[F,M|Args1], 1400 variabilize_list(T,T1,A1,A,M). 1401 1402variabilize_list([(H,Mode)|T],[H1|T1],A0,A,M):- 1403 builtin(H),!, 1404 H=..[F|Args], 1405 Mode=..[F|ArgTypes], 1406 variabilize_args(Args,ArgTypes, Args1,A0,A1), 1407 H1=..[F,M|Args1], 1408 variabilize_list(T,T1,A1,A,M). 1409 1410variabilize_list([(H,Mode)|T],[H1|T1],A0,A,M):- 1411 H=..[F,_M|Args], 1412 Mode=..[F|ArgTypes], 1413 variabilize_args(Args,ArgTypes, Args1,A0,A1), 1414 H1=..[F,M|Args1], 1415 variabilize_list(T,T1,A1,A,M). 1416 1417 1418variabilize_args([],[],[],A,A). 1419 1420variabilize_args([C|T],[C|TT],[C|TV],A0,A):-!, 1421 variabilize_args(T,TT,TV,A0,A). 1422 1423variabilize_args([C|T],[# _Ty|TT],[C|TV],A0,A):-!, 1424 variabilize_args(T,TT,TV,A0,A). 1425 1426variabilize_args([C|T],[-# _Ty|TT],[C|TV],A0,A):-!, 1427 variabilize_args(T,TT,TV,A0,A). 1428 1429variabilize_args([C|T],[Ty|TT],[V|TV],A0,A):- 1430 (Ty = +Ty1;Ty = -Ty1), 1431 member(C/Ty1/V,A0),!, 1432 variabilize_args(T,TT,TV,A0,A). 1433 1434variabilize_args([C|T],[Ty|TT],[V|TV],A0,A):- 1435 (Ty = +Ty1;Ty = -Ty1),!, 1436 variabilize_args(T,TT,TV,[C/Ty1/V|A0],A). 1437 1438variabilize_args([C|T],[Ty|TT],[V|TV],A0,A):- 1439 compound(C), 1440 C=..[F|Args], 1441 Ty=..[F|ArgsT], 1442 variabilize_args(Args,ArgsT,ArgsV,A0,A1), 1443 V=..[F|ArgsV], 1444 variabilize_args(T,TT,TV,A1,A). 1445 1446 1447cycle_modeb(ArgsTypes,Args,ArgsTypes,Args,_Mod,_BL,L,L,L,_,_M):-!. 1448 1449cycle_modeb(_ArgsTypes,_Args,_ArgsTypes1,_Args1,_Mod,_BL,_L,L,L,0,_M):-!. 1450 1451cycle_modeb(ArgsTypes,Args,_ArgsTypes0,_Args0,Mod,BL,_L0,L1,L,D,M):- 1452 find_atoms(BL,Mod,ArgsTypes,Args,ArgsTypes1,Args1,L1,L2,M), 1453 D1 is D-1, 1454 cycle_modeb(ArgsTypes1,Args1,ArgsTypes,Args,Mod,BL,L1,L2,L,D1,M). 1455 1456 1457find_atoms([],_Mod,ArgsTypes,Args,ArgsTypes,Args,L,L,_M). 1458 1459find_atoms([(R,\+ H)|T],Mod,ArgsTypes0,Args0,ArgsTypes,Args,L0,L1,M):-!, 1460 H=..[F|ArgsT], 1461 findall((A,H),instantiate_query_neg(ArgsT,ArgsTypes0,Args0,F,M,A),L), 1462 call_atoms(L,Mod,[],At), 1463 remove_duplicates(At,At1), 1464 ((R = '*' ) -> 1465 R1= +1e20 1466 ; 1467 R1=R 1468 ), 1469 sample(R1,At1,At2), 1470 append(L0,At2,L2), 1471 find_atoms(T,Mod,ArgsTypes0,Args0,ArgsTypes,Args,L2,L1,M). 1472 1473find_atoms([(R,H)|T],Mod,ArgsTypes0,Args0,ArgsTypes,Args,L0,L1,M):- 1474 H=..[F|ArgsT], 1475 findall((A,H),instantiate_query(ArgsT,ArgsTypes0,Args0,F,M,A),L), 1476 call_atoms(L,Mod,[],At), 1477 remove_duplicates(At,At1), 1478 ((R = '*' ) -> 1479 R1= +1e20 1480 ; 1481 R1=R 1482 ), 1483 sample(R1,At1,At2), 1484 extract_output_args(At2,ArgsT,ArgsTypes0,Args0,ArgsTypes1,Args1), 1485 append(L0,At2,L2), 1486 find_atoms(T,Mod,ArgsTypes1,Args1,ArgsTypes,Args,L2,L1,M). 1487 1488 1489call_atoms([],_Mod,A,A). 1490 1491call_atoms([(H,M)|T],Mod,A0,A):- 1492 findall((H,M),Mod:H,L), 1493 append(A0,L,A1), 1494 call_atoms(T,Mod,A1,A). 1495 1496 1497extract_output_args([],_ArgsT,ArgsTypes,Args,ArgsTypes,Args). 1498 1499extract_output_args([(H,_At)|T],ArgsT,ArgsTypes0,Args0,ArgsTypes,Args):- 1500 builtin(H),!, 1501 H=..[_F|ArgsH], 1502 add_const(ArgsH,ArgsT,ArgsTypes0,Args0,ArgsTypes1,Args1), 1503 extract_output_args(T,ArgsT,ArgsTypes1,Args1,ArgsTypes,Args). 1504 1505extract_output_args([(H,_At)|T],ArgsT,ArgsTypes0,Args0,ArgsTypes,Args):- 1506 H=..[_F,_M|ArgsH], 1507 add_const(ArgsH,ArgsT,ArgsTypes0,Args0,ArgsTypes1,Args1), 1508 extract_output_args(T,ArgsT,ArgsTypes1,Args1,ArgsTypes,Args). 1509 1510 1511add_const([],[],ArgsTypes,Args,ArgsTypes,Args). 1512 1513add_const([_A|T],[+_T|TT],ArgsTypes0,Args0,ArgsTypes,Args):-!, 1514 add_const(T,TT,ArgsTypes0,Args0,ArgsTypes,Args). 1515 1516add_const([A|T],[-Type|TT],ArgsTypes0,Args0,ArgsTypes,Args):-!, 1517 (already_present(ArgsTypes0,Args0,A,Type)-> 1518 ArgsTypes1=ArgsTypes0, 1519 Args1=Args0 1520 ; 1521 ArgsTypes1=[+Type|ArgsTypes0], 1522 Args1=[A|Args0] 1523 ), 1524 add_const(T,TT,ArgsTypes1,Args1,ArgsTypes,Args). 1525 1526add_const([A|T],[-# Type|TT],ArgsTypes0,Args0,ArgsTypes,Args):-!, 1527 (already_present(ArgsTypes0,Args0,A,Type)-> 1528 ArgsTypes1=ArgsTypes0, 1529 Args1=Args0 1530 ; 1531 ArgsTypes1=[+Type|ArgsTypes0], 1532 Args1=[A|Args0] 1533 ), 1534 add_const(T,TT,ArgsTypes1,Args1,ArgsTypes,Args). 1535 1536add_const([_A|T],[# _|TT],ArgsTypes0,Args0,ArgsTypes,Args):-!, 1537 add_const(T,TT,ArgsTypes0,Args0,ArgsTypes,Args). 1538 1539add_const([A|T],[A|TT],ArgsTypes0,Args0,ArgsTypes,Args):- 1540 atomic(A),!, 1541 add_const(T,TT,ArgsTypes0,Args0,ArgsTypes,Args). 1542 1543add_const([A|T],[AT|TT],ArgsTypes0,Args0,ArgsTypes,Args):- 1544 A=..[F|Ar], 1545 AT=..[F|ArT], 1546 add_const(Ar,ArT,ArgsTypes0,Args0,ArgsTypes1,Args1), 1547 add_const(T,TT,ArgsTypes1,Args1,ArgsTypes,Args). 1548 1549 1550already_present([+T|_TT],[C|_TC],C,T):-!. 1551 1552already_present([_|TT],[_|TC],C,T):- 1553 already_present(TT,TC,C,T). 1554 1555 1556instantiate_query_neg(ArgsT,ArgsTypes,Args,F,M,A):- 1557 instantiate_input(ArgsT,ArgsTypes,Args,ArgsB), 1558 A1=..[F|ArgsB], 1559 (builtin(A1)-> 1560 A= (\+ A1) 1561 ; 1562 A0=..[F,M|ArgsB], 1563 A = (\+ A0) 1564 ). 1565 1566instantiate_query(ArgsT,ArgsTypes,Args,F,M,A):- 1567 instantiate_input(ArgsT,ArgsTypes,Args,ArgsB), 1568 A1=..[F|ArgsB], 1569 (builtin(A1)-> 1570 A=A1 1571 ; 1572 A=..[F,M|ArgsB] 1573 ). 1574 1575 1576instantiate_input([],_AT,_A,[]). 1577 1578instantiate_input([-_Type|T],AT,A,[_V|TA]):-!, 1579 instantiate_input(T,AT,A,TA). 1580 1581instantiate_input([+Type|T],AT,A,[H|TA]):-!, 1582 find_val(AT,A,+Type,H), 1583 instantiate_input(T,AT,A,TA). 1584 1585instantiate_input([# Type|T],AT,A,[H|TA]):-!, 1586 find_val(AT,A,+Type,H), 1587 instantiate_input(T,AT,A,TA). 1588 1589instantiate_input([-# _Type|T],AT,A,[_V|TA]):-!, 1590 instantiate_input(T,AT,A,TA). 1591 1592instantiate_input([C|T],AT,A,[C1|TA]):- 1593 C=..[F|Args], 1594 instantiate_input(Args,AT,A,Args1), 1595 C1=..[F|Args1], 1596 instantiate_input(T,AT,A,TA). 1597 1598 1599find_val([T|_TT],[A|_TA],T,A). 1600 1601find_val([HT|_TT],[HA|_TA],T,A):- 1602 nonvar(HA), 1603 HT=..[F|ArgsT], 1604 HA=..[F|Args], 1605 find_val(ArgsT,Args,T,A). 1606 1607find_val([_T|TT],[_A|TA],T,A):- 1608 find_val(TT,TA,T,A). 1609 1610 1611get_output_atoms(O,M):- 1612 findall((A/Ar),M:output((A/Ar)),O). 1613 1614generate_goal(LP,M,H,[],LG):- 1615 M:local_setting(neg_ex,given),!, 1616 find_ex_pred(LP,M,[H],[],LG,0,_Pos,0,_Neg). 1617 1618generate_goal(LP,M,H,[],LG):- 1619 M:local_setting(neg_ex,cw), 1620 (M:modeh(_,_)-> 1621 true 1622 ; 1623 throw(missing_mode_declarations) 1624 ), 1625 find_ex_pred_cw(LP,M,[H],[],LG,0,_Pos,0,_Neg).
1633remove_duplicates(L0,L):- 1634 remove_duplicates(L0,[],L1), 1635 reverse(L1,L). 1636 1637remove_duplicates([],L,L). 1638 1639remove_duplicates([H|T],L0,L):- 1640 member_eq(H,L0),!, 1641 remove_duplicates(T,L0,L). 1642 1643remove_duplicates([H|T],L0,L):- 1644 remove_duplicates(T,[H|L0],L). 1645 1646 1647/* 1648 1649EMBLEM and SLIPCASE 1650 1651Copyright (c) 2011, Fabrizio Riguzzi, Nicola di Mauro and Elena Bellodi 1652 1653*/ 1654 1655 1656specialize_rule(Rule,M,_SpecRule,_Lit):- 1657 M:local_setting(max_body_length,ML), 1658 Rule = rule(_ID,_LH,BL,_Lits,_Tun), 1659 length(BL,L), 1660 L=ML,!, 1661 fail. 1662 1663%used by cycle_clauses in slipcover.pl 1664specialize_rule(Rule,M,SpecRule,Lit):- 1665 M:local_setting(specialization,bottom), 1666 Rule = rule(ID,LH,BL,Lits,Tun), 1667 delete_one(Lits,RLits,Lit), 1668 \+ M:lookahead_cons(Lit,_), 1669 \+ M:lookahead_cons_var(Lit,_), 1670 \+ member_eq(Lit,BL), 1671 append(BL,[Lit],BL1), 1672 remove_prob(LH,LH1), 1673 delete(LH1,'',LH2), 1674 append(LH2,BL1,ALL2), 1675 dv(LH2,BL1,M,DList), %-DList: list of couples (variable,depth) 1676 extract_fancy_vars(ALL2,Vars1), 1677 length(Vars1,NV), 1678 M:local_setting(max_var,MV), 1679 NV=<MV, 1680 linked_clause(BL1,M,LH2), 1681 M:local_setting(maxdepth_var,MD), 1682 exceed_depth(DList,MD), 1683 \+ banned_clause(M,LH2,BL1), 1684 SpecRule=rule(ID,LH,BL1,RLits,Tun). 1685 1686specialize_rule(Rule,M,SpecRule,Lit):- 1687 M:local_setting(specialization,bottom), 1688 Rule = rule(ID,LH,BL,Lits,Tun), 1689 delete_one(Lits,RLits,Lit), 1690 \+ member_eq(Lit,BL), 1691 append(BL,[Lit],BL0), 1692 \+M:lookahead_cons_var(Lit,_), 1693 (M:lookahead(Lit,LLit1);M:lookahead_cons(Lit,LLit1)), 1694 copy_term(LLit1,LLit2), 1695 specialize_rule_la_bot(LLit2,RLits,RLits1,BL0,BL1), 1696 remove_prob(LH,LH1), 1697 delete(LH1,'',LH2), 1698 append(LH2,BL1,ALL2), 1699 dv(LH2,BL1,M,DList), 1700 extract_fancy_vars(ALL2,Vars1), 1701 length(Vars1,NV), 1702 M:local_setting(max_var,MV), 1703 NV=<MV, 1704 linked_clause(BL1,M,LH2), 1705 M:local_setting(maxdepth_var,MD), 1706 exceed_depth(DList,MD), 1707 \+ banned_clause(M,LH2,BL1), 1708 SpecRule=rule(ID,LH,BL1,RLits1,Tun). 1709 1710specialize_rule(Rule,M,SpecRule,Lit):- 1711 M:local_setting(specialization,bottom), 1712 Rule = rule(ID,LH,BL,Lits,Tun), 1713 delete_one(Lits,RLits,Lit), 1714 \+ member_eq(Lit,BL), 1715 append(BL,[Lit],BL0), 1716 M:lookahead_cons_var(Lit,LLit2), 1717 specialize_rule_la_bot(LLit2,RLits,_RLits1,BL0,BL1), 1718 remove_prob(LH,LH1), 1719 delete(LH1,'',LH2), 1720 append(LH2,BL1,ALL2), 1721 dv(LH2,BL1,M,DList), 1722 extract_fancy_vars(ALL2,Vars1), 1723 length(Vars1,NV), 1724 M:local_setting(max_var,MV), 1725 NV=<MV, 1726 linked_clause(BL1,M,LH2), 1727 M:local_setting(maxdepth_var,MD), 1728 exceed_depth(DList,MD), 1729 \+ banned_clause(M,LH2,BL1), 1730 SpecRule=rule(ID,LH,BL1,[],Tun). 1731 1732specialize_rule(Rule,M,SpecRule,Lit):- 1733 M:local_setting(specialization,mode),%!, 1734 findall(BL , M:modeb(_,BL), BLS), 1735 specialize_rule(BLS,Rule,M,SpecRule,Lit). 1736 1737%specializes the clause head 1738specialize_rule(rule(ID,LH,BL,Lits,Tun),M,rule(ID,LH2,BL,Lits,Tun),Lit):- 1739 M:local_setting(specialize_head,true), 1740 length(LH,L), 1741 L>2, 1742 delete_one(LH,LH1,Lit), %deletes Lit 1743 Lit\='', 1744 update_head1(LH1,L-1,LH2). %updates parameters 1745 1746update_head1([],_N,[]):-!. 1747 1748update_head1([H:_P|T],N,[H:P|T1]):- 1749 P is 1/N, 1750 update_head1(T,N,T1).
1758banned_clause(M,H,B):- 1759 numbervars((H,B),0,_N), 1760 M:banned(H2,B2), 1761 mysublist(H2,H), 1762 mysublist(B2,B). 1763 1764 1765mysublist([],_). 1766 1767mysublist([H|T],L):- 1768 member(H,L), 1769 mysublist(T,L). 1770 1771 1772specialize_rule([Lit|_RLit],Rule,M,SpecRul,SLit):- 1773 Rule = rule(ID,LH,BL,true,Tun), 1774 remove_prob(LH,LH1), 1775 append(LH1,BL,ALL), 1776 specialize_rule1(Lit,M,ALL,SLit), 1777 append(BL,[SLit],BL1), 1778 (M:lookahead(SLit,LLit1);M:lookahead_cons(SLit,LLit1)), 1779 specialize_rule_la(LLit1,M,LH1,BL1,BL2), 1780 append(LH1,BL2,ALL2), 1781 extract_fancy_vars(ALL2,Vars1), 1782 length(Vars1,NV), 1783 M:local_setting(max_var,MV), 1784 NV=<MV, 1785 SpecRul = rule(ID,LH,BL2,true,Tun). 1786 1787specialize_rule([Lit|_RLit],Rule,M,SpecRul,SLit):- 1788 Rule = rule(ID,LH,BL,true,Tun), 1789 remove_prob(LH,LH1), 1790 append(LH1,BL,ALL), 1791 specialize_rule1(Lit,M,ALL,SLit), 1792 \+ M:lookahead_cons(SLit,_), 1793 append(BL,[SLit],BL1), 1794 append(LH1,BL1,ALL1), 1795 extract_fancy_vars(ALL1,Vars1), 1796 length(Vars1,NV), 1797 M:local_setting(max_var,MV), 1798 NV=<MV, 1799 SpecRul = rule(ID,LH,BL1,true,Tun). 1800 1801specialize_rule([_|RLit],Rule,M,SpecRul,Lit):- 1802 specialize_rule(RLit,Rule,M,SpecRul,Lit). 1803 1804 1805specialize_rule_la([],_M,_LH1,BL1,BL1). 1806 1807specialize_rule_la([Lit1|T],M,LH1,BL1,BL3):- 1808 copy_term(Lit1,Lit2), 1809 M:modeb(_,Lit2), 1810 append(LH1,BL1,ALL1), 1811 specialize_rule1(Lit2,M,ALL1,SLit1), 1812 append(BL1,[SLit1],BL2), 1813 specialize_rule_la(T,M,LH1,BL2,BL3). 1814 1815 1816specialize_rule_la_bot([],Bot,Bot,BL,BL). 1817 1818specialize_rule_la_bot([Lit|T],Bot0,Bot,BL1,BL3):- 1819 delete_one(Bot0,Bot1,Lit), 1820 \+ member_eq(Lit,BL1), 1821 append(BL1,[Lit],BL2), 1822 specialize_rule_la_bot(T,Bot1,Bot,BL2,BL3). 1823 1824 1825remove_prob(['':_P],[]):-!. 1826 1827remove_prob([X:_|R],[X|R1]):- 1828 remove_prob(R,R1). 1829 1830 1831specialize_rule1(Lit,M,Lits,SpecLit):- 1832 Lit =.. [Pred|Args], 1833 extract_type_vars(Lits,M,TypeVars0), 1834 remove_duplicates(TypeVars0,TypeVars), 1835 take_var_args(Args,TypeVars,Args1), 1836 SpecLit =.. [Pred|Args1], 1837 \+ member_eq(SpecLit,Lits). 1838 1839 1840convert_to_input_vars([],[]):-!. 1841 1842convert_to_input_vars([+T|RT],[+T|RT1]):- 1843 !, 1844 convert_to_input_vars(RT,RT1). 1845 1846convert_to_input_vars([-T|RT],[+T|RT1]):- 1847 convert_to_input_vars(RT,RT1). 1848 1849 1850 1851remove_eq(X,[Y|R],R):- 1852 X == Y, 1853 !. 1854 1855remove_eq(X,[_|R],R1):- 1856 remove_eq(X,R,R1).
1867linked_clause([],_M,_). 1868 1869linked_clause([L|R],M,PrevLits):- 1870 term_variables(PrevLits,PrevVars), 1871 input_variables(L,M,InputVars), 1872 linked(InputVars,PrevVars),!, 1873 linked_clause(R,M,[L|PrevLits]). 1874 1875 1876linked([],_). 1877 1878linked([X|R],L) :- 1879 member_eq(X,L), 1880 !, 1881 linked(R,L). 1882 1883 1884input_variables(\+ LitM,M,InputVars):- 1885 !, 1886 LitM=..[P|Args], 1887 length(Args,LA), 1888 length(Args1,LA), 1889 Lit1=..[P|Args1], 1890 M:modeb(_,Lit1), 1891 Lit1 =.. [P|Args1], 1892 convert_to_input_vars(Args1,Args2), 1893 Lit2 =.. [P|Args2], 1894 input_vars(LitM,Lit2,InputVars). 1895 1896input_variables(LitM,M,InputVars):- 1897 LitM=..[P|Args], 1898 length(Args,LA), 1899 length(Args1,LA), 1900 Lit1=..[P|Args1], 1901 M:modeb(_,Lit1), 1902 input_vars(LitM,Lit1,InputVars). 1903 1904input_variables(LitM,M,InputVars):- 1905 LitM=..[P|Args], 1906 length(Args,LA), 1907 length(Args1,LA), 1908 Lit1=..[P|Args1], 1909 M:modeh(_,Lit1), 1910 input_vars(LitM,Lit1,InputVars). 1911 1912input_vars(Lit,Lit1,InputVars):- 1913 Lit =.. [_|Vars], 1914 Lit1 =.. [_|Types], 1915 input_vars1(Vars,Types,InputVars). 1916 1917 1918input_vars1([],_,[]). 1919 1920input_vars1([V|RV],[+_T|RT],[V|RV1]):- 1921 !, 1922 input_vars1(RV,RT,RV1). 1923 1924input_vars1([_V|RV],[_|RT],RV1):- 1925 input_vars1(RV,RT,RV1).
1933extract_type_vars([],_M,[]). 1934 1935extract_type_vars([Lit|RestLit],M,TypeVars):- 1936 Lit =.. [Pred|Args], 1937 length(Args,L), 1938 length(Args1,L), 1939 Lit1 =.. [Pred|Args1], 1940 take_mode(M,Lit1), 1941 type_vars(Args,Args1,Types), 1942 extract_type_vars(RestLit,M,TypeVars0), 1943 !, 1944 append(Types,TypeVars0,TypeVars). 1945 1946 1947take_mode(M,Lit):- 1948 M:modeh(_,Lit),!. 1949 1950take_mode(M,Lit):- 1951 M:modeb(_,Lit),!. 1952 1953take_mode(M,Lit):- 1954 M:mode(_,Lit),!. 1955 1956 1957type_vars([],[],[]). 1958 1959type_vars([V|RV],[+T|RT],[V=T|RTV]):- 1960 !, 1961 type_vars(RV,RT,RTV). 1962 1963type_vars([V|RV],[-T|RT],[V=T|RTV]):-atom(T),!, 1964 type_vars(RV,RT,RTV). 1965 1966type_vars([_V|RV],[_T|RT],RTV):- 1967 type_vars(RV,RT,RTV).
1977take_var_args([],_,[]). 1978 1979take_var_args([+T|RT],TypeVars,[V|RV]):- 1980 !, 1981 member(V=T,TypeVars), 1982 take_var_args(RT,TypeVars,RV). 1983 1984take_var_args([-T|RT],TypeVars,[_V|RV]):- 1985 atom(T), 1986 take_var_args(RT,TypeVars,RV). 1987 1988take_var_args([-T|RT],TypeVars,[V|RV]):- 1989 member(V=T,TypeVars), 1990 take_var_args(RT,TypeVars,RV). 1991 1992take_var_args([T|RT],TypeVars,[T|RV]):- 1993 T\= + _,(T\= - _; T= - A,number(A)), 1994 take_var_args(RT,TypeVars,RV). 1995 1996 1997 1998add_probs([],['':P],P):-!. 1999 2000add_probs([H|T],[H:P|T1],P):- 2001 add_probs(T,T1,P).
2010extract_fancy_vars(List,Vars):- 2011 term_variables(List,Vars0), 2012 fancy_vars(Vars0,1,Vars). 2013 2014 2015fancy_vars([],_,[]). 2016 2017fancy_vars([X|R],N,[NN2=X|R1]):- 2018 name(N,NN), 2019 append([86],NN,NN1), 2020 name(NN2,NN1), 2021 N1 is N + 1, 2022 fancy_vars(R,N1,R1).
delete(+List1, @Elem, -List2)
but
Element is unified with the deleted element (so it can be
instantiated by the call).
/2032delete_one([X|R],R,X). 2033 2034delete_one([X|R],[X|R1],D):- 2035 delete_one(R,R1,D). 2036 2037 2038 2039 2040%Computation of the depth of the variables in the clause head/body 2041dv(H,B,M,DV1):- %DV1: returns a list of couples (Variable, Max depth) 2042 term_variables(H,V), 2043 head_depth(V,DV0), 2044 findall((MD-DV),var_depth(B,M,DV0,DV,0,MD),LDs), 2045 get_max(LDs,-1,-,DV1). 2046 2047 2048input_variables_b(\+ LitM,M,InputVars):-!, 2049 LitM=..[P|Args], 2050 length(Args,LA), 2051 length(Args1,LA), 2052 Lit1=..[P|Args1], 2053 M:modeb(_,Lit1), 2054 all_plus(Lit1), 2055 input_vars(LitM,Lit1,InputVars). 2056 2057input_variables_b(LitM,M,InputVars):- 2058 LitM=..[P|Args], 2059 length(Args,LA), 2060 length(Args1,LA), 2061 Lit1=..[P|Args1], 2062 M:modeb(_,Lit1), 2063 input_vars(LitM,Lit1,InputVars). 2064 2065 2066 2067%associates depth 0 to each variable in the clause head 2068head_depth([],[]). 2069head_depth([V|R],[[V,0]|R1]):- 2070 head_depth(R,R1). 2071 2072%associates a depth to each variable in the clause body 2073var_depth([],_M,PrevDs1,PrevDs1,MD,MD):-!. 2074 2075var_depth([L|R],M,PrevDs,PrevDs1,_MD,MD):- %L = a body literal, MD = maximum depth set by the user 2076 input_variables_b(L,M,InputVars), 2077 term_variables(L, BodyAtomVars), 2078 output_vars(BodyAtomVars,InputVars,OutputVars), 2079 depth_InputVars(InputVars,PrevDs,0,MaxD), %MaxD: maximum depth of the input variables in the body literal 2080 D is MaxD+1, 2081 compute_depth(OutputVars,D,PrevDs,PrevDs0), %Computes the depth for the output variables in the body literal 2082 var_depth(R,M,PrevDs0,PrevDs1,D,MD). 2083 2084get_max([],_,Ds,Ds). 2085 2086get_max([(MD-DsH)|T],MD0,_Ds0,Ds):- 2087 MD>MD0,!, 2088 get_max(T,MD,DsH,Ds). 2089 2090get_max([_H|T],MD,Ds0,Ds):- 2091 get_max(T,MD,Ds0,Ds). 2092 2093delete_eq([],_E,[]). 2094 2095delete_eq([H|T],E,T1):- 2096 H==E,!, 2097 delete_eq(T,E,T1). 2098 2099delete_eq([H|T],E,[H|T1]):- 2100 delete_eq(T,E,T1). 2101 2102output_vars(OutVars,[],OutVars):-!. 2103output_vars(BodyAtomVars,[I|InputVars],OutVars):- 2104 delete_eq(BodyAtomVars, I, Residue), 2105 output_vars(Residue,InputVars, OutVars). 2106 2107% returns D as the maximum depth of the variables in the list (first argument) 2108depth_InputVars([],_,D,D). 2109depth_InputVars([I|Input],PrevDs,D0,D):- 2110 member_l(PrevDs,I,MD), 2111 (MD>D0-> 2112 D1=MD 2113 ; 2114 D1=D0 2115 ), 2116 depth_InputVars(Input,PrevDs,D1,D). 2117 2118member_l([[L,D]|_P],I,D):- 2119 I==L,!. 2120member_l([_|P],I,D):- 2121 member_l(P,I,D). 2122 2123compute_depth([],_,PD,PD):-!. 2124compute_depth([O|Output],D,PD,RestO):- 2125 member_l(PD,O,_),!, 2126 compute_depth(Output,D,PD,RestO). 2127 2128compute_depth([O|Output],D,PD,[[O,D]|RestO]):- 2129 compute_depth(Output,D,PD,RestO). 2130 2131 2132 2133%checks if a variable depth exceeds the setting_sc 2134exceed_depth([],_):-!. 2135exceed_depth([H|T],MD):- 2136 nth1(2,H,Dep), 2137 Dep<MD, %setting_sc(maxdepth_var,MD), 2138 exceed_depth(T,MD). 2139 2140/* 2141 2142EMBLEM and SLIPCASE 2143 2144Copyright (c) 2011, Fabrizio Riguzzi and Elena Bellodi 2145 2146*/
assertz(M:Term,Ref)
and
returns the list of references in Refs
/2154assert_all([],_M,[]). 2155 2156assert_all([H|T],M,[HRef|TRef]):- 2157 assertz(M:,HRef), 2158 assert_all(T,M,TRef). 2159 2160assert_all([],[]). 2161 2162assert_all([H|T],[HRef|TRef]):- 2163 assertz(slipcover:,HRef), 2164 assert_all(T,TRef).
2171retract_all([]):-!. 2172 2173retract_all([H|T]):- 2174 erase(H), 2175 retract_all(T). 2176 2177 2178read_clauses_dir(S,[Cl|Out]):- 2179 read_term(S,Cl,[]), 2180 (Cl=end_of_file-> 2181 Out=[] 2182 ; 2183 read_clauses_dir(S,Out) 2184 ).
rule(R,HeadList,BodyList,Lit,Tun)
.
ClausesOut/Clauses is a difference list of clauses to be asserted.
/2194process_clauses([],_M,C,C,R,R):-!. 2195 2196process_clauses([end_of_file],_M,C,C,R,R):-!. 2197 2198process_clauses([H|T],M,C0,C1,R0,R1):- 2199 (term_expansion_int(H,M,H1)-> 2200 true 2201 ; 2202 H1=(H,[]) 2203 ), 2204 (H1=([_|_],R)-> 2205 H1=(List,R), 2206 append(C0,List,C2), 2207 append(R0,R,R2) 2208 ; 2209 (H1=([],_R)-> 2210 C2=C0, 2211 R2=R0 2212 ; 2213 H1=(H2,R), 2214 append(C0,[H2],C2), 2215 append(R0,R,R2) 2216 ) 2217 ), 2218 process_clauses(T,M,C2,C1,R2,R1).
2228get_next_rule_number(M,R):- 2229 retract(M:rule_sc_n(R)), 2230 R1 is R+1, 2231 assert(M:rule_sc_n(R1)). 2232 2233reset_next_rule_number(M):- 2234 retract(M:rule_sc_n(_)), 2235 assert(M:rule_sc_n(0)).
2245get_next_nonground_rule_number(M,R):- 2246 retract(M:rule_ng_sc_n(R)), 2247 R1 is R+1, 2248 assert(M:rule_ng_sc_n(R1)). 2249 2250reset_next_nonground_rule_number(M):- 2251 retract(M:rule_ng_sc_n(_)), 2252 assert(M:rule_ng_sc_n(0)). 2253 2254get_node(\+ Goal,M,Env,BDD):- 2255 M:local_setting(depth_bound,true),!, 2256 M:local_setting(depth,DB), 2257 retractall(M:v(_,_,_)), 2258 abolish_all_tables, 2259 add_bdd_arg_db(Goal,Env,B,DB,Goal1), 2260 (M:Goal1-> 2261 bdd_notc(Env,B,(_,BDD)) 2262 ; 2263 onec(Env,(_,BDD)) 2264 ). 2265 2266get_node(\+ Goal,M,Env,BDD):-!, 2267 retractall(M:v(_,_,_)), 2268 abolish_all_tables, 2269 add_bdd_arg(Goal,Env,B,Goal1), 2270 (M:Goal1-> 2271 bdd_notc(Env,B,(_,BDD)) 2272 ; 2273 onec(Env,(_,BDD)) 2274 ). 2275 2276get_node(Goal,M,Env,BDD):- 2277 M:local_setting(depth_bound,true),!, 2278 M:local_setting(depth,DB), 2279 retractall(M:v(_,_,_)), 2280 abolish_all_tables, 2281 add_bdd_arg_db(Goal,Env,B,DB,Goal1),%DB=depth bound 2282 (M:Goal1-> 2283 (_,BDD)=B 2284 ; 2285 zeroc(Env,(_,BDD)) 2286 ). 2287 2288get_node(Goal,M,Env,BDD):- %with DB=false 2289 retractall(M:v(_,_,_)), 2290 add_bdd_arg(Goal,Env,B,Goal1), 2291 abolish_all_tables, 2292% trace, 2293 (M:Goal1-> 2294 (_,BDD)=B 2295 ; 2296 zeroc(Env,(_,BDD)) 2297 ). 2298 2299add_int_arg(_I,A,A):- 2300 builtin(A),!. 2301 2302add_int_arg(I,A,A1):- 2303 A=..[P|Args], 2304 A1=..[P,I|Args]. 2305 2306add_bdd_arg(A,Env,BDD,A1):- 2307 A=..[P|Args], 2308 append(Args,[Env,BDD],Args1), 2309 A1=..[P|Args1]. 2310 2311 2312add_bdd_arg_db(A,Env,BDD,DB,A1):- 2313 A=..[P|Args], 2314 append(Args,[DB,Env,BDD],Args1), 2315 A1=..[P|Args1]. 2316 2317 2318add_bdd_arg(A,Env,BDD,Module,A1):- 2319 A=..[P|Args], 2320 append(Args,[Env,BDD],Args1), 2321 A1=..[P,Module|Args1]. 2322 2323 2324add_bdd_arg_db(A,Env,BDD,DB,Module,A1):- 2325 A=..[P|Args], 2326 append(Args,[DB,Env,BDD],Args1), 2327 A1=..[P,Module|Args1]. 2328 2329add_mod_arg(A,Module,A1):- 2330 A=..[P|Args], 2331 A1=..[P,Module|Args]. 2332 2333 2334generate_rules_fact([],_Env,_VC,_R,_Probs,_N,[],_Module,_M). 2335 2336generate_rules_fact([Head:_P1,'':_P2],Env,VC,R,Probs,N,[Clause],Module,M):-!, 2337 add_bdd_arg(Head,Env,BDD,Module,Head1), 2338 Clause=(Head1:-(slipcover:get_sc_var_n(M,Env,R,VC,Probs,V),slipcover:equalityc(Env,V,N,BDD))). 2339 2340generate_rules_fact([Head:_P|T],Env,VC,R,Probs,N,[Clause|Clauses],Module,M):- 2341 add_bdd_arg(Head,Env,BDD,Module,Head1), 2342 Clause=(Head1:-(slipcover:get_sc_var_n(M,Env,R,VC,Probs,V),slipcover:equalityc(Env,V,N,BDD))), 2343 N1 is N+1, 2344 generate_rules_fact(T,Env,VC,R,Probs,N1,Clauses,Module,M). 2345 2346 2347generate_rules_fact_db([],_Env,_VC,_R,_Probs,_N,[],_Module,_M). 2348 2349generate_rules_fact_db([Head:_P1,'':_P2],Env,VC,R,Probs,N,[Clause],Module,M):-!, 2350 add_bdd_arg_db(Head,Env,BDD,_DB,Module,Head1), 2351 Clause=(Head1:-(slipcover:get_sc_var_n(M,Env,R,VC,Probs,V),slipcover:equalityc(Env,V,N,BDD))). 2352 2353generate_rules_fact_db([Head:_P|T],Env,VC,R,Probs,N,[Clause|Clauses],Module,M):- 2354 add_bdd_arg_db(Head,Env,BDD,_DB,Module,Head1), 2355 Clause=(Head1:-(slipcover:get_sc_var_n(M,Env,R,VC,Probs,V),slipcover:equalityc(Env,V,N,BDD))), 2356 N1 is N+1, 2357 generate_rules_fact_db(T,Env,VC,R,Probs,N1,Clauses,Module,M). 2358 2359 2360generate_clause(Head,Env,Body,VC,R,Probs,BDDAnd,N,Clause,Module,M):- 2361 add_bdd_arg(Head,Env,BDD,Module,Head1), 2362 Clause=(Head1:-(Body,slipcover:get_sc_var_n(M,Env,R,VC,Probs,V),slipcover:equalityc(Env,V,N,B),slipcover:andc(Env,BDDAnd,B,BDD))). 2363 2364 2365generate_clause_db(Head,Env,Body,VC,R,Probs,DB,BDDAnd,N,Clause,Module,M):- 2366 add_bdd_arg_db(Head,Env,BDD,DBH,Module,Head1), 2367 Clause=(Head1:-(DBH>=1,DB is DBH-1,Body,slipcover:get_sc_var_n(M,Env,R,VC,Probs,V),slipcover:equalityc(Env,V,N,B),slipcover:andc(Env,BDDAnd,B,BDD))). 2368 2369 2370generate_rules([],_Env,_Body,_VC,_R,_Probs,_BDDAnd,_N,[],_Module,_M). 2371 2372generate_rules([Head:_P1,'':_P2],Env,Body,VC,R,Probs,BDDAnd,N,[Clause],Module,M):-!, 2373 generate_clause(Head,Env,Body,VC,R,Probs,BDDAnd,N,Clause,Module,M). 2374 2375generate_rules([Head:_P|T],Env,Body,VC,R,Probs,BDDAnd,N,[Clause|Clauses],Module,M):- 2376 generate_clause(Head,Env,Body,VC,R,Probs,BDDAnd,N,Clause,Module,M), 2377 N1 is N+1, 2378 generate_rules(T,Env,Body,VC,R,Probs,BDDAnd,N1,Clauses,Module,M). 2379 2380 2381generate_rules_db([],_Env,_Body,_VC,_R,_Probs,_DB,_BDDAnd,_N,[],_Module,_M):-!. 2382 2383generate_rules_db([Head:_P1,'':_P2],Env,Body,VC,R,Probs,DB,BDDAnd,N,[Clause],Module,M):-!, 2384 generate_clause_db(Head,Env,Body,VC,R,Probs,DB,BDDAnd,N,Clause,Module,M). 2385 2386generate_rules_db([Head:_P|T],Env,Body,VC,R,Probs,DB,BDDAnd,N,[Clause|Clauses],Module,M):- 2387 generate_clause_db(Head,Env,Body,VC,R,Probs,DB,BDDAnd,N,Clause,Module,M),!,%agg.cut 2388 N1 is N+1, 2389 generate_rules_db(T,Env,Body,VC,R,Probs,DB,BDDAnd,N1,Clauses,Module,M). 2390 2391process_body_bg([],[],_Module). 2392 2393process_body_bg([\+ H|T],[\+ H|Rest],Module):- 2394 builtin(H),!, 2395 process_body_bg(T,Rest,Module). 2396 2397process_body_bg([\+ H|T],[\+ H1|Rest],Module):-!, 2398 add_mod_arg(H,Module,H1), 2399 process_body_bg(T,Rest,Module). 2400 2401process_body_bg([H|T],[H|Rest],Module):- 2402 builtin(H),!, 2403 process_body_bg(T,Rest,Module). 2404 2405process_body_bg([H|T],[H1|Rest],Module):-!, 2406 add_mod_arg(H,Module,H1), 2407 process_body_bg(T,Rest,Module). 2408 2409 2410 2411process_body([],BDD,BDD,Vars,Vars,[],_Env,_Module,_M). 2412 2413process_body([\+ H|T],BDD,BDD1,Vars,Vars1,[\+ H|Rest],Env,Module,M):- 2414 builtin(H),!, 2415 process_body(T,BDD,BDD1,Vars,Vars1,Rest,Env,Module,M). 2416 2417process_body([\+ H|T],BDD,BDD1,Vars,Vars1,[\+ H|Rest],Env,Module,M):- 2418 db(H),!, 2419 process_body(T,BDD,BDD1,Vars,Vars1,Rest,Env,Module,M). 2420 2421process_body([\+ H|T],BDD,BDD1,Vars,Vars1,[ 2422(((neg(H1);\+ H1),slipcover:onec(Env,BDDN)); 2423 (H2,slipcover:bdd_notc(Env,BDDH,BDDN))), 2424 slipcover:andc(Env,BDD,BDDN,BDD2) 2425 |Rest],Env,Module,M):- 2426 given(M,H),!, 2427 add_mod_arg(H,Module,H1), 2428 add_bdd_arg(H,Env,BDDH,Module,H2), 2429 process_body(T,BDD2,BDD1,Vars,Vars1,Rest,Env,Module,M). 2430 2431process_body([\+ H|T],BDD,BDD1,Vars,Vars1,[ 2432 \+(H1)|Rest],Env,Module,M):- 2433 given_cw(M,H),!, 2434 add_mod_arg(H,Module,H1), 2435 process_body(T,BDD,BDD1,Vars,Vars1,Rest,Env,Module,M). 2436 2437process_body([\+ H|T],BDD,BDD1,Vars,[BDDH,BDDN,BDD2|Vars1], 2438[H1,slipcover:bdd_notc(Env,BDDH,BDDN), 2439 slipcover:andc(Env,BDD,BDDN,BDD2)|Rest],Env,Module,M):-!, 2440 add_bdd_arg(H,Env,BDDH,Module,H1), 2441 process_body(T,BDD2,BDD1,Vars,Vars1,Rest,Env,Module,M). 2442 2443process_body([H|T],BDD,BDD1,Vars,Vars1,[H|Rest],Env,Module,M):- 2444 builtin(H),!, 2445 process_body(T,BDD,BDD1,Vars,Vars1,Rest,Env,Module,M). 2446 2447process_body([H|T],BDD,BDD1,Vars,Vars1,[H|Rest],Env,Module,M):- 2448 db(H),!, 2449 process_body(T,BDD,BDD1,Vars,Vars1,Rest,Env,Module,M). 2450 2451process_body([H|T],BDD,BDD1,Vars,Vars1, 2452[((H1,slipcover:onec(Env,BDDH));H2),slipcover:andc(Env,BDD,BDDH,BDD2)|Rest],Env,Module,M):- 2453 given(M,H),!, 2454 add_mod_arg(H,Module,H1), 2455 add_bdd_arg(H,Env,BDDH,Module,H2), 2456 process_body(T,BDD2,BDD1,Vars,Vars1,Rest,Env,Module,M). 2457 2458process_body([H|T],BDD,BDD1,Vars,Vars1, 2459[H1|Rest],Env,Module,M):- 2460 given_cw(M,H),!, 2461 add_mod_arg(H,Module,H1), 2462 process_body(T,BDD,BDD1,Vars,Vars1,Rest,Env,Module,M). 2463 2464process_body([H|T],BDD,BDD1,Vars,Vars1,[H1|Rest],Env,Module,M):- 2465 add_mod_arg(H,Module,H1), 2466 db(H1),!, 2467 process_body(T,BDD,BDD1,Vars,Vars1,Rest,Env,Module,M). 2468 2469process_body([H|T],BDD,BDD1,Vars,[BDDH,BDD2|Vars1], 2470[H1,slipcover:andc(Env,BDD,BDDH,BDD2)|Rest],Env,Module,M):- 2471 add_bdd_arg(H,Env,BDDH,Module,H1), 2472 process_body(T,BDD2,BDD1,Vars,Vars1,Rest,Env,Module,M). 2473 2474process_body_db([],BDD,BDD,_DB,Vars,Vars,[],_Env,_Module,_M):-!. 2475 2476process_body_db([\+ H|T],BDD,BDD1,DB,Vars,Vars1,[\+ H|Rest],Env,Module,M):- 2477 builtin(H),!, 2478 process_body_db(T,BDD,BDD1,DB,Vars,Vars1,Rest,Env,Module,M). 2479 2480process_body_db([\+ H|T],BDD,BDD1,DB,Vars,Vars1,[\+ H|Rest],Env,Module,M):- 2481 db(H),!, 2482 process_body_db(T,BDD,BDD1,DB,Vars,Vars1,Rest,Env,Module,M). 2483 2484process_body_db([\+ H|T],BDD,BDD1,DB,Vars,Vars1,[ 2485 (((neg(H1);\+ H1),slipcover:onec(Env,BDDN)); 2486 (H2,slipcover:bdd_notc(Env,BDDH,BDDN))), 2487 slipcover:andc(Env,BDD,BDDN,BDD2) 2488 |Rest],Env,Module,M):- 2489 given(M,H),!, 2490 add_mod_arg(H,Module,H1), 2491 add_bdd_arg_db(H,Env,BDDH,DB,Module,H2), 2492 process_body_db(T,BDD2,BDD1,DB,Vars,Vars1,Rest,Env,Module,M). 2493 2494process_body_db([\+ H|T],BDD,BDD1,DB,Vars,Vars1,[ 2495 neg(H1)|Rest],Env,Module,M):- 2496 given_cw(M,H),!, 2497 add_mod_arg(H,Module,H1), 2498 process_body_db(T,BDD,BDD1,DB,Vars,Vars1,Rest,Env,Module,M). 2499 2500process_body_db([\+ H|T],BDD,BDD1,DB,Vars,[BDDH,BDDN,BDD2|Vars1], 2501[H1,slipcover:bdd_notc(Env,BDDH,BDDN), 2502 slipcover:andc(Env,BDD,BDDN,BDD2)|Rest],Env,Module,M):-!, 2503 add_bdd_arg_db(H,Env,BDDH,DB,Module,H1), 2504 process_body_db(T,BDD2,BDD1,DB,Vars,Vars1,Rest,Env,Module,M). 2505 2506process_body_db([H|T],BDD,BDD1,DB,Vars,Vars1,[H|Rest],Env,Module,M):- 2507 builtin(H),!, 2508 process_body_db(T,BDD,BDD1,DB,Vars,Vars1,Rest,Env,Module,M). 2509 2510process_body_db([H|T],BDD,BDD1,DB,Vars,Vars1,[H|Rest],Env,Module,M):- 2511 db(H),!, 2512 process_body_db(T,BDD,BDD1,DB,Vars,Vars1,Rest,Env,Module,M). 2513 2514process_body_db([H|T],BDD,BDD1,DB,Vars,Vars1, 2515[((H1,slipcover:onec(Env,BDDH));H2),slipcover:andc(Env,BDD,BDDH,BDD2)|Rest],Env,Module,M):- 2516 given(M,H),!, 2517 add_mod_arg(H,Module,H1), 2518 add_bdd_arg_db(H,Env,BDDH,DB,Module,H2), 2519 process_body_db(T,BDD2,BDD1,DB,Vars,Vars1,Rest,Env,Module,M). 2520 2521process_body_db([H|T],BDD,BDD1,DB,Vars,Vars1, 2522[H1|Rest],Env,Module,M):- 2523 given_cw(M,H),!, 2524 add_mod_arg(H,Module,H1), 2525 process_body_db(T,BDD,BDD1,DB,Vars,Vars1,Rest,Env,Module,M). 2526 2527process_body_db([H|T],BDD,BDD1,DB,Vars,[BDDH,BDD2|Vars1], 2528[H1,slipcover:andc(Env,BDD,BDDH,BDD2)|Rest],Env,Module,M):-!, %agg. cut 2529 add_bdd_arg_db(H,Env,BDDH,DB,Module,H1), 2530 process_body_db(T,BDD2,BDD1,DB,Vars,Vars1,Rest,Env,Module,M). 2531 2532 2533 2534process_body_cw([],BDD,BDD,Vars,Vars,[],_Module). 2535 2536process_body_cw([\+ H|T],BDD,BDD1,Vars,Vars1,[\+ H|Rest],Module):- 2537 builtin(H),!, 2538 process_body_cw(T,BDD,BDD1,Vars,Vars1,Rest,Module). 2539 2540process_body_cw([\+ H|T],BDD,BDD1,Vars,Vars1,[\+ H|Rest],Module):- 2541 db(H),!, 2542 process_body_cw(T,BDD,BDD1,Vars,Vars1,Rest,Module). 2543 2544process_body_cw([\+ H|T],BDD,BDD1,Vars,Vars1,[ 2545 \+(H1)|Rest],Module):- 2546 add_mod_arg(H,Module,H1), 2547 process_body_cw(T,BDD,BDD1,Vars,Vars1,Rest,Module). 2548 2549process_body_cw([H|T],BDD,BDD1,Vars,Vars1,[H|Rest],Module):- 2550 builtin(H),!, 2551 process_body_cw(T,BDD,BDD1,Vars,Vars1,Rest,Module). 2552 2553process_body_cw([H|T],BDD,BDD1,Vars,Vars1,[H|Rest],Module):- 2554 db(H),!, 2555 process_body_cw(T,BDD,BDD1,Vars,Vars1,Rest,Module). 2556 2557process_body_cw([H|T],BDD,BDD1,Vars,Vars1, 2558[H1|Rest],Module):- 2559 add_mod_arg(H,Module,H1), 2560 process_body_cw(T,BDD,BDD1,Vars,Vars1,Rest,Module). 2561 2562 2563given(M,H):- 2564 functor(H,P,Ar), 2565 (M:input(P/Ar)). 2566 2567 2568given_cw(M,H):- 2569 functor(H,P,Ar), 2570 (M:input_cw(P/Ar)).
2579set_sc(M:Parameter,Value):-
2580 must_be(atom,Parameter),
2581 must_be(nonvar,Value),
2582 retract(M:local_setting(Parameter,_)),
2583 assert(M:local_setting(Parameter,Value)).
2592setting_sc(M:P,V):- 2593 must_be(atom,P), 2594 M:local_setting(P,V). 2595 2596 2597 2598difference([],_,[]). 2599 2600difference([H|T],L2,L3):- 2601 member_eq(H,L2),!, 2602 difference(T,L2,L3). 2603 2604difference([H|T],L2,[H|L3]):- 2605 difference(T,L2,L3).
2612member_eq(E,[H|_T]):- 2613 E==H,!. 2614 2615member_eq(E,[_H|T]):- 2616 member_eq(E,T). 2617 2618 2619 2620 2621process_head(HeadList,M, GroundHeadList) :- 2622 ground_prob(HeadList), !, 2623 process_head_ground(HeadList,M, 0, GroundHeadList). 2624 2625process_head(HeadList,_M, HeadList). 2626 2627 2628process_head_fixed([Head:p(ProbHead)],M, Prob, [Head:ProbHead1|Null]) :-!, 2629 ProbHead1 is ProbHead, 2630 ProbLast is 1 - Prob - ProbHead1, 2631 M:local_setting(epsilon_parsing, Eps), 2632 EpsNeg is - Eps, 2633 ProbLast > EpsNeg, 2634 (ProbLast > Eps -> 2635 Null = ['':ProbLast] 2636 ; 2637 Null = [] 2638 ). 2639 2640process_head_fixed([Head:p(ProbHead)|Tail], M, Prob, [Head:ProbHead1|Next]) :- 2641 ProbHead1 is ProbHead, 2642 ProbNext is Prob + ProbHead1, 2643 process_head_fixed(Tail, M, ProbNext, Next). 2644 2645 2646/* process_head_ground([Head:ProbHead], Prob, [Head:ProbHead|Null]) 2647 * ---------------------------------------------------------------- 2648 */ 2649process_head_ground([Head:ProbHead],M, Prob, [Head:ProbHead1|Null]) :-!, 2650 ProbHead1 is ProbHead, 2651 ProbLast is 1 - Prob - ProbHead1, 2652 M:local_setting(epsilon_parsing, Eps), 2653 EpsNeg is - Eps, 2654 ProbLast > EpsNeg, 2655 (ProbLast > Eps -> 2656 Null = ['':ProbLast] 2657 ; 2658 Null = [] 2659 ). 2660 2661process_head_ground([Head:ProbHead|Tail], M, Prob, [Head:ProbHead1|Next]) :- 2662 ProbHead1 is ProbHead, 2663 ProbNext is Prob + ProbHead1, 2664 process_head_ground(Tail, M, ProbNext, Next). 2665 2666 2667ground_prob([]). 2668 2669ground_prob([_Head:ProbHead|Tail]) :- 2670 ground(ProbHead), % Succeeds if there are no free variables in the term ProbHead. 2671 ground_prob(Tail). 2672 2673 2674get_probs([], []). 2675 2676get_probs([_H:P|T], [P1|T1]) :- 2677 P1 is P, 2678 get_probs(T, T1). 2679 2680get_probs_t([H:A|T],_M, LP,L3):- 2681 A=..[t,Prob|_], 2682 var(Prob),!, 2683 length([H:A|T],N), 2684 P is 1/(N+1), 2685 maplist(set_prob(P),[H:A|T],LP,L2), 2686 append(L2,['':P],L3). 2687 2688get_probs_t(L,M,LP,L3):- 2689 process_head_init(L,M,0,L3), 2690 get_probs(L3,LP). 2691 2692process_head_init([Head:Ann],M, Prob, [Head:ProbHead1|Null]) :-!, 2693 Ann=..[t,ProbHead|_], 2694 ProbHead1 is ProbHead, 2695 ProbLast is 1 - Prob - ProbHead1, 2696 M:local_setting(epsilon_parsing, Eps), 2697 EpsNeg is - Eps, 2698 ProbLast > EpsNeg, 2699 (ProbLast > Eps -> 2700 Null = ['':ProbLast] 2701 ; 2702 Null = [] 2703 ). 2704 2705process_head_init([Head:Ann|Tail], M, Prob, [Head:ProbHead1|Next]) :- 2706 Ann=..[t,ProbHead|_], 2707 ProbHead1 is ProbHead, 2708 ProbNext is Prob + ProbHead1, 2709 process_head_init(Tail, M, ProbNext, Next). 2710 2711set_prob(P,A:_,P,A:P). 2712 2713set_prob_t(A:Ann,P,A:P):- 2714 Ann=..[t,P|_]. 2715 2716get_at(A:_,A). 2717 2718generate_clauses_cw([],_M,[],_N,C,C):-!. 2719 2720generate_clauses_cw([H|T],M,[H1|T1],N,C0,C):- 2721 gen_clause_cw(H,M,N,N1,H1,CL),!, %agg.cut 2722 append(C0,CL,C1), 2723 generate_clauses_cw(T,M,T1,N1,C1,C). 2724 2725gen_clause_cw((H :- Body),_M,N,N,(H :- Body),[(H :- Body)]):- 2726 !. 2727 2728gen_clause_cw(rule(_R,HeadList,BodyList,Lit,Tun),M,N,N1, 2729 rule(N,HeadList,BodyList,Lit,Tun),Clauses):-!, 2730% disjunctive clause with more than one head atom senza depth_bound 2731 process_body_cw(BodyList,BDD,BDDAnd,[],_Vars,BodyList1,Module), 2732 append([slipcover:onec(Env,BDD)],BodyList1,BodyList2), 2733 list2and(BodyList2,Body1), 2734 append(HeadList,BodyList,List), 2735 term_variables(List,VC), 2736 get_probs(HeadList,Probs), 2737 (M:local_setting(single_var,true)-> 2738 generate_rules(HeadList,Env,Body1,[],N,Probs,BDDAnd,0,Clauses,Module,M) 2739 ; 2740 generate_rules(HeadList,Env,Body1,VC,N,Probs,BDDAnd,0,Clauses,Module,M) 2741 ), 2742 N1 is N+1. 2743 2744gen_clause_cw(def_rule(H,BodyList,Lit),_M,N,N,def_rule(H,BodyList,Lit),Clauses) :- !,%agg. cut 2745% disjunctive clause with a single head atom senza depth_bound con prob =1 2746 process_body_cw(BodyList,BDD,BDDAnd,[],_Vars,BodyList2,Module), 2747 append([slipcover:onec(Env,BDD)],BodyList2,BodyList3), 2748 list2and(BodyList3,Body1), 2749 add_bdd_arg(H,Env,BDDAnd,Module,Head1), 2750 Clauses=[(Head1 :- Body1)].
rule(R,HeadList,BodyList,Lit,Tun)
.
Rules is a list of terms of the form
rule(N,HeadList,BodyList,Lit,Tun)
where N is
an increasing index starting from StartingIndex.
ClausesOut/Clauses is a difference list of clauses to be asserted.
/2763generate_clauses([],_M,[],_N,C,C):-!. 2764 2765generate_clauses([H|T],M,[H1|T1],N,C0,C):- 2766 gen_clause(H,M,N,N1,H1,CL),!, %agg.cut 2767 append(C0,CL,C1), 2768 generate_clauses(T,M,T1,N1,C1,C). 2769 2770 2771gen_clause((H :- Body),_M,N,N,(H :- Body),[(H :- Body)]):- 2772 !. 2773 2774gen_clause(rule(R,HeadList,BodyList,Lit,Tun),M,N,N, 2775 rule(RI,HeadList,BodyList,Lit,Tun),Clauses):- 2776 M:local_setting(depth_bound,true),!, 2777% disjunctive clause with more than one head atom e depth_bound 2778 process_body_db(BodyList,BDD,BDDAnd, DB,[],_Vars,BodyList1,Env,Module,M), 2779 append([slipcover:onec(Env,BDD)],BodyList1,BodyList2), 2780 list2and(BodyList2,Body1), 2781 append(HeadList,BodyList,List), 2782 term_variables(List,VC), 2783 get_probs(HeadList,Probs), 2784 (M:local_setting(single_var,true)-> 2785 generate_rules_db(HeadList,Env,Body1,[],RI,Probs,DB,BDDAnd,0,Clauses,Module,M) 2786 ; 2787 generate_rules_db(HeadList,Env,Body1,VC,RI,Probs,DB,BDDAnd,0,Clauses,Module,M) 2788 ), 2789 (R=ng(_,Vals)-> 2790 get_next_nonground_rule_number(M,RG), 2791 RI=ng(RG,Vals) 2792 ; 2793 get_next_rule_number(M,RI) 2794 ). 2795 2796gen_clause(rule(R,HeadList,BodyList,Lit,Tun),M,N,N, 2797 rule(RI,HeadList,BodyList,Lit,Tun),Clauses):-!, 2798% disjunctive clause with more than one head atom senza depth_bound 2799 process_body(BodyList,BDD,BDDAnd,[],_Vars,BodyList1,Env,Module,M), 2800 append([slipcover:onec(Env,BDD)],BodyList1,BodyList2), 2801 list2and(BodyList2,Body1), 2802 append(HeadList,BodyList,List), 2803 term_variables(List,VC), 2804 get_probs(HeadList,Probs), 2805 (M:local_setting(single_var,true)-> 2806 generate_rules(HeadList,Env,Body1,[],RI,Probs,BDDAnd,0,Clauses,Module,M) 2807 ; 2808 generate_rules(HeadList,Env,Body1,VC,RI,Probs,BDDAnd,0,Clauses,Module,M) 2809 ), 2810 (R=ng(_,Vals)-> 2811 get_next_nonground_rule_number(M,RG), 2812 RI=ng(RG,Vals) 2813 ; 2814 get_next_rule_number(M,RI) 2815 ). 2816 2817 2818gen_clause(def_rule(H,BodyList,Lit),M,N,N,def_rule(H,BodyList,Lit),Clauses) :- 2819% disjunctive clause with a single head atom e depth_bound 2820 M:local_setting(depth_bound,true),!, 2821 process_body_db(BodyList,BDD,BDDAnd,DB,[],_Vars,BodyList2,Env,Module,M), 2822 append([slipcover:onec(Env,BDD)],BodyList2,BodyList3), 2823 list2and(BodyList3,Body1), 2824 add_bdd_arg_db(H,Env,BDDAnd,DBH,Module,Head1), 2825 Clauses=[(Head1 :- (DBH>=1,DB is DBH-1,Body1))]. 2826 2827gen_clause(def_rule(H,BodyList,Lit),M,N,N,def_rule(H,BodyList,Lit),Clauses) :- !,%agg. cut 2828% disjunctive clause with a single head atom senza depth_bound con prob =1 2829 process_body(BodyList,BDD,BDDAnd,[],_Vars,BodyList2,Env,Module,M), 2830 append([slipcover:onec(Env,BDD)],BodyList2,BodyList3), 2831 list2and(BodyList3,Body1), 2832 add_bdd_arg(H,Env,BDDAnd,Module,Head1), 2833 Clauses=[(Head1 :- Body1)].
def_rule(H,BodyList,_Lit)
.
Clauses is a list of clauses to be asserted.
/2843generate_clauses_bg([],[]):-!. 2844 2845generate_clauses_bg([H|T],[CL|T1]):- 2846 gen_clause_bg(H,CL), %agg.cut 2847 generate_clauses_bg(T,T1). 2848 2849gen_clause_bg(def_rule(H,BodyList,_Lit),Clauses) :- 2850% disjunctive clause with a single head atom e depth_bound 2851 process_body_bg(BodyList,BodyList2,Module), 2852 list2and(BodyList2,Body1), 2853 add_mod_arg(H,Module,Head1), 2854 Clauses=(Head1 :- Body1).
ng(RN,Vals)
, indicating a rule for which
different instantiations get different parameters.
/2865get_sc_var_n(M,Env,R,S,Probs0,V):- 2866 (ground(Probs0)-> 2867 maplist(is,Probs,Probs0), 2868 (M:v(R,S,V)-> 2869 true 2870 ; 2871 (R=ng(RN,Vals)-> 2872 M:rule(ng(RN,Vals),HeadList,BodyList,Lits,Tun), 2873 (M:rule(g(GR),HeadList,BodyList,Lits,Tun)-> 2874 (M:v(GR,S,V)-> 2875 true 2876 ; 2877 add_var(Env,Probs,GR,V), 2878 assert(M:v(GR,S,V)) 2879 ) 2880 ; 2881 get_next_rule_number(M,GR), 2882 assert(M:rule(g(GR),HeadList,BodyList,Lits,Tun)), 2883 add_var(Env,Probs,GR,V), 2884 assert(M:v(GR,S,V)) 2885 ) 2886 ; 2887 add_var(Env,Probs,R,V), 2888 assert(M:v(R,S,V)) 2889 ) 2890 ) 2891 ; 2892 throw(error('Non ground probailities not instantiated by the body')) 2893 ). 2894 2895 2896builtin(average(_L,_Av)) :- !. 2897builtin(G) :- 2898 swi_builtin(G). 2899 2900 2901gen_cl_db_t(M,HeadList,BodyList,Clauses,rule(ng(R,Vals),HeadList1,BodyList,true,Tun)):- 2902 process_body_db(BodyList,BDD,BDDAnd, DB,[],_Vars,BodyList1,Env,Module,M), 2903 append(HeadList,BodyList,List), 2904 term_variables(List,VC), 2905 append([slipcover:onec(Env,BDD)],BodyList1,BodyList2), 2906 list2and(BodyList2,Body1), 2907 get_next_nonground_rule_number(M,R), 2908 get_probs_t(HeadList,M,Probs,HeadList1), 2909 HeadList=[_:Ann|_], 2910 Ann=..[t,P|Vals], 2911 (var(P)-> 2912 Tun=tunable 2913 ; 2914 Tun=initial 2915 ), 2916 (M:local_setting(single_var,true)-> 2917 generate_rules_db(HeadList1,Env,Body1,[],ng(R,Vals),Probs,DB,BDDAnd,0,Clauses,Module,M) 2918 ; 2919 generate_rules_db(HeadList1,Env,Body1,VC,ng(R,Vals),Probs,DB,BDDAnd,0,Clauses,Module,M) 2920 ). 2921 2922gen_cl_db_fact_t(M,HeadList,Clauses,rule(ng(R,Vals),HeadList1,[],true,Tun)):- 2923 term_variables(HeadList,VC), 2924 get_next_nonground_rule_number(M,R), 2925 get_probs_t(HeadList,M,Probs,HeadList1), 2926 HeadList=[_:Ann|_], 2927 Ann=..[t,P|Vals], 2928 (var(P)-> 2929 Tun=tunable 2930 ; 2931 Tun=initial 2932 ), 2933 (M:local_setting(single_var,true)-> 2934 generate_rules_fact_db(HeadList,_Env,[],ng(R,Vals),Probs,0,Clauses,_Module,M) 2935 ; 2936 generate_rules_fact_db(HeadList,_Env,VC,ng(R,Vals),Probs,0,Clauses,_Module,M) 2937 ). 2938 2939gen_cl_fact_t(M,HeadList,Clauses,rule(ng(R,Vals),HeadList1,[],true,Tun)):- 2940 term_variables(HeadList,VC), 2941 get_next_nonground_rule_number(M,R), 2942 get_probs_t(HeadList,M,Probs,HeadList1), 2943 HeadList=[_:Ann|_], 2944 Ann=..[t,P|Vals], 2945 (var(P)-> 2946 Tun=tunable 2947 ; 2948 Tun=initial 2949 ), 2950 (M:local_setting(single_var,true)-> 2951 generate_rules_fact(HeadList,_Env,[],ng(R,Vals),Probs,0,Clauses,_Module,M) 2952 ; 2953 generate_rules_fact(HeadList,_Env,VC,ng(R,Vals),Probs,0,Clauses,_Module,M) 2954 ). 2955 2956gen_cl_t(M,HeadList,BodyList,Clauses,rule(ng(R,Vals),HeadList1,BodyList,true,Tun)):- 2957 process_body(BodyList,BDD,BDDAnd, [],_Vars,BodyList1,Env,Module,M), 2958 append(HeadList,BodyList,List), 2959 term_variables(List,VC), 2960 append([slipcover:onec(Env,BDD)],BodyList1,BodyList2), 2961 list2and(BodyList2,Body1), 2962 get_next_nonground_rule_number(M,R), 2963 get_probs_t(HeadList,M,Probs,HeadList1), 2964 HeadList=[_:Ann|_], 2965 Ann=..[t,P|Vals], 2966 (var(P)-> 2967 Tun=tunable 2968 ; 2969 Tun=initial 2970 ), 2971 (M:local_setting(single_var,true)-> 2972 generate_rules(HeadList1,Env,Body1,[],ng(R,Vals),Probs,BDDAnd,0,Clauses,Module,M) 2973 ; 2974 generate_rules(HeadList1,Env,Body1,VC,ng(R,Vals),Probs,BDDAnd,0,Clauses,Module,M) 2975 ). 2976 2977term_expansion_int((Head :- Body),_M, ((H :- Body),[])):- 2978 Head=db(H),!. 2979 2980term_expansion_int((Head :- Body),M, (Clauses,[Rule])):- 2981 M:local_setting(compiling,on), 2982 M:local_setting(depth_bound,true), 2983% disjunctive clause with more than one head atom e depth_bound with individual pars 2984 Head = (_H:A;_), 2985 A=..[t,_P|_], 2986 !, 2987 list2or(HeadList, Head), 2988 list2and(BodyList, Body), 2989 gen_cl_db_t(M,HeadList,BodyList,Clauses,Rule). 2990 2991term_expansion_int((Head :- Body),M, (Clauses,[Rule])):- 2992 M:local_setting(compiling,on), 2993% disjunctive clause with more than one head atom without depth_bound with individual pars 2994 Head = (_H:A;_), 2995 A=..[t,_P|_], 2996 !, 2997 list2or(HeadList0, Head), 2998 append(HeadList0,['':_],HeadList), 2999 list2and(BodyList, Body), 3000 gen_cl_t(M,HeadList,BodyList,Clauses,Rule). 3001 3002term_expansion_int((Head :- Body),M, (Clauses,[rule(R,HeadList,BodyList,true,fixed)])):- 3003 M:local_setting(compiling,on), 3004 M:local_setting(depth_bound,true), 3005% disjunctive clause with more than one head atom e depth_bound, fixed par 3006 Head = (_H:p(_P);_), 3007 !, 3008 list2or(HeadListOr, Head), 3009 process_head_fixed(HeadListOr,M,0,HeadList), 3010 list2and(BodyList, Body), 3011 process_body_db(BodyList,BDD,BDDAnd, DB,[],_Vars,BodyList1,Env,Module,M), 3012 append([slipcover:onec(Env,BDD)],BodyList1,BodyList2), 3013 list2and(BodyList2,Body1), 3014 append(HeadList,BodyList,List), 3015 term_variables(List,VC), 3016 get_next_rule_number(M,R), 3017 get_probs(HeadList,Probs), 3018 (M:local_setting(single_var,true)-> 3019 generate_rules_db(HeadList,Env,Body1,[],R,Probs,DB,BDDAnd,0,Clauses,Module,M) 3020 ; 3021 generate_rules_db(HeadList,Env,Body1,VC,R,Probs,DB,BDDAnd,0,Clauses,Module,M) 3022 ). 3023 3024term_expansion_int((Head :- Body),M, (Clauses,[rule(R,HeadList,BodyList,true,fixed)])):- 3025 M:local_setting(compiling,on), 3026% disjunctive clause with more than one head atom senza depth_bound, fixed par 3027 Head = (_H:p(_P);_), 3028 !, 3029 list2or(HeadListOr, Head), 3030 process_head_fixed(HeadListOr,M,0,HeadList), 3031 list2and(BodyList, Body), 3032 process_body(BodyList,BDD,BDDAnd,[],_Vars,BodyList1,Env,Module,M), 3033 append([slipcover:onec(Env,BDD)],BodyList1,BodyList2), 3034 list2and(BodyList2,Body1), 3035 append(HeadList,BodyList,List), 3036 term_variables(List,VC), 3037 get_next_rule_number(M,R), 3038 get_probs(HeadList,Probs), 3039 (M:local_setting(single_var,true)-> 3040 generate_rules(HeadList,Env,Body1,[],R,Probs,BDDAnd,0,Clauses,Module,M) 3041 ; 3042 generate_rules(HeadList,Env,Body1,VC,R,Probs,BDDAnd,0,Clauses,Module,M) 3043 ). 3044 3045term_expansion_int((Head :- Body),M, (Clauses,[rule(R,HeadList,BodyList,true,tunable)])):- 3046 M:local_setting(compiling,on), 3047 M:local_setting(depth_bound,true), 3048% disjunctive clause with more than one head atom e depth_bound 3049 Head = (_;_), !, 3050 list2or(HeadListOr, Head), 3051 process_head(HeadListOr,M,HeadList), 3052 list2and(BodyList, Body), 3053 process_body_db(BodyList,BDD,BDDAnd, DB,[],_Vars,BodyList1,Env,Module,M), 3054 append([slipcover:onec(Env,BDD)],BodyList1,BodyList2), 3055 list2and(BodyList2,Body1), 3056 append(HeadList,BodyList,List), 3057 term_variables(List,VC), 3058 get_next_rule_number(M,R), 3059 get_probs(HeadList,Probs), 3060 (M:local_setting(single_var,true)-> 3061 generate_rules_db(HeadList,Env,Body1,[],R,Probs,DB,BDDAnd,0,Clauses,Module,M) 3062 ; 3063 generate_rules_db(HeadList,Env,Body1,VC,R,Probs,DB,BDDAnd,0,Clauses,Module,M) 3064 ). 3065 3066term_expansion_int((Head :- Body),M, (Clauses,[rule(R,HeadList,BodyList,true,tunable)])):- 3067 M:local_setting(compiling,on), 3068% disjunctive clause with more than one head atom senza depth_bound 3069 Head = (_;_), !, 3070 list2or(HeadListOr, Head), 3071 process_head(HeadListOr,M,HeadList), 3072 list2and(BodyList, Body), 3073 process_body(BodyList,BDD,BDDAnd,[],_Vars,BodyList1,Env,Module,M), 3074 append([slipcover:onec(Env,BDD)],BodyList1,BodyList2), 3075 list2and(BodyList2,Body1), 3076 append(HeadList,BodyList,List), 3077 term_variables(List,VC), 3078 get_next_rule_number(M,R), 3079 get_probs(HeadList,Probs), 3080 (M:local_setting(single_var,true)-> 3081 generate_rules(HeadList,Env,Body1,[],R,Probs,BDDAnd,0,Clauses,Module,M) 3082 ; 3083 generate_rules(HeadList,Env,Body1,VC,R,Probs,BDDAnd,0,Clauses,Module,M) 3084 ). 3085 3086term_expansion_int((Head :- Body),M, (Clauses,[Rule])) :- 3087% disjunctive clause with a single head atom e DB, con prob. diversa da 1 with individual pars 3088 M:local_setting(compiling,on), 3089 M:local_setting(depth_bound,true), 3090 ((Head:-Body) \= ((sc_expansion(_,_) ):- _ )), 3091 Head = (H:A), 3092 A=..[t,_P|_], 3093 !, 3094 HeadList=[H:A], 3095 list2and(BodyList, Body), 3096 gen_cl_db_t(M,HeadList,BodyList,Clauses,Rule). 3097 3098term_expansion_int((Head :- Body),M, (Clauses,[Rule])):- 3099 M:local_setting(compiling,on), 3100% disjunctive clause with a single head atom without depth_bound with individual pars 3101 Head = (H:A), 3102 A=..[t,_P|_], 3103 !, 3104 HeadList=[H:A], 3105 list2and(BodyList, Body), 3106 gen_cl_t(M,HeadList,BodyList,Clauses,Rule). 3107 3108term_expansion_int((Head :- Body),M, (Clauses,[rule(R,HeadList,BodyList,true,fixed)])) :- 3109% disjunctive clause with a single head atom e DB, con prob. diversa da 1, fixed par 3110 M:local_setting(compiling,on), 3111 M:local_setting(depth_bound,true), 3112 ((Head:-Body) \= ((sc_expansion(_,_) ):- _ )), 3113 Head = (H:p(_)), 3114 !, 3115 list2or(HeadListOr, Head), 3116 process_head_fixed(HeadListOr,M,0,HeadList), 3117 list2and(BodyList, Body), 3118 process_body_db(BodyList,BDD,BDDAnd,DB,[],_Vars,BodyList2,Env,Module,M), 3119 append([slipcover:onec(Env,BDD)],BodyList2,BodyList3), 3120 list2and(BodyList3,Body2), 3121 append(HeadList,BodyList,List), 3122 term_variables(List,VC), 3123 get_next_rule_number(M,R), 3124 get_probs(HeadList,Probs),%***test single_var 3125 (M:local_setting(single_var,true)-> 3126 generate_clause_db(H,Env,Body2,[],R,Probs,DB,BDDAnd,0,Clauses,Module,M) 3127 ; 3128 generate_clause_db(H,Env,Body2,VC,R,Probs,DB,BDDAnd,0,Clauses,Module,M) 3129 ). 3130 3131term_expansion_int((Head :- Body),M, (Clauses,[rule(R,HeadList,BodyList,true,fixed)])) :- 3132% disjunctive clause with a single head atom senza DB, con prob. diversa da 1, fixed par 3133 M:local_setting(compiling,on), 3134 ((Head:-Body) \= ((sc_expansion(_,_) ):- _ )), 3135 Head = (H:p(_)), 3136 !, 3137 list2or(HeadListOr, Head), 3138 process_head_fixed(HeadListOr,M,0,HeadList), 3139 list2and(BodyList, Body), 3140 process_body(BodyList,BDD,BDDAnd,[],_Vars,BodyList2,Env,Module,M), 3141 append([slipcover:onec(Env,BDD)],BodyList2,BodyList3), 3142 list2and(BodyList3,Body2), 3143 append(HeadList,BodyList,List), 3144 term_variables(List,VC), 3145 get_next_rule_number(M,R), 3146 get_probs(HeadList,Probs),%***test single_vars 3147 (M:local_setting(single_var,true)-> 3148 generate_clause(H,Env,Body2,[],R,Probs,BDDAnd,0,Clauses,Module,M) 3149 ; 3150 generate_clause(H,Env,Body2,VC,R,Probs,BDDAnd,0,Clauses,Module,M) 3151 ). 3152 3153term_expansion_int((Head :- Body),M, ([],[])) :- 3154% disjunctive clause with a single head atom con prob. 0 senza depth_bound --> la regola non è caricata nella teoria e non è conteggiata in NR 3155 M:local_setting(compiling,on), 3156 ((Head:-Body) \= ((sc_expansion(_,_) ):- _ )), 3157 Head = (_H:P),number(P),P=:=0.0, !. 3158 3159term_expansion_int((Head :- Body),M, (Clauses,[def_rule(H,BodyList,true)])) :- 3160% disjunctive clause with a single head atom e depth_bound con prob =1 3161 M:local_setting(compiling,on), 3162 M:local_setting(depth_bound,true), 3163 ((Head:-Body) \= ((sc_expansion(_,_) ):- _ )), 3164 list2or(HeadListOr, Head), 3165 process_head(HeadListOr,M,HeadList), 3166 HeadList=[H:_],!, 3167 list2and(BodyList, Body), 3168 process_body_db(BodyList,BDD,BDDAnd,DB,[],_Vars,BodyList2,Env,Module,M), 3169 append([slipcover:onec(Env,BDD)],BodyList2,BodyList3), 3170 list2and(BodyList3,Body1), 3171 add_bdd_arg_db(H,Env,BDDAnd,DBH,Module,Head1), 3172 Clauses=(Head1 :- (DBH>=1,DB is DBH-1,Body1)). 3173 3174term_expansion_int((Head :- Body), M,(Clauses,[def_rule(H,BodyList,true)])) :- 3175% disjunctive clause with a single head atom senza depth_bound con prob =1 3176 M:local_setting(compiling,on), 3177 ((Head:-Body) \= ((sc_expansion(_,_) ):- _ )), 3178 list2or(HeadListOr, Head), 3179 process_head(HeadListOr,M,HeadList), 3180 HeadList=[H:_],!, 3181 list2and(BodyList, Body), 3182 process_body(BodyList,BDD,BDDAnd,[],_Vars,BodyList2,Env,Module,M), 3183 append([slipcover:onec(Env,BDD)],BodyList2,BodyList3), 3184 list2and(BodyList3,Body1), 3185 add_bdd_arg(H,Env,BDDAnd,Module,Head1), 3186 Clauses=(Head1 :- Body1). 3187 3188term_expansion_int((Head :- Body),M, (Clauses,[rule(R,HeadList,BodyList,true,tunable)])) :- 3189% disjunctive clause with a single head atom e DB, con prob. diversa da 1 3190 M:local_setting(compiling,on), 3191 M:local_setting(depth_bound,true), 3192 ((Head:-Body) \= ((sc_expansion(_,_) ):- _ )), 3193 Head = (H:_), !, 3194 list2or(HeadListOr, Head), 3195 process_head(HeadListOr,M,HeadList), 3196 list2and(BodyList, Body), 3197 process_body_db(BodyList,BDD,BDDAnd,DB,[],_Vars,BodyList2,Env,Module,M), 3198 append([slipcover:onec(Env,BDD)],BodyList2,BodyList3), 3199 list2and(BodyList3,Body2), 3200 append(HeadList,BodyList,List), 3201 term_variables(List,VC), 3202 get_next_rule_number(M,R), 3203 get_probs(HeadList,Probs),%***test single_var 3204 (M:local_setting(single_var,true)-> 3205 generate_clause_db(H,Env,Body2,[],R,Probs,DB,BDDAnd,0,Clauses,Module,M) 3206 ; 3207 generate_clause_db(H,Env,Body2,VC,R,Probs,DB,BDDAnd,0,Clauses,Module,M) 3208 ). 3209 3210term_expansion_int((Head :- Body),M, (Clauses,[rule(R,HeadList,BodyList,true,tunable)])) :- 3211% disjunctive clause with a single head atom senza DB, con prob. diversa da 1 3212 M:local_setting(compiling,on), 3213 ((Head:-Body) \= ((sc_expansion(_,_) ):- _ )), 3214 Head = (H:_), !, 3215 list2or(HeadListOr, Head), 3216 process_head(HeadListOr,M,HeadList), 3217 list2and(BodyList, Body), 3218 process_body(BodyList,BDD,BDDAnd,[],_Vars,BodyList2,Env,Module,M), 3219 append([slipcover:onec(Env,BDD)],BodyList2,BodyList3), 3220 list2and(BodyList3,Body2), 3221 append(HeadList,BodyList,List), 3222 term_variables(List,VC), 3223 get_next_rule_number(M,R), 3224 get_probs(HeadList,Probs),%***test single_vars 3225 (M:local_setting(single_var,true)-> 3226 generate_clause(H,Env,Body2,[],R,Probs,BDDAnd,0,Clauses,Module,M) 3227 ; 3228 generate_clause(H,Env,Body2,VC,R,Probs,BDDAnd,0,Clauses,Module,M) 3229 ). 3230 3231term_expansion_int((Head :- Body),M,(Clauses,[])) :- 3232% definite clause for db facts 3233 M:local_setting(compiling,on), 3234 ((Head:-Body) \= ((sc_expansion(_,_)) :- _ )), 3235 Head=db(Head1),!, 3236 Clauses=(Head1 :- Body). 3237 3238term_expansion_int((Head :- Body),M,(Clauses,[def_rule(Head,BodyList,true)])) :- 3239% definite clause with depth_bound 3240 M:local_setting(compiling,on), 3241 M:local_setting(depth_bound,true), 3242 ((Head:-Body) \= ((sc_expansion(_,_)) :- _ )),!, 3243 list2and(BodyList, Body), 3244 process_body_db(BodyList,BDD,BDDAnd,DB,[],_Vars,BodyList2,Env,Module,M), 3245 append([slipcover:onec(Env,BDD)],BodyList2,BodyList3), 3246 list2and(BodyList3,Body1), 3247 add_bdd_arg_db(Head,Env,BDDAnd,DBH,Module,Head1), 3248 Clauses=(Head1 :- (DBH>=1,DB is DBH-1,Body1)). 3249 3250term_expansion_int((Head :- Body),M,(Clauses,[def_rule(Head,BodyList,true)])) :- 3251% definite clause senza DB 3252 M:local_setting(compiling,on), 3253 ((Head:-Body) \= ((sc_expansion(_,_)) :- _ )),!, 3254 list2and(BodyList, Body), 3255 process_body(BodyList,BDD,BDDAnd,[],_Vars,BodyList2,Env,Module,M), 3256 append([slipcover:onec(Env,BDD)],BodyList2,BodyList3), 3257 list2and(BodyList3,Body2), 3258 add_bdd_arg(Head,Env,BDDAnd,Module,Head1), 3259 Clauses=(Head1 :- Body2). 3260 3261term_expansion_int(Head,M,(Clauses,[rule(R,HeadList,[],true,fixed)])) :- 3262 M:local_setting(compiling,on), 3263 M:local_setting(depth_bound,true), 3264% disjunctive FACT with more than one head atom e db, fixed par 3265 Head=(_:p(_);_), !, 3266 list2or(HeadListOr, Head), 3267 process_head_fixed(HeadListOr,M,0,HeadList), 3268 term_variables(HeadList,VC), 3269 get_next_rule_number(M,R), 3270 get_probs(HeadList,Probs), 3271 (M:local_setting(single_var,true)-> 3272 generate_rules_fact_db(HeadList,_Env,[],R,Probs,0,Clauses,_Module,M) 3273 ; 3274 generate_rules_fact_db(HeadList,_Env,VC,R,Probs,0,Clauses,_Module,M) 3275 ). 3276 3277 3278term_expansion_int(Head,M,(Clauses,[rule(R,HeadList,[],true,fixed)])) :- 3279 M:local_setting(compiling,on), 3280% disjunctive fact with more than one head atom senza db, fixed par 3281 Head=(_:p(_);_), !, 3282 list2or(HeadListOr, Head), 3283 process_head_fixed(HeadListOr,M,0,HeadList), 3284 term_variables(HeadList,VC), 3285 get_next_rule_number(M,R), 3286 get_probs(HeadList,Probs), %**** test single_var 3287 (M:local_setting(single_var,true)-> 3288 generate_rules_fact(HeadList,_Env,[],R,Probs,0,Clauses,_Module,M) 3289 ; 3290 generate_rules_fact(HeadList,_Env,VC,R,Probs,0,Clauses,_Module,M) 3291 ). 3292 3293term_expansion_int(Head,M,(Clauses,[Rule])) :- 3294 M:local_setting(compiling,on), 3295 M:local_setting(depth_bound,true), 3296% disjunctive FACT with more than one head atom e db with individual pars 3297 Head = (_H:A;_), 3298 A=..[t,_P|_], 3299 !, 3300 list2or(HeadList0, Head), 3301 append(HeadList0,['':_],HeadList), 3302 gen_cl_db_fact_t(M,HeadList,Clauses,Rule). 3303 3304term_expansion_int(Head,M,(Clauses,[Rule])) :- 3305 M:local_setting(compiling,on), 3306% disjunctive FACT with more than one head atom wo db with individual pars 3307 Head = (_H:A;_), 3308 A=..[t,_P|_], 3309 !, 3310 list2or(HeadList0, Head), 3311 append(HeadList0,['':_],HeadList), 3312 gen_cl_fact_t(M,HeadList,Clauses,Rule). 3313 3314term_expansion_int(Head,M,(Clauses,[rule(R,HeadList,[],true,tunable)])) :- 3315 M:local_setting(compiling,on), 3316 M:local_setting(depth_bound,true), 3317% disjunctive FACT with more than one head atom e db 3318 Head=(_;_), !, 3319 list2or(HeadListOr, Head), 3320 process_head(HeadListOr,M,HeadList), 3321 term_variables(HeadList,VC), 3322 get_next_rule_number(M,R), 3323 get_probs(HeadList,Probs), 3324 (M:local_setting(single_var,true)-> 3325 generate_rules_fact_db(HeadList,_Env,[],R,Probs,0,Clauses,_Module,M) 3326 ; 3327 generate_rules_fact_db(HeadList,_Env,VC,R,Probs,0,Clauses,_Module,M) 3328 ). 3329 3330 3331term_expansion_int(Head,M,(Clauses,[rule(R,HeadList,[],true,tunable)])) :- 3332 M:local_setting(compiling,on), 3333% disjunctive fact with more than one head atom senza db 3334 Head=(_;_), !, 3335 list2or(HeadListOr, Head), 3336 process_head(HeadListOr,M,HeadList), 3337 term_variables(HeadList,VC), 3338 get_next_rule_number(M,R), 3339 get_probs(HeadList,Probs), %**** test single_var 3340 (M:local_setting(single_var,true)-> 3341 generate_rules_fact(HeadList,_Env,[],R,Probs,0,Clauses,_Module,M) 3342 ; 3343 generate_rules_fact(HeadList,_Env,VC,R,Probs,0,Clauses,_Module,M) 3344 ). 3345 3346term_expansion_int(Head,M,([],[])) :- 3347 M:local_setting(compiling,on), 3348% disjunctive fact with a single head atom con prob. 0 3349 (Head \= ((sc_expansion(_,_)) :- _ )), 3350 Head = (_H:P),number(P),P=:=0.0, !. 3351 3352term_expansion_int(Head,M,(Clause,[def_rule(H,[],true)])) :- 3353 M:local_setting(compiling,on), 3354 M:local_setting(depth_bound,true), 3355% disjunctive fact with a single head atom con prob.1 e db 3356 (Head \= ((sc_expansion(_,_)) :- _ )), 3357 Head = (H:P),number(P),P=:=1.0, !, 3358 list2and([slipcover:onec(Env,BDD)],Body1), 3359 add_bdd_arg_db(H,Env,BDD,_DB,_Module,Head1), 3360 Clause=(Head1 :- Body1). 3361 3362term_expansion_int(Head,M,(Clause,[def_rule(H,[],true)])) :- 3363 M:local_setting(compiling,on), 3364% disjunctive fact with a single head atom con prob. 1, senza db 3365 (Head \= ((sc_expansion(_,_)) :- _ )), 3366 Head = (H:P),number(P),P=:=1.0, !, 3367 list2and([slipcover:onec(Env,BDD)],Body1), 3368 add_bdd_arg(H,Env,BDD,_Module,Head1), 3369 Clause=(Head1 :- Body1). 3370 3371term_expansion_int(Head,M,(Clause,[rule(R,HeadList,[],true,fixed)])) :- 3372 M:local_setting(compiling,on), 3373 M:local_setting(depth_bound,true), 3374% disjunctive fact with a single head atom e prob. generiche, con db, fixed par 3375 (Head \= ((sc_expansion(_,_)) :- _ )), 3376 Head=(H:p(_)), !, 3377 list2or(HeadListOr, Head), 3378 process_head_fixed(HeadListOr,M,0,HeadList), 3379 term_variables(HeadList,VC), 3380 get_next_rule_number(M,R), 3381 get_probs(HeadList,Probs), 3382 add_bdd_arg_db(H,Env,BDD,_DB,_Module,Head1), 3383 (M:local_setting(single_var,true)-> 3384 Clause=(Head1:-(slipcover:get_sc_var_n(M,Env,R,[],Probs,V),slipcover:equalityc(Env,V,0,BDD))) 3385 ; 3386 Clause=(Head1:-(slipcover:get_sc_var_n(M,Env,R,VC,Probs,V),slipcover:equalityc(Env,V,0,BDD))) 3387 ). 3388 3389term_expansion_int(Head,M,(Clause,[rule(R,HeadList,[],true,fixed)])) :- 3390 M:local_setting(compiling,on), 3391% disjunctive fact with a single head atom e prob. generiche, senza db, fixed par 3392 (Head \= ((sc_expansion(_,_)) :- _ )), 3393 Head=(H:p(_)), !, 3394 list2or(HeadListOr, Head), 3395 process_head_fixed(HeadListOr,M,0,HeadList), 3396 term_variables(HeadList,VC), 3397 get_next_rule_number(M,R), 3398 get_probs(HeadList,Probs), 3399 add_bdd_arg(H,Env,BDD,_Module,Head1),%***test single_var 3400 (M:local_setting(single_var,true)-> 3401 Clause=(Head1:-(slipcover:get_sc_var_n(M,Env,R,[],Probs,V),slipcover:equalityc(Env,V,0,BDD))) 3402 ; 3403 Clause=(Head1:-(slipcover:get_sc_var_n(M,Env,R,VC,Probs,V),slipcover:equalityc(Env,V,0,BDD))) 3404 ). 3405 3406 3407term_expansion_int(Head,M,(Clauses,[Rule])) :- 3408 M:local_setting(compiling,on), 3409 M:local_setting(depth_bound,true), 3410% disjunctive FACT with a sigble head atom e db with individual pars 3411 Head = (H:A), 3412 A=..[t,_P|_], 3413 !, 3414 HeadList=[H:0.5,'':0.5], 3415 gen_cl_db_fact_t(M,HeadList,Clauses,Rule). 3416 3417term_expansion_int(Head,M,(Clauses,[Rule])) :- 3418 M:local_setting(compiling,on), 3419% disjunctive FACT with a single head atom wo db with individual pars 3420 Head = (H:A), 3421 A=..[t,_P|_], 3422 !, 3423 HeadList=[H:0.5,'':0.5], 3424 gen_cl_fact_t(M,HeadList,Clauses,Rule). 3425 3426term_expansion_int(Head,M,(Clause,[rule(R,HeadList,[],true,tunable)])) :- 3427 M:local_setting(compiling,on), 3428 M:local_setting(depth_bound,true), 3429% disjunctive fact with a single head atom e prob. generiche, con db 3430 (Head \= ((sc_expansion(_,_)) :- _ )), 3431 Head=(H:_), !, 3432 list2or(HeadListOr, Head), 3433 process_head(HeadListOr,M,HeadList), 3434 term_variables(HeadList,VC), 3435 get_next_rule_number(M,R), 3436 get_probs(HeadList,Probs), 3437 add_bdd_arg_db(H,Env,BDD,_DB,_Module,Head1), 3438 (M:local_setting(single_var,true)-> 3439 Clause=(Head1:-(slipcover:get_sc_var_n(M,Env,R,[],Probs,V),slipcover:equalityc(Env,V,0,BDD))) 3440 ; 3441 Clause=(Head1:-(slipcover:get_sc_var_n(M,Env,R,VC,Probs,V),slipcover:equalityc(Env,V,0,BDD))) 3442 ). 3443 3444term_expansion_int(Head,M,(Clause,[rule(R,HeadList,[],true,tunable)])) :- 3445 M:local_setting(compiling,on), 3446% disjunctive fact with a single head atom e prob. generiche, senza db 3447 (Head \= ((sc_expansion(_,_)) :- _ )), 3448 Head=(H:_), !, 3449 list2or(HeadListOr, Head), 3450 process_head(HeadListOr,M,HeadList), 3451 term_variables(HeadList,VC), 3452 get_next_rule_number(M,R), 3453 get_probs(HeadList,Probs), 3454 add_bdd_arg(H,Env,BDD,_Module,Head1),%***test single_var 3455 (M:local_setting(single_var,true)-> 3456 Clause=(Head1:-(slipcover:get_sc_var_n(M,Env,R,[],Probs,V),slipcover:equalityc(Env,V,0,BDD))) 3457 ; 3458 Clause=(Head1:-(slipcover:get_sc_var_n(M,Env,R,VC,Probs,V),slipcover:equalityc(Env,V,0,BDD))) 3459 ). 3460 3461term_expansion_int(Head,M, ((Head1:-slipcover:onec(Env,One)),[def_rule(Head,[],true)])) :- 3462 M:local_setting(compiling,on), 3463 M:local_setting(depth_bound,true), 3464% definite fact with db 3465 (Head \= ((sc_expansion(_,_) ):- _ )), 3466 (Head\= end_of_file),!, 3467 add_bdd_arg_db(Head,Env,One,_DB,_Module,Head1). 3468 3469term_expansion_int(Head,M, ((Head1:-slipcover:onec(Env,One)),[def_rule(Head,[],true)])) :- 3470 M:local_setting(compiling,on), 3471% definite fact without db 3472 (Head \= ((sc_expansion(_,_) ):- _ )), 3473 (Head\= end_of_file),!, 3474 add_bdd_arg(Head,Env,One,_Module,Head1). 3475 3476/*-----------*/ 3477 3478 3479 3480:- multifile sandbox:safe_meta/2. 3481 3482sandbox:safe_meta(slipcover:induce_par(_,_) ,[]). 3483sandbox:safe_meta(slipcover:induce(_,_), []). 3484sandbox:safe_meta(slipcover:get_node(_,_), []). 3485sandbox:safe_meta(slipcover:test_prob(_,_,_,_,_,_), []). 3486sandbox:safe_meta(slipcover:test(_,_,_,_,_,_,_), []). 3487sandbox:safe_meta(slipcover:set_sc(_,_), []). 3488sandbox:safe_meta(slipcover:setting_sc(_,_), []). 3489 3490 3491 3492test_no_area(TestSet,M,NPos,NNeg,CLL,Results):- 3493 test_folds(TestSet,M,[],Results,0,NPos,0,NNeg,0,CLL). 3494 3495 3496test_folds([],_M,LG,LG,Pos,Pos,Neg,Neg,CLL,CLL). 3497 3498test_folds([HT|TT],M,LG0,LG,Pos0,Pos,Neg0,Neg,CLL0,CLL):- 3499 test_1fold(HT,M,LG1,Pos1,Neg1,CLL1), 3500 append(LG0,LG1,LG2), 3501 Pos2 is Pos0+Pos1, 3502 Neg2 is Neg0+Neg1, 3503 CLL2 is CLL0+CLL1, 3504 test_folds(TT,M,LG2,LG,Pos2,Pos,Neg2,Neg,CLL2,CLL). 3505 3506test_1fold(F,M,LGOrd,Pos,Neg,CLL1):- 3507 find_ex(F,M,LG,Pos,Neg), 3508 compute_CLL_atoms(LG,M,0,0,CLL1,LG1), 3509 keysort(LG1,LGOrd). 3510 3511 3512find_ex(DB,M,LG,Pos,Neg):- 3513 findall(P/A,M:output(P/A),LP), 3514 M:local_setting(neg_ex,given),!, 3515 find_ex_pred(LP,M,DB,[],LG,0,Pos,0,Neg). 3516 3517find_ex(DB,M,LG,Pos,Neg):- 3518 findall(P/A,M:output(P/A),LP), 3519 M:local_setting(neg_ex,cw), 3520 find_ex_pred_cw(LP,M,DB,[],LG,0,Pos,0,Neg). 3521 3522 3523find_ex_pred([],_M,_DB,LG,LG,Pos,Pos,Neg,Neg). 3524 3525find_ex_pred([P/A|T],M,DB,LG0,LG,Pos0,Pos,Neg0,Neg):- 3526 functor(At,P,A), 3527 find_ex_db(DB,M,At,LG0,LG1,Pos0,Pos1,Neg0,Neg1), 3528 find_ex_pred(T,M,DB,LG1,LG,Pos1,Pos,Neg1,Neg). 3529 3530find_ex_db([],_M,_At,LG,LG,Pos,Pos,Neg,Neg). 3531 3532find_ex_db([H|T],M,At,LG0,LG,Pos0,Pos,Neg0,Neg):- 3533 At=..[P|L], 3534 At1=..[P,H|L], 3535 findall(At1,M:At1,LP), 3536 findall(\+ At1,M:neg(At1),LN), 3537 length(LP,NP), 3538 length(LN,NN), 3539 append([LG0,LP,LN],LG1), 3540 Pos1 is Pos0+NP, 3541 Neg1 is Neg0+NN, 3542 find_ex_db(T,M,At,LG1,LG,Pos1,Pos,Neg1,Neg). 3543 3544 3545find_ex_pred_cw([],_M,_DB,LG,LG,Pos,Pos,Neg,Neg). 3546 3547find_ex_pred_cw([P/A|T],M,DB,LG0,LG,Pos0,Pos,Neg0,Neg):- 3548 functor(At,P,A), 3549 findall(Types,get_types(At,M,Types),LT), 3550 append(LT,LLT), 3551 remove_duplicates(LLT,Types1), 3552 find_ex_db_cw(DB,M,At,Types1,LG0,LG1,Pos0,Pos1,Neg0,Neg1), 3553 find_ex_pred_cw(T,M,DB,LG1,LG,Pos1,Pos,Neg1,Neg). 3554 3555get_types(At,_M,[]):- 3556 At=..[_],!. 3557 3558get_types(At,M,Types):- 3559 M:modeh(_,At), 3560 At=..[_|Args], 3561 get_args(Args,Types). 3562 3563get_types(At,M,Types):- 3564 M:modeh(_,HT,_,_), 3565 member(At,HT), 3566 At=..[_|Args], 3567 get_args(Args,Types). 3568 3569 3570get_args([],[]). 3571 3572get_args([+H|T],[H|T1]):-!, 3573 get_args(T,T1). 3574 3575get_args([-H|T],[H|T1]):-!, 3576 get_args(T,T1). 3577 3578get_args([#H|T],[H|T1]):-!, 3579 get_args(T,T1). 3580 3581get_args([-#H|T],[H|T1]):-!, 3582 get_args(T,T1). 3583 3584get_args([H|T],[H|T1]):- 3585 get_args(T,T1). 3586 3587 3588 3589 3590get_constants([],_M,_Mod,[]). 3591 3592get_constants([Type|T],M,Mod,[(Type,Co)|C]):- 3593 find_pred_using_type(Type,Mod,LP), 3594 find_constants(LP,M,Mod,[],Co), 3595 get_constants(T,M,Mod,C). 3596 3597find_pred_using_type(T,M,L):- 3598 (setof((P,Ar,A),pred_type(T,M,P,Ar,A),L)-> 3599 true 3600 ; 3601 L=[] 3602 ). 3603 3604pred_type(T,M,P,Ar,A):- 3605 M:modeh(_,S), 3606 S=..[P|Args], 3607 length(Args,Ar), 3608 scan_args(Args,T,1,A). 3609 3610pred_type(T,M,P,Ar,A):- 3611 M:modeb(_,S), 3612 S=..[P|Args], 3613 length(Args,Ar), 3614 scan_args(Args,T,1,A). 3615 3616scan_args([+T|_],T,A,A):-!. 3617 3618scan_args([-T|_],T,A,A):-!. 3619 3620scan_args([#T|_],T,A,A):-!. 3621 3622scan_args([-#T|_],T,A,A):-!. 3623 3624scan_args([_|Tail],T,A0,A):- 3625 A1 is A0+1, 3626 scan_args(Tail,T,A1,A). 3627 3628find_constants([],_M,_Mod,C,C). 3629 3630find_constants([(P,Ar,A)|T],M,Mod,C0,C):- 3631 gen_goal(1,Ar,A,Args,ArgsNoV,V), 3632 G=..[P,M|Args], 3633 (setof(V,ArgsNoV^call_goal(Mod,G),LC)-> 3634 true 3635 ; 3636 LC=[] 3637 ), 3638 append(C0,LC,C1), 3639 remove_duplicates(C1,C2), 3640 find_constants(T,M,Mod,C2,C). 3641 3642call_goal(M,G):- 3643 M:G. 3644 3645gen_goal(Arg,Ar,_A,[],[],_):- 3646 Arg =:= Ar+1,!. 3647 3648gen_goal(A,Ar,A,[V|Args],ArgsNoV,V):-!, 3649 Arg1 is A+1, 3650 gen_goal(Arg1,Ar,A,Args,ArgsNoV,V). 3651 3652gen_goal(Arg,Ar,A,[ArgV|Args],[ArgV|ArgsNoV],V):- 3653 Arg1 is Arg+1, 3654 gen_goal(Arg1,Ar,A,Args,ArgsNoV,V). 3655 3656 3657 3658find_ex_db_cw([],_M,_At,_Ty,LG,LG,Pos,Pos,Neg,Neg). 3659 3660find_ex_db_cw([H|T],M,At,Types,LG0,LG,Pos0,Pos,Neg0,Neg):- 3661 get_constants(Types,H,M,C), 3662 At=..[P|L], 3663 get_types(At,M,TypesA),!, 3664 length(L,N), 3665 length(LN,N), 3666 At1=..[P,H|LN], 3667 findall(At1,M:At1,LP), 3668 (setof(\+ At1,neg_ex(LN,M,TypesA,At1,C),LNeg)->true;LNeg=[]), 3669 length(LP,NP), 3670 length(LNeg,NN), 3671 append([LG0,LP,LNeg],LG1), 3672 Pos1 is Pos0+NP, 3673 Neg1 is Neg0+NN, 3674 find_ex_db_cw(T,M,At,Types,LG1,LG,Pos1,Pos,Neg1,Neg). 3675 3676neg_ex([],M,[],At1,_C):- 3677 \+ M:At1. 3678 3679neg_ex([H|T],M,[HT|TT],At1,C):- 3680 member((HT,Co),C), 3681 member(H,Co), 3682 neg_ex(T,M,TT,At1,C). 3683 3684compute_CLL_atoms([],_M,_N,CLL,CLL,[]):-!. 3685 3686compute_CLL_atoms([\+ H|T],M,N,CLL0,CLL1,[PG- (\+ H)|T1]):-!, 3687 init(Env), 3688 abolish_all_tables, 3689 get_node(H,M,Env,BDD),!, 3690 ret_prob(Env,BDD,PG), 3691 end(Env),!, 3692 PG1 is 1-PG, 3693 (PG1=:=0.0-> 3694 M:local_setting(logzero,LZ), 3695 CLL2 is CLL0+LZ 3696 ; 3697 CLL2 is CLL0+ log(PG1) 3698 ), 3699 N1 is N+1, 3700 compute_CLL_atoms(T,M,N1,CLL2,CLL1,T1). 3701 3702compute_CLL_atoms([H|T],M,N,CLL0,CLL1,[PG-H|T1]):- 3703 init(Env), 3704 abolish_all_tables, 3705 get_node(H,M,Env,BDD),!, 3706 ret_prob(Env,BDD,PG), 3707 end(Env),!, 3708 (PG=:=0.0-> 3709 M:local_setting(logzero,LZ), 3710 CLL2 is CLL0+LZ 3711 ; 3712 CLL2 is CLL0+ log(PG) 3713 ), 3714 N1 is N+1, 3715 compute_CLL_atoms(T,M,N1,CLL2,CLL1,T1).
write(Message)
if the verbosity is at least 2.
Module is used to get the verbosity setting
/
3724write2(M,A):-
3725 M:local_setting(verbosity,Ver),
3726 (Ver>1->
3727 write(A)
3728 ;
3729 true
3730 ).
write(Message)
if the verbosity is at least 3.
Module is used to get the verbosity setting.
/
3737write3(M,A):-
3738 M:local_setting(verbosity,Ver),
3739 (Ver>2->
3740 write(A)
3741 ;
3742 true
3743 ).
3750nl2(M):-
3751 M:local_setting(verbosity,Ver),
3752 (Ver>1->
3753 nl
3754 ;
3755 true
3756 ).
3763nl3(M):-
3764 M:local_setting(verbosity,Ver),
3765 (Ver>2->
3766 nl
3767 ;
3768 true
3769 ).
format(Format,Arguments)
if the verbosity is at least 2.
Module is used to get the verbosity setting.
/
3776format2(M,A,B):-
3777 M:local_setting(verbosity,Ver),
3778 (Ver>1->
3779 format(A,B)
3780 ;
3781 true
3782 ).
format(Format,Arguments)
if the verbosity is at least 3.
Module is used to get the verbosity setting.
/
3789format3(M,A,B):-
3790 M:local_setting(verbosity,Ver),
3791 (Ver>2->
3792 format(A,B)
3793 ;
3794 true
3795 ).
3802write_rules2(M,A,B):-
3803 M:local_setting(verbosity,Ver),
3804 (Ver>1->
3805 write_rules(A,B)
3806 ;
3807 true
3808 ).
3815write_rules3(M,A,B):- 3816 M:local_setting(verbosity,Ver), 3817 (Ver>2-> 3818 write_rules(A,B) 3819 ; 3820 true 3821 ). 3822 3823 3824write_disj_clause2(M,A,B):- 3825 M:local_setting(verbosity,Ver), 3826 (Ver>1-> 3827 write_disj_clause(A,B) 3828 ; 3829 true 3830 ). 3831 3832write_disj_clause3(M,A,B):- 3833 M:local_setting(verbosity,Ver), 3834 (Ver>2-> 3835 write_disj_clause(A,B) 3836 ; 3837 true 3838 ). 3839 3840write_body2(M,A,B):- 3841 M:local_setting(verbosity,Ver), 3842 (Ver>1-> 3843 write_body(A,B) 3844 ; 3845 true 3846 ). 3847 3848write_body3(M,A,B):- 3849 M:local_setting(verbosity,Ver), 3850 (Ver>2-> 3851 write_body(A,B) 3852 ; 3853 true 3854 ).
3863tab(M,A/B,P):-
3864 length(Args0,B),
3865 (M:local_setting(depth_bound,true)->
3866 ExtraArgs=[_,_,_,lattice(slipcover:orc/3)]
3867 ;
3868 ExtraArgs=[_,_,lattice(slipcover:orc/3)]
3869 ),
3870 append(Args0,ExtraArgs,Args),
3871 P=..[A|Args],
3872 PT=..[A|Args0],
3873 (M:tabled(PT)->
3874 true
3875 ;
3876 assert(M:tabled(PT))
3877 ).
3884zero_clause(M,A/B,(H:-maplist(nonvar,Args0),slipcover:zeroc(Env,BDD))):- 3885 B1 is B+1, 3886 length(Args0,B1), 3887 (M:local_setting(depth_bound,true)-> 3888 ExtraArgs=[_,Env,BDD] 3889 ; 3890 ExtraArgs=[Env,BDD] 3891 ), 3892 append(Args0,ExtraArgs,Args), 3893 H=..[A|Args]. 3894 3895 3896 3897 3898sc_expansion((:- begin_bg), []) :- 3899 prolog_load_context(module, M), 3900 sc_input_mod(M),!, 3901 assert(M:bg_on). 3902 3903sc_expansion(C, M:bgc(C)) :- 3904 prolog_load_context(module, M), 3905 C\= (:- end_bg), 3906 sc_input_mod(M), 3907 M:bg_on,!. 3908 3909sc_expansion((:- end_bg), []) :- 3910 prolog_load_context(module, M), 3911 sc_input_mod(M),!, 3912 retractall(M:bg_on), 3913 findall(C,M:bgc(C),L), 3914 retractall(M:bgc(_)), 3915 (M:bg(BG0)-> 3916 retract(M:bg(BG0)), 3917 append(BG0,L,BG), 3918 assert(M:bg(BG)) 3919 ; 3920 assert(M:bg(L)) 3921 ). 3922 3923sc_expansion((:- begin_in), []) :- 3924 prolog_load_context(module, M), 3925 sc_input_mod(M),!, 3926 assert(M:in_on). 3927 3928sc_expansion(C, M:inc(C)) :- 3929 prolog_load_context(module, M), 3930 C\= (:- end_in), 3931 sc_input_mod(M), 3932 M:in_on,!. 3933 3934sc_expansion((:- end_in), []) :- 3935 prolog_load_context(module, M), 3936 sc_input_mod(M),!, 3937 retractall(M:in_on), 3938 findall(C,M:inc(C),L), 3939 retractall(M:inc(_)), 3940 (M:in(IN0)-> 3941 retract(M:in(IN0)), 3942 append(IN0,L,IN), 3943 assert(M:in(IN)) 3944 ; 3945 assert(M:in(L)) 3946 ). 3947 3948sc_expansion(begin(model(I)), []) :- 3949 prolog_load_context(module, M), 3950 sc_input_mod(M),!, 3951 retractall(M:model(_)), 3952 assert(M:model(I)), 3953 assert(M:int(I)). 3954 3955sc_expansion(end(model(_I)), []) :- 3956 prolog_load_context(module, M), 3957 sc_input_mod(M),!, 3958 retractall(M:model(_)). 3959 3960sc_expansion(output(P/A), [output(P/A)|TabDir]) :- 3961 prolog_load_context(module, M), 3962 sc_input_mod(M), 3963 M:local_setting(tabling,auto),!, 3964 tab(M,P/A,P1), 3965 zero_clause(M,P/A,Z), 3966 system:term_expansion((:- table P1),TabDir), 3967 assert(M:zero_clauses([Z])). 3968 3969sc_expansion(input(P/A), [input(P/A)|TabDir]) :- 3970 prolog_load_context(module, M), 3971 sc_input_mod(M), 3972 M:local_setting(tabling,auto),!, 3973 tab(M,P/A,P1), 3974 zero_clause(M,P/A,Z), 3975 system:term_expansion((:- table P1),TabDir), 3976 assert(M:zero_clauses([Z])). 3977 3978sc_expansion(At, A) :- 3979 prolog_load_context(module, M), 3980 sc_input_mod(M), 3981 M:model(Name), 3982 At \= (_ :- _), 3983 At \= end_of_file, 3984 (At=neg(Atom)-> 3985 Atom=..[Pred|Args], 3986 Atom1=..[Pred,Name|Args], 3987 A=neg(Atom1) 3988 ; 3989 (At=prob(Pr)-> 3990 A='$prob'(Name,Pr) 3991 ; 3992 At=..[Pred|Args], 3993 Atom1=..[Pred,Name|Args], 3994 A=Atom1 3995 ) 3996 ). 3997 3998:- thread_local sc_file/1. 3999 4000userterm_expansion((:- sc), []) :-!, 4001 prolog_load_context(source, Source), 4002 asserta(sc_file(Source)), 4003 prolog_load_context(module, M), 4004 retractall(M:local_setting(_,_)), 4005 findall(local_setting(P,V),default_setting_sc(P,V),L), 4006 assert_all(L,M,_), 4007 assert(sc_input_mod(M)), 4008 retractall(M:rule_sc_n(_)), 4009 assert(M:rule_sc_n(0)), 4010 retractall(M:rule_ng_sc_n(_)), 4011 assert(M:rule_ng_sc_n(0)), 4012 M:dynamic((modeh/2,modeh/4,modeb/2,fixed_rule/3,banned/2,lookahead/2, 4013 lookahead_cons/2,lookahead_cons_var/2,'$prob'/2,output/1,input/1,input_cw/1, 4014 ref_clause/1,ref/1,model/1,neg/1,rule/5,determination/2, 4015 bg_on/0,bg/1,bgc/1,in_on/0,in/1,inc/1,int/1,v/3, 4016 query_rule/4,database/1, 4017 zero_clauses/1,tabled/1, 4018 fold/2)), 4019 retractall(M:tabled(_)), 4020 style_check(-discontiguous). 4021 4022userterm_expansion(end_of_file, C) :- 4023 sc_file(Source), 4024 prolog_load_context(source, Source), 4025 retractall(sc_file(Source)), 4026 prolog_load_context(module, M), 4027 sc_input_mod(M),!, 4028 retractall(sc_input_mod(M)), 4029 make_dynamic(M), 4030 findall(LZ,M:zero_clauses(LZ),L0), 4031 append(L0,L), 4032 retractall(M:zero_clauses(_)), 4033% retractall(M:tabled(_)), 4034 %retractall(sc_input_mod(M)), 4035 append(L,[(:- style_check(+discontiguous)),end_of_file],C). 4036 4037userterm_expansion(In, Out) :- 4038 \+ current_prolog_flag(xref, true), 4039 sc_file(Source), 4040 prolog_load_context(source, Source), 4041 sc_expansion(In, Out)
slipcover
This module performs learning over Logic Programs with Annotated Disjunctions and CP-Logic programs. It performs both parameter and structure learning.
See https://friguzzi.github.io/cplint/ for details.
Reexports bddem