constraint_to_store( spy(Op), InStore, InStore ) :- !, spy_message( Op, InStore ). constraint_to_store( static_distribution(Var,Dist), Store, Store ) :- !, Goal = static_distribution(Var,Dist), must_be( pfd_var(Var), Goal, 1 ), variables_to_roots_active( [Var], Store, Roots, Active ), ( nth1( Nth, Roots, Var-_Data ) -> % add to appendix findall( El-BranchPr, ( label_roots( Roots, Labels, LabPrbs ), rationals_multiplication_list( LabPrbs, LPrb ), probe_variables( Active, Labels, LPrb, Probed, BranchPr ), dbg( probed(Probed)-BranchPr ), % ( probe_variables( Roots, Active, [], Probed, 1/1, BranchPr ), % probed_predicate_is_in_event( PrlgCnstr, PFdIs, PrlgVs, Probed ) nth1( Nth, Probed, Var-El ) ), UnordDist ) ; active_selects( [Var], Active, [Var-VarData] ), data_choose( dmn(Fd), VarData ), Predicate = (El==Val), findall( El-BranchPr, ( member( El, Fd ), dbg( element(El) ), label_roots( Roots, Labels, LabPrbs ), rationals_multiplication_list( LabPrbs, LPrb ), probe_variables( Active, Labels, LPrb, Probed, BranchPr ), % probe_variables( Roots, Active, [], Probed, 1/1, BranchPr ), dbg( probed(Probed)-BranchPr ), probed_predicate_is_in_event( Predicate, [Var], [Val], Probed ) % nth1( _NthSb, Probed, Var-El ) ), UnordDist ) ), keysort( UnordDist, SortedFragDist ), collate_el_prb_pairs( SortedFragDist, Dist). constraint_to_store( domain_cardinality(Var,Card), Store, Store ) :- !, Goal = domain_cardinality(Var,Card), must_be( pfd_var(Var), Goal, 1 ), single_enquiry_for_store( act(Active), Store ), active_selects( [Var], Active, [Var-VarData] ), data_choose( dmn(Fd), VarData ), length( Fd, Card ). constraint_to_store( label_n(LabelMethod,Vars,Vals,Prob,AccPr), InStore, OutStore ) :- ( LabelMethod == rev_pr_order -> OrderOp = '<', abort ; LabelMethod == pr_order, OrderOp = '>' ), store_enquire( InStore, [act(Active)] ), active_selects_del( Vars, Active, VarToDataList, RemAct ), data_choices_for_label_n( VarToDataList, Meths, Fds, Nds ), method_pfd_constract_act_many( Meths, Fds, OrderOp, RemAct, Pairs ), next_probability_sum_counter( Counter ), assert( probability_sum(Counter,0/1) ), % the following imposes a (hopefuly that the only extra one) % restriction in that no Var in Vars can be defn dependant on % another variable in Var. probe_n( LabelMethod, Pairs, Vals, _ValPrbs, Prob ), % remove _ValPrbs all the way back data_update_dmns( Vals, VarToDataList, NewVarToData ), active_additions( NewVarToData, RemAct, NewAct ), dependent_values_satisfies_all( Nds, Vals, NewAct ), probability_sum( Counter, OldAccPr ), retractall( (probability_sum(Counter,_VOA)) ), rationals_addition( OldAccPr, Prob, AccPr ), rationals_dilute( AccPr, DilutPrb, 10000 ), assert( probability_sum(Counter,DilutPrb) ), single_update_store( act(NewAct), InStore, OutStore ). constraint_to_store( label(Var,Val,Prob,AccPr), InStore, OutStore ) :- constraint_to_store( label(Var,dmn_order,Val,Prob,AccPr), InStore, OutStore ). constraint_to_store( label(Var,LMeth,Val,Prob,AccPr), InStore, OutStore ) :- store_enquire( InStore, [act(Active)] ), active_selects_del( [Var], Active, [Var-VarData], RemAct ), retractall( (probability_sum(Var,_AnyOldAccPr)) ), assert( probability_sum(Var,0/1) ), data_choices( [mtd(Method),dmn(Fd),nds(Nd)], VarData ), method_pfd_constract_act( Method, Fd, RemAct, CnDom, CnProbs ), probe( LMeth, CnDom, CnProbs, Val, Prob ), dependent_value_satisfies_all( Nd, Val, Active ), probability_sum( Var, OldAccPr ), retractall( (probability_sum(Var,_VOA)) ), rationals_addition( OldAccPr, Prob, AccPr ), assert( probability_sum(Var,AccPr) ), data_update( dmn(Val), VarData, NewData ), active_additions( [Var-NewData], RemAct, NewAct ), single_update_store( act(NewAct), InStore, OutStore ). constraint_to_store( ~(Var,Method), InStore, OutStore ) :- % constraint_to_store( pin(Var,Method), InStore, OutStore ) :- next_var( Var, Method, InStore, OutStore ). constraint_to_store( ~~(Var,Method), InStore, OutStore ) :- % constraint_to_store( fpin(Var,Method), InStore, OutStore ) :- next_fdi_var( Var, Method, InStore, OutStore ). constraint_to_store( ~-(Var,Method), InStore, OutStore ) :- next_var( Var, Method, InStore, OutStore ), register_mass_loss_function_for( Var ). constraint_to_store( ~~-(Var,Method), InStore, OutStore ) :- next_fdi_var( Var, Method, InStore, OutStore ), register_mass_loss_function_for( Var ). constraint_to_store( conditional(DepPairs,Op,QlfCn), InStore, OutStore ) :- conditional_op( Op ), !, store_enquire( InStore, [fdi(FdIs)] ), bi_unconditional_constraint( QlfCn, FdIs, Q, Qvs, Qpvars, Zs ), ( Op == (++) -> bi_unconditional_constraint_pairs( DepPairs, FdIs, Zs, DPas, Dv, Dpvar ), % bi_unconditional_constraint_pairs( DepPairs, Zs, DPas, [Dv], [Dpvar] ), Reqs = (DPas,onevar,Q,Dv,Qvs,Zs), % write( reqs(DPas,onevar,Q,Dv,Qvs,Zs) ), nl, constraint_to_store_conditional( Dpvar, Qpvars, Reqs, InStore, OutStore ) ; ( Op = (\>) -> bi_unconditional_ind_const_pairs( DepPairs, FdIs, Zs, [], [], Dv, DPas, Dpvs ), % fixme: _Qv1 was Qv (singleton in if with its mention on other branch Reqs = (DPas,multivar,Q,Dv,_Qv1,Zs), constraint_to_store_clist( Dpvs, Qpvars, Reqs, InStore, OutStore ) ; DepPairs = DepCn:PiIn, in_num_to_fraction( PiIn, (DepCn::PiIn++QlfCn), Pi ), dep_unconditional_constraint( DepCn, D, Dv, Dpvar, Zs ), % fixme: _Qv2 was Qv (singleton in if with its mention on other branch Reqs = (D,Pi,Q,Dv,_Qv2,Zs), constraint_to_store_conditional( Dpvar, Qpvars, Reqs, InStore, OutStore ) ) ). constraint_to_store( conditional(DepVarCn,PiIn,QlfCn), InStore, OutStore ) :- in_num_to_fraction( PiIn, (DepVarCn++Pi::QlfCn), Pi ), store_enquire( InStore, [fdi(FdIs)] ), bi_unconditional_constraint( QlfCn, FdIs, Q, Qv, Qpvars, Zs ), dep_unconditional_constraint( DepVarCn, FdIs, D, Dv, Dpvar, Zs ), Reqs = (D,Pi,Q,Dv,Qv,Zs), constraint_to_store_conditional( Dpvar, Qpvars, Reqs, InStore, OutStore ). % dbg( cond_out(OutStore) ). constraint_to_store( cond_diff(DepVar,PiIn,Var), InStore, OutStore ) :- in_num_to_fraction( PiIn, (DepVar#Pi:Var), Pi ), % constraint_to_store_conditional( DepVar, [Var], cond_diff(Pi), InStore, OutStore ). ( Pi = 1/1 -> Dep = [(DepVar \= W) : Pi] ; Dep = [(DepVar \= W) : PiIn,(DepVar == W) : (1 - PiIn)] ), Qlf = (Var = W), constraint_to_store( conditional(Dep,++,Qlf), InStore, OutStore ). /* Bucket algorithm constraint_to_store( prob(Event,Prob), Store, Store ) :- store_enquire( Store, fdi(FdIs) ), pfd_to_prolog_predicate( Event, FdIs, CallEvent, PFdIs, PrlgVs ), variables_to_active_tord( PFdIs, Store, Active ), % Active preserves the graph induced topological order. probe_active_statics( Active, ProbeStatics ), probe_event_in_statics( CallEvent, PFdIs, PrlgVs, ProbeStatics, Prob ). */ constraint_to_store( prob(Event,Prob), Store, Store ) :- store_enquire( Store, fdi(FdIs) ), pfd_to_prolog_predicate( Event, FdIs, CallEvent, PFdIs, PrlgVs ), variables_to_roots_active( PFdIs, Store, Roots, Active ), % variables_to_roots_active( PFdIs, Store, [Root,Other], PreActive ), % write( preactive(PreActive) ), nl, % append( PreActive, [Other], Active ), % write( variables_to_roots_active( PFdIs, Store, Roots, Active ) ), nl, % dbg( variables_to_roots_active( PFdIs, Store, Roots, Active ) ), % findall( BranchPr, % ( dbg( roots(Roots) ), nl, findall( BranchPr, ( label_roots( Roots, Labels, LabPrbs ), rationals_multiplication_list( LabPrbs, LPrb ), probe_variables( Active, Labels, LPrb, Probed, BranchPr ), % probe_variables( Active, Roots, Probed ), dbg( probed(Probed)-BranchPr ), % dbg( probe_event_in_statics( CallEvent, PFdIs, PrlgVs, Probed ) ), % probe_event_in_statics( CallEvent, PFdIs, PrlgVs, Probed, Prob ), probe_event_in_labels( CallEvent, PFdIs, PrlgVs, Probed ), dbg( successful(CallEvent) ) ), Probabilities ), % dbg( outside_findall ), rationals_add_list( Probabilities, Prob ). label_roots( [], [], [] ). label_roots( [V-ActV|T], [V-El|TLabs], [HPrb|TPrbs] ) :- data_choices( [mtd(Method),dmn(Fd)], ActV ), method_apply( Method, Fd, Prbs ), kv_compose( Fd, Prbs, Static ), (var(V) -> data_choose( clpfd_dmn(ClpFd), ActV ), kv_compose( ClpFd, Static, Trips ), member( V-(El-HPrb), Trips ) ; member( El-HPrb, Static ) ), label_roots( T, TLabs, TPrbs ). variables_to_active_tord( Vars, Store, ResActive ) :- store_enquire( Store, [act(Active),gr(Graph)] ), % write( roots(Roots) ), nl, graph_variables_reach_ord( Vars, Graph, ReachRev ), reverse( ReachRev, Reach ), dbg( rev(graph_variables_reach_ord(Vars,Graph,Reach)) ), active_selects( Reach, Active, ResActive ). variables_to_roots_active( Vars, Store, ResRoots, ResActive ) :- store_enquire( Store, [act(Active),rts(Roots),gr(Graph)] ), graph_variables_reach( Vars, Graph, [], Reach ), dbg( graph_variables_reach( Vars, Graph, [], Reach ) ), active_split_roots( Active, Roots, Reach, ResRoots, ResActive ), % Bucket Testing. graph_variables_reach_ord( Vars, Graph, ReachRev ), reverse( ReachRev, ReachOrd ), dbg( graph_variables_reach_ord( Vars, Graph, ReachOrd ) ). % active_split_roots_tord( ResActive, ResRoots, ReachOrd, ResRootsOrd, ResActiveOrd ). constraint_to_store_clist( [], _Qpvs, _Reqs, Store, Store ). constraint_to_store_clist( [HDv|T], Qpvs, Reqs, InStore, OutStore ) :- constraint_to_store_conditional( HDv, Qpvs, Reqs, InStore, MidStore ), constraint_to_store_clist( T, Qpvs, Reqs, MidStore, OutStore ). % Reqs = (DPas,onevar,Q,Dv,Qvs,Zs), constraint_to_store_conditional( DepVar, QVs, Reqs, InStore, OutStore ) :- store_enquire( InStore, [act(Active),gr(Graph),rts(Roots)] ), % active_selects_del( [Var,DepVar], Active, [Var-VDt,DepVar-DpVDt], MidAct ), active_selects_del( [DepVar|QVs], Active, [DepVar-DpVDt|QKVs], MidAct ), kv_decompose( QKVs, _QVs, QVDts ), % data_add_needs( Reqs, Var, DpVDt, NewDpVDt ), data_add_needs( Reqs, QVs, DpVDt, NewDpVDt ), % data_add_required( DepVar, diff, VDt, Roots, NewVDt, NewRoots ), data_add_required_many( QVDts, DepVar, diff, Roots, NewRoots, NewQVDts ), kv_compose( QVs, NewQVDts, NewQKVs ), active_additions( [DepVar-NewDpVDt|NewQKVs], MidAct, NewActive ), % graph_add_constraint( Var, diff, DepVar, Graph, NewGraph ), graph_add_constraint_many_to_one( QVs, diff, DepVar, Graph, NewGraph ), % dbg( newroots(NewRoots) ), store_update( InStore, [act(NewActive),gr(NewGraph),rts(NewRoots)], OutStore ). next_probability_sum_counter( Counter ) :- probability_sum_counter(Counter), retractall( (probability_sum_counter(Counter)) ), NxCounter is Counter + 1, asserta( (probability_sum_counter(NxCounter)) ), !.