probe_active_statics( [], Acc, Acc ).
probe_active_statics( [V-VData|T], Acc, [V-_Stat|R] ) :-
	% there will be two cases: (a) root and (b) dependendant
	throw( here ),
	data_choices( [mtd(Method),dmn(Fd),nds(Nd)], VData ),
	( Nd == [] ->    % this is the root case
		method_apply( Method, Fd, Prbs ),
		kv_compose( Fd, Prbs, Static )
		;
		throw( here )
		%% here: find format of needs
          %% see data_needs_satisfy in data.pl
	),
	ord_add_element( Acc, V-Static, NxAcc ),
	probe_active_statics( T, NxAcc, R ).

% probe_variables( Active, Roots, StatDistros ) :-
% 
probe_variables( [], Labels, Prb, Labels, Prb ).
probe_variables( [V-ActvV|ActvVs], InLbs, InPrb, OutLbs, OutPrb ) :-
	data_choose( nds(Nds), ActvV ), 
	% data_needs_has_free( Nds, NdFrVs ),
	% cohese_propagated_domains( PropDmns, Distro ),
	% CUT from HERE
	% data_choose( dmn(FD), ActvV ),
	data_choose( dmn_or_v(FDV), ActvV ),
	data_choose( mtd(Fi), ActvV ),
	( has_mass_lossing_function( V ) -> Ms=lost ; Ms=kept ),
	probe_qualifying( Nds, V, Ms, Fi, FDV, InLbs, Distro ),
	% split_true_qfrees( BISeqs, [], [], Trues ),
	% required_to_domains( Additives, PlV, Trues, FD, Fi, Ms, Domains ),
	% probe_qualifying( ActvV, V, PlV, Stc, Additives, QlfBools ),
	% data_additive( ActV, VFd, VFi, PlV, Additives ),
	% multi_conditional_probe( FD, Ms, Fi, PlV, QlfBools, Additives, Distro ),
	member( El-ElPrb, Distro ), ElPrb \= 0/1,
	NxLbs = [V-El|InLbs],
	rationals_multiplication( InPrb, ElPrb, NxPrb ),
	probe_variables( ActvVs, NxLbs, NxPrb, OutLbs, OutPrb ).
	% 
	% probe_parts( VTuple, V, Fd, Prs, ReqBy ),
	% dbg( part_var(V) ),
	% probe( Fd, Prs, Val, VPrb ),
	% dbg( probed(Fd,Val,VPrb) ),
	% active_satisfied( ReqBy, Active, V, Val, Acc, AccPrb, NewActive, Stsfd, PisPrb ),
	% dbg( pisprb(PisPrb) ),
	% append( Vs, Stsfd, NewVs ),
	% rationals_multiplication( PisPrb, VPrb, NewAccPrb ),
	% % rationals_multiplication( AccPrb, VPrb, NewAccPrb ),
	% % rationals_multiplication_list( [VPrb,PisPrb], AccPrb, NewAccPrb ),
	% ord_add_element( Acc, V-Val, NewAcc ),
	% dbg( accs(in(AccPrb),out(NewAccPrb)) ),
	% dbg( vars_accs(in(Acc),out(NewAcc)) ),
	% probe_variables( NewVs, NewActive, NewAcc, AllVs, NewAccPrb, Prb ).

required_to_domains( [], _V, _Trues, _FD, _Fi, _Ms, [] ).
required_to_domains( [H/Frees|T], V, [HTr|RTrs], FD, Fi, Ms, [HDmns|TDmns] ) :-
	% one_constraint_required_to_domain( H, HTr, FD, HDm ),
	required_predicates_to_domains( H, Frees, V, HTr, FD, Fi, Ms, HDmns ),
	required_to_domains( T, V, RTrs, FD, Fi, Ms, TDmns ).

required_predicates_to_domains( [], _Frees, _V, _Trues, _FD, _Fi, _Ms, [] ).
required_predicates_to_domains( [H|TPdcs], Frees, V, Trues, FD, Fi, Ms, [HDm|TDmns] ) :-
	( H = (HPdc:HPrb)-_Fvs ->
		true
		;
		H = (HPdc:HPrb)
	),
	findall( Distro,
			( member( Frees, Trues ),
			  sieve_fd_on_pred( FD, HPdc, V, Ms, Sieved ),
			  method_apply( Fi, Sieved, Prbs ),
			  rationals_all_multiply_list( Prbs, HPrb, AmortD ),
			  kv_compose( Sieved, AmortD, Distro )
			  ), 
			  Distros ),
	% nested_list_add_in_position( Distros, HDm ),
	domain_distros_consolidation( FD, Distros, HDm ),
	required_predicates_to_domains( TPdcs, Frees, V, Trues, FD, Fi, Ms, TDmns ).

% sieve_fd_on_pred( FD, HPdc, V, Sieved ),
sieve_fd_on_pred( FD, Pdc, V, Ms, Sieved ) :-
	findall( V, (member(V,FD),pfd_call_once(Pdc)), NwDom ),
	( Ms == lost ->
		Sieved = NwDom
		;
		( NwDom == [] ->
			Sieved = FD
			;
			Sieved = NwDom
		)
	).

split_true_qfrees( [], RevAcc, Rem, Trues ) :-
	reverse( RevAcc, Acc ),
	( Rem == [[]|_] ->
		Trues = [Acc]
		;
		Trues = [Acc|Tail],
		% reverse( Rem, LeftOvers ),
		% split_true_qfrees( LeftOvers, [], [], Tail )
		split_true_qfrees( Rem, [], [], Tail )
	).
