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)) ),
	!.