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