split_true_qfrees( [H|T], Acc, Rem, Trues ) :-
	( peel_one_qfree_true( H, Acc, NxAcc, AddRem ) ->
		split_true_qfrees( T, NxAcc, [AddRem|Rem], Trues )
		;
		remove_vacuous_qfrees( [H|T], Next ),
		( Next = [_-[]|_] -> 
			Trues = [[[]]]
			;
			Trues = [[[]]|TTrues],
            % fixme: Rem was [AddRem|Rem]
			split_true_qfrees( Next, Acc, Rem, TTrues )
		)
	).

remove_vacuous_qfrees( [], [] ).
remove_vacuous_qfrees( [H|T], [RmvH|RmvT] ) :-
	remove_one_vacuous( H, RmvH ),
	remove_vacuous_qfrees( T, RmvT ).

remove_one_vacuous( HBl-Hinst, RmvH ) :-
	Hinst = [_|Tinst],
	true_bool( HBl, _Val, RemBl ),
	RmvH = RemBl-Tinst.
	
peel_one_qfree_true( HBl-Hinst, Acc, NxAcc, AddRem ) :-
	Hinst = [Hvls|Tvls],
	\+ Hvls == [],
	true_bool( HBl, TrVal, RemBl ),
	( TrVal == 0't ->
		NxAcc = [Hvls|Acc]
		;
		NxAcc = Acc
	),
	( Tvls == [] ->
		AddRem = []
		;
		AddRem = RemBl-Tvls
	).

true_bool( HBl, TrVal, RemBl ) :-
	atom_codes( HBl, [TrVal|RemBlCs] ),
	atom_codes( RemBl, RemBlCs ).

probe_qualifying( Nds, V, Ms, Fi, FDV, Stcs, FinalDistro ) :-
% probe_qualifying( ActvV, V, PlV, Stcs, Adds, QlfBools ) :-
	% data_choose( nds(Nds), ActvV ), 
	data_needs_to_adds_n_qlf( Nds, V, PlV, Stcs, Adds, [], [], Vals, Qlfs, _Frees, PlVs, _Dps ),
	% data_needs_to_adds_n_qlf( Nds, V, PlV, Stcs, Adds, [], [], Doms, Qlfs, _Frees, PlVs, _Dps ),
	findall( Distro, % TSeq-Prb-Free, 
				% ( probe_labeld(Doms,PlVs,1/1,Prb),
				  (	Vals = PlVs,
	                     % true_seq(Qlfs,Free,TSeqCs),
					 satisfied_selects( Qlfs, Adds, SelAdds ),
					 data_domain_concrete( FDV, FD ),
					 multi_conditional( FD, Ms, Fi, PlV, SelAdds, 1/1, Distro )
					 % atom_codes(TSeq,TSeqCs)
					 ),
	            Distros ),
	data_domain_concrete( FDV, MaxFD ), % this is Maximal right ?
	domain_distros_consolidation( MaxFD, Distros, FinalDistro ).
	% kv_split_triple( Seqs, TPSeqs, BISeqs ),
	% write( trips(Seqs) ), nl,
	% kv_rat_additive_consolidation( TPSeqs, UnqKeySeq ),
	% sort( UnqKeySeq, QlfBools ),
	% dbg( bools(QlfBools) ),
	% kv_decompose( QlfBools, _Keys, Prbs ),
	% sum_list( Prbs, Total ),
	% dbg( ['total probabilitity: ', Total] ).

probe_labeld( [], [], Prb, Prb ).
probe_labeld( [H|T], [HVar|TVars], In, Out ) :-
	one_value( H, HVar, PrbH ),
	% Mid is In * PrbH,
	rationals_multiplication( In, PrbH, Mid ),
	probe_labeld( T, TVars, Mid, Out ).
probe_labeld( [H|T], Vars, In, Out ) :-
	skip_one( H, HSkip ),
	probe_labeld( [HSkip|T], Vars, In, Out ).

true_seq( [], [], [] ).
true_seq( [C/Vs|Cs], [NwVs|TNwVs], [Tr|TTrs] ) :-
	( Vs = [] -> NwC = C, NwVs = [] ; copy_term( C-Vs, NwC-NwVs ) ),
	( pfd_call_once(NwC) -> 
	% ( call(C) -> 
		Tr = 0't
		;
		Tr = 0'f
	),
	true_seq( Cs, TNwVs, TTrs ).

one_value( [H-PrbH|_T], H, PrbH ).
skip_one( [_H|T], T ) :- T \= [].

probe( Domain, VarPrbs, Val, VarPrb ) :-
	nth1( Idx, Domain, Val ),
	nth1( Idx, VarPrbs, VarPrb ).

probe( LMeth, CnDom, CnProbs, Val, Prob ) :-
	ProbeCall =.. [LMeth,CnDom,CnProbs,Val,Prob],
	% call( label_method(ProbeCall) ).
	abel_method(ProbeCall).

probe_n( pr_order, Pairs, Vals, Prbs, Prob ) :-
	!,
	List = [(1/1,[],[],Pairs)],
	Tree = t(0,List,nil,nil),
	values( Tree, 1, 0, [], Prob, Prbs, Vals ).

probe_n( Method, _Pairs, _Vals, _Probs, _Prob ) :-
	Goal = label_n/4-5,
	throw( pfd(unkown_label_method(Goal,Method)) ).

pairs_to_alts( [], [] ).
pairs_to_alts( [H|T], [1/1-H|TP] ) :-
	pairs_to_alts( T, TP ).

satisfied_selects( [], _Empty, [] ).
satisfied_selects( [Goal|Gs], [H|T], Selected ) :-
	( pfd_call_once(Goal) ->
		Selected = [H|TSel]
		;
		Selected = TSel
	),
	satisfied_selects( Gs, T, TSel ).