1 % (c) 2009-2025 Lehrstuhl fuer Softwaretechnik und Programmiersprachen,
2 % Heinrich Heine Universitaet Duesseldorf
3 % This software is licenced under EPL 1.0 (http://www.eclipse.org/org/documents/epl-v10.html)
4
5
6 :- module(b_interpreter,
7 [b_test_boolean_expression/4, b_test_boolean_expression/6,
8 %b_test_boolean_expression_wf/3,
9 b_test_boolean_expression_cs/5,
10 b_test_boolean_expression_for_ground_state/4, b_test_boolean_expression_for_ground_state/5,
11 % b_det_test_boolean_expression/6,
12 b_not_test_boolean_expression/4, b_not_test_boolean_expression/6,
13 %b_not_test_boolean_expression_wf/3,
14 b_not_test_boolean_expression_cs/5,
15
16 b_convert_bool/5,
17 b_convert_bool_timeout/7,
18 b_compute_expression/5,
19
20 b_execute_top_level_statement/7,
21 b_execute_statement_nowf/5,
22
23 b_compute_expression_nowf/4, b_compute_expression_nowf/6, b_compute_expression_nowf/7,
24 b_compute_explicit_epression_no_wf/6, b_compute_explicit_epression_no_wf/7,
25
26 b_set_up_concrete_constants/2, b_partial_set_up_concrete_constants/1,
27 b_initialise_machine/4,
28
29 b_execute_top_level_operation_update/5, b_execute_top_level_operation_wf/8,
30
31 convert_list_of_expressions_into_set_wf/4,
32 %state_satisfies_negation_of_invariant/1,
33
34 b_state_violates_invariant/2,
35 state_violates_assertions/2,
36 analyse_invariant_for_state/1,
37
38 insert_before_substitution_variables/5, % add $0 values to a store
39
40 try_lookup_value_in_store_and_global_sets/3, lookup_value_in_store_and_global_sets_wf/7,
41 set_up_typed_localstate/6, set_up_typed_localstate2/8,
42 %set_up_localstate_for_let/7,
43
44 set_projection_on_static_assertions/1,
45
46 tcltk_unsatisfiable_components_exist/0,
47 tcltk_quick_describe_unsat_properties/2,
48
49 get_unsat_component_predicate/3,
50 properties_were_filtered/1, % true if PROPERTIES / axioms filtered due to prob-ignore pragmas
51 b_generate_for_all_list_domain_nolwf/8 % for predicate_evaluator
52 ]).
53
54 :- meta_predicate not_with_enum_warning_and_possible_delay(0,-,?,?,?).
55 :- meta_predicate not_with_enum_warning_delay(0,-,?,?,?,?).
56
57 %:- use_module('../extensions/profiler/profiler.pl').
58 %:- use_module('../extensions/profiler/profiler_te.pl').
59 %:- enable_profiling(b_test_boolean_expression/4).
60 %:- enable_profiling(b_test_boolean_expression_cs/5).
61
62 :- use_module(kernel_objects).
63 :- use_module(bsets_clp).
64 :- use_module(delay).
65
66
67 :- use_module(kernel_mappings).
68 :- use_module(b_global_sets).
69 :- use_module(store).
70 :- use_module(library(lists)).
71 :- use_module(library(ordsets)).
72 :- use_module(library(avl)).
73
74 :- use_module(b_global_sets).
75 :- use_module(bmachine).
76 :- use_module(b_enumerate, [b_enumerate_values_in_store/5,
77 b_tighter_enumerate_all_values/2, b_tighter_enumerate_values_in_ctxt/3]).
78 :- use_module(debug).
79 :- use_module(performance_messages).
80 :- use_module(self_check).
81 :- use_module(tools).
82
83 :- use_module(module_information,[module_info/2]).
84 :- module_info(group,interpreter).
85 :- module_info(description,'This module provides the basic interpreter for expressions, predicates and substitutions.').
86
87 :- use_module(preferences).
88 :- use_module(error_manager).
89 :- use_module(typechecker).
90 :- use_module(specfile,[state_corresponds_to_initialised_b_machine/2
91 ,state_corresponds_to_set_up_constants_only/2]).
92
93 :- use_module(bsyntaxtree).
94
95 :- use_module(translate).
96
97 :- use_module(kernel_waitflags).
98 :- use_module(kernel_reals).
99 :- use_module(kernel_records).
100
101 :- use_module(kodkodsrc(kodkod),[kodkod_request/5]).
102
103 :- use_module(custom_explicit_sets).
104 :- use_module(closures,[is_symbolic_closure/1,
105 mark_closure_as_symbolic/2, mark_closure_as_recursive/2, mark_closure/3]).
106
107 :- use_module(state_space).
108 :- use_module(b_interpreter_eventb).
109 :- use_module(tools_printing,[print_term_summary/1,print_functor/1]).
110 :- use_module(value_persistance,[load_partial_constants/3,lookup_cached_transitions/4]).
111 :- use_module(extrasrc(b_expression_sharing),[is_lazy_let_identifier/1]).
112 :- use_module(bool_pred,[negate/2]).
113 :- use_module(smt_solvers_interface(smt_solvers_interface),[smt_add_predicate/5]).
114
115 :- use_module(debug).
116 :- use_module(external_functions).
117
118 :- use_module(static_ordering,[sort_ids_by_usage/4,reorder_state/3]).
119 %:- use_module(bsyntaxtree,[predicate_has_ignore_pragma/1]).
120 :- use_module(tools_lists,[exclude_count/4, optimized_nth1/3]).
121 :- use_module(tools_meta, [safe_time_out/3]).
122
123 :- set_prolog_flag(double_quotes, codes).
124
125 /* ----------------------------------*/
126
127 /* For partial evaluation */
128
129 %:- use_module('~/cvs_root/cogen2/logen_source/runtime/logen_dispatcher.pl').
130
131 % new profiler
132 %:- use_module('../extensions/profiler/profiler.pl').
133 %:- use_module('../extensions/profiler/profiler_te.pl').
134 %:- enable_profiling_naming(b_interpreter:b_state_violates_invariant_aux/2,name).
135
136 %name(b_interpreter:b_state_violates_invariant_aux,_,INVERIANT).
137
138 %b_state_violates_invariant(ID,State) :-
139 % b_intepreter:b_state_violates_invariant_aux(ID,State).
140
141 % old profiler
142 :- use_module(runtime_profiler,[profile_single_call/3]).
143
144 % called by force_check_invariantKO and indirectly by model_checker (State was prepare_state_for_specfile_trans )
145 b_state_violates_invariant(ID,State) :-
146 b_state_violates_invariant_aux(ID,State).
147
148 b_state_violates_invariant_aux(ID,CurBState) :-
149 retract(specialized_inv(ID,AVL)), % Note: when we assert this we check that invariant holds in predecessor state
150 intersect_invs(AVL,SPO), !,
151 (SPO = b(truth,_,_) -> fail
152 ; profile_single_call('INVARIANT-Specialized',ID,b_interpreter:b_state_violates_spec_invariant(ID,SPO,CurBState))).
153 b_state_violates_invariant_aux(ID,CurBState) :-
154 profile_single_call('INVARIANT',ID,b_interpreter:state_violates_invariant(ID,CurBState)).
155
156 b_state_violates_spec_invariant(ID,SPO,CurBState) :-
157 \+ check_invariant_predicate_with_time_out(ID,SPO,CurBState).
158
159 intersect_invs(invariant_preserved,Inv) :- !, Inv= b(truth,pred,[]).
160 intersect_invs([],Inv) :- !, add_internal_error('Illegal empty specialized inv list:', intersect_invs([],Inv)),
161 Inv = b(falsity,pred,[]).
162 intersect_invs(A,InvList) :-
163 avl_domain(A,OpList),
164 get_mask(OpList,Mask), %print(check(OpList,Mask)),nl,
165 findall(nth1_invariant(Nr), member(Nr,Mask), InvList).
166
167 % intersect all masks of specialized invariant nrs to be checked
168 get_mask([],[]).
169 get_mask([H|T],Res) :-
170 b_specialized_invariant_mask_for_op(H,Mask),get_mask3(T,Mask,Res).
171 get_mask3([],Acc,Acc).
172 get_mask3([H|T],Acc,Res) :-
173 b_specialized_invariant_mask_for_op(H,Mask),
174 ord_intersection(Mask,Acc,A1),
175 get_mask3(T,A1,Res).
176 /* ----------------------------------*/
177
178 :- load_files(library(system), [when(compile_time), imports([environ/2])]).
179
180
181 state_satisfies_invariant_aux(ID,State) :-
182 check_invariant_with_time_out(ID,State). % version without partial evaluation
183
184
185 :- use_module(library(timeout)).
186
187 :- use_module(tools_printing,[format_with_colour_nl/4]).
188 :- use_module(probsrc(specfile),[prepare_state_for_specfile_trans/3]).
189 % called by prob_cli when invariant violation found:
190 % we no longer have access to the specialized_inv facts
191 analyse_invariant_for_state(ID) :-
192 b_invariant_number_list(InvList),
193 visited_expression(ID,State),
194 prepare_state_for_specfile_trans(State,ID,PreparedCurState),
195 maplist(check_invariant(ID,PreparedCurState),InvList).
196 check_invariant(ID,State,InvariantNr) :-
197 enter_new_error_scope(L,check_invariant),
198 check_invariant_predicate_with_time_out_res(InvariantNr,State,TimeOutRes),
199 (TimeOutRes=success -> true
200 ; InvariantNr = nth1_invariant(Nr),
201 b_nth1_invariant(Nr,Invariant,_UsedIds),
202 translate_bexpression_with_limit(Invariant,TS),
203 translate_span(Invariant,SpanStr),
204 (TimeOutRes=failure -> InvRes=false ; InvRes=unknown),
205 format_with_colour_nl(user_output,[red,bold],
206 '*** Invariant ~w ~w is ~w (in state with id ~w):~n ~w',[Nr,SpanStr,InvRes,ID,TS]),
207 % add_message(check_invariant,'Invariant false: ',Nr,TS),
208 (debug_mode(off) -> true
209 ; translate:print_bstate(State),nl
210 )
211 % TODO: pass check dot_file_prefix or similar to analyse_invariant_for_state and call:
212 % bvisual:get_tree_from_expr(Tree, Invariant, [], State),
213 % bvisual:write_dot_graph_to_file(Tree,'invariant.dot')
214 ), exit_error_scope(L,_ErrOcc,check_invariant).
215
216
217
218 check_invariant_with_time_out(ID,State) :-
219 %b_get_invariant_from_machine(Invariant),
220 b_invariant_number_list(InvList), % ensures operation caching can be applied
221 % TO DO: we could just get unproven invariants; unless we are in an initial state
222 check_invariant_predicate_with_time_out(ID,InvList,State).
223
224
225 check_invariant_predicate_with_time_out(ID,Invariant,State) :-
226 (check_invariant_predicate_with_time_out_res(Invariant,State,TimeOutRes)
227 -> check_time_out_res(TimeOutRes,ID)).
228
229 check_invariant_predicate_with_time_out_res(b(truth,_,_),_State,TimeOutRes) :- !, % only typing in invariant
230 TimeOutRes = success.
231 check_invariant_predicate_with_time_out_res(Invariant,State,TimeOutRes) :-
232 set_error_context(checking_invariant),
233 preferences:get_computed_preference(debug_time_out,DebugTimeOut),
234 call_cleanup(
235 (time_out_with_enum_warning_one_solution_no_new_error_scope(
236 b_interpreter:check_invariant_predicate_aux(Invariant,State ),
237 DebugTimeOut,TimeOutRes)
238 -> true
239 ; TimeOutRes = failure),
240 clear_error_context).
241
242 % process typed predicates, lists and special invariant(Nr) terms
243 check_invariant_predicate_aux(nth1_invariant(Nr),State) :- !,
244 (get_preference(try_operation_reuse,false)
245 ? -> check_nth1_invariant(Nr,State)
246 ? ; \+ b_operation_cache:check_invariant_violated_cache(Nr,State) % will call check_nth1_invariant if necessary
247 % note : for performance it is important that the State is prepared but not expanded
248 % (e.g. it should be expanded_const_and_vars with the info field containing the packed state)
249 ).
250 check_invariant_predicate_aux([],_) :- !.
251 check_invariant_predicate_aux([H|T],State) :- !,
252 ? check_invariant_predicate_aux(H,State),
253 ? check_invariant_predicate_aux(T,State).
254 check_invariant_predicate_aux(Invariant,State) :-
255 b_test_boolean_expression_for_ground_state(Invariant,[],State,'INVARIANT',0).
256
257 % check the nth invariant
258 check_nth1_invariant(Nr,State) :-
259 if(b_nth1_invariant(Nr,Invariant,_UsedIds),
260 ? b_test_boolean_expression_for_ground_state(Invariant,[],State,'INVARIANT',Nr), % add Nr to call_stack
261 add_internal_error('Invariant does not exist:',Nr)).
262
263
264 check_time_out_res(time_out,ID) :- !,
265 format('**** TIMEOUT during invariant evaluation in state ~w!~n',[ID]),
266 assert_time_out_for_invariant(ID),
267 fail.
268 check_time_out_res(virtual_time_out(_WARNING),ID) :- !,
269 format('**** VIRTUAL TIMEOUT during invariant evaluation in state ~w!~n',[ID]),
270 assert_time_out_for_invariant(ID),
271 fail.
272 check_time_out_res(failure,_) :- !, fail.
273 check_time_out_res(_,_).
274
275 % b_test_boolean_expression_for_ground_state:
276 % idea: check each conjunct individually; avoids multiplication of choice points between conjuncts
277
278 :- use_module(specfile,[expand_const_and_vars_to_full_store/2]).
279 b_test_boolean_expression_for_ground_state(b(Expr,_,Infos),LS,S,PredKind) :-
280 b_test_boolean_expression_for_ground_state(b(Expr,_,Infos),LS,S,PredKind,0).
281 b_test_boolean_expression_for_ground_state(b(Expr,_,Infos),LS,S,PredKind,Nr) :-
282 expand_const_and_vars_to_full_store(S,FS), % ensure we have full store
283 ? b_test_boolean_expression_for_ground_state2(Expr,Infos,LS,FS,PredKind,Nr).
284
285 b_test_boolean_expression_for_ground_state1(b(Expr,_,Infos),LS,S,Kind,Nr) :- !,
286 ? b_test_boolean_expression_for_ground_state2(Expr,Infos,LS,S,Kind,Nr).
287
288 b_test_boolean_expression_for_ground_state2(conjunct(LHS,RHS),_,LocalState,State,Kind,Nr) :- !,
289 % usually LHS is the nested conjunct and RHS atomic:
290 %it would be better to swap LHS and RHS: but does not seem to buy anything
291 ? b_test_boolean_expression_for_ground_state1(LHS,LocalState,State,Kind,Nr),
292 !, % do we need this cut; it makes partial evaluation more tricky
293 ? b_test_boolean_expression_for_ground_state1(RHS,LocalState,State,Kind,Nr).
294 % TO DO: treate lazy_let_pred ?
295 b_test_boolean_expression_for_ground_state2(BE,Infos,LS,S,Kind,Nr) :-
296 ? b_test_boolean_expression_cs(b(BE,pred,Infos),LS,S,Kind,Nr).
297
298 state_violates_invariant(ID,State) :-
299 State \== root,
300 State \= concrete_constants(_), % machine not yet initialised (cf state_corresponds_to_initialised_b_machine)
301 \+(state_satisfies_invariant_aux(ID,State)).
302
303
304 % new profiler
305 %:- use_module('../extensions/profiler/profiler.pl').
306 %:- use_module('../extensions/profiler/profiler_te.pl').
307 %:- enable_profiling_naming(b_interpreter:state_violates_assertions_aux/2,name2).
308
309 %name2(b_interpreter:state_violates_assertions_aux,_,ASSERTIONS).
310
311 %state_violates_assertions(ID,State) :-
312 % b_interpreter:state_violates_assertions_aux(ID,State).
313
314 % old profiler
315 :- use_module(runtime_profiler,[profile_single_call/3]).
316 :- use_module(bmachine,[get_assertions_from_machine/2, b_machine_has_dynamic_assertions/0, b_machine_has_static_assertions/0]).
317 state_violates_assertions(ID,State) :-
318 profile_single_call('ASSERTIONS',ID,b_interpreter:state_violates_assertions_aux(ID,State)).
319 state_violates_assertions_aux(ID,State) :-
320 b_machine_has_dynamic_assertions,
321 state_corresponds_to_initialised_b_machine(State,BState), !,
322 \+(state_satisfies_assertions(ID,dynamic,BState)).
323 state_violates_assertions_aux(ID,State) :-
324 b_machine_has_static_assertions,
325 state_corresponds_to_set_up_constants_only(State,BState),
326 \+(state_satisfies_assertions(ID,static,BState)).
327 state_satisfies_assertions(ID,Type,State) :-
328 ( get_assertions_from_machine(Type,Ass) ->
329 set_error_context(checking_assertions),
330 %enter_new_error_scope(Level,checking_assertions),
331 preferences:get_computed_preference(debug_time_out,DebugTimeOut),
332 %print(checking_assertions(ID)),nl,
333 time_out_with_enum_warning_one_solution(
334 b_test_list_of_boolean_expression_for_ground_state(Ass,'ASSERTION ',[],State),
335 DebugTimeOut,TimeOutRes, clear_errors),
336 % TO DO: in case of a virtual time-out (cf UML-B/drone_2_error.eventb) we could try and continue with the next assertion
337 clear_error_context,
338 (nonvar(TimeOutRes),
339 (TimeOutRes == time_out, Kind='TIMEOUT' ; TimeOutRes = virtual_time_out(_), Kind = 'Virtual TIMEOUT')
340 -> format('~n*** ~w during assertion checking for state id ~w!~n',[Kind,ID]),
341 assert_time_out_for_assertions(ID)
342 ; true
343 )
344 ; true
345 ).
346
347
348
349 /* ----------------------------------*/
350 /* b_test_boolean_expression */
351 /* ----------------------------------*/
352
353
354 :- type variable_id_list +--> list(type(variable_id)).
355
356 :- type boolean_expression +--> call(bsyntaxtree:check_if_typed_predicate).
357
358 % used for testing ASSERTIONS on a fully ground state
359 b_test_list_of_boolean_expression_for_ground_state(List,PredKind,LS,S) :-
360 b_test_list_of_boolean_expression_aux(List,PredKind,1,LS,S).
361
362 b_test_list_of_boolean_expression_aux([],_,_,_,_).
363 b_test_list_of_boolean_expression_aux([B1|T],PredKind,Nr,LS,S) :- %nl,print(nr(PredKind,Nr)),nl,
364 ? (b_test_boolean_expression_for_ground_state1(B1,LS,S,PredKind,Nr)
365 -> N1 is Nr+1, b_test_list_of_boolean_expression_aux(T,PredKind,N1,LS,S)
366 ; silent_mode(off),
367 (critical_enumeration_warning_occured_in_error_scope -> Res='UNKNOWN'
368 ; abort_error_occured_in_error_scope -> Res ='NOT-WELL-DEFINED'
369 ; Res='false'),
370 ajoin([PredKind, Nr, ' is ', Res,': '],Msg),
371 add_message(b_interpreter,Msg,B1,B1), % TO DO: get just label/location?
372 fail).
373
374
375 :- use_module(b_interpreter_components).
376
377
378 :- assert_pre(b_interpreter:b_test_boolean_expression_cs(E,LS,S,_,_),
379 (bsyntaxtree:check_if_typed_predicate(E),type_check(LS,store),type_check(S,store) )).
380 :- assert_post(b_interpreter:b_test_boolean_expression_cs(_,_,_,_,_), true ).
381
382
383 % --------------------- BOOLEAN EXPRESSIONS ----------------------------
384
385 :- use_module(b_interpreter_check).
386 :- use_module(kernel_propagation, [do_not_enumerate_binary_boolean_operator/3]).
387
388 % a version where we can provide an initial call stack entry for context
389 b_test_boolean_expression_cs(E,LS,S,PredKind,Nr) :-
390 init_wait_flags_cs(E,PredKind,Nr,b_test_boolean_expression_cs,WF),
391 % TO DO: call b_trace_test_components ?
392 ? b_test_boolean_expression(E,LS,S,WF),
393 ? ground_wait_flags(WF).
394
395 init_wait_flags_cs(E,PredKind,Nr,PP,WF) :-
396 (PredKind=none -> init_wait_flags(WF,[PP])
397 ; get_texpr_pos(E,Pos),
398 CallStackEntry = prob_command_context(check_pred_command(PredKind,Nr),Pos),
399 init_wait_flags_and_push_call_stack(no_wf_available,CallStackEntry,WF)
400 ).
401
402
403 b_test_boolean_expression(b(Expr,_,Infos),LS,S,WF) :- !,
404 (b_interpreter_check:composed(Expr) -> empty_avl(Ai)
405 ; Ai = no_avl), % simple expression: no sharing is possible: no need to register expressions
406 ? b_test_boolean_expression2(Expr,Infos,LS,S,WF,Ai,_).
407 b_test_boolean_expression(E,LS,S,WF) :- % will generate error message
408 empty_avl(Ai), b_test_boolean_expression(E,LS,S,WF,Ai,_).
409
410 :- assert_pre(b_interpreter:b_test_boolean_expression(E,LS,S,WF),
411 (nonvar(E),bsyntaxtree:check_if_typed_predicate(E),type_check(LS,store),type_check(S,store),
412 type_check(WF,wait_flag))).
413 :- assert_post(b_interpreter:b_test_boolean_expression(_,_,_,WF), type_check(WF,wait_flag)).
414
415
416 %b_test_boolean_expression(Expr,_,_,_) :- print('test: '),translate:print_bexpr(Expr),nl,print(Expr),nl,fail. %%
417
418 :- load_files(library(system), [when(compile_time), imports([environ/2])]).
419 :- if(environ(prob_debug_watch_flag,true)).
420 b_test_boolean_expressiond(b(Expr,_,Infos),LS,S,WF,Ai,Ao) :- !,
421 b_test_boolean_expression2(Expr,Infos,LS,S,WF,Ai,Ao).
422 b_test_boolean_expression(Expr,LS,S,WF,Ai,Ao) :- !,
423 (waitflag0_is_set(WF)
424 -> debug:watch(300,b_interpreter:b_test_boolean_expressiond(Expr,LS,S,WF,Ai,Ao))
425 ; debug:watch_det(300,b_interpreter:b_test_boolean_expressiond(Expr,LS,S,WF,Ai,Ao)) ).
426 :- else.
427 b_test_boolean_expression(b(Expr,Type,Infos),LS,S,WF,Ai,Ao) :- !,
428 (preference(smt_supported_interpreter,true)
429 -> b_test_boolean_expression2(Expr,Infos,LS,S,WF,Ai,Ao),
430 get_wait_flag1(smt_call,WF,BeforeEnumWF),
431 gensym:gensym(smt_assertion_name,Symbol),
432 smt_add_predicate(BeforeEnumWF,b(Expr,Type,Infos),LS,S,Symbol)
433 ;
434 ? b_test_boolean_expression2(Expr,Infos,LS,S,WF,Ai,Ao)).
435 :- endif.
436 b_test_boolean_expression(E,LS,S,WF,Ai,Ao) :-
437 add_internal_error('Boolean expression not properly wrapped: ',
438 b_test_boolean_expression(E,LS,S,WF,Ai,Ao)),
439 b_test_boolean_expression2(E,[],LS,S,WF,Ai,Ao).
440
441
442 b_test_boolean_expression2(truth,_,_,_,_WF,Ai,Ao) :- !,Ai=Ao.
443 b_test_boolean_expression2(falsity,_,_,_,_WF,_Ai,_Ao) :- !,fail.
444 b_test_boolean_expression2(negation(BExpr),_,LocalState,State,WF,Ai,Ao) :- !,
445 ? b_not_test_boolean_expression(BExpr,LocalState,State,WF,Ai,Ao).
446 b_test_boolean_expression2(conjunct(LHS,RHS),_,LocalState,State,WF,Ai,Ao) :- !,
447 ? b_test_boolean_expression(LHS,LocalState,State,WF,Ai,Aii),
448 ? b_test_boolean_expression(RHS,LocalState,State,WF,Aii,Ao).
449 b_test_boolean_expression2(implication(LHS,RHS),Info,LocalState,State,WF,Ai,Ao) :-
450 %b_compiler:b_compile(LHS,[],LocalState,State,CLHS), % this slows down Cruise benchmark from 3.75 s to 4.3
451 !,
452 ? b_test_implication(LHS,RHS,Info,LocalState,State,WF,Ai,Ao).
453 b_test_boolean_expression2(equivalence(LHS,RHS),_,LocalState,State,WF,Ai,Ao) :- !,
454 ? b_test_equivalence(LHS,RHS,LocalState,State,WF,Ai,Ao).
455 b_test_boolean_expression2(disjunct(LHS,RHS),Info,LocalState,State,WF,Ai,Ao) :- !,
456 % TO DO: normalise disjunct first ?
457 copy_wf_start(WF,disjunct,CWF),
458 ? if(b_check_boolean_expression(LHS,LocalState,State,CWF,PredRes,Ai,Aii),
459 % we can check lhs
460 ? if(b_interpreter_check:b_check_boolean_expression0(pred_false,PredRes,RHS,LocalState,State,CWF,RR,Aii,Ao),
461 ( /* we can also check rhs */
462 ? b_interpreter_check:disjoin(PredRes,RR,pred_true,LHS,RHS,WF),
463 copy_wf_finish(WF,CWF)
464 ),
465 (
466 Ao=Aii,
467 copy_wf_finish(WF,CWF),
468 imply_test_boolean_expression(PredRes,pred_false,RHS,LocalState,State,WF,Aii),
469 perfmessagecall(choice_point,reification_of_disjunction_rhs_failed,translate:print_bexpr(RHS),Info),
470 enumerate_bool(PredRes,15,WF)
471 )
472 ),
473 % we cannot check lhs
474 if((always_well_defined(RHS),
475 b_check_boolean_expression(RHS,LocalState,State,CWF,PredRes,Ai,Aii)),
476 (
477 Ao=Aii,
478 copy_wf_finish(WF,CWF),
479 imply_test_boolean_expression(PredRes,pred_false,LHS,LocalState,State,WF,Aii),
480 perfmessagecall(choice_point,reification_of_disjunction_lhs_failed,translate:print_bexpr(LHS),Info),
481 enumerate_bool(PredRes,15,WF)
482 ),
483 % we cannot check neither lhs nor rhs:
484 (Ai=Ao,
485 get_priority_of_boolean_expression2(disjunct(LHS,RHS),StartPrio),
486 %get_wait_flag(Prio,disjunct,WF,WF2),
487 get_binary_choice_wait_flag_exp_backoff(StartPrio,disjunct,WF,WF2),
488 % be sure that e.g. for (x=2 or x=3) both branches will be tested once deterministic propagation is over
489 %print(prio(Prio)), print(' : '),print_bexpr(LHS), print(' or '), print_bexpr(RHS),nl,
490 perfmessagecall(choice_point,reification_of_disjunction_failed,translate:print_bexpr(b(disjunct(LHS,RHS),pred,Info)),Info),
491 b_test_disjunction(LHS,RHS,LocalState,State,WF,WF2,Ai)
492 )
493 )
494 ).
495 b_test_boolean_expression2(exists(Parameters,RHS),Infos,LocalState,State,WF,Ai,Ao) :- !,Ai=Ao,
496 ? b_test_exists(Parameters,RHS,Infos,LocalState,State,WF).
497 %b_test_boolean_expression2(forall(PARS,LHS,RHS),_Inf,LocalState,State,WF) :-
498 % PARS = [b(identifier(R1),integer,_),b(identifier(R2),integer,_)],
499 % LHS = b(conjunct(b(conjunct(MEM1,MEM2),pred,_I1),NEQ),pred,_I2),
500 % NEQ = b(not_equal(b(identifier(RR1),integer,_I3),b(identifier(RR2),integer,_I4)),pred,_I5),
501 % (RR1=R1, RR2=R2 ; RR1=R2, RR2=R1),
502 % MEM1 = b(member(b(identifier(RRR1),integer,_),b(SET,set(integer),_)),pred,_),
503 % MEM2 = b(member(b(identifier(RRR2),integer,_),b(SET,set(integer),_)),pred,_),
504 % (RRR1=R1, RRR2=R2 ; RRR1=R2, RRR2=R1),
505 % /* TO DO: check that RHS is symmetric ! */ /* TO DO : generalize symmetry breaking */
506 % !, % print(symmetry_breaking_forall(R1,R2)),nl,
507 % GT = b(less(b(identifier(R1),integer,_I3),b(identifier(R2),integer,_I4)),pred,_I5),
508 % NewLHS = b(conjunct(b(conjunct(MEM1,MEM2),pred,_I1),GT),pred,_I2),
509 % b_test_boolean_expression2(forall(PARS,NewLHS,RHS),_Inf,LocalState,State,WF).
510 b_test_boolean_expression2(forall(Parameters,LHS,RHS),Infos,LocalState,State,WF,Ai,Ao) :- !,Ai=Ao,
511 /* !ID.(LHS => RHS) */
512 % print_message(forall(Parameters,LHS,RHS)),
513 % get_wait_flag0(WF,WF0), when(nonvar(WF0),
514 ? b_for_all(Parameters,Infos,LHS,RHS,LocalState,State,WF). %).
515 b_test_boolean_expression2(let_predicate(Ids,AssignmentExprs,Pred),Infos,LocalState,State,WF,Ai,Ao) :- !,
516 Ai=Ao, % any expression inside the LET cannot be safely reused
517 (is_truth(Pred)
518 -> % useless let, only sense of computations below is in detecting WD errors
519 get_enumeration_starting_wait_flag(useless_let_predicate(Ids),WF,ESWF),
520 when(nonvar(ESWF),set_up_localstate_for_let(Ids,_,AssignmentExprs,LocalState,State,_LetState,WF))
521 ? ; set_up_localstate_for_let(Ids,ParaValues,AssignmentExprs,LocalState,State,LetState,WF),
522 opt_push_wait_flag_call_stack_quantifier_info(WF,let_quantifier,Ids,ParaValues,Infos,WF2),
523 ? b_test_boolean_expression(Pred,LetState,State,WF2)). % we could pass Ai in if Ids fresh
524
525 b_test_boolean_expression2(lazy_let_pred(Id,AssignmentExpr,Expr),_I,LocalState,State,WF,Ai,Ao) :- !,
526 add_lazy_let_id_and_expression(Id,AssignmentExpr,LocalState,State,NewLocalState,WF,Ai),
527 ? b_test_boolean_expression(Expr,NewLocalState,State,WF,Ai,Ao). % we could use Ai,Ao version as lazy lets never interfere with each other and never invalidate existing expressions
528 b_test_boolean_expression2(lazy_lookup_pred(Id),_Info,LocalState,_State,WF,Ai,Ao) :- !, Ai=Ao,
529 lookup_value_for_existing_id_wf(Id,LocalState,(Trigger,Value),WF), % should normally only occur in LocalState; value introduced by lazy_let
530 (Trigger,Value) = (pred_true,pred_true). % force evaluation
531 b_test_boolean_expression2(value(PredVal),_Info,_LocalState,_State,_WF,Ai,Ao) :- !, % this can occur when lazy_lookup_pred gets compiled by b_compiler
532 is_pred_true(PredVal),Ai=Ao.
533 b_test_boolean_expression2(Pred,Info,LocalState,State,WF,Ai,Ao) :-
534 % TO DO: we could put some of the operators into the Ai store (comparison operators)
535 ? b_interpreter_check:register_predicate(Pred,Info,pred_true,Reused,Ai,Ao),
536 (Reused==true
537 -> %% print('REUSED: '), translate:print_bexpr(Pred),nl
538 true
539 ? ; b_test_atomic_boolean_expression2(Pred,Info,LocalState,State,WF)).
540
541 :- block is_pred_true(-).
542 is_pred_true(X) :- (X=pred_true -> true ; X=pred_false -> fail ; add_internal_error('Illegal call: ',is_pred_true(X)),fail).
543 :- block is_pred_false(-).
544 is_pred_false(X) :- (X=pred_false -> true ; X=pred_true -> fail ; add_internal_error('Illegal call: ',is_pred_false(X)),fail).
545
546
547 % we could simply call disjunct(NegLHS,RHS) ?
548 % A => B has more of a feeling of a passive constraint than A or B
549 % hence we use a lower priority here for enumerate_bool below and do not
550 % try to reify rhs if lhs reification failed (but maybe we should)
551 b_test_implication(LHS,RHS,_Info,LocalState,State,WF,Ai,Ao) :-
552 copy_wf_start(WF,implication,CWF),
553 ? if(b_check_boolean_expression(LHS,LocalState,State,CWF,PredRes,Ai,Aii),
554 %% print('checking => '), print_bexpr(LHS), print(' '), print(PredRes),nl,
555 %% The following improves constraint propagation; but can be tricky with undefinedness
556 if((var(PredRes),always_well_defined(RHS),
557 b_check_boolean_expression(RHS,LocalState,State,CWF,RHSPredRes,Aii,Ao)),
558 (/* also propagate from right to left */
559 ? b_interpreter_check:imply_true(PredRes,RHSPredRes),
560 perfmessage_bexpr(good(reify),'Fully reified implication with LHS: ',LHS),
561 ? copy_wf_finish(WF,CWF)
562 ),
563 ( Aii=Ao,
564 ? copy_wf_finish(WF,CWF),
565 ? imply_test_boolean_expression(PredRes,pred_true,RHS,LocalState,State,WF,Aii),
566 (nonvar(PredRes) -> true
567 ; performance_monitoring_on,
568 \+always_well_defined(RHS) -> perfmessage_bexpr(reify,'Cannot reify RHS of => due to WD condition, creating choice point:',RHS)
569 ; perfmessage_bexpr(reify,'Cannot reify RHS of =>, creating choice point:',RHS)
570 ),
571 enumerate_bool(PredRes,10000,WF) % lower priority than disjunction (15); we could use last_finite_priority ?
572 )
573 ),
574 ( Ai=Ao,
575 perfmessage_bexpr(reify,'Cannot reify LHS of =>, creating binary choice point:',LHS),
576 get_binary_choice_wait_flag(implication,WF,WF2),
577 block_test_implication(LHS,RHS,LocalState,State,WF,WF2)
578 )
579 ).
580
581 % ------------
582
583 :- discontiguous b_test_atomic_boolean_expression2/5.
584 %b_test_atomic_boolean_expression2(Expr,T,LocalState,State,WF) :- print(eval(Expr,T)),nl,fail.
585 b_test_atomic_boolean_expression2(partition(LHS,RHS),_,LocalState,State,WF) :- !,
586 b_compute_expression(LHS,LocalState,State,SV1,WF), %print(lhs(SV1)),nl,
587 l_compute_expression(RHS,LocalState,State,SV2,WF), % RHS is Prolog list of expressions
588 ? kernel_call_predicate(partition_wf(SV1,SV2,WF),kernel_objects,WF,partition(LHS,RHS)).
589 b_test_atomic_boolean_expression2(member(TElem,TSet),_,LocalState,State,WF) :- !,
590 ? b_test_member_expression(TElem,TSet,LocalState,State,WF).
591 b_test_atomic_boolean_expression2(not_member(TElem,TSet),Info,LocalState,State,WF) :- !,
592 get_texpr_expr(TSet,Set),
593 ? b_test_notmember_expression(Set,TElem,TSet,Info,LocalState,State,WF).
594 b_test_atomic_boolean_expression2(freetype_case(Freetype,Case,Expr),_,LocalState,State,WF) :-
595 !,equal_object_wf(Value,freeval(Freetype,Case,_),b_test_atomic_boolean_expression2,WF),
596 b_compute_expression(Expr,LocalState,State,Value,WF). % NOT COVERED (16)
597 b_test_atomic_boolean_expression2(finite(SetExpr),_,LocalState,State,WF) :-
598 !, b_compute_expression(SetExpr,LocalState,State,Value,WF),
599 kernel_call_predicate(is_finite_set_wf(Value,WF),kernel_objects,WF,finite(SetExpr)).
600 /* Extension for Kodkod */
601 b_test_atomic_boolean_expression2(kodkod(ProblemId,_),_,LocalState,State,WF) :-
602 !,get_wait_flag1(kodkod_call,WF,WF0),
603 kodkod_request(ProblemId,pos,LocalState,State,WF0). % NOT COVERED (17)
604 %b_test_atomic_boolean_expression2(equal(Arg1,Arg2),_,LocalState,State,WF) :- get_texpr_type(Arg1,integer),!,
605 % b_compute_expression(Arg1,LocalState,State,ExprRes,WF),
606 % b_compute_expression(Arg2,LocalState,State,ExprRes,WF). /* avoids one extra variable compared to code below + could fail earlier ; but problem as b_compute_expression still uses = in some places */
607
608 :- include(b_arithmetic_expressions).
609 %The following clause improves Nqueens performance by about 50 %; by avoiding intermediate variables
610 % TO DO: do the same for >, <, >= ...
611 b_test_atomic_boolean_expression2(equal(Arg1,Arg2),Info,LocalState,State,WF) :- !,
612 ? b_test_atomic_equal_boolean_expression(Arg1,Arg2,Info,LocalState,State,WF).
613 b_test_atomic_boolean_expression2(not_equal(Arg1,Arg2),Info,LocalState,State,WF) :- !,
614 ? b_test_atomic_not_equal_boolean_expression(Arg1,Arg2,Info,LocalState,State,WF).
615 b_test_atomic_boolean_expression2(less_equal(Arg1,Arg2),_Info,LocalState,State,WF) :-
616 %get_texpr_type(Arg1,integer), % type checker already checks this
617 preferences:preference(use_clpfd_solver,true),
618 !,
619 ? b_compute_arith_expression(Arg1,LocalState,State,CLPFD_Expr1,WF),
620 ? b_compute_arith_expression(Arg2,LocalState,State,CLPFD_Expr2,WF),
621 clpfd_interface:clpfd_leq_expr(CLPFD_Expr1,CLPFD_Expr2).
622 b_test_atomic_boolean_expression2(greater_equal(Arg1,Arg2),_Info,LocalState,State,WF) :-
623 %get_texpr_type(Arg1,integer), % type checker already checks this
624 preferences:preference(use_clpfd_solver,true),
625 !,
626 ? b_compute_arith_expression(Arg1,LocalState,State,CLPFD_Expr1,WF),
627 ? b_compute_arith_expression(Arg2,LocalState,State,CLPFD_Expr2,WF),
628 clpfd_interface:clpfd_leq_expr(CLPFD_Expr2,CLPFD_Expr1).
629 b_test_atomic_boolean_expression2(less(Arg1,Arg2),_Info,LocalState,State,WF) :-
630 %get_texpr_type(Arg1,integer), % type checker already checks this
631 preferences:preference(use_clpfd_solver,true),
632 !,
633 ? b_compute_arith_expression(Arg1,LocalState,State,CLPFD_Expr1,WF),
634 ? b_compute_arith_expression(Arg2,LocalState,State,CLPFD_Expr2,WF),
635 clpfd_interface:clpfd_lt_expr(CLPFD_Expr1,CLPFD_Expr2).
636 b_test_atomic_boolean_expression2(greater(Arg1,Arg2),_Info,LocalState,State,WF) :-
637 %get_texpr_type(Arg1,integer), % type checker already checks this
638 preferences:preference(use_clpfd_solver,true),
639 !,
640 ? b_compute_arith_expression(Arg1,LocalState,State,CLPFD_Expr1,WF),
641 b_compute_arith_expression(Arg2,LocalState,State,CLPFD_Expr2,WF),
642 clpfd_interface:clpfd_lt_expr(CLPFD_Expr2,CLPFD_Expr1).
643 b_test_atomic_boolean_expression2(external_pred_call(FunName,Args),Info,LocalState,State,WF) :-
644 !,
645 (do_not_evaluate_args(FunName) -> EvaluatedArgs=[]
646 ? ; b_compute_expressions(Args, LocalState,State, EvaluatedArgs, WF)),
647 push_wait_flag_call_stack_info(WF,external_call(FunName,EvaluatedArgs,Info),WF2),
648 call_external_predicate(FunName,Args,EvaluatedArgs,LocalState,State,pred_true,Info,WF2).
649 b_test_atomic_boolean_expression2(Expression,Info,LocalState,State,WF) :-
650 preferences:preference(use_clpfd_solver,false),
651 special_binary_predicate(Expression,Module:Kernel_predicate,Arg1,T1,Arg2,T2),
652 (nonmember(contains_wd_condition,Info) -> true ; preference(disprover_mode,true)),
653 !,
654 % print('Special call: '), print_bexpr(Expression),nl, print(Kernel_predicate),print(' : '),nl,
655 %(Arg1==list_of_expressions -> b_compute_expressions ... % no longer needed
656 b_compute_expression(Arg1,LocalState,State,SV1,WF),
657 b_compute_expression(Arg2,LocalState,State,SV2,WF),
658 KernelCall =.. [Kernel_predicate,SV1,T1,SV2,T2,WF],
659 kernel_call_predicate(KernelCall,Module,WF,Expression).
660 b_test_atomic_boolean_expression2(Expression,_,LocalState,State,WF) :-
661 functor(Expression,BOP,2),
662 kernel_mappings:binary_boolean_operator(BOP,Module:Kernel_predicate,WFEnabled),!,
663 arg(1,Expression,Arg1), arg(2,Expression,Arg2),
664 ? b_compute_expression(Arg1,LocalState,State,SV1,WF), % TODO: symbolic for some BOP: <:, <<: ?
665 (binary_boolean_operator_trivially_true(BOP,SV1)
666 -> check_well_defined(Arg2,LocalState,State,WF)
667 ? ; b_compute_expression(Arg2,LocalState,State,SV2,WF),
668 ( WFEnabled==yes ->
669 KernelCall =.. [Kernel_predicate,SV1,SV2,WF2],
670 (do_not_enumerate_binary_boolean_operator(BOP,Arg1,Arg2) % we assume: this is only true for WFEnabled predicates
671 -> add_wait_flag_info(WF,wfx_no_enumeration,WF2)
672 ; WF2=WF)
673 ; KernelCall =.. [Kernel_predicate,SV1,SV2], WF2=WF % note: WF2 still used in kernel_call_predicate
674 ),
675 ? kernel_call_predicate(KernelCall,Module,WF2,Expression)
676 ).
677 b_test_atomic_boolean_expression2(E,Info,_LS,_S,_WF) :-
678 add_internal_error('Uncovered boolean expression: ',b(E,pred,Info)),
679 print_functor(E),nl,
680 fail.
681
682
683 binary_boolean_operator_trivially_true(subset,X) :- X==[].
684
685 check_well_defined(Arg,_LocalState,_State,_WF) :-
686 always_well_defined(Arg),!.
687 check_well_defined(Arg,LocalState,State,WF) :-
688 b_compute_expression(Arg,LocalState,State,_,WF).
689
690 %:- use_module(specfile,[animation_minor_mode/1]).
691 :- use_module(b_machine_hierarchy,[abstract_constant/2, concrete_constant/2]).
692 b_test_atomic_equal_boolean_expression(Arg1,Arg2,_Info,LocalState,State,WF) :-
693 Arg1 = b(_,integer,_), %get_texpr_type(Arg1,integer),
694 preferences:preference(use_clpfd_solver,true),!,
695 (Arg2 = b(_,integer,_) -> true ; add_internal_error('Type error in AST, not wrapped integer: ',Arg2)),
696 ? b_test_arith_equal_boolean_expression(Arg1,Arg2,LocalState,State,WF).
697 b_test_atomic_equal_boolean_expression(Arg1,Arg2,Info,LocalState,State,WF) :-
698 ? member(prob_annotation('LAMBDA-EQUALITY'),Info),
699 \+ simple_expression(Arg2),
700 is_lambda_result_id(Arg1), %get_texpr_id(Arg1,'_lambda_result_'), % ensure we have not renamed it to was_lambda_result ?
701 !, % this is an equality for the result of a lambda abstraction; only evaluate at the end
702 b_compute_expression(Arg1,LocalState,State,SV1,WF), % this is the lambda result identifier _lambda_result_
703 %get_enumeration_finished_wait_flag(WF,EWF),
704 %get_wait_flag(10000,lambda_result,WF,EWF),
705 % compute deterministic parts of Arg2 in wf0 phase: avoid computing this stuff over again
706 %print('DELAY: '), translate:print_bexpr(Arg2),nl,
707 ? kernel_waitflags:copy_wf01e_wait_flags(WF,WF2), b_compute_expression(Arg2,LocalState,State,SV2,WF2),
708 get_last_wait_flag(lambda_result,WF,EWF),
709 ground_value_check(SV2,G2),
710 when((nonvar(G2);nonvar(SV1);nonvar(EWF)),b_lambda_result_equal_boolean_expression(SV1,SV2,WF,EWF,WF2)).
711 b_test_atomic_equal_boolean_expression(Arg1,Arg2,Info,LocalState,State,WF) :-
712 (LocalState = []
713 -> true % only check if we are at the outer level
714 % (not inside a quantifier,...) or if we have CSE introduzed lazy_lets:
715 ; preferences:preference(use_common_subexpression_elimination,true)
716 % TO DO: check that we have only added @nr to local state from lazy_let; ADD INFO FIELD
717 ),
718 get_texpr_type(Arg1,Type1), is_set_type(Type1,SetType1),
719 % previously we required SetType1 = couple(_,_)
720 get_texpr_id(Arg1,ID),
721 % we could check: \+ get_texpr_id(Arg2,_), we do not need to treat simple equations like ID=ID2; unless for memo?
722 ? (abstract_constant(ID,_) % check if ABSTRACT_CONSTANT
723 -> Kind=abstract,
724 ? kernel_objects:max_cardinality(Type1,MaxCard1),
725 (number(MaxCard1) % check that type is large enough to warrant recursive or symbolic treatment
726 -> (MaxCard1>100 -> true ; constant_variable_marked_as_memo(ID))
727 ; true)
728 ; %fail,
729 ? concrete_constant(ID,_)
730 -> Kind=concrete,
731 (constant_variable_marked_as_expand(ID)
732 -> true % note: we also check for expand annotation in store (expand_closure_value),
733 % but it is useful to expand ID already here to ease checking PROPERTIES
734 ; constant_variable_marked_as_memo(ID))
735 %; b_is_unused_constant(ID) -> ABSTRACT=true % TO DO: check if ID not used somewhere else in Properties ??!!
736 ),
737 % in future: we may do size change analysis, or something like that to check that we have properly defined
738 % recursive function
739 debug_format(19,'Equation defining ~w constant: ~w~n',[Kind,ID]),
740 !,
741 (constant_variable_marked_as_expand(ID) -> SymArg2 = Arg2 ; mark_bexpr_as_symbolic(Arg2,SymArg2)),
742 ? b_add_constant_definition(Kind,ID,Info,Arg1,SetType1,SymArg2,LocalState,State,WF).
743 b_test_atomic_equal_boolean_expression(Arg1,Arg2,Info,LocalState,State,WF) :-
744 constants_profiling_on,
745 get_texpr_id(Arg1,ID),b_is_constant(ID), !,
746 % Note: does not yet keep track of arithmetic equalities above
747 b_compute_expression(Arg1,LocalState,State,SV1,WF),
748 push_constant_def_equality_call_stack(WF,ID,Info,WF2),
749 start_profile(ID,T1),
750 b_compute_expression(Arg2,LocalState,State,SV2,WF2),
751 get_waitflags_phase(WF,Phase),
752 stop_constant_profile(SV2,Phase,ID,[],T1), % normal constant, not symbolic, memoized or recursive
753 start_propagation_profile(ID,T2,CstL1),
754 kernel_call_predicate_equal_object_optimized(SV1,SV2,WF),
755 stop_propagation_profile(SV2,ID,T2,CstL1).
756 b_test_atomic_equal_boolean_expression(Arg1,Arg2,_Info,LocalState,State,WF) :-
757 ? b_compute_expression(Arg1,LocalState,State,SV1,WF),
758 ? b_compute_expression(Arg2,LocalState,State,SV2,WF),
759 ? kernel_call_predicate_equal_object_optimized(SV1,SV2,WF).
760
761
762
763 % treat equality ID = Symbolic Function (or relation/set)
764 b_add_constant_definition(Kind,ID,Info,Arg1,SetType1,SymArg2,LocalState,State,WF) :-
765 % observe CTRL-C: e.g., in data validation models these abstract functions can be very large and costly to compute
766 ? observe_user_interrupt_signal(computing_value_for_abstract_constant(ID),SymArg2,
767 b_add_constant_definition_aux(Kind,ID,Info,Arg1,SetType1,SymArg2,LocalState,State,WF)).
768
769 :- use_module(runtime_profiler,[start_profile/2,
770 stop_constant_profile/5, constants_profiling_on/0]).
771 b_add_constant_definition_aux(Kind,ID,_Info,Arg1,SetType1,SymArg2,LocalState,State,WF) :-
772 (preference(use_function_memoization,true), Kind=abstract ;
773 constant_variable_marked_as_memo(ID)), % description(memo) as info field using @desc memo pragma; see
774 !,
775 start_profile(ID,T1),
776 b_compute_expression(Arg1,LocalState,State,SV1,WF), % the identifier
777 (SymArg2 = b(recursive_let(TID,Body),_,_)
778 -> get_texpr_id(TID,RecID),
779 b_compute_expression(Body,[bind(RecID,RedIDVal)|LocalState],State,SV2,WF),
780 RecValue='$recursion_value'(RedIDVal), IDInfo = [recursive_memo]
781 ; b_compute_expression(SymArg2,LocalState,State,SV2,WF),
782 RecValue='$no_recursion', IDInfo = [memoized]
783 ),
784 get_waitflags_phase(WF,Phase), stop_constant_profile(SV2,Phase,ID,IDInfo,T1),
785 (nonvar(SV2), SV2 \= closure(_,_,_)
786 -> % value fully computed; no need to memoize
787 debug_println(19,not_memoizing(ID)),
788 kernel_call_predicate_equal_object_optimized(SV1,SV2,WF)
789 ; (nonvar(SV2) -> mark_closure_as_symbolic(SV2,SV3) ; SV3=SV2),
790 memoization:register_memoization_function(ID,SV3,SetType1,RecValue,MEMOID,SV4),
791 debug_println(19,marking_for_memoization(ID,MEMOID)),
792 kernel_call_predicate_equal_object_optimized(SV1,SV4,WF)
793 ).
794 b_add_constant_definition_aux(_Kind,ID,Info,Arg1,_,SymArg2,LocalState,State,WF) :-
795 start_profile(ID,T1),
796 b_compute_expression(Arg1,LocalState,State,SV1,WF), % the identifier ID
797 push_constant_def_equality_call_stack(WF,ID,Info,WF2),
798 ? b_compute_expression(SymArg2,LocalState,State,SV2,WF2),
799 (constant_variable_marked_as_expand(ID)
800 -> IDInfo = [marked_as_expand],
801 b_expand_compute_comprehension_set(SV2,Info,SV3,WF)
802 ; definitely_expand_this_explicit_set(SV2) % check for a few patterns which should definitely be expanded;
803 % in case user puts a set accidentally into the ABSTRACT_CONSTANTS section
804 -> IDInfo = [automatic_expand],
805 b_expand_compute_comprehension_set(SV2,Info,SV3,WF)
806 ; var(SV2) -> IDInfo = [], SV3=SV2
807 ; IDInfo = [], % it is from ABSTRACT_CONSTANTS, but this info is already stored
808 mark_closure_as_symbolic(SV2,SV3)
809 ),
810 get_waitflags_phase(WF,Phase), stop_constant_profile(SV3,Phase,ID,IDInfo,T1),
811 start_propagation_profile(ID,T2,CstL1),
812 kernel_call_predicate_equal_object_optimized(SV1,SV3,WF),
813 % profile propagation time and what constants are grounded
814 stop_propagation_profile(SV3,ID,T2,CstL1).
815
816 push_constant_def_equality_call_stack(WF,ID,Pos,WF2) :-
817 (constants_profiling_on
818 -> push_wait_flag_call_stack_info(WF,
819 id_equality_evaluation(ID,constant,Pos),WF2)
820 ; WF2=WF).
821
822 start_propagation_profile(ID,T1,CstL1) :-
823 (constants_profiling_on -> findall(Cst1,det_solution_for_constant_was_stored(Cst1),CstL1) ; CstL1=[]),
824 start_profile(ID,T1).
825 stop_propagation_profile(SV3,ID,T1,CstL1) :-
826 (constants_profiling_on
827 -> findall(Cst2,det_solution_for_constant_was_stored(Cst2),L2),
828 append(CstL1,New,L2), debug_format(9,'Propagation of value for ~w instantiated ~w~n',[ID,New]),
829 IDInfo2 = [instantiates(New)]
830 ; IDInfo2 = []),
831 stop_constant_profile(SV3,propagate_value,ID,IDInfo2,T1).
832
833 % treat not(Arg1 = Arg2) predicates
834 b_test_atomic_not_equal_boolean_expression(Arg1,Arg2,_Info,LocalState,State,WF) :-
835 get_texpr_type(Arg1,boolean),!, % special treatment : not_equal_object has no type information
836 b_compute_expression(Arg1,LocalState,State,B1,WF),
837 b_compute_expression(Arg2,LocalState,State,B2,WF),
838 negate(B1,B2). % from bool_pred
839 b_test_atomic_not_equal_boolean_expression(Arg1,Arg2,_Info,LocalState,State,WF) :-
840 get_texpr_type(Arg1,integer),
841 preferences:preference(use_clpfd_solver,true),
842 !,
843 % Note: calling b_compute_arith_expression will also instantiate a variable to at least the int(_) skeleton; thereby enabling propagation
844 % this is potentially better than calling the default versions of the predicates, which may wait until the int(_) skeleton is set up before propagation
845 ? b_compute_arith_expression(Arg1,LocalState,State,CLPFD_Expr1,WF),
846 ? b_compute_arith_expression(Arg2,LocalState,State,CLPFD_Expr2,WF),
847 clpfd_interface:clpfd_neq_expr(CLPFD_Expr1,CLPFD_Expr2).
848 b_test_atomic_not_equal_boolean_expression(Arg1,Arg2,_Info,LocalState,State,WF) :-
849 ? b_compute_expression_symbolic(Arg1,LocalState,State,SV1,WF),
850 ? b_compute_expression_symbolic(Arg2,LocalState,State,SV2,WF),
851 kernel_call_predicate_not_equal_object(SV1,SV2,WF,not_equal(Arg1,Arg2)).
852 % Note: symbolic case occurs for symbolic abstract constants f when using DOUBLE_EVALUATION
853 % in the evaluation view which are defined by f = %x... when checking f /=
854
855 % a version of b_compute_expression which does not try to expand comprehension sets
856 % TODO: deal with other constructs which merit symbolic treatment; union of comprehension sets, ...
857 % (see line 147 in AMASS_mchs/oriented_abscissa.mch)
858 b_compute_expression_symbolic(Arg,LocalState,State,Val,WF) :-
859 (Arg = b(comprehension_set(PP,CC),_,InfoCS) % second arg is a comprehension set;
860 -> % print(symbolic(PP)),nl,
861 ? b_compute_comprehension_set_symbolic(PP,CC,InfoCS,LocalState,State,Val,WF)
862 ? ; b_compute_expression(Arg,LocalState,State,Val,WF)
863 ).
864 % ditto for already de-constructed b/3 expression:
865 b_compute_expression2_symbolic(comprehension_set(PP,CC),_,InfoCS,LocalState,State,Val,WF) :- !,
866 b_compute_comprehension_set_symbolic(PP,CC,InfoCS,LocalState,State,Val,WF).
867 b_compute_expression2_symbolic(Arg,Type,Info,LocalState,State,Val,WF) :-
868 b_compute_expression2(Arg,Type,Info,LocalState,State,Val,WF).
869
870 simple_expression(b(A,_,_)) :- simple_expression_aux(A).
871 simple_expression_aux(boolean_true).
872 simple_expression_aux(boolean_false).
873 simple_expression_aux(empty_set).
874 simple_expression_aux(empty_sequence).
875 simple_expression_aux(integer(_)).
876 simple_expression_aux(max_int).
877 simple_expression_aux(min_int).
878 simple_expression_aux(string(_)).
879 simple_expression_aux(value(_)).
880
881
882 is_lambda_result_id(b(identifier('_lambda_result_'),_,_)).
883 % at the moment we only detect those identifiers; the info field is currently not updated for _was_lambda_result_
884 % and not available in other treatmens of _lambda_result_ (in b_enumerate)
885 %is_lambda_result_id(b(identifier(X),_,Info)) :-
886 % memberchk(lambda_result,Info).
887 % (X=='_lambda_result_' -> (memberchk(lambda_result,Info) -> true ; format('~n*** _lambda_result_ without info: ~w~n~N',[Info])) ; memberchk(lambda_result,Info)).
888
889 %:- block b_lambda_result_equal_boolean_expression(-,?,?, -,?). % we now use when above
890 % only compute lambda result when finished finding domain element, i.e., _EWF is grounded
891 b_lambda_result_equal_boolean_expression(SV1,SV2,WF,EWF,WF2) :-
892 kernel_call_predicate_equal_object_optimized(SV1,SV2,WF),
893 % print(' LAMBDA : '), print((SV1,_EWF)),nl,
894 % the inner waitflags are for evaluating the lambda_result Expression; unless there is a WD issue this should
895 % never fail; we can delay the enumeration as much as possible
896 % NOTE: even if SV2 is ground, Arg2 may not be (e.g., if Arg2 = prj2(..,..)(NotGr,Ground))
897 ? blocking_ground_copied_wait_flags(WF2,EWF). % without when we will ground WF0 which is shared with outer WF-store
898 :- block blocking_ground_copied_wait_flags(?,-).
899 blocking_ground_copied_wait_flags(WF2,_) :-
900 ? ground_constraintprop_wait_flags(WF2). % do not ground EF flag, as shared with outer WF and WF2 is copied
901
902 % TO DO: add avl_set+closure expansion
903 %b_test_member_expression(Expr,El,_Set,_LocalState,_State,_WF) :-
904 % print('test member: '),print_bexpr(Expr),nl,fail.
905 b_test_member_expression(TElem,b(Set,Type,Info),LocalState,State,WF) :-
906 ? b_test_member_expression2(Set,Type,Info,TElem,LocalState,State,WF).
907
908 % new profiler
909 %:- use_module('../extensions/profiler/profiler.pl').
910 %:- use_module('../extensions/profiler/profiler_te.pl').
911 %:- enable_profiling(b_test_member_expression2/7).
912
913 % old profiler
914 %:- use_module(covsrc(hit_profiler)).
915
916 b_test_member_expression2(comprehension_set(Par,Cond),_Type,_Info,El,LocalState,State,WF) :-
917 % used to call in next clause below: b_generate_closure_if_necessary(Par,Cond,LocalState,State,SetValue,WF) /* will not expand closure */
918 /* optimized case for dealing with comprehension_set ; however, does not seem to buy anything over older version with b_generate_closure_if_necessary in test 1079 */
919 /* new version buys about 6 % for {x| x:1..400000 & x:{n|n >= 9000 & n<= 600000 & n mod 100 = 0}} (Sep 3 2014) */
920 set_up_typed_localstate(Par,ValueList,_TypedVals,LocalState,NewLocalState,positive),
921 !,
922 convert_list_into_pairs(ValueList,ElementVal),
923 b_compute_expression(El,LocalState,State,ElementVal,WF),
924 b_test_boolean_expression(Cond,NewLocalState,State,WF).
925 b_test_member_expression2(SymbolicSetConstant,_Type,_Info,El,LocalState,State,WF) :-
926 %hit_profiler:add_profile_hit(SymbolicSetConstant),
927 cst_in_boolean_type(SymbolicSetConstant,Module:Kernel_predicate),!, % two cases : string_set and integer_set
928 b_compute_expression(El,LocalState,State,ElValue,WF),
929 functor(KernelCall,Kernel_predicate,2),
930 arg(1,KernelCall,ElValue),
931 arg(2,KernelCall,WF),
932 % print_message(cst_in_boolean_type_call(KernelCall)),
933 kernel_call_predicate(KernelCall,Module,WF,SymbolicSetConstant). % should be member(... SymbolicSetConstant)
934 b_test_member_expression2(Expression,_Type,Info,El,LocalState,State,WF) :-
935 functor(Expression,BOP,2),
936 binary_in_boolean_type(BOP,Module:Kernel_predicate),!,
937 b_compute_expression(El,LocalState,State,ElValue,WF),
938 arg(1,Expression,Arg1),arg(2,Expression,Arg2),
939 (binary_in_definitely_true(BOP,ElValue)
940 -> % no need to compute arguments; unless required for WD:
941 check_well_defined(Arg1,LocalState,State,WF),
942 check_well_defined(Arg2,LocalState,State,WF)
943 ; b_compute_expression(Arg1,LocalState,State,SV1,WF),
944 ? b_compute_expression(Arg2,LocalState,State,SV2,WF),
945 opt_push_wait_flag_call_stack_info(WF,b_operator_call(member,[ElValue,b_operator(BOP,[SV1,SV2])],Info),WF2),
946 % for constant profiling: we could catch partial/total_fun checks here translate:print_bexpr(El),nl,translate:print_bexpr(b(Expression,_Type,Info)),nl,nl,
947 ? binary_in_kernel_call(Module,Kernel_predicate,ElValue,SV1,SV2,WF2,Expression)
948 ).
949 b_test_member_expression2(Expression,_Type,Info,El,LocalState,State,WF) :-
950 functor(Expression,UnOP,1),
951 unary_in_boolean_type(UnOP,Module:Kernel_predicate),!,
952 b_compute_expression(El,LocalState,State,ElValue,WF),
953 arg(1,Expression,Arg1),
954 (unary_in_definitely_true(UnOP,ElValue)
955 -> % no need to compute arguments; unless required for WD:
956 check_well_defined(Arg1,LocalState,State,WF)
957 ; b_compute_expression(Arg1,LocalState,State,SV1,WF),
958 opt_push_wait_flag_call_stack_info(WF,b_operator_call(member,[ElValue,b_operator(UnOP,[SV1])],Info),WF2),
959 ? unary_in_kernel_call(Module,Kernel_predicate,ElValue,SV1,WF2,Expression)
960 ).
961 b_test_member_expression2(SetExpression,Type,Info,El,LocalState,State,WF) :-
962 ? b_compute_expression2(SetExpression,Type,Info,LocalState,State,SetValue,WF),
963 (always_well_defined_or_disprover_mode(El)
964 -> SetValue \== [] % if we have the empty set: check_element will always fail
965 ; true % we could check SetValue \== [] if find_abort_values=false ??
966 ),
967 ? b_compute_expression(El,LocalState,State,Element,WF),
968 Span = El, % Info is quite often the empty list
969 (not_invertible(El) % then no sense in setting up member constraint f(...) : SetValue ;
970 % we cannot used the info anyway; but we could enumerate
971 -> % we wait until Element is fully known before doing the check
972 ground_value_check(Element,GrEl),
973 when(nonvar(GrEl),kernel_call_predicate_check_element_of_wf(Element,SetValue,WF,Span))
974 ? ; kernel_call_predicate_check_element_of_wf(Element,SetValue,WF,Span)).
975
976 :- use_module(external_functions,[external_fun_can_be_inverted/1]).
977 not_invertible(b(E,_,_)) :- not_inv_aux(E).
978 not_inv_aux(external_function_call(FunName,_Args)) :- \+ external_fun_can_be_inverted(FunName).
979 % TO DO: capture other cases like function applications
980 % TO DO: also do this in b_interpreter_check ?
981 % TO DO: We should compute this information in ast_cleanup; e.g., what if we do STRING_TO_INT(s)+1 : SET
982
983 % TO DO: >>> 2:{x,v} --> special case for set_extension([b(identifier(x),integer,[nodeid(none)]),b(identifier(v),integer,[nodeid(none)])]) --> 2=x or 2=v --> evaluate [x,v] -> sort and then use list member (or should b_ast_cleanup do this) ?
984
985 :- use_module(kernel_lists,[not_element_of_list_wf/3]).
986 b_test_notmember_expression(set_extension(Ex),El,_Set,_,LocalState,State,WF) :- !,
987 b_compute_expressions(Ex,LocalState,State,ExValueList,WF),
988 b_compute_expression(El,LocalState,State,ElementVal,WF),
989 not_element_of_list_wf(ElementVal,ExValueList,WF).
990 b_test_notmember_expression(SymbolicSetCst,El,_Set,_,LocalState,State,WF) :-
991 kernel_mappings:cst_not_in_boolean_type(SymbolicSetCst,Module:Kernel_predicate),!,
992 b_compute_expression(El,LocalState,State,ElValue,WF),
993 functor(KernelCall,Kernel_predicate,1),
994 arg(1,KernelCall,ElValue),
995 % debug_print(cst_not_in_boolean_type(9,KernelCall)),
996 kernel_call_predicate(KernelCall,Module,WF,SymbolicSetCst).
997 b_test_notmember_expression(Expression,El,_Set,Info,LocalState,State,WF) :-
998 functor(Expression,BOP,2),
999 kernel_mappings:binary_not_in_boolean_type(BOP,Module:Kernel_predicate),!,
1000 b_compute_expression(El,LocalState,State,ElValue,WF),
1001 \+ binary_in_definitely_true(BOP,ElValue),
1002 arg(1,Expression,Arg1),arg(2,Expression,Arg2),
1003 b_compute_expression(Arg1,LocalState,State,SV1,WF),
1004 b_compute_expression(Arg2,LocalState,State,SV2,WF),
1005 % KernelCall =.. [Kernel_predicate,ElValue,SV1,SV2,WF],
1006 opt_push_wait_flag_call_stack_info(WF,b_operator_call(not_member,[ElValue,b_operator(BOP,[SV1,SV2])],Info),WF2),
1007 ? kernel_call_predicate3(Kernel_predicate,ElValue,SV1,SV2,Module,WF2,Expression).
1008 b_test_notmember_expression(Expression,El,_Set,Info,LocalState,State,WF) :-
1009 functor(Expression,UnOP,1),
1010 unary_not_in_boolean_type(UnOP,Module:Kernel_predicate),!,
1011 b_compute_expression(El,LocalState,State,ElValue,WF),
1012 \+ unary_in_definitely_true(UnOP,ElValue),
1013 arg(1,Expression,Arg1),
1014 b_compute_expression(Arg1,LocalState,State,SV1,WF),
1015 %KernelCall =.. [Kernel_predicate,ElValue,SV1,WF],
1016 %kernel_call_predicate(KernelCall,Module,WF,Expression).
1017 opt_push_wait_flag_call_stack_info(WF,b_operator_call(not_member,[ElValue,b_operator(UnOP,[SV1])],Info),WF2),
1018 kernel_call_predicate2(Kernel_predicate,ElValue,SV1,Module,WF2,Expression).
1019 b_test_notmember_expression(Expr,Elem,Set,_Info,LocalState,State,WF) :-
1020 (Expr=comprehension_set(Par,Cond)
1021 -> b_generate_closure_if_necessary(Par,Cond,LocalState,State,SetValue,WF) /* will not expand closure */
1022 ; b_compute_expression(Set,LocalState,State,SetValue,WF)
1023 ),
1024 (SetValue == []
1025 -> /* nothing can be member of empty set */
1026 check_well_defined(Elem,LocalState,State,WF)
1027 % we could disable this check if find_abort_values=true
1028 ; b_compute_expression(Elem,LocalState,State,ElemValue,WF),
1029 %kernel_call_predicate2(not_element_of_wf,ElemValue,SetValue,kernel_objects,WF,Expr)
1030 %kernel_call_predicate(not_element_of_wf(ElemValue,SetValue,WF),kernel_objects,WF,Expr)
1031 kernel_call_predicate_not_element_of_wf(ElemValue,SetValue,WF)
1032 ).
1033
1034 :- block block_test_implication(?,?,?,?,?,-).
1035 block_test_implication(LHS,RHS,LocalState,State,WF,_WF2) :-
1036 ? b_test_inner_boolean_expression(LHS,LocalState,State,WF),
1037 b_test_inner_boolean_expression(RHS,LocalState,State,WF).
1038 block_test_implication(LHS,_RHS,LocalState,State,WF,_WF2) :-
1039 ? b_not_test_inner_boolean_expression(LHS,LocalState,State,WF).
1040
1041
1042 b_test_equivalence(LHS,RHS,LocalState,State,WF,Ai,Ao) :-
1043 copy_wf_start(WF,equivalence,CWF),
1044 ? if(b_check_boolean_expression(LHS,LocalState,State,CWF,PredRes,Ai,Aii),
1045 ? (b_check_test_equivalence(PredRes,LHS,RHS,LocalState,State,CWF,Aii,Ao),
1046 copy_wf_finish(WF,CWF)),
1047 (% check LHS fails, We could check if RHS can be checked with b_check_boolean_expression
1048 Ai=Ao, get_binary_choice_wait_flag(equivalence,WF,WF2),
1049 b_enum_test_equivalence(LHS,RHS,LocalState,State,WF,WF2,Ai))).
1050 b_not_test_equivalence(LHS,RHS,LocalState,State,WF,Ai,Ao) :-
1051 copy_wf_start(WF,not_equivalence,CWF),
1052 if(b_check_boolean_expression(LHS,LocalState,State,CWF,PredRes,Ai,Aii),
1053 (negate(PredRes,NegPredRes), % from bool_pred
1054 b_check_test_equivalence(NegPredRes,LHS,RHS,LocalState,State,CWF,Aii,Ao),
1055 copy_wf_finish(WF,CWF)),
1056 (% check LHS fails, We could check if RHS can be checked with b_check_boolean_expression
1057 Ai=Ao, get_binary_choice_wait_flag(not_equivalence,WF,WF2),
1058 b_enum_not_test_equivalence(LHS,RHS,LocalState,State,WF,WF2,Ai))).
1059 b_check_test_equivalence(PredRes,LHS,RHS,LocalState,State,WF,Aii,Ao) :-
1060 % print('checking <=> '), print_bexpr(LHS), print(' '), print(PredRes),nl,
1061 ? (var(PredRes),b_check_boolean_expression(RHS,LocalState,State,WF,PredRes2,Aii,Ao) % TO DO <---- REPLACE CUT
1062 -> /* also propagate from right to left */
1063 ? equiv_bidrectional_test_boolean_expression(PredRes,PredRes2,LHS,RHS,LocalState,State,WF)
1064 ; Aii=Ao,
1065 ? equiv_test_boolean_expression(PredRes,pred_true,RHS,LocalState,State,WF,Aii)
1066 ). % should we also add a binary choice flag ?? what about a=2 <=> b/=3 ??
1067
1068 :- block b_enum_test_equivalence(?,?,?,?,?,-,?).
1069 b_enum_test_equivalence(LHS,RHS,LocalState,State,WF,_WF2,Ai) :-
1070 b_test_boolean_expression(LHS,LocalState,State,WF,Ai,Aii), % TO DO: we could call b_test_inner_boolean_expression with Ai
1071 b_test_boolean_expression(RHS,LocalState,State,WF,Aii,_).
1072 b_enum_test_equivalence(LHS,RHS,LocalState,State,WF,_WF2,Ai) :-
1073 b_not_test_boolean_expression(LHS,LocalState,State,WF,Ai,Aii),
1074 b_not_test_boolean_expression(RHS,LocalState,State,WF,Aii,_).
1075
1076 %enumerate_bool(X,WF) :- !.
1077 enumerate_bool(X,Prio,WF) :- (nonvar(X) -> true /* already set */
1078 ; get_wait_flag0(WF,WF0),
1079 enumerate_bool0(X,Prio,WF,WF0)).
1080
1081 :- block enumerate_bool0(?,?,?,-).
1082 enumerate_bool0(X,Prio,WF,_) :- (nonvar(X) -> true /* already set */
1083 ; %print(enum_bool(X)), translate:print_bexpr(LHS),nl,
1084 % get_binary_choice_wait_flag(enumerate_bool,WF,WF2),
1085 get_wait_flag(Prio,enumerate_bool,WF,WF2), % what priority should we use ?? give time for other enumerators to decide the lhs of the disjunct; actions_cbtc is slower to setup with low priority
1086 enumerate_bool_aux(X,WF2)).
1087 :- block enumerate_bool_aux(-,-).
1088 %enumerate_bool_aux(P,WF) :- var(P),print(forcing_bool(P,WF)),nl,fail. %
1089 enumerate_bool_aux(pred_true,_).
1090 enumerate_bool_aux(pred_false,_).
1091
1092 :- block b_test_disjunction(?,?,?,?,?,-,?).
1093 b_test_disjunction(LHS,_RHS,LocalState,State,WF,_WF2,Ai) :-
1094 ? b_test_boolean_expression(LHS,LocalState,State,WF,Ai,_).
1095 b_test_disjunction(LHS,RHS,LocalState,State,WF,_WF2,Ai) :-
1096 ? b_not_test_boolean_expression(LHS,LocalState,State,WF,Ai,Aii),
1097 ? b_test_boolean_expression(RHS,LocalState,State,WF,Aii,_).
1098
1099 :- block b_not_test_conjunction(?,?,?,?,?,-,?).
1100 b_not_test_conjunction(LHS,_RHS,LocalState,State,WF,_WF2,Ai) :-
1101 b_not_test_boolean_expression(LHS,LocalState,State,WF,Ai,_).
1102 b_not_test_conjunction(LHS,RHS,LocalState,State,WF,_WF2,Ai) :-
1103 ? b_test_boolean_expression(LHS,LocalState,State,WF,Ai,Aii),
1104 ? b_not_test_boolean_expression(RHS,LocalState,State,WF,Aii,_).
1105
1106 :- block b_enum_not_test_equivalence(?,?,?,?,?,-,?).
1107 b_enum_not_test_equivalence(LHS,RHS,LocalState,State,WF,_WF2,Ai) :-
1108 b_test_boolean_expression(LHS,LocalState,State,WF,Ai,Aii), % we could call b_test_inner_boolean_expression with Ai
1109 b_not_test_boolean_expression(RHS,LocalState,State,WF,Aii,_).
1110 b_enum_not_test_equivalence(LHS,RHS,LocalState,State,WF,_WF2,Ai) :-
1111 b_not_test_boolean_expression(LHS,LocalState,State,WF,Ai,Aii),
1112 b_test_boolean_expression(RHS,LocalState,State,WF,Aii,_).
1113
1114
1115
1116 /* --------------------------------------*/
1117 /* b_not_test_boolean_expression */
1118 /* --------------------------------------*/
1119
1120 b_not_test_list_of_boolean_expression([],_,_,_WF).
1121 b_not_test_list_of_boolean_expression([B1|T],LS,S,WF) :-
1122 b_not_test_boolean_expression(B1,LS,S,WF),
1123 b_not_test_list_of_boolean_expression(T,LS,S,WF).
1124
1125 :- assert_pre(b_interpreter:b_not_test_boolean_expression_cs(E,LS,S,_,_),
1126 (bsyntaxtree:check_if_typed_predicate(E),type_check(LS,store),type_check(S,store))).
1127 :- assert_post(b_interpreter:b_not_test_boolean_expression_cs(_,_,_,_,_), true).
1128
1129
1130 % a version where we can provide an initial call stack entry for context
1131 b_not_test_boolean_expression_cs(E,LS,S,PredKind,Nr) :-
1132 init_wait_flags_cs(E,PredKind,Nr,b_not_test_boolean_expression_cs,WF), % TODO: we could register negation info
1133 % TO DO: call b_trace_test_components ?
1134 ? b_not_test_boolean_expression(E,LS,S,WF),
1135 ground_wait_flags(WF).
1136
1137 b_not_test_boolean_expression(E,LS,S,WF) :-
1138 ? empty_avl(Ai), b_not_test_boolean_expression(E,LS,S,WF,Ai,_).
1139
1140 :- assert_pre(b_interpreter:b_not_test_boolean_expression(E,LS,S,WF),
1141 (type_check(E,boolean_expression),type_check(LS,store),type_check(S,store), type_check(WF,wait_flag))).
1142 :- assert_post(b_interpreter:b_not_test_boolean_expression(_,_,_,_), true).
1143
1144 :- if(environ(prob_debug_watch_flag,true)).
1145 b_not_test_boolean_expression(b(Expr,_,Infos),LS,S,WF,Ai,Ao) :- !,
1146 (waitflag0_is_set(WF)
1147 -> debug:watch(400,b_interpreter:b_not_test_boolean_expression2(Expr,Infos,LS,S,WF,Ai,Ao))
1148 ; debug:watch_det(400,b_interpreter:b_not_test_boolean_expression2(Expr,Infos,LS,S,WF,Ai,Ao)) ).
1149 :- else.
1150 b_not_test_boolean_expression(b(Expr,Type,Infos),LS,S,WF,Ai,Ao) :- !,
1151 (preference(smt_supported_interpreter,true)
1152 -> b_not_test_boolean_expression2(Expr,Infos,LS,S,WF,Ai,Ao),create_negation(b(Expr,Type,Infos),Neg),
1153 get_wait_flag1(smt_call,WF,BeforeEnumWF),
1154 gensym:gensym(smt_assertion_name,Symbol),
1155 smt_add_predicate(BeforeEnumWF,Neg,LS,S,Symbol)
1156 ? ; b_not_test_boolean_expression2(Expr,Infos,LS,S,WF,Ai,Ao)).
1157 :- endif.
1158 b_not_test_boolean_expression(E,LS,S,WF,Ai,Ao) :-
1159 add_internal_error('Boolean (not) expression not properly wrapped: ',
1160 b_not_test_boolean_expression(E,LS,S,WF,Ai,Ao)),
1161 b_not_test_boolean_expression2(E,[],LS,S,WF,Ai,Ao).
1162
1163 b_not_test_boolean_expression2(truth,_,_,_,_WF,_Ai,_Ao) :- !,fail.
1164 b_not_test_boolean_expression2(falsity,_,_,_,_WF,Ai,Ao) :- !,Ai=Ao. % NOT COVERED (2)
1165 b_not_test_boolean_expression2(negation(BExpr),_,LocalState,State,WF,Ai,Ao) :- !,
1166 b_test_boolean_expression(BExpr,LocalState,State,WF,Ai,Ao).
1167 % following makes test 349 fail:
1168 %b_not_test_boolean_expression2(conjunct(LHS,RHS),Infos,LocalState,State,WF,Ai,Ao) :- !,
1169 % nl, print(' NOT: '),translate:print_bexpr(b(conjunct(LHS,RHS),pred,Infos)),nl,
1170 % create_negation(LHS,NegLHS), % TO DO: avoid this construction by generalising code for disjunct
1171 % create_negation(RHS,NegRHS),
1172 % b_test_boolean_expression2(disjunct(NegLHS,NegRHS),Infos,LocalState,State,WF,Ai,Ao).
1173 b_not_test_boolean_expression2(conjunct(LHS,RHS),Infos,LocalState,State,WF,Ai,Ao) :- !,
1174 b(conjunct(LHS,RHS),pred,Infos) = Conj,
1175 copy_wf_start(WF,not_conjunct,CWF),
1176 ? if(b_check_boolean_expression(Conj,LocalState,State,CWF,PredRes,Ai,Ao),
1177 (PredRes=pred_false,
1178 ? copy_wf_finish(WF,CWF)
1179 ),
1180 if(b_check_boolean_expression(LHS,LocalState,State,CWF,LHSPredRes,Ai,Ao), % some redundant work with call above: TODO: avoid !
1181 (copy_wf_finish(WF,CWF),
1182 get_last_wait_flag(not_conjunct_rhs,WF,WF2), % before starting to enumerate infinite types: better try both possibilities:
1183 ? b_not_test_conjunction_rhs(LHSPredRes,RHS,LocalState,State,WF,Ai,WF2)
1184 ),
1185 (Ai=Ao,
1186 get_priority_of_boolean_expression2(disjunct(LHS,RHS),StartPrio),
1187 %get_wait_flag(Prio,not_conjunct,WF,WF2),
1188 get_binary_choice_wait_flag_exp_backoff(StartPrio,not_conjunct,WF,WF2),
1189 % TO DO: we could check if LHS or RHS are registered in Ai as pred_true/pred_false ??
1190 b_not_test_conjunction(LHS,RHS,LocalState,State,WF,WF2,Ai))
1191 )
1192 ).
1193
1194 b_not_test_boolean_expression2(implication(LHS,RHS),_,LocalState,State,WF,Ai,Ao) :- !,
1195 b_test_boolean_expression(LHS,LocalState,State,WF,Ai,Aii),
1196 ? b_not_test_boolean_expression(RHS,LocalState,State,WF,Aii,Ao).
1197 b_not_test_boolean_expression2(equivalence(LHS,RHS),_,LocalState,State,WF,Ai,Ao) :- !,
1198 b_not_test_equivalence(LHS,RHS,LocalState,State,WF,Ai,Ao).
1199 b_not_test_boolean_expression2(disjunct(LHS,RHS),_,LocalState,State,WF,Ai,Ao) :- !,
1200 b_not_test_boolean_expression(LHS,LocalState,State,WF,Ai,Aii),
1201 b_not_test_boolean_expression(RHS,LocalState,State,WF,Aii,Ao).
1202 b_not_test_boolean_expression2(lazy_let_pred(Id,AssignmentExpr,Expr),_I,LocalState,State,WF,Ai,Ao) :- !,
1203 add_lazy_let_id_and_expression(Id,AssignmentExpr,LocalState,State,NewLocalState,WF,Ai),
1204 b_not_test_boolean_expression(Expr,NewLocalState,State,WF,Ai,Ao). % we could use Ai,Ao version as lazy lets never interfere with each other and never invalidate existing expressions
1205 b_not_test_boolean_expression2(lazy_lookup_pred(Id),_Info,LocalState,_State,WF,Ai,Ao) :- !, Ai=Ao,
1206 lookup_value_for_existing_id_wf(Id,LocalState,(Trigger,Value),WF), % should normally only occur in LocalState; value introduced by lazy_let
1207 (Trigger,Value) = (pred_true,pred_false). % force evaluation
1208 b_not_test_boolean_expression2(value(PredVal),_Info,_LocalState,_State,_WF,Ai,Ao) :- !, % this can occur when lazy_lookup_pred gets compiled by b_compiler
1209 is_pred_false(PredVal),Ai=Ao.
1210 b_not_test_boolean_expression2(Expr,Info,LocalState,State,WF,Ai,Ao) :-
1211 % TO DO: we could put some of the operators into the Ai store (comparison operators)
1212 ? b_not_test_atomic_boolean_expression2(Expr,Info,LocalState,State,WF,Ai,Ao).
1213
1214 % Other boolean expressions, not involving boolean connectives
1215 b_not_test_atomic_boolean_expression2(exists(Parameters,RHS),Infos,LocalState,State,WF,Ai,Ao) :- !,
1216 /* #ID.(RHS) */
1217 Ai=Ao,
1218 ? b_not_test_exists(Parameters,RHS,Infos,LocalState,State,compile,WF).
1219 b_not_test_atomic_boolean_expression2(forall(Parameters,LHS,RHS),Infos,LocalState,State,WF,Ai,Ao) :- !,
1220 /* !ID.(LHS => RHS) */
1221 Ai=Ao,
1222 safe_create_texpr(negation(RHS),pred,Negation),
1223 conjunct_predicates_with_pos_info(LHS,Negation,Condition),
1224 % conjunct_predicates merges the used_ids Info in Condition
1225 ? b_test_exists(Parameters,Condition,Infos,LocalState,State,WF).
1226 /* TODO(DP, 2.8.2008): Extension for Z: a let-statement as predicate */
1227 b_not_test_atomic_boolean_expression2(let_predicate(Ids,AssignmentExprs,Pred),Infos,LocalState,State,WF,Ai,Ao) :-
1228 !,Ai=Ao, % any expression inside the LET cannot be safely reused
1229 ? set_up_localstate_for_let(Ids,ParaValues,AssignmentExprs,LocalState,State,LetState,WF),
1230 opt_push_wait_flag_call_stack_quantifier_info(WF,let_quantifier,Ids,ParaValues,Infos,WF2),
1231 ? b_not_test_boolean_expression(Pred,LetState,State,WF2). % NOT COVERED (10)
1232 /* TODO(DP, 2.8.2008): */
1233 b_not_test_atomic_boolean_expression2(freetype_case(Freetype,Case,Expr),_,LocalState,State,WF,Ai,Ao) :-
1234 !,Ai=Ao,b_compute_expression(Expr,LocalState,State,freeval(Freetype,RealCase,_),WF),
1235 dif(RealCase,Case). % NOT COVERED (11)
1236 b_not_test_atomic_boolean_expression2(finite(SetExpr),_,LocalState,State,WF,Ai,Ao) :-
1237 !, Ai=Ao,b_compute_expression(SetExpr,LocalState,State,Value,WF),
1238 kernel_call_predicate(is_infinite_set_wf(Value,WF),kernel_objects,WF,finite(SetExpr)).
1239 /* Extension for Kodkod */
1240 b_not_test_atomic_boolean_expression2(kodkod(ProblemId,_),_,LocalState,State,WF,Ai,Ao) :-
1241 !,Ai=Ao,get_wait_flag1(kodkod_negative_call,WF,WF0),
1242 kodkod_request(ProblemId,neg,LocalState,State,WF0). % NOT COVERED (12)
1243 b_not_test_atomic_boolean_expression2(partition(LHS,RHS),Info,LocalState,State,WF,Ai,Ao) :- !,
1244 b_interpreter_check:register_predicate(partition(LHS,RHS),Info,pred_false,Reused,Ai,Ao),
1245 (Reused==true -> true
1246 ; b_compute_expression(LHS,LocalState,State,SV1,WF),
1247 l_compute_expression(RHS,LocalState,State,SV2,WF), % RHS is Prolog list of expressions
1248 kernel_call_predicate(not_partition_wf(SV1,SV2,WF),kernel_objects,WF,partition(LHS,RHS))
1249 ).
1250 b_not_test_atomic_boolean_expression2(external_pred_call(FunName,Args),Info,LocalState,State,WF,Ai,Ao) :-
1251 !, Ai=Ao,
1252 (do_not_evaluate_args(FunName) -> EvaluatedArgs=[]
1253 ; b_compute_expressions(Args, LocalState,State, EvaluatedArgs, WF)),
1254 push_wait_flag_call_stack_info(WF,external_call(FunName,EvaluatedArgs,Info),WF2),
1255 call_external_predicate(FunName,Args,EvaluatedArgs,LocalState,State,pred_false,Info,WF2).
1256 b_not_test_atomic_boolean_expression2(Pred,Info,LocalState,State,WF,Ai,Ao) :-
1257 b_interpreter_check:register_predicate(Pred,Info,pred_false,Reused,Ai,Ao),
1258 (Reused==true
1259 -> %% print('REUSED (not): '), translate:print_bexpr(Pred),nl,
1260 true
1261 ? ; b_not_test_atomic_boolean_expression3(Pred,Info,LocalState,State,WF)).
1262 b_not_test_atomic_boolean_expression3(Expression,Info,LocalState,State,WF) :-
1263 functor(Expression,BOP,2),
1264 ? kernel_mappings:negate_binary_boolean_operator(BOP,NBOP),
1265 arg(1,Expression,Arg1),arg(2,Expression,Arg2),!,
1266 NExpression =.. [NBOP,Arg1,Arg2],
1267 ? b_test_atomic_boolean_expression2(NExpression,Info,LocalState,State,WF).
1268 b_not_test_atomic_boolean_expression3(Expression,Info,LocalState,State,WF) :-
1269 functor(Expression,BOP,2),
1270 kernel_mappings:negate_binary_boolean_operator_swap(BOP,NBOP),
1271 arg(1,Expression,Arg1),arg(2,Expression,Arg2),!,
1272 NExpression =.. [NBOP,Arg2,Arg1],
1273 b_test_atomic_boolean_expression2(NExpression,Info,LocalState,State,WF).
1274 b_not_test_atomic_boolean_expression3(E,_,_,_,_WF) :-
1275 add_internal_error('Uncovered boolean expression (not): ',E),
1276 print_functor(E),nl,fail.
1277
1278
1279 % test RHS of not-conjunction depending on outcome of LHS
1280 :- block b_not_test_conjunction_rhs(-,?,?,?,?,?,-).
1281 b_not_test_conjunction_rhs(pred_false,_RHS,_LocalState,_State,_WF,_Ai,_LWF).
1282 b_not_test_conjunction_rhs(pred_true,RHS,LocalState,State,WF,Ai,_LWF) :-
1283 ? b_not_test_boolean_expression(RHS,LocalState,State,WF,Ai,_).
1284
1285 /* -----------------------------*/
1286 /* b_compute_expression */
1287 /* -----------------------------*/
1288
1289
1290
1291 :- assert_must_succeed((b_interpreter:b_compute_expression(b(pow_subset(
1292 b(identifier(nm),set(integer),[])),set(set(integer)),[]),
1293 [], [bind(nm,[])],R,_WF),
1294 nonvar(R), custom_explicit_sets:expand_custom_set_to_list(R,[[]]))).
1295 :- assert_must_succeed((b_interpreter:b_compute_expression(b(pow_subset(
1296 b(identifier(nm),set(boolean),[])),set(set(boolean)),[]),[],
1297 [bind(nm,[pred_false /* bool_false */])],R,_WF),
1298 nonvar(R), custom_explicit_sets:expand_custom_set_to_list(R,ER),
1299 kernel_objects:equal_object(ER,[[pred_false /* bool_false */],[]]))).
1300
1301 :- assert_pre(b_interpreter:b_compute_expression(Exp,LS,State,_Val,WF),
1302 (nonvar(Exp),
1303 bsyntaxtree:check_if_typed_expression(Exp),
1304 type_check(LS,store),type_check(State,store), type_check(WF,wait_flag))).
1305 :- assert_post(b_interpreter:b_compute_expression(_E,_LS,_State,Val,WF),
1306 (b_interpreter:value_type(Val), type_check(WF,wait_flag))). %, nonvar(Val)
1307
1308 b_compute_expression_nowf(E,LS,S,R) :-
1309 b_compute_expression_nowf(E,LS,S,R,none,0).
1310
1311 b_compute_expression_nowf(E,LS,S,R,FormulaKind,Nr) :-
1312 get_texpr_info(E,Info),
1313 ? b_compute_expression_nowf(E,LS,S,R,FormulaKind,Nr,Info).
1314 b_compute_expression_nowf(E,LS,S,R,FormulaKind,Nr,Span) :-
1315 ? b_compute_expression_no_wf8(E,LS,S,R,FormulaKind,Nr,default,Span).
1316 % a variation where we tell ProB to expect non-symbolic / explicit values
1317 b_compute_explicit_epression_no_wf(E,LS,S,R,FormulaKind,Nr) :-
1318 get_texpr_info(E,Info),
1319 ? b_compute_explicit_epression_no_wf(E,LS,S,R,FormulaKind,Nr,Info).
1320 b_compute_explicit_epression_no_wf(E,LS,S,R,FormulaKind,Nr,Span) :-
1321 ? b_compute_expression_no_wf8(E,LS,S,R,FormulaKind,Nr,expect_explicit_value,Span).
1322 b_compute_expression_no_wf8(E,LS,S,R,FormulaKind,Nr,Expect,Span) :-
1323 %add_message(b_compute_expression,'Called Version wo WFLAGS: ', b_compute_expression(E,LS,S,R)),
1324 (Expect=expect_explicit_value -> WFInfos = [expect_explicit_value] ; WFInfos = []),
1325 (FormulaKind = none -> init_wait_flags(WF,WFInfos)
1326 ; CallStackEntry = prob_command_context(eval_expr_command(FormulaKind,Nr),Span),
1327 init_wait_flags_and_push_call_stack(no_wf_available,CallStackEntry,WFInfos,WF)
1328 ),
1329 ? b_compute_expression(E,LS,S,R,WF),
1330 ? ground_wait_flags(WF), % this will add abort errors and fail before enumerating the result:
1331 init_wait_flags(WF2,[b_compute_expression_nowf2]),
1332 get_texpr_type(E,Type),
1333 b_enumerate:b_tighter_enumerate_single_value(R,Type,Span,b_compute_expression_nowf,WF2), %should rarely be necessary
1334 % a non-ground result only occurs when WD error appears and in this case ground_wait_flags will fail after
1335 % adding the abort error (and thus no value is returned)
1336 % exceptions are test 1066 with a complicated set comprehension used in a function application
1337 % test 1861 relies on two phase enumeration
1338 ground_wait_flags(WF2).
1339
1340 l_compute_expression([],_LS,_S,[],_WF).
1341 l_compute_expression([H|T],LS,S,[CH|CT],WF) :-
1342 b_compute_expression(H,LS,S,CH,WF),
1343 l_compute_expression(T,LS,S,CT,WF).
1344
1345 :- if(environ(prob_debug_watch_flag,true)).
1346 b_compute_expressiond(b(Expr,Type,Info),LS,S,R,WF) :- !,
1347 ((ground(Type), Type \== pred, Type \== subst) -> true
1348 ; add_error_wf(b_compute_expression,'Expression has illegal type: ',b(Expr,Type,Info),WF)),
1349 check_value(R,b(Expr,Type,Info)),
1350 b_compute_expression2(Expr,Type,Info,LS,S,R,WF).
1351 :- block check_value(-,?).
1352 check_value(pred_true,_) :- !. check_value(pred_false,_) :- !.
1353 check_value(string(_),_) :- !.
1354 check_value([],_) :- !.
1355 check_value([H|T],E) :- !, check_value(H,E), check_value(T,E).
1356 check_value((A,B),E) :- !, check_value(A,E), check_value(B,E).
1357 check_value(fd(N,T),E) :- !, (nonvar(T) -> check_fd(N,T,E) ; check_err(fd(N,T),E)).
1358 check_value(global_set(GS),E) :- !,(nonvar(GS) -> true ; check_err(global_set(GS),E)).
1359 check_value(avl_set(AS),E) :- !,((nonvar(AS),AS=node(_,_,_,_,_)) -> true ; check_err(global_set(AS),E)).
1360 check_value(int(X),E) :- !,check_int(X,E).
1361 check_value(closure(P,T,B),E) :- !,
1362 (ground(P),ground(T),nonvar(B)
1363 -> (same_length(P,T) -> bsyntaxtree:check_ast(B) ; check_err(closure_not_same_length(P,T)))
1364 ; check_err(closure(P,T,B),E)).
1365 check_value(rec(_),_) :- !. %TODO: check
1366 check_value(X,E) :- check_err(uncovered(X),E).
1367 % TO DO: add records + more thorough checking of global_set and closures and avl_sets
1368 :- block check_int(-,?).
1369 check_int(X,E) :- (number(X) -> true ; check_err(int(X),E)).
1370 :- block check_fd(-,?,?).
1371 check_fd(X,T,E) :- (number(X),b_get_fd_type_bounds(T,Low,Up),X>=Low,X=<Up -> true ; check_err(fd(X,T),E)).
1372
1373 check_err(V,E) :- add_internal_error('Illegal value when computing expression: ',V:E).
1374 b_compute_expression(E,LS,S,R,WF) :- !,
1375 (waitflag0_is_set(WF)
1376 -> debug:watch(100,b_interpreter:b_compute_expressiond(E,LS,S,R,WF))
1377 ; debug:watch_det(100,b_interpreter:b_compute_expressiond(E,LS,S,R,WF))).
1378 :- else.
1379 b_compute_expression(b(Expr,Type,Info),LS,S,R,WF) :- !,
1380 ((ground(Type), Type \== pred, Type \== subst) -> true
1381 ; Type==pred -> add_internal_error_wf(b_interpreter,'Expected expression, not predicate: ',b(Expr,Type,Info),Info,WF)
1382 ; Type==subst -> add_internal_error_wf(b_interpreter,'Expected expression, not substitution: ',b(Expr,Type,Info),Info,WF)
1383 ; add_internal_error_wf(b_interpreter,'Expression has non-ground type: ',b(Expr,Type,Info),Info,WF)
1384 ),
1385 ? b_compute_expression2(Expr,Type,Info,LS,S,R,WF).
1386 :- endif.
1387 b_compute_expression(Expr,LS,S,R,WF) :-
1388 add_internal_error('Expression not properly wrapped: ',b_compute_expression(Expr,LS,S,R,WF)),
1389 b_compute_expression2(Expr,unknown,[],LS,S,R,WF).
1390
1391
1392 :- use_module(bsyntaxtree,[get_texpr_set_type/2]).
1393
1394 %:- use_module(b_global_sets,[b_type2_set/2]).
1395 %b_compute_expression2(V,T,I,LS,S,R,_WF) :- nonvar(R), print('result_instantiated: '(R:V)),nl,fail.
1396 ?b_compute_expression2(value(Val),_T,_I,_LS,_S,V,WF) :- !, equal_object_wf(Val,V,WF). %Val=V.
1397 b_compute_expression2(boolean_true,_T,_I,_LState,_State,Res,_WF) :- !, Res = pred_true /* bool_true */. % for simple types we can use ordinary unification
1398 b_compute_expression2(boolean_false,_T,_I,_LState,_State,Res,_WF) :- !, Res = pred_false /* bool_false */.
1399 b_compute_expression2(integer_set(NSET),_T,_I,_LState,_State,Res,WF) :- !, equal_object_wf(Res,global_set(NSET),WF). %Res = global_set(NSET).
1400 b_compute_expression2(bool_set,_T,_I,_LState,_State,Res,WF) :- !, % b_type2_set(bool,Res).
1401 equal_object_wf(Res,avl_set(node(pred_false,true,1,empty,node(pred_true,true,0,empty,empty))),WF).
1402 % was equal_object(Res,[pred_true /* bool_true */,pred_false /* bool_false */]) % changing this to avl used to break test 800 Bosch Deadlock v9; probably because of identity closure detection instantiation
1403 b_compute_expression2(float_set,_T,_I,_LState,_State,Res,WF) :- !, equal_object_wf(Res,global_set('FLOAT'),WF).
1404 b_compute_expression2(real_set,_T,_I,_LState,_State,Res,WF) :- !, equal_object_wf(Res,global_set('REAL'),WF).
1405 b_compute_expression2(string_set,_T,_I,_LState,_State,Res,WF) :- !, equal_object_wf(Res,global_set('STRING'),WF).
1406 % was all_strings(Res). %% NOT COVERED (6)
1407 b_compute_expression2(string(S),_T,_I,_LState,_State,Res,_WF) :- !,
1408 % TODO(ML,26.8.2008): Check if we should use a different functor for syntax tree vs data
1409 Res = string(S).
1410 b_compute_expression2(typeset,Type,_I,_LState,_State,Res,WF) :- !,
1411 is_set_type(Type,ElType), % we could generate global_set('STRING'),... for certain types
1412 equal_object_wf(Res,closure('_zzzz_unary',[ElType],b(truth,pred,[])),WF).
1413 b_compute_expression2(empty_set,_T,_I,_LState,_State,Res,_WF) :- !, empty_set(Res).
1414 b_compute_expression2(empty_sequence,_T,_I,_LState,_State,Res,_WF) :- !, empty_sequence(Res).
1415 b_compute_expression2(event_b_identity,EType,_I,_LState,_State,Res,WF) :-
1416 get_set_type(EType,couple(Type,Type)),!,
1417 event_b_identity_for_type(Type,Res,WF).
1418 b_compute_expression2(integer(Val),_T,_I,_LocalState,_State,Res,_WF) :- !, Res = int(Val).
1419 b_compute_expression2(max_int,_T,_I,_LS,_S,Res,_WF) :-
1420 preferences:get_preference(maxint,CVal),!, Res = int(CVal).
1421 b_compute_expression2(min_int,_T,_I,_LS,_S,Res,_WF) :-
1422 preferences:get_preference(minint,CVal),!, Res = int(CVal).
1423 b_compute_expression2(identifier(Id),Type,Info,LocalState,State,Res,WF) :- !,
1424 lookup_value_in_store_and_global_sets_wf(Id,Type,LocalState,State,Value,Info,WF),
1425 equal_object_wf(Res,Value,WF).
1426 b_compute_expression2(lazy_lookup_expr(Id),_Type,_Info,LocalState,_State,Res,WF) :- !,
1427 lookup_value_for_existing_id_wf(Id,LocalState,(Trigger,Value),WF), % should normally only occur in LocalState; value introduced by lazy_let
1428 Trigger = pred_true, % force evaluation
1429 equal_object_wf(Res,Value,WF).
1430 b_compute_expression2(lazy_let_expr(Id,AssignmentExpr,Expr),_T,_I,LocalState,State,Value,WF) :-
1431 !,
1432 add_lazy_let_id_and_expression(Id,AssignmentExpr,LocalState,State,NewLocalState,WF),
1433 %Trigger = pred_true, % expressions cannot be delayed !? (TO DO: more refined check)
1434 %block_lazy_compute_expression(Trigger,_,AssignmentExpr,LocalState,State,IdValue,WF,Ai),
1435 b_compute_expression(Expr,NewLocalState,State,Value,WF).
1436 b_compute_expression2(real(Atom),_T,_I,_LocalState,_State,Res,_WF) :- !, construct_real(Atom,Res).
1437 b_compute_expression2(rec(Fields),_T,_I,LocalState,State,Record,WF) :- !,
1438 ? l_compute_field(Fields,LocalState,State,FieldValues,WF),
1439 ? construct_record_wf(FieldValues,Record,WF).
1440 b_compute_expression2(record_field(RecEx,Name),_T,_I,LocalState,State,Value,WF) :- !,
1441 ? b_compute_expression(RecEx,LocalState,State,RecValue,WF),
1442 access_record_wf(RecValue,Name,Value,WF).
1443 b_compute_expression2(freetype_set(Id),_T,_I,_LState,_State,Val,_WF) :- !, Val=freetype(Id). %% NOT COVERED (17)
1444 b_compute_expression2(function(Function,FunArg),Type,Info,LocalState,State,Res,WF) :- !,
1445 ? b_compute_expression_function(Function,FunArg,Type,Info,LocalState,State,Res,WF).
1446 b_compute_expression2(card(b(Arg1,Type,Info)),integer,OuterInfo,LocalState,State,Card,WF) :- !,
1447 ? b_compute_card(Arg1,Type,Info,OuterInfo,LocalState,State,Card,WF).
1448 b_compute_expression2(max(b(Arg1,Type,Info)),integer,_I,LocalState,State,Max,WF) :- !,
1449 b_compute_max(Arg1,Type,Info,LocalState,State,Max,WF).
1450 b_compute_expression2(min(b(Arg1,Type,Info)),integer,_I,LocalState,State,Min,WF) :- !,
1451 ? b_compute_min(Arg1,Type,Info,LocalState,State,Min,WF).
1452 b_compute_expression2(set_extension(Ex),Type,_I,LocalState,State,Res,WF) :- !,
1453 ? b_compute_expressions(Ex,LocalState,State,ExValue,WF),
1454 kernel_call(b_interpreter:convert_list_of_expressions_into_set_wf(ExValue,ValueSet,Type,WF),ExValue,WF, set_extension(Ex)),
1455 ? equal_object_wf(Res,ValueSet,WF).
1456 %kernel_call_convert_list_of_expressions_into_set_wf(ExValue,ValueSet,Type, WF).
1457 %b_compute_expression('ListTermes'(ListOfEx),LocalState,State,ValueSet,WF) :- !,
1458 % /* convert list of expressions of CASE statement into set of elements */
1459 % b_compute_expression(ListOfEx,LocalState,State,Value,WF),
1460 % init_wait_flags(WF),convert_list_of_expressions_into_set_wf(Value,ValueSet,set(any),WF),ground_wait_flags(WF).
1461 b_compute_expression2(sequence_extension(Ex),_T,_I,LocalState,State,ValueSeq,WF) :- !,
1462 ? b_compute_expressions(Ex,LocalState,State,Value,WF),
1463 kernel_call(b_interpreter:convert_list_of_expressions_into_sequence(Value,ValueSeq),Value,WF,sequence_extension(Ex)).
1464 b_compute_expression2(convert_bool(PRED),_T,_I,LocalState,State,Val,WF) :- !, /* B bool(.) operator */
1465 b_convert_bool(PRED,LocalState,State,WF,Val).
1466 b_compute_expression2(couple(El1,El2),_T,_I,LocalState,State,Result,WF) :- !, Result = (Val1,Val2),
1467 ? b_compute_expression(El1,LocalState,State,Val1,WF),
1468 ? b_compute_expression(El2,LocalState,State,Val2,WF).
1469 b_compute_expression2(comprehension_set(Parameters,Condition),_T,Info,LocalState,State,Result,WF) :- !,
1470 ? b_compute_comprehension_set(Parameters,Condition,Info,LocalState,State,Result,WF).
1471 b_compute_expression2(recursive_let(TId,TSet),OrigType,OrigInfo,LocalState,State,Result,WF) :- !,
1472 % LET TId = TSet in TSet
1473 ( get_texpr_expr(TSet,comprehension_set(Parameters,Condition)) ->
1474 true % if the argument TSet is a comprehension set,
1475 % we just add a recursive parameter
1476 ; get_texpr_set_type(TSet,Type) ->
1477 % if not, we construct a new comprehension set {x | x:TSet}
1478 unique_typed_id("_tmparg_",Type,TArg),
1479 Parameters=[TArg],
1480 safe_create_texpr(member(TArg,TSet),pred,Condition)
1481 ;
1482 add_internal_error('Expected set as argument to recursive_let',
1483 b_compute_expression2(recursive_let(TId,TSet),OrigType,OrigInfo,LocalState,State,Result,WF)),fail
1484 ),
1485 % Generate closure where the references to the recursion are kept
1486 % add recursion ID to parameters to prevent removal of references during compilation
1487 generate_recursive_closure(TId,recursion,[TId|Parameters],Condition,LocalState,State,Closure1,WF),
1488 % add_message(b_interpreter,'Recursive Let for: ',TId,TId),
1489 % remove recursion ID from parameters after compilation
1490 Closure1=closure([_|P],[_|T],Cond),RClosure=closure(P,T,Cond),
1491 % Generate closure where the references to the recursion are kept
1492 generate_recursive_closure(TId,RClosure,Parameters,Condition,LocalState,State,Result,WF).
1493 b_compute_expression2(general_sum(Ids,Condition,Expression),Type,Info,LocalState,State,SumResult,WF) :- !,
1494 b_general_sum_or_mul(Ids,Condition,Expression,Type,Info,LocalState,State,SumResult,WF,sum).
1495 b_compute_expression2(general_product(Ids,Condition,Expression),Type,Info,LocalState,State,MulResult,WF) :- !,
1496 b_general_sum_or_mul(Ids,Condition,Expression,Type,Info,LocalState,State,MulResult,WF,mul).
1497 /* Begin: Extensions for Z */
1498 b_compute_expression2(if_then_else(If,Then,Else),T,_I,LocalState,State,Value,WF) :- !,
1499 opt_push_wait_flag_call_stack_info(WF,b_expr_call(if_test,If),WF2),
1500 ? b_try_check_boolean_expression_wf(If,LocalState,State,WF2,PredRes),
1501 (var(PredRes), can_get_full_fd_value(T), preferences:preference(use_clpfd_solver,true),
1502 always_well_defined(Then), always_well_defined(Else)
1503 % Note: always_well_defined_or_disprover_mode probably not ok, as we evaluate the expressions unconditionally
1504 -> b_clpfd_if_then_else(PredRes,T,Then,Else,LocalState,State,Value,WF)
1505 ? ; b_compute_if_then_else(PredRes,Then,Else,LocalState,State,Value,WF)
1506 ).
1507 b_compute_expression2(let_expression_global(Ids,AssignmentExprs,Expr),_T,Info,LocalState,State,Value,WF) :-
1508 debug_println(4,global_let(Ids,Info)),
1509 % store variables globally (not in LocalState) to be visible to subsidiary operation_calls
1510 !, set_up_localstate_for_global_let(Ids,AssignmentExprs,LocalState,State,LetState,WF),
1511 b_compute_expression(Expr,LocalState,LetState,Value,WF).
1512 b_compute_expression2(let_expression(Ids,AssignmentExprs,Expr),_T,_I,LocalState,State,Value,WF) :-
1513 ? !, set_up_localstate_for_let(Ids,_ParaValues,AssignmentExprs,LocalState,State,LetState,WF),
1514 ? b_compute_expression(Expr,LetState,State,Value,WF). %% NOT COVERED (30)
1515 b_compute_expression2(freetype_constructor(Id,Case,Expr),_T,_I,LocalState,State,FreeValue,WF) :-
1516 !, FreeValue = freeval(Id,Case,Value),
1517 b_compute_expression(Expr,LocalState,State,Value,WF). %% NOT COVERED (32)
1518 b_compute_expression2(freetype_destructor(Id,Case,Expr),_T,Info,LocalState,State,Value,WF) :-
1519 !, b_compute_expression(Expr,LocalState,State,freeval(Id,VCase,VValue),WF),
1520 check_freetype_case(Id,Case,VCase,VValue,Value,Info,WF).
1521 /* End: Extensions for Z */
1522 b_compute_expression2(assertion_expression(Cond,ErrMsg,Expr),T,Info,LocalState,State,Value,WF) :- !,
1523 opt_push_wait_flag_call_stack_info(WF,
1524 span_predicate(b(assertion_expression(Cond,ErrMsg,b(value(string('')),string,[])),T,Info),LocalState,State),WF2),
1525 % should we use another term for call stack?
1526 (get_preference(disprover_mode,true) -> PredRes = pred_true ; true), % in Disprover mode we know Cond must be true
1527 b_try_check_boolean_expression_no_enum_wf(Cond,LocalState,State,WF2,PredRes), % DO NOT ENUM, unless we cannot reify
1528 % does not make sense to enumerate PredRes as with pred_false we get no value anyway
1529 % however, we may get pending co-routines if Cond cannot be reified
1530 ( PredRes==pred_false ->
1531 translate_bexpression_with_limit(Cond,100,CS),
1532 add_wd_error_span(ErrMsg,CS,span_predicate(Cond,LocalState,State),WF2),
1533 get_last_wait_flag(assertion_expression,WF2,WFC),
1534 when(nonvar(WFC),
1535 (ground_value(Value) -> true % we have a WD Error, any Value goes
1536 ; b_compute_expression(Expr,LocalState,State,Value,WF2) % compute Value; avoid infinite enumeration of possible values; useful e.g. for prj1/prj2 assertion expressions
1537 ))
1538 ? ; b_compute_expression(Expr,LocalState,State,Value,WF),
1539 add_wd_error_if_false(PredRes,ErrMsg,Cond,span_predicate(Cond,LocalState,State),WF2)
1540 ). %% NOT COVERED (34)
1541 b_compute_expression2(multiplication(Arg1,Arg2),integer,Info,LocalState,State,Value,WF) :-
1542 same_texpr(Arg1,Arg2), !, % is less useful when CLPFD is already turned on, calls square(Arg1,Value,WF)
1543 b_compute_expression(Arg1,LocalState,State,SV1,WF),
1544 unary_kernel_call(kernel_objects,square,SV1,Value,WF,multiplication(Arg1,Arg1),integer,Info).
1545 b_compute_expression2(image(Relation,Set),_EType,_Info,LocalState,State,Value,WF) :-
1546 special_operator_for_image(Relation,Kind,Args),
1547 % we have closure1(Rel)[Set] or similar -> avoid computing full closure
1548 !,
1549 ? b_compute_expression(Set,LocalState,State,SV,WF),
1550 b_compute_expressions(Args,LocalState,State,EArgs,WF),
1551 ? kernel_call(bsets_clp:image_for_special_operator(Kind,EArgs,SV,Value,WF),[SV|EArgs],WF,image(Relation,Set)).
1552 b_compute_expression2(external_function_call(FunName,Args),EType,Info,LocalState,State,Value,WF) :-
1553 !,
1554 ? b_compute_expressions(Args, LocalState,State, EvaluatedArgs, WF),
1555 push_wait_flag_call_stack_info(WF,external_call(FunName,EvaluatedArgs,Info),WF2),
1556 ? call_external_function(FunName,Args,EvaluatedArgs,Value,EType,Info,WF2).
1557 b_compute_expression2(Expression,EType,Info,LocalState,State,Res,WF) :-
1558 is_set_type(EType,Type),
1559 /* avoid evaluating certain expensive expressions:
1560 convert them into symbolic closures and expand only if really required */
1561 functor(Expression,UnOp,1),
1562 symbolic_closure_unary_operator(UnOp),
1563 /* TO DO: UNFOLD THIS OR WRAP in CONSTRUCTOR */
1564 arg(1,Expression,BType),
1565 !, %preferences:get_preference(convert_types_into_closures,true),!,
1566 % print_message(delayed_un_op(UnOp,BType)),
1567 ? b_compute_expression(BType,LocalState,State,ArgValue,WF),
1568 ( do_not_keep_symbolic_unary(UnOp,ArgValue),
1569 unary_function(UnOp,Module,KernelFunction) ->
1570 /* special treatment for empty set or other situations: no need to keep symbolic */
1571 ? unary_kernel_call(Module,KernelFunction,ArgValue,Res,WF,Expression,EType,Info)
1572 ;
1573 get_texpr_type(BType,ArgType),
1574 create_texpr(value(ArgValue),ArgType,[],TValue),
1575 ClosureSetExpression =.. [UnOp,TValue],
1576 construct_member_closure('_zzzz_unary',Type,Info,ClosureSetExpression,Value),
1577 ? ((unop_to_be_marked_as_symbolic(UnOp,ArgValue) ; member(prob_annotation('SYMBOLIC'),Info)) ->
1578 mark_closure_as_symbolic(Value,SValue),
1579 equal_object_wf(Res,SValue,WF)
1580 ; equal_object_wf(Res,Value,WF))
1581
1582 ).
1583 b_compute_expression2(Expression,EType,Info,LocalState,State,Res,WF) :-
1584 is_set_type(EType,Type),
1585 /* avoid evaluating certain expensive expressions:
1586 convert them into symbolic closures and expand only if really required */
1587 functor(Expression,BinOp,2),
1588 arg(1,Expression,BType1),
1589 arg(2,Expression,BType2),
1590 kernel_mappings:symbolic_closure_binary_operator(BinOp),
1591 !,
1592 %preferences:get_preference(convert_types_into_closures,true),!,
1593 ? b_compute_expression(BType1,LocalState,State,ArgValue1,WF),
1594 (binary_arg1_determines_value(BinOp,ArgValue1,DetResult)
1595 -> /* print(det(BinOp,ArgValue1)),nl, */
1596 equal_object_wf(Res,DetResult,b_compute_expression2(BinOp),WF)
1597 ; b_compute_expression(BType2,LocalState,State,ArgValue2,WF),
1598 % print_message(delayed_bin_op(BinOp,ArgValue1,ArgValue2)),
1599 (is_definitely_empty(BinOp,ArgValue1,ArgValue2)
1600 -> empty_set(Res)
1601 ; if(do_not_keep_symbolic(BinOp,ArgValue1,ArgValue2,ERes,WF),
1602 % then:
1603 equal_object_wf(Res,ERes,b_compute_expression2(BinOp),WF),
1604 % else:
1605 (get_texpr_type(BType1,TypeArg1), create_texpr(value(ArgValue1),TypeArg1,[],TArg1),
1606 get_texpr_type(BType2,TypeArg2), create_texpr(value(ArgValue2),TypeArg2,[],TArg2),
1607 ClosureSetExpression =.. [BinOp,TArg1,TArg2],
1608 construct_member_closure('_zzzz_unary',Type,Info,ClosureSetExpression,Value),
1609 % print('Constructed Symbolic Closure : '), translate:print_bvalue(Value),nl,
1610 ? (binop_to_be_marked_as_symbolic(BinOp,ArgValue1,ArgValue2) ->
1611 mark_closure_as_symbolic(Value,SValue),
1612 equal_object_wf(Res,SValue,WF)
1613 ; equal_object_wf(Res,Value,WF))
1614 )
1615 ) % if
1616 )
1617 ).
1618 b_compute_expression2(Expression,Type,Info,LocalState,State,Value,WF) :-
1619 functor(Expression,Op,1),
1620 unary_function(Op,Module,KernelFunction),
1621 arg(1,Expression,Arg1),!,
1622 %opt_push_wait_flag_call_stack_info(WF,b_operator_arg_evaluation(Op,1,[SV1],Arg1),WF1),
1623 ? b_compute_expression(Arg1,LocalState,State,SV1,WF),
1624 ? unary_kernel_call(Module,KernelFunction,SV1,Value,WF,Expression,Type,Info).
1625 b_compute_expression2(Expression,Type,Info,LocalState,State,Value,WF) :-
1626 functor(Expression,Op,2),
1627 binary_function(Op,Module,KernelFunction),
1628 arg(1,Expression,Arg1),
1629 arg(2,Expression,Arg2),!,
1630 %opt_push_wait_flag_call_stack_info(WF,b_operator_arg_evaluation(Op,1,[SV1,_],Arg1),WF1),
1631 ? b_compute_expression(Arg1,LocalState,State,SV1,WF),
1632 (binary_arg1_determines_value(Op,SV1,Result) % we could disable this if find_abort_values=true or if SV1 not guaranteed to be wd
1633 ->
1634 equal_object_wf(Value,Result,b_compute_expression2(Op),WF)
1635 ? ; b_compute_expression(Arg2,LocalState,State,SV2,WF),
1636 ? binary_kernel_call(Module,KernelFunction,SV1,SV2,Value,WF,Expression,Type,Info)
1637 ).
1638 b_compute_expression2(operation_call_in_expr(Operation,Parameters),_T,Info,LocalState,State,Value,WF) :-
1639 !, def_get_texpr_id(Operation,op(OperationName)),
1640 % TODO: check that this is a query operation; probably done in type checker
1641 b_execute_operation_in_expression(OperationName,LocalState,State,Parameters,Value,Info,WF).
1642 b_compute_expression2(E,T,Info,_L,_S,_R,_WF) :-
1643 (T==pred -> add_internal_error('Uncovered expression; looks like a predicate in the wrong place: ',b(E,T,Info))
1644 ; T==subst -> add_internal_error('Uncovered expression; looks like a substitution in the wrong place: ',b(E,T,Info))
1645 ; requires_cleanup_pre(E) -> add_internal_error('Non-cleaned up ambiguous expression: ',b(E,T,Info))
1646 ; add_internal_error('Uncovered expression: ',b(E,T,Info))
1647 ),
1648 print_functor(E), print(' : '), print(T),nl,fail.
1649
1650 requires_cleanup_pre(mult_or_cart(_,_)).
1651 requires_cleanup_pre(minus_or_set_subtract(_,_)).
1652
1653 make_couplise([A],R) :- !,R=A.
1654 make_couplise([A,B],R) :- !,R=(A,B).
1655 make_couplise([A,B|Rest],Result) :- !,
1656 make_couplise([(A,B)|Rest],Result).
1657 make_couplise(A,_) :- add_internal_error('Illegal operation call result:',A),fail.
1658
1659 % ---
1660
1661
1662 % check if a symbolic_closure_unary_operator result should be marked with prob_annotation(SYMBOLIC)
1663 % because direct sub-args are marked SYMBOLIC
1664 unop_to_be_marked_as_symbolic(UnOp,Value) :- nonvar(Value),
1665 ? to_be_marked_as_symbolic_aux(UnOp,Value).
1666 to_be_marked_as_symbolic_aux(struct,rec(Fields)) :- !,
1667 ? member(field(_,SymbolicClosure),Fields),
1668 ? is_symbolic_closure(SymbolicClosure).
1669 %to_be_marked_as_symbolic_aux(pow_subset,SymbolicClosure) :- is_symbolic_closure(SymbolicClosure).
1670 %to_be_marked_as_symbolic_aux(pow1_subset,SymbolicClosure) :- is_symbolic_closure(SymbolicClosure).
1671 ?to_be_marked_as_symbolic_aux(_,SymbolicClosure) :- is_symbolic_closure(SymbolicClosure).
1672
1673 % check if a symbolic_closure_binary_operator result should be marked with prob_annotation(SYMBOLIC)
1674 % because direct sub-args are marked SYMBOLIC
1675 binop_to_be_marked_as_symbolic(interval,_,_) :- !, fail.
1676 %binop_to_be_marked_as_symbolic(overwrite,_,_) :- !, true. % TO DO: fix by detecting infinite <+ closures
1677 ?binop_to_be_marked_as_symbolic(set_subtraction,ArgVal1,_) :- !, is_symbolic_closure(ArgVal1).
1678 binop_to_be_marked_as_symbolic(intersection,ArgVal1,ArgVal2) :-
1679 ? (finite_reasonably_sized_set(ArgVal1) ; finite_reasonably_sized_set(ArgVal2)), !,
1680 fail. % intersection is finite and reasonably sized
1681 ?binop_to_be_marked_as_symbolic(_,ArgVal1,_) :- is_symbolic_closure(ArgVal1).
1682 ?binop_to_be_marked_as_symbolic(_,_,ArgVal2) :- is_symbolic_closure(ArgVal2).
1683 % ---
1684
1685 % check if we have a finite known set that can be reasonably represented
1686 % see small_known_set/1 is kernel_mappings
1687 finite_reasonably_sized_set(AVL) :- nonvar(AVL), AVL=avl_set(_). % already expanded; so it can be represented in memory
1688 finite_reasonably_sized_set(Closure) :- nonvar(Closure),
1689 custom_explicit_sets:is_interval_closure(Closure,From,To), integer(From), integer(To),
1690 1+To-From < 250000. % what value should we use here?
1691
1692 lazy_compute_expression(TRIGGER,AssignmentExpr,LocalState,State,IdValue,WF,Ai) :-
1693 get_enumeration_finished_wait_flag(WF,F),
1694 block_lazy_compute_expression(TRIGGER,F,AssignmentExpr,LocalState,State,IdValue,WF,Ai).
1695
1696 :- block block_lazy_compute_expression(-,-,?,?,?, ?,?,?).
1697 block_lazy_compute_expression(TRIGGER,_F,_AssignmentExpr,_LocalState,_State,_IdValue,_WF,_Ai) :-
1698 var(TRIGGER),!.
1699 block_lazy_compute_expression(pred_true,_,AssignmentExpr,LocalState,State,IdValue,WF,Ai) :-
1700 AssignmentExpr = b(Expr,Type,Infos),
1701 (Type \== pred -> b_compute_expression2(Expr,Type,Infos,LocalState,State,IdValue,WF)
1702 ; IdValue == pred_true -> b_test_boolean_expression2(Expr,Infos,LocalState,State,WF,Ai,_)
1703 ; IdValue == pred_false -> b_not_test_boolean_expression2(Expr,Infos,LocalState,State,WF,Ai,_)
1704 ; b_check_boolean_expression(AssignmentExpr,LocalState,State,WF,PredVal,Ai,_) -> IdValue = PredVal
1705 ; % reification of check_boolean_expression failed:
1706 b_try_check_failed(AssignmentExpr,LocalState,State,'$ENUMERATION',WF,IdValue,'$GENERATE_ON_DEMAND')
1707 ).
1708 block_lazy_compute_expression(pred_false,_,_AssignmentExpr,_LocalState,_State,[],_WF,_Ai). % maybe generate any value ??
1709
1710 % ---
1711
1712 :- block add_wd_error_if_false(-,?,?,?,?).
1713 add_wd_error_if_false(pred_true,_,_,_,_).
1714 add_wd_error_if_false(pred_false,ErrMsg,Cond,Span,WF) :-
1715 translate_bexpression_with_limit(Cond,100,CS),
1716 %(Span=span_predicate(P,LS,State) -> tcltk_interface:write_dot_file_for_pred_expr_and_state(P, LS, State,'/tmp/prob_wd_error.dot') ; true),
1717 add_wd_error_span(ErrMsg,CS,Span,WF).
1718
1719 % ---
1720
1721
1722 :- use_module(kernel_tools,[ground_value/1]).
1723 % compute function application:
1724 b_compute_expression_function(Function,FunArg,Type,Info,LocalState,State,Res,WF) :-
1725 preferences:preference(find_abort_values,false), % the treatment below will not check, e.g., if the set extension is really a function
1726 is_extension_function(Function,FInfo,ExFun), !,
1727 /* a set extension applied to an argument: in some cases we can can first evaluate the argument,
1728 and then avoid having to compute the set_extension for all non-matching args */
1729 b_compute_expression(FunArg,LocalState,State,ArgValue,WF),
1730 % TO DO : should we only do this if ArgValue is known ?? otherwise the standard treatment is better ??
1731 % Note: b_compiler has a special rule to not remove this optimisation
1732 Span = span_predicate(b(function(Function,FunArg),Type,Info),LocalState,State),
1733 opt_push_wait_flag_call_stack_info(WF,function_call(Function,ArgValue,Info),WF2), % small performance hit; hence we only push onto call_stack in TRACE_INFO mode
1734 ((memberchk(contains_wd_condition,FInfo) ; % relevant for test 1302; but machine seems to contain real WD error
1735 preferences:preference(use_clpfd_solver,false) ;
1736 ground_value(ArgValue))
1737 -> b_apply_function_set_extension(ExFun,ArgValue,LocalState,State,Res,WF2,Span)
1738 ; /* the standard treatment can infer information about the result,... in clpfd_mode */
1739 b_compute_expression(Function,LocalState,State,FValue,WF),
1740 get_texpr_type(Function,FunctionType),
1741 kernel_call_apply_to(FValue,ArgValue,Res,FunctionType,Span,WF2)).
1742 %b_compute_expression_function(b(comprehension_set(Parameters,Condition),_,SInfo),Arg,Type,Info,LocalState,State,Value,WF) :- !,
1743 % b_compute_comprehension_set_symbolic(Parameters,Condition,SInfo,LocalState,State,FValue,WF),
1744 % b_compute_expression(Arg,LocalState,State,ArgValue,WF),
1745 % Span = span_predicate(b(function(Function,Arg),Type,Info),LocalState,State),
1746 % get_texpr_type(Function,FunctionType),
1747 % kernel_call_apply_to(FValue,ArgValue,Value,FunctionType,Span,WF).
1748 b_compute_expression_function(Function,FunArg,_Type,Info,LocalState,State,Value,WF) :-
1749 special_operator_for_image(Function,Kind,Args),!, % detect e.g. iterate(rel,k)(x)
1750 b_compute_expression(FunArg,LocalState,State,SV,WF),
1751 b_compute_expressions(Args,LocalState,State,EArgs,WF),
1752 kernel_call(bsets_clp:apply_fun_for_special_operator(Kind,EArgs,SV,Value,WF,Info),
1753 [SV|EArgs],WF,function(Function,FunArg)).
1754 b_compute_expression_function(Function,Arg,Type,Info,LocalState,State,Value,WF) :-
1755 opt_push_wait_flag_call_stack_info(WF,function_call(Function,ArgValue,Info),WF2),
1756 ? b_compute_expression(Function,LocalState,State,FValue,WF2),
1757 ? b_compute_expression(Arg,LocalState,State,ArgValue,WF2),
1758 Span = span_predicate(b(function(Function,Arg),Type,Info),LocalState,State),
1759 get_texpr_type(Function,FunctionType),
1760 % TODO: do we still need the span predicate when we have the function_call call_stack infos?
1761 ? kernel_call_apply_to(FValue,ArgValue,Value,FunctionType,Span,WF2).
1762
1763
1764 :- use_module(bsyntaxtree,[get_set_type/2,is_set_type/2]).
1765 :- use_module(kernel_cardinality_attr,[finite_cardinality_as_int_with_type_wf/5]).
1766 b_compute_card(Arg1,Type,Info,OuterInfo,LocalState,State,Card,WF) :-
1767 ? b_compute_card2(Arg1,Type,Info,OuterInfo,LocalState,State,Card,WF),
1768 % maybe we should move this code below inside kernel_objects ??
1769 (ground(Card) -> true
1770 ; get_set_type(Type,SetElType), % TO DO: only needed for cardinality_of_set_extension_list
1771 ? kernel_objects:max_cardinality(SetElType,MaxCard), % this could be precomputed statically
1772 (number(MaxCard) -> kernel_objects:in_nat_range(Card,int(0),int(MaxCard))
1773 ; kernel_objects:greater_than_equal(Card,int(0)) % not sure this is required
1774 )
1775 ).
1776 b_compute_card2(set_extension(Ex),_,_,_,LocalState,State,Card,WF) :- !,
1777 b_compute_expressions(Ex,LocalState,State,ExValue,WF),
1778 kernel_objects:cardinality_of_set_extension_list(ExValue,Card,WF).
1779 b_compute_card2(range(F),_,_,_,LocalState,State,Card,WF) :- !,
1780 b_compute_expression(F,LocalState,State,SV1,WF),
1781 kernel_objects:cardinality_of_range(SV1,Card,WF).
1782 b_compute_card2(comprehension_set(Parameters,Condition),Type,Info,OuterInfo,LocalState,State,Card,WF) :- !,
1783 get_set_type(Type,SetElType),
1784 % ensure that we keep the closure and don't expand it:
1785 ? b_compute_comprehension_set_symbolic(Parameters,Condition,Info,LocalState,State,SV1,WF),
1786 ? kernel_mappings:must_succ_kernel_call(
1787 kernel_cardinality_attr:finite_cardinality_as_int_with_type_wf(SV1,SetElType,OuterInfo,Card,WF),SV1,WF,card).
1788 % TO DO: treat comprehension set + things like card({x|x>1 & x<2**e & x mod 2 = 0}) = 0
1789 b_compute_card2(Arg1,Type,Info,OuterInfo,LocalState,State,Card,WF) :-
1790 get_set_type(Type,SetElType),
1791 b_compute_expression2(Arg1,Type,Info,LocalState,State,SV1,WF),
1792 ? kernel_mappings:must_succ_kernel_call(
1793 kernel_cardinality_attr:finite_cardinality_as_int_with_type_wf(SV1,SetElType,OuterInfo,Card,WF),SV1,WF,card).
1794
1795 b_compute_max(set_extension(Ex),_,Info,LocalState,State,Max,WF) :- !,
1796 b_compute_expressions(Ex,LocalState,State,ExValue,WF),
1797 kernel_objects:maximum_of_set_extension_list(ExValue,Max,Info,WF).
1798 b_compute_max(Arg1,Type,Info,LocalState,State,Max,WF) :-
1799 b_compute_expression2_symbolic(Arg1,Type,Info,LocalState,State,SV1,WF),
1800 kernel_mappings:must_succ_kernel_call(kernel_objects:maximum_of_set(SV1,Max,Info,WF),SV1,WF,max).
1801
1802 b_compute_min(set_extension(Ex),_,Info,LocalState,State,Min,WF) :- !,
1803 ? b_compute_expressions(Ex,LocalState,State,ExValue,WF),
1804 kernel_objects:minimum_of_set_extension_list(ExValue,Min,Info,WF).
1805 /* doesnot really buy a lot: */
1806 /*b_compute_min(union(Arg1,Arg2),_,Info,LocalState,State,Min,WF) :-
1807 Arg1 = b(set_extension(Ex),Type1,Info1),
1808 !,
1809 b_compute_min(set_extension(Ex),Type1,Info1,LocalState,State,Min1,WF),
1810 b_compute_expression(Arg2,LocalState,State,SV2,WF),
1811 b_compute_min2(SV2,Min1,Min,Info,WF).
1812 :- block b_compute_min2(-,?,?,?,?).
1813 b_compute_min2([],Min1,Res,_,_WF) :- !, Res=Min1.
1814 b_compute_min2(SV1,Min1,Res,Info,WF) :-
1815 kernel_mappings:must_succ_kernel_call(kernel_objects:minimum_of_set(SV1,Min2,Info,WF),SV1,WF,min),
1816 min(Min1,Min2,Res).
1817 min(int(A),int(B),int(Res)) :- kernel_objects:minimum(A,B,Res). */
1818 b_compute_min(Arg1,Type,Info,LocalState,State,Min,WF) :-
1819 b_compute_expression2_symbolic(Arg1,Type,Info,LocalState,State,SV1,WF),
1820 kernel_mappings:must_succ_kernel_call(kernel_objects:minimum_of_set(SV1,Min,Info,WF),SV1,WF,min).
1821
1822 generate_recursive_closure(TRecId,RecValue,Parameters,Condition,LocalState,State,Result,WF) :-
1823 get_texpr_id(TRecId,RecId),
1824 add_var_to_localstate(RecId,RecValue,LocalState,State1),
1825 debug_println(9,generating_recursive_closure(RecId,Parameters)),
1826 b_generate_rec_closure_aux(RecId,Parameters,Condition,State1,State,RClosure1,WF),
1827 mark_closure_as_recursive(RClosure1,RClosure2),
1828 mark_closure(RClosure2,[recursive(TRecId)],Result),
1829 ( debug_mode(off) -> true
1830 ; ground_value(Result) -> true
1831 ; term_variables(Result,TV),
1832 add_message(b_interpreter,'non-ground closure generated: ',TV:Result,Condition)
1833 ).
1834 % a variation of b_generate_closure
1835 b_generate_rec_closure_aux(RecId,Parameters,Condition,LocalState,State,Result,WF) :-
1836 split_names_and_types(Parameters,Names,Types),
1837 construct_closure(Names,Types,ClosurePred,Result),
1838 % now add RecId to parameters to prevent looking up recursive calls
1839 b_compiler:b_compile(Condition,[RecId|Names],LocalState,State,ClosurePred,WF).
1840
1841 % check if a freetype value has the expected case, if not
1842 % generate a WD-error
1843 check_freetype_case(Id,Case,VCase,Inner,Value,Info,WF) :-
1844 get_enumeration_finished_wait_flag(WF,F),
1845 check_freetype_case2(Id,Case,VCase,Inner,Value,Info,F,WF).
1846 :- block check_freetype_case2(?,?,-,?,?,?,-,?).
1847 check_freetype_case2(Id,Case,VCase,Inner,Value,Info,_F,WF) :-
1848 ( nonvar(VCase) ->
1849 ( Case=VCase -> equal_object_wf(Inner,Value,check_freetype_case2,WF)
1850 ;
1851 ajoin(['cannot apply destructor for data type ',Id,
1852 ', expected constructor ',Case,', but got: '],Msg),
1853 add_wd_error_set_result(Msg,VCase,Inner,Value,Info,WF))
1854 ; % the computation has finished without value,
1855 true). % just drop the check
1856
1857 % check if we have a set_extension argument representing an explicit function
1858 % {a |-> f1, b |-> f2, ...} or [f1,f2]
1859 is_extension_function(b(A,_,Info),Info,C) :- is_extension_function_aux(A,C).
1860 is_extension_function_aux(set_extension(Ex),CaseList) :- is_set_extension_function(Ex,CaseList).
1861 is_extension_function_aux(sequence_extension(Ex),CaseList) :- is_sequence_extension_function(Ex,1,CaseList).
1862 is_set_extension_function([],[]).
1863 is_set_extension_function([b(Couple,TC,_)|T],[case(A,B)|ST]) :- is_couple(Couple,TC,A,B),
1864 is_set_extension_function(T,ST).
1865 is_sequence_extension_function([],_,[]).
1866 is_sequence_extension_function([B|T],Nr,[case(b(value(int(Nr)),integer,[]),B)|ST]) :- N1 is Nr+1,
1867 is_sequence_extension_function(T,N1,ST).
1868
1869 is_couple(couple(A,B),_,A,B).
1870 is_couple(value((VA,VB)),couple(TA,TB), b(value(VA),TA,[]), b(value(VB),TB,[])).
1871
1872 :- use_module(kernel_equality,[equality_objects_wf/4]).
1873 b_apply_function_set_extension([],FunArgVal,_LocalState,_State,_Res,WF,Span) :-
1874 add_wd_error_span('Function applied outside of domain (#8): ','@fun'(FunArgVal,[]),Span,WF).
1875 b_apply_function_set_extension([case(A,B)|T],FunArgVal,LocalState,State,Res,WF,Span) :-
1876 b_compute_expression(A,LocalState,State,AVal,WF),
1877 equality_objects_wf(AVal,FunArgVal,EqRes,WF),
1878 % TO DO: if Res is known, we can call equality_objects(BVal,Res,ResEqRes)
1879 b_apply_function_set_extension_aux(EqRes,B,T,FunArgVal,LocalState,State,Res,WF,Span).
1880
1881 :- block b_apply_function_set_extension_aux(-,?,?,?, ?,?,?,?,?).
1882 b_apply_function_set_extension_aux(pred_true,B,_T,_FunArgVal,LocalState,State,Res,WF,_Span) :-
1883 b_compute_expression(B,LocalState,State,BVal,WF), %print(value(BVal)),nl,
1884 equal_object_wf(BVal,Res,b_apply_function_set_extension_aux,WF).
1885 b_apply_function_set_extension_aux(pred_false,_B,T,FunArgVal,LocalState,State,Res,WF,Span) :-
1886 b_apply_function_set_extension(T,FunArgVal,LocalState,State,Res,WF,Span).
1887
1888
1889 % --------------------- SIGMA & PI ------------------------
1890 :- use_module(bsyntaxtree,[is_membership_or_equality/3,same_id/3]).
1891 /* first clause: try to do a specific treatment for formulas of the form SIGMA(ID).(ID:SET|EXPR) */
1892 /* Advantage: will not delay as long before computing comprehension_set SET ; see test 1312 */
1893 b_general_sum_or_mul([TID],Condition,Expression,Type,_Info,LocalState,State,SumResult,WF,SUMorMUL) :-
1894 is_membership_or_equality(Condition,MID,SET),
1895 same_id(TID,MID,_),!,
1896 b_compute_expression(SET,LocalState,State,SETResult,WF),
1897 b_general_sum_or_mul_over_set([TID],SETResult,Expression,Type,LocalState,State,SumResult,WF,SUMorMUL).
1898 b_general_sum_or_mul(Ids,Condition,Expression,Type,Info,LocalState,State,SumMulResult,WF,SUMorMUL) :-
1899 b_compute_comprehension_set(Ids,Condition,Info,LocalState,State,SETResult,WF),
1900 (var(SETResult) -> perfmessagecall(sigma_pi_not_expanded_or_reified(SUMorMUL),
1901 translate:print_bexpr(Condition),Condition) ; true),
1902 b_general_sum_or_mul_over_set(Ids,SETResult,Expression,Type,LocalState,State,SumMulResult,WF,SUMorMUL).
1903
1904
1905 :- block b_general_sum_or_mul_over_set(?,-, ?,?,?,?, ?,?,?).
1906 b_general_sum_or_mul_over_set([TID],SETResult,Expression,Type,_LS,_S,SumResult,WF,SUMorMUL) :-
1907 Type=integer, % TO DO: also for real
1908 get_texpr_id(Expression,ID), % check if we just sum the elements of the list SIGMA(x).(x:S|x)
1909 get_texpr_id(TID,ID),
1910 ? sum_or_mul_of_explicit_set(SETResult,SUMorMUL,R),!,
1911 equal_object_wf(SumResult,R,b_general_sum_or_mul_over_set,WF).
1912 b_general_sum_or_mul_over_set(IDs,SETResult,Expression,Type,LocalState,State,SumResult,WF,SUMorMUL) :-
1913 expand_custom_set_to_list_wf(SETResult,ESETResult,_Done,b_general_sum_or_mul_over_set,WF),
1914 ? b_sum_or_mul_over_list(ESETResult,IDs,Expression,Type,LocalState,State,SumResult,WF,SUMorMUL).
1915
1916 b_sum_or_mul_over_list(L,IDs,Expr,Type,LS,State,Result,WF,SUMorMUL) :-
1917 get_acc_base(SUMorMUL,Type,Acc),
1918 (Type = integer -> get_wait_flag0(WF,WF0) ; true), % for real: delay until values known
1919 ? b_sum_or_mul_over_list_acc(L,IDs,Expr,Type,LS,State,Acc,Result,WF,SUMorMUL,WF0).
1920
1921 :- block b_sum_or_mul_over_list_acc(-, ?, ?,?,?,?,?, ?,?,?,?).
1922 % better if list is fully known: no constraint propagation performed during computation !
1923 % for example: SIGMA(x).(x:{-1} \/ 1..30000|x+1) goes down from 2050 ms to 1210 ms
1924 b_sum_or_mul_over_list_acc([],_,_,Type,_,_,Acc,Result,_WF,_SUMorMUL,_) :-
1925 ? get_acc_result(Type,Acc,Result).
1926 b_sum_or_mul_over_list_acc([H|T],IDs,Expr,Type,LocalState,State,Acc,Result,WF,SUMorMUL,WF0) :-
1927 add_typed_vars_to_localstate(IDs,H,LocalState,NewLocalState),
1928 b_compute_expression(Expr,NewLocalState,State,HExprVal,WF),
1929 b_sum_or_mul_over_list_acc2(HExprVal,T,IDs,Expr,Type,LocalState,State,Acc,Result,WF,SUMorMUL,WF0).
1930
1931 :- block b_sum_or_mul_over_list_acc2(?,-, ?, ?,?,?,?,?, ?,?,?,?),
1932 b_sum_or_mul_over_list_acc2(?,?, ?, ?,?,?,?,-, ?,?,?,-),
1933 b_sum_or_mul_over_list_acc2(-,?, ?, ?,?,?,?,?, ?,?,?,-). % wait until T nonvar and either Acc & HExprVal known or WF0 set
1934 % purpose: try and remain in non-CLPFD mode as long as possible to avoid overflows,... (see eg. test 1642, 1708)
1935 b_sum_or_mul_over_list_acc2(HExprVal,T,IDs,Expr,Type,LocalState,State,Acc, Result,WF,SUMorMUL,WF0) :-
1936 (nonvar(T),nonvar(Acc),ground(HExprVal)
1937 -> % we can continue computing the system without constraint propagation; is faster
1938 get_value(Type,HExprVal,HVal),
1939 compose_acc(SUMorMUL,Acc,HVal,NewAcc),
1940 b_sum_or_mul_over_list_acc(T,IDs,Expr,Type,LocalState,State,NewAcc,Result,WF,SUMorMUL,WF0)
1941 ; T==[], number(Acc), get_acc_base(SUMorMUL,Type,Acc) ->
1942 /* we have just a single element left and no operator has to be applied -> no need for clpfd treatment */
1943 equal_object_wf(HExprVal,Result,b_sum_or_mul_over_list_acc)
1944 ; Type=real -> % no CLP(FD) treatment possible yet
1945 when(ground(HExprVal),
1946 b_sum_or_mul_over_list_acc2(HExprVal,T,IDs,Expr,Type,LocalState,State,Acc, Result,WF,SUMorMUL,WF0))
1947 ; init_clp_acc(SUMorMUL,HExprVal,int(Acc),CLPAccumulator),
1948 b_sum_or_mul_over_list_clp(T,IDs,Expr,LocalState,State,CLPAccumulator,Result,WF,SUMorMUL)
1949 ).
1950
1951 % add set comprehension solution ValueForTypedIDs as individual values for every TypedIDs to LocalState
1952 add_typed_vars_to_localstate(TypedIDs,ValueForTypedIDs,LocalState,NewLocalState) :-
1953 (flatten_pairs(TypedIDs,ValueForTypedIDs,ValAsList),
1954 add_typed_vars_to_localstate_aux(TypedIDs,ValAsList,LocalState,R)
1955 -> NewLocalState = R
1956 ; add_internal_error('Call failed: ',add_typed_vars_to_localstate(TypedIDs,ValueForTypedIDs,LocalState,NewLocalState)),
1957 fail
1958 ).
1959 % set comprehension results for {a,b,c|P} are nested like this ((a,b),c)
1960 % first argument only used for length (to know how deep the pairs are nested)
1961 flatten_pairs(L,Pairs,FlatList) :- flatten_pairs(L,Pairs,FlatList,[]).
1962 flatten_pairs([_],A) --> !, [A].
1963 flatten_pairs([_|T],(A,B)) --> flatten_pairs(T,A) ,[B].
1964 add_typed_vars_to_localstate_aux([],_,LS,LS).
1965 add_typed_vars_to_localstate_aux([TID],[H],LocalState,NewLocalState) :- !,
1966 get_texpr_id(TID,ID), get_texpr_type(TID,TYPE),
1967 add_typed_var_to_localstate(ID,H,TYPE,LocalState,NewLocalState).
1968 add_typed_vars_to_localstate_aux([TID1|Ids],[H1|Hs],LocalState,NewLocalState) :- !,
1969 get_texpr_id(TID1,ID1), get_texpr_type(TID1,TYPE),
1970 add_typed_var_to_localstate(ID1,H1,TYPE,LocalState,LS1),
1971 add_typed_vars_to_localstate_aux(Ids,Hs,LS1,NewLocalState).
1972
1973
1974 :- block b_sum_or_mul_over_list_clp(-, ?, ?,?,?, ?, ?,?,?).
1975 b_sum_or_mul_over_list_clp([],_, _,_,_, Acc, Result,_WF,SUMorMUL) :-
1976 finalise_clp(SUMorMUL,Acc,Result).
1977 b_sum_or_mul_over_list_clp([H|T],IDs,Expr,LocalState,State,Acc, Result,WF,SUMorMUL) :-
1978 add_typed_vars_to_localstate(IDs,H,LocalState,NewLocalState),
1979 b_compute_expression(Expr,NewLocalState,State,HExprVal,WF),
1980 compose_clp(SUMorMUL,HExprVal,Acc,NewAcc),
1981 b_sum_or_mul_over_list_clp(T,IDs,Expr,LocalState,State,NewAcc,Result,WF,SUMorMUL).
1982
1983 :- use_module(kernel_reals,[is_real/2]).
1984 get_acc_base(sum,integer,R) :- !, R=0.
1985 get_acc_base(sum,real,0.0).
1986 get_acc_base(mul,integer,R) :- !, R=1.
1987 get_acc_base(mul,real,1.0).
1988 get_acc_result(integer,Nr,int(Nr)).
1989 get_acc_result(real,Nr,Real) :- is_real(Real,Nr).
1990 get_value(integer,int(Val),Val) :- !.
1991 get_value(real,Real,Nr) :- is_real(Real,Nr).
1992
1993 compose_acc(sum,A,B,C) :- C is A+B.
1994 compose_acc(mul,A,B,C) :- C is A*B.
1995 init_clp_acc(sum,int(A),int(B),Res) :- (B==0 -> Res=[A] ; Res=[A,B]). % A always not ground
1996 init_clp_acc(mul,A,B,C) :- times(A,B,C).
1997 compose_clp(sum,int(A),Acc,NewAcc) :- NewAcc = [A|Acc].
1998 compose_clp(mul,A,B,C) :- times(A,B,C).
1999 :- use_module(clpfd_interface,[clpfd_sum/2]).
2000 finalise_clp(sum,Acc,int(Result)) :-
2001 clpfd_sum(Acc,Result). % using clpfd_sum can be much more efficient: no intermediate variables set up
2002 finalise_clp(mul,int(Acc),int(Acc)).
2003
2004 /* for if-then-else in Z: compute Then or Else,
2005 depending on the outcome of the predicate */
2006 :- block b_compute_if_then_else(-,?,?,?,?,?,?).
2007 b_compute_if_then_else(pred_true,Then,_Else,LocalState,State,Value,WF) :-
2008 opt_push_wait_flag_call_stack_info(WF,b_expr_call(if_then_body,Then),WF2),
2009 ? b_compute_expression(Then,LocalState,State,Value,WF2).
2010 b_compute_if_then_else(pred_false,_Then,Else,LocalState,State,Value,WF) :-
2011 opt_push_wait_flag_call_stack_info(WF,b_expr_call(if_else_body,Else),WF2),
2012 ? b_compute_expression(Else,LocalState,State,Value,WF2).
2013
2014 :- use_module(clpfd_interface,[clpfd_if_then_else/4]).
2015 % a more sophisticated treatment, can also work backwards forcing PredRes
2016 % examples:
2017 % x = IF a<10 THEN 0 ELSE 5 END & x:6..10 & a:1..23
2018 % see must_fail_clpfd_det 132 and 133
2019 % problematic if Else contains recursion; but then we should have WD condition
2020 b_clpfd_if_then_else(PredRes,Type,Then,Else,LocalState,State,Value,WF) :-
2021 get_wait_flag0(WF,WF0),
2022 b_clpfd_if_then_else_block(PredRes,WF0,Type,Then,Else,LocalState,State,Value,WF).
2023 :- block b_clpfd_if_then_else_block(-,-,?,?,?,?,?,?,?).
2024 b_clpfd_if_then_else_block(PredRes,_,Type,Then,Else,LocalState,State,Value,WF) :- var(PredRes),!,
2025 get_full_fd_value(Type,Value,FDValue),
2026 b_compute_expression(Then,LocalState,State,ThenValue,WF),
2027 get_full_fd_value(Type,ThenValue,FDThenValue),
2028 b_compute_expression(Else,LocalState,State,ElseValue,WF),
2029 get_full_fd_value(Type,ElseValue,FDElseValue),
2030 % TO DO: catch CLPFD overflow and use equality_objects
2031 clpfd_if_then_else(PredRes,FDThenValue,FDElseValue,FDValue).
2032 b_clpfd_if_then_else_block(pred_true,_,_Type,Then,_Else,LocalState,State,Value,WF) :-
2033 b_compute_expression(Then,LocalState,State,Value,WF).
2034 b_clpfd_if_then_else_block(pred_false,_,_Type,_Then,Else,LocalState,State,Value,WF) :-
2035 b_compute_expression(Else,LocalState,State,Value,WF).
2036
2037 :- use_module(b_global_sets,[get_global_type_value/3]).
2038 % try and get full_fd_value; true if full value can be translated to CLP(FD) value
2039 get_full_fd_value(global(T),FY,X) :- get_global_type_value(FY,T,X).
2040 get_full_fd_value(integer,int(X),X).
2041 get_full_fd_value(boolean,B,FD) :- kernel_equality:prop_eq_01(B,FD).
2042 % record with single field ?
2043
2044 can_get_full_fd_value(global(_)).
2045 can_get_full_fd_value(integer).
2046 can_get_full_fd_value(boolean).
2047
2048 % a slightly improved version over set_up_localstate (not sure it is really much faster):
2049 add_lazy_let_id_to_local_state(b(identifier(ID),_,_),Trigger,IdValue,LocalState,NewState) :-
2050 % should we delete any old occurence of ID in LocalState?
2051 NewState = [bind(ID,(Trigger,IdValue))|LocalState].
2052
2053 add_lazy_let_id_and_expression(Id,IdExpr,LocalState,InState,NewLocalState,WF) :-
2054 empty_avl(Ai),
2055 add_lazy_let_id_and_expression(Id,IdExpr,LocalState,InState,NewLocalState,WF,Ai).
2056 add_lazy_let_id_and_expression(Id,IdExpr,LocalState,InState,NewLocalState,WF,Ai) :-
2057 add_lazy_let_id_to_local_state(Id,Trigger,IdValue,LocalState,NewLocalState),
2058 lazy_compute_expression(Trigger,IdExpr,LocalState,InState,IdValue,WF,Ai).
2059
2060 /* for let-statements in Z and now in B: expand localstate by new variables and assign
2061 values to them ;
2062 now Expressions are evaluated in state *with* the new identifiers !
2063 */
2064 %set_up_localstate_for_let_no_reuse(Ids,Exprs,LocalState,State,LetState,WF) :-
2065 % set_up_localstate(Ids,Vars,LocalState,LetState),
2066 % compute_let_expressions(Exprs,Vars,LocalState,State,WF).
2067 set_up_localstate_for_let(Ids,Vars,Exprs,LocalState,State,LetState,WF) :-
2068 set_up_localstate(Ids,Vars,LocalState,LetState),
2069 %external_functions:observe_variables(Ids,Vars),
2070 ? compute_let_expressions(Exprs,Vars,LetState,State,WF).
2071 compute_let_expressions([],[],_,_,_).
2072 compute_let_expressions([Expr|RestExprs],[Var|RestVars],LocalState,State,WF) :-
2073 ? b_compute_expression(Expr,LocalState,State,Value,WF),
2074 equal_object_optimized(Var,Value,compute_let_expressions),
2075 compute_let_expressions(RestExprs,RestVars,LocalState,State,WF).
2076
2077 set_up_localstate_for_global_let(Ids,Exprs,LocalState,State,LetState,WF) :-
2078 set_up_localstate(Ids,Vars,State,LetState),
2079 compute_let_expressions(Exprs,Vars,LocalState,LetState,WF).
2080
2081
2082 l_compute_field([],_LS,_S,[],_WF).
2083 l_compute_field([Field|T],LS,S,[FVal|CT],WF) :-
2084 ? b_compute_field(Field,LS,S,FVal,WF),
2085 ? l_compute_field(T,LS,S,CT,WF).
2086
2087 b_compute_field(field(Name,TypeOrVal),LocalState,State,field(Name,TypeOrFieldValue),WF) :-
2088 ? b_compute_expression(TypeOrVal,LocalState,State,TypeOrFieldValue,WF).
2089
2090
2091
2092 :- use_module(b_compiler).
2093
2094 /* :- type bsets_closure +--> closure(list(type(variable_id)),
2095 list(type(basic_type_descriptor)),type(boolean_expression)). */
2096
2097 :- assert_pre(b_interpreter:b_compute_comprehension_set(Parameters,Cond,_Info,LS,State,_R,_WF),
2098 (ground_check(Parameters),
2099 bsyntaxtree:check_if_typed_predicate(Cond),type_check(LS,store),type_check(State,store)) ).
2100
2101 :- assert_post(b_interpreter:b_compute_comprehension_set(_P,_C,_Info,_LS,_State,Val,_WF),
2102 (b_interpreter:value_type(Val))). %, nonvar(Val)
2103
2104
2105
2106 b_compute_comprehension_set_symbolic(Parameters,Condition,Info,LocalState,State,Result,WF) :-
2107 % a version which never expands the generated closure
2108 ? b_generate_closure_if_necessary(Parameters,Condition,LocalState,State,CResult,WF),
2109 ? (member(prob_annotation('SYMBOLIC'),Info)
2110 -> mark_closure_as_symbolic(CResult,CRS),Result=CRS
2111 ; Result=CResult). % TODO: check if we need definitely_expand_this_explicit_set
2112 % we could catch Parameters = [TID], Condition = b(member(b(identifier(ID),_TYPE,_),SET)
2113 b_compute_comprehension_set(Parameters,Condition,Info,LocalState,State,Result,WF) :-
2114 ? b_generate_closure_if_necessary(Parameters,Condition,LocalState,State,CResult,WF),
2115 b_compute_comprehension_set_aux(CResult,Info,Result,WF).
2116
2117 :- use_module(clpfd_interface,[catch_clpfd_overflow_call2/2]).
2118 b_compute_comprehension_set_aux(CResult,_,Result,_WF) :-
2119 (var(CResult) ; \+ functor(CResult,closure,3) ),!,
2120 Result=CResult.
2121 b_compute_comprehension_set_aux(CResult,Info,Result,_WF) :-
2122 ? member(prob_annotation('SYMBOLIC'),Info),!,
2123 mark_closure_as_symbolic(CResult,CRS),Result=CRS.
2124 b_compute_comprehension_set_aux(CResult,Info,Result,WF) :-
2125 (preferences:get_preference(convert_comprehension_sets_into_closures,true)
2126 -> \+ definitely_expand_this_explicit_set(CResult)
2127 ; dont_expand_symbolic_explicit_set(CResult), % Note: also detects FORCE annotation
2128 perfmessage_wf(symbolic,'Keeping set comprehension symbolic (use FORCE to override this or increase SYMBOLIC_LIMIT)','',Info,WF)
2129 ),!,
2130 Result=CResult.
2131 b_compute_comprehension_set_aux(CResult,Info,Result,WF) :-
2132 b_expand_compute_comprehension_set(CResult,Info,Result,WF).
2133
2134 b_expand_compute_comprehension_set(CResult,Info,Result,WF) :-
2135 % using just get_wait_flag1(b_compute_comprehension_set,WF,WF0), makes many benchmarks faster ; but e.g., test 268 fails; maybe we sholud pre-compute bexpr_variables ? and pass this to expand_only_custom_closure_global
2136 (preferences:preference(use_smt_mode,false)
2137 -> get_wait_flag(1000,b_compute_comprehension_set,WF,WF0) % ideally we should say WF0 = _ ; but for some benchmarks Rule_DB_SIGAREA_0024_ori.mch this is important to avoid expanding closures before other stuff fails
2138 % only in SMT mode can there be any benefit in expanding a non-ground closure (when it is a lambda closure)
2139 % => hence delay expansion longer, possibly detecting enumeration warnings while expanding
2140 % TO DO: for lambda closures with known domain: expand earlier !
2141 ; get_wait_flag(2,b_compute_comprehension_set,WF,WF0)),
2142 kernel_objects:mark_as_to_be_computed(Result), % avoid that we instantiate this set (e.g., in check_element_of_wf: we will get a full description of the set later; see test 1353
2143 (var(WF0),var(Result) -> ground_value_check(CResult,CGr) ; true),
2144 block_compute_comprehension_set_aux(CResult,Info,Result,WF,WF0,CGr).
2145
2146 :- block block_compute_comprehension_set_aux(?,?,-,?,-,-).
2147 block_compute_comprehension_set_aux(CResult,Info,Result,WF,_WF0,_CGr) :-
2148 (
2149 nonvar(Result)
2150 ? -> equal_object_wf(CResult,Result,WF) % this may expand CResult or do other tests;
2151 % like emptyness test or symbolic equality;
2152 % if Result=[_|_] then the closure needs to be expanded anyhow, so need to try and keep symbolic
2153 ;
2154 ? catch_clpfd_overflow_call2(
2155 on_enumeration_warning_with_continue(expand_only_custom_closure_global(CResult,Expansion,check_no_inf,WF),
2156 % check_no_inf: we know it is not definitely infinite; and we do not want warnings for virtual time-outs
2157 % an enumeration warning occured in the expansion scope: keep closure symbolic after all
2158 % NOTE: for this detection to work it is better to delay until the body is ground (CGr)
2159 % and not use a priority too low for WF0, otherwise Expansion will be var and enum warning may occur later
2160 b_compute_comprehension_set_sym_msg(CResult,Info,Result,WF) % Backup Call in case of enum warning
2161 ,
2162 equal_object_wf(Result,Expansion,WF) % TrueContinuation
2163 % instantiating Result can trigger other code which fails and confuses on_enumeration_warning
2164 ),
2165 b_compute_comprehension_set_sym(CResult,Result,WF)
2166 ) % catch_clpfd_overflow_call2
2167 ).
2168
2169 b_compute_comprehension_set_sym_msg(CResult,Info,Result,WF) :- CResult = closure(P,_T,B),
2170 silent_mode(off),
2171 % TO DO: should we check that this closure has not been constructed by ProB, e.g., for UNION ??
2172 % e.g., P = ['__RANGE_LAMBDA__'] what about '_zzzz_unary', '_zzzz_binary', '_prj_arg1__', ...
2173 % also: what if the enumeration warning has a pending_abort_error
2174 !,
2175 Msg = 'Keeping comprehension-set symbolic (you may want to use the /*@symbolic*/ pragma to prevent this message, unless it was due to a WD-Error), identifiers: ',
2176 (contains_info_pos(Info) -> Span=Info ; Span=B),
2177 add_message(b_compute_comprehension_set,Msg,P,Span),
2178 b_compute_comprehension_set_sym(CResult,Result,WF).
2179 b_compute_comprehension_set_sym_msg(CResult,_,Result,WF) :-
2180 b_compute_comprehension_set_sym(CResult,Result,WF).
2181
2182
2183 b_compute_comprehension_set_sym(CResult,Result,WF) :-
2184 mark_closure_as_symbolic(CResult,CRS), % prevent doing the same mistake again
2185 equal_object_wf(Result,CRS,b_compute_comprehension_set_sym,WF).
2186
2187
2188 :- use_module(closures,[construct_closure_if_necessary/4]).
2189 b_generate_forall_closure(Parameters,Condition,LocalState,State,Result,WF) :-
2190 split_names_and_types(Parameters,Names,Types),
2191 construct_closure(Names,Types,ClosurePred1,Result),
2192 (LocalState==[],State==[]
2193 -> ClosurePred = Condition % no lookups can be performed anyway; no need to compile
2194 ; b_compiler:b_compile(Condition,Names,LocalState,State,ClosurePred,WF) ),
2195 add_texpr_infos(ClosurePred,[quantifier_kind(forall)],ClosurePred1). % info for call_stack
2196
2197
2198
2199 b_generate_closure_if_necessary(Parameters,Condition,LocalState,State,Result,WF) :-
2200 split_names_and_types(Parameters,Names,Types),
2201 ? b_compiler:b_compile(Condition,Names,LocalState,State,ClosurePred,WF),
2202 %print('COMPILED: '),translate:print_bexpr(ClosurePred),nl,
2203 construct_closure_if_necessary(Names,Types,ClosurePred,Result).
2204
2205
2206 :- public convert_list_of_expressions_into_sequence/2.
2207 convert_list_of_expressions_into_sequence(List,SeqValue) :-
2208 convert_list_of_expressions_into_sequence(List,1,Seq),
2209 ? equal_object_optimized(Seq,SeqValue,convert_list_of_expressions_into_sequence).
2210
2211 convert_list_of_expressions_into_sequence([],_,[]).
2212 convert_list_of_expressions_into_sequence([H|T],Cur,[(int(Cur),H)|ConvT]) :-
2213 C1 is Cur+1,
2214 convert_list_of_expressions_into_sequence(T,C1,ConvT).
2215
2216 convert_list_of_expressions_into_set_wf(ListOfElements,Set,Type,WF) :-
2217 list_of_expressions_is_ground(ListOfElements,Ground,OrderedListOfElements),
2218 ? convert_list_of_expressions_into_set1(Ground,OrderedListOfElements,Set,Type,WF).
2219 convert_list_of_expressions_into_set1(true,ListOfElements,Set,_Type,WF) :- %var(Set),
2220 ? \+ (ListOfElements = [H|_], is_symbolic_closure(H)), % list contains symbolic closures, do not try to expand to avl
2221 % see should_be_converted_to_avl_from_lists ?
2222 !, construct_avl_from_lists_wf(ListOfElements,AVLSet,WF),
2223 ? equal_object_wf(AVLSet,Set,convert_list_of_expressions_into_set1,WF).
2224 convert_list_of_expressions_into_set1(_,Seq,Set,Type,WF) :-
2225 ? kernel_objects:max_cardinality(Type,TypeMaxCard),
2226 ? convert_list_of_expressions_into_set2(Seq,1,[],Set,TypeMaxCard,WF).
2227
2228 % TO DO: sort elements : ground elements first
2229 convert_list_of_expressions_into_set2([],_,Set,Res,_,WF) :-
2230 ? equal_object_wf(Set,Res,convert_list_of_expressions_into_set2,WF).
2231 convert_list_of_expressions_into_set2([H|T],MaxSze,SetSoFar,OutSet,TypeMaxCard,WF) :-
2232 %kernel_objects:basic_type_set(Type,IntSet,MaxSze),
2233 check_set_lists_bounded(IntSet,TypeMaxCard,MaxSze),
2234 % TO DO: optimize; avoid traversing or typing elements over and over again
2235 % maybe add a max. sze argument to add_element
2236 add_element_wf(H,SetSoFar,IntSet,WF), % print(add_el(H,SetSoFar,IntSet)),nl,
2237 % TO DO: check if H in OutSet and keep track of which elements have already been covered in OutSet
2238 %check_element_of_wf(H,OutSet,WF), makes tests 114, 115, 118-120, 1063 fail ! % we could also call lazy_try_check_element_of if this turns out to be too expensive
2239 kernel_objects:lazy_try_check_element_of(H,OutSet,WF),
2240 M1 is MaxSze+1,
2241 ? convert_list_of_expressions_into_set2(T,M1,IntSet,OutSet,TypeMaxCard,WF).
2242
2243
2244 :- use_module(inf_arith).
2245
2246 % check that a set does not exceed a certain bound (to prevent infinite
2247 % or overeager enumeration of sets); Warning: will not check custom_explicit_set sizes
2248 check_set_lists_bounded(Set,TypeMaxCard,Bound) :-
2249 inf_arith:infmin(TypeMaxCard,Bound,Card),
2250 (is_inf_or_overflow_card(Card) -> true
2251 ; Card<1 -> empty_set(Set)
2252 ; check_set_bounded_aux(Set,Card)).
2253
2254 :- block check_set_bounded_aux(-,?).
2255 check_set_bounded_aux(CustomSet,_) :- is_custom_explicit_set(CustomSet,check_set_bounded_aux),!.
2256 check_set_bounded_aux([],_).
2257 check_set_bounded_aux([_|T],Card) :-
2258 C1 is Card-1,
2259 (C1=0 -> empty_set(T) ; check_set_bounded_aux(T,C1)).
2260
2261
2262
2263 % check if the list can be converted into AVL form; if not: re-order list so that ground elements are present first
2264 list_of_expressions_is_ground([],true,[]).
2265 list_of_expressions_is_ground([E|T],Ground,ResList) :-
2266 (should_be_converted_to_avl(E) -> ResList=[E|RT], list_of_expressions_is_ground(T,Ground,RT)
2267 ; Ground=false,
2268 bring_ground_elements_forward(T,[E],ResList)
2269 ).
2270
2271 bring_ground_elements_forward([],Acc,Acc).
2272 bring_ground_elements_forward([H|T],Acc,Res) :-
2273 (should_be_converted_to_avl(H) -> Res=[H|RT], bring_ground_elements_forward(T,Acc,RT)
2274 ; bring_ground_elements_forward(T,[H|Acc],Res)).
2275
2276 :- use_module(kernel_card_arithmetic,[is_inf_or_overflow_card/1, safe_mul/3]).
2277 % compute cardinality of a list of parameters, such as for forall
2278 parameter_list_cardinality([],1).
2279 parameter_list_cardinality([b(identifier(_),BasicType,_)|T],Res) :-
2280 ? parameter_list_cardinality(T,TCard),
2281 (is_inf_or_overflow_card(TCard) -> Res=TCard
2282 ? ; kernel_objects:max_cardinality(BasicType,Card),
2283 safe_mul(Card,TCard,Res)
2284 ).
2285 % see also basic_type_list_cardinality, now moved to custom_explicit_sets
2286
2287 b_for_all(Parameters,Infos,LHS,RHS,LocalState,State,WF) :-
2288 get_wait_flag1(for_all(Parameters),WF,LWF), % hack: give total_function,... priority to set up domain/range
2289 ? b_for_all_aux(LWF,Parameters,Infos,LHS,RHS,LocalState,State,WF).
2290
2291 :- block b_for_all_aux(-,?,?,?,?,?,?,?).
2292 b_for_all_aux(_,Parameters,Infos,LHS,RHS,LocalState,State,WF) :-
2293 split_names_and_types(Parameters,Names,Types),
2294 ? b_compile(LHS,Names,LocalState,State,CLHS,WF),
2295 ? b_compile(RHS,Names,LocalState,State,CRHS,WF),
2296 ? b_for_all_aux2(Parameters,Names,Types,Infos,CLHS,CRHS,WF).
2297
2298 :- use_module(kernel_tools,[ground_bexpr/1, ground_bexpr_check/2]).
2299 b_for_all_aux2(_,_,_,_,LHS,RHS,_) :-
2300 (is_falsity(LHS) ; is_truth(RHS)),
2301 !. % quantifier always true
2302 b_for_all_aux2(Parameters,CParameters,CParameterTypes,Infos,LHS,RHS,WF) :-
2303 ground_bexpr(LHS),
2304 ? \+ obvious_enumeration(LHS,CParameters), % if we have an obvious (small) enumeration in the LHS it is often better simply to enumerate and check the RHS for every instance
2305 ground_bexpr(RHS), %print(not_exists_forall(Parameters,LHS,RHS)),nl,
2306 !,
2307 b_for_all_find_counter_example(Parameters,CParameters,CParameterTypes,Infos,LHS,RHS,WF).
2308 b_for_all_aux2(Parameters,CParameters,CParameterTypes,Infos,LHS,RHS,WF) :-
2309 ? parameter_list_cardinality(Parameters,ParCard),
2310 peel_implications(Parameters,ParCard,LHS,RHS, LHS2,RHS2),
2311 ? b_for_all_aux3(Parameters,ParCard,CParameters,CParameterTypes,Infos,LHS2,RHS2,WF).
2312
2313 b_for_all_aux3(Parameters,ParCard,CParameters,CParameterTypes,Infos,LHS,RHS,WF) :-
2314 %large_domain(Parameters,ParCard,LHS),
2315 is_infinite_or_very_large_explicit_set(closure(CParameters,CParameterTypes,LHS),10000000),
2316 % the domain is so large that we cannot possibly check all instances
2317 % in this case: we prefer to look for a counter example in the hope that the constraint solver can narrow down the search by combining LHS and not(RHS)
2318 !,
2319 perfmessage(forall,'Large forall domain: ',ParCard,Infos),
2320 ground_bexpr_check(LHS,LG),
2321 ground_bexpr_check(RHS,RG),
2322 when((nonvar(LG),nonvar(RG)),
2323 b_for_all_find_counter_example(Parameters,CParameters,CParameterTypes,Infos,LHS,RHS,WF)
2324 ).
2325 b_for_all_aux3(Parameters,ParCard,_CP,_,Infos,LHS,RHS,WF) :-
2326 if(expand_forall_quantifier(Parameters,LHS,RHS,Infos,WF,ReificationVariable),
2327 (
2328 perfmessage(good(forall),'Reified forall by expanding into conjunction: ',LHS),
2329 ReificationVariable=pred_true),
2330 ( % print(normal_forall(Parameters)),nl,
2331 b_generate_for_all_list_domain1(Parameters,ParCard,LHS,RHS,[],[],AllSolList,NewRHS,WF),
2332 ? expand_forall1(AllSolList,NewRHS,Parameters,WF)
2333 )).
2334
2335
2336 % a treatment of for all where we look for counter examples satisfying LHS & not(RHS)
2337 b_for_all_find_counter_example(Parameters,CParameters,CParameterTypes,Infos,LHS,RHS,WF) :-
2338 % if LHS is Parameters: avl_set(V) then we probably should not apply this rule ?
2339 create_negation(RHS,NegRHS),
2340 conjunct_predicates_with_pos_info(LHS,NegRHS,Pred0),
2341 % format('looking for: ~w ',[CParameters]), translate:print_bexpr(LHS),nl, translate:print_bexpr(NegRHS),nl,
2342 perfmessage(good(forall),translating_forall_into_not_exists(CParameters),LHS),
2343 add_texpr_infos(Pred0,[quantifier_kind(forall)],ClosureBody1), % for call_stack
2344 init_quantifier_wait_flag(WF,not(forall),Parameters,ParValues,Infos,LocalWF), % relevant for test 1904
2345 not_with_enum_warning_and_possible_delay(
2346 (custom_explicit_sets:b_test_closure(CParameters,CParameterTypes,ClosureBody1,ParValues,negative,LocalWF),
2347 perfmessage_bexpr(forall,forall_counter_example(CParameters,ParValues),LHS)
2348 ),LocalWF, WF, forall(CParameters), Infos).
2349
2350 :- use_module(library(timeout),[time_out/3]).
2351 not_with_enum_warning_and_possible_delay(C,WF,OuterWF,PP,Span) :-
2352 get_preference(disprover_mode,true),
2353 % in disprover mode we do not track WD errors, no need to start_attach_inner_abort_errors
2354 !,
2355 % delay potentially expensive quantifications in the hope of finding other contradictions earlier
2356 if( (time_out(not_with_enum_warning(C,WF,PP,Span),20,TRes),TRes \== time_out),
2357 copy_wfe_from_inner_if_necessary(WF,OuterWF),
2358 (get_wait_flag(2,not_with_enum_warning_and_possible_delay,OuterWF,LWF), % which priority to use ??
2359 debug_println(19,delay_not_in_disprover_mode),
2360 not_with_enum_warning_delay(C,LWF,WF,OuterWF,PP,Span))).
2361 not_with_enum_warning_and_possible_delay(C,WF,OuterWF,PP,Span) :-
2362 start_attach_inner_abort_errors(Level,not_with_enum_warning),
2363 call_cleanup(not_with_enum_warning(C,WF,PP,Span),
2364 re_attach_pending_inner_abort_errors(Level,OuterWF,_)),
2365 copy_wfe_from_inner_if_necessary(WF,OuterWF).
2366
2367
2368 :- block not_with_enum_warning_delay(?,-,?,?,?,?).
2369 not_with_enum_warning_delay(C,_,WF,OuterWF,PP,Span) :-
2370 debug_println(19,trigger_not_with_enum_warning_delay),
2371 not_with_enum_warning(C,no_wf_available,PP,Span),
2372 copy_wfe_from_inner_if_necessary(WF,OuterWF).
2373
2374 :- use_module(avl_tools,[quick_avl_approximate_size/2]).
2375 obvious_enumeration(LHS,[Id]) :- % TO DO : allow multiple ids
2376 % TO DO: unify with is_for_all_set_membership_predicate code below
2377 TLHSMembership = b(LHSMembership,_,_),
2378 ? member_conjunct(TLHSMembership,LHS,_),
2379 obvious_enum_aux(LHSMembership,Id).
2380
2381 obvious_enum_aux(member(TID,b(value(VAL),_,_)),ID) :- get_texpr_id(TID,ID),
2382 nonvar(VAL), VAL = avl_set(AVL), % TO DO: also support interval closures ?
2383 quick_avl_approximate_size(AVL,Size),
2384 Size<256.
2385 %obvious_enum_aux(equal(LHS,RHS),ID) :- % stillposes problem for test 231, investigate
2386 % ( get_texpr_id(LHS,ID) -> get_texpr_expr(RHS,value(_))
2387 % ; get_texpr_id(RHS,ID) -> get_texpr_expr(LHS,value(_))).
2388 % % TODO: do we need to accept integer(.),... literals?
2389
2390 % expands forall quantifier and thus enables that we also propagate from right to left
2391 % This helps for test 1397 (HandshakeSimple_TotFun)
2392 % TO DO: directly call the code which tries to expand a forall quantifier
2393 expand_forall_quantifier(Parameters,LHS,RHS,Infos,WF,ReificationVariable) :-
2394 (preferences:preference(use_smt_mode,true) -> true
2395 ; preferences:preference(solver_strength,SS), SS>9), % sometimes contrapositive checking maybe not useful; see test 1368
2396 % TO DO: investigate and provide more principled heuristic
2397 b_interpreter_check:b_check_forall_wf(Parameters,LHS,RHS,Infos,[],[],WF,ReificationVariable).
2398
2399 % rewrite !(x,..).( TRUTH => (LHS2 => RHS2)) into !(x,...).(LHS2 => RHS2)
2400 peel_implications(Parameters,ParCard,LHS,RHS, NewLHS,NewRHS) :-
2401 %print(forall),nl, print(Parameters),nl,print(LHS),nl,
2402 % this patterns occurs often in Event-B translations to classical B
2403 LHS=b(truth,_,_),
2404 RHS=b(implication(LHS2,RHS2),_,_), % TO DO: maybe also accept nested forall and then add to Parameters?
2405 (is_inf_or_overflow_card(ParCard) -> true ; ParCard>50),
2406 % larger bound than below: maybe user explicitly wants to expand it
2407 !,
2408 peel_implications(Parameters,ParCard,LHS2,RHS2, NewLHS,NewRHS).
2409 peel_implications(_,_,LHS,RHS, LHS,RHS).
2410
2411 b_generate_for_all_list_domain_nolwf(Parameters,LHS,RHS,LS,S,ForAllDomain,NewRHS,WF) :-
2412 ? parameter_list_cardinality(Parameters,ParCard),
2413 peel_implications(Parameters,ParCard,LHS,RHS, LHS2,RHS2),
2414 b_generate_for_all_list_domain1(Parameters,ParCard,LHS2,RHS2,LS,S,OForAllDomain,NewRHS,WF),
2415 optlist_to_list(OForAllDomain,ForAllDomain). % resolve any optional_value/2 items
2416
2417 % generate the domain of a Universally Quantified Formula as a list
2418 b_generate_for_all_list_domain1(Parameters,_ParCard,LHS,RHS,LS,S,ForAllDomain,NewRHS,WF) :-
2419 % optimized treatment for formulas of the form !x.(x:S => RHS) or !(x,y).(x|->y:S => RHS)
2420 % to do: expand to more formulas, such as !(x,y).(x:S & y:T => RHS)
2421 % or !y.(y:1..(n-1) & f(y)=TRUE => f(y+1)=TRUE) --> !y.(y:1..(n-1) => (f(y)=TRUE => f(y+1)=TRUE))
2422 % or we could try and reify set membership for small domains and trigger implication
2423 is_for_all_set_membership_predicate(LHS,Parameters,Set,Pattern,ParameterValues),!,
2424 perfmessages_bexpr_call(good(forall),['Detected forall set membership over ',Ps,': '],
2425 LHS,bsyntaxtree:def_get_texpr_ids(Parameters,Ps)),
2426 NewRHS=RHS,
2427 b_generate_set_for_all_domain(Set,LS,S,Pattern,ParameterValues,ForAllDomain,WF).
2428 b_generate_for_all_list_domain1(Parameters,ParCard,LHS,RHS,LS,S,ForAllDomain,NewRHS,WF) :-
2429 b_generate_forall_closure(Parameters,LHS,LS,S,Closure,WF), % POSSIBLY NO NEED TO COMPILE
2430 b_generate_for_all_domain2(Closure,Parameters,ParCard,LHS,RHS,ForAllDomain,NewRHS,WF).
2431
2432 b_generate_for_all_domain2(Closure,_Parameters,_,LHS,RHS,ForAllDomain,NewRHS,WF) :-
2433 (LHS=b(truth,pred,_) ; ground_value(Closure)),
2434 !, NewRHS=RHS, % nl,print('FORALL EXPAND: '),(ground_value(Closure) -> print(ground(_Parameters)),nl, print_bexpr(LHS),nl ; print('NONGROUND!!'),nl,print_bexpr(RHS),nl), %%
2435 b_expand_closure_forall_to_list(Closure,ForAllDomain,WF).
2436 b_generate_for_all_domain2(_,Parameters,_,LHS,RHS,ForAllDomain,NewRHS,WF) :-
2437 is_a_conjunct(LHS,_,_), % otherwise we have already checked for set_membership above !
2438 LHS_Membership = b(member(_,_),_,_), % TO DO: also allow conjuncts
2439 ? member_conjunct(LHS_Membership,LHS,RestLHS),
2440 % !(x). ( x:Set & RestLHS => RHS) ---> !(x).(x:Set => (RestLHS => RHS))
2441 is_for_all_set_membership_predicate(LHS_Membership,Parameters,Set,Pattern,ParameterValues),
2442 ? max_cardinality_ok_for_expansion(Set,100,[],[]), % TO DO: simplify LS,S argument <----
2443 !,
2444 % as we expand Set without RHS predicate, check if this is ok
2445 % indeed maximum cardinality of Set could be infinite !! !x.(x:NATURAL1 & x<N => P)
2446 % print('Splitting for all conjunct: '), print(Parameters),nl, print_bexpr(LHS_Membership),nl,print_bexpr(RestLHS),nl, %%
2447 perfmessage_bexpr(good(forall),'Splitting LHS of forall: ',LHS),
2448 NewRHS = b(implication(RestLHS,RHS),pred,[]), % TO DO: extract & join info
2449 b_generate_set_for_all_domain(Set,[],[],Pattern,ParameterValues,ForAllDomain,WF).
2450 b_generate_for_all_domain2(Closure,_Parameters,ParCard,LHS,RHS,ForAllDomain,NewRHS,WF) :-
2451 (is_inf_or_overflow_card(ParCard) -> true ; ParCard>8),
2452 !,
2453 NewRHS=RHS,
2454 perfmessage_bexpr(forall,'No optimisations applicable to forall (will delay until all variables are bound): ',LHS), % maybe we should generate this message only if ForAllDomain is var ?
2455 b_expand_closure_forall_to_list(Closure,ForAllDomain,WF).
2456 b_generate_for_all_domain2(_Closure,Parameters,ParCard,LHS,RHS,ForAllDomain,NewRHS,WF) :-
2457 NewLHS=b(truth,pred,[]), NewRHS=b(implication(LHS,RHS),pred,[]),
2458 b_generate_forall_closure(Parameters,NewLHS,[],[],Closure,WF),
2459 perfmessages_bexpr(good(forall),['Expanding forall with finite parameter type, card = ',ParCard,': '],LHS),
2460 b_expand_closure_forall_to_list(Closure,ForAllDomain,WF).
2461
2462 % code to decide whether a for all should be expanded if the
2463 % predicate contains a set membership predicate : !x.( (P & x:S & P') => Q)
2464 max_cardinality_ok_for_expansion(b(Expr,Type,_Info),Limit,LS,S) :- % which value to choose for Limit ??
2465 ? kernel_objects:max_cardinality(Type,TypeCard),
2466 ( (number(TypeCard),TypeCard =< Limit) -> true ;
2467 max_cardinality_ok_for_expansion2(Expr,Limit,TypeCard,LS,S)).
2468
2469 max_cardinality_ok_for_expansion1(b(E,_,_),Limit,TC,LS,S) :-
2470 max_cardinality_ok_for_expansion2(E,Limit,TC,LS,S).
2471
2472 :- use_module(custom_explicit_sets,[efficient_card_for_set/3]).
2473
2474 max_cardinality_ok_for_expansion2(set_extension(E),Limit,_TC,_,_) :- !, length(E,Len), Len =< Limit.
2475 max_cardinality_ok_for_expansion2(interval(Up,Low),Limit,_TC,LS,S) :- !,
2476 get_integer(UpI,Up,LS,S), get_integer(LowI,Low,LS,S),
2477 UpI-LowI<Limit.
2478 max_cardinality_ok_for_expansion2(integer_set(GS),Limit,_TC,_LS,_S) :- !, b_global_set_cardinality(GS,Card),
2479 number(Card), Card =< Limit.
2480 max_cardinality_ok_for_expansion2(set_subtraction(A,_),Limit,TC,LS,S) :- !,
2481 max_cardinality_ok_for_expansion1(A,Limit,TC,LS,S).
2482 max_cardinality_ok_for_expansion2(image(RelA,_),Limit,TC,LS,S) :- !,
2483 max_cardinality_ok_for_expansion1(RelA,Limit,TC,LS,S).
2484 max_cardinality_ok_for_expansion2(function(_RelA,_),_Limit,_TC,_LS,_S) :- !,
2485 fail. % TO DO: we should look at the size of the range elements
2486 % max_cardinality_ok_for_expansion1(_RelA,_Limit,_TC,_LS,_S).
2487 max_cardinality_ok_for_expansion2(intersection(A,B),Limit,TC,LS,S) :- !,
2488 (max_cardinality_ok_for_expansion1(A,Limit,TC,LS,S) -> true ; max_cardinality_ok_for_expansion1(B,Limit,TC,LS,S)).
2489 max_cardinality_ok_for_expansion2(union(A,B),Limit,TC,LS,S) :- !,
2490 max_cardinality_ok_for_expansion1(A,Limit,TC,LS,S), max_cardinality_ok_for_expansion1(B,Limit,TC,LS,S).
2491 max_cardinality_ok_for_expansion2(range(A),Limit,TC,LS,S) :- !,
2492 max_cardinality_ok_for_expansion1(A,Limit,TC,LS,S).
2493 max_cardinality_ok_for_expansion2(domain(A),Limit,TC,LS,S) :- !,
2494 max_cardinality_ok_for_expansion1(A,Limit,TC,LS,S).
2495 max_cardinality_ok_for_expansion2(domain_restriction(_A,B),Limit,TC,LS,S) :- !,
2496 max_cardinality_ok_for_expansion1(B,Limit,TC,LS,S). % note: finite A does not guarantee finite result
2497 max_cardinality_ok_for_expansion2(domain_subtraction(_A,B),Limit,TC,LS,S) :- !,
2498 max_cardinality_ok_for_expansion1(B,Limit,TC,LS,S).
2499 max_cardinality_ok_for_expansion2(range_restriction(A,_B),Limit,TC,LS,S) :- !,
2500 max_cardinality_ok_for_expansion1(A,Limit,TC,LS,S). % note: finite B does not guarantee finite result
2501 max_cardinality_ok_for_expansion2(range_subtraction(A,_B),Limit,TC,LS,S) :- !,
2502 max_cardinality_ok_for_expansion1(A,Limit,TC,LS,S).
2503 max_cardinality_ok_for_expansion2(direct_product(A,B),Limit,TC,LS,S) :- !,
2504 max_cardinality_ok_for_expansion2(cartesian_product(A,B),Limit,TC,LS,S).
2505 max_cardinality_ok_for_expansion2(parallel_product(A,B),Limit,TC,LS,S) :- !,
2506 max_cardinality_ok_for_expansion2(cartesian_product(A,B),Limit,TC,LS,S).
2507 max_cardinality_ok_for_expansion2(cartesian_product(A,B),Limit,TC,LS,S) :- !,
2508 ILimit is Limit//2, ILimit>0, %use sqrt ?
2509 max_cardinality_ok_for_expansion1(A,ILimit,TC,LS,S),
2510 max_cardinality_ok_for_expansion1(B,ILimit,TC,LS,S).
2511 max_cardinality_ok_for_expansion2(value(S),Limit,_TC,_LS,_S) :- !,
2512 get_max_card_for_value(S,MaxCard),
2513 MaxCard =< Limit.
2514 max_cardinality_ok_for_expansion2(identifier(_ID),_Limit,TC,_LS,_S) :- !, number(TC).
2515 % TO DO: check if ID is fully defined; if so use card else accept as it will
2516 % probably be represented by a list and the forall constraints could be useful in finding ID's value
2517 % we have to store/compute ID anyway (could be infinite closure; hence check that TC is a number); a bit of a hack; is there a more principled way?
2518 max_cardinality_ok_for_expansion2(external_function_call(_,_),_,_,_,_) :- !,fail.
2519 max_cardinality_ok_for_expansion2(lazy_lookup_expr(_),_,_,_,_) :- !,fail.
2520 max_cardinality_ok_for_expansion2(record_field(_,_),_Limit,_TC,_LS,_S) :- !, fail.
2521 max_cardinality_ok_for_expansion2(E,Limit,TC,_LS,_S) :- functor(E,F,N),
2522 print(unknown_max_card(F/N,Limit,TC)),nl,fail.
2523
2524
2525 :- use_module(kernel_cardinality_attr,[clpfd_card_domain_for_var/3]).
2526
2527 get_max_card_for_value(S,MaxCard) :- var(S), !,
2528 clpfd_card_domain_for_var(S,_,Max), number(Max),
2529 MaxCard=Max.
2530 get_max_card_for_value([],R) :- !, R=0.
2531 get_max_card_for_value([_|T],R) :- !,get_max_card_for_value(T,TMax), R is TMax+1.
2532 get_max_card_for_value(S,Card) :- efficient_card_for_set(S,Card,C),!,
2533 call(C), number(Card).
2534
2535
2536 get_integer(X, b(Expr,integer,_),LS,S) :- get_integer2(Expr,X,LS,S).
2537 get_integer2(integer(X),X,_,_) :- number(X).
2538 get_integer2(identifier(Id),Val,LS,S) :- lookup_value(Id,LS,S,int(Val)), number(Val).
2539
2540 member_conjunct(Predicate,Conjunction,Rest) :-
2541 conjunction_to_list(Conjunction,List),
2542 ? select(Predicate,List,RestList),
2543 conjunct_predicates(RestList,Rest).
2544 % member_conjunct(Conj,Conj,b(truth,pred,[])). covered by case above
2545
2546 b_generate_set_for_all_domain(Set,LS,S,Pattern,ParameterValues,ForAllDomain,WF) :-
2547 b_compute_expression(Set,LS,S,EvSet,WF),
2548 expand_custom_set_to_list_wf(EvSet,ESet,_Done,b_generate_set_for_all_domain,WF),
2549 filter_and_convert_list_to_parameter_tuples(ESet,Pattern,ParameterValues,ForAllDomain).
2550
2551
2552 % check if it is a predicate of the form x:S or x:Sx & y:Sy ... which we can optimize
2553 % (i.e. compute SET before all values inside it are fully known)
2554 is_for_all_set_membership_predicate(LHS,Parameters,Set,Pattern,ParameterValues) :-
2555 % print('CHECK FORALL : '), translate:print_bexpr(LHS),nl,nl,
2556 get_texpr_ids(Parameters,ParIDs), % TO DO: call get_texpr_ids before
2557 same_length(ParIDs,ParameterValues),
2558 is_for_all_set_membership_predicate2(LHS,ParIDs,ParIDs,UnmatchedParIDs,Set,Pattern,ParameterValues,_UPV),
2559 UnmatchedParIDs=[].
2560
2561 % TODO: maybe also deal with existential quantifiers #x.(x|->y:Set) -> in Pattern x becomes free var
2562 is_for_all_set_membership_predicate2(LHS,All,ParIDs,UnmatchedParIDs,Set,Pattern,ParameterValues,UPV) :-
2563 is_member_test(LHS,Element,Set),
2564 !,
2565 identifiers_not_used_in_bexp(All,Set),
2566 convert_to_prolog_pattern_match(Element,ParIDs,UnmatchedParIDs,Pattern,ParameterValues,UPV).
2567 % TO DO: also allow failing pattern matches ?!; at least when splitting
2568 is_for_all_set_membership_predicate2(LHS,All,ParIDs,ParIDs2,Set,
2569 (Pat1,Pat2),ParameterValues,UPV) :-
2570 is_a_conjunct(LHS,LHS1,LHS2), % we could have something of the form x:Sx & y:Sy ...
2571 Set = b(cartesian_product(Set1,Set2),couple(T1,T2),[]),
2572 is_for_all_set_membership_predicate2(LHS1,All,ParIDs, ParIDs1,Set1,Pat1,ParameterValues,PV1),
2573 get_texpr_type(Set1,T1),
2574 !,
2575 is_for_all_set_membership_predicate2(LHS2,All,ParIDs1,ParIDs2,Set2,Pat2,PV1,UPV),
2576 get_texpr_type(Set2,T2).
2577
2578 % TO DO: maybe use a more general test to be reused in other places
2579 is_member_test(b(P,_,_),Element,Set) :- is_member_test_aux(P,Element,Set).
2580 is_member_test_aux(member(Element,Set),Element,Set).
2581 % also detect equalities: important for tests 28,29 after b_compiler can introduce equalities for singleton set memberships
2582 is_member_test_aux(equal(Element,SetVal),Element,Set) :- % TO DO : also other direction + other kinds of values ?
2583 SetVal = b(value(SV),T,I),
2584 Set = b(value([SV]),set(T),I).
2585
2586 identifiers_not_used_in_bexp(IDList,Expr) :-
2587 find_identifier_uses(Expr,[],Used),
2588 id_check(IDList,Used).
2589 id_check([],_).
2590 id_check([ID|T],Used) :-
2591 nonmember(ID,Used), !,
2592 id_check(T,Used).
2593
2594 % check if an expression can be converted to a Prolog linear unification/pattern match
2595 % give an list of free identifiers IDS
2596 convert_to_prolog_pattern_match(b(E,_,_),IDS,OutIDS,Pattern,VarsIn,VarsOut) :-
2597 convert_to_prolog_pattern_match2(E,IDS,OutIDS,Pattern,VarsIn,VarsOut).
2598
2599 convert_to_prolog_pattern_match2(identifier(ID),IDsIn,IDsOut,PatVariable,VarsIn,VarsOut) :-
2600 % check that the identifier is in the list of quantified variables and thus unbound
2601 !,
2602 ? (nth1(Nr,IDsIn,ID,IDsOut)
2603 -> nth1(Nr,VarsIn,PatVariable,VarsOut) % put fresh PatVariable in the Pattern
2604 ),!.
2605 convert_to_prolog_pattern_match2(couple(ID1,ID2),IDS,OutIDS,Pattern,VarsIn,VarsOut) :-
2606 Pattern = (Pat1,Pat2),
2607 convert_to_prolog_pattern_match(ID1,IDS,RemIDS,Pat1,VarsIn,VarsInt),
2608 convert_to_prolog_pattern_match(ID2,RemIDS,OutIDS,Pat2,VarsInt,VarsOut).
2609 convert_to_prolog_pattern_match2(value(V),IDsIn,IDsOut,Pattern,VarsIn,VarsOut) :-
2610 can_be_used_for_unification(V), % check if we can use Prolog unification for equality
2611 !, Pattern=V, IDsOut=IDsIn, VarsIn=VarsOut.
2612 % TO DO: records?
2613
2614 % a pattern match code to be used with above; ensure we do not instantiate values
2615 pattern_match(PatVar,Val,Res) :- var(PatVar),!,PatVar=Val, Res=pred_true. % we have a free pattern variable
2616 pattern_match((Pat1,Pat2),(V1,V2),Res) :- !,
2617 pattern_match(Pat1,V1,R1), conjoin_simple(R1,R2,Res),
2618 pattern_match(Pat2,V2,R2).
2619 pattern_match(GroundPatVal,Val,Res) :- % we have a value that can_be_used_for_unification
2620 when( ?=(GroundPatVal,Val), (GroundPatVal=Val -> Res=pred_true ; Res=pred_false)).
2621
2622 :- block conjoin_simple(-,?,?). % TO DO: also allow second arg to unblock
2623 conjoin_simple(pred_true,X,X).
2624 conjoin_simple(pred_false,_,pred_false).
2625
2626 % similar to get_template(V,T,[])
2627 % but more restricted; we only accept those values where equality corresponds to Prolog unification
2628 % get_template is different and can assume normalized values, e.g., for empty set
2629 % pairs are treated above in convert_to_prolog_pattern_match2
2630 can_be_used_for_unification(V) :- var(V),!,fail.
2631 can_be_used_for_unification(int(V)) :- nonvar(V).
2632 can_be_used_for_unification(string(S)) :- ground(S).
2633 can_be_used_for_unification(fd(S,T)) :- ground(S), ground(T).
2634 can_be_used_for_unification(pred_false).
2635 can_be_used_for_unification(pred_true).
2636
2637
2638
2639 % take a list and a pattern and filter the values that do not match the Pattern
2640 % Unification with the Pattern also instantiates the ParameterValues
2641 % TODO: Instead of converting to a Prolog Unification we could use kernel_equality instead of pattern_match
2642 % but this is not obvious, as the pattern contains free variables and equality would never return true
2643 % we would need to apply kernel_equality only to the ground pattern parts
2644 :- block filter_and_convert_list_to_parameter_tuples(-,?,?,?).
2645 filter_and_convert_list_to_parameter_tuples([],_,_,[]).
2646 filter_and_convert_list_to_parameter_tuples([H|T],Pattern,ParameterValues,Res) :-
2647 copy_term((Pattern,ParameterValues),(CPat,CPV)),
2648 pattern_match(CPat,H,PredRes), % check if pattern matches new element H in set; careful not to instantiate H
2649 ? filter_and_convert_list_to_parameter_tuples_aux(PredRes,CPV,T,Pattern,ParameterValues,Res).
2650
2651 :- block filter_and_convert_list_to_parameter_tuples_aux(-,?,-,?,?,?).
2652 filter_and_convert_list_to_parameter_tuples_aux(PredRes,CPV,T,Pattern,ParameterValues,Res) :-
2653 var(PredRes),!, % we cannot decide yet whether the optional value is to be used or not
2654 Res = [optional_value(CPV,PredRes)|RT], % create constructor for map_optlist or similar
2655 filter_and_convert_list_to_parameter_tuples(T,Pattern,ParameterValues,RT).
2656 filter_and_convert_list_to_parameter_tuples_aux(PredRes,CPV,T,Pattern,ParameterValues,Res) :-
2657 (PredRes = pred_true % we have a match, universal quantifier applies to H
2658 -> Res = [CPV|RT]
2659 ; % element of set does not match pattern; universal quantifier does not apply
2660 % ProB used to only accept non-failing pattern matches;
2661 % now we also accept tuples with static parts where Prolog unification can fail
2662 Res=RT
2663 ),
2664 ? filter_and_convert_list_to_parameter_tuples(T,Pattern,ParameterValues,RT).
2665
2666 :- use_module(tools,[map_optlist/2,optlist_to_list/2]).
2667 :- use_module(library(lists),[maplist/3]).
2668 expand_forall1(OList,RHS,Parameters,WF) :-
2669 ground_bexpr(RHS), % because compiled this means we cannot do any constraint propagation on variables in RHS
2670 optlist_to_list(OList,List),
2671 ground_value(List), % ditto here: no variables on which we could do constraint propagation
2672 %% preferences:get_preference(double_evaluation_when_analysing,false), % causes test 1112 to fail TO DO:fix
2673 % otherwise we do not have a real redundancy wrt to not exists check
2674 debug_println(15,ground_forall_translating_into_not_exists(Parameters)),
2675 !,
2676 %kernel_waitflags:init_wait_flags(LocalWF,[expansion_context(forall,Parameters)]),
2677 init_quantifier_wait_flag(WF,forall,Parameters,ParResult,unknown,LocalWF),
2678 % Advantage over treatment below: NegRHS is interpreted only once
2679 % but we cannot provide any instantiations and there must not be any links with variables outside of the forall !!
2680 create_negation(RHS,NegRHS),
2681 not_with_enum_warning( (
2682 b_interpreter:test_forall_instance(NegRHS,Parameters,LocalWF,negative,ParResult), % can fail; if inconsistency detected in WF0
2683 kernel_waitflags:ground_det_wait_flag(LocalWF),
2684 member(ParResultInList,List), % check the body for every solution
2685 lists:maplist(kernel_objects:equal_object,ParResultInList,ParResult), % match parameters with the solutions of the domain
2686 kernel_waitflags:ground_wait_flags(LocalWF) % do not ground EF? ground_constraintprop_wait_flags ground_inner_wait_flags
2687 ), LocalWF, forall(Parameters), RHS
2688 ).
2689 expand_forall1(List,RHS,Parameters,WF) :-
2690 ? map_optlist(b_interpreter:test_forall_instance(RHS,Parameters,WF,positive),List).
2691
2692
2693 test_forall_instance(RHS,Parameters,WF,NegationContext,ParResult) :-
2694 LocalState=[],State=[],
2695 ? if(set_up_typed_localstate(Parameters,ParResult,_TypedVals,LocalState,NewLocalState,NegationContext),
2696 true,
2697 (nl,print(set_up_typed_localstate_failed(Parameters,ParResult,_,LocalState,NewLocalState)),nl,
2698 % it can happen that ParResult has constraints on it and that setting up the typing info detects the error
2699 % add_internal_error('Call failed: ', set_up_typed_localstate(Parameters,ParResult,_,LocalState,NewLocalState)),
2700 fail)),
2701 ? b_optimized_b_test_instance(RHS,NewLocalState,State,WF).
2702
2703 reification_relevant_for_op(implication(_,_)).
2704 reification_relevant_for_op(equivalence(_,_)).
2705 reification_relevant_for_op(disjunct(_,_)).
2706 % TODO: maybe check if a conjunct contains implication
2707 % relevant for example for: n=2000 & f:1..n-->BOOL & !i.(i:2..n => (f(i)=TRUE =>f(i-1)=FALSE)) & f(1)=TRUE
2708
2709 b_optimized_b_test_instance(RHS,NewLocalState,State,WF) :-
2710 get_texpr_expr(RHS,RE), reification_relevant_for_op(RE), % we will attempt reification
2711 attempt_reification,
2712 \+ always_well_defined(RHS), % this will prevent reification
2713 !,
2714 % try and compile in the hope that now the WD issue disappears:
2715 b_compiler:b_optimize(RHS,[],NewLocalState,State,NewRHS,WF),
2716 b_test_boolean_expression(NewRHS,NewLocalState,State,WF).
2717 b_optimized_b_test_instance(RHS,NewLocalState,State,WF) :-
2718 ? b_test_boolean_expression(RHS,NewLocalState,State,WF).
2719 % using b_test_inner_boolean_expression considerably slows down NQueens, Sudoku,...
2720 % WF=InnerWF. /* give the boolean expression a chance to do ground propagations first */
2721
2722
2723 % use this when the test boolean expression could be called with WF0 already set
2724 % give the inner expression a chance to do the deterministic stuff first
2725 b_test_inner_boolean_expression(Pred,LocalState,State,WF) :-
2726 kernel_waitflags:clone_wait_flags_from1(WF,GroundUponFinish,WF2),
2727 % set WF0 to variable to propagate deterministic infos first:
2728 ? b_test_boolean_expression(Pred,LocalState,State,WF2),
2729 ? kernel_waitflags:clone_wait_flags_from1_finish(WF,GroundUponFinish,WF2).
2730 % the same for testing negation of a predicate:
2731 b_not_test_inner_boolean_expression(Pred,LocalState,State,WF) :-
2732 kernel_waitflags:clone_wait_flags_from1(WF,GroundUponFinish,WF2),
2733 % set WF0 to variable to propagate deterministic infos first:
2734 b_not_test_boolean_expression(Pred,LocalState,State,WF2),
2735 ? kernel_waitflags:clone_wait_flags_from1_finish(WF,GroundUponFinish,WF2).
2736
2737 /* now the same as above; but without converting list of values into pairs */
2738 :- assert_pre(b_interpreter:b_expand_closure_forall_to_list(Closure,_Result,_WF),
2739 (nonvar(Closure), custom_explicit_sets:is_closure(Closure,_Parameters,_ParameterTypes,ClosureBody),
2740 nonvar(ClosureBody),
2741 bsyntaxtree:check_if_typed_predicate(ClosureBody))).
2742 :- assert_post(b_interpreter:b_expand_closure_forall_to_list(_Closure,Result,_WF),
2743 b_interpreter:value_type(Result)).
2744 b_expand_closure_forall_to_list(Closure,Result,WF) :- nonvar(Closure),
2745 Closure = closure(Parameters,ParameterTypes,ClosureBody),
2746 !,
2747 % print('Expand closure forall: '), translate:print_bexpr(ClosureBody),nl,
2748 % at the moment we may wait too long before expanding this closure
2749 % what if we have f(1) in the ClosureBody: in principle we only need to wait until f(1) known or even f sekeleton set up ? compilation now solves this issue ?
2750 (performance_monitoring_on,
2751 term_variables(ClosureBody,Vars),
2752 Vars \= []
2753 ->
2754 perfmessagecall(delaying_forall(Parameters,vars(Vars),out(ParValues)),
2755 translate:print_bexpr(ClosureBody),ClosureBody)
2756 ; true),
2757 ground_bexpr_check(ClosureBody,BodyGround),
2758 add_texpr_infos(ClosureBody,[quantifier_kind(forall)],ClosureBody1), % for call_stack
2759 delay_setof_list_wf( ParValues,
2760 %% (print_bt_message(expanding_forall_closure(Parameters,ClosureBody,ParValues)), %%
2761 custom_explicit_sets:b_test_closure(Parameters,ParameterTypes,ClosureBody1,
2762 ParValues,all_solutions,WF)
2763 %% ,print_bt_message(expanded(Parameters,ParValues)) ) %%
2764 ,
2765 Result,
2766 BodyGround,WF).
2767 b_expand_closure_forall_to_list(Closure,Result,WF) :-
2768 add_internal_error('Illegal Call: ', b_expand_closure_forall_to_list(Closure,Result,WF)),
2769 fail.
2770
2771
2772 :- assert_pre(b_interpreter:set_up_typed_localstate(V,S,_), (list_skeleton(V),list_skeleton(S))).
2773 :- assert_post(b_interpreter:set_up_typed_localstate(_,_,R),list_skeleton(R)).
2774
2775 set_up_typed_localstate(Identifiers,InState,OutState) :-
2776 ? set_up_typed_localstate(Identifiers,_FreshVars,_TypedVals,InState,OutState,positive).
2777
2778 :- use_module(b_enumerate,[construct_typedval_infos/4]).
2779 set_up_typed_localstate([],[],[],State,State,_).
2780 set_up_typed_localstate([Identifier|IdRest],[Val|ValRest],[typedval(Val,Type,Var,TINFO)|TRest],
2781 % TO DO: add info field to typedval: source_span, and lambda_result/do_not_enumerate infos
2782 InState,OutState,NegationContext) :-
2783 % The other way round (first add Identfier, then IdRest) would be more efficient,
2784 % but we do it this way to keep compatibility with a previous version.
2785 % In specfile:compute_operation_effect, the arguments of an operation are in the same order than in the store
2786 ? set_up_typed_localstate(IdRest,ValRest,TRest,InState,InterState,NegationContext),
2787 def_get_texpr_id(Identifier,Var), get_texpr_type(Identifier,Type),
2788 get_texpr_info(Identifier,Info),
2789 triggers_enum_warning(Var,Type,Info,NegationContext,TriggersEnumWarning),
2790 get_texpr_info(Identifier,Infos),construct_typedval_infos(Var,Infos,TriggersEnumWarning,TINFO),
2791 ? add_typed_var_to_localstate(Var,Val,Type,InterState,OutState).
2792
2793 % same version; but with list of atomic ids and list of types
2794 set_up_typed_localstate2([],[],_,[],[],State,State,_).
2795 set_up_typed_localstate2([Var|IdRest],[Type|TyRest],Infos,[Val|ValRest],[typedval(Val,Type,Var,TINFO)|TRest],
2796 InState,OutState,NegationContext) :-
2797 % The other way round (first add Identfier, then IdRest) would be more efficient,
2798 % but we do it this way to keep compatibility with a previous version.
2799 % In specfile:compute_operation_effect, the arguments of an operation are in the same order than in the store
2800 ? set_up_typed_localstate2(IdRest,TyRest,Infos,ValRest,TRest,InState,InterState,NegationContext),
2801 triggers_enum_warning(Var,Type,Infos,NegationContext,TriggersEnumWarning),
2802 construct_typedval_infos(Var,Infos,TriggersEnumWarning,TINFO),
2803 ? add_typed_var_to_localstate(Var,Val,Type,InterState,OutState).
2804
2805 % possible values for NegationContext: positive, negative, all_solutions
2806 triggers_enum_warning(Id,Type,Info,all_solutions,Res) :- !,
2807 Res = trigger_throw(b(identifier(Id),Type,Info)).
2808 %triggers_enum_warning(Id,_Type,Info,NegationContext,trigger_false(Id)) :- % no longer used
2809 % NegationContext=positive, % when negated then success will occur if all possibilities have been tried out
2810 % memberchk(introduced_by(exists),Info),
2811 % %%((preferences:get_preference(disprover_mode,true),type_contains_unfixed_deferred_set(Type))-> fail % otherwise %finding a solution may depend on the size of the deferred set; true),
2812 % %% The Disprover now checks whether unfixed_deferred sets were involved; keeping track of implicit enumerations of %deferred sets is just too difficult
2813 % !.
2814 triggers_enum_warning(Id,Type,Info,_,trigger_true(b(identifier(Id),Type,Info))).
2815
2816
2817 add_typed_var_to_localstate(Var,Val,Type,InState,OutState) :-
2818 add_var_to_localstate(Var,Val,InState,OutState),
2819 %%when(ground(Val), (print(' ++ '),print(Var),print(' ---> '), print(Val),nl)),
2820 ? kernel_objects:basic_type(Val,Type). %% ,print(ok(Val)),nl.
2821
2822 /*
2823 xxb_test_exists(Parameters,Condition,Infos,LocalState,State,WF) :-
2824 b_check_boolean_expression(b(exists(Parameters,Condition),pred,Infos),LocalState,State,WF,NR),
2825 get_exists_used_ids(Parameters,Condition,Infos,Used),lookup_values_if_vars(Used,LocalState,State,WaitVars),
2826 \+ ground(WaitVars),
2827 !,
2828 debug_println(9,unfolding_exists(Parameters)), print(unfolding(Parameters)),nl,
2829 %translate:print_bexpr(Condition),nl, print(State),nl, print(LocalState),nl,nl,
2830 NR=pred_true. %, print(set_res(pred_true)),nl.
2831 % if enabled it slows down: ./probcli examples/EventBPrologPackages/SET_Game/SET_GAM_Sym_NoSet20_mch.eventb -mc 10000000 -p SYMMETRY_MODE hash -p TIME_OUT 7000 -p CLPFD TRUE -df -goal "n=18" -p MAX_OPERATIONS 20 -strict -expcterr goal_found
2832 */
2833
2834 b_test_exists(Parameters,Condition,Infos,LocalState,State,WF) :-
2835 get_wait_flag0(WF,WF0),
2836 ? b_test_exists(WF0,Parameters,Condition,Infos,LocalState,State,WF).
2837
2838 :- block b_test_exists(-,?,?, ?,?,?,?).
2839 b_test_exists(_LWF,Parameters,Condition,Infos,LocalState,State,WF) :-
2840 if((attempt_reification, % what if there is a wd_condition attached to Condition?
2841 b_interpreter_check:b_check_exists_wf(Parameters,Condition,Infos,LocalState,State,WF,ReificationVariable)),
2842 % try and expand quantifiers of small cardinality; see also expand_forall_quantifier
2843 % tested in test 1452
2844 (debug_println(9,expanded_exists(Parameters)),
2845 ReificationVariable=pred_true),
2846 ? b_test_exists_wo_expansion(Parameters,Condition,Infos,LocalState,State,WF)).
2847
2848 %attempt_reification :- preferences:preference(use_clpfd_solver,true),!. % all tests seem to pass
2849 attempt_reification :- preferences:preference(use_smt_mode,true),!.
2850 attempt_reification :- preferences:preference(solver_strength,SS), SS>9.
2851 % TO DO: maybe take context into account: setup constants, becomes such, ... allow_skipping_over_components/reset_component_info(true)
2852
2853 :- use_module(kernel_tools,[bexpr_variables/2, value_variables/3]).
2854
2855 % we treat the existential quantifier without expansion into a disjuncition aka reification
2856 b_test_exists_wo_expansion(Parameters,Condition,Infos,LocalState,State,WF) :-
2857 %print(test_exists(Parameters,Infos)),nl,portray_waitflags(WF),nl,
2858 ? (preference(lift_existential_quantifiers,true) ; member(allow_to_lift_exists,Infos)),
2859 !, % we enumerate the exists normally; treat it just like an ordinary predicate
2860 % lifting may generate multiple solutions; but avoids delaying enumeration of quantified parameters
2861 % print('*Lifting existential quantifier: '), translate:print_bexpr(Condition),nl,
2862 ? set_up_typed_localstate(Parameters,ParaValues,TypedVals,LocalState,NewLocalState,positive),
2863 copy_wf_start(WF,b_test_exists_wo_expansion,CWF),
2864 opt_push_wait_flag_call_stack_quantifier_info(CWF,exists,Parameters,ParaValues,Infos,CWF2),
2865 ? b_test_boolean_expression(Condition,NewLocalState,State,CWF2),
2866 % often we do not need to enumerate TypedVals; they can be derived, but we could have #y.(y>x) and need to enum y
2867 b_tighter_enumerate_values_in_ctxt(TypedVals,Condition,CWF2),
2868 ? copy_wf_finish(WF,CWF2). % moving this before tighter_enum may mean that we have more precise ranges; but this can be counter-productive (e.g., for test 1162 unless we strengthen the useless enum analysis)
2869 b_test_exists_wo_expansion(Parameters,Condition,Infos,LocalState,State,WF) :-
2870 get_exists_used_ids(Parameters,Condition,Infos,Used),
2871 % IT IS IMPORTANT THAT THE USED INFO IS CORRECT ; otherwise the WaitVars will be incorrect
2872 % The used_ids info does not include the Parameters of the existential quantifier !
2873 ? set_up_typed_localstate(Parameters,ParaValues,TypedVals,LocalState,NewLocalState,positive),
2874 lookup_values_if_vars(Used,LocalState,State,WaitVarsState), % TO DO: we could use b_compiler instead
2875 % What if the Condition was compiled and now contains a previously used_variable inside a closure/value ?
2876 %term_variables((Condition,WaitVarsState),WaitVars), % this can be expensive when we have large data values (see rule_RVF219/rule_RVF219_compo.mch)
2877 bexpr_variables(Condition,CondVars),
2878 value_variables(WaitVarsState,CondVars,WaitVars),
2879 % now determine which WaitVars are really worth waiting for, e.g., do not wait for res in #x.(x:E & ... res=min(f(x)))
2880 % relevant tests: 1868, 1194, 383, 1642, 1708, 1003, 1080, 1081, 1943
2881 (remove_ids_defined_by_equality(WaitVars,LocalState,State,Infos,RealWaitVars) -> RemovedVars=true
2882 ; RealWaitVars = WaitVars, RemovedVars=false),
2883 opt_push_wait_flag_call_stack_quantifier_info(WF,exists,Parameters,ParaValues,Infos,WF2),
2884 create_inner_wait_flags(WF2,expansion_context(b_test_exists,Parameters),LocalWF), % we are creating inner waitflags here as the exist will wait anyway; LocalWF shares just WFE flag with WF
2885 ? b_test_boolean_expression(Condition,NewLocalState,State,LocalWF), /* check Condition */
2886 ? ground_det_wait_flag(LocalWF), % print('det no contradiction'),nl,flush_output,
2887 b_tighter_enumerate_values_in_ctxt(TypedVals,Condition,LocalWF), % will not yet enumerate
2888 (% we could treat allow_to_lift_exists also here by setting ESWF=1; but 1162 then fails
2889 get_preference(data_validation_mode,true),
2890 not_generated_exists_paras(Parameters) % generated exists, e.g., for relational composition can lead to virtual timeouts, cf Thales_All/rule_zcpa2.mch in test 2287
2891 -> get_wait_flag(50000,b_test_exists(Parameters),WF,ESWF) % 100000 sufficient for test 1945; 869 for rule_CHAMPS in private_examples/ClearSy/2023
2892 ; get_enumeration_starting_wait_flag(b_test_exists(Parameters),WF,ESWF)), %% TO DO: get flag when enumeration of infinite type starts; maybe if domain of exists is small we can start enumerating earlier ?? <-> relation with lifting exists in closure expansion heuristic
2893 when((nonvar(ESWF);ground(RealWaitVars)),b_enumerate_exists(ESWF,RemovedVars,WaitVars,Parameters,Infos,LocalWF,WF)).
2894
2895
2896 :- use_module(tools,[remove_variables/3]).
2897 :- use_module(kernel_tools,[value_variables/2]).
2898 % if we have #x.( P & y = E(x)) we do not have to wait for y to be known
2899 remove_ids_defined_by_equality(WaitVars,LocalState,State,Infos,RealWaitVars) :- WaitVars \== [],
2900 memberchk(used_ids_defined_by_equality(Ideq),Infos),
2901 Ideq = [ID1|_], % currently we only look at one used_id defined by equality,
2902 % we could have #x.(P & y=E(z) & z=E(y)): TODO: improve computation in ast_cleanup
2903 (memberchk(bind(ID1,VAL),LocalState) -> true ; memberchk(bind(ID1,VAL),State)),
2904 value_variables(VAL,VARS),
2905 remove_variables(WaitVars,VARS,RealWaitVars),
2906 debug_println(9,removed_ids_def_by_equality(WaitVars,ID1,RealWaitVars)).
2907
2908
2909 b_enumerate_exists(ESWF,RemovedVars,WaitVars,Parameters,Infos,LocalWF,WF) :-
2910 %print(enum_exists(ESWF,RemovedVars,WaitVars,Parameters,LocalWF,WF)),nl,
2911 ((RemovedVars=false,var(ESWF) ; % WaitVars guaranteed to be ground
2912 ground(WaitVars)) % TODO: replace this by an optimised version of ground check
2913 -> get_idle_flag(Parameters,WF,LWF),
2914 /* allow all other co-routines waiting on WaitVars to complete */
2915 /* Note however: if WF grounding as triggered two non-deterministic co-routines this
2916 will allow the other non-determinism to run first, duplicating the number of calls !
2917 This has been fixed by storing seperate waitflag variables for same prio in kernel_waitflags
2918 TODO: However, for enumeration of FD variables this might still happen and lead to duplication of
2919 calls to b_enumerate_exists_aux_ground
2920 */
2921 %print(get_idle(Parameters,WaitVars)),nl, %kernel_waitflags:portray_waitflags(WF),nl,nl,
2922 b_enumerate_exists_aux_ground(LWF,WaitVars,Parameters,Infos,LocalWF,WF)
2923 ; debug_println(9,semi_lifting_exists(ESWF,Parameters)),
2924 % add_message_wf(exists,'Semi-lifting exists:',Parameters,Parameters,WF),portray_waitflags(LocalWF),nl,
2925 kernel_waitflags:copy_waitflag_store(LocalWF,WF) % outer WF will now drive enumeration
2926 % Note: in case a LET has been moved inside and replaced this may lead to duplication
2927 ).
2928
2929 :- if(environ(prob_safe_mode,true)).
2930 get_idle_flag(Parameters,WF,LWF) :- kernel_waitflags:get_idle_wait_flag(b_enumerate_exists(Parameters),WF,LWF),
2931 (var(LWF) -> true ; add_internal_error('Illegal idle waitflag for exists:',get_idle_flag(Parameters,WF,LWF))).
2932 :- else.
2933 get_idle_flag(Parameters,WF,LWF) :- kernel_waitflags:get_idle_wait_flag(b_enumerate_exists(Parameters),WF,LWF).
2934 :- endif.
2935
2936 :- block b_enumerate_exists_aux_ground(-,?,?,?,?,?).
2937 b_enumerate_exists_aux_ground(_,_WaitVars,Parameters,Infos,LocalWF,_WF) :-
2938 /* Note: this does a local cut: so it is important
2939 that all conditions are fully evaluated before performing the cut ; otherwise
2940 solutions will be lost */
2941 % print_bt_message('ENUMERATE EXISTS'(_Parameters)),nl, % portray_waitflags(_WF),
2942 if(ground_wait_flags_for_exists(Parameters,LocalWF),true,
2943 (perfmessage(exists,'Late bound exists failed: ',Parameters,Infos),fail)).
2944
2945
2946 ground_wait_flags_for_exists(Parameters,LocalWF) :-
2947 ? \+ enumeration_warning_occured_in_error_scope,
2948 get_current_error_scope(Level),
2949 ? \+ error_manager:throw_error(Level,_,_),
2950 !, % current scope is already clean, no need to enter a fresh one
2951 ground_wait_flags_for_exists2(Parameters,LocalWF,Level).
2952 ground_wait_flags_for_exists(Parameters,LocalWF) :-
2953 enter_new_clean_error_scope(Level),
2954 % Note: see {x|x:1..10 & #y.(y>x & y*y >10)} in test 2210:
2955 % we do not want to throw enum warnings even if the outer scope does in case a solution is found
2956 % NOTE: if this engenders an enumeration warning: it may have been better to enumerate the outer WF first ?! : but as WaitVars are ground, so only failure of outer WF could help us here in preventing enumeration warning
2957 call_cleanup(ground_wait_flags_for_exists2(Parameters,LocalWF,Level),
2958 exit_error_scope(Level,_,ground_wait_flags_for_exists)).
2959
2960 ground_wait_flags_for_exists2(_Parameters,LocalWF,Level) :-
2961 ? (ground_constraintprop_wait_flags(LocalWF)
2962 -> % local cut: one solution is sufficient.
2963 clear_enumeration_warning_in_error_scope(Level)
2964 % ; %print(fail),nl, % do not clear enumeration warnings fail
2965 ).
2966
2967
2968 :- use_module(b_ast_cleanup,[check_used_ids_info/4]).
2969 get_exists_used_ids(Parameters,Condition,Infos,Used) :-
2970 preference(prob_safe_mode,true),!,
2971 (select(used_ids(Used),Infos,Rest)
2972 -> check_used_ids_info(Parameters,Condition,Used,exists), %% comment in to check used_ids field
2973 (member(used_ids(_),Rest)
2974 -> add_internal_error('Multiple used_ids info fields:',Parameters:Infos) ; true)
2975 ;
2976 add_internal_error(
2977 'Expected information of used identifiers in exists information',Parameters:Infos),
2978 bsyntaxtree:find_identifier_uses(Condition, [], Used)
2979 ).
2980 get_exists_used_ids(Parameters,Condition,Infos,Used) :-
2981 ? member(used_ids(Used),Infos) -> true
2982 ;
2983 add_internal_error(
2984 'Expected information of used identifiers in exists information',Parameters:Infos),
2985 bsyntaxtree:find_identifier_uses(Condition, [], Used).
2986 % what if we call test_exists for a negated universal quantifier ??
2987
2988
2989
2990
2991 :- use_module(kernel_tools,[ground_state/1]).
2992 /* the following causes performance problems with examples/B/Mathematical/GraphIso/CheckGraphIsomorphism
2993 and with lausanne.mch in SMT mode */
2994 b_not_test_exists(Parameters,Condition,Infos,LocalState,State,_,WF) :-
2995 preferences:preference(use_smt_mode,true),
2996 is_a_conjunct(Condition,LHS,RHS),
2997 (\+ ground_state(LocalState) ; \+ ground_state(State)),
2998 % TO DO: check if any of the variables in Condition are not ground
2999 % TO DO: check if used_ids exist in Infos ? memberchk(used_ids(_),Infos),
3000 !,
3001 %print(translating_not_exists_into_forall),nl,print(' '),print_bexpr(LHS),nl, print('=> '),print_bexpr(RHS),nl,
3002 (is_for_all_set_membership_predicate(RHS,Parameters,_Set,_Pattern,_ParameterValues),
3003 \+ is_for_all_set_membership_predicate(LHS,Parameters,_,_,_)
3004 -> LLHS=RHS, RRHS=LHS % swap LHS and RHS; TO DO: search for membership predicate inside LHS,RHS !!
3005 ; LLHS=LHS, RRHS=RHS
3006 ),
3007 safe_create_texpr(negation(RRHS),pred,NegRHS),
3008 b_for_all(Parameters,Infos,LLHS,NegRHS,LocalState,State,WF).
3009 b_not_test_exists(Parameters,Condition,Infos,[],[],no_compile,WF) :- !,
3010 % already compiled in is_empty_closure_wf
3011 ground_bexpr_check(Condition,Ground),
3012 b_not_test_exists_aux(Ground,Parameters,Condition, Infos, WF).
3013 b_not_test_exists(Parameters,Condition,Infos,LocalState,State,_,WF) :-
3014 % compile to remove dependency on unused parts of State+LocalState; will make it delay less below
3015 def_get_texpr_ids(Parameters,ParaIDs),
3016 %% print(b_not_test_exists(ParaIDs)),nl, print(state(LocalState,State)),nl, %%
3017 ? b_compiler:b_compile(Condition,ParaIDs,LocalState,State,CompiledCond,WF),
3018 (is_truth(CompiledCond) -> fail
3019 ; is_falsity(CompiledCond) -> true
3020 % TO DO: we could detect equalities that will always succeed (but be careful for WD issues)
3021 ; ground_bexpr_check(CompiledCond,Ground),
3022 b_not_test_exists_aux(Ground,Parameters,CompiledCond, Infos, WF)
3023 ).
3024
3025 :- block b_not_test_exists_aux(-,?,?,?,?).
3026 b_not_test_exists_aux(_,Parameters,CompiledCond,Infos,WF) :-
3027 % getting an idle waitflag considerably slows down test 1739; see also ClearSy/2019_Aug/call_residue/rule_erreur.mch
3028 % slow down no longer the case with the new waitflag implementation
3029 kernel_waitflags:get_idle_wait_flag(b_not_test_exists_aux(Parameters),WF,LWF),
3030 % allow pending co-routines to complete
3031 b_not_test_exists_aux2(LWF,Parameters,CompiledCond,Infos,WF).
3032 :- block b_not_test_exists_aux2(-,?,?,?,?).
3033 b_not_test_exists_aux2(_,Parameters,CompiledCond,Infos,WF) :-
3034 % no need to create inner waitflag: we enumerate fully below: create_inner_wait_flags(WF,b_not_test_exists(Parameters),LocalWF),
3035 %init_wait_flags(LocalWF,[expansion_context(b_not_not_test_exists,Parameters)]),
3036 init_quantifier_wait_flag(WF,not(exists),Parameters,ParaResult,Infos,LocalWF),
3037 not_with_enum_warning(
3038 b_interpreter:b_not_not_test_exists_aux(Parameters,ParaResult,CompiledCond,LocalWF),
3039 LocalWF, CompiledCond, % was not_exists(Parameters), the not_exists quantifier call is on call_stack now
3040 CompiledCond),
3041 copy_wfe_from_inner_if_necessary(LocalWF,WF). % for the case that the negated call has found abort errors and WFE was not grounded
3042 b_not_not_test_exists_aux(Parameters,ParaResult,CompiledCond,LocalWF) :-
3043 ? b_interpreter:set_up_typed_localstate(Parameters,ParaResult,TypedVals,[],NewLocalState,negated),
3044 % delay generation of WD error messages until outer WFE flag set
3045 ? b_interpreter:b_test_boolean_expression(CompiledCond,NewLocalState,[],LocalWF), % check Condition
3046 b_tighter_enumerate_values_in_ctxt(TypedVals,CompiledCond,LocalWF),
3047 ? ground_inner_wait_flags(LocalWF). % does not always ground WFE if abort is pending in which case not_with_enum_warning also does not fail and keeps the co-routines
3048 % pending co-routines will be discarded by negation !
3049
3050
3051 /* --------------------------------- */
3052
3053 value_type(_X). % only used in post_conditions (assert_post)
3054 /*
3055 value_type(X) :- nonvar(X),
3056 (X = value(_) ; X = global_set(_) ;
3057 X = global_constant(_) ; X = term(_)).*/
3058
3059
3060 % look up identifiers in store, if the identifier
3061 % is not in the store, assume it's a constant and ignore it
3062 % used for determining wait variables for existential quantifier
3063 % TO DO: better deal with CSE @identifiers ?
3064 lookup_values_if_vars([],_,_,[]).
3065 lookup_values_if_vars([Id|IRest],LocalStore,Store,Values) :-
3066 ( lookup_value(Id,LocalStore,Store,Val)
3067 -> (force_evaluation_of_lazy_value(Id,Val,RealVal)
3068 -> Values = [RealVal|VRest]
3069 ; Values = [Val|VRest])
3070 ; Values = VRest),
3071 lookup_values_if_vars(IRest,LocalStore,Store,VRest).
3072
3073 force_evaluation_of_lazy_value(Id,Value,RealVal) :- nonvar(Value), Value=(Trigger,RealVal),
3074 var(Trigger),
3075 get_preference(use_common_subexpression_elimination,true),
3076 is_lazy_let_identifier(Id),
3077 !,
3078 Trigger=pred_true. % force evaluation, as the exists will otherwise delay/flounder
3079 % Warning: this means that outer lazy_let_expressions inside an exists should be well-defined (WD)
3080
3081
3082 /* will not generate error messages; used for CSP||B when we don't know if something is a B variable or not */
3083 /* TO DO: add peel_prefix for global_sets and constants ?? */
3084 try_lookup_value_in_store_and_global_sets(Id,State,Val) :-
3085 (lookup_value(Id,State,RVal) -> RVal=Val
3086 ; b_global_sets:lookup_global_constant(Id,VGC) -> Val = VGC
3087 ; b_global_set_or_free_type(Id,_AnyType,Value) -> Val=Value /* global set evaluates to itself */
3088 ).
3089
3090
3091 lookup_value_in_store_and_global_sets_wf(Id,Type,LocalState,State,Val,Span,WF) :-
3092 (lookup_value_with_span_wf(Id,LocalState,State,RVal,Span,WF)
3093 -> RVal=Val
3094 ; lookup_value_in_global_sets_wf(Id,Type,Val,LocalState,State,Span,WF)
3095 ).
3096
3097 lookup_value_in_global_sets_wf(Id,Type,Val,LocalState,State,Span,WF) :-
3098 (b_global_sets:lookup_global_constant(Id,VGC)
3099 -> Val=VGC
3100 ? ; (b_global_set_or_free_type(Id,Type,Value)
3101 -> Val = Value /* global set evaluates to itself */
3102 ; ((member(bind(Id,_),LocalState) ; member(bind(Id,_),State))
3103 -> Msg1 = 'Cannot determine value for identifier '
3104 ; Msg1 = 'Cannot find identifier '
3105 ),
3106 append(LocalState,State,LSS),
3107 translate:translate_bstate_limited(LSS,StateInfo),
3108 ajoin([Msg1,Id,':'],Msg),
3109 add_error_wf(identifier_not_found,Msg,StateInfo,Span,WF),
3110 fail % Val = term(Id) /* Val=fail */
3111 )
3112 ).
3113
3114 :- use_module(probsrc(kernel_freetypes),[registered_freetype/2, registered_freetype_case_value/3]).
3115 ?b_global_set_or_free_type(Id,_,global_set(Id)) :- b_global_set(Id).
3116 b_global_set_or_free_type(Id,_,freetype(Id)) :- registered_freetype(Id,_).
3117 b_global_set_or_free_type(Id,Type,Value) :-
3118 registered_freetype_case_value(Id,Type,Value). % to instantiate the type parameters we also need the TypeId
3119 % TODO: we could also register Event-B destructors and look them up here
3120
3121 /* -----------------------------*/
3122 /* b_compute_expressions */
3123 /* -----------------------------*/
3124
3125 b_compute_expressions([], _, _, [],_WF).
3126 b_compute_expressions([EXPRsHd|EXPRsTl],LocalState,InState,[ValHd|ValTl],WF) :-
3127 ? b_compute_expression(EXPRsHd,LocalState,InState,ValHd,WF),
3128 ? b_compute_expressions(EXPRsTl,LocalState,InState,ValTl,WF).
3129
3130 % a variation of above that delays computing the expressions until Waitflag 1/2 is set
3131 b_compute_assign_expressions_when(EXPRsTl,LocalState,InState,ValTl,WF,OR) :-
3132 get_assign_expr_priority_wf(OR,WF,LWF),
3133 ? b_compute_expressions_when2(EXPRsTl,LocalState,InState,ValTl,WF,LWF).
3134 b_compute_expressions_when2([], _, _, [],_WF,_).
3135 b_compute_expressions_when2([EXPRsHd|EXPRsTl],LocalState,InState,[ValHd|ValTl],WF,LWF) :-
3136 ? b_compute_expression_when2(EXPRsHd,LocalState,InState,ValHd,WF,LWF),
3137 b_compute_expressions_when2(EXPRsTl,LocalState,InState,ValTl,WF,LWF).
3138
3139 % TO DO: add step number in OR
3140 get_assign_expr_priority_wf(output_required,_WF,LWF) :- !,
3141 % the Output of the statement is required; do not delay computing it
3142 LWF=0. % this would delay computation until WF0 is set: get_wait_flag0(WF,LWF); cf. initialisation for test 2104
3143 get_assign_expr_priority_wf(_,WF,LWF) :-
3144 % the Output is not directly required; compute it later (when we are sure that the statement actually succeeds)
3145 (preferences:preference(use_smt_mode,true)
3146 -> Prio = 2.0 % SMT Mode: we are probably doing CBC checking, we may have set up constraints on ValTl
3147 ; Prio=4000), % unless the expression is inside an sequential composition: nothing can depend on ValTl; TO DO: check if we are inside a sequential composition; if not use inf priority; otherwise use 2.0 or 4
3148 get_wait_flag(Prio,get_assign_expr_priority_wf,WF,LWF).
3149
3150 :- block b_compute_expression_when2(?,?,?,?,?,-).
3151 b_compute_expression_when2(eval_must_not_fail(ErrMsg,EXPRsHd),LocalState,InState,Res,WF,_) :- !,
3152 % catch failure; in case the interpreter fails to catch wd-error itself (e.g., try_find_abort is false)
3153 if(b_compute_expression(EXPRsHd,LocalState,InState,ValHd,WF),equal_object_wf(ValHd,Res,WF),
3154 (translate:translate_bexpression_with_limit(EXPRsHd,TS),
3155 add_wd_error_span(ErrMsg,TS,span_predicate(EXPRsHd,LocalState,InState),WF))).
3156 b_compute_expression_when2(EXPRsHd,LocalState,InState,ValHd,WF,_) :-
3157 copy_wf_start(WF,b_compute_expression_when2,CWF), % not sure this is useful for expressions:
3158 ? b_compute_expression(EXPRsHd,LocalState,InState,ValHd,CWF),
3159 ? copy_wf_finish(WF,CWF).
3160
3161
3162 /* -----------------------------*/
3163 /* b_execute_statement */
3164 /* -----------------------------*/
3165 /* b_execute_statement(XMLStatements:input, StateofLocalVariables:input,
3166 StateOfGlobalVariables:input,
3167 ListOfUpdateBindingsForGlobalVariablesAndResultVariables:output) */
3168
3169 :- assert_pre(b_interpreter:b_execute_statement(Stmt,LS,IS,_OS,_WF,_Path,_OR),
3170 (bsyntaxtree:check_if_typed_substitution(Stmt),type_check(LS,store),type_check(IS,store) )).
3171 :- assert_post(b_interpreter:b_execute_statement(_Stmt,_LS,_IS,OS,_WF,_Path,_OR),
3172 (type_check(OS,store))).
3173
3174 b_execute_inner_statement(Body,LocalState,InState,OutState,WF,Path,output_required) :-
3175 get_texpr_expr(Body,BE),
3176 BE \= while(_COND,_STMT,_INV,_VARIANT), % also other non-det substitutions ??
3177 BE \= select(_),
3178 BE \= select(_,_),
3179 BE \= if(_), % case(_,_,_) statements are now translated to if-then-else in ast_cleanup
3180 !,
3181 get_wait_flag0(WF,WF0),
3182 block_execute_statement(WF0,Body,LocalState,InState,OutState,WF,Path).
3183 b_execute_inner_statement(Body,LocalState,InState,OutState,WF,Path,OR) :-
3184 get_wait_flag(2,inner_stmt,WF,LWF), % was 2.0
3185 clone_wait_flags_from1(WF,GroundUponFinish,InnerWF), % copy everything but WF0
3186 b_execute_inner_statement(Body,LocalState,InState,OutState,GroundUponFinish,InnerWF,Path,LWF,OR).
3187
3188 :- block block_execute_statement(-, ?,?,?, ?,?,?).
3189 block_execute_statement(_,Body,LocalState,InState,OutState,WF,Path) :-
3190 ? b_execute_statement(Body,LocalState,InState,OutState,WF,Path,output_required).
3191
3192 :- block b_execute_inner_statement(?,?,?,?,?,?,?,-,?).
3193 b_execute_inner_statement(Body,LocalState,InState,OutState,GUF,InnerWF,Path,_,OR) :-
3194 ? b_execute_statement(Body,LocalState,InState,OutState,InnerWF,Path,OR),
3195 (GUF=ground_upon_finish -> ground_wait_flags(InnerWF) ; ground_wait_flag0(InnerWF)).
3196
3197 :- use_module(source_profiler,[opt_add_source_location_hits/2]).
3198 :- use_module(b_operation_guards,[get_substitution_enabling_condition/4]).
3199
3200
3201 b_execute_statement_nowf(Subst,LS,S,OutS,Ctxt) :-
3202 init_wait_flags_with_call_stack(WF,[prob_command_context(Ctxt,unknown)]),
3203 b_interpreter:b_execute_statement(Subst,LS,S,OutS,WF,_Path),
3204 ground_wait_flags(WF).
3205
3206 b_execute_statement(Stmt, LS, S, OS, WF,Path) :-
3207 ? b_execute_statement(Stmt, LS, S, OS, WF,Path,output_not_required).
3208 b_execute_statement(b(Stmt,_,Infos), LS, S, OS, WF,Path,OR) :- !,
3209 ? b_execute_statement2(Stmt, Infos, LS, S, OS, WF,Path,OR).
3210 b_execute_statement(Stmt, LS, S, OS, WF,Path,OR) :-
3211 add_internal_error('Statement not properly wrapped: ',b_execute_statement(Stmt, LS, S, OS, WF,Path,OR)),
3212 b_execute_statement2(Stmt, [], LS, S, OS, WF,Path,OR).
3213
3214 % blocks should be removed by type-checker
3215 b_execute_statement2(block(Stmt),_,LS,IS,OS,WF,Path,OR) :- !,
3216 b_execute_statement(Stmt,LS,IS,OS,WF,Path,OR). %% NOT COVERED
3217 b_execute_statement2(assign(LHS,Exprs),Info,LocalState,InState,OutState,WF,assign,OR) :- !,
3218 /* Var1, ..., VarN := Expr1, ..., ExprN */
3219 /* also: Var1, fun1(arg), ... := Expr1, Expr2, ... */
3220 opt_add_source_location_hits(Info,1),
3221 ? b_compute_assign_expressions_when(Exprs,LocalState,InState,VALs,WF,OR),% VALs - a list of computed values
3222 ? b_assign_values_or_functions(LHS,VALs,LocalState,InState,OutState,WF,OR).
3223 b_execute_statement2(assign_single_id(IDE,Expr),Info,LocalState,InState,OutState,WF,assign,_OR) :-
3224 get_texpr_id(IDE,ID),!,
3225 opt_add_source_location_hits(Info,1),
3226 ? b_compute_expression(Expr,LocalState,InState,Value,WF), % b_compute_assign_expressions_when
3227 %b_compute_assign_expressions_when([Expr],LocalState,InState,[Value],WF),
3228 OutState=[bind(ID,Value)].
3229 b_execute_statement2(choice(ChoiceList),_,LocalState,InState,OutState,WF,Path,OR) :- !,
3230 /* CHOICE LHS OR RHS OR ... END */
3231 get_wait_flag(2,choice,WF,WFC), % % was 2.0, maybe use length of ChoiceList as Priority ??
3232 b_execute_choice(ChoiceList,LocalState,InState,OutState,WF,Path,WFC,OR).
3233 b_execute_statement2(becomes_element_of(LHS,RHS), /* LHS :: RHS */
3234 Info,LocalState,InState,OutState,WF,becomes_element_of,_OR) :- !,
3235 % LHS must be of the form Var1,..,Vark where all variables are disjoint
3236 opt_add_source_location_hits(Info,1),
3237 b_compute_expression(RHS,LocalState,InState,ValueSet,WF),
3238 check_element_of_wf(SingleValue,ValueSet,WF),
3239 ground_det_wait_flag(WF), %% TODO: remove this
3240 convert_pairs_into_list(LHS,SingleValue,ValList),
3241 set_up_typed_localstate(LHS,ValList,TypedVals,[],OutState,positive),
3242 b_tighter_enumerate_all_values(TypedVals,WF).
3243 b_execute_statement2(becomes_such(Vars,Condition), /* Vars : Condition */
3244 Info,LocalState,InState,OutState,WF,becomes_such,_OR) :- !,
3245 opt_add_source_location_hits(Info,1),
3246 ? b_execute_becomes_such(Vars,Condition,LocalState,InState,OutState,_,WF).
3247 b_execute_statement2(sequence(Seq), /* LHS ; RHS */
3248 _,LocalState,InState,OutUpdates,WF,Path,OR) :- !, %pe_print(sequence(Seq,InState)),
3249 ? b_execute_sequence(Seq,LocalState,InState,OutUpdates,WF,Path,OR).
3250 b_execute_statement2(precondition(PreCond,Body),_,LocalState,InState,OutState,WF,Path,OR) :- !,
3251 %print('*** Non-outermost PRE construct'),nl,
3252 Path=pre(PreRes,IPath),
3253 b_try_check_boolean_expression(PreCond,LocalState,InState,WF,PreRes),
3254 %used to be: ground_det_wait_flag(WF),
3255 check_precondition_result(PreRes,PreCond,LocalState,InState,WF),
3256 ? (PreRes == pred_true -> b_execute_statement(Body,LocalState,InState,OutState,WF,IPath,OR)
3257 ; PreRes == pred_false -> IPath = not_executed
3258 ; b_execute_inner_statement(Body,LocalState,InState,OutState,WF,IPath,OR) % with extra waitflag
3259 ).
3260 b_execute_statement2(assertion(PreCond,Body),_,LocalState,InState,OutState,WF,Path,OR) :- !,
3261 ? b_execute_assertion(PreCond,Body,LocalState,InState,OutState,WF,Path,OR).
3262 b_execute_statement2(witness_then(PreCond,Body),_,LocalState,InState,OutState,WF,Path,OR) :- !,
3263 b_test_boolean_expression(PreCond,LocalState,InState,WF),
3264 b_execute_inner_statement(Body,LocalState,InState,OutState,WF,Path,OR).
3265 b_execute_statement2(select(Whens),_, LocalState, InState, OutState,WF,select(Nr,Path),OR) :- !,
3266 get_texpr_expr(TExpr,select_when(PreCond, Body)), % info field not used for select_when
3267 ? optimized_nth1(Nr, Whens, TExpr), % THIS IS A CHOICE POINT if length(Whens)>1 ! <-------- TO DO guard
3268 ? b_test_boolean_expression(PreCond,LocalState,InState,WF),
3269 %used to call: ground_det_wait_flag(WF), now execute inner statement delays
3270 b_execute_inner_statement(Body,LocalState,InState,OutState,WF,Path,OR).
3271 b_execute_statement2(select(Whens,Else), Infos, LocalState, InState, OutState,WF,Path,OR) :- !,
3272 (
3273 ? b_execute_statement2(select(Whens), Infos, LocalState, InState, OutState,WF,Path,OR)
3274 ; % THIS IS A CHOICE POINT ! <-------- TO DO guard
3275 findall(PC,
3276 (member(SW,Whens),get_texpr_expr(SW,select_when(PC,_))), AllPreconds),
3277 b_not_test_list_of_boolean_expression(AllPreconds,LocalState,InState,WF),
3278 Path = select(else,IPath),
3279 b_execute_inner_statement(Else,LocalState,InState,OutState,WF,IPath,OR)
3280 ).
3281 b_execute_statement2(var(Parameters,Body), /* VAR _ IN _ substitution */
3282 _,LocalState,InState,NewOutState,WF,var(Path),OR) :- !,
3283 /* introduces a new variable that can be assigned to */
3284 split_names_and_types(Parameters,Names,_),
3285 delete_variables_from_state(Names,InState,InState1), % in case any local parameter name is also a constant/variable: remove it % but if we do an operation_call: we leave context and it becomes visible again !!
3286 % otherwise we may think there are two updates, e.g., in WHILE loop; see Rule_DB_SIGAREA_0030 from test 1303
3287 set_up_undefined_localstate(Parameters,InState1,NewInState),
3288 delete_variables_from_state(Names,LocalState,NewLocalState),
3289 %check_valid_store(InState,var_in_state), check_valid_store(LocalState,var_local_state),
3290 ? b_execute_statement(Body,NewLocalState,NewInState,OutState,WF,Path,OR),
3291 % check_valid_store(OutState,var_out_state),
3292 filter_results(Parameters,OutState,NewOutState,WF)
3293 .
3294 /* it can be ok not to assign to a local variable */
3295
3296 %TODO(DP, 5.8.2008):
3297 b_execute_statement2(let(Parameters,Defs,Body), /* LET _ BE _ IN _ */
3298 _,LocalState,InState,OutState,WF,let(Path),OR) :- !,
3299 ? set_up_typed_localstate(Parameters,LocalState,NewLocalState),
3300 b_execute_let_definitions(Defs,NewLocalState,InState,WF),
3301 ? b_execute_statement(Body,NewLocalState,InState,OutState,WF,Path,OR).
3302 b_execute_statement2(lazy_let_subst(Id,IdExpr,Body),_,LocalState,InState,OutState,WF,lazy_let(Path),OR) :-
3303 !,
3304 add_lazy_let_id_and_expression(Id,IdExpr,LocalState,InState,NewLocalState,WF),
3305 b_execute_statement(Body,NewLocalState,InState,OutState,WF,Path,OR).
3306 b_execute_statement2(any(Parameters,PreCond,Body), /* ANY _ WHERE */
3307 Info,LocalState,InState,OutState,WF0,any(Bindings,Path),OR) :- !, %statistics(runtime,_),
3308 %print('ANY: '), print_bexpr(PreCond),nl, %%
3309 ? set_up_typed_localstate(Parameters,FreshVars,TypedVals,LocalState,NewLocalState,positive),
3310 create_any_bindings(Parameters,FreshVars,Bindings),
3311 push_wait_flag_call_stack_info(WF0,quantifier_call('ANY',Parameters,FreshVars,Info),WF),
3312 ? b_test_inner_boolean_expression(PreCond,NewLocalState,InState,WF), /* check WHERE */
3313 %%observe_state(TypedVals,WF,0), b_tracetest_boolean_expression(PreCond,NewLocalState,InState,WF,one), %% comment in for debugging
3314 b_tighter_enumerate_all_values(TypedVals,WF), % moved enumeration after test; in case WF already instantiated
3315 %TODO: check if we can use b_tighter_enumerate_values_in_ctxt
3316 ? b_execute_statement(Body,NewLocalState,InState,OutState,WF,Path,OR). /* should we use b_execute_inner_statement/LWF here ?? */
3317 b_execute_statement2(skip, /* SKIP */
3318 Info,_LocalState,_InState,OutState,_WF,skip,_OR) :- !,
3319 opt_add_source_location_hits(Info,1),
3320 OutState = [].
3321 b_execute_statement2(parallel(Statements), /* LHS || RHS */ %@@@
3322 _,LocalState,InState,OutState,WF,parallel(Paths),OR) :- !,
3323 ? b_execute_statements_in_parallel(Statements,LocalState,InState,OutState,WF,Paths,OR).
3324 b_execute_statement2(init_statement(Stmt),_,LocalState,InState,OutState,WF,Path,OR) :- !,
3325 /* Like block: but
3326 writes error messages if statement fails */ %@@@
3327 (preferences:get_preference(provide_trace_information,true)
3328 -> nl,print(' =INIT=> '),translate:print_subst(Stmt),nl, flush_output(user_output),
3329 statistics(walltime,[Tot1,_])
3330 ; true),
3331 ? if(b_execute_initialisation_statement(Stmt,LocalState,InState,OutState,WF,Path,OR),
3332 (
3333 (preferences:get_preference(provide_trace_information,true)
3334 -> statistics(walltime,[Tot2,_]), Tot is Tot2-Tot1,
3335 format(' [=OK= ~w ms]~n',[Tot]), flush_output(user_output)
3336 ; true)
3337 ),
3338 ( translate:translate_substitution(Stmt,TStmtStr),
3339 (bmachine:b_machine_temp_predicate(_TempPred)
3340 -> Msg = 'INITIALISATION statement cannot be executed with extra predicate: ',
3341 add_error_wf(initialisation_fails,Msg,TStmtStr,Stmt,WF)
3342 % do not add as state error; user requested transition
3343 ; Msg = 'INITIALISATION statement fails: ',
3344 (get_substitution_enabling_condition(Stmt,SpanPred,_BSVars,_IsPreciseV)
3345 -> %insert_custom_predicate_into_guard(EnablingCondition,TempPred,SpanPred),
3346 ErrPos = span_predicate(SpanPred,LocalState,InState) % for visualising by user
3347 % Note: user can also visualise by chooise execute by predicate (in TK)
3348 ; ErrPos = Stmt
3349 ),
3350 % add as state error so that we can visualise span predicate
3351 add_state_error_wf(initialisation_fails,Msg,TStmtStr,ErrPos,WF) % cf test 1736 and 278
3352 %add_error_wf(initialisation_fails,Msg,TStmtStr,ErrPos,WF)
3353 ),
3354 fail
3355 )
3356 ).
3357 b_execute_statement2(if(IfList),_,LocalState,InState,OutState,WF,if,OR) :- !,
3358 %LWF=1,
3359 LWF='$GENERATE_ON_DEMAND', %
3360 ? b_execute_else_list(IfList,LocalState,InState,OutState,WF,LWF,OR).
3361 b_execute_statement2(operation_call(Operation,Results,Parameters),Info,LocalState,InState,OutState,WF,
3362 operation_call(OperationName,ParamValues,ResultValues,InnerPath),OR) :- !,
3363 def_get_texpr_id(Operation,op(OperationName)),
3364 ? b_execute_operation_with_parameters(OperationName,LocalState,InState,Results,
3365 Parameters,OpOutState,ParamValues,ResultValues,InnerPath,Info,WF,OR),
3366 split_names_and_types(Results,ResultingIDs,_),
3367 store_values(ResultingIDs, ResultValues, ResultsOutState),
3368 combine_updates(ResultsOutState,OpOutState,OutState).
3369
3370 b_execute_statement2(while(COND,STMT,INV,VARIANT),
3371 Info,LocalState,InState,OutState,WF0,while,_OR) :- !,
3372 %hit_profiler:add_profile_hit(while(COND,WF),2),
3373 % we may go around the loop many times: avoid carrying around unused variables
3374 get_while_reads_write_info_and_filter_state(Info,LocalState,InState,LS,IS,ModVars),
3375 push_wait_flag_call_stack_info(WF0,b_operator_call('WHILE',[],Info),WF), % TODO: provide subst. call stack entry
3376 %print_message(execute_while(LocalState,InState)),
3377 b_compiler:b_optimize(INV,ModVars,LS,IS,CINV,WF),
3378 b_compiler:b_optimize(COND,ModVars,LS,IS,CCOND,WF),
3379 b_compiler:b_optimize(VARIANT,ModVars,LS,IS,CVARIANT,WF),
3380 %,b_compiler:b_compile(STMT,ModVars,LS,IS,CSTMT,WF)
3381 % TO DO: maybe exclude in one go; use ordered approach ?
3382 %exclude(unused_variable(ModVars),LS,LS2), % only keep modified vars; all other compiled
3383 %exclude(unused_variable(ModVars),IS,IS2), % only keep modified vars; all other compiled
3384 b_compute_expression(CVARIANT,LS,IS,VarVal,WF),
3385 b_execute_while(CCOND,STMT,CINV,CVARIANT,ModVars,VarVal,LS,IS,OutState,WF).
3386 b_execute_statement2(external_subst_call(FunName,Args),Info,LocalState,State,OutState,WF,external(FunName),_OR) :-
3387 !, b_compute_expressions(Args, LocalState,State, EvaluatedArgs, WF),
3388 push_wait_flag_call_stack_info(WF,external_call(FunName,EvaluatedArgs,Info),WF2),
3389 call_external_substitution(FunName,EvaluatedArgs,State,OutState,Info,WF2).
3390 b_execute_statement2(E,I,LS,S,O,WF,Path,OR) :-
3391 add_internal_error('Uncovered statement: ',b_execute_statement2(E,I,LS,S,O,WF,Path,OR)),
3392 print_functor(E),nl,fail.
3393
3394 % -------------------
3395
3396 b_execute_becomes_such(Vars,Condition,LocalState,InState,OutState,Values,WF) :- !,
3397 % create the LHS variables in the local state
3398 ? set_up_typed_localstate(Vars,Values,TypedVals,LocalState,TempLocalState1,positive),
3399 get_texpr_ids(Vars,Ids),
3400 % store those values also the outgoing state
3401 store_values(Ids,Values,OutState),
3402 % there might be some variables of the form x$0 to access the
3403 % values before the substitution. We put them into the local state
3404 insert_before_substitution_variables(Vars,LocalState,InState,TempLocalState1,TempLocalState),
3405 ? b_test_inner_boolean_expression(Condition,TempLocalState,InState,WF),
3406 b_tighter_enumerate_values_in_ctxt(TypedVals,Condition,WF). % moved enumeration after test, to avoid overhead in case Condition is deterministic (see e.g. WhileAssignTupleChoose_v2)
3407
3408
3409 b_execute_sequence([],_LocalState,_InState,[],_WF,[],_OR).
3410 b_execute_sequence([First|Rest],LocalState,InState,OutUpdates,WF,Path,OR) :-
3411 (Rest == []
3412 ? -> b_execute_statement(First,LocalState,InState,OutUpdates,WF,Path,OR)
3413 ; Path = sequence(Path1,RestPath),
3414 ? b_execute_statement(First,LocalState,InState,LHSUpdates,WF,Path1,output_required),
3415 ? ground_det_wait_flag(WF), % maybe better to delay next execute_statement ? TODO
3416 store_intermediate_updates_wf(InState,LHSUpdates,IntermediateState,First,WF),
3417 % TO DO: statically determine what the Rest can modify and copy over LHSUpdates not modified by Rest into OutUpdates
3418 ? b_execute_statement_list_when_state_set(Rest,LocalState,IntermediateState,
3419 LHSUpdates,OutUpdates,WF,RestPath,OR)
3420 ).
3421
3422
3423 :- block check_precondition_result(-,?,?,?,?).
3424 check_precondition_result(pred_true,_,_,_,_).
3425 check_precondition_result(pred_false,PreCond,LS,S,WF) :-
3426 translate_bexpression(PreCond,PreString),
3427 add_abort_error_span(precondition_error,'Precondition violated: ',PreString,span_predicate(PreCond,LS,S),WF).
3428
3429 create_any_bindings([],[],[]).
3430 create_any_bindings([Param|Prest],[Value|Vrest],[bind(Id,Value)|Brest]) :-
3431 get_texpr_id(Param,Id),
3432 create_any_bindings(Prest,Vrest,Brest).
3433
3434 % insert the values of variables before the substitution under an
3435 % alternative name. The alternative name is given as an optional extra
3436 % information in the variable (see type-checking of becomes_such for
3437 % details). Usually (i.e. always) the alternative name is x$0 for the variable x.
3438 insert_before_substitution_variables([],_LocalState,_InState,State,State).
3439 insert_before_substitution_variables([Var|VRest],LocalState,InState,StateA,ResultStateB) :-
3440 get_texpr_info(Var,Infos),
3441 ? ( member(before_substitution(_,Alternative),Infos) ->
3442 def_get_texpr_id(Var,Id),
3443 lookup_value_for_existing_id(Id,LocalState,InState,Value),
3444 store_value(Alternative,Value,StateA,StateC)
3445 ;
3446 StateA = StateC),
3447 insert_before_substitution_variables(VRest,LocalState,InState,StateC,ResultStateB).
3448
3449
3450
3451 % treat the bool(.) operator
3452 b_convert_bool(Pred,LocalState,State,WF,PredRes) :-
3453 get_wait_flag0(WF,WF0), % first give a chance for PredRes to be instantiated
3454 b_convert_bool_wf0(Pred,LocalState,State,WF,PredRes,WF0).
3455
3456 :- block b_convert_bool_wf0(?,?,?,?,-,-).
3457 b_convert_bool_wf0(Pred,LocalState,State,WF,PredRes,_) :- PredRes==pred_true,!,
3458 %% print('bool(.)=TRUE '), translate:print_bexpr(Pred),nl, %%
3459 b_test_inner_boolean_expression(Pred,LocalState,State,WF).
3460 b_convert_bool_wf0(Pred,LocalState,State,WF,PredRes,_) :- PredRes==pred_false,!,
3461 %% print('bool(.)=FALSE '), translate:print_bexpr(Pred),nl, %%
3462 b_not_test_inner_boolean_expression(Pred,LocalState,State,WF).
3463 b_convert_bool_wf0(Pred,LocalState,State,WF,PredRes,_) :-
3464 %% print('bool(.) check : '), translate:print_bexpr(Pred),nl, % obsv(LocalState),
3465 ? b_try_check_boolean_expression_wf(Pred,LocalState,State,WF,PredRes ).
3466 %% print('finished bool(.) check : '), translate:print_bexpr(Pred),nl,translate:print_bstate(LocalState),nl.
3467
3468 % Additional time limit +TO in ms, e.g., used for CDCL(T). +TORes is time_out if a timeout occurred.
3469 b_convert_bool_timeout(Pred,LocalState,State,WF,PredRes,TO,TORes) :-
3470 get_wait_flag0(WF,WF0),
3471 b_convert_bool_wf0_timeout(Pred,LocalState,State,WF,PredRes,WF0,TO,TORes).
3472
3473 :- block b_convert_bool_wf0_timeout(?,?,?,?,-,-,?,?).
3474 b_convert_bool_wf0_timeout(Pred,LocalState,State,WF,PredRes,_,TO,TORes) :-
3475 PredRes == pred_true,
3476 !,
3477 safe_time_out(b_test_inner_boolean_expression(Pred,LocalState,State,WF),
3478 TO,
3479 TORes).
3480 b_convert_bool_wf0_timeout(Pred,LocalState,State,WF,PredRes,_,TO,TORes) :-
3481 PredRes == pred_false,
3482 !,
3483 safe_time_out(b_not_test_inner_boolean_expression(Pred,LocalState,State,WF),
3484 TO,
3485 TORes).
3486 b_convert_bool_wf0_timeout(Pred,LocalState,State,WF,PredRes,_,TO,TORes) :-
3487 safe_time_out(b_try_check_boolean_expression_wf(Pred,LocalState,State,WF,PredRes ),
3488 TO,
3489 TORes).
3490
3491 %%obsv([]).
3492 %%obsv([bind(Var,Val) | T] ) :- when(ground(Val), format("~w = ~w~n",[Var,Val])), obsv(T).
3493
3494 % check boolean expression without enumeration predicate result (unless WFE is set)
3495 b_try_check_boolean_expression_no_enum_wf(Pred,LocalState,State,WF,PredRes) :-
3496 b_try_check_boolean_expression_lwf(Pred,LocalState,State,WF,'$NO_ENUMERATION',PredRes,_).
3497
3498 b_try_check_boolean_expression_wf(Pred,LocalState,State,WF,PredRes) :-
3499 ? b_try_check_boolean_expression_lwf(Pred,LocalState,State,WF,'$ENUMERATION',PredRes,'$GENERATE_ON_DEMAND' ).
3500 % try to do check_boolean expression; if not possible create choice point if LWF is grounded
3501 b_try_check_boolean_expression_lwf(Pred,LocalState,InState,WF,DoEnumeration,PredRes,LWF) :-
3502 ? b_compiler:b_optimize(Pred,[],LocalState,InState,CPRED,WF), % this increases chance that check can be applied+avoids multiple computations in two branches
3503 % still: some computations may not be pre-computed, e.g., union of closures, ..., see Rule_DB_PSR_0003_C
3504 ? b_try_check_boolean_expression_lwf_c(CPRED,LocalState,InState,WF,DoEnumeration,PredRes,LWF).
3505
3506 b_try_check_boolean_expression_lwf_c(b(truth,_,_),_LocalState,_InState,_WF,_,PredRes,_LWF) :- !,
3507 % typical case in e.g. IF-THEN-ELSE
3508 PredRes= pred_true.
3509 b_try_check_boolean_expression_lwf_c(Pred,LocalState,InState,WF,DoEnumeration,PredRes,LWF) :-
3510 copy_wf_start(WF,try_check,CWF),
3511 ? if(b_check_boolean_expression_with_enum(Pred,LocalState,InState,CWF,DoEnumeration,Res),
3512 % Note: we do not use a cut here ! usually b_check will not enumerate; but on rare occasions it can (apply function in inverse,...)
3513 (PredRes=Res,
3514 ? copy_wf_finish(WF,CWF)
3515 ),
3516 b_try_check_failed(Pred,LocalState,InState,WF,DoEnumeration,PredRes,LWF)
3517 ).
3518 b_try_check_failed(Pred,LocalState,InState,WF,DoEnumeration,PredRes,LWF) :-
3519 % print(choice_point(LWF)),nl, translate:print_bexpr(Pred),nl,
3520 perfmessagecall(choice_point,reification_of_check_predicate_failed,translate:print_bexpr(Pred),Pred),
3521 (LWF=='$GENERATE_ON_DEMAND' -> get_binary_choice_wait_flag('$GENERATE_ON_DEMAND',WF,WF1)
3522 ; var(LWF),DoEnumeration=='$NO_ENUMERATION' -> get_enumeration_finished_wait_flag(WF,WF1) % nothing will enum LWF
3523 ; WF1=LWF),
3524 b_try_check_boolean_expression_lwf_block(Pred,LocalState,InState,WF,PredRes,WF1).
3525
3526 % a version of b_check_boolean_expression which will enumerate its result as last resort
3527 % should we only do this in SMT mode : preferences:preference(use_smt_mode,true) ?
3528 b_check_boolean_expression_with_enum(Pred,LocalState,State,WF,DoEnumeration,Res) :-
3529 ? b_check_boolean_expression(Pred,LocalState,State,WF,Res),
3530 (nonvar(Res) -> true
3531 ; DoEnumeration=='$NO_ENUMERATION' -> get_enumeration_finished_wait_flag(WF,EWF), enum_pred_result(Res,EWF,WF)
3532 ; get_wait_flag0(WF,LWF0),
3533 enum_pred_result0(Res,LWF0,WF)).
3534
3535 % first set up with wait_flag0: easy to get, avoid putting unnecessary waitflags into store
3536 % relevant for DataValidationTest.mch with n>20000
3537 :- block enum_pred_result0(-,-,?).
3538 enum_pred_result0(Res,_,WF) :- var(Res),!,
3539 get_last_wait_flag(b_check_boolean_expression_with_enum,WF,LWF),
3540 enum_pred_result(Res,LWF,WF). % before doing infinite enumerations: better do case-distinction here
3541 enum_pred_result0(_,_,_).
3542
3543 :- block enum_pred_result(-,-,?).
3544 enum_pred_result(pred_true,_,_).
3545 enum_pred_result(pred_false,_,_).
3546
3547 :- block b_try_check_boolean_expression_lwf_block(?,?,?, ?,-,-).
3548 b_try_check_boolean_expression_lwf_block(Pred,LocalState,InState,WF,PREDRES,_) :-
3549 PREDRES \== pred_false,
3550 % print(' TRUE +++++> '), translate:print_bexpr(Pred),nl,
3551 ? b_test_inner_boolean_expression(Pred,LocalState,InState,WF),
3552 PREDRES = pred_true. % set it only after we have actually checked the predicate; e.g., for IF we may execute rest of while loop etc... before actually having set up the constraint Pred; See Hansen23_WhilePerformance
3553 b_try_check_boolean_expression_lwf_block(Pred,LocalState,InState,WF,PREDRES,_) :-
3554 PREDRES \== pred_true,
3555 % print(' FALSE +++++> '), translate:print_bexpr(Pred),nl,
3556 b_not_test_inner_boolean_expression(Pred,LocalState,InState,WF),
3557 PREDRES = pred_false.
3558
3559 % try to do check_boolean expression; if not possible create choice point *directly*
3560 b_try_check_boolean_expression(Pred,LocalState,InState,WF,PredRes) :-
3561 b_compiler:b_optimize(Pred,[],LocalState,InState,CPRED,WF), % this increases chance that check can be applied+avoids multiple computations in two branches
3562 b_try_check_boolean_expression_c(CPRED,LocalState,InState,WF,PredRes).
3563 b_try_check_boolean_expression_c(Pred,LocalState,InState,WF,PredRes) :-
3564 copy_wf_start(WF,try_check_c,CWF),
3565 if(b_check_boolean_expression(Pred,LocalState,InState,CWF,Res),
3566 (PredRes=Res,copy_wf_finish(WF,CWF)),
3567 ? b_try_check_boolean_expression_c2(Pred,LocalState,InState,WF,PredRes)
3568 ).
3569 b_try_check_boolean_expression_c2(Pred,LocalState,InState,WF,pred_true) :-
3570 %hit_profiler:add_profile_hit(b_try_check_failed(Pred),3),
3571 b_test_inner_boolean_expression(Pred,LocalState,InState,WF).
3572 b_try_check_boolean_expression_c2(Pred,LocalState,InState,WF,pred_false) :-
3573 b_not_test_inner_boolean_expression(Pred,LocalState,InState,WF).
3574
3575
3576 % WHILE SUBSTITUTION TREATMENT:
3577
3578 :- if(environ(prob_noopt_mode,true)).
3579 get_while_reads_write_info_and_filter_state(Info,LocalState,InState,LS,IS,ModVars) :-
3580 member(modifies(ModVars),Info),!,
3581 LS=LocalState, IS=InState. % do not filter state
3582 :- endif.
3583 get_while_reads_write_info_and_filter_state(Info,LocalState,InState,LS,IS,ModVars) :-
3584 member(reads(ReadVars),Info),
3585 ? member(modifies(ModVars),Info),!,
3586 % we may go around the loop many times: avoid carrying around unused variables
3587 ord_union(ReadVars,ModVars,ReadOrModVars),
3588 filter_states(ReadOrModVars,LocalState,InState,LS,IS).
3589 get_while_reads_write_info_and_filter_state(Info,LocalState,InState,LS,IS,ModVars) :-
3590 add_internal_error('No reads & modifies info for while loop: ',get_while_reads_write_info_and_filter_state(Info,LocalState,InState,LS,IS,ModVars)),
3591 ModVars=_, % all variables assumed to be modified
3592 LS=LocalState, IS=InState.
3593
3594 unused_variable(List,bind(Var,_)) :-
3595 % b_is_variable(Var), % TO DO: also include constants in reads Info ?
3596 ord_nonmember(Var,List).
3597 unused_localvariable(List,bind(Var,Val)) :- ord_nonmember(Var,List),
3598 (nonvar(Val),Val=(_,_) -> atom_codes(Var,Codes), Codes \= [64|_] % not a lazy_let ID starting with @
3599 % TO DO: either ensure lazy-let ids are also included in reads/writes ! or mark Val not as pair but using a special functor in add_lazy_let_id_to_local_state ?
3600 ; true).
3601
3602 filter_states(ReadOrModVars,LocalState,InState,LS,IS) :-
3603 exclude(unused_localvariable(ReadOrModVars),LocalState,LS),
3604 exclude(unused_variable(ReadOrModVars),InState,IS).
3605 % TO DO: investigate whether we should use ord_intersect; ReadVars is already sorted
3606
3607 :- block lazy_exclude(-,?,?).
3608 lazy_exclude([],_,[]).
3609 lazy_exclude([bind(Var,Val)|T],ModVars,Res) :- lazy_exclude_aux(Var,Val,T,ModVars,Res).
3610 :- block lazy_exclude_aux(-,?,?,?,?).
3611 lazy_exclude_aux(Var,Val,T,ModVars,Res) :-
3612 ? (member(Var,ModVars) -> Res = [bind(Var,Val)|RT]
3613 ; Res = RT),
3614 lazy_exclude(T,ModVars,RT).
3615
3616
3617 :- use_module(kernel_tools,[ground_state_check/2]).
3618 % outermost while code:; at next iteration b_execute_while1 will be called.
3619 :- block b_execute_while(?,?,?,?,?,-, ?,?,?, ?). % we block on Variant Value int(VarVal)
3620 b_execute_while(COND,STMT,INV,VARIANT,ModVars,int(VarVal),LocalState,InState,OutState,WF) :-
3621 %kernel_waitflags:get_idle_wait_flag(b_execute_while,WF,LWF),
3622 (number(VarVal),VarVal =< 50
3623 -> LWF=VarVal % we will wait anyway on GrInState below; no danger for WD issues in in b_optimize
3624 ; no_pending_waitflags(WF) -> get_wait_flag0(WF,LWF) %important for e.g. PerformanceTests/While/LiftExec_LIM.mch
3625 ; kernel_waitflags:get_last_wait_flag(b_execute_while1,WF,LWF) % to do: maybe get largest waitflag to avoid as much as possible that new choice points get enumerated before while triggers?
3626 % see also tests 979, 981
3627 ),
3628 % before entering while loop, we wait for co-routines to complete that may have activated b_execute_while
3629 b_execute_while_idle(COND,STMT,INV,VARIANT,ModVars,int(VarVal),LocalState,InState,OutState,WF,LWF).
3630
3631 :- block b_execute_while_idle(?,?,?,?,?,?, ?,?,?, ?,-). % we block on enumeration starting wait_flag
3632 b_execute_while_idle(COND,STMT,INV,VARIANT,ModVars,int(VarVal),LocalState,InState,OutState,WF,_) :-
3633 %ground_constraintprop_wait_flags(WF),
3634 (number(VarVal), VarVal>50, preference(compile_while_body,true)
3635 % if VarVal > 50 -> worthwhile to compile STMT
3636 % TO DO: also take size of body into account, and what if only a small part of the body is reachable in each iteration
3637 ? -> b_compiler:b_optimize(STMT,ModVars,LocalState,InState,CSTMT,WF),
3638 % print(compiled_while(ModVars)),nl, translate:print_subst(CSTMT),nl,
3639 OutState=WhileOutState,
3640 exclude(unused_variable(ModVars),LocalState,LS), % only keep modified vars; all other compiled
3641 exclude(unused_variable(ModVars),InState,IS) % only keep modified vars; all other compiled
3642 ; CSTMT=STMT, LS=LocalState, IS=InState,
3643 lazy_exclude(WhileOutState,ModVars,OutState) % only copy over those variables (potentially) modified by While loop
3644 % Note: it is important that we only have one copy of each modified variable in OutState
3645 ),
3646 ground_state_check(InState,GrInState),
3647 ? b_execute_while_loop_block(GrInState,COND,CSTMT,INV,VARIANT,none,VarVal,LS,IS,WhileOutState,WF).
3648
3649 :- block b_execute_while_loop_block(-,?,?,?,?,?,?,?,?,?,?).
3650 b_execute_while_loop_block(_,COND,CSTMT,INV,VARIANT,none,VarVal,LS,IS,WhileOutState,WF) :-
3651 ? b_execute_while_loop(COND,CSTMT,INV,VARIANT,none,VarVal,LS,IS,WhileOutState,WF).
3652
3653 :- block b_execute_while1(?,?,?,?,?,-,?,?,?,?).
3654 b_execute_while1(COND,STMT,INV,VARIANT,PrevVariantValue,int(VarVal),LocalState,InState,OutState,WF) :-
3655 % get_last_wait_flag(while(VarVal),WF,LWF),
3656 deref_wf(WF,FreshWF),
3657 %ground_constraintprop_wait_flags(FreshWF), % this is not a good idea, co-routine may be triggered while grounding WF; this subsidiary call will prevent grounding from completing and may trigger later waitflags before earlier ones are finished
3658 % this can lead to enumeration warnings; the same applies to other calls to ground_constraintprop_wait_flags below
3659 b_execute_while_loop(COND,STMT,INV,VARIANT,PrevVariantValue,VarVal,LocalState,InState,OutState,FreshWF).
3660
3661 % block on PrevVarVal and VarVal not yet needed here; but we need it for b_execute_while_body below
3662 :- block b_execute_while_loop(?,?,?,?,-,?,?,?,?,?), b_execute_while_loop(?,?,?,?,?,-,?,?,?,?).
3663 b_execute_while_loop(COND,STMT,INV,VARIANT,PrevVarVal,VarVal,LocalState,InState,OutState,WF) :-
3664 ? b_try_check_boolean_expression_c(INV,LocalState,InState,WF,INVRes),
3665 %ground_constraintprop_wait_flags(WF), % seems to slow down interpretation
3666 ? b_check_execute_while_loop1(INVRes,COND,STMT,INV,VARIANT,PrevVarVal,VarVal,LocalState,InState,OutState,WF).
3667
3668 :- block b_check_execute_while_loop1(-,?,?,?,?,?,?,?,?,?,?).
3669 b_check_execute_while_loop1(pred_false,_COND,_STMT,INV,_VAR,_PrevVarVal,VarVal,LocalState,InState,_OutState,WF) :-
3670 add_abort_error_span(while_invariant_violation,
3671 'While INVARIANT VIOLATED, current VARIANT value: ',VarVal,span_predicate(INV,LocalState,InState),WF).
3672 b_check_execute_while_loop1(pred_true,COND,STMT,INV,VARIANT,PrevVarVal,VarVal,LocalState,InState,OutState,WF) :-
3673 b_try_check_boolean_expression_c(COND,LocalState,InState,WF,CondRes),
3674 %ground_constraintprop_wait_flags(WF), % seems to slow down interpretation
3675 ? b_check_execute_while_loop2(CondRes,COND,STMT,INV,VARIANT,PrevVarVal,VarVal,LocalState,InState,OutState,WF).
3676
3677 :- block b_check_execute_while_loop2(-,?,?,?,?,?,?,?,?,?,?).
3678 b_check_execute_while_loop2(pred_false,_COND,_STMT,_INV,_VARIANT,_PrevVarVal,_VarVal,_LS,InState,OutState,_WF) :-
3679 OutState=InState. % we copy over the while InState: the updates will be computed at the end of the while loop
3680 b_check_execute_while_loop2(pred_true,COND,STMT,INV,VARIANT,PrevVarVal,VarVal,LocalState,InState,OutState,WF) :-
3681
3682 %hit_profiler:add_profile_hit(b_execute_while_body(STMT,VarVal,PrevVarVal,LocalState),2),
3683 % TO DO: maybe only compute VARIANT now and not above ??
3684 % b_compute_expression(VARIANT,LocalState,InState,VarVal,WF),
3685 % ground_constraintprop_wait_flags(WF), %% moved here because VARIANT computed later
3686 ? b_execute_while_body(COND,STMT,INV,VARIANT,PrevVarVal,VarVal,LocalState,InState,OutState,WF).
3687
3688 %:- block b_execute_while_body(?,?,?,?,-,?,?,?,?,?), b_execute_while_body(?,?,?,?,?,-,?,?,?,?).
3689 % we must ensure VarVal and PrevVaraintValue known
3690 % the block declaration above for b_execute_while_loop already ensures this
3691 b_execute_while_body(_COND,_STMT,_INVARIANT,VAR,_PV,VarVal,LocalState,InState,_OutState,WF) :-
3692 VarVal<0, !, % more efficient than is_not_natural(int(VarVal)),
3693 %ground_constraintprop_wait_flags(WF),
3694 % add_abort_error_span will fail; hence no need to set _OutState
3695 add_abort_error_span(while_variant_error,'While VARIANT not NATURAL:',VarVal,span_predicate(VAR,LocalState,InState),WF).
3696 b_execute_while_body(_COND,_STMT,_INVARIANT,VAR,PrevVariantValue,VarVal,LocalState,InState,_OutState,WF) :-
3697 % check no longer required VarVal>=0,%is_natural(int(VarVal),WF),
3698 PrevVariantValue \= none,
3699 PrevVariantValue =< VarVal, !, %less_than_equal(int(PrevVariantValue),int(VarVal)),
3700 %ground_constraintprop_wait_flags(WF),
3701 % add_abort_error_span will fail; hence no need to set _OutState
3702 ajoin(['VARIANT = ',VarVal,', previous value = ',PrevVariantValue],Details),
3703 add_abort_error_span(while_variant_error,'While VARIANT not decreasing:',
3704 Details,span_predicate(VAR,LocalState,InState),WF).
3705 b_execute_while_body(COND,STMT,INV,VARIANT,_PrevVariantValue,VarVal,LocalState,InState,OutState,WF) :-
3706 % check no longer required due to cuts above %VarVal>=0, %is_natural(int(VarVal),WF),
3707 %(PrevVariantValue==none -> true ; less_than(int(VarVal),int(PrevVariantValue))),
3708 %ground_constraintprop_wait_flags(WF), % seems to slow down interpretation
3709 copy_wf_start(WF,while_body,CWF),
3710 ? b_execute_statement(STMT,LocalState,InState,LHSUpdates,CWF,_Path1,output_required),
3711 copy_wf_finish(WF,CWF),
3712 ground_det_wait_flag(WF), % TODO: remove this
3713 store_intermediate_updates_wf(InState,LHSUpdates,IntermediateState,STMT,WF),
3714 check_state_skeleton_bound(LHSUpdates,Bound), % otherwise variable lookups will cause problems; ensures IntermediateState skeleton bound
3715 b_execute_while_when_state_set(COND,STMT,INV,VARIANT,VarVal,LocalState,IntermediateState,OutState,WF,Bound).
3716
3717 :- block b_execute_while_when_state_set(?,?,?,?,?,?,?,?,?,-).
3718 b_execute_while_when_state_set(COND,STMT,INV,VARIANT,PrevVariantValue,LocalState,State,Res,WF,_) :-
3719 copy_wf_start(WF,while2,CWF),
3720 b_compute_expression(VARIANT,LocalState,State,VarVal,CWF),
3721 copy_wf_finish(WF,CWF),
3722 b_execute_while1(COND,STMT,INV,VARIANT,PrevVariantValue,VarVal,LocalState,State,Res,WF).
3723
3724 % ------------- IF-THEN-ELSE
3725
3726 :- block b_execute_else_list2(-,?,?,?, ?,?,?,-,?). % should we also unblock if LWF set ? needed for seq. composition to set up state ??
3727 b_execute_else_list2(PredRes,Body,Rest,LocalState,InState,OutState,InnerWF,LWF,OR) :-
3728 %(var(PredRes) -> print('IF-THEN-ELSE ENUMERATION: '), translate:print_subst(Body),nl ; true),
3729 ? b_execute_else_list3(PredRes,Body,Rest,LocalState,InState,OutState,InnerWF,LWF,OR).
3730
3731 b_execute_else_list3(pred_true,Body,_,LocalState,InState,OutState,WF,_,OR) :-
3732 ? push_wait_flag_call_stack_info(WF,b_expr_call(if_then_body,Body),WF2),
3733 ? b_execute_statement(Body,LocalState,InState,OutState,WF2,_Path,OR).
3734 b_execute_else_list3(pred_false,_Body,Rest,LocalState,InState,OutState,WF,LWF,OR) :-
3735 ? b_execute_else_list(Rest,LocalState,InState,OutState,WF,LWF,OR).
3736
3737 b_execute_else_list([],_,_State,[],_WF,_LWF,_OR). /* skip */
3738 b_execute_else_list([TExpr|Rest],LocalState,InState,OutState,WF,LWF,OR) :-
3739 get_texpr_expr(TExpr,if_elsif(Test,Body)), % Info field not used
3740 % get_enumeration_finished_wait_flag(WF,LWF),
3741 InnerWF=WF, %clone_wait_flags_from1(WF,InnerWF),
3742 push_wait_flag_call_stack_info(InnerWF,b_expr_call(if_elsif_test,Test),WF2),
3743 ? b_try_check_boolean_expression_lwf(Test,LocalState,InState,WF2,'$ENUMERATION',PredRes,LWF),
3744 %ground_wait_flag0(InnerWF),
3745 (nonvar(PredRes) -> b_execute_else_list3(PredRes,Body,Rest,LocalState,InState,OutState,InnerWF,LWF,OR)
3746 ; (LWF == '$GENERATE_ON_DEMAND' ->
3747 get_wait_flag0(WF,LWF1),
3748 get_wait_flag_if_necessary(PredRes,LWF1,OR,WF,LWF2)
3749 ; LWF2=LWF),
3750 ? b_execute_else_list2(PredRes,Body,Rest,LocalState,InState,OutState,InnerWF,LWF2,OR)
3751 ).
3752
3753 % avoid calling get_wait_flag if possible (expensive)
3754 :- block get_wait_flag_if_necessary(-,-,?,?,?).
3755 get_wait_flag_if_necessary(PredRes,_,OR,WF,LWF2) :- var(PredRes), !, % we need waitflag
3756 (preferences:preference(use_smt_mode,true) -> Prio = 2 % was 2.0
3757 ; OR == output_required -> Prio = 2000
3758 ; Prio = 200000 %last_finite_priority(Prio)
3759 ), % TO DO: check if there is a guard inside; if not we can wait much longer; unless we are in CBC mode
3760 get_wait_flag(Prio,if_else,WF,LWF2).
3761 get_wait_flag_if_necessary(_,_,_,_,_).
3762
3763 :- block b_execute_choice(?,?,?,?,?,?,-,?).
3764 b_execute_choice(ChoiceList,LocalState,InState,OutState,WF,choice(Nr,Path),_WFC,OR) :-
3765 ? nth1(Nr,ChoiceList,Choice),
3766 b_execute_statement(Choice,LocalState,InState,OutState,WF,Path,OR).
3767
3768 % execute ASSERT PreCond THEN Body
3769 b_execute_assertion(_PreCond,Body,LocalState,InState,OutState,WF,Path,OR) :-
3770 preference(do_assert_checking,false), % ASSERT checking disabled
3771 !,
3772 b_execute_statement(Body,LocalState,InState,OutState,WF,Path,OR).
3773 b_execute_assertion(PreCond,Body,LocalState,InState,OutState,WF,Path,OR) :-
3774 ? b_try_check_boolean_expression_lwf(PreCond,LocalState,InState,WF,'$ENUMERATION',PredRes,WFC),
3775 % enumeration of PredRes before WFE set make sense, Body can instantiate values
3776 (var(PredRes) -> get_last_wait_flag(assertion,WF,WFC) ; true),
3777 b_execute_assertion_block(PredRes,PreCond,Body,LocalState,InState,OutState,WF,Path,OR).
3778
3779 :- block b_execute_assertion_block(-, ?,?,?,?, ?,?,?,?).
3780 b_execute_assertion_block(pred_true,_PreCond,Body,LocalState,InState,OutState,WF,Path,OR) :-
3781 Path = assertion(IPath),
3782 b_execute_statement(Body,LocalState,InState,OutState,WF,IPath,OR).
3783 b_execute_assertion_block(pred_false,PreCond,_Body,LocalState,InState,_OutState,WF,Path,_OR) :-
3784 Path = assertion_violated,
3785 translate_bexpression(PreCond,PreString),
3786 add_abort_error_span(assert_error,'ASSERT violated: ',PreString,span_predicate(PreCond,LocalState,InState),WF).
3787
3788 :- block check_state_skeleton_bound(-,?).
3789 check_state_skeleton_bound([],true).
3790 check_state_skeleton_bound([bind(Var,_)|T],Res) :-
3791 check_state_skeleton_bound_aux(Var,T,Res).
3792
3793 :- block check_state_skeleton_bound_aux(-,?,?).
3794 check_state_skeleton_bound_aux(Var,T,Res) :-
3795 (atomic(Var) -> true ; print('*** variable name not atomic: '), print(Var),nl),
3796 check_state_skeleton_bound(T,Res).
3797
3798
3799 b_execute_statement_list_when_state_set(StmtList,LS,State,USoFar,Res,WF,Path,OR) :-
3800 check_state_skeleton_bound(State,Bound), % otherwise variable lookups will cause problems
3801 ? b_execute_statement_when_state_set2(StmtList,LS,State,USoFar,Res,WF,Path,Bound,OR).
3802 :- block b_execute_statement_when_state_set2(?,?,?,?,?,?,?,-,?).
3803 b_execute_statement_when_state_set2(StmtList,LS,State,UpdatesSofar,Res,WF,Path,_,OR) :-
3804 copy_wf_start(WF,while2,CWF),
3805 ? b_execute_sequence(StmtList,LS,State,StmtUpdates,CWF,Path,OR),
3806 ? copy_wf_finish(WF,CWF),
3807 ? merge_updates(UpdatesSofar,StmtUpdates,Res).
3808
3809
3810 store_values([], [], []).
3811 store_values([IDsHd|IDsTl], [VALsHd|VALsTl], [bind(IDsHd,VALsHd)|OutStateTl]) :-
3812 store_values(IDsTl, VALsTl, OutStateTl).
3813
3814
3815
3816
3817 /* the B syntax does allow multiple definitions in a LET: */
3818
3819 b_execute_let_definitions(Pred,LocalState,State,WF) :-
3820 is_a_conjunct(Pred,LHS,RHS),!,
3821 b_execute_let_definitions(LHS,LocalState,State,WF),
3822 b_execute_let_definitions(RHS,LocalState,State,WF).
3823 b_execute_let_definitions(b(equal(LHS,RHS),_,_),LocalState,State,WF) :- !,
3824 b_compute_expression(LHS,LocalState,State,LHSVal,WF),
3825 b_compute_expression(RHS,LocalState,State,RHSVal,WF),
3826 % TO DO: ideally we should check if LHS is a declared identifier and is only defined once
3827 kernel_objects:equal_object_optimized(LHSVal,RHSVal,b_execute_let_definitions).
3828 b_execute_let_definitions(b(lazy_let_pred(Id,AssignmentExpr,Body),_,_),LocalState,State,WF) :- !,
3829 add_lazy_let_id_and_expression(Id,AssignmentExpr,LocalState,State,NewLocalState,WF),
3830 b_execute_let_definitions(Body,NewLocalState,State,WF).
3831 b_execute_let_definitions(P,_L,_S,WF) :-
3832 add_internal_error_wf(b_interpreter,'Let contains a predicate which is not an equality: ',P,P,WF),fail.
3833
3834
3835 /* -----------------------------------------*/
3836 /* b_assign_function */
3837 /* -----------------------------------------*/
3838
3839 b_assign_values_or_functions([],[],_LS,_S,[],_WF,_OR).
3840 b_assign_values_or_functions([TExpr|ERest],[Value|VRest],LS,S,[bind(Id,New)|NRest],WF,OR) :-
3841 get_texpr_expr(TExpr,Expr),
3842 ? b_assign_value_or_function(Expr,Value,LS,S,Id,New,WF,OR),
3843 b_assign_values_or_functions(ERest,VRest,LS,S,NRest,WF,OR).
3844
3845 :- use_module(kernel_tools,[ground_value_check/2]).
3846 :- use_module(kernel_records,[overwrite_record_wf/5]).
3847 b_assign_value_or_function(identifier(Id),Value,_LS,_S,LHS_Id,FullValue,WF,_OR) :- !,
3848 LHS_Id=Id,
3849 ? equal_object_wf(FullValue,Value,b_assign_value_or_function(Id),WF).
3850 b_assign_value_or_function(function(Fun,Arg),Value,LocalState,InState,Id,FullValue,WF,OR) :- !,
3851 %b_compute_expression(Arg,LocalState,InState,ArgVal,WF),
3852 %expand_global_sets_but_not_closures(ArgVal,EArgVal),
3853 FunMNF = eval_must_not_fail('Assignment left-hand-side (or part thereof) could not be evaluated: ',Fun), % could be f(..)(..)
3854 b_compute_assign_expressions_when([Arg,FunMNF],LocalState,InState,[ArgVal,FunVal],WF,OR), % or should we pass the OR info around ?
3855 /* we do not examine local state: these vars cannot be modified by operations !? */
3856 (OR=output_required -> override(FunVal,ArgVal,Value,NewFun,WF)
3857 ; ground_value_check((FunVal,ArgVal,Value),GRV),
3858 % wait until all arguments known so that we can effiently compute override
3859 blocking_override(GRV,FunVal,ArgVal,Value,NewFun,WF)),
3860 get_texpr_expr(Fun,Lhs),
3861 b_assign_value_or_function(Lhs,NewFun,LocalState,InState,Id,FullValue,WF,OR).
3862 b_assign_value_or_function(record_field(RecordExpr,FieldName),Value,LocalState,InState,LHS_Id,FullValue,WF,OR) :-
3863 !,
3864 % we allow nested record assignments: x'Field1'Field2 := Value
3865 b_compute_expression(RecordExpr,LocalState,InState,OldRecVal,WF),
3866 overwrite_record_wf(OldRecVal,FieldName,Value,NewRecVal,WF),
3867 get_texpr_expr(RecordExpr,Lhs),
3868 b_assign_value_or_function(Lhs,NewRecVal,LocalState,InState,LHS_Id,FullValue,WF,OR).
3869 b_assign_value_or_function(LHS,_Value,_LS,_InState,_Id,_FullValue,WF,_OR) :-
3870 add_internal_error_wf(b_interpreter,'Illegal LHS for assignment (must be ID(.) or ID\'Field or ID): ',LHS,LHS,WF),
3871 fail.
3872
3873 :- block blocking_override(-,?,?,?,?,?).
3874 blocking_override(_,FunVal,ArgVal,Value,NewFun,WF) :- override(FunVal,ArgVal,Value,NewFun,WF).
3875
3876
3877 /* -----------------------------------------*/
3878 /* b_execute_statements_in_parallel */
3879 /* -----------------------------------------*/
3880 /* execute a parallel composition of statements */
3881 :- assert_pre(b_interpreter:b_execute_statements_in_parallel(Ss,LS,State,_Os,WF,_Paths,_OR),
3882 (ground_check(Ss),type_check(LS,store),
3883 type_check(State,store),type_check(WF,wait_flag))).
3884 :- assert_post(b_interpreter:b_execute_statements_in_parallel(_Ss,_LS,_State,Os,WF,_Paths,_OR),
3885 (type_check(Os,store),type_check(WF,wait_flag))).
3886
3887 b_execute_statements_in_parallel([],_,_,[],_WF,[],_OR).
3888 b_execute_statements_in_parallel([Stmt|TS],LocalState,InState,OutState,WF,[Path1|TPath],OR) :-
3889 ? b_execute_statement(Stmt,LocalState,InState,OutState1,WF,Path1,OR),
3890 ? combine_updates(OutState1,OutState2,OutState), /* merge updates */
3891 ? b_execute_statements_in_parallel(TS,LocalState,InState,OutState2,WF,TPath,OR).
3892
3893
3894 %:- block combine_updates(-,-,?).
3895 %combine_updates(A,B,C) :- (B==[] -> A=C ; combine_updates_aux(A,B,C)).
3896
3897 % TO DO: investigate whether we could also unblock on second argument and copy it to result
3898 :- block combine_updates(-,?,?). % can also be used to merge states
3899 combine_updates([],X,R) :- !,R=X.
3900 ?combine_updates([H|T],Y,Res) :- !, Res=[H|Z], combine_updates(T,Y,Z).
3901 combine_updates(X,Y,Z) :- add_internal_error('Illegal call: ',combine_updates(X,Y,Z)),fail.
3902
3903
3904
3905 b_execute_initialisation_statement(Stmt,LS,In,Out,_OUTERWF,Path,OR) :-
3906 init_wait_flags(WF,[b_execute_initialisation_statement]),
3907 % each initialisation can be executed in isolation (except in CBC mode)
3908 ? b_execute_statement(Stmt,LS,In,Out,WF,Path,OR),
3909 ? ground_wait_flags(WF).
3910
3911 % replace certain parallels by init_parallel for better error reporting in INITIALISATION
3912 % will not be used in CBC mode (by set_up_initialisation or tc_initialise)
3913 translate_init_statements(b(Stmt,subst,I),b(TStmt,subst,I)) :-
3914 tp2(Stmt,I,TStmt).
3915 tp2(assign(LHS,RHS),I,parallel(S)) :- LHS=[_,_|_],
3916 % translate multiple assignment into parallel assignments
3917 maplist(generate_assignment(I),LHS,RHS,S),
3918 !.
3919 tp2(Stmt,I,init_statement(b(Stmt,subst,I))) :- %get_preference(provide_trace_information,true),
3920 wrap_stmt(Stmt),
3921 !.
3922 % TO DO: cover WHILE
3923 tp2(parallel(S),_,parallel(TS)) :- maplist(translate_init_statements,S,TS),
3924 !.
3925 tp2(sequence(A),_,sequence(LA)) :- !,maplist(translate_init_statements,A,LA).
3926 tp2(if(A),_,if(LA)) :- !, maplist(translate_init_statements,A,LA).
3927 tp2(if_elsif(Test,Body),_,if_elsif(Test,LBody)) :- !,
3928 translate_init_statements(Body,LBody).
3929 tp2(X,_,X). % :- functor(X,F,A), nl,nl,print(uncovered(F/A)),nl,nl.
3930
3931 wrap_stmt(assign(_,_)).
3932 wrap_stmt(becomes_element_of(_,_)).
3933 wrap_stmt(becomes_such(_,_)).
3934 wrap_stmt(assign_single_id(_,_)).
3935
3936 generate_assignment(I,V,RHS,b(init_statement(b(Assign,subst,I)),subst,I)) :-
3937 Assign = assign([V],[RHS]).
3938
3939
3940
3941 /* ---------------------------------------*/
3942 /* b_execute_top_level_statement */
3943 /* ---------------------------------------*/
3944
3945 /* this is just like b_execute_statement with the
3946 only difference that a PRE-condition is treated like
3947 a select, i.e., it does not generate an abort if used
3948 outside of its condition */
3949 b_execute_top_level_statement(TExpr,LocalState,InState,OutState,WF,Path,OR) :-
3950 get_texpr_expr(TExpr,Stmt),
3951 ? b_execute_top_level_statement2(Stmt,TExpr,LocalState,InState,OutState,WF,Path,OR).
3952 b_execute_top_level_statement2(precondition(PreCond,Body),TExpr,
3953 LocalState,InState,OutState,WF,Path,OR) :-
3954 preferences:preference(treat_outermost_pre_as_select,true),!,
3955 %debug_println(9,'Top level PRE treated as SELECT'),
3956 preference(ltsmin_do_not_evaluate_top_level_guards,NO_EVAL),
3957 (NO_EVAL=full ->
3958 debug_println(9,pge_guard_will_not_be_evaluated)
3959 ; NO_EVAL=true, % do not evaluate guards detected by guard splitting
3960 get_texpr_info(TExpr,Info),member(prob_annotation('LTSMIN-GUARD'),Info) ->
3961 debug_println(9,ltsmin_guard_will_not_be_evaluated)
3962 ? ; b_test_boolean_expression(PreCond,LocalState,InState,WF)
3963 ),
3964 % b_tracetest_boolean_expression(PreCond,LocalState,InState,WF,one), % comment in for debugging
3965 ? b_execute_statement(Body,LocalState,InState,OutState,WF,Path,OR).
3966 b_execute_top_level_statement2(lazy_let_subst(Id,IdExpr,Body),_,
3967 LocalState,InState,OutState,WF,lazy_let(Path),OR) :-
3968 !,
3969 add_lazy_let_id_and_expression(Id,IdExpr,LocalState,InState,NewLocalState,WF),
3970 b_execute_top_level_statement(Body,NewLocalState,InState,OutState,WF,Path,OR).
3971 b_execute_top_level_statement2(_,TExpr,LocalState,InState,OutState,WF,Path,OR) :-
3972 ? b_execute_statement(TExpr,LocalState,InState,OutState,WF,Path,OR).
3973
3974
3975 /* -----------------------------*/
3976 /* b_execute_operation */
3977 /* -----------------------------*/
3978 /* execute a single operation */
3979
3980 try_get_op_name(FullOperation,_Name) :- var(FullOperation),!.
3981 try_get_op_name('-->'(FO,_),Name) :- !,try_get_op_name(FO,Name).
3982 try_get_op_name(FullOperation,Name) :- functor(FullOperation,Name,_).
3983
3984
3985
3986 :- assert_pre(b_interpreter:b_execute_top_level_operation_update(_Name,_FullOperation,InState,_NewState,_P),
3987 (ground_check(InState),type_check(InState,store))).
3988 :- assert_post(b_interpreter:b_execute_top_level_operation_update(Name,_FullOperation,_InState,NewState,_Path),
3989 (type_check(NewState,store),ground_check(Name))).
3990
3991
3992 b_execute_top_level_operation_update(Name,FullOperation,InState,Updates,Path) :-
3993 ? b_execute_top_level_operation_update_wf(Name,FullOperation,InState,Updates,Path,WF),
3994 ? ground_wait_flags(WF).
3995 %store:store_updates_and_normalise(Updates,InState,NewState).
3996
3997
3998 b_execute_top_level_operation_update_wf(Name,FullOperation,InState,Updates,Path,WF) :-
3999 init_wait_flags(WF,[]), % now treated by call_stack: [expansion_context(op(Name),[])]),
4000 % b_execute_operation2 below will push_wait_flag_call_stack_info
4001 try_get_op_name(FullOperation,Name), b_top_level_operation(Name),
4002 setup_result_input_values(Name,RIV),
4003 Info=unknown, % Info extracted later for top_level
4004 ? b_execute_operation2(Name,FullOperation,InState,Updates,_,RIV,_,true,Path,Info,WF,output_not_required).
4005
4006 % set up value of read output variables *before* operation call to some dummy value
4007 setup_result_input_values(Name,ResultInputValues) :-
4008 (get_preference(allow_operations_to_read_outputs,true),
4009 b_operation_reads_output_variables(Name,_Reads,TReadsInfo) ->
4010 maplist(setup_read_output_variable,TReadsInfo,ResultInputValues)
4011 %translate_bstate_limited(ResultInputValues,TS),
4012 %ajoin(['Warning: setting read output variables in ',Name,' to default values: ',TS],Msg),
4013 %add_warning(b_interpreter,Msg),
4014 %store_error_for_context_state(eventerror(Name,event_other_error(Msg),[]),_Id)
4015 ; ResultInputValues=[]).
4016
4017 :- use_module(typing_tools,[any_value_for_type/2]).
4018 setup_read_output_variable(reads_result(_,Name,Type),bind(Name,Val)) :- any_value_for_type(Type,Val).
4019
4020 % for use by CBC:
4021 b_execute_top_level_operation_wf(Name,FullOperation,ParaVals,ResultVals,InState,NewState,Path,WF) :-
4022 try_get_op_name(FullOperation,Name),
4023 if(b_top_level_operation(Name),true,
4024 (add_internal_error('Unknown operation name for b_execute_top_level_operation_wf: ',Name),fail)
4025 ),
4026 % call before execute operation to copy over results immediately in case b_execute_operation2 generates choice points:
4027 store_intermediate_updates_wf(InState,Updates,NewState,operation(Name),WF), % no normalising is better for constraint propagation
4028 % TO DO?: copy over unmodified variables b_get_machine_variables(Variables),copy_unmodified_variables(Variables,OpName,InState,NewState)
4029 setup_result_input_values(Name,RIV),
4030 Info=unknown, % Info extracted later for top_level
4031 b_execute_operation2(Name,FullOperation,InState,Updates,ParaVals,RIV,ResultVals,true,Path,Info,WF,output_required).
4032 % we should ensure that Operation part is executed to instantiate NewOutState skeleton
4033
4034
4035
4036 % Note : if the argument OR (OutputRequired) has value output_required this indicates that the output
4037 % an operation or its effect is required (e.g., because of sequential composition) and the constraint solver
4038 % should not delay computing the effect of the operation
4039 % Atelier-B Handbook 6.16: [R <- op (E)]P = [X := E ; S ; R :=Y] P where op defined by X <- op(Y) = S
4040 b_execute_operation_with_parameters(Name,LocalState,InState,Results,Parameters,OutState,ParamValues,ResultValues,Path,Info,WF,OR) :-
4041 (b_is_operation_name(Name)
4042 -> b_compute_expressions(Parameters,LocalState,InState,ParamValues,WF),
4043 % TO DO : remove local vars from InState
4044 (b_operation_reads_output_variables(Name,_Reads,TReadsInfo)
4045 -> % format('Transferring outputs ~w ~w~n ~w~n',[Name,_Reads,TReadsInfo]),
4046 maplist(output_parameters_value(LocalState,InState,Results,Info,WF),TReadsInfo,ResultInputValues)
4047 ; ResultInputValues=[]),
4048 ? call_b_execute_operation2(Name,InState,OutState,ParamValues,ResultInputValues,ResultValues,false,Path,Info,WF,OR)
4049 ; add_internal_error('Unknown B operation, cannot call: ',
4050 b_execute_operation_with_parameters(Name,LocalState,InState,Results,Parameters,
4051 OutState,ParamValues,ResultValues,Path,Info,WF,OR)),
4052 fail
4053 ).
4054
4055
4056 %b_execute_operation_in_expression(Name,_LocalState,_InState,_Parameters,_Value,Info,_WF) :-
4057 % % This clause is disabled: sometimes variables are marked as read even though they are not:
4058 % % the analysis is not precise due to sequential composition, CASE statements, ...
4059 % b_operation_reads_output_variables(Name,_Reads,_TReadsInfo),!,
4060 % add_error(b_interpreter,'Operation that reads output cannot be called in expression: ',Name,Info),
4061 % fail.
4062 b_execute_operation_in_expression(Name,LocalState,InState,Parameters,Value,Info,WF) :-
4063 % TODO: check that this is a query operation; probably done in type checker
4064 OR=output_required, % alternative: OR=output_not_required,
4065 setup_result_input_values(Name,ResultInputValues),
4066 b_compute_expressions(Parameters,LocalState,InState,ParamValues,WF),
4067 b_get_operation_normalized_read_write_info(Name,Read,_Modified), % Modified should be []
4068 create_inner_wait_flags(WF,operation_call_in_expr,OpWF),
4069 ground_value_check(ParamValues,ParaGround),
4070 exclude(unused_variable(Read),InState,IS),
4071 ground_state_check(IS,StateGround),
4072 % TO DO: in case of recursion it may be good to delay executing sub-operation until some WF is set
4073 call_b_execute_operation2(Name,IS,_OutState,ParamValues,ResultInputValues,ResultValues,false,_Path,Info,OpWF,OR),
4074 ground_inner_wf(ParaGround,StateGround,OpWF),
4075 make_couplise(ResultValues,Value).
4076
4077 % ground inner waitflags when parameters and relevant read variables fully known
4078 :- block ground_inner_wf(-,?,?), ground_inner_wf(?,-,?).
4079 ground_inner_wf(_,_,WF) :-
4080 ? ground_inner_wait_flags(WF).
4081
4082 call_b_execute_operation2(Name,InState,OutState,ParamValues,ResultInputValues,ResultValues,false,Path,Info,WF,OR) :-
4083 % TODO: insert operation call as additional error context; stack trace
4084 ? runtime_profiler:profile_single_call(Name,unknownStateId, b_interpreter:
4085 b_execute_operation2(Name,_,InState,OutState,ParamValues,ResultInputValues,ResultValues,false,Path,Info,WF,OR)
4086 ).
4087
4088 output_parameters_value(LocalState,InState,Results,_,WF,reads_result(Index,ID,_Type),bind(ID,Val)) :-
4089 nth1(Index,Results,ReadResultTID),!,
4090 def_get_texpr_id(ReadResultTID,ReadID),
4091 (lookup_value_without_check(ReadID,LocalState,InState,Val)
4092 -> true %check_not_undefined(Val,ReadID,ReadResultTID)
4093 ; add_error_wf(output_parameters,'Could not obtain value for read output parameter: ',ReadID,ReadResultTID,WF),
4094 Val = term(undefined)).
4095 output_parameters_value(_LocalState,_InState,_Results,Info,WF,reads_result(_Index,ID,_Type),bind(ID,Val)) :-
4096 add_error_wf(output_parameters,'Could not obtain value for read output parameter: ',ID,Info,WF),
4097 Val = term(undefined).
4098
4099 % TO DO: use this ?
4100 %:- block check_not_undefined(-,?,?).
4101 %check_not_undefined(term(undefined),ReadID,ReadResultTID) :- !,
4102 % add_error(output_parameters_value,'Output parameter not assigned to: ',ReadID,ReadResultTID).
4103 %check_not_undefined(_,_,_).
4104
4105 :- use_module(probsrc(succeed_max),[assert_max_reached/1]).
4106 % ResultInputValues: in Atelier-B result parameters can also be read !
4107 b_execute_operation2(Name,Operation,InState,Updates,ParaValues,ResultInputValues,ResultValues,_TopLevel,TransInfo,_,_WF,_OR) :-
4108 ResultInputValues = [], % in this case the operation's behaviour also depends on current value of output variables
4109 lookup_cached_transitions(Name,InState,Info,Solutions),!,
4110 (member(max_reached,Info) -> assert_max_reached(Name) ; true),
4111 ? member(trans_cached(ParaValues,ResultValues,Updates,TransInfo),Solutions),
4112 create_full_operation(Name,ResultValues,ParaValues,ResultValues,Operation).
4113
4114 b_execute_operation2(Name,Operation,InState,NewOutState,ParaValues,ResultInputValues,ResultValues,
4115 TopLevel,TransInfo,Info,WF,OutputRequired) :-
4116 b_get_machine_operation_for_animation(Name,Results,Parameters,Body,OType,TopLevel,OpPos),
4117 %% % we do not want skip the evaluation of a guard of an operation with parameters
4118 %% (Parameters==[] ->true; retractall(pge_algo:do_not_evaluate_guard)),
4119 (Info=unknown, TopLevel==true -> CallInfo=OpPos ; CallInfo=Info),
4120 push_wait_flag_call_stack_info(WF,operation_call(Name,ParaValues,CallInfo),WF2),
4121 ? b_execute_operation3(OType,Name,Operation,
4122 InState,NewOutState,
4123 Body,Parameters,ParaValues,Results,ResultInputValues,ResultValues,TopLevel,TransInfo,WF2,OutputRequired).
4124
4125 create_full_operation(Name,Results,ParaValues,ResultValues,FullOperation) :-
4126 %length(ParaValues,Len),print(create_full_op(Name,Len)),nl,
4127 Operation =.. [Name|ParaValues], % TO DO: catch if > 255 args (max_arity)
4128 ( Results == [] -> /* we have an ordinary operation */
4129 FullOperation = Operation
4130 ; FullOperation = '-->'(Operation,ResultValues)
4131 ).
4132
4133 b_execute_operation3(classic,Name,Operation,InState,NewOutState,
4134 Body,Parameters,ParaValues,Results,ResultInputValues,NormalisedResultValues,TopLevel,
4135 [], % [path(Path)], % as path is currently filtered out anyway and not stored !
4136 WF,OR) :-
4137 %print('Attempting Operation ----> '),print(Name),nl,
4138 empty_state(EmptyState),
4139 ? set_up_typed_localstate(Parameters,ParaValues,ParamTypedVals,EmptyState,LocalState,positive),
4140 l_expand_and_normalise_values(ParaValues,NormalisedParaValues,Parameters), % not useful for call_b_execute_operation2
4141 create_full_operation(Name,Results,NormalisedParaValues, % ditto
4142 NormalisedResultValues,Operation),
4143 set_up_undefined_localstate_with_predefined(Results,ResultInputValues,InState,NewInState),
4144 /* to avoid error messages with sequential composition (store_intermediate_updates) */
4145 check_additional_guard(TopLevel,LocalState,NewInState,WF),
4146 (TopLevel==true
4147 ? -> b_execute_top_level_statement(Body,LocalState,NewInState,OutState,WF,_Path1,OR)
4148 ? ; b_execute_statement(Body,LocalState,NewInState,OutState,WF,_Path2,OR)
4149 ),
4150 b_tighter_enumerate_all_values(ParamTypedVals,WF), % moved afer execute for performance reasons; see PerformanceTests/ParameterEnumeration.mch
4151 % print_bt_message('Operation Successful ------> '),
4152 (preferences:preference(treat_outermost_pre_as_select,true),
4153 preferences:preference(require_operations_to_assign_all_outputs,true)
4154 -> ReportError = true ; ReportError = false),
4155 get_results(Results,OutState,NormalisedResultValues,NewOutState,ReportError,normalise_results,WF).
4156 b_execute_operation3(eventb_operation(ChangeSet,ParaValues,Operation),
4157 _Name,Operation, InState,Updates,
4158 TBody,Parameters,ParaValues,[],[],[],true,TransInfo,WF,OutputRequired) :-
4159 % TO DO: check if need to pass _OutputRequired to b_event
4160 ? b_execute_event_with_change_set_wf(TBody,Parameters,ParaValues,InState,ChangeSet,Updates,TransInfo,WF,OutputRequired).
4161
4162 :- use_module(b_global_sets,[add_prob_deferred_set_elements_to_store/3]).
4163 % additional guards can be set by the user to constrain/direct the execution of operations
4164 check_additional_guard(TopLevel,LocalState,State,WF) :-
4165 (TopLevel==true,
4166 bmachine:b_machine_temp_predicate(TempPred)
4167 /* an additional precondition typed in by the user */
4168 -> check_state_skeleton_bound(LocalState,LB),
4169 check_state_skeleton_bound(State,BB),
4170 check_additional_guard_when_bound(LB,BB,TempPred,LocalState,State,WF)
4171 ; true
4172 ).
4173
4174 :- block check_additional_guard_when_bound(-,?,?, ?,?,?), check_additional_guard_when_bound(?,-,?, ?,?,?).
4175 check_additional_guard_when_bound(_,_,TempPred,LocalState,State,WF) :-
4176 (debug_mode(on) -> print(check_additional_guard),nl, print_bexpr(TempPred),nl ; true),
4177 add_prob_deferred_set_elements_to_store(State,BState1,visible),
4178 b_test_boolean_expression(TempPred,LocalState,BState1,WF).
4179
4180 % additional properties can either be set by user or by command-line or by VALUES clause
4181 add_additional_properties(OldProperty,NewProperty) :-
4182 (bmachine:b_machine_temp_predicate(TempPred) % this overrides additional property !
4183 -> conjunct_predicates([TempPred,OldProperty],NewProperty)
4184 ; findall(AddPred,b_machine_additional_property(AddPred),L),
4185 (L=[] -> NewProperty = OldProperty
4186 ; conjunct_predicates([OldProperty|L],NewProperty)
4187 )
4188 ).
4189
4190 % get removes results from OutState
4191 filter_results(Results,OutState,NewOutState,WF) :-
4192 get_results(Results,OutState,_ResultValues,NewOutState,false,do_not_normalise,WF).
4193 get_results(Results,OutState,ResultValues,NewOutState,ReportError,Normalise,WF) :-
4194 (Results==[] -> (ResultValues,NewOutState) = ([],OutState)
4195 ; get_results1(Results,OutState,ResultValues,NewOutState,ReportError,Normalise,WF)).
4196 :- block get_results1(?,-,?,?,?,?,?).
4197 get_results1([],OutState,[],OutState,_ReportError,_Normalise,_WF).
4198 get_results1([R|Results],OutState,[NRV|ResultValues],NewOutState,ReportError,Normalise,WF) :-
4199 def_get_texpr_id(R,ResultId),
4200 lookup_and_delete_value(ResultId,RV,OutState,OutState2,ReportError,WF,Finished),
4201 get_results2(Finished,R,Results,RV,NRV,OutState2,ResultValues,NewOutState,ReportError,Normalise,WF).
4202 :- block get_results2(-,?,?,?,?,?,?,?,?,?,?).
4203 get_results2(_,R,Results,RV,NRV,OutState2,ResultValues,NewOutState,ReportError,Normalise,WF) :-
4204 (Normalise==normalise_results -> normalise_value_for_var(R,true,RV,NRV)
4205 ;
4206 NRV=RV), % Maybe we should not normalise in CBC mode ?
4207 get_results1(Results,OutState2,ResultValues,NewOutState,ReportError,Normalise,WF).
4208
4209
4210
4211 /* ------------------------------------------------------------------ */
4212 /* SET UP CONSTANTS */
4213 /* ------------------------------------------------------------------ */
4214
4215 :- use_module(static_ordering).
4216
4217 :- volatile no_solution_found_for_constants/0, properties_were_filtered/1,
4218 unsat_properties_component/2, unsat_properties_enumeration_warning/1, unsat_properties_abort_error/1,
4219 unsat_properties_conjunct_inside_component/4.
4220 :- dynamic no_solution_found_for_constants/0,
4221 properties_were_filtered/1,
4222 unsat_properties_component/2, unsat_properties_enumeration_warning/1,
4223 unsat_properties_abort_error/1,
4224 unsat_properties_conjunct_inside_component/4.
4225
4226 reset_unsat_component_infos :-
4227 retractall(unsat_properties_component(_,_)),
4228 retractall(unsat_properties_enumeration_warning(_)),
4229 retractall(unsat_properties_abort_error(_)),
4230 retractall(unsat_properties_conjunct_inside_component(_,_,_,_)).
4231
4232 :- use_module(b_interpreter_components,[unsat_conjunct_inside_component/4, unsat_component_abort_error/1,
4233 unsat_component_enumeration_warning/1]).
4234 % store information about unsatisfiable components for later usage
4235 % will only be called when no solution found for components
4236 assert_unsat_component_infos(_) :-
4237 unsat_component(X,FalseOrUnknown), % from b_interpreter_components
4238 assertz(unsat_properties_component(X,FalseOrUnknown)),fail.
4239 assert_unsat_component_infos(_) :-
4240 unsat_component_enumeration_warning(X), % from b_interpreter_components
4241 assertz(unsat_properties_enumeration_warning(X)),fail.
4242 assert_unsat_component_infos(_) :-
4243 unsat_component_abort_error(X), % from b_interpreter_components
4244 assertz(unsat_properties_abort_error(X)),fail.
4245 assert_unsat_component_infos(_) :-
4246 unsat_conjunct_inside_component(X,BE,Status,Reason), % from b_interpreter_components
4247 assertz(unsat_properties_conjunct_inside_component(X,BE,Status,Reason)),fail.
4248 assert_unsat_component_infos(Status) :-
4249 (unsat_conjunct_inside_component(_,_,false,_) -> Status = false
4250 ; unsat_component(X,false), \+ unsat_component_abort_error(X) -> Status = false % what about enumeration warnings?
4251 ; Status=unknown).
4252
4253
4254 all_unsat_components_marked_prob_ignore :-
4255 unsat_properties_conjunct_inside_component(_,_,unknown,'prob-ignore'), % at least one prob-ignore was used
4256 !,
4257 \+ non_ignore_unsat_component.
4258
4259 non_ignore_unsat_component :-
4260 unsat_properties_conjunct_inside_component(_,_,Status,Reason),
4261 \+ (Status = unknown, Reason = 'prob-ignore').
4262
4263 tcltk_unsatisfiable_components_exist :- unsat_or_unknown_component_exists,!.
4264
4265 %tcltk_unsatisfiable_components(list(UnsatComponents)) :-
4266 % findall(C,unsat_properties_component(C),UnsatComponents), UnsatComponents\=[].
4267
4268 get_property_components(Components) :-
4269 b_machine_has_constants_or_properties,
4270 b_get_properties_from_machine(Properties),
4271 add_additional_properties(Properties,NewProperty),
4272 bsyntaxtree:predicate_components(NewProperty,Components),!.
4273 get_property_components([]).
4274
4275 :- dynamic uses_implementable_integers/0.
4276 :- dynamic min_max_integer_value_used/2.
4277
4278
4279 tcltk_quick_describe_unsat_properties(list(FullDescr),STATUS) :-
4280 retractall(uses_implementable_integers),
4281 retractall(min_max_integer_value_used(_,_)), assertz(min_max_integer_value_used(none,none)),
4282 get_property_components(Components),
4283 (unsat_properties_conjunct_inside_component(_,_,false,_)
4284 -> STATUS='FALSE'
4285 ; all_unsat_components_marked_prob_ignore
4286 -> STATUS = 'prob-ignore'
4287 ; STATUS='UNKNOWN'
4288 ),
4289 findall(TP, (unsat_properties_conjunct_inside_component(CompNr,P,_Status,_ReasonMsg), % find individual conjuncts
4290 % Status can be false or unknown
4291 nth1(CompNr,Components,component(FullPred,_Vars)),
4292 check_uses_implementable_integers(FullPred), % for the min-max one may need to look at the entire component !
4293 translate_bexpression_with_limit(P,TrP),
4294 get_component_enum_warning_message(CompNr,EnumWarningAbortMsg),
4295 (EnumWarningAbortMsg = '' -> Prefix = '' ; Prefix = '\n '),
4296 get_span_msg(P,'\n ',SpanMsg),
4297 ajoin([' * ',TrP,Prefix,EnumWarningAbortMsg,SpanMsg,'\n'],TP)),
4298 D1),
4299 findall([Msg1,PS|DescrVars],
4300 (get_unsat_component_description(Components,CompNr,MaxCompNr,
4301 Size,PS,DescrVars,EnumWarningAbortMsg,SpanMsg),
4302 ajoin([' * Predicate Component ',EnumWarningAbortMsg,CompNr,'/',MaxCompNr,
4303 ' (with ',Size,' conjunct(s))',SpanMsg, ':'],Msg1)),
4304 UC),
4305 append(UC,UCL), % join all component descriptions
4306 (D1=[]
4307 % TO DO: adapt message for enumeration warning
4308 -> Descr = D2,
4309 (UCL=[] -> D2 = ['The properties were satisfiable']
4310 ; D2 = ['No solution found for the following predicates: '|UCL]
4311 )
4312 ; Descr = ['The following properties prevented finding a solution:\n'|D12],
4313 % Comment: the predicate can trigger the computation of another earlier registered predicate
4314 % Example f = {1|->2} & f: A --> B & A = 1..5; A=1..5 triggers the check for f
4315 (UCL=[] -> D2=[]
4316 ; D2 = ['\nIn addition no solution was found for the following predicates: '|UCL]
4317 ),
4318 append(D1,D2,D12)),
4319 findall(W,other_warning(W),Warnings),
4320 (Warnings = [] -> FullDescr=Descr ; append(Descr,['\nWARNINGS/MESSAGES:'|Warnings],FullDescr)).
4321
4322 % called by predicate_debugger:
4323 get_unsat_component_predicate(CompNr,Predicate,Vars) :-
4324 unsat_properties_component(CompNr,_FalseOrUnknown),
4325 get_property_components(Components),
4326 nth1(CompNr,Components,component(Predicate,Vars)).
4327
4328 get_unsat_component_description(Components,CompNr,MaxCompNr,Size,PS,DescrVars,EnumWarningAbortMsg,SpanMsg) :-
4329 unsat_properties_component(CompNr,_),
4330 \+ unsat_properties_conjunct_inside_component(CompNr,_,_,_), % we have not yet dealt with this component in first findall above
4331 nth1(CompNr,Components,component(Pred,Vars)),
4332 length(Components,MaxCompNr),
4333 size_of_conjunction(Pred,Size),
4334 describe_constants(Vars,DescrVars),
4335 check_uses_implementable_integers(Pred), % store information in case it does use implementable integers for later user messages
4336 (debug_mode(on) -> Lim = 1500 ; Lim = 250),
4337 translate_bexpression_with_limit(Pred,Lim,PS),
4338 get_component_enum_warning_message(CompNr,EnumWarningAbortMsg),
4339 % note: sometimes we have a conjunction with empty span info, but different conjuncts (possibly from different files):
4340 get_span_msg(Pred,'\n ',SpanMsg).
4341
4342 get_span_msg(Pred,Prefix,SpanMsg) :-
4343 (extract_span_description(Pred,SpanStr) -> ajoin([Prefix,SpanStr],SpanMsg) ; SpanMsg = '').
4344
4345 get_component_enum_warning_message(CompNr,EnumWarningAbortMsg) :-
4346 (unsat_properties_enumeration_warning(CompNr)
4347 ->(unsat_properties_abort_error(CompNr)
4348 -> EnumWarningAbortMsg = '[** with Enumeration Warning and WD-ERROR **] '
4349 ; EnumWarningAbortMsg = '[* with Enumeration Warning *] ')
4350 ; (unsat_properties_abort_error(CompNr)
4351 -> EnumWarningAbortMsg = '[** with WD-ERROR **] '
4352 ; EnumWarningAbortMsg = '')
4353 ).
4354
4355 describe_constants([],R) :- !,R=[].
4356 describe_constants(Vars,['* over identifiers : '|Vars]).
4357
4358 check_uses_implementable_integers(_) :- specfile:eventb_mode,!. % cannot use implementable integers
4359 check_uses_implementable_integers(_) :- uses_implementable_integers,!. % no need to check another component
4360 check_uses_implementable_integers(Pred) :-
4361 (uses_implementable_integers(Pred)
4362 -> assertz(uses_implementable_integers),
4363 retract(min_max_integer_value_used(Min,Max)),
4364 min_max_integer_value_used(Pred,Min,Max,NewMin,NewMax),
4365 assertz(min_max_integer_value_used(NewMin,NewMax))
4366 ; true).
4367
4368 other_warning(W) :- uses_implementable_integers,
4369 preferences:get_preference(minint,MININT),
4370 preferences:get_preference(maxint,MAXINT),
4371 min_max_integer_value_used(Min,Max),
4372 ( (number(Min),Min<MININT ; number(Max),Max>MAXINT)
4373 -> ajoin(['\n MININT...MAXINT only set to ',MININT,'..',MAXINT,' but integers used at least from ',Min,'..',Max],W)
4374 ; (MAXINT < 127 ; MININT > -128)
4375 -> ajoin(['\n MININT...MAXINT possibly too small: ',MININT,'..',MAXINT],W)).
4376 % TO DO: we could also extract explicit integer values used in the component and compare them against MININT/MAXINT
4377 other_warning(W) :- bmachine_eventb:deferred_set_equality_without_enumeration_axioms(X,_Set),
4378 translate_bexpression_with_limit(X,XS),
4379 ajoin(['\n Set not recognized as enumerated: ',XS],W).
4380 % TO DO: generate warning if MAXINT/MININT small and NAT,NAT1 or INT was used in component(s) above
4381
4382 % call if tcltk_quick_describe_unsat_properties fails:
4383 % TODO: maxint warning above
4384 generate_unsat_properties_warnings :- uses_implementable_integers,
4385 preferences:get_preference(minint,MININT),
4386 preferences:get_preference(maxint,MAXINT),
4387 min_max_integer_value_used(Min,Max),
4388 (number(Min),Min<MININT ; number(Max),Max>MAXINT),
4389 ajoin(['MININT...MAXINT only set to ',MININT,'..',MAXINT,' but integers used at least from ',Min,'..',Max],Msg),
4390 add_warning(setup_constants_unknown,Msg),
4391 fail.
4392 generate_unsat_properties_warnings :-
4393 bmachine_eventb:deferred_set_equality_without_enumeration_axioms(X,Set),
4394 translate_bexpression_with_limit(X,TX),
4395 Eq = b(equal(X,Set),pred,[]),
4396 ajoin(['Deferred SET ',TX,' was not recognized as an enumerated set, you may want to use partition instead of the equality: '],Msg),
4397 add_warning(setup_constants_unknown,Msg,Eq,X),
4398 fail.
4399 generate_unsat_properties_warnings.
4400
4401 % -------------
4402
4403 % Complete is either complete_properties or partial_properties if properties were marked as ignore
4404 b_set_up_concrete_constants(NormalisedConstantsState,Complete) :-
4405 reset_unsat_component_infos,
4406 retractall(properties_were_filtered(_)),
4407 (no_solution_found_for_constants -> true ; assertz(no_solution_found_for_constants)),
4408 % preference(allow_incomplete_partial_setup_constants,AllowSkipping),
4409 reset_component_info(true),
4410 b_machine_has_constants_or_properties,
4411 b_get_machine_constants(UnsortedConstants),
4412 !,
4413 silent_mode(SilentMode),
4414 ? (SilentMode=on -> true ; bt_start_ms_timer('SETUP_CONSTANTS')), % TO DO: store time for unsat core
4415 b_get_properties_from_machine(MProperties),
4416 (get_preference(use_ignore_pragmas,true) % filter out prob-ignore predicates here
4417 -> conjunction_to_list(MProperties,LMP), % TO DO avoid this conversion and back
4418 exclude_count(predicate_has_ignore_pragma, LMP,LMP2,Excluded), % exclude props marked as prob-ignore
4419 conjunct_predicates(LMP2,MProperties2),
4420 %format('FILTERED (~w): ',[Excluded]),translate:print_bexpr(MProperties2),nl,
4421 (Excluded=0 -> Complete=complete_properties
4422 ; assertz(properties_were_filtered(Excluded)), Complete=partial_properties)
4423 ; MProperties2=MProperties,
4424 Complete=complete_properties
4425 ),
4426 add_additional_properties(MProperties2,Properties),
4427 project_onto_static_assertions(Properties,UnsortedConstants,PProperties,PUnsortedConstants),
4428 ? solve_properties(PProperties,PUnsortedConstants,ConstantsState),
4429 ? (SilentMode=on -> true ; bt_stop_ms_timer('SETUP_CONSTANTS')),
4430 normalise_store(ConstantsState,NormalisedConstantsState),
4431 retractall(no_solution_found_for_constants). /* ensure that b_partial_set_up_concrete_constants fails */
4432 b_set_up_concrete_constants([],complete).
4433
4434
4435 % solve already projected and filtered properties and constants, return state with solution for constants
4436 % cbc_solve_timed almost does what we want; but looks at current state; see solve_free_aux
4437 % TODO: move this to a separate module and add cdclt
4438 solve_properties(PProperties,PUnsortedConstants,ConstantsState) :-
4439 get_preference(use_solver_on_load,Solver),
4440 ? solve_properties(Solver,PProperties,PUnsortedConstants,ConstantsState).
4441
4442 solve_properties(sat,Properties,_TypedConstants,ConstantsState) :- !,
4443 b2sat:solve_predicate_with_satsolver_free(Properties, ConstantsState,Result,[]),
4444 Result=solution(_).
4445 solve_properties('sat-z3',Properties,_TypedConstants,ConstantsState) :- !,
4446 b2sat:solve_predicate_with_satsolver_free(Properties, ConstantsState,Result,[use_satsolver(z3)]),
4447 Result=solution(_).
4448 solve_properties(cdclt,Properties,_TypedConstants,ConstantsState) :- !,
4449 cdclt_solver:cdclt_solve_predicate(Properties,_,Result),
4450 Result=solution(ConstantsState).
4451 solve_properties(clingo,Properties,_TypedConstants,ConstantsState) :- !,
4452 get_preference(maxNrOfInitialisations,MaxNrSols),
4453 b2asp:solve_pred_with_clingo(Properties,MaxNrSols,_,Result,_Exhaustive),
4454 % TODO: check if non_exhaustive and assert max_reached ?
4455 Result=solution(ConstantsState).
4456 solve_properties(kodkod,PProperties,PUnsortedConstants,ConstantsState) :- !,
4457 ? solve_properties(prob,PProperties,PUnsortedConstants,ConstantsState). % Kodkod processing is done elswehere
4458 solve_properties(prob,PProperties,PUnsortedConstants,ConstantsState) :- !,
4459 (preferences:preference(use_static_ordering,true)
4460 -> sort_ids_by_usage(PUnsortedConstants,PProperties,Constants,no_warnings), % no_warnings as Ids could be used in operations, assertions, ...
4461 set_up_typed_localstate(Constants,_FreshVars,TypedVals,[],SortedState,positive),
4462 ? reorder_state(PUnsortedConstants,SortedState,ConstantsState)
4463 ; Constants = PUnsortedConstants,
4464 ? set_up_typed_localstate(Constants,_FreshVars,TypedVals,[],ConstantsState,positive)
4465 ),
4466 % now try and load saved constants from file for sub-machines when -cache is used:
4467 ? load_partial_constants(ConstantsState,PProperties,LPProperties), % Note: this can backtrack
4468 reset_component_info(true), % reset in case load_partial_constants backtracks! relevant for test 2112
4469 b_global_sets:static_symmetry_reduction_for_global_sets(ConstantsState),
4470 ? b_trace_test_components_full(LPProperties,ConstantsState,TypedVals).
4471 solve_properties(SolverName,Properties,_TypedConstants,ConstantsState) :-
4472 temporary_set_preference(z3_solve_for_animation, true,Chng),
4473 call_cleanup(smt_solvers_interface:smt_solve_predicate_free(SolverName, Properties, ConstantsState),
4474 reset_temporary_preference(z3_solve_for_animation,Chng)).
4475
4476
4477 b_trace_test_components_full(LPProperties,ConstantsState,TypedVals) :-
4478 init_wait_flags_and_push_call_stack(no_wf_available,operation_call('SETUP_CONSTANTS',[],unknown),WF),
4479 ? b_trace_test_components_wf(LPProperties,ConstantsState,TypedVals,WF),
4480 ground_wait_flags(WF), % WF is just a dummy waitflag to pass call stack info
4481 (unsat_or_unknown_component_exists -> (!,fail) ; true). % otherwise some expressions were skipped; use partial_set_up
4482
4483 :- volatile project_properties_on_identifiers/1.
4484 :- dynamic project_properties_on_identifiers/1.
4485 set_projection_on_static_assertions(ALL) :-
4486 % set interpreter in mode which projects out all constants not needed
4487 % for static assertion checking; all variables are also projected out
4488 retractall(project_properties_on_identifiers(_)),
4489 (b_get_assertions(ALL,dynamic,[]) -> true
4490 ; nl,print('*** WARNING: DYNAMIC B ASSERTIONS NOT EMPTY'),nl,nl),
4491 ? b_get_assertions(ALL,static,L),
4492 (L=[] -> nl,print('*** WARNING: NO STATIC B ASSERTIONS ***'),nl,nl ; true),
4493 conjunct_predicates(L,Conj),
4494 (debug_mode(on) -> print('Static Assertion: '),translate:print_bexpr(Conj),nl ; true),
4495 bsyntaxtree:predicate_identifiers(Conj,IDs),
4496 (debug_mode(on) -> print('IDS: '), print(IDs),nl ; true),
4497 assertz(project_properties_on_identifiers(IDs)).
4498
4499 % optionally project properties onto those required for checking assertions
4500 project_onto_static_assertions(Properties,Constants,NewProperties,NewConstants) :-
4501 %% set_projection_on_static_assertions(main), %% main or all %% set by probcli if we_need_only_static_assertions
4502 project_properties_on_identifiers(ProjIDs),
4503 bsyntaxtree:project_predicate_on_identifiers(Properties,ProjIDs,NewProperties,PIDs,_),
4504 sort(PIDs,SIPDs),
4505 debug_println(9,projecting(SIPDs)),
4506 include(keep_constant(SIPDs),Constants,NewConstants),!. % Constants is a typed identifier list.
4507 project_onto_static_assertions(Properties,Constants,Properties,Constants).
4508
4509 keep_constant(SIPDs,TypedID) :- get_texpr_id(TypedID,ID),ord_member(ID,SIPDs).
4510
4511
4512
4513 /* can be called if b_set_up_concrete_constants failed; will partially set up the state using values found in first ground value propagation phase */
4514 :- use_module(specfile,[get_specification_description/2]).
4515 b_partial_set_up_concrete_constants(NormalisedConstantsState) :-
4516 assert_unsat_component_infos(Status), % Status is false or unknown
4517 no_solution_found_for_constants,
4518 (b_partial_set_up_concrete_constants2(NormalisedConstantsState,Status)
4519 -> generate_unsat_properties_warnings
4520 ; generate_unsat_properties_warnings,fail).
4521
4522 b_partial_set_up_concrete_constants2(NormalisedConstantsState,Status) :-
4523 b_get_machine_constants(Constants),
4524 Constants \= [],
4525 ? (det_solution_for_constant_was_stored(Cst1) -> true), % we have found a solution for at least one constant
4526 %set_up_typed_localstate(Constants,[],ConstantsState), -> can create call_residue due to typing fd/2 values
4527 findall(bind(ID,_),(member(TID,Constants),def_get_texpr_id(TID,ID)),ConstantsState),
4528 formatsilent('SETUP_CONSTANTS not successful, but solutions were found for some constants (e.g., ~w):~n',[Cst1]),
4529 (fill_in_det_solutions(ConstantsState,FC)
4530 -> All=all, TMSG = [')']
4531 ; All=some, TMSG = [', e.g., ',Cst1,')']
4532 ),
4533 (preference(allow_incomplete_partial_setup_constants,true)
4534 -> true
4535 ; % fill_in_det_solutions will fail if not all constants valued and
4536 % if allow_incomplete_partial_setup_constants is false
4537 get_specification_description(properties,PS),
4538 % TO DO: determine if time-out occurred or not
4539 (Status=false
4540 -> ajoin([PS,' are unsatisfiable (but ',All,' CONSTANTS valued'|TMSG],Msg),
4541 add_error(setup_constants_inconsistent,Msg)
4542 ; unsat_properties_abort_error(_)
4543 -> ajoin([PS,' are unknown due to well-definedness error(s) (but ',All,' CONSTANTS valued'|TMSG],Msg),
4544 add_error(setup_constants_unknown,Msg)
4545 ; unsat_component_enumeration_warning(_)
4546 -> ajoin([PS,' are unknown due to enumeration warning(s) (but ',All,' CONSTANTS valued'|TMSG],Msg),
4547 add_error(setup_constants_unknown,Msg)
4548 ; all_unsat_components_marked_prob_ignore
4549 -> ajoin([PS,' are unknown due to prob-ignore pragmas (but ',All,' CONSTANTS valued'|TMSG],Msg),
4550 add_message(setup_constants_unknown,Msg)
4551 ;
4552 ajoin([PS,' are unknown (but ',All,' CONSTANTS valued'|TMSG],Msg),
4553 % typical message: but some CONSTANTS valued
4554 add_error(setup_constants_unknown,Msg)
4555 ),
4556 All=all % only continue if all constants valued
4557 ),
4558 normalise_store(FC,NormalisedConstantsState).
4559
4560
4561 :- use_module(store,[no_value_for_variable/2]).
4562 fill_in_det_solutions([],[]).
4563 fill_in_det_solutions([bind(Var,Val)|T],[bind(Var,FVal)|FT]) :-
4564 (det_solution_for_constant(Var,Val)
4565 -> (silent_mode(on) -> true ; write(' --det--> '),print_term_summary(bind(Var,Val))),
4566 FVal=Val
4567 ; %format('No (deterministic) solution was found or stored for constant: ~w~n',[Var]), % message printed by det_solution_for_constant
4568 (preference(allow_incomplete_partial_setup_constants,true)
4569 -> no_value_for_variable(FVal,Var)
4570 ; format('Aborting SETUP_CONSTANTS (set preference ALLOW_INCOMPLETE_SETUP_CONSTANTS to TRUE to allow ProB to proceed without having values for all CONSTANTS)~n',[]),
4571 fail
4572 )
4573 ),
4574 fill_in_det_solutions(T,FT).
4575
4576
4577
4578 /* --------------------------------- */
4579
4580 :- use_module(b_state_model_check, [b_check_valid_state/1]).
4581
4582 % note: set_up_initialisation for CBC checks does not use this predicate
4583 b_initialise_machine(ConstantsState,NormalisedInitialVarsState,FullInitialState,Path) :-
4584 ? if(b_initialise_machine2(ConstantsState,NormalisedInitialVarsState,FullInitialState,Path),
4585 true,
4586 (\+ logged_error(initialisation_fails,_,_,_), % we have already provided a more precise error message
4587 \+ abort_error_exists_in_context_state(initialisation_fails), % ditto as a state error
4588 (bmachine:b_machine_temp_predicate(TempPred)
4589 -> add_message(initialisation_fails,'INITIALISATION FAILS with provided predicate: ',TempPred,TempPred)
4590 ; b_get_initialisation_from_machine(Stmt,_OType)
4591 -> add_error(initialisation_fails,'INITIALISATION FAILS','',Stmt)
4592 ; add_error(initialisation_fails,'MACHINE has no INITIALISATION clause')
4593 ),
4594 fail)
4595 ).
4596
4597 b_initialise_machine2(ConstantsState,NormalisedInitialVarsState,FullInitialState,Path) :-
4598 /* InitialVarsState is an ouput */
4599 b_get_initialisation_from_machine(InitStatement,OType),
4600 ( InitStatement=[] ->
4601 Path = [],
4602 add_message(b_initialise_machine,'Machine has no INITIALISATION statement(s)!'),
4603 NormalisedInitialVarsState = [],
4604 FullInitialState = ConstantsState
4605 ; OType == classic ->
4606 Path = [path(PathInfo)],
4607 b_get_machine_variables(DeclaredVars),
4608 set_up_undefined_localstate(DeclaredVars,ConstantsState,NewInState),
4609 /* this is if the INITIALISATION has a sequential composition; to avoid error messages */
4610 get_texpr_info(InitStatement,PosInfo),
4611 init_wait_flags_with_call_stack(WF,[operation_call('INITIALISATION',[],PosInfo)]),
4612 (bmachine:b_machine_temp_predicate(_)
4613 -> InitStatement2=InitStatement /* avoid enumerating each init statement in parallel in case additional guard links them */
4614 ; translate_init_statements(InitStatement,InitStatement2)
4615 ),
4616 check_additional_guard(true,InitialVarsState,ConstantsState,WF),
4617 ? b_execute_statement(InitStatement2,[],NewInState,InitialVarsState,WF,PathInfo),
4618 % Warning: in Z mode (e.g. test 565) the variable skeleton may not yet be set up !
4619 sort_variable_binding(InitialVarsState,NormalisedInitialVarsState),
4620 append(NormalisedInitialVarsState,ConstantsState,FullInitialState), % put constants at end to make sharing of complete tail-list easier for successor states; should be compatible with order in expand_const_and_vars
4621 split_names_and_types(DeclaredVars,DeclaredNames,DeclaredTypes),
4622 ? ground_wait_flags(WF),
4623
4624 b_enumerate_values_in_store(DeclaredNames,DeclaredTypes,_,InitialVarsState,WF) %% MOVED HERE TO AVOID that target values are enumerated before initialisation effect computed
4625 ; OType = eventb_operation(_ChangeSet,ParaValues,_Operation) ->
4626 prepare_eventb_initialisation(ConstantsState,InitialVarsUnNormState,FullInitialUnNormState),
4627 get_texpr_expr(InitStatement,
4628 rlevent(_Name,_Sec,_Stat,Parameters,_Grd,_Thm,_Act,_VWit,_PWit,_Unmod,_AbsEv)),
4629 ? b_execute_event('initialisation',InitStatement,Parameters,ParaValues,ConstantsState,FullInitialUnNormState,Path),
4630 normalise_store(InitialVarsUnNormState,NormalisedInitialVarsState),
4631 normalise_store(FullInitialUnNormState,FullInitialState) % a bit of redundant work here; we do the work twice and try to normalise constants again !
4632 ),
4633 b_check_valid_state(FullInitialState).
4634
4635 % ensure that the variables always appear in the same order as reported by b_get_machine_variables:
4636 % this is important for e.g., state_packing TO DO: we could sort them according to the variable names, but would there be a gain ??
4637 sort_variable_binding(Store,SortedStore) :- %print(sort_variable_binding(Store,SortedStore)),nl,
4638 b_get_machine_variables(Variables),
4639 sort_aux(Variables,Store,[],SortedStore).
4640 sort_aux([],S,Acc,NormRes) :- reverse(Acc,Res),
4641 normalise_store(Res,NormRes),
4642 (S=[] -> true ; add_internal_error('Unknown variable bindings: ',S)).
4643 sort_aux([TVar|T],Store,Acc,Res) :- def_get_texpr_id(TVar,ID),
4644 bselect(ID,Val,Store,Rest),
4645 sort_aux(T,Rest,[bind(ID,Val)|Acc],Res).
4646
4647 :- block bselect(?,?,-,?). % in Z mode (e.g. test 565) the variable skeleton may not yet be set up !
4648 bselect(ID,Val,[bind(ID1,Val1)|T],Rest) :- % we assume ID1 is nonvar
4649 (ID=ID1 -> Val=Val1,T=Rest
4650 ; Rest = [bind(ID1,Val1)|RT],
4651 bselect(ID,Val,T,RT)).
4652
4653 prepare_eventb_initialisation(ConstantsState,InitialVarsState,FullInitialState) :-
4654 b_get_machine_variables(Variables),
4655 empty_state(Empty),
4656 set_up_typed_localstate(Variables,_,_,Empty,InitialVarsState,positive),
4657 % NormalisedInitialVarsState = InitialVarsState, % TO DO : check that b_event normalises this
4658 combine_updates(InitialVarsState,ConstantsState,FullInitialState).
4659 % put constants at end, to be compatible with b_initialise_machine2 and expand_const_and_vars order and e.g. ltsmin
4660
4661
4662
4663 reset_b_interpreter :-
4664 %reset_partial_evaluator,
4665 retractall(project_properties_on_identifiers(_)),
4666 reset_unsat_component_infos,
4667 retractall(no_solution_found_for_constants).
4668
4669 :- use_module(eventhandling,[register_event_listener/3]).
4670 :- register_event_listener(clear_specification,reset_b_interpreter,
4671 'Reset B-Interpreter Memo Table & Unsat Components.').