1 % (c) 2004-2026 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 :- module(kernel_relations,
6 [empty_sequence/1,
7 is_sequence/2, is_sequence_wf/3, not_is_sequence/2, not_is_sequence_wf/3,
8 not_is_non_empty_sequence_wf/3,
9 injective_sequence_wf/3,
10 not_injective_sequence/3,
11 not_non_empty_injective_sequence/3,
12 injective_non_empty_sequence/3,
13 finite_non_empty_sequence/3,
14 test_finite_non_empty_sequence/4,
15 permutation_sequence_wf/3,
16 not_permutation_sequence/3,
17 size_of_sequence/3,
18 prepend_sequence/4, append_sequence/4, prefix_sequence_wf/4,
19 suffix_sequence/4, concat_sequence/4,
20 disjoint_union_wf/4,
21 concatentation_of_sequences/3,
22 tail_sequence/4, first_sequence/4, front_sequence/4, last_sequence/4,
23 rev_sequence/3,
24
25
26 % maplet/3,
27 % relation/1,
28 relation_over/3, relation_over_wf/4,
29 not_relation_over/4,
30 domain_wf/3,
31
32 range_wf/3,
33 identity_relation_over_wf/3, in_identity/3, not_in_identity/3,
34 invert_relation_wf/3,
35 tuple_of/3,
36 in_composition_wf/4, not_in_composition_wf/4, rel_composition_wf/5,
37 direct_product_wf/4,
38 parallel_product_wf/4, in_parallel_product_wf/4, not_in_parallel_product_wf/4,
39 rel_iterate_wf/5,
40 event_b_identity_for_type/3,
41
42 not_partial_function/4,
43 partial_function/3, partial_function_wf/4, partial_function_test_wf/5,
44
45 total_function/3, total_function_wf/4, total_function_test_wf/5,
46
47 % enumerate_total_bijection/3,
48 total_bijection/3, total_bijection_wf/4,
49
50 not_total_function/4,
51 not_total_bijection/4,
52
53
54 range_restriction_wf/4, range_subtraction_wf/4,
55 in_range_restriction_wf/4, not_in_range_restriction_wf/4,
56 in_range_subtraction_wf/4, not_in_range_subtraction_wf/4,
57 domain_restriction_wf/4, domain_subtraction_wf/4,
58 in_domain_restriction_wf/4, not_in_domain_restriction_wf/4,
59 in_domain_subtraction_wf/4, not_in_domain_subtraction_wf/4,
60 override_relation/4,
61 in_override_relation_wf/4, not_in_override_relation_wf/4,
62 image_wf/4, image_for_closure1_wf/4,
63 special_operator_for_image/3, image_for_special_operator/5, apply_fun_for_special_operator/6,
64
65 in_domain_wf/3, not_in_domain_wf/3,
66 apply_to/4, apply_to/5, apply_to/6,
67 override/5,
68
69 %sum_over_range/2, mul_over_range/2,
70
71 disjoint_union_generalized_wf/3,
72
73 partial_surjection/3, not_partial_surjection_wf/4,
74 partial_surjection_test_wf/5,
75
76 total_relation_wf/4,
77 not_total_relation_wf/4,
78
79 surjection_relation_wf/4, total_surjection_relation_wf/4,
80 not_surjection_relation_wf/4, not_total_surjection_relation_wf/4,
81
82 total_surjection/3, total_surjection_wf/4,
83 not_total_surjection_wf/4,
84
85 partial_injection/3, partial_injection_wf/4,
86 not_partial_injection/4,
87
88 total_injection/3, total_injection_wf/4,
89 not_total_injection/4,
90
91 partial_bijection/3, partial_bijection_wf/4,
92 not_partial_bijection/4,
93
94 relational_trans_closure_wf/3, %relational_reflexive_closure/2,
95 in_closure1_wf/3, not_in_closure1_wf/3
96 ]).
97
98
99 :- use_module(library(terms)).
100 :- use_module(self_check).
101
102 :- use_module(debug).
103 :- use_module(tools).
104
105 :- use_module(module_information,[module_info/2]).
106 :- module_info(group,kernel).
107 :- module_info(description,'This module provides more advanced operations for the basic datatypes of ProB (mainly for relations, functions, sequences).').
108
109 :- use_module(tools_printing).
110
111 :- use_module(delay).
112
113 :- use_module(typechecker).
114 :- use_module(error_manager).
115
116 :- use_module(kernel_objects).
117 :- use_module(kernel_records).
118 :- use_module(kernel_tools).
119
120 :- use_module(kernel_waitflags).
121 :- use_module(kernel_equality,[equality_objects_wf/4]).
122
123 :- use_module(custom_explicit_sets).
124 :- use_module(avl_tools,[avl_fetch_pair/3]).
125 :- use_module(bool_pred,[negate/2]).
126 :- use_module(closures,[is_symbolic_closure/1]).
127 :- use_module(bsyntaxtree, [conjunct_predicates/2,
128 mark_bexpr_as_symbolic/2,
129 create_texpr/4,
130 safe_create_texpr/3,
131 get_texpr_type/2
132 ]).
133
134 /* --------- */
135 /* SEQUENCES */
136 /* ------- - */
137
138 :- assert_must_succeed((kernel_relations:empty_sequence([]))).
139 :- assert_must_fail((kernel_relations:empty_sequence([int(1)]))).
140 empty_sequence(X) :- empty_set(X).
141 empty_sequence_wf(X,WF) :- empty_set_wf(X,WF).
142
143 :- assert_must_succeed(exhaustive_kernel_check(kernel_relations:not_empty_sequence([(int(2),int(33)),(int(1),int(22))]))).
144 :- assert_must_succeed(exhaustive_kernel_check(kernel_relations:not_empty_sequence([(int(1),int(33))]))).
145 :- assert_must_succeed(exhaustive_kernel_fail_check(kernel_relations:not_empty_sequence([]))).
146
147 not_empty_sequence(X) :- var(X),!,
148 X = [(int(1),_)|_].
149 not_empty_sequence(X) :- is_custom_explicit_set_nonvar(X),!,
150 is_non_empty_explicit_set(X).
151 not_empty_sequence([(int(_),_)|_]). % clousure, avl_set dealt with clause above
152
153 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:not_empty_sequence_wf([(int(1),int(33))],WF),WF)).
154 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:not_empty_sequence_wf([(int(1),pred_true),(int(2),pred_false)],WF),WF)).
155 not_empty_sequence_wf(X,_WF) :- nonvar(X),!, not_empty_sequence(X).
156 not_empty_sequence_wf(X,WF) :-
157 (preferences:preference(use_smt_mode,true) -> not_empty_sequence(X)
158 ; get_enumeration_starting_wait_flag(not_empty_sequence_wf,WF,LWF),
159 not_empty_sequence_lwf(X,LWF)).
160
161 :- block not_empty_sequence_lwf(-,-).
162 not_empty_sequence_lwf(S,_) :- nonvar(S),!,not_empty_sequence(S).
163 not_empty_sequence_lwf([(int(1),_)|_],_).
164
165 :- assert_must_succeed(exhaustive_kernel_check(kernel_relations:is_sequence([(int(1),int(22))],[int(22)]))).
166 :- assert_must_succeed(kernel_relations:is_sequence(closure(['_zzzz_unit_tests'],[couple(integer,integer)],b(member(b(identifier('_zzzz_unit_tests'),couple(integer,integer),[generated]),b(value([(int(1),int(22))]),set(couple(integer,integer)),[])),pred,[])),[int(22)])).
167
168 :- assert_must_succeed(exhaustive_kernel_check(kernel_relations:is_sequence([(int(2),int(33)),(int(1),int(22))],[int(22),int(33),int(44)]))).
169 :- assert_must_succeed(exhaustive_kernel_fail_check(kernel_relations:is_sequence([(int(2),int(33)),(int(1),int(23))],[int(22),int(33),int(44)]))).
170 :- assert_must_succeed(exhaustive_kernel_fail_check(kernel_relations:is_sequence([(int(1),int(33)),(int(0),int(22))],[int(22),int(33),int(44)]))).
171 :- assert_must_succeed(exhaustive_kernel_fail_check(kernel_relations:is_sequence([(int(3),int(33)),(int(1),int(22))],[int(22),int(33),int(44)]))).
172 :- assert_must_succeed((is_sequence(R,global_set('Name')),R = [])).
173 :- assert_must_succeed((is_sequence(R,global_set('Name')),
174 R = [(int(2),fd(1,'Name')),(int(1),fd(2,'Name'))] )).
175 :- assert_must_succeed((is_sequence(R,global_set('Name')),
176 R = [(int(1),fd(2,'Name'))] )).
177 :- assert_must_succeed((is_sequence(R,global_set('Name')),
178 R = [(int(1),fd(1,'Name')),(int(2),fd(2,'Name'))] )).
179 :- assert_must_succeed((is_sequence(R,global_set('Name')),
180 R = [(int(2),fd(1,'Name')),(int(1),fd(1,'Name'))] )).
181 :- assert_must_succeed((is_sequence([(int(2),fd(1,'Name')),(int(1),fd(1,'Name'))],
182 global_set('Name')) )).
183 :- assert_must_succeed((is_sequence(R,[int(1),int(2)]),
184 R = [(int(2),int(2)),(int(1),int(1))] )).
185 :- assert_must_fail((is_sequence(R,[int(1),int(2)]),
186 R = [(int(2),int(2)),(int(3),int(1))] )).
187 :- assert_must_fail((is_sequence(R,[int(1),int(2)]),
188 R = [(int(2),int(2)),(int(1),int(3))] )).
189 :- assert_must_fail((is_sequence(R,global_set('Name')),
190 R = [(int(0),fd(1,'Name')),(int(1),fd(2,'Name'))] )).
191 :- assert_must_succeed((is_sequence(X,global_set('Name')),
192 (preferences:get_preference(randomise_enumeration_order,true) -> true
193 ; kernel_objects:enumerate_basic_type(X,seq(global('Name')))),
194 X = [(int(1),fd(1,'Name'))])). % can take a long time with RANDOMISE_ENUMERATION_ORDER
195
196 is_sequence(X,Type) :- init_wait_flags(WF,[is_sequence]),
197 is_sequence_wf(X,Type,WF),
198 ground_wait_flags(WF).
199
200 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:is_sequence_domain([int(1),int(2),int(3)],WF),WF)).
201 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:is_sequence_domain([int(1)],WF),WF)).
202 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:is_sequence_domain([],WF),WF)).
203 :- assert_must_succeed(exhaustive_kernel_fail_check_wfdet(kernel_relations:is_sequence_domain([int(0)],WF),WF)).
204 :- assert_must_succeed(exhaustive_kernel_fail_check_wfdet(kernel_relations:is_sequence_domain([int(2),int(3)],WF),WF)).
205 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:not_is_sequence_domain([int(2),int(3)],WF),WF)).
206 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:not_is_sequence_domain([int(0)],WF),WF)).
207 :- assert_must_succeed(exhaustive_kernel_fail_check_wfdet(kernel_relations:not_is_sequence_domain([int(1)],WF),WF)).
208 :- assert_must_succeed(exhaustive_kernel_fail_check_wfdet(kernel_relations:not_is_sequence_domain([],WF),WF)).
209
210 % check if a set is the domain of a sequence, i.e., an interval 1..n with n>=0
211 :- use_module(custom_explicit_sets,[construct_interval_closure/3]).
212 :- use_module(kernel_cardinality_attr,[finite_cardinality_as_int_wf/3]).
213 :- block is_sequence_domain(-,?).
214 is_sequence_domain(Domain,WF) :-
215 finite_cardinality_as_int_wf(Domain,int(Max),WF),
216 construct_interval_closure(1,Max,Interval), equal_object_wf(Domain,Interval,is_sequence_domain,WF).
217 :- block not_is_sequence_domain(-,?).
218 not_is_sequence_domain(Domain,WF) :-
219 finite_cardinality_as_int_wf(Domain,int(Max),WF),
220 construct_interval_closure(1,Max,Interval), not_equal_object_wf(Domain,Interval,WF).
221
222 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:is_sequence_wf([(int(1),pred_true)],
223 [pred_true,pred_false],WF),WF)).
224 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:is_sequence_wf([(int(1),pred_true),(int(2),pred_false),(int(3),pred_true)],
225 [pred_true,pred_false],WF),WF)).
226 :- assert_must_succeed((kernel_relations:is_sequence_wf([(int(X),R)],[pred_true],_WF),X==1, R==pred_true)).
227 :- assert_must_succeed((kernel_relations:is_sequence_wf([(int(X),R),(int(Y),R)],[pred_true],_WF),X=2,
228 (preferences:preference(use_clpfd_solver,true) -> Y==1 ; Y=1), R==pred_true)).
229
230 ?is_sequence_wf(Seq,Range,WF) :- is_sequence_wf_ex(Seq,Range,WF,_).
231 % is_sequence_wf_ex also returns expansion; if it was done
232 :- block is_sequence_wf_ex(-,?,?,?).
233 is_sequence_wf_ex(FF,Range,WF,FF) :-
234 nonvar(FF), FF = closure(_,_,_),
235 custom_explicit_sets:is_definitely_maximal_set(Range),
236 % we do not need the Range; this means we can match more closures (e.g., lambda)
237 custom_explicit_sets:dom_for_specific_closure(FF,FFDomain,function(_),WF),!,
238 is_sequence_domain(FFDomain,WF).
239 is_sequence_wf_ex(Seq,Range,WF,Res) :-
240 expand_and_convert_to_avl_set_warn(Seq,AER,is_sequence_wf_ex,'ARG : seq(?)',WF),!,
241 is_avl_sequence(AER),
242 ? is_avl_relation_over_range(AER,Range,WF),
243 custom_explicit_sets:construct_avl_set(AER,Res).
244 is_sequence_wf_ex(X,Type,WF,EX) :-
245 % try_ensure_seq_numbering(X,1),
246 expand_custom_set_to_list_wf(X,EX,_,is_sequence_wf_ex,WF),
247 ? is_sequence2(EX,[],Type,0,_MinSize,WF).
248
249 % will make this much faster x:seq(STRING) & card(x)=400 & 401:dom(x) (40 ms rather than > 2 secs)
250 % but this does not work -eval_file /Users/leuschel/git_root/prob_examples/examples/Setlog/prob-ttf/plavis-TransData_SP_21_simplified.prob
251 %:- block try_ensure_seq_numbering(-,?).
252 %try_ensure_seq_numbering([H|T],NextNr) :- var(H),!, print(nr(NextNr)),nl,
253 % H = (int(NextNr),_), N1 is NextNr+1,
254 % try_ensure_seq_numbering(T,N1).
255 %try_ensure_seq_numbering(_,_).
256
257 :- block is_sequence2(-,?,?,?,?,?).
258 is_sequence2([],IndexesSoFar,_Type,Size,MinSize,_WF) :- MinSize = Size,
259 contiguous_set_of_indexes(IndexesSoFar,Size).
260 /* not very good to do the checking at the end; can we move part of the checking earlier ? */
261 is_sequence2([(int(Idx),X)|Tail],IndexesSoFar,Type,Size,MinSize,WF) :-
262 less_than_direct(0,Idx), %is_index_greater_zero(Idx),
263 not_element_of_wf(int(Idx),IndexesSoFar,WF),
264 ? check_element_of_wf(X,Type,WF), S1 is Size+1,
265 clpfd_interface:clpfd_leq(Idx,MinSize,_Posted),
266 (var(Tail)
267 -> clpfd_interface:clpfd_domain(MinSize,Low,_Up), % TO DO: ensure that final size at least Low
268 (number(Low),Low>S1 -> Tail = [_|_] % TO DO: proper reification; what if MinSize gets constrained later
269 ; expand_seq_if_necessary(Idx,S1,Tail)) % the sequence must be longer; force it
270 ; true
271 ),
272 ? is_sequence2(Tail,[int(Idx)|IndexesSoFar],Type,S1,MinSize,WF).
273
274 :- block expand_seq_if_necessary(-,?,-).
275 expand_seq_if_necessary(MinSize,S1,Tail) :- % TO DO: proper reification on MinSize above
276 number(MinSize), MinSize>S1, (var(Tail) ; Tail==[]),
277 !,
278 Tail = [_|_].
279 expand_seq_if_necessary(_,_,_).
280
281 :- block contiguous_set_of_indexes(-,?).
282 contiguous_set_of_indexes([],_).
283 contiguous_set_of_indexes([H|T],Size) :- contiguous_set_of_indexes1(T,H,Size).
284
285 :- block contiguous_set_of_indexes1(-,?,?).
286 contiguous_set_of_indexes1([],int(1),_).
287 contiguous_set_of_indexes1([int(H2)|T],int(H1),Size) :- less_than_equal_direct(H1,Size),
288 less_than_equal_direct(H2,Size), less_than_equal_indexes(T,[H1,H2],Size).
289
290
291 less_than_equal_indexes([],All,_) :- clpfd_interface:clpfd_alldifferent(All).
292 less_than_equal_indexes([int(H)|T],All,Size) :- less_than_equal_direct(H,Size),less_than_equal_indexes(T,[H|All],Size).
293
294 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_is_sequence_wf([(int(1),int(6)),(int(2),int(7)),(int(4),int(7))],[int(7),int(6)],WF),WF)).
295 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_is_sequence_wf([(int(1),int(6)),(int(2),int(7)),(int(3),int(8))],[int(7),int(6)],WF),WF)).
296 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_is_sequence_wf([(int(1),int(6)),(int(2),int(7)),(int(1),int(7))],[int(7),int(6)],WF),WF)).
297 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_is_sequence_wf([(int(2),int(6)),(int(3),int(7)),(int(4),int(7))],[int(7),int(6)],WF),WF)).
298 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_is_sequence_wf([(int(1),int(6)),(int(0),int(7)),(int(2),int(7))],[int(7),int(6)],WF),WF)).
299 :- assert_must_succeed(exhaustive_kernel_fail_check(kernel_relations:not_is_sequence([(int(1),int(22))],[int(22)]))).
300 :- assert_must_succeed(exhaustive_kernel_fail_check(kernel_relations:not_is_sequence([(int(2),int(33)),(int(1),int(22))],[int(22),int(33),int(44)]))).
301 :- assert_must_succeed(exhaustive_kernel_check(kernel_relations:not_is_sequence([(int(2),int(33)),(int(1),int(23))],[int(22),int(33),int(44)]))).
302 :- assert_must_succeed(exhaustive_kernel_check(kernel_relations:not_is_sequence([(int(3),int(33)),(int(1),int(22))],[int(22),int(33),int(44)]))).
303 :- assert_must_fail((not_is_sequence(R,global_set('Name')),R = [])).
304 :- assert_must_fail((not_is_sequence(R,global_set('Name')),
305 R = [(int(2),fd(1,'Name')),(int(1),fd(2,'Name'))] )).
306 :- assert_must_fail((not_is_sequence(R,global_set('Name')),
307 R = [(int(1),fd(2,'Name'))] )).
308 :- assert_must_fail((not_is_sequence(R,global_set('Name')),
309 R = [(int(1),fd(1,'Name')),(int(2),fd(2,'Name'))] )).
310 :- assert_must_fail((not_is_sequence(R,global_set('Name')),
311 R = [(int(2),fd(1,'Name')),(int(1),fd(1,'Name'))] )).
312 :- assert_must_fail((not_is_sequence([(int(2),fd(1,'Name')),(int(1),fd(1,'Name'))],
313 global_set('Name')) )).
314 :- assert_must_fail((not_is_sequence(R,[int(1),int(2)]),
315 R = [(int(2),int(2)),(int(1),int(1))] )).
316 :- assert_must_succeed((not_is_sequence(R,[int(1),int(2)]),
317 R = [(int(2),int(2)),(int(3),int(1))] )).
318 :- assert_must_succeed((not_is_sequence(R,[int(1),int(2)]),
319 R = [(int(2),int(2)),(int(1),int(3))] )).
320
321
322 not_is_sequence(X,Type) :- init_wait_flags(WF,[not_is_sequence]),
323 not_is_sequence_wf(X,Type,WF),
324 ground_wait_flags(WF).
325
326 :- block not_is_sequence_wf(-,?,?).
327 not_is_sequence_wf(FF,Range,WF) :- nonvar(FF),custom_explicit_sets:is_definitely_maximal_set(Range),
328 % we do not need the Range; this means we can match more closures (e.g., lambda)
329 custom_explicit_sets:dom_for_specific_closure(FF,FFDomain,function(_),WF),!,
330 not_is_sequence_domain(FFDomain,WF).
331 not_is_sequence_wf(Seq,Range,WF) :-
332 expand_and_convert_to_avl_set_warn(Seq,AER,not_is_sequence_wf,'ARG /: seq(?)',WF),
333 !,
334 (is_avl_sequence(AER) -> is_not_avl_relation_over_range(AER,Range,WF)
335 ; true).
336 not_is_sequence_wf(X,Type,WF) :- expand_custom_set_to_list_wf(X,EX,_Done,not_is_sequence_wf,WF),
337 not_is_sequence2(EX,[],Type,WF).
338
339 :- block not_is_sequence2(-,?,?,?).
340 ?not_is_sequence2([],IndexesSoFar,_,_WF) :- not_contiguous_set_of_indexes(IndexesSoFar).
341 not_is_sequence2([(int(Idx),X)|Tail],IndexesSoFar,Type,WF) :-
342 membership_test_wf(IndexesSoFar,int(Idx),MemRes,WF),
343 not_is_sequence3(MemRes,Idx,X,Tail,IndexesSoFar,Type,WF).
344
345 :- block not_is_sequence3(-,?,?,?,?,?,?).
346 not_is_sequence3(pred_true,_Idx,_X,_Tail,_IndexesSoFar,_Type,_WF).
347 not_is_sequence3(pred_false,Idx,_X,_Tail,_IndexesSoFar,_Type,_WF) :- nonvar(Idx),Idx<1,!.
348 not_is_sequence3(pred_false,Idx,X,Tail,IndexesSoFar,Type,WF) :-
349 membership_test_wf(Type,X,MemRes,WF),
350 not_is_sequence4(MemRes,Idx,Tail,IndexesSoFar,Type,WF).
351
352 :- block not_is_sequence4(-,?,?,?,?,?).
353 not_is_sequence4(pred_false,_Idx,_Tail,_IndexesSoFar,_Type,_WF).
354 not_is_sequence4(pred_true,Idx,Tail,IndexesSoFar,Type,WF) :-
355 not_is_sequence2(Tail,[int(Idx)|IndexesSoFar],Type,WF).
356
357 not_contiguous_set_of_indexes(Indexes) :-
358 ? when(ground(Indexes),(sort(Indexes,Sorted),not_contiguous_set_of_indexes2(Sorted,1))).
359 not_contiguous_set_of_indexes2([int(N)|T],N1) :-
360 ? when(?=(N,N1),
361 ((N \= N1) ; (N=N1, N2 is N1+1, not_contiguous_set_of_indexes2(T,N2)))).
362
363
364
365
366
367 :- assert_must_succeed(exhaustive_kernel_fail_check(kernel_relations:not_is_non_empty_sequence([(int(1),int(22))],[int(22)]))).
368 :- assert_must_succeed(exhaustive_kernel_check(kernel_relations:not_is_non_empty_sequence([(int(1),int(2))],[int(22)]))).
369 :- assert_must_succeed((kernel_relations:not_is_non_empty_sequence(R,global_set('Name')),R = [])).
370 :- assert_must_fail((kernel_relations:not_is_non_empty_sequence(R,global_set('Name')),
371 R = [(int(2),fd(1,'Name')),(int(1),fd(2,'Name'))] )).
372 :- assert_must_succeed((kernel_relations:not_is_non_empty_sequence(R,global_set('Name')),
373 R = [(int(2),fd(1,'Name')),(int(4),fd(2,'Name'))] )).
374 :- assert_must_fail((kernel_relations:not_is_non_empty_sequence(R,global_set('Name')),
375 R = [(int(1),fd(1,'Name')),(int(2),fd(1,'Name'))] )).
376 :- assert_must_succeed((kernel_relations:not_is_non_empty_sequence(R,[int(1),int(2)]),
377 R = [(int(1),int(2)),(int(2),int(3))] )).
378
379 % S /: seq1(T)
380 not_is_non_empty_sequence(S,T) :- not_is_non_empty_sequence_wf(S,T,no_wf_available).
381
382 :- block not_is_non_empty_sequence_wf(-,?,?).
383 not_is_non_empty_sequence_wf([],_,_WF) :- !.
384 not_is_non_empty_sequence_wf(X,Type,WF) :-
385 empty_sequence_wf(X,WF) ; not_is_sequence_wf(X,Type,WF).
386
387
388
389 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:injective_sequence_wf([(int(1),int(22))],[int(22)],WF),WF)).
390 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:injective_sequence_wf([(int(2),int(33)),(int(1),int(22))],[int(22),int(33),int(44)],WF),WF)).
391 :- assert_must_succeed(exhaustive_kernel_fail_check_wfdet(kernel_relations:injective_sequence_wf([(int(2),int(33)),(int(1),int(23))],[int(22),int(33),int(44)],WF),WF)).
392 :- assert_must_succeed(exhaustive_kernel_fail_check_wfdet(kernel_relations:injective_sequence_wf([(int(2),int(22)),(int(1),int(22))],[int(22),int(33),int(44)],WF),WF)).
393 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:injective_sequence_wf([],global_set('Name'),WF),WF)).
394 :- assert_must_succeed((kernel_relations:injective_sequence_wf(R,global_set('Name'),WF),
395 kernel_waitflags:ground_det_wait_flag(WF), R = [(int(2),fd(1,'Name')),(int(1),fd(2,'Name'))] )).
396 :- assert_must_succeed((kernel_relations:injective_sequence_wf(R,global_set('Name'),WF),
397 ground_det_wait_flag(WF), R = [(int(1),fd(2,'Name'))] )).
398 :- assert_must_succeed((kernel_relations:injective_sequence_wf(R,global_set('Name'),WF),
399 ground_det_wait_flag(WF), R = [(int(1),fd(1,'Name')),(int(2),fd(2,'Name'))] )).
400 :- assert_must_fail((kernel_relations:injective_sequence_wf(R,global_set('Name'),WF),
401 ground_det_wait_flag(WF), R = [(int(2),fd(1,'Name')),(int(1),fd(1,'Name'))] )).
402 :- assert_must_succeed(exhaustive_kernel_fail_check_wf(kernel_relations:injective_sequence_wf([(int(2),fd(1,'Name')),(int(1),fd(1,'Name'))],
403 global_set('Name'),WF),WF) ).
404 :- assert_must_succeed((kernel_relations:injective_sequence_wf(R,[int(1),int(2)],WF),
405 ground_det_wait_flag(WF),R = [(int(2),int(2)),(int(1),int(1))] )).
406 :- assert_must_fail((kernel_relations:injective_sequence_wf(R,[int(1),int(2)],WF),
407 ground_det_wait_flag(WF),R = [(int(2),int(2)),(int(3),int(1))] )).
408 :- assert_must_fail((kernel_relations:injective_sequence_wf(R,[int(1),int(2)],WF),
409 ground_det_wait_flag(WF), R = [(int(2),int(2)),(int(1),int(3))] )).
410
411
412
413 :- block injective_sequence_wf(-,-,?).
414 injective_sequence_wf(Seq,Type,WF) :- /* corresponds to iseq */
415 nonvar(Seq),
416 %expand_and_convert_to_avl_set_warn(Seq,AER,injective_sequence_wf_aux,'ARG : iseq(?)',WF),
417 Seq=avl_set(AER),
418 !,
419 is_avl_sequence(AER),
420 is_injective_avl_relation(AER,_ExactRange), % Should we check _ExactRange <: Type ??
421 ? is_avl_relation_over_range(AER,Type,WF).
422 injective_sequence_wf(Seq,Type,WF) :-
423 cardinality_as_int_for_wf(Type,MaxCard),
424 custom_explicit_sets:blocking_nr_iseq(MaxCard,ISeqSize),
425 block_get_wait_flag(ISeqSize,injective_sequence_wf,WF,LWF),
426 injective_sequence_wf_aux(Seq,Type,MaxCard,WF,LWF).
427
428 :- block injective_sequence_wf_aux(-,?,?,?,-).
429 injective_sequence_wf_aux(Seq,Type,_,WF,_) :- /* corresponds to iseq */
430 nonvar(Seq),
431 expand_and_convert_to_avl_set_warn(Seq,AER,injective_sequence_wf_aux,'ARG : iseq(?)',WF),
432 !,
433 is_avl_sequence(AER),
434 is_injective_avl_relation(AER,_ExactRange), % Should we check _ExactRange <: Type ??
435 is_avl_relation_over_range(AER,Type,WF).
436 injective_sequence_wf_aux(Seq,Type,MaxCard,WF,LWF) :-
437 expand_custom_set_to_list_wf(Seq,ESeq,_,injective_sequence_wf,WF),
438 is_sequence_wf(ESeq,Type,WF),
439 ? injective_sequence2(ESeq,0,[],Type,WF,MaxCard,LWF).
440
441 :- block injective_sequence2(-,?,?,?,?,?,-),injective_sequence2(-,?,?,?,?,-,?).
442 injective_sequence2([],_,_,_Type,_WF,_MaxCard,_LWF).
443 injective_sequence2([(int(Index),X)|Tail],CardSoFar,SoFar,Type,WF,MaxCard,LWF) :-
444 ? (number(MaxCard) -> CardSoFar< MaxCard, %less_than_equal_direct(Index,MaxCard) % does not enumerate index
445 in_nat_range_wf(int(Index),int(0),int(MaxCard),WF) % ensures the index gets enumerated, see test 1914, x:iseq(50001..50002) & y:1..100005 & SIGMA(yy).(yy:dom(x)|x(yy)) = y & y>50002
446 ; true),
447 check_element_of_wf(X,Type,WF),
448 not_element_of_wf(X,SoFar,WF),
449 add_new_element_wf(X,SoFar,SoFar2,WF),
450 C1 is CardSoFar+1,
451 (C1 == MaxCard -> Tail=[] ; true),
452 ? injective_sequence2(Tail,C1,SoFar2,Type,WF,MaxCard,LWF).
453
454
455 :- assert_must_succeed(exhaustive_kernel_fail_check_wf(kernel_relations:not_injective_sequence([(int(1),int(22))],[int(22)],WF),WF)).
456 :- assert_must_succeed(exhaustive_kernel_fail_check_wf(kernel_relations:not_injective_sequence([(int(2),int(33)),(int(1),int(22))],[int(22),int(33),int(44)],WF),WF)).
457 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:not_injective_sequence([(int(2),int(33)),(int(1),int(23))],[int(22),int(33),int(44)],WF),WF)).
458 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:not_injective_sequence([(int(2),int(22)),(int(1),int(22))],[int(22),int(33),int(44)],WF),WF)).
459 :- assert_must_fail((kernel_relations:not_injective_sequence(R,global_set('Name'),_WF),R = [])).
460 :- assert_must_fail((kernel_relations:not_injective_sequence(R,global_set('Name'),WF),
461 ground_det_wait_flag(WF),
462 R = [(int(2),fd(1,'Name')),(int(1),fd(2,'Name'))] )).
463 :- assert_must_fail((kernel_relations:not_injective_sequence(R,global_set('Name'),WF),
464 ground_det_wait_flag(WF),
465 R = [(int(1),fd(2,'Name'))] )).
466 :- assert_must_fail((kernel_relations:not_injective_sequence(R,global_set('Name'),WF),
467 ground_det_wait_flag(WF),
468 R = [(int(1),fd(1,'Name')),(int(2),fd(2,'Name'))] )).
469 :- assert_must_fail((kernel_relations:not_injective_sequence(R,[int(1),int(2)],WF),
470 ground_det_wait_flag(WF),
471 R = [(int(2),int(2)),(int(1),int(1))] )).
472 :- assert_must_succeed((kernel_relations:not_injective_sequence(R,global_set('Name'),WF),
473 ground_det_wait_flag(WF),
474 R = [(int(2),fd(1,'Name')),(int(1),fd(1,'Name'))] )).
475 :- assert_must_succeed((kernel_relations:not_injective_sequence([(int(2),fd(1,'Name')),(int(1),fd(1,'Name'))],
476 global_set('Name'),WF),
477 ground_det_wait_flag(WF) )).
478 :- assert_must_succeed((kernel_relations:not_injective_sequence(R,[int(1),int(2)],WF),
479 ground_det_wait_flag(WF),
480 R = [(int(2),int(2)),(int(3),int(1))] )).
481 :- assert_must_succeed((kernel_relations:not_injective_sequence(R,[int(1),int(2)],WF),
482 ground_det_wait_flag(WF),
483 R = [(int(2),int(2)),(int(1),int(3))] )).
484 :- block not_injective_sequence(-,?,?), not_injective_sequence(?,-,?).
485 not_injective_sequence(Seq,_,_) :- Seq==[],!,fail.
486 not_injective_sequence(Seq,Type,WF) :- nonvar(Seq),
487 expand_and_convert_to_avl_set_warn(Seq,AER,not_injective_sequence,'ARG /: iseq(?)',WF),!,
488 (\+ is_avl_sequence(AER) -> true
489 ; is_injective_avl_relation(AER,ExactRange) -> not_subset_of_wf(ExactRange,Type,WF)
490 ; true).
491 not_injective_sequence(Seq,Type,WF) :- /* corresponds to Iseq */
492 %get_middle_wait_flag(not_injective_sequence,WF,LWF),
493 ground_value_check(Seq,SV),
494 not_injective_sequence1(Seq,Type,WF,SV).
495 :- block not_injective_sequence1(?,?,?,-).
496 not_injective_sequence1(Seq,Type,WF,_) :-
497 expand_custom_set_to_list_wf(Seq,ESeq,_,not_injective_sequence1,WF),
498 (not_is_sequence_wf(ESeq,Type,WF)
499 ; /* CHOICE POINT !! */
500 (is_sequence_wf(ESeq,Type,WF),not_injective_sequence2(ESeq,[],Type,WF))).
501 :- block not_injective_sequence2(-,?,?,?).
502 not_injective_sequence2([(int(_),X)|Tail],SoFar,Type,WF) :-
503 membership_test_wf(SoFar,X,MemRes,WF),
504 not_injective_sequence3(MemRes,X,Tail,SoFar,Type,WF).
505
506 :- block not_injective_sequence3(-,?,?,?,?,?).
507 not_injective_sequence3(pred_true,_X,_Tail,_SoFar,_Type,_WF).
508 not_injective_sequence3(pred_false,X,Tail,SoFar,Type,WF) :-
509 add_new_element_wf(X,SoFar,SoFar2,WF),
510 not_injective_sequence2(Tail,SoFar2,Type,WF).
511
512 :- assert_must_succeed(exhaustive_kernel_fail_check_wf(kernel_relations:not_non_empty_injective_sequence([(int(1),int(22))],[int(22)],WF),WF)).
513 :- assert_must_succeed(exhaustive_kernel_fail_check_wf(kernel_relations:not_non_empty_injective_sequence([(int(2),int(33)),(int(1),int(22))],[int(22),int(33),int(44)],WF),WF)).
514 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:not_non_empty_injective_sequence([(int(2),int(33)),(int(1),int(23))],[int(22),int(33),int(44)],WF),WF)).
515 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:not_non_empty_injective_sequence([(int(2),int(33)),(int(1),int(33))],[int(44),int(33),int(22)],WF),WF)).
516 :- assert_must_succeed((kernel_relations:not_non_empty_injective_sequence(R,global_set('Name'),WF),
517 ground_det_wait_flag(WF), R = [])).
518 :- assert_must_fail((kernel_relations:not_non_empty_injective_sequence(R,global_set('Name'),WF),
519 ground_det_wait_flag(WF), R = [(int(1),fd(1,'Name')),(int(2),fd(2,'Name'))] )).
520 :- assert_must_succeed((kernel_relations:not_non_empty_injective_sequence(R,[int(1),int(2)],WF),
521 ground_det_wait_flag(WF), R = [(int(2),int(2)),(int(1),int(3))] )).
522
523 :- block not_non_empty_injective_sequence(-,?,?).
524 not_non_empty_injective_sequence([],_Type,_WF) :- !.
525 not_non_empty_injective_sequence(X,Type,WF) :-
526 empty_sequence_wf(X,WF) ; not_injective_sequence(X,Type,WF).
527
528
529 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:injective_non_empty_sequence([(int(1),int(22))],[int(22)],WF),WF)).
530 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:injective_non_empty_sequence([(int(2),int(33)),(int(1),int(22))],[int(22),int(33),int(44)],WF),WF)).
531 :- assert_must_succeed(exhaustive_kernel_fail_check_wf(kernel_relations:injective_non_empty_sequence([(int(2),int(33)),(int(1),int(23))],[int(22),int(33),int(44)],WF),WF)).
532 :- assert_must_succeed(exhaustive_kernel_fail_check_wf(kernel_relations:injective_non_empty_sequence([(int(2),int(44)),(int(1),int(44))],[int(22),int(33),int(44)],WF),WF)).
533 :- assert_must_fail((kernel_relations:injective_non_empty_sequence(R,global_set('Name'),WF),
534 ground_det_wait_flag(WF),R = [])).
535 :- assert_must_succeed((kernel_relations:injective_non_empty_sequence(R,global_set('Name'),WF),
536 ground_det_wait_flag(WF),R = [(int(1),fd(1,'Name')),(int(2),fd(2,'Name'))] )).
537 :- block injective_non_empty_sequence(-,-,?). /* corresponds to iseq1 */
538 injective_non_empty_sequence(A,Type,WF) :- nonvar(A),A=avl_set(AS), !,
539 injective_sequence_wf(avl_set(AS),Type,WF),is_non_empty_explicit_set_wf(avl_set(AS),WF).
540 injective_non_empty_sequence(Seq,Type,WF) :-
541 ((nonvar(Seq),Seq=closure(_,_,_)) -> try_expand_custom_set_wf(Seq,ESeq,injective_non_empty_sequence,WF) ; ESeq=Seq),
542 injective_sequence_wf(ESeq,Type,WF),not_empty_sequence_wf(ESeq,WF).
543
544 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:finite_non_empty_sequence([(int(1),int(22))],[int(22)],WF),WF)).
545 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:finite_non_empty_sequence([(int(1),int(33)),(int(2),int(33))],[int(22),int(33)],WF),WF)).
546 :- assert_must_fail((kernel_relations:finite_non_empty_sequence(R,global_set('Name'),WF),ground_det_wait_flag(WF),ground_det_wait_flag(WF),R = [])).
547 :- assert_must_succeed((kernel_relations:finite_non_empty_sequence(R,global_set('Name'),WF),
548 ground_det_wait_flag(WF),R = [(int(2),fd(1,'Name')),(int(1),fd(1,'Name'))] )).
549 :- block finite_non_empty_sequence(-,?,?).
550 finite_non_empty_sequence(Seq,Type,WF) :- /* corresponds to Seq1 */
551 ? is_sequence_wf_ex(Seq,Type,WF,ESeq),
552 (var(ESeq) -> not_empty_sequence_wf(Seq,WF) ; not_empty_sequence_wf(ESeq,WF)).
553
554 % reification of seq1(.)
555 :- block test_finite_non_empty_sequence(-,?,-,?).
556 test_finite_non_empty_sequence(Seq,_Type,Res,_WF) :-
557 Seq == [],!, Res=pred_false.
558 test_finite_non_empty_sequence(Seq,Type,Res,WF) :- var(Res),!,
559 ground_value_check(Seq,GrSeq),get_wait_flag1(WF,WF1),
560 test_finite_non_empty_sequence2(Res,Seq,Type,GrSeq,WF1,WF). % will trigger and enumerate Res below
561 % Note: we cannot rely on Res being enumerated; e.g., in case a WD error occurs
562 test_finite_non_empty_sequence(Seq,Type,Res,WF) :- get_wait_flag1(WF,WF1),
563 test_finite_non_empty_sequence2(Res,Seq,Type,_,WF1, WF).
564
565 % TODO: improve to incrementally check if something is a sequence
566 :- block test_finite_non_empty_sequence2(-,?,?,-,?,?),
567 test_finite_non_empty_sequence2(-,?,?,?,-,?).
568 test_finite_non_empty_sequence2(pred_true,Seq,Type,_,_,WF) :-
569 finite_non_empty_sequence(Seq,Type,WF).
570 test_finite_non_empty_sequence2(pred_false,Seq,Type,_,_,WF) :-
571 not_is_non_empty_sequence_wf(Seq,Type,WF).
572
573
574
575 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:permutation_sequence_wf([(int(1),int(22))],[int(22)],WF),WF)).
576 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:permutation_sequence_wf([(int(2),int(33)),(int(1),int(22))],[int(22),int(33)],WF),WF)).
577 :- assert_must_succeed(exhaustive_kernel_fail_check_wf(kernel_relations:permutation_sequence_wf([(int(2),int(33)),(int(1),int(23))],[int(23),int(33),int(44)],WF),WF)).
578 :- assert_must_succeed(exhaustive_kernel_fail_check_wf(kernel_relations:permutation_sequence_wf([(int(2),int(44)),(int(1),int(44))],[int(44)],WF),WF)).
579 :- assert_must_succeed((kernel_waitflags:init_wait_flags(WF),kernel_relations:permutation_sequence_wf(R,[int(1)],WF),
580 ground_det_wait_flag(WF),R = [(int(1),int(1))] )).
581 :- assert_must_succeed((kernel_waitflags:init_wait_flags(WF),kernel_relations:permutation_sequence_wf(R,[int(1),int(2)],WF),
582 ground_det_wait_flag(WF),R = [(int(1),int(1)),(int(2),int(2))] )).
583 :- assert_must_succeed((kernel_relations:permutation_sequence_wf(R,[int(1),int(2)],WF),
584 ground_det_wait_flag(WF),R = [(int(1),int(2)),(int(2),int(1))] )).
585 :- assert_must_succeed((kernel_waitflags:init_wait_flags(WF),kernel_relations:permutation_sequence_wf(R,[pred_true /* bool_true */,pred_false /* bool_false */],WF), kernel_waitflags:ground_wait_flags(WF), nonvar(R),
586 R = [(int(1),pred_false /* bool_false */),(int(2),pred_true /* bool_true */)] )).
587 :- assert_must_fail((kernel_waitflags:init_wait_flags(WF),kernel_relations:permutation_sequence_wf(R,[int(1)],WF),
588 ground_det_wait_flag(WF),R = [(int(1),int(1)),(int(2),int(1))] )).
589 :- assert_must_fail((kernel_waitflags:init_wait_flags(WF),kernel_relations:permutation_sequence_wf(R,global_set('Name'),WF),ground_det_wait_flag(WF),R = [])).
590 :- assert_must_fail((kernel_waitflags:init_wait_flags(WF),kernel_relations:permutation_sequence_wf(R,global_set('Name'),WF),
591 ground_det_wait_flag(WF),R = [(int(1),fd(1,'Name')),(int(2),fd(2,'Name'))] )).
592 :- assert_must_succeed((kernel_relations:permutation_sequence_wf(R,global_set('Name'),WF),
593 ground_det_wait_flag(WF),
594 kernel_objects:equal_object(R,[(int(1),fd(1,'Name')),(int(3),fd(2,'Name')),(int(2),fd(3,'Name'))]) )).
595 :- assert_must_fail((kernel_waitflags:init_wait_flags(WF),kernel_relations:permutation_sequence_wf(R,[int(1),int(2)],WF),
596 ground_det_wait_flag(WF),R = [(int(1),int(1)),(int(2),int(3))] )).
597 :- assert_must_fail((kernel_waitflags:init_wait_flags(WF),kernel_relations:permutation_sequence_wf(R,global_set('Name'),WF),
598 ground_det_wait_flag(WF),R = [(int(2),fd(1,'Name')),(int(1),fd(1,'Name'))] )).
599 :- assert_must_succeed((kernel_waitflags:init_wait_flags(WF),kernel_relations:permutation_sequence_wf(R,[int(4),int(3),int(2),int(1)],WF),
600 ground_det_wait_flag(WF), R=[(int(1),int(1)),(int(2),int(2)),(int(3),int(3)),(int(4),int(4))])).
601
602 :- block permutation_sequence_wf(-,-,?).
603 permutation_sequence_wf(SeqFF,Type,WF) :- nonvar(SeqFF),
604 custom_explicit_sets:dom_range_for_specific_closure(SeqFF,FFDomain,FFRange,function(bijection),WF),!,
605 equal_object_wf(FFRange,Type,permutation_sequence_wf_1,WF),
606 is_sequence_domain(FFDomain,WF).
607 permutation_sequence_wf(Seq,Type,WF) :-
608 expand_and_convert_to_avl_set_warn(Seq,AER,permutation_sequence_wf,'ARG : perm(?)',WF),!,
609 is_avl_sequence(AER),
610 is_injective_avl_relation(AER,Range),
611 kernel_objects:equal_object_wf(Range,Type,permutation_sequence_wf_2,WF).
612 permutation_sequence_wf(Seq,Type,WF) :-
613 try_expand_custom_set_wf(Seq,ESeq,permutation_sequence_wf,WF),
614 cardinality_as_int_wf(Type,int(Card),WF),
615 when(nonvar(Card), (setup_sequence_wf(Card,SkelSeq,perm,WF),
616 CardGround=true,
617 kernel_objects:equal_object_wf(SkelSeq,ESeq,permutation_sequence_wf_3,WF))),
618 %injective_sequence_wf(ESeq,Type,WF,LWF),
619 surjective_iseq_0(SkelSeq,ESeq,Type,WF,Card,CardGround).
620 % quick_all_different_range(ESeq,[],Type,WF). % see all_different_wf
621
622 :- block surjective_iseq_0(-,-,?,?,?,-).
623 surjective_iseq_0(SkelSeq,_ESeq,Type,WF,_Card,Ground) :-
624 nonvar(Ground),
625 nonvar(SkelSeq),
626 preference(use_clpfd_solver,true), % try and use an optimized version calling global_cardinality in CLPFD module
627 ? get_global_cardinality_list(Type,YType,GCL,_,WF),
628 % this dramatically reduces runtime for NQueens40_perm; maybe we should do this only when necessary, i.e., when surjective_iseq blocks on PreviousRemoveDone
629 % check why it slows down SortByPermutation_v2
630 !,
631 global_cardinality_range(SkelSeq,[],YType,GCL,WF).
632 surjective_iseq_0(_,ESeq,Type,WF,Card,_) :-
633 %quick_propagate_range(ESeq,Type,WF), % ensure that we propagate type information to all elements; p:perm(5..20) & p(10)=21 will fail straightaway (surjective_iseq will block);
634 % but this slows down EulerWay.mch ; maybe because it sets up enumerators ? TO DO: investigate
635 surjective_iseq(ESeq,Type,WF,Card).
636
637 %:- use_module(clpfd_interface,[clpfd_alldifferent/1]).
638 % collect range and then call CLPFD global_cardinality using GCL (Global Cardinality List Ki-Vi)
639 :- use_module(library(clpfd), [global_cardinality/3]).
640 :- block global_cardinality_range(-,?,?,?,?).
641 global_cardinality_range([],Acc,_Type,GCL,WF) :-
642 global_cardinality(Acc,GCL,[consistency(value)]),
643 add_fd_variables_for_labeling(Acc,WF). % this is needed for efficiency for NQueens40_perm !!
644 global_cardinality_range([(_,Y)|T],Acc,Type,GCL,WF) :-
645 get_simple_fd_value(Type,Y,FDYVAL),
646 global_cardinality_range(T,[FDYVAL|Acc],Type,GCL,WF).
647
648
649 :- use_module(library(avl), [avl_domain/2]).
650 :- use_module(b_global_sets,[all_elements_of_type_wf/3,b_integer_set/1]).
651 % try and convert a B set into a list suitable for calling clpfd:global_cardinality
652 % get_global_cardinality_list(avl_set(A) % TO DO: extend to integer_lists
653 get_global_cardinality_list(global_set(G),Type,GCL,list,WF) :- !,
654 all_elements_of_type_wf(G,Values,WF), % can only work for finite sets, not for STRING, NATURAL, REAL, ...
655 (b_integer_set(G) -> Type=integer ; Type=global(G)),
656 findall(X-1,(get_simple_fd_value(Type,VV,X),member(VV,Values)),GCL).
657 get_global_cardinality_list(avl_set(A),Type,GCL,list,_WF) :- !,
658 A = node(TopValue,_True,_,_,_),
659 ? get_simple_fd_value(Type,TopValue,_), % we have CLPFD values
660 avl_domain(A,Values),
661 findall(X-1,(get_simple_fd_value(Type,VV,X),member(VV,Values)),GCL).
662 get_global_cardinality_list(Set,integer,GCL,interval(L1,U1),_WF) :- nonvar(Set),
663 is_interval_closure_or_integerset(Set,L1,U1), number(L1),number(U1),
664 global_cardinality_list_interval(L1,U1,GCL).
665
666 global_cardinality_list_interval(From,To,[]) :- From>To, !.
667 global_cardinality_list_interval(From,To,[From-1|T]) :-
668 F1 is From+1, global_cardinality_list_interval(F1,To,T).
669
670 %try_get_simple_fd_value(Type,V,Val) :- nonvar(V),get_simple_fd_value(Type,V,Val).
671 get_simple_fd_value(integer,int(X),X).
672 get_simple_fd_value(global(T),fd(X,T),X).
673 % try_get_simple_fd_value(pred_false,0). try_get_simple_fd_value(pred_true,1). ??
674 % TO DO: maybe also treat pairs ? but we need complete values; see module clpfd_lists !
675
676 setup_sequence_wf(0,R,_,_) :- !, R=[].
677 setup_sequence_wf(Card,_,PP,WF) :- \+ number(Card), !,
678 add_error_wf(infinite_sequence,'Cannot generate infinite sequence for', PP,unknown,WF). % triggered in test 1979
679 setup_sequence_wf(Card,[(int(1),_)|T] ,_PP,_WF) :- Card>0, C1 is Card-1,
680 setup_sequence(C1,T,2).
681 setup_sequence(0,R,_) :- !, R=[].
682 setup_sequence(Card,[(int(Nr),_)|T], Nr ) :- Card>0, C1 is Card-1,
683 N1 is Nr+1,
684 setup_sequence(C1,T,N1).
685
686 :- block surjective_iseq(?,?,?,-),surjective_iseq(?,-,?,?), surjective_iseq(-,?,?,?).
687 surjective_iseq(avl_set(S),Type,WF,Done) :-
688 expand_custom_set_wf(avl_set(S),ES,surjective_iseq,WF),
689 surjective_iseq(ES,Type,WF,Done).
690 surjective_iseq(closure(P,T,B),Type,WF,Done) :-
691 expand_custom_set_wf(closure(P,T,B),ES,surjective_iseq,WF),
692 surjective_iseq(ES,Type,WF,Done).
693 % no case for global_set: cannot be a relation
694 surjective_iseq([],T,WF,_) :- empty_set_wf(T,WF).
695 surjective_iseq([(int(_Nr),El)|Tail],Type,WF,_PreviousRemoveDone) :-
696 ? remove_element_wf(El,Type,NType,WF,Done),
697 surjective_iseq(Tail,NType,WF,Done).
698 :- assert_must_succeed(exhaustive_kernel_fail_check_wf(kernel_relations:not_permutation_sequence([(int(1),int(22))],[int(22)],WF),WF)).
699 :- assert_must_succeed(exhaustive_kernel_fail_check_wf(kernel_relations:not_permutation_sequence([(int(2),int(33)),(int(1),int(22))],[int(22),int(33)],WF),WF)).
700 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:not_permutation_sequence([(int(2),int(33)),(int(1),int(23))],[int(23),int(33),int(44)],WF),WF)).
701 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:not_permutation_sequence([(int(2),int(44)),(int(1),int(44))],[int(44)],WF),WF)).
702 :- assert_must_fail((kernel_relations:not_permutation_sequence(R,[int(1)],WF),
703 ground_det_wait_flag(WF),R = [(int(1),int(1))] )).
704 :- assert_must_fail((kernel_relations:not_permutation_sequence(R,[int(1),int(2)],WF),
705 ground_det_wait_flag(WF),R = [(int(2),int(2)),(int(1),int(1))] )).
706 :- assert_must_fail((kernel_relations:not_permutation_sequence(R,[int(1),int(2)],WF),
707 ground_det_wait_flag(WF),R = [(int(1),int(2)),(int(2),int(1))] )).
708 :- assert_must_fail((kernel_relations:not_permutation_sequence(R,global_set('Name'),WF),
709 ground_det_wait_flag(WF), R = [(int(1),fd(1,'Name')),(int(3),fd(2,'Name')),(int(2),fd(3,'Name'))] )).
710 :- assert_must_succeed((kernel_relations:not_permutation_sequence(R,[int(1)],WF),
711 ground_det_wait_flag(WF),R = [(int(1),int(1)),(int(2),int(1))] )).
712 :- assert_must_succeed((kernel_relations:not_permutation_sequence(R,global_set('Name'),_WF),R = [])).
713 :- assert_must_succeed((kernel_relations:not_permutation_sequence(R,global_set('Name'),WF),
714 ground_det_wait_flag(WF),R = [(int(1),fd(1,'Name')),(int(2),fd(2,'Name'))] )).
715 :- assert_must_succeed((kernel_relations:not_permutation_sequence(R,[int(1),int(2)],WF),
716 ground_det_wait_flag(WF),R = [(int(1),int(1)),(int(2),int(3))] )).
717 :- assert_must_succeed((kernel_relations:not_permutation_sequence(R,global_set('Name'),WF),
718 ground_det_wait_flag(WF),R = [(int(2),fd(1,'Name')),(int(1),fd(1,'Name'))] )).
719 :- block not_permutation_sequence(-,?,?).
720 not_permutation_sequence(SeqFF,Type,WF) :- nonvar(SeqFF),
721 custom_explicit_sets:dom_range_for_specific_closure(SeqFF,FFDomain,FFRange,function(bijection),WF),!,
722 equality_objects_wf(FFRange,Type,Result,WF),
723 when(nonvar(Result),(Result=pred_false -> true ; not_is_sequence_domain(FFDomain,WF))).
724 not_permutation_sequence(Seq,Type,WF) :-
725 ground_value_check(Seq,SV),
726 not_permutation_sequence1(Seq,Type,SV,WF).
727 :- block not_permutation_sequence1(?,-,?,?), not_permutation_sequence1(?,?,-,?).
728 not_permutation_sequence1(avl_set(A),Type,_,WF) :- is_ground_set(Type), !, Seq=avl_set(A),
729 if(not_injective_sequence(Seq,Type,WF),
730 true, % no backtracking required; we could even use regular if with ->
731 not_surj_avl(Seq,Type,WF)
732 ).
733 not_permutation_sequence1(avl_set(A),Type,_,WF) :- !, Seq=avl_set(A),
734 (not_injective_sequence(Seq,Type,WF)
735 ; injective_sequence_wf(Seq,Type,WF),
736 not_surj_avl(Seq,Type,WF)).
737 not_permutation_sequence1(Seq,Type,_,WF) :-
738 expand_custom_set_to_list_wf(Seq,ESeq,Done,not_permutation_sequence1,WF),
739 not_permutation_sequence2(ESeq,Type,WF,Done).
740
741 not_surj_avl(Seq,Type,WF) :- range_wf(Seq,Range,WF),
742 not_equal_object_wf(Range,Type,WF). % TO DO: one could even just check cardinality as Seq is inj
743 %expand_custom_set_to_list_wf(Seq,ESeq,_,not_permutation_sequence1,WF),
744 % not_surjective_seq(ESeq,Type,WF).
745 % check if it is a ground set that cannot be instantiated
746 is_ground_set(V) :- var(V),!,fail.
747 is_ground_set(avl_set(_)).
748 is_ground_set(global_set(_)).
749 is_ground_set([]).
750
751 % here we could have a choice point in WF0
752 :- block not_permutation_sequence2(?,?,?,-).
753 not_permutation_sequence2(Seq,Type,WF,_) :- not_injective_sequence(Seq,Type,WF).
754 not_permutation_sequence2(Seq,Type,WF,_) :-
755 injective_sequence_wf(Seq,Type,WF), not_surjective_seq(Seq,Type,WF).
756
757 :- block not_surjective_seq(-,?,?).
758 not_surjective_seq([],T,WF) :- not_empty_set_wf(T,WF).
759 not_surjective_seq([(int(_),El)|Tail],Type,WF) :-
760 delete_element_wf(El,Type,NType,WF),
761 not_surjective_seq(Tail,NType,WF).
762
763 :- assert_must_succeed(exhaustive_kernel_check(kernel_relations:size_of_sequence([(int(1),int(22))],int(1),_WF))).
764 :- assert_must_succeed(exhaustive_kernel_check(kernel_relations:size_of_sequence([(int(2),int(22)),(int(1),int(22))],int(2),_WF))).
765 :- assert_must_succeed(exhaustive_kernel_fail_check(kernel_relations:size_of_sequence([(int(2),int(22)),(int(1),int(22))],int(3),_WF))).
766 :- assert_must_succeed(exhaustive_kernel_check(kernel_relations:size_of_sequence([(int(2),int(22)),(int(1),int(22)),(int(3),int(33))],int(3),_WF))).
767 :- assert_must_succeed((kernel_relations:size_of_sequence(X,R,_WF),
768 X = [(int(1),int(2)),(int(2),int(1))],
769 R = int(2))).
770 :- assert_must_succeed((preferences:preference(use_clpfd_solver,false) -> true
771 ; preferences:preference(use_smt_mode,false) -> true
772 ; kernel_relations:size_of_sequence(X,R,_WF), R=int(RI),
773 clpfd_interface:clpfd_geq2(RI,2,_), nonvar(X), X = [(I1,_),(I2,_)|T],
774 I1==int(1), I2==int(2), T=[], RI==2 )).
775 :- assert_must_succeed((kernel_relations:size_of_sequence(X,R,_WF),X = [(int(1),_),(int(2),_)],R = int(2))).
776 :- assert_must_succeed((kernel_relations:size_of_sequence(X,_R,_WF),X =[(int(1),_),(int(2),_)] )).
777 :- assert_must_succeed_any((kernel_relations:size_of_sequence(X,int(2),_WF),nonvar(X),X=[_|Y],nonvar(Y),Y=[_|Z],Z==[])).
778 :- assert_must_succeed((kernel_relations:size_of_sequence([],int(0),_WF))).
779 :- assert_must_succeed((kernel_relations:size_of_sequence([],int(0),_WF))).
780 :- assert_must_succeed((kernel_relations:size_of_sequence([(int(1),int(4))],int(1),_WF))).
781 :- assert_must_succeed((kernel_relations:size_of_sequence([],_,_WF))).
782 :- assert_must_fail((kernel_relations:size_of_sequence(X,int(1),_WF),
783 X = [(int(1),_),(int(2),_)|_])).
784 :- block size_of_sequence(-,-,?).
785 ?size_of_sequence(Seq,int(Res),WF) :- size_of_sequence1(Seq,Res,WF),
786 set_up_sequence_skel(Seq,Res,WF).
787
788 % setup sequence skeleton if we have some CLPFD bounds information about the size
789 % currently still quite limited: only sets up if sequence is a variable; + does the setup only once
790 :- use_module(library(clpfd), [(#<=>)/2]).
791 :- use_module(clpfd_interface,[clpfd_domain/3]).
792 set_up_sequence_skel(Seq,Res,WF) :-
793 var(Seq), % to do: also deal with cases when Seq partially instantiated
794 var(Res),
795 preferences:preference(use_clpfd_solver,true),
796 !,
797 clpfd_interface:clpfd_geq2(Res,0,_), % assert that size must not be negative
798 clpfd_interface:try_post_constraint((Res#>0) #<=> Trigger), % generate reified trigger for when we can instantiate Seq
799 set_up_sequence_skel_aux(Seq,Res,Trigger,WF).
800 set_up_sequence_skel(_,_,_). % TO DO: check if Size interval shrinks
801 :- block set_up_sequence_skel_aux(-,?,-,?).
802 set_up_sequence_skel_aux(Seq,_Res,_Trigger,_WF) :-
803 nonvar(Seq),
804 !. % to do: also deal with cases when Seq partially instantiated
805 set_up_sequence_skel_aux(Seq,Res,_Trigger,_WF) :-
806 (number(Res) ; preferences:preference(use_smt_mode,true)),
807 !,
808 gen_seq_for_res(Res,Seq).
809 set_up_sequence_skel_aux(Seq,Res,_Trigger,WF) :-
810 get_large_finite_wait_flag(set_up_sequence_skel,WF,LWF),
811 % delay, avoid costly unification with partially instantiated list skeleton;
812 % TO DO: in future we may use the kernel_cardinality attribute instead
813 when((nonvar(LWF) ; nonvar(Seq) ; nonvar(Res)),
814 (nonvar(Seq) -> true ; gen_seq_for_res(Res,Seq))).
815
816 gen_seq_for_res(Res,Seq) :-
817 clpfd_domain(Res,FDLow,FDUp), % FDLow could also be 0
818 (number(FDLow) % it is ok if FDUp is sup, see test 1109
819 -> gen_sequence_skeleton(1,FDLow,FDUp,S),
820 Seq=S
821 ; true).
822 gen_sequence_skeleton(N,M,FDUp,S) :- N>M,!,(FDUp==M -> S=[] ; true).
823 gen_sequence_skeleton(N,Max,FDUp,[(int(N),_)|T]) :-
824 N1 is N+1,
825 gen_sequence_skeleton(N1,Max,FDUp,T).
826
827 :- block size_of_sequence1(-,-,?).
828 size_of_sequence1(Seq,ResInt,WF) :-
829 nonvar(Seq),is_custom_explicit_set_nonvar(Seq),
830 size_of_custom_explicit_set(Seq,Size,WF),!,
831 ? equal_object_wf(Size,int(ResInt),size_of_sequence1,WF).
832 /* TO DO: CHECK BELOW: would it not be better to use cardinality ?? */
833 /*
834 size_of_sequence1(Seq,Size,WF) :- !,kernel_cardinality_attr:finite_cardinality_as_int_wf(Seq,int(Size),WF), check_indexes(Seq,Size).
835
836 construct_interval_closure(1,Size,Domain),
837 total_function_wf(FF,Domain,Range,_WF)
838 % we could also call total_function 1..Size --> _RangeType; would setup domain ?
839 :- block check_indexes(-,?).
840 check_indexes([],_) :- !.
841 check_indexes([(int(X),_)|T],Size) :- !,
842 less_than_equal_direct(X,Size), check_indexes(T,Size).
843 check_indexes(_,_).
844 */
845 size_of_sequence1(Seq,Size,WF) :- Size==0,!, empty_sequence_wf(Seq,WF).
846 size_of_sequence1(Seq,Size,WF) :-
847 expand_custom_set_to_list_wf(Seq,ESeq,_,size_of_sequence1,WF),
848 ? (var(ESeq),nonvar(Size) -> size_of_var_seq(ESeqR,0,Size),
849 ESeqR=ESeq % unify after to do propagation in one go, without triggering coroutines inbetween
850 ? ; size_of_seq2(ESeq,0,Size),
851 (var(Size),var(ESeq) -> less_than_equal_direct(0,Size) % propagate that Size is positive
852 ; true)
853 ).
854 /* small danger of expanding closure while still var !*/
855 :- block size_of_seq2(-,?,-).
856 size_of_seq2([],Size,Size).
857 size_of_seq2([I|Tail],SizeSoFar,Res) :-
858 S2 is SizeSoFar + 1,
859 check_index(I,Res), % don't instantiate I yet; allow other kernel_predicates to freely instantiate it
860 less_than_equal_direct(S2,Res),
861 %(ground(Res) -> safe_less_than_equal(size_of_seq2,S2,Res) ; true),
862 ? size_of_seq2(Tail,S2,Res).
863 size_of_var_seq([],Size,Size).
864 size_of_var_seq([(int(S2),_)|Tail],SizeSoFar,Res) :-
865 S2 is SizeSoFar + 1,safe_less_than_equal(size_of_var_seq,S2,Res),
866 ? (var(Tail) -> size_of_var_seq(Tail,S2,Res) ; size_of_seq2(Tail,S2,Res)).
867
868
869 :- block check_index(-,?).
870 check_index((I,_),Res) :- check_index1(I,Res).
871 :- block check_index1(-,?).
872 check_index1(int(Idx),Res) :- less_than_equal_direct(Idx,Res).
873
874 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:prepend_sequence(int(33),[(int(1),int(22))],[(int(2),int(22)),(int(1),int(33))],WF),WF)).
875 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:prepend_sequence(int(33),[],[(int(1),int(33))],WF),WF)).
876 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:prepend_sequence(int(33),[(int(2),int(44)),(int(1),int(22))],[(int(1),int(33)),(int(3),int(44)),(int(2),int(22))],WF),WF)).
877 :- assert_must_succeed(exhaustive_kernel_fail_check_wfdet(kernel_relations:prepend_sequence(int(33),[(int(1),int(22))],[(int(1),int(22)),(int(2),int(33))],WF),WF)).
878 :- assert_must_succeed((kernel_relations:prepend_sequence(int(7),[],[(int(1),int(7))],_WF))).
879 :- assert_must_succeed((kernel_relations:prepend_sequence(int(7),X,R,_WF),
880 X = [(int(2),int(4)),(int(1),int(3))],
881 kernel_objects:equal_object(R,[(int(1),int(7)),(int(2),int(3)),(int(3),int(4))]))).
882 % code for insert_front operator: El -> Seq
883 :- block prepend_sequence(?,-,-,?).
884 prepend_sequence(El,Seq,Res,_WF) :- Seq==[],!,
885 equal_object_optimized([(int(1),El)],Res,prepend_sequence).
886 prepend_sequence(El,Seq,Res,WF) :- nonvar(Seq),is_custom_explicit_set(Seq,prepend_sequence),
887 prepend_custom_explicit_set(Seq,El,ERes),!,
888 equal_sequence(Res,ERes,WF).
889 prepend_sequence(El,Seq,Res,WF) :- nonvar(Res),is_custom_explicit_set(Res,prepend_sequence),
890 tail_sequence_custom_explicit_set(Res,First,Tail,unknown,WF),!,
891 equal_object_wf(El,First,prepend_sequence,WF),
892 equal_sequence(Seq,Tail,WF).
893 prepend_sequence(El,Seq,Res,WF) :-
894 ? equal_cons_wf(Res,(int(1),El),ShiftSeq,WF),
895 ? shift_seq_indexes(Seq,1,ShiftSeq,WF).
896
897 :- block shift_seq_indexes(-,-,?,?),shift_seq_indexes(-,?,-,?).
898 shift_seq_indexes(Seq,Offset,ShiftedSeq,WF) :-
899 Offset == 0,!, equal_sequence(Seq,ShiftedSeq,WF).
900 shift_seq_indexes(Seq,Offset,ShiftedSeq,WF) :- nonvar(Seq),!,
901 expand_custom_set_to_list_wf(Seq,ESeq,_,shift_seq_indexes,WF),
902 ? shift_seq_indexes2(ESeq,Offset,ShiftedSeq,WF,Done),
903 (Done == done
904 -> true
905 ; % also propagate in the other way: TO DO: make a more efficient fine-grained two-ways propagation; maybe using CHR
906 NegOffset is -Offset,
907 expand_custom_set_to_list_wf(ShiftedSeq,ESeq1,_,shift_seq_indexes,WF),
908 shift_seq_indexes2(ESeq1,NegOffset,ESeq,WF,_)).
909 shift_seq_indexes(Seq,Offset,ShiftedSeq,WF) :- NegOffset is -Offset,
910 % compute in the other direction; TO DO: make a more efficient fine-grained two-ways propagation; maybe using CHR
911 expand_custom_set_to_list_wf(ShiftedSeq,ESeq,_,shift_seq_indexes,WF),
912 shift_seq_indexes2(ESeq,NegOffset,Seq,WF,Done),
913 (Done == done
914 -> true
915 ; % also propagate in the original way:
916 expand_custom_set_to_list_wf(Seq,ESeq1,_,shift_seq_indexes,WF),
917 shift_seq_indexes2(ESeq1,Offset,ESeq,WF,_)).
918
919 :- block shift_seq_indexes2(-,?,?,?,?).
920 shift_seq_indexes2([],_,R,WF,Done) :- !, Done = done, empty_set_wf(R,WF).
921 shift_seq_indexes2([Pair|Tail],Offset,Res,WF,Done) :- !,
922 Pair = (int(N),El),
923 equal_cons_wf(Res,(int(NewN),El),ShiftTail,WF),
924 ? int_plus(int(N),int(Offset),int(NewN)),
925 ? shift_seq_indexes2(Tail,Offset,ShiftTail,WF,Done).
926 shift_seq_indexes2(Seq,Offset,Res,WF,Done) :-
927 add_internal_error('Unexpected set argument: ',shift_seq_indexes2(Seq,Offset,Res,WF,Done)), fail.
928
929 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:append_sequence([(int(1),int(22))],int(33),[(int(2),int(33)),(int(1),int(22))],WF),WF)).
930 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:append_sequence([],int(33),[(int(1),int(33))],WF),WF)).
931 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:append_sequence([(int(2),int(44)),(int(1),int(22))],int(33),[(int(1),int(22)),(int(3),int(33)),(int(2),int(44))],WF),WF)).
932 :- assert_must_succeed(exhaustive_kernel_fail_check_wfdet(kernel_relations:append_sequence([(int(1),int(22))],int(33),[(int(1),int(33)),(int(2),int(22))],WF),WF)).
933 :- assert_must_succeed((kernel_relations:append_sequence([],int(7),[(int(1),int(7))],_WF))).
934 :- assert_must_succeed((kernel_relations:append_sequence(X,int(7),R,_WF),
935 X = [(int(2),int(4)),(int(1),int(3))],
936 kernel_objects:equal_object(R,[(int(1),int(3)),(int(2),int(4)),(int(3),int(7))]))).
937
938 % code for the insert_tail operator Seq<-El
939 :- block append_sequence(-,?,-,?).
940 append_sequence(Seq,El,Res,_WF) :- Seq==[],!,
941 ? equal_object_optimized([(int(1),El)],Res,append_sequence).
942 append_sequence(Seq,El,Res,WF) :-
943 nonvar(Seq),is_custom_explicit_set_nonvar(Seq),
944 append_custom_explicit_set(Seq,El,ERes,WF),!,
945 equal_sequence(Res,ERes,WF).
946 append_sequence(Seq,El,Res,WF) :-
947 nonvar(Res),is_custom_explicit_set_nonvar(Res),
948 % we know result: deconstruct into last El and front Seq
949 front_sequence_custom_explicit_set(Res,Last,Front), !,
950 equal_object_wf(El,Last,append_sequence,WF),
951 equal_sequence(Seq,Front,WF).
952 append_sequence(Seq,El,Res,WF) :-
953 (var(Seq) -> size_of_sequence(Res,INewSize,WF), INewSize=int(NewSize) ; true),
954 equal_cons_wf(Res,(int(NewSize),El),ResT,WF),
955 append_sequence2(Seq,ResT,NewSize,WF).
956
957 :- block append_sequence2(-,?,-,?).
958 append_sequence2(Seq,ResT,_NewSize,WF) :- var(Seq),!,
959 equal_sequence(Seq,ResT,WF).
960 append_sequence2(Seq,ResT,NewSize,WF) :-
961 try_expand_custom_set_wf(Seq,ESeq,append_sequence2,WF),
962 equal_sequence(ESeq,ResT,WF),
963 size_of_sequence(ESeq,Size,WF),
964 int_plus(Size,int(1),int(NewSize)).
965
966 :- assert_must_succeed(exhaustive_kernel_check(kernel_relations:prefix_sequence([(int(1),int(22))],int(1),[(int(1),int(22))]))).
967 :- assert_must_succeed(exhaustive_kernel_succeed_check(kernel_relations:prefix_sequence([(int(2),int(22)),(int(3),int(33)),(int(1),int(11))],int(2),[(int(1),int(11)),(int(2),int(22))]))).
968 :- assert_must_succeed(exhaustive_kernel_fail_check(kernel_relations:prefix_sequence([(int(2),int(22)),(int(3),int(33)),(int(1),int(11))],int(3),[(int(1),int(11)),(int(2),int(22))]))).
969 :- assert_must_succeed((kernel_relations:prefix_sequence(X,int(1),X),X = [(int(1),int(1))])).
970 :- assert_must_succeed((kernel_relations:prefix_sequence(X,int(0),[]),X = [(int(1),int(1))])).
971 :- assert_must_abort_wf((kernel_relations:prefix_sequence_wf(X,int(-1),_R,WF),X = [(int(1),int(1))]),WF).
972 :- assert_must_succeed((kernel_relations:prefix_sequence(X,int(2),Y),
973 X = [(int(2),int(3)),(int(3),int(4)),(int(1),int(1))],
974 kernel_objects:equal_object(Y,[(int(1),int(1)),(int(2),int(3))]) )).
975 :- assert_must_succeed((kernel_relations:prefix_sequence(X,int(1),Y),
976 X = [(int(2),int(3)),(int(3),int(4)),(int(1),int(1))],
977 kernel_objects:equal_object(Y,[(int(1),int(1))]) )).
978 :- assert_must_succeed((kernel_relations:prefix_sequence(X,int(3),Y),
979 X = [(int(2),int(3)),(int(3),int(4)),(int(1),int(1))],
980 kernel_objects:equal_object(Y,X) )).
981
982 prefix_sequence(Seq,N,R) :- init_wait_flags(WF,[prefix_sequence]),
983 prefix_sequence_wf(Seq,N,R,WF),
984 ground_wait_flags(WF).
985
986 % Prefix of a sequence (s /|\ n)
987 prefix_sequence_wf(Seq,int(Num),Res,WF) :-
988 prefix_sequence1(Seq,Num,Res,WF),
989 ? propagate_size(Res,Num,WF).
990
991 % the size of the result of (s /|\ n) is the number n
992 :- block propagate_size(-,-,?).
993 propagate_size(Res,Num,WF) :-
994 var(Res),!,
995 (Num<0 -> preferences:preference(disprover_mode,false) % don't do anything; we may want to generate WD error
996 ; Num < 4 -> size_of_sequence(Res,int(Num),WF)
997 ; Prio is 1+Num // 100,
998 get_wait_flag(Prio,propagate_size,WF,LWF), % avoid setting up very large skeletons too early
999 block_size_of_sequence(LWF,Res,int(Num),WF)
1000 ).
1001 propagate_size(_,Num,_) :- number(Num), !. % no need to propagate
1002 propagate_size(_,_Num,_) :- \+ preferences:preference(find_abort_values,false),
1003 !. % do not propagate as we could prevent detection of WD errors below
1004 propagate_size([],Num,_WF) :- !,
1005 Num=0. % Note: this could prevent a wd-error being detected
1006 propagate_size(avl_set(A),Num,WF) :- var(Num),
1007 % with partially instantated sets we get slowdowns (SimpleCSGGrammar2_SlowCLPFD)
1008 % TO DO: treat list skeletons
1009 !,
1010 ? size_of_sequence(avl_set(A),int(Num),WF). % Note: this could prevent a wd-error being detected
1011 propagate_size(_,_,_). % should we also propagate the other way around ?
1012
1013 :- block block_size_of_sequence(-,?,?,?).
1014 ?block_size_of_sequence(_,Seq,Size,WF) :- size_of_sequence(Seq,Size,WF).
1015
1016 :- block prefix_sequence1(-,?,?,?), prefix_sequence1(?,-,?,?).
1017 ?prefix_sequence1(_Seq,Num,Res,WF) :- Num==0,!, empty_set_wf(Res,WF).
1018 prefix_sequence1(_Seq,Num,_Res,WF) :- Num<0,!, % according to version 1.8.8 of Atelier-B manual Num must be in 0..size(_Seq)
1019 add_wd_error('negative index in prefix_sequence (/|\\)! ', Num,WF).
1020 prefix_sequence1(Seq,Num,Res,WF) :-
1021 is_custom_explicit_set(Seq,prefix),
1022 prefix_of_custom_explicit_set(Seq,Num,ERes,WF),!, % TO DO: check Num <= size(Seq)
1023 ? equal_object_wf(Res,ERes,prefix_sequence1,WF).
1024 prefix_sequence1(Seq,Num,Res,WF) :-
1025 expand_custom_set_to_list_wf(Seq,ESeq,_,prefix_sequence1,WF),
1026 unify_same_index_elements(Res,ESeq,WF),
1027 unify_same_index_elements(Seq,Res,WF),
1028 ? prefix_seq(ESeq,Num,0,Res,WF).
1029 :- block prefix_seq(-,?,?,?,?).
1030 prefix_seq([],Max,Sze,Res,WF) :-
1031 (less_than_direct(Sze,Max)
1032 -> add_wd_error('index larger than size of sequence in prefix_sequence (/|\\)! ', (Max,Sze),WF)
1033 ; true),
1034 empty_set_wf(Res,WF).
1035 %(less_than(int(_Sze),int(_Max))
1036 % -> (print_message('Index bigger than sequence size in prefix_sequence (/|\\) !'),
1037 % print_message(Max))
1038 % /* in the AtelierB book this is allowed, in Wordsworth + AMN on web it is not ?? */
1039 % ; true).
1040 prefix_seq([(int(N),El)|Tail],Max,SizeSoFar,Res,WF) :-
1041 ? prefix_seq2(N,El,Tail,Max,SizeSoFar,Res,WF).
1042 :- block prefix_seq2(-,?,?,?,?,?,?).
1043 prefix_seq2(N,El,Tail,Max,SizeSoFar,Res,WF) :- % SizeSoFar is always ground
1044 (less_than_equal_direct(N,Max), equal_cons_wf(Res,(int(N),El),PTail,WF)
1045 ;
1046 less_than_direct(Max,N), equal_object_wf(Res,PTail,prefix_seq2,WF)
1047 ),
1048 ( SizeSoFar<N -> NewSizeSoFar=N ; NewSizeSoFar = SizeSoFar ),
1049 ? prefix_seq(Tail,Max,NewSizeSoFar,PTail,WF).
1050
1051 :- assert_must_succeed(exhaustive_kernel_check(kernel_relations:suffix_sequence([(int(1),int(22))],int(0),[(int(1),int(22))],WF),ground_det_wait_flag(WF))).
1052 :- assert_must_succeed(exhaustive_kernel_succeed_check(kernel_relations:suffix_sequence([(int(2),int(22)),(int(3),int(33)),(int(1),int(11))],int(1),[(int(1),int(22)),(int(2),int(33))],_WF))).
1053 :- assert_must_succeed(exhaustive_kernel_fail_check(kernel_relations:suffix_sequence([(int(2),int(22)),(int(3),int(33)),(int(1),int(11))],int(2),[(int(1),int(22)),(int(2),int(33))],_WF))).
1054 :- assert_must_succeed((kernel_relations:suffix_sequence(X,int(0),X,_WF),X = [(int(1),int(1))])).
1055 :- assert_must_succeed((kernel_relations:suffix_sequence(X,int(1),[],_WF),X = [(int(1),int(1))])).
1056 :- assert_must_succeed((kernel_relations:suffix_sequence(X,int(2),Y,_WF),
1057 X = [(int(2),int(3)),(int(3),int(4)),(int(1),int(1))],
1058 kernel_objects:equal_object(Y,[(int(1),int(4))]) )).
1059 :- assert_must_succeed((kernel_relations:suffix_sequence(X,int(1),Y,_WF),
1060 X = [(int(2),int(3)),(int(3),int(4)),(int(1),int(1))],
1061 kernel_objects:equal_object(Y,[(int(1),int(3)),(int(2),int(4))]) )).
1062 :- assert_must_succeed((kernel_relations:suffix_sequence(X,int(2),Y,_WF),
1063 X = [(int(2),int(3)),(int(3),int(4)),(int(1),int(1))],
1064 kernel_objects:equal_object(Y,[(int(1),int(4))]) )).
1065 :- assert_must_abort_wf(kernel_relations:suffix_sequence([(int(1),int(11)),(int(2),int(22))],int(-1),_R,WF),WF).
1066 :- assert_must_abort_wf(kernel_relations:suffix_sequence([(int(1),int(11)),(int(2),int(22))],int(3),_R,WF),WF).
1067
1068 % kernel_waitflags:assert_must_abort2_wf(kernel_relations:suffix_sequence([int(11),int(22)],int(-1),_R,WF),WF)
1069
1070 % suffix of a sequence (s \|/ n); also called restrict at tail (Atelier B) or Drop
1071 :- block suffix_sequence(-,?,?,?).
1072 suffix_sequence(Seq,int(Num),Res,WF) :-
1073 suffix_sequence1(Seq,Num,Res,WF).
1074 :- block suffix_sequence1(?,-,?,?).
1075 suffix_sequence1(Seq,Num,Res,WF) :- Num==0, !, equal_object_wf(Res,Seq,suffix_sequence1_1,WF).
1076 suffix_sequence1(_Seq,Num,_Res,WF) :- Num<0, !, add_wd_error('negative index in suffix_sequence (\\|/)! ', Num,WF).
1077 suffix_sequence1(Seq,Num,Res,WF) :- is_custom_explicit_set(Seq,suffix),
1078 suffix_of_custom_explicit_set(Seq,Num,ERes,WF),!,
1079 ? equal_object_wf(Res,ERes,suffix_sequence1_2,WF).
1080 suffix_sequence1(Seq,Num,Res,WF) :-
1081 expand_custom_set_to_list_wf(Seq,ESeq,_,suffix_sequence,WF), suffix_seq(ESeq,Num,0,Res,WF).
1082 :- block suffix_seq(-,?,?,?,?).
1083 suffix_seq([],Max,Sze,Res,WF) :-
1084 (less_than_direct(Sze,Max)
1085 -> add_wd_error('index larger than size of sequence in suffix_sequence (\\|/)! ', '>'(Max,Sze),WF)
1086 ; true), empty_set_wf(Res,WF).
1087 suffix_seq([(int(N),El)|Tail],Max,SizeSoFar,Res,WF) :-
1088 suffix_seq2(N,El,Tail,Max,SizeSoFar,Res,WF).
1089 :- block suffix_seq2(-,?,?,?,?,?,?).
1090 suffix_seq2(N,El,Tail,Max,SizeSoFar,Res,WF) :-
1091 (less_than_equal_direct(N,Max), equal_object_wf(Res,PTail,suffix_seq2,WF)
1092 ;
1093 less_than_direct(Max,N),int_minus(int(N),int(Max),int(NN)),
1094 equal_cons_wf(Res,(int(NN),El),PTail,WF)
1095 ),
1096 (N>SizeSoFar -> (NewSizeSoFar=N)
1097 ; (NewSizeSoFar = SizeSoFar)),
1098 suffix_seq(Tail,Max,NewSizeSoFar,PTail,WF).
1099
1100
1101
1102 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:concat_sequence([],[(int(1),int(33))],[(int(1),int(33))],WF),WF)).
1103 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:concat_sequence([(int(1),int(22)),(int(2),int(33))],[(int(1),int(33)),(int(2),int(44))],[(int(2),int(33)),(int(3),int(33)),(int(1),int(22)),(int(4),int(44))],WF),WF)). % not wfdet because of pending label_el_nr from clpfd_lists
1104 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:concat_sequence([(int(1),int(22))],[(int(1),int(33))],[(int(2),int(33)),(int(1),int(22))],WF),WF)).
1105 :- assert_must_succeed(exhaustive_kernel_fail_check_wfdet(kernel_relations:concat_sequence([(int(1),int(22))],[(int(1),int(33))],[(int(2),int(22)),(int(1),int(33))],WF),WF)).
1106 :- assert_must_succeed((kernel_relations:concat_sequence([],X,Y,_WF),
1107 X = [(int(1),int(1))], Y==X)).
1108 :- assert_must_succeed((kernel_relations:concat_sequence(X,[],Y,_WF), X = [(int(1),int(1))], Y==X)).
1109 :- assert_must_succeed((kernel_relations:concat_sequence([(int(1),int(1))],[],Y,_WF), Y==[(int(1),int(1))])).
1110 :- assert_must_succeed((kernel_relations:concat_sequence(X,X,Y,_WF),
1111 X = [(int(1),int(1))], kernel_objects:equal_object(Y,[(int(1),int(1)),(int(2),int(1))]))).
1112 :- assert_must_succeed((kernel_relations:concat_sequence(X,X,Y,_WF),
1113 X = [(int(2),int(88)),(int(1),int(77))],
1114 kernel_objects:equal_object(Y,[(int(1),int(77)),(int(2),int(88)),(int(3),int(77)),(int(4),int(88))]))).
1115
1116 :- block /* concat_sequence(-,-,?,?), */
1117 concat_sequence(?,-,-,?), concat_sequence(-,?,-,?).
1118 concat_sequence(S1,S2,Res,WF) :- Res==[],!, empty_set_wf(S1,WF), empty_set_wf(S2,WF).
1119 concat_sequence(S1,S2,Res,WF) :-
1120 (var(S1),var(S2) -> get_wait_flag(2,concat,WF,LWF) % we have at least two solutions; TODO maybe use cardinality as wait_flag?
1121 ; LWF=1),
1122 ? concat_sequence2(LWF,S1,S2,Res,WF).
1123
1124 :- block concat_sequence2(-,?,-,?,?), concat_sequence2(-,-,?,?,?).
1125 ?concat_sequence2(_,S1,S2,Res,WF) :- S1==[],!,equal_sequence(S2,Res,WF).
1126 ?concat_sequence2(_,S1,S2,Res,WF) :- S2==[],!,equal_sequence(S1,Res,WF).
1127 concat_sequence2(LWF,S1,S2,Res,WF) :-
1128 try_expand_and_convert_to_avl_with_check(S1,AS1,concat1),
1129 try_expand_and_convert_to_avl_with_check(S2,AS2,concat2),
1130 ? concat_sequence3(LWF,AS1,AS2,Res,WF).
1131
1132 concat_sequence3(_,S1,S2,Res,WF) :- nonvar(S1),is_custom_explicit_set(S1,concat_sequence),
1133 concat_custom_explicit_set(S1,S2,ERes,WF),!,
1134 equal_sequence(Res,ERes,WF).
1135 concat_sequence3(_LWF,S1,S2,Res,WF) :-
1136 %try_expand_custom_set_wf(S1,ES1,concat,WF),
1137 size_of_sequence(S1,int(Size1),WF),
1138 (number(Size1) -> true
1139 ; size_of_sequence(S2,Size2,WF),
1140 size_of_sequence(Res,SizeRes,WF),
1141 int_minus(SizeRes,Size2,int(Size1)),
1142 in_nat_range_wf(int(Size1),int(0),SizeRes,WF)
1143 % is this required: ?? ,in_nat_range_wf(Size2,int(0),SizeRes,WF)
1144 ),
1145 ? concat_sequence_aux(Size1,S1,S2,Res,WF).
1146
1147
1148 :- assert_must_succeed( (kernel_relations:equal_sequence([(int(1),A)|T1],[(int(1),int(22))|T2],_WF),
1149 A==int(22),T2=[],T1==[] )) .
1150 :- assert_must_succeed( (kernel_relations:equal_sequence([(int(1),A)|T],avl_set(node((int(2),string(a)),true,0,node((int(1),string(c)),true,0,empty,empty),node((int(3),string(b)),true,0,empty,empty))),_WF),
1151 check_eqeq(A,string(c)),
1152 kernel_objects:equal_object(T,[(int(2),B)|T2]), check_eqeq(B,string(a)),
1153 kernel_objects:equal_object(T2,[(int(3),C)]), check_eqeq(C,string(b))) ).
1154 % equal_object optimized for sequences; can infer that pairs with same index have same value
1155 % TO DO: complete and make more efficient
1156 %equal_sequence(X,Y,_WF) :- nonvar(X),nonvar(Y),
1157 % is_custom_explicit_set(X,eval_sequence), is_custom_explicit_set(Y,eval_sequence),!,
1158 % equal_explicit_sets(X,Y).
1159 equal_sequence(X,Y,WF) :- nonvar(X),nonvar(Y),
1160 get_seq_head(X,XI,XEl,XT), get_seq_head(Y,YI,YEl,YT), XI==YI,!,
1161 % THIS CURRENTLY ONLY CHECKS FRONTMOST indexes
1162 equal_object_wf(XEl,YEl,equal_sequence_1,WF),
1163 equal_sequence(XT,YT,WF).
1164 equal_sequence(X,Y,WF) :-
1165 /* (is_custom_explicit_set(Y) -> monitor_equal_sequence_againts_custom_set(X,Y,WF)
1166 ; is_custom_explicit_set(X) -> monitor_equal_sequence_againts_custom_set(Y,X,WF)
1167 ; true), does not seem to buy anything; equal_object already powerful enough */
1168 ? equal_object_wf(X,Y,equal_sequence_2,WF).
1169
1170 % enforces the constraint that there is only one possible elemenent per index:
1171 %:- block monitor_equal_sequence_againts_custom_set(-,?,?).
1172 %monitor_equal_sequence_againts_custom_set([],_,_) :- !.
1173 %monitor_equal_sequence_againts_custom_set([El|T],CS,WF) :- !,
1174 % element_of_custom_set_wf(El,CS,WF),
1175 % monitor_equal_sequence_againts_custom_set(T,CS,WF).
1176 %monitor_equal_sequence_againts_custom_set(_,_,_).
1177
1178 get_seq_head([(Idx,El)|Tail],Idx,El,Tail).
1179 %get_seq_head(avl_set(AVL),Idx,El,Tail) :- does not seem to buy anything; equal_object already powerful enough
1180 % custom_explicit_sets:avl_min_pair(AVL,Idx,El),
1181 % custom_explicit_sets:direct_remove_element_from_avl(AVL,(Idx,El),Tail). % TO DO: only compute if indexes ==
1182
1183
1184 :- block concat_sequence_aux(-,?,?,?,?).
1185 concat_sequence_aux(Size1,_S1,_S2,Res,WF) :- nonvar(Res),Res=avl_set(_),
1186 size_of_custom_explicit_set(Res,int(RSize),WF), number(RSize),
1187 Size1 > RSize,!, % S1 is longer than Res; no solution (prevent WD error below)
1188 fail.
1189 concat_sequence_aux(Size1,S1,S2,Res,WF) :- nonvar(Res),Res=avl_set(_),
1190 % split Result into prefix and suffix
1191 prefix_of_custom_explicit_set(Res,Size1,Prefix,WF), % we could call versions which do not check WD
1192 suffix_of_custom_explicit_set(Res,Size1,Postfix,WF),
1193 !,
1194 ? equal_sequence(S1,Prefix,WF), equal_sequence(S2,Postfix,WF).
1195 concat_sequence_aux(Size1,S1,S2,Res,WF) :-
1196 shift_seq_indexes(S2,Size1,NewS2,WF),
1197 % We can do something stronger than disjoint union: we know that the indexes are disjoint!
1198 % Hence: if (int(X),Y) : Res & (int(X),Z) : S1 => Y=Z
1199 % Hence: if (int(X),Y) : Res & (int(X),Z) : S2 => Y=Z
1200 unify_same_index_elements(S1,Res,WF),
1201 unify_same_index_elements(Res,S1,WF),
1202 unify_same_index_elements(NewS2,Res,WF),
1203 unify_same_index_elements(Res,NewS2,WF),
1204 ? disjoint_union_wf(S1,NewS2,Res,WF).
1205
1206 % Check if (int(X),Y) pairs in Seq2 have a matching (int(X),Z) in Seq1 and then unify(Y,Z)
1207 :- block unify_same_index_elements(-,?,?).
1208 unify_same_index_elements(avl_set(A),Seq,WF) :- !,
1209 unify_same_index_elements_aux(Seq,A,WF).
1210 unify_same_index_elements(_,_,_). % TO DO: maybe also support other partially instantiated lists
1211
1212 :- block unify_same_index_elements_aux(-,?,?).
1213 unify_same_index_elements_aux([],_,_) :- !.
1214 unify_same_index_elements_aux([(int(Idx),El)|T],A,WF) :- !,
1215 try_find_index_element(Idx,El,A,WF),
1216 unify_same_index_elements_aux(T,A,WF).
1217 unify_same_index_elements_aux(_,_,_).
1218
1219 :- block try_find_index_element(-,?,?,?).
1220 try_find_index_element(Idx,El,AVL,WF) :-
1221 ? avl_fetch_pair(int(Idx),AVL,AvlEl),
1222 !,
1223 % We have found an entry with the same index: El and AvlEl must be identical:
1224 equal_object_wf(El,AvlEl,try_find_index_element,WF).
1225 try_find_index_element(_Idx,_El,_AVL,_WF). % :- print(not_found(_Idx,_AVL)),nl.
1226
1227 % TO DO: add waitflags + use within partition_wf
1228 % computes union of two sets which are guaranteed to be disjoint: means that if two of three sets known the other one can be determined
1229
1230 :- assert_must_succeed(exhaustive_kernel_check_wf([commutative],kernel_relations:disjoint_union_wf([int(3)],[int(2),int(1)],[int(1),int(3),int(2)],WF),WF)).
1231 :- assert_must_succeed(exhaustive_kernel_check_wf([commutative],kernel_relations:disjoint_union_wf([],[int(2),int(1)],[int(1),int(2)],WF),WF)).
1232 :- assert_must_succeed(exhaustive_kernel_check_wf([commutative],kernel_relations:disjoint_union_wf([int(1),int(2)],[],[int(2),int(1)],WF),WF)).
1233 :- assert_must_succeed((kernel_relations:disjoint_union_wf([int(1)],[int(2)],Res,_WF),kernel_objects:equal_object(Res,[int(1),int(2)]))).
1234 :- assert_must_succeed((kernel_relations:disjoint_union_wf(A,B,[int(1)],_WF),B=[H],H==int(1),A==[])).
1235
1236 % a union where we know that Set1 and Set2 are disjoint
1237 % this means we can propagate elements of Set1/2 more easily to result
1238 disjoint_union_wf(Set1,Set2,Res,WF) :-
1239 (var(Res)
1240 -> disjoint_union_wf0(Set1,Set2,DRes,DRes,WF),
1241 equal_object_optimized_wf(Res,DRes,disjoint_union_wf,WF) % try and convert result to AVL
1242 ? ; disjoint_union_wf0(Set1,Set2,Res,Res,WF)).
1243
1244 % disjoint_union_wf0(Set1,Set2,UnionOfSet1Set2, SuperSet, WF)
1245 :- block disjoint_union_wf0(-,-,-,?,?).
1246 ?disjoint_union_wf0(Set1,Set2,Res,_,WF) :- Set1==[],!,equal_object_wf(Set2,Res,disjoint_union_wf0_1,WF).
1247 disjoint_union_wf0(Set1,Set2,Res,_,WF) :- Set2==[],!,equal_object_wf(Set1,Res,disjoint_union_wf0_2,WF).
1248 ?disjoint_union_wf0(Set1,Set2,Res,_,WF) :- Res==[],!,empty_set_wf(Set1,WF), empty_set_wf(Set2,WF).
1249 disjoint_union_wf0(Set1,Set2,Res,FullRes,WF) :-
1250 ((nonvar(Set1);nonvar(Set2)) -> true ; get_cardinality_powset_wait_flag(Res,disjoint_union_wf0,WF,_Card,CWF)),
1251 ? disjoint_union0(Set1,Set2,Res,FullRes,WF,CWF).
1252
1253 :- block disjoint_union0(-,-,?,?,?,-), disjoint_union0(-,?,-,-,?,?), disjoint_union0(?,-,-,-,?,?).
1254 disjoint_union0(Set1,Set2,Res,_,WF,_) :- Set1==[],!,equal_object_wf(Set2,Res,disjoint_union0_1,WF).
1255 ?disjoint_union0(Set1,Set2,Res,_,WF,_) :- Set2==[],!,equal_object_wf(Set1,Res,disjoint_union0_2,WF).
1256 disjoint_union0(S1,S2,Res,_F,WF,_CWF) :-
1257 ground_value(Res),
1258 ( ground_value(S1) -> !,
1259 ? check_subset_of_wf(S1,Res,WF), % TO DO: check if we can merge the check_subset and difference set in one predicate
1260 difference_set_wf(Res,S1,S2,WF)
1261 ; ground_value(S2) -> !,
1262 ? check_subset_of_wf(S2,Res,WF),
1263 ? difference_set_wf(Res,S2,S1,WF)
1264 ; var(S1),var(S2) -> !, % CWF nonvar
1265 % see test 1408; allows to generate subsets of Res and avoid enumeration warnings
1266 check_subset_of_wf(S1,Res,WF),
1267 %check_subset_of(S1,Res), % without waitflag: will generate ground version
1268 difference_set_wf(Res,S1,S2,WF)
1269 ).
1270 disjoint_union0(Set1,Set2,Res,_,WF,_) :- nonvar(Set1),
1271 is_custom_explicit_set_nonvar(Set1),
1272 union_of_explicit_set(Set1,Set2,Union), !, % TODO: if it fails: copy/propagate values to result?
1273 equal_object_wf(Union,Res,disjoint_union0_3,WF).
1274 disjoint_union0(Set1,Set2,Res,Full,WF,_) :-
1275 expand_custom_set_to_list_no_dups_wf(Set1,ESet1,_,disjoint_union0_1,WF),
1276 expand_custom_set_to_list_no_dups_wf(Set2,ESet2,_,disjoint_union0_2,WF),
1277 ? disj_union1(ESet1,ESet2,Res,Full,WF).
1278
1279 :- block disj_union1(-,-,?,?,?).
1280 disj_union1(X,Y,Res,FullRes,WF) :-
1281 ? var(X) -> disj_union2(Y,X,Res,FullRes,WF) ; disj_union2(X,Y,Res,FullRes,WF).
1282
1283 ?disj_union2([],Y,Res,_,_WF) :- equal_object_optimized(Y,Res,disj_union2).
1284 disj_union2([X|TX],Y,Res,FullRes,WF) :-
1285 ? remove_element_wf(X,Res,TR,WF), % was: equal_cons_wf(Res,X,TR,WF) but error was that it could force X to be a certain value
1286 ground_value_check(X,XV),
1287 (nonvar(XV) -> equal_cons_wf(Res,X,TR,WF)
1288 ; check_element_of_wf(X,FullRes,WF), % ensure that we set up proper constraints for X; e.g., for x \/ y = 1..10 & x /\ y = {}
1289 when(nonvar(XV), equal_cons_wf(Res,X,TR,WF))
1290 ), % ensure that we instantiate Res if TR known; otherwise we may get pending co-routines, e.g. test 506, SyracuseGrammar
1291 ? disj_union3(TX,Y,TR,FullRes,WF).
1292
1293 :- block disj_union3(-,-,-,?,?).
1294 ?disj_union3(X,Y,Res,_,WF) :- Res==[],!,empty_set_wf(X,WF),empty_set_wf(Y,WF).
1295 ?disj_union3(X,Y,Res,FullRes,WF) :- disj_union1(X,Y,Res,FullRes,WF).
1296
1297
1298 :- block disjoint_union_generalized_wf(-,?,?).
1299 %disjoint_union_generalized_wf([Set1|T],Res,_WF) :- T==[],!, % just one set; probably not covered at the moment (ast_cleanup simplifies partition with single set
1300 % equal_object(Set1,Res).
1301 disjoint_union_generalized_wf(ListOfSets,Res,WF) :-
1302 %expand_custom_set_to_list_wf(SetsOfSets,ESetsOfSets,_,disjoint_union_generalized_wf,WF), % this is a list of sets
1303 ? disjoint_union_generalized2(ListOfSets,[],Res,WF).
1304 :- block disjoint_union_generalized2(-,?,?,?).
1305 ?disjoint_union_generalized2([],S,Res,WF) :- !, equal_object_optimized_wf(S,Res,disjoint_union_generalized2,WF).
1306 disjoint_union_generalized2([H|T],UnionSoFar,Res,WF) :- !,
1307 disjoint_union_wf0(H,UnionSoFar,UnionSoFar2,Res,WF),
1308 %% print_message(called_disjoint_union(H,UnionSoFar,UnionSoFar2)), %%
1309 ? disjoint_union_generalized2(T,UnionSoFar2,Res,WF).
1310 disjoint_union_generalized2(L,S,Res,WF) :-
1311 add_internal_error('Not a list: ',disjoint_union_generalized2(L,S,Res,WF)),fail.
1312 % TO DO: if there are more than two sets: it may be interesting to set up constraint that
1313 % each set is a subset of the full set;
1314 % (would avoid enumeration warning in, e.g., x \/ y \/ z = 1..10 & x /\ y = {} & x /\ z = {} & y /\ z = {} & card(x)=card(y)+2 )
1315
1316 :- assert_must_succeed(exhaustive_kernel_check(kernel_relations:concatentation_of_sequences([(int(1),[]),(int(3),[(int(1),int(22)),(int(2),int(33))]),(int(2),[(int(1),int(11))])],
1317 [(int(1),int(11)),(int(2),int(22)),(int(3),int(33))],_WF))).
1318 :- assert_must_succeed(exhaustive_kernel_check(kernel_relations:concatentation_of_sequences([(int(1),[]),(int(2),[(int(1),int(33))])],[(int(1),int(33))],_WF))).
1319 :- assert_must_succeed((kernel_waitflags:init_wait_flags(WF),kernel_relations:concatentation_of_sequences([(int(1),[]),(int(2),[(int(1),int(55))])],Res,WF),
1320 kernel_waitflags:ground_wait_flags(WF),
1321 kernel_objects:equal_object(Res,[(int(1),int(55))]) )).
1322 :- assert_must_succeed((kernel_waitflags:init_wait_flags(WF),kernel_relations:concatentation_of_sequences([(int(1),[(int(1),int(22))]),(int(2),[(int(1),int(55))])],Res,WF),
1323 kernel_waitflags:ground_wait_flags(WF),
1324 kernel_objects:equal_object(Res,[(int(1),int(22)),(int(2),int(55))]) )).
1325 :- block concatentation_of_sequences(-,?,?).
1326 concatentation_of_sequences(SeqOfSeq,Res,WF) :-
1327 try_expand_and_convert_to_avl_with_check(SeqOfSeq,ES,conc),
1328 ? concs2(ES,Res,WF).
1329
1330 concs2(SeqOfSeq,Res,WF) :- is_custom_explicit_set(SeqOfSeq,conc),
1331 conc_custom_explicit_set(SeqOfSeq,CRes),!,
1332 equal_object_wf(CRes,Res,concs2,WF).
1333 concs2(SeqOfSeq,Res,WF) :- empty_set_wf(SeqOfSeq,WF),empty_set_wf(Res,WF).
1334 concs2(SeqOfSeq,Res,WF) :- not_empty_set_wf(SeqOfSeq,WF),
1335 front_sequence(SeqOfSeq,Front,WF),
1336 concatentation_of_sequences(Front,FrontRes,WF),
1337 last_sequence(SeqOfSeq,Last,WF),
1338 concat_sequence(FrontRes,Last,Res,WF).
1339
1340 :- assert_must_abort_wf(kernel_relations:tail_sequence([],_R,unknown,WF),WF).
1341 :- assert_must_abort_wf(kernel_relations:tail_sequence([],[],unknown,WF),WF).
1342 :- assert_must_succeed(exhaustive_kernel_succeed_check(
1343 kernel_relations:tail_sequence([(int(1),int(4)),(int(2),int(5))],[(int(1),int(5))],unknown,_WF)) ).
1344 :- assert_must_succeed(exhaustive_kernel_succeed_check( kernel_relations:tail_sequence([(int(1),int(4)),(int(3),int(6)),(int(2),int(5))],
1345 [(int(1),int(5)),(int(2),int(6))],unknown,_WF)) ).
1346 :- assert_must_succeed((kernel_relations:tail_sequence(X,R,unknown,_),
1347 X = [(int(1),int(6)),(int(2),int(5))],
1348 kernel_objects:equal_object(R,[(int(1),int(5))]) )).
1349 :- assert_must_succeed((kernel_relations:tail_sequence(X,[(int(1),int(5))],unknown,_),
1350 X = [(int(1),int(6)),(int(2),int(5))] )).
1351 :- assert_must_succeed((kernel_relations:tail_sequence(X,[(int(1),int(5)),(int(2),int(7))],unknown,_),
1352 X = [(int(1),int(6)),(int(2),int(5)),(int(3),int(7))] )).
1353 :- assert_must_succeed((kernel_relations:tail_sequence(X,[(int(2),int(7)),(int(1),int(5))],unknown,_),
1354 X = [(int(1),int(6)),(int(2),int(5)),(int(3),int(7))] )).
1355 :- block tail_sequence(-,?,?,?).
1356 tail_sequence(S1,Res,Span,WF) :- is_custom_explicit_set(S1,tail_sequence),
1357 tail_sequence_custom_explicit_set(S1,_,TRes,Span,WF),!,
1358 equal_object_wf(TRes,Res,tail_sequence,WF).
1359 tail_sequence(S1,Res,Span,WF) :- expand_custom_set_to_list_wf(S1,ES1,_,tail_sequence,WF),
1360 tail2(ES1,Res,Span,WF).
1361
1362 tail2([],_,Span,WF) :-
1363 add_wd_error_span('tail applied to empty sequence!',[],Span,WF).
1364 tail2([H|T],Res,_Span,WF) :- domain_subtraction_wf([int(1)],[H|T],IntRes,WF),
1365 shift_seq_indexes(IntRes,-1,Res,WF).
1366
1367
1368 :- assert_must_abort_wf(kernel_relations:first_sequence([],_R,unknown,WF),WF).
1369 :- assert_must_abort_wf(kernel_relations:first_sequence([],int(1),unknown,WF),WF).
1370 :- assert_must_succeed(exhaustive_kernel_succeed_check( kernel_relations:first_sequence([(int(1),int(4)),(int(2),int(5))],int(4),unknown,_WF)) ).
1371 :- assert_must_succeed(exhaustive_kernel_succeed_check( kernel_relations:first_sequence([(int(1),int(4)),(int(3),int(6)),(int(2),int(5))],int(4),unknown,_WF)) ).
1372 :- assert_must_succeed((kernel_relations:first_sequence(X,R,unknown,_WF),
1373 X = [(int(1),int(2)),(int(2),int(1))],
1374 R = int(2))).
1375
1376 :- block first_sequence(-,?,?,?).
1377 first_sequence([],_,Span,WF) :- !,add_wd_error_span('first applied to empty sequence!',[],Span,WF).
1378 ?first_sequence(Seq,Res,Span,WF) :- apply_to(Seq,int(1),Res,Span,WF).
1379
1380
1381
1382 :- assert_must_abort_wf(kernel_relations:front_sequence([],_R,WF),WF).
1383 :- assert_must_abort_wf(kernel_relations:front_sequence([],[],WF),WF).
1384 :- assert_must_succeed(exhaustive_kernel_succeed_check( kernel_relations:front_sequence([(int(1),int(4)),(int(2),int(5))],[(int(1),int(4))],_WF)) ).
1385 :- assert_must_succeed(exhaustive_kernel_succeed_check( kernel_relations:front_sequence([(int(1),int(4)),(int(3),int(6)),(int(2),int(5))],[(int(1),int(4)),(int(2),int(5))],_WF)) ).
1386 :- assert_must_succeed((kernel_waitflags:init_wait_flags(WF),kernel_relations:front_sequence(X,R,WF),
1387 X = [(int(1),int(2)),(int(2),int(55))],kernel_waitflags:ground_wait_flags(WF),
1388 kernel_objects:equal_object(R,[(int(1),int(2))]))).
1389 :- assert_must_succeed((kernel_waitflags:init_wait_flags(WF),kernel_relations:front_sequence(X,R,WF),
1390 X = [(int(3),int(33))|R], kernel_waitflags:ground_wait_flags(WF),
1391 kernel_objects:equal_object(R,[(int(1),int(2)),(int(2),int(55))]) )).
1392
1393 front_sequence(Seq,Res,WF) :- front_sequence(Seq,Res,unknown,WF).
1394 :- block front_sequence(-,?,?,?).
1395 front_sequence(S1,Res,_Span,WF) :-
1396 is_custom_explicit_set(S1,front_sequence),
1397 front_sequence_custom_explicit_set(S1,_,FRes),!,
1398 ? equal_object_wf(FRes,Res,front_sequence,WF).
1399 front_sequence(Seq,Res,Span,WF) :- expand_custom_set_to_list_wf(Seq,ESeq,_,front_sequence,WF),
1400 ? front2(ESeq,Res,Span,WF).
1401 front2([],_,Span,WF) :- add_wd_error_span('front applied to empty sequence!',[],Span,WF).
1402 front2([H|T],Res,_Span,WF) :- size_of_sequence([H|T],int(Size),WF),
1403 ? (number(Size) -> true ; size_of_sequence(Res,SizeRes,WF), int_plus(SizeRes,int(1),int(Size))),
1404 when(ground(Size), domain_subtraction_wf([int(Size)],[H|T],Res,WF)).
1405
1406
1407 :- assert_must_abort_wf(kernel_relations:last_sequence([],_R,WF),WF).
1408 :- assert_must_abort_wf(kernel_relations:last_sequence([],int(1),WF),WF).
1409 :- assert_must_succeed(exhaustive_kernel_succeed_check( kernel_relations:last_sequence([(int(1),int(4)),(int(2),int(5))],int(5),_WF)) ).
1410 :- assert_must_succeed(exhaustive_kernel_succeed_check( kernel_relations:last_sequence([(int(1),int(4)),(int(3),int(6)),(int(2),int(5))],int(6),_WF)) ).
1411 :- assert_must_succeed((kernel_relations:last_sequence(X,R,_WF),
1412 X = [(int(1),int(2)),(int(2),int(55))],R = int(55))).
1413 :- assert_must_succeed((kernel_relations:last_sequence(X,R,_WF), X = [(int(1),int(55))], R = int(55))).
1414 :- assert_must_succeed((kernel_relations:last_sequence([(int(1),[(int(1),int(22))]),(int(2),[(int(1),int(55))])],R,_WF), R == [(int(1),int(55))])).
1415
1416 last_sequence(Seq,Res,WF) :- last_sequence(Seq,Res,unknown,WF).
1417 :- block last_sequence(-,?,?,?).
1418 last_sequence(Seq,Res,_Span,WF) :-
1419 is_custom_explicit_set(Seq,last_sequence),
1420 last_sequence_explicit_set(Seq,Last), !,
1421 ? equal_object_wf(Last,Res,last_sequence,WF).
1422 last_sequence([],_,Span,WF) :- !,add_wd_error_span('last applied to empty sequence!',[],Span,WF).
1423 last_sequence(Seq,Res,Span,WF) :-
1424 size_of_sequence(Seq,int(Size),WF),
1425 last_sequence_aux(Size,Seq,Res,Span,WF).
1426 :- block last_sequence_aux(-,?,?,?,?).
1427 last_sequence_aux(Size,Seq,Res,Span,WF) :-
1428 apply_to(Seq,int(Size),Res,Span,WF).
1429
1430
1431 :- assert_must_succeed(exhaustive_kernel_check_wfdet( kernel_relations:rev_sequence([(int(1),int(4)),(int(2),int(5))],[(int(1),int(5)),(int(2),int(4))],WF),WF )).
1432 :- assert_must_succeed(exhaustive_kernel_check_wfdet( kernel_relations:rev_sequence([(int(1),int(4))],[(int(1),int(4))],WF),WF )).
1433 :- assert_must_succeed(exhaustive_kernel_check_wfdet( kernel_relations:rev_sequence([],[],WF),WF )).
1434 :- assert_must_succeed(exhaustive_kernel_check_wfdet( kernel_relations:rev_sequence([(int(1),int(4)),(int(3),int(6)),(int(2),int(5))],[(int(1),int(6)),(int(3),int(4)),(int(2),int(5))],WF),WF )).
1435 :- assert_must_succeed((kernel_relations:rev_sequence([],[],_WF))).
1436 :- assert_must_succeed((kernel_relations:rev_sequence(X,R,_WF),
1437 X = [(int(1),int(2)),(int(2),int(1))],
1438 kernel_objects:equal_object(R,[(int(2),int(2)),(int(1),int(1))]) )).
1439 :- assert_must_succeed((kernel_relations:rev_sequence(X,R,_WF),
1440 X = [(int(1),int(23)),(int(2),int(1)),(int(3),int(55))],
1441 kernel_objects:equal_object(R,[(int(3),int(23)),(int(2),int(1)),(int(1),int(55))]) )).
1442 :- assert_must_succeed((kernel_relations:rev_sequence(R,X,_WF),
1443 X = [(int(1),int(23)),(int(2),int(1)),(int(3),int(55))],
1444 kernel_objects:equal_object(R,[(int(3),int(23)),(int(2),int(1)),(int(1),int(55))]) )).
1445 :- assert_must_succeed((kernel_relations:rev_sequence(X,_R,_WF),
1446 X = [(int(2),int(1)),(int(1),int(23)),(int(3),int(55))] )).
1447 :- assert_must_succeed((kernel_relations:rev_sequence(_R,X,_WF),
1448 X = [(int(3),int(55)),(int(1),int(23)),(int(2),int(1))] )).
1449
1450 /* reverse of sequence */
1451 :- block rev_sequence(-,-,?).
1452 rev_sequence(S1,Res,WF) :-
1453 ? (nonvar(S1) -> rev_sequence2(S1,Res,WF)
1454 ; rev_sequence2(Res,S1,WF)).
1455
1456 rev_sequence2(S1,Res,WF) :- reverse_custom_explicit_set(S1,RS1),!,
1457 ? equal_object_wf(Res,RS1,WF).
1458 rev_sequence2(S1,Res,WF) :-
1459 expand_custom_set_to_list_wf(S1,ES1,_,rev_sequence2,WF),
1460 size_of_sequence(ES1,int(Size1),WF),
1461 % TO DO: we could also try and get the size from the result Res
1462 rev_sequence3(ES1,Size1,Res,WF).
1463
1464 :- block rev_sequence3(?,-,-,?).
1465 rev_sequence3(E,_Size,Res,WF) :- nonvar(Res), reverse_custom_explicit_set(Res,RevRes),!,
1466 equal_object_wf(E,RevRes,WF).
1467 rev_sequence3(E,Size,Res,WF) :- var(Size), !,
1468 % try to obtain size from result as well
1469 size_of_sequence(Res,int(Size),WF), rev_sequence3b(E,Size,Res,WF).
1470 ?rev_sequence3(E,S,R,WF) :- rev_sequence4(E,S,R,WF).
1471
1472 :- block rev_sequence3b(?,-,?,?).
1473 rev_sequence3b(E,S,R,WF) :- rev_sequence4(E,S,R,WF).
1474
1475 :- block rev_sequence4(-,?,?,?).
1476 rev_sequence4([],_,Res,WF) :- empty_set_wf(Res,WF).
1477 rev_sequence4([(int(N),El)|Tail],Size1,Res,WF) :-
1478 ? equal_cons_wf(Res,(NewN,El),RTail,WF),
1479 % compute NewN = Size - (N-1)
1480 int_minus(int(N),int(1),N1),
1481 int_minus(int(Size1),N1,NewN),
1482 (ground(NewN) -> true ; in_nat_range(NewN,int(0),int(Size1))),
1483 ? rev_sequence4(Tail,Size1,RTail,WF).
1484
1485
1486 /* --------- */
1487 /* RELATIONS */
1488 /* --------- */
1489
1490 %maplet(X,Y,(X,Y)).
1491
1492 % relation([]).
1493 % relation([(_X,_Y)|T]) :- relation(T).
1494
1495 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:relation_over_wf([(int(1),int(6)),(int(2),int(7)),(int(1),int(7))],[int(1),int(2)],[int(7),int(6)],WF),WF)).
1496 :- assert_must_succeed(exhaustive_kernel_check( kernel_relations:relation_over([],[int(1),int(2)],[int(2)]) )).
1497 :- assert_must_succeed(exhaustive_kernel_succeed_check( kernel_relations:relation_over([(int(1),int(2))],[int(1),int(2)],[int(2)]) )).
1498 :- assert_must_succeed(exhaustive_kernel_succeed_check( kernel_relations:relation_over([([int(1)],[int(2)])],[[int(1)],[],[int(2)]],[[int(2)]]) )).
1499 :- assert_must_succeed(exhaustive_kernel_succeed_check( kernel_relations:relation_over([(pred_true /* bool_true */,pred_false /* bool_false */)],[pred_false /* bool_false */,pred_true /* bool_true */],[pred_false /* bool_false */]) )).
1500 :- assert_must_succeed(exhaustive_kernel_succeed_check( kernel_relations:relation_over([((pred_true /* bool_true */,int(2)),fd(1,'Name'))],[(pred_false /* bool_false */,int(1)),(pred_true /* bool_true */,int(2))],[fd(2,'Name'),fd(1,'Name')]) )).
1501 :- assert_must_succeed(exhaustive_kernel_succeed_check( kernel_relations:relation_over([((rec([field(a,fd(1,'Name'))]),int(2)),fd(1,'Name'))],[(rec([field(a,fd(1,'Name'))]),int(1)),(rec([field(a,fd(1,'Name'))]),int(2))],[fd(2,'Name'),fd(1,'Name')]) )).
1502 :- assert_must_succeed(exhaustive_kernel_succeed_check( kernel_relations:relation_over([((rec([field(a,fd(2,'Name')),field(b,fd(1,'Name'))]),int(2)),fd(1,'Name'))],[(rec([field(a,fd(1,'Name')),field(b,fd(1,'Name'))]),int(1)),(rec([field(a,fd(1,'Name')),field(b,fd(2,'Name'))]),int(2)),(rec([field(a,fd(2,'Name')),field(b,fd(1,'Name'))]),int(2))],[fd(2,'Name'),fd(1,'Name')]) )).
1503 :- assert_must_succeed(exhaustive_kernel_succeed_check( kernel_relations:relation_over([((pred_true /* bool_true */,int(2)),string('STRING1'))],[(pred_false /* bool_false */,int(1)),(pred_true /* bool_true */,int(2))],[string('STRING2'),string('STRING1')]) )).
1504 :- assert_must_succeed(exhaustive_kernel_succeed_check( /* multiple solutions !!*/ kernel_relations:relation_over([(int(1),int(2)),(int(2),int(2))],[int(1),int(2)],[int(2)]) )).
1505 :- assert_must_succeed(exhaustive_kernel_succeed_check( kernel_relations:relation_over([(int(1),int(2)),(int(1),int(3))],[int(1),int(2)],[int(3),int(2)]) )).
1506 :- assert_must_succeed(exhaustive_kernel_fail_check( kernel_relations:relation_over([(int(1),int(2)),(int(2),int(1))],[int(1),int(2)],[int(2)]) )).
1507 :- assert_must_fail(( kernel_relations:relation_over([(int(1),int(1))],[int(1),int(2)],[int(2)]) )).
1508 :- assert_must_succeed(( kernel_relations:relation_over(X,[int(1),int(2)],[int(3)]),
1509 X==[(int(1),int(3))] )).
1510 :- assert_must_succeed(( kernel_relations:relation_over(X,[int(1),int(2)],[int(3)]),
1511 X==[(int(1),int(3)),(int(2),int(3))] )).
1512 :- assert_must_succeed(( kernel_relations:relation_over(X,[int(1),int(2)],[int(4),int(5)]),
1513 X==[(int(2),int(4)),(int(2),int(5))] )).
1514
1515 relation_over(R,Dom,Ran) :- init_wait_flags(WF,[relation_over]),
1516 relation_over_wf(R,Dom,Ran,WF),
1517 ground_wait_flags(WF).
1518
1519 :- block relation_over_wf(-,-,-,?).
1520 relation_over_wf(R,Dom,Ran,WF) :-
1521 kernel_equality:get_cardinality_relation_over_wait_flag(Dom,Ran,WF,WFR,MaxCard,MaxNrOfRels),
1522 ? relation_over1(R,Dom,Ran,WF,WFR,MaxCard,MaxNrOfRels).
1523
1524 :- block relation_over1(-,?,?,?,-,?,?).
1525 relation_over1(FF,Domain,Range,WF,_WFR,_MaxCard,_MaxNrOfRels) :-
1526 nonvar(FF),
1527 custom_explicit_sets:is_definitely_maximal_set(Range),
1528 % we do not need the Range; this means we can match more closures (e.g., lambda)
1529 ? custom_explicit_sets:dom_for_specific_closure(FF,FFDomain,_,WF),!,
1530 check_domain_subset_for_closure_wf(FF,FFDomain,Domain,WF).
1531 relation_over1(FF,Domain,Range,WF,_WFR,_MaxCard,_MaxNrOfRels) :- nonvar(FF),
1532 custom_explicit_sets:dom_range_for_specific_closure(FF,FFDomain,FFRange,_,WF),!,
1533 check_domain_subset_for_closure_wf(FF,FFDomain,Domain,WF),
1534 check_range_subset_for_closure_wf(FF,FFRange,Range,WF).
1535 relation_over1(R,Dom,Ran,WF,WFR,MaxCard,MaxNrOfRels) :- var(R),!,
1536 expand_custom_set_to_list_wf(R,ER,_,relation_over1,WF),
1537 ? relation_over2(ER,[],Dom,Ran,WF,WFR,MaxCard,MaxNrOfRels,none).
1538 relation_over1(R,Domain,Range,WF,_WFR,_MaxCard,_) :-
1539 expand_and_convert_to_avl_set_catch(R,AER,relation_over1,'ARG : ? <-> ?',ResultStatus,WF),!,
1540 (ResultStatus=avl_set
1541 ? -> is_avl_relation_over_domain(AER,Domain,WF),
1542 ? is_avl_relation_over_range(AER,Range,WF)
1543 ; (debug_level_active_for(19) -> add_message_wf(relation_over,'SYMBOLIC <-> check: ',R,unknown,WF) ; true),
1544 symbolic_domain_subset_check(R,Domain,WF),
1545 symbolic_range_subset_check(R,Range,WF)
1546 ).
1547 relation_over1(R,Dom,Ran,WF,WFR,MaxCard,MaxNrOfRels) :-
1548 expand_custom_set_to_list_wf(R,ER,_,relation_over1,WF),
1549 ? relation_over2(ER,[],Dom,Ran,WF,WFR,MaxCard,MaxNrOfRels,none).
1550
1551 % check the domain of a symbolic closure value FF whose domain is FFDomain and expected domain is Domain:
1552 check_domain_subset_for_closure_wf(FF,FFDomain,Domain,WF) :-
1553 opt_push_wait_flag_call_stack_info(WF,b_operator_call(subset,
1554 [b_operator(domain,[FF]),Domain],unknown),WF2),
1555 check_subset_of_wf(FFDomain,Domain,WF2).
1556 % ditto for range
1557 check_range_subset_for_closure_wf(FF,FFRange,Range,WF) :-
1558 opt_push_wait_flag_call_stack_info(WF,b_operator_call(subset,
1559 [b_operator(range,[FF]),Range],unknown),WF2),
1560 ? check_subset_of_wf(FFRange,Range,WF2).
1561
1562
1563 % try and expand set to AVL and catch enumeration warning exceptions and set OK result value
1564 % if it succeeds with OK = avl_set -> we have an avl_set
1565 % if it fails: it cannot be expanded at the moment
1566 % if it retuns keep_symbolic: expansion cannot be performed and can never be performed; keep set symbolic
1567 expand_and_convert_to_avl_set_catch(R,_AS,_Origin,_Operator,_ResultStatus,_WF) :- var(R),!,fail.
1568 expand_and_convert_to_avl_set_catch(R,_AS,_Origin,_Operator,ResultStatus,_WF) :-
1569 is_infinite_or_symbolic_set(R),!,
1570 % we used to call is_infinite_explicit_set; expectation is that we have a good fallback option for symbolic sets
1571 % see test 2073 with STRICT_RAISE_ENUM_WARNINGS
1572 ResultStatus=keep_symbolic.
1573 expand_and_convert_to_avl_set_catch(R,AS,Origin,Operator,ResultStatus,WF) :-
1574 catch(
1575 (expand_and_convert_to_avl_set(R,AS,Origin,Operator),ResultStatus=avl_set),
1576 enumeration_warning(_,_,_,_,_),
1577 (add_message_wf(Origin,'Attempting symbolic treatment, enumeration warning occured while expanding ARG for ',
1578 Operator,b(value(R),any,[]),WF),
1579 ResultStatus=keep_symbolic)).
1580
1581 expand_and_convert_to_avl_set_warn(R,_AS,_Origin,_Operator,_WF) :- var(R),!,fail.
1582 expand_and_convert_to_avl_set_warn(R,AS,Origin,Operator,WF) :-
1583 % TO DO: check for not fully instantiated closures, like memoization closures where ID not yet known
1584 % it is used before a cut: we need to expand straightaway without choice points
1585 (is_symbolic_closure(R)
1586 -> add_message_wf(Origin,'Expanding symbolic set argument ARG for predicate ',Operator,b(value(R),any,[]),WF)
1587 ; true),
1588 % TODO: instead of observe_enumeration_warnings we could push onto the call-stack and pass WF
1589 observe_enumeration_warnings(expand_and_convert_to_avl_set(R,AS,Origin,Operator),
1590 add_message_wf(Origin,'Enumeration warning occured while expanding argument ARG for predicate ',
1591 Operator,b(value(R),any,[]),WF)).
1592 %expand_and_convert_to_avl_set(R,AS,_,Operator,Values) :-
1593 % observe_enumeration_warnings(expand_and_convert_to_avl_set(R,AS,,),
1594 % display_warning_message(Operator,Values)).
1595 %display_warning_message(Operator,Values) :-
1596 % format(user_error,'Enumeration Warning for Operator ~w~n',[Operator]),
1597 % maplist(translate:print_bvalue,Values),nl.
1598
1599 :- block relation_over2(-,?,?,?,?,-,?,?,?).
1600 relation_over2([],_,_,_,_WF,_WFR,_MaxCard,_MaxNrOfRels,_LastPair).
1601 relation_over2(REL,SoFar,Domain,Range,WF,WFR,MaxCard,MaxNrOfRels,LastPair) :-
1602 (var(REL) -> NewLastPair=(X,Y) ; NewLastPair=none), %remember whether we freely chose X,Y
1603 REL = [(X,Y)|T],
1604 ? (number(MaxCard)
1605 -> MaxCard>0,C1 is MaxCard-1 ,(C1=0 -> T=[] ; true)
1606 ; C1=MaxCard),
1607 % TO DO: try to enumerate elements in order
1608 ? ordered_pair(LastPair,X,Y,not_equal),
1609 ? check_element_of_wf(X,Domain,WF),
1610 ? check_element_of_wf(Y,Range,WF),
1611 ? not_element_of_wf((X,Y),SoFar,WF),
1612 update_waitflag(MaxNrOfRels,WFR,NewWFR,WF),
1613 ? relation_over2(T,[(X,Y)|SoFar],Domain,Range,WF,NewWFR,C1,MaxNrOfRels,NewLastPair).
1614
1615 % check that new pair is greater than previous pair, if that pair was freely chosen
1616 ordered_pair(none,_,_,_).
1617 ordered_pair((LastX,LastY),NewX,NewY,Eq) :- ordered_value(LastX,NewX,EqualX),
1618 check_second_component(EqualX,LastY,NewY,Eq).
1619
1620 :- block check_second_component(-,?,?,?).
1621 check_second_component(equal,X,Y,EqRes) :- ordered_value(X,Y,EqRes).
1622 check_second_component(not_equal,_X,_Y,not_equal). % no need to check 2nd component
1623
1624 :- block ordered_value(-,?,?), ordered_value(?,-,?).
1625 ordered_value(pred_true /* bool_true */,B,Eq) :- !, (B=pred_true /* bool_true */ -> Eq=equal ; Eq=not_equal).
1626 ordered_value(pred_false /* bool_false */,B,Eq) :- !, B=pred_false /* bool_false */, Eq=equal.
1627 ordered_value(int(X),int(Y),Eq) :- !,
1628 kernel_objects:less_than_equal_direct(X,Y), equal_atomic_term(X,Y,Eq).
1629 ordered_value(fd(NrX,T),fd(NrY,T),Eq) :- !,
1630 ? kernel_objects:less_than_equal_direct(NrX,NrY),
1631 equal_atomic_term(NrX,NrY,Eq).
1632 ordered_value((X1,X2),(Y1,Y2),Eq) :- !, ordered_pair((X1,X2),Y1,Y2,Eq).
1633 ordered_value(string(X),string(Y),Eq) :- !, less_equal_atomic_term(X,Y,Eq).
1634 ordered_value(rec(FX),rec(FY),Eq) :- !,
1635 ordered_fields(FX,FY,Eq).
1636 ordered_value([],Y,Eq) :- !, (Y==[] -> Eq=equal ; Eq=not_equal). % empty set is the smallest set
1637 ordered_value(avl_set(A),Y,Eq) :- !,
1638 (Y==[] -> fail
1639 ; Y=avl_set(B) -> (A @< B -> Eq=not_equal ; A@>B -> fail ; Eq=equal)
1640 ; Eq=not_equal). % assuming strictly ordered; TO DO: treat sets better
1641 ordered_value([H|T],Y,Eq) :- !, ordered_value_cons(Y,H,T,Eq).
1642 ordered_value(term(T1),term(T2),Eq) :- !, ordered_term_value(T1,T2,Eq).
1643 ordered_value(global_set(G1),global_set(G2),Eq) :- !, % must be equal, otherwise type error
1644 G1=G2, Eq=equal. % occurs for Alloy/PerformanceTests/SimpleGraphSig.als
1645 ordered_value(_A,_B,not_equal). % assuming strictly ordered
1646
1647 :- block ordered_term_value(-,?,?),ordered_term_value(?,-,?).
1648 ordered_term_value(floating(F1),floating(F2),Eq) :- !,
1649 kernel_reals:real_less_than_equal_wf(term(floating(F1)),term(floating(F2)),no_wf_available),
1650 equal_atomic_term(F1,F2,Eq).
1651 ordered_term_value(_A,_B,not_equal). % assuming strictly ordered
1652
1653 ordered_value_cons([],_,_,_) :- !,fail.
1654 ordered_value_cons([H2|T2],H,T,Eq) :- !,ordered_pair((H,T),H2,T2,Eq). % Note: order different than for avl_sets!
1655 ordered_value_cons(_Y,_H,_T,not_equal). % assuming strictly ordered
1656
1657 :- block ordered_fields(-,?,?).
1658 ordered_fields([],RHS,Eq) :- !,RHS=[], Eq=equal.
1659 ordered_fields([field(Name,ValX)|TX],RHS,Eq) :- !,RHS=[field(Name,ValY)|TY],
1660 ordered_value(ValX,ValY,Equal1), check_next_field(Equal1,TX,TY,Eq).
1661 ordered_fields(FX,FY,Eq) :- add_internal_error('Unknown fields: ',ordered_fields(FX,FY,Eq)), Eq=not_equal.
1662
1663 :- block check_next_field(-,?,?,?).
1664 check_next_field(equal,TX,TY,EqRes) :- ordered_fields(TX,TY,EqRes).
1665 check_next_field(not_equal,_X,_Y,not_equal). % no need to check next field
1666
1667 :- block less_equal_atomic_term(-,?,?), less_equal_atomic_term(?,-,?).
1668 less_equal_atomic_term(A,B,Res) :- (A==B -> Res=equal ; A @<B, Res=not_equal).
1669
1670 :- block equal_atomic_term(-,?,?), equal_atomic_term(?,-,?).
1671 equal_atomic_term(A,B,Res) :- (A==B -> Res=equal ; Res=not_equal).
1672
1673
1674 :- assert_must_succeed(exhaustive_kernel_check( kernel_relations:not_relation_over([(int(1),int(2)),(int(2),int(1))],[int(1),int(2)],[int(2)],_WF) )).
1675 :- assert_must_succeed(exhaustive_kernel_check( kernel_relations:not_relation_over([(int(1),int(2))],[],[int(2)],_WF) )).
1676 :- assert_must_succeed(exhaustive_kernel_fail_check( kernel_relations:not_relation_over([(int(1),pred_true)],[int(1)],[pred_true],_WF) )).
1677 :- assert_must_succeed(exhaustive_kernel_fail_check( kernel_relations:not_relation_over([],[int(1)],[pred_true],_WF) )).
1678 :- assert_must_succeed( kernel_relations:not_relation_over([(int(1),int(2))],[int(3)],[int(1),int(2)],_) ).
1679 :- assert_must_succeed( kernel_relations:not_relation_over([(int(1),int(2))],[int(1)],[int(3)],_) ).
1680 :- assert_must_succeed( kernel_relations:not_relation_over([(int(1),int(3)),(int(1),int(2))],[int(1)],[int(3)],_) ).
1681 :- assert_must_fail( kernel_relations:not_relation_over([(int(1),int(3))],[int(1)],[int(3)],_) ).
1682 :- assert_must_fail( kernel_relations:not_relation_over([],[int(1)],[int(3)],_) ).
1683 :- assert_must_fail( kernel_relations:not_relation_over([],[],[],_) ).
1684 :- block not_relation_over(-,?,?,?).
1685
1686 not_relation_over(FF,Domain,Range,WF) :- nonvar(FF),custom_explicit_sets:is_definitely_maximal_set(Range),
1687 % we do not need the Range; this means we can match more closures (e.g., lambda)
1688 custom_explicit_sets:dom_for_specific_closure(FF,FFDomain,_,WF),!,
1689 not_subset_of_wf(FFDomain,Domain,WF).
1690 not_relation_over(FF,Domain,Range,WF) :- nonvar(FF),
1691 custom_explicit_sets:dom_range_for_specific_closure(FF,FFDomain,FFRange,_,WF),!,
1692 not_both_subset_of(FFDomain,FFRange,Domain,Range,WF).
1693 /* could be slightly more efficient: but not clear if warrants additional complexity in code:
1694 not_relation_over(FF,Domain,Range,WF) :- nonvar(FF),
1695 check_element_can_be_decided(Domain), % ensures that check_element_of_wf will not block below
1696 check_element_can_be_decided(Range), % ensures that check_element_of_wf will not block below
1697 expand_and_convert_to_avl_set(FF,AER,no_relation_over,''),!,
1698 (is_avl_relation_over_domain(AER,Domain,WF)
1699 -> \+ is_avl_relation_over_range(AER,Range,WF)
1700 ; true).
1701 check_element_can_be_decided(X) :- var(X),!,fail.
1702 check_element_can_be_decided(avl_set(_)).
1703 check_element_can_be_decided([]).
1704 check_element_can_be_decided(closure(P,T,B)) :-
1705 custom_explicit_sets:is_interval_closure_or_integerset(closure(P,T,B),Low,Up),
1706 ground(Low), ground(Up).
1707 */
1708 not_relation_over(R,Dom,Ran,WF) :-
1709 expand_custom_set_to_list_wf(R,ER,_,not_relation_over,WF),
1710 %% print(not_rel(ER,Dom,Ran)),nl,
1711 not_relation_over2(ER,Dom,Ran,WF).
1712
1713
1714 %not_relation_over2(R,_,_) :- when(nonvar(R), (R\=[], R\=[_|_])) . % TYPE ERROR !
1715 :- block not_relation_over2(-,?,?,?).
1716 not_relation_over2([(X,Y)|T],Domain,Range,WF) :-
1717 membership_test_wf(Domain,X,MemRes,WF),
1718 not_relation_over3(MemRes,Y,T,Domain,Range,WF).
1719
1720 :- block not_relation_over3(-,?,?,?,?,?).
1721 not_relation_over3(pred_false,_Y,_T,_Domain,_Range,_WF).
1722 not_relation_over3(pred_true,Y,T,Domain,Range,WF) :-
1723 membership_test_wf(Range,Y,MemRes,WF),
1724 not_relation_over4(MemRes,T,Domain,Range,WF).
1725
1726 :- block not_relation_over4(-,?,?,?,?).
1727 not_relation_over4(pred_false,_T,_Domain,_Range,_WF).
1728 not_relation_over4(pred_true,T,Domain,Range,WF) :-
1729 not_relation_over2(T,Domain,Range,WF).
1730
1731
1732
1733 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:domain_wf([],[],WF),WF)).
1734 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:domain_wf([(int(1),int(3))],[int(1)],WF),WF)).
1735 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:domain_wf(
1736 [(int(0),int(55)),(int(2),int(3)),(int(1),int(3))],[int(1),int(2),int(0)],WF),WF)).
1737 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:domain_wf(
1738 [(int(99),int(55)),(int(2),int(3)),(int(99),int(4))],[int(2),int(99)],WF),WF)).
1739 :- assert_must_succeed((kernel_relations:domain_wf([],Res,_WF),Res=[])).
1740 :- assert_must_succeed((kernel_relations:domain_wf([(int(1),int(2))],Res,_WF),
1741 kernel_objects:equal_object(Res,[int(1)]))).
1742 :- assert_must_succeed((kernel_relations:domain_wf([(int(1),int(2)),(int(1),int(1))],Res,_WF),
1743 kernel_objects:equal_object(Res,[int(1)]))).
1744 :- assert_must_succeed((kernel_relations:domain_wf([(int(2),int(2)),(int(1),int(2))],Res,_WF),
1745 kernel_objects:equal_object(Res,[int(1),int(2)]))).
1746 :- assert_must_succeed((kernel_relations:domain_wf(X,Res,_WF),kernel_objects:equal_object(Res,[int(1),int(3),int(2)]),
1747 kernel_objects:equal_object(X,[(int(2),int(2)),(int(1),int(1)),(int(3),int(2))]))).
1748 :- assert_must_succeed((kernel_relations:domain_wf(X,Res,_WF),kernel_objects:equal_object(Res,[int(1),int(2)]),
1749 kernel_objects:equal_object(X,[(int(2),int(2)),(int(1),int(1)),(int(1),int(2))]))).
1750 :- assert_must_fail((kernel_relations:domain_wf(X,Res,_WF),kernel_objects:equal_object(Res,[int(1),int(2)]),
1751 kernel_objects:equal_object(X,[(int(2),int(2)),(int(1),int(1)),(int(3),int(2))]))).
1752
1753 :- block domain_wf(-,-,?).
1754 domain_wf(Rel,Res,WF) :- Res == [],!,
1755 empty_set_wf(Rel,WF).
1756 domain_wf(Rel,Res,WF) :- var(Rel),!, % hence Res must me nonvar
1757 (is_custom_explicit_set(Res,domain_wf)
1758 -> expand_custom_set_to_list_wf(Res,Res2,_,propagate_result_to_input2,WF) % avoid expanding twice
1759 ; Res2 = Res),
1760 ? propagate_result_to_input(Res2,Rel,domain,WF),
1761 domain_wf1(Rel,Res2,WF).
1762 ?domain_wf(Rel,Res,WF) :- domain_wf1(Rel,Res,WF).
1763
1764
1765 % propagate result of domain/range back to original relation
1766 propagate_result_to_input(Result,OriginalRel,DomOrRange,WF) :-
1767 propagate_empty_set_wf(Result,result,OriginalRel,WF), % this will trigger before LWF ground
1768 (preferences:preference(use_smt_mode,true)
1769 ? -> propagate_result_to_input1(Result,OriginalRel,1,DomOrRange)
1770 % hopefully full CHR implementation will avoid the need for this hack
1771 % ; kernel_objects:is_marked_to_be_computed(OriginalRel) -> true % get_last_wait_flag(propagate_result_to_input,WF,LWF)
1772 ;
1773 get_wait_flag(2000,propagate_result_to_input,WF,LWF), % TO DO: determine right value for Priority ?
1774 % higher number for data_validation mode seems slightly counterproductive (on private_source_not_available tests)
1775 propagate_result_to_input1(Result,OriginalRel,LWF,DomOrRange) % this slows down test 289 if not guarded, 1088 if guarded
1776 ).
1777
1778 :- block propagate_result_to_input1(-,?,?,?), propagate_result_to_input1(?,-,-,?).
1779 % Note: if arg 2 (Rel) is known we will not propagate
1780 propagate_result_to_input1([],Rel,_,_) :- !, empty_set(Rel).
1781 propagate_result_to_input1(Result,Input,LWF,DomOrRange) :-
1782 (kernel_objects:is_marked_to_be_computed(Input) -> true
1783 ? ; propagate_result_to_input2(Result,Input,LWF,DomOrRange)).
1784
1785 %:- block propagate_result_to_input2(-,?).
1786 :- block propagate_result_to_input2(-,?,?,?), propagate_result_to_input2(?,-,-,?).
1787 % maybe do in CHR in future: x:dom(R) => #z.(x,z) : R
1788 % TO DO: make stronger; also support avl_set ...
1789 propagate_result_to_input2([],_Rel,_,_) :- !. % nothing can be said; we could have repeated entries for previous domain elements
1790 propagate_result_to_input2([D|T],Rel,LWF,DomOrRange) :- %print(propagate_result_to_input2([D|T],Rel,LWF,DomOrRange)),nl,
1791 !,
1792 (Rel == [] -> fail % we would need more relation elements to generate the domain/range
1793 ; nonvar(Rel) -> true % no propagation
1794 ; (DomOrRange=domain -> Rel = [(D,_)|RT] ; Rel = [(_,D)|RT]),
1795 ? propagate_result_to_input2(T,RT,LWF,DomOrRange)
1796 ).
1797 propagate_result_to_input2(CS,Rel,LWF,DomOrRange) :- var(Rel), is_custom_explicit_set(CS),!,
1798 expand_custom_set_to_list(CS,Res,_,propagate_result_to_input2),
1799 ? propagate_result_to_input2(Res,Rel,LWF,DomOrRange).
1800 propagate_result_to_input2(_1,_2,_LWF,_DomOrRange).
1801
1802 :- block domain_wf1(-,?,?).
1803 domain_wf1(Rel,Res,WF) :- is_custom_explicit_set(Rel,domain_wf),
1804 domain_of_explicit_set_wf(Rel,Dom,WF), !,
1805 ? equal_object_wf(Dom,Res,domain_wf1,WF).
1806 domain_wf1(Rel,Res,WF) :-
1807 expand_custom_set_to_list_wf(Rel,Relation,_,domain_wf,WF),
1808 ? newdomain1(Relation,[],Res,WF),
1809 quick_propagate_domain(Relation,Res,WF).
1810
1811 :- block quick_propagate_domain(-,?,?).
1812 quick_propagate_domain([],_,_WF).
1813 quick_propagate_domain([(X,_)|T],FullRes,WF) :-
1814 quick_propagation_element_information(FullRes,X,WF,FullRes1), % should we use a stronger check ?
1815 quick_propagate_domain(T,FullRes1,WF).
1816
1817 %:- block newdomain1(-,?,-,?). % why was this commented out ?
1818 :- block newdomain1(-,?,?,?).
1819 /* newdomain1(Rel,SoFar,Res,WF) :- var(Rel), !,
1820 domain_propagate_result(Res,Rel,SoFar,WF). */
1821 ?newdomain1(Dom,SoFar,Res,WF) :- newdomain2(Dom,SoFar,Res,WF).
1822
1823 %:- block newdomain2(-,?,?,?).
1824 ?newdomain2([],_SoFar,Res,WF) :- empty_set_wf(Res,WF).
1825 newdomain2([(X,Y)|T],SoFar,Res,WF) :-
1826 (Res==[]
1827 -> MemRes=pred_true, % no new elements can appear, all Xs must already be in SoFar
1828 ? check_element_of_wf(X,SoFar,WF)
1829 ; membership_test_wf(SoFar,X,MemRes,WF),
1830 % now check that card of Relation is greater or equal to Result; if equal set MemRes to pred_false
1831 % if card(Result)=card(dom(Result)) => all elements in Result must be fresh domain elements
1832 card_greater_equal_check([(X,Y)|T],Res,MemRes)
1833 ),
1834 ? newdomain3(MemRes,X,T,SoFar,Res,WF).
1835
1836 :- block newdomain3(-,?,?,?,?,?).
1837 newdomain3(pred_true,_,T,SoFar,Res,WF) :- newdomain1(T,SoFar,Res,WF).
1838 newdomain3(pred_false,X,T,SoFar,Res,WF) :-
1839 kernel_objects:mark_as_non_free(X,domain), % X is linked to a particular Y -> it is not free
1840 add_element_wf(X,SoFar,SoFar2,WF),
1841 ? equal_cons_wf(Res,X,Res2,WF),
1842 ? newdomain1(T,SoFar2,Res2,WF).
1843
1844
1845 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:in_domain_wf(int(2),[(int(2),int(7))],WF),WF)).
1846 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:in_domain_wf(int(2),[(int(1),int(6)),(int(2),int(7))],WF),WF)). % used to be wfdet; but dom_symbolic can create existential quantifier, not all co-routines/... evaluated in wfdet
1847 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:in_domain_wf(int(22),[(int(1),int(6)),(int(22),int(7)),(int(33),int(7))],WF),WF)). % used to be wfdet (see above)
1848 :- assert_must_succeed((kernel_relations:in_domain_wf(int(1),[(int(1),int(2))],_))).
1849 :- assert_must_succeed((kernel_relations:in_domain_wf(int(3),[(int(1),int(2)),(int(3),int(4))],_))).
1850 :- assert_must_fail((kernel_relations:in_domain_wf(int(3),[],_))).
1851 :- assert_must_fail((kernel_relations:in_domain_wf(int(3),[(int(1),int(2))],_))).
1852 /* a more efficient version than using element_of and computing domain */
1853
1854 % just like not_empty_set_wf but instantiates with (El,_) as first element
1855 ?in_domain_wf(El,S,WF) :- var(S),!, force_in_domain_wf(El,S,WF).
1856 ?in_domain_wf(El,Rel,WF) :- in_domain_wf_lazy(El,Rel,WF).
1857
1858 :- use_module(kernel_non_empty_attr,[mark_var_set_as_non_empty/1]).
1859 % next is also used in apply_to/6
1860 force_in_domain_wf(El,S,WF) :-
1861 (preferences:preference(use_smt_mode,true) -> get_wait_flag0(WF,WF0),
1862 when(ground(WF0),delayed_force_in_domain_wf(El,S,WF))
1863 ; % TO DO: non-empty flag
1864 mark_var_set_as_non_empty(S),
1865 ? get_enumeration_starting_wait_flag(not_empty_domain_wf,WF,LWF), in_domain_lwf(El,S,LWF,WF)).
1866 % delay instantiating S somewhat: it can mess up many other optimisations
1867 % fixes trying to deconstruct infinite set enum warning for test 2022
1868 delayed_force_in_domain_wf(El,S,_WF) :- var(S),!, S=[(El,_)|_]. % TODO: mark _ as irrelevant
1869 delayed_force_in_domain_wf(El,Rel,WF) :- in_domain_wf_lazy(El,Rel,WF).
1870
1871 :- block in_domain_lwf(-,-,-,?).
1872 % was :- block in_domain_lwf(-,?,-,?). but this prevents instantiating El in case Rel becomes known ! see e.g. private_examples/ClearSy/ComparePv10Pv11/DebugPv10/ test 1952, 2270
1873 %:- block in_domain_lwf(-,-,?,?),in_domain_lwf(?,-,-,?). % this annotation fails test 1703
1874 in_domain_lwf(El,Rel,LWF,WF) :- % tools_printing:print_term_summary(in_domain_lwf(El,Rel,LWF)),
1875 (var(Rel) -> ground_value_check(El,GrVal),
1876 ? in_domain_lwf2(El,Rel,LWF,GrVal,WF) % we could also wait at least until WF0 is fully grounded?
1877 ; not_empty_set_unless_closure_wf(Rel,WF),
1878 ? in_domain_wf_lazy(El,Rel,WF)).
1879
1880 :- block in_domain_lwf2(?,-,-,-,?).
1881 in_domain_lwf2(El,Rel,_LWF,_Grval,WF) :- % tools_printing:print_term_summary(in_domain_lwf2(El,Rel,_LWF,_Grval)),
1882 (var(Rel) -> Rel = [(El,_)|_]
1883 % can create a choice point when unifying with large avl_set:, see rule_Rule_DB_PSR_0003_C
1884 % maybe we should delay even further
1885 ; not_empty_set_unless_closure_wf(Rel,WF),
1886 in_domain_wf_lazy(El,Rel,WF)).
1887
1888 not_empty_set_unless_closure_wf(closure(_,_,_),_) :- !. % do not check this; in_domain_wf or other call will find a solution anyway; no need to set up closure constraints twice
1889 not_empty_set_unless_closure_wf(Rel,WF) :- not_empty_set_wf(Rel,WF).
1890
1891 % does not instantiate to [(El,_)|_]
1892 :- block in_domain_wf_lazy(?,-,?).
1893 in_domain_wf_lazy(_DomainElement,[],_WF) :- !,fail.
1894 in_domain_wf_lazy(DomainElement,avl_set(A),WF) :-
1895 ground_value(DomainElement), !,
1896 check_in_domain_of_avlset_wf(DomainElement,A,WF).
1897 % TO DO: check for infinite closures
1898 in_domain_wf_lazy(DomainElement,ES,WF) :-
1899 is_custom_explicit_set(ES,in_domain_wf_lazy),
1900 domain_of_explicit_set_wf(ES,Dom,WF),!,
1901 ? check_element_of_wf(DomainElement,Dom,WF).
1902 in_domain_wf_lazy(El,Rel,WF) :-
1903 expand_custom_set_to_list_wf(Rel,Relation,Done,in_domain_wf_lazy,WF),
1904 get_binary_choice_wait_flag(in_domain_wf_lazy(El),WF,LWF), % TO DO: get_pow2_binary_choice_priority(Len,Prio), get_binary_choice_wait_flag_exp_backoff
1905 % if Done == true -> we can use maybe clpfd_inlist or clpfd:element or quick_propagate
1906 quick_propagation_domain_element_list(Done,Relation,El,WF),
1907 in_domain2(El,Relation,WF,LWF).
1908
1909 % a custom implementation of quick_propagation_element_information for checking domain elements and lists only
1910 :- use_module(clpfd_lists,[try_in_fd_value_list_check/4]).
1911 :- block quick_propagation_domain_element_list(-,?,?,?).
1912 quick_propagation_domain_element_list(_,_,_,_) :- preferences:preference(use_clpfd_solver,false),!.
1913 quick_propagation_domain_element_list(_,_,El,_) :- ground(El),!.
1914 quick_propagation_domain_element_list(_,RelList,El,WF) :-
1915 try_in_fd_value_list_check(RelList,(El,_),couple_left(_),WF). % use couple_left to ignore range values
1916
1917
1918 :- block in_domain2(?,-,?,?).
1919 in_domain2(El,[(X,_Y)|T],WF,LWF) :-
1920 (T==[]
1921 -> equal_object_wf(El,X,in_domain2,WF)
1922 ? ; kernel_objects:equality_objects_lwf(El,X,EqRes,LWF,WF),
1923 in_domain3(EqRes,El,T,WF,LWF)
1924 ).
1925
1926 :- block in_domain3(-,?,?,?,?).
1927 in_domain3(pred_true,_El,_T,_WF,_LWF).
1928 in_domain3(pred_false,El,T,WF,LWF) :-
1929 get_new_subsidiary_wait_flag(LWF,in_domain2(El,T),WF,NewLWF), % not necessary if T only has single element
1930 in_domain2(El,T,WF,NewLWF).
1931
1932
1933 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_in_domain_wf(int(3),[],WF),WF)).
1934 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_in_domain_wf(int(3),[(int(2),int(7))],WF),WF)).
1935 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_in_domain_wf(int(3),[(int(2),int(7)),(int(4),int(3))],WF),WF)).
1936 :- assert_must_succeed(exhaustive_kernel_fail_check_wfdet(kernel_relations:not_in_domain_wf(int(4),[(int(2),int(7)),(int(4),int(3))],WF),WF)).
1937 :- assert_must_fail((kernel_relations:not_in_domain_wf(int(1),[(int(1),int(2))],_))).
1938 :- assert_must_fail((kernel_relations:not_in_domain_wf(int(3),[(int(1),int(2)),(int(3),int(4))],_))).
1939 :- assert_must_succeed((kernel_relations:not_in_domain_wf(int(3),[],_))).
1940 :- assert_must_succeed((kernel_relations:not_in_domain_wf(int(3),[(int(1),int(2))],_))).
1941 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_in_domain_wf(int(3),[(int(1),int(2)),(int(2),int(3))],WF),WF)).
1942 /* a more efficient version than using not_element_of and computing domain */
1943
1944
1945 :- block not_in_domain_wf(?,-,?).
1946 not_in_domain_wf(DomainElement,ES,WF) :- is_custom_explicit_set(ES,not_in_domain),
1947 domain_of_explicit_set_wf(ES,Dom,WF),!,
1948 ? not_element_of_wf(DomainElement,Dom,WF).
1949 not_in_domain_wf(El,Rel,WF) :-
1950 expand_custom_set_to_list_wf(Rel,Relation,_,not_in_domain,WF),
1951 not_in_domain2(Relation,El,WF).
1952 :- block not_in_domain2(-,?,?).
1953 not_in_domain2([],_,_WF).
1954 not_in_domain2([(X,_Y)|T],E,WF) :- not_equal_object_wf(E,X,WF), not_in_domain2(T,E,WF).
1955
1956
1957
1958
1959 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:range_wf([],[],WF),WF)).
1960 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:range_wf([(int(1),int(3))],[int(3)],WF),WF)).
1961 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:range_wf(
1962 [(int(0),int(55)),(int(2),int(3)),(int(1),int(3))],[int(3),int(55)],WF),WF)).
1963 :- assert_must_succeed((kernel_relations:range_wf([],Res,_WF),Res=[])).
1964 :- assert_must_succeed((kernel_relations:range_wf([(int(1),int(2))],Res,_WF),
1965 kernel_objects:equal_object(Res,[int(2)]))).
1966 :- assert_must_succeed((kernel_relations:range_wf([(int(1),int(1)),(int(2),int(1))],Res,_WF),
1967 kernel_objects:equal_object(Res,[int(1)]))).
1968 :- assert_must_succeed((kernel_relations:range_wf([(int(1),int(2)),(int(1),int(1))],Res,_WF),
1969 kernel_objects:equal_object(Res,[int(1),int(2)]))).
1970 :- assert_must_succeed((kernel_relations:range_wf([(int(1),int(2)),(int(1),int(1)),(int(2),int(3))],Res,_WF),
1971 kernel_objects:equal_object(Res,[int(1),int(3),int(2)]))).
1972 :- assert_must_succeed((kernel_relations:range_wf(X,Res,_WF),
1973 X = [(int(1),int(2)),(int(1),int(1)),(int(2),int(3))],
1974 kernel_objects:equal_object(Res,[int(1),int(3),int(2)]))).
1975 :- assert_must_succeed((kernel_relations:range_wf(X,Res,WF), kernel_relations:domain_wf(X,Res2,WF), kernel_objects:equal_object(Res,Res2),
1976 X = [(int(1),int(2)),(int(1),int(1)),(int(2),int(2))])).
1977 :- assert_must_succeed((kernel_relations:range_wf(X,Res,WF), kernel_relations:domain_wf(X,Res2,WF), kernel_objects:equal_object(Res,Res2),
1978 X = [(int(2),int(1)),(int(1),int(2)),(int(2),int(2))])).
1979 :- assert_must_succeed((kernel_relations:range_wf(X,Res,WF), kernel_relations:domain_wf(X,Res2,WF), kernel_objects:equal_object(Res,Res2),
1980 X = [])).
1981 :- assert_must_succeed((kernel_relations:range_wf([([],[]),([int(0)],[int(0)]),
1982 ([int(0),int(1)],[int(0),int(1)]),([int(0),int(2)],[int(0),int(2)]),
1983 ([int(0),int(3)],[int(0),int(3)]),([int(0),int(4)],[int(0),int(4)]),([int(1)],[int(1)]),
1984 ([int(1),int(2)],[int(1),int(2)]),([int(1),int(3)],[int(1),int(3)]),
1985 ([int(1),int(4)],[int(1),int(4)]),([int(2)],[int(2)]),([int(2),int(3)],[int(2),int(3)]),
1986 ([int(2),int(4)],[int(2),int(4)]),([int(3)],[int(3)]),([int(3),int(4)],
1987 [int(3),int(4)]),([int(4)],[int(4)])],_Res,_WF))).
1988 :- assert_must_succeed((kernel_relations:range_wf([([],[]),([int(0)],[int(0)]),
1989 ([int(0),int(1)],[int(0),int(1)]),
1990 ([int(0),int(3)],[int(0),int(3)]),([int(0),int(4)],[int(0),int(4)]),([int(1)],[int(1)]),
1991 ([int(1),int(2)],[int(1),int(2)])],_Res,_WF))).
1992
1993
1994 :- block range_wf(-,-,?).
1995 ?range_wf(Rel,Res,WF) :- Res ==[],!, empty_set_wf(Rel,WF).
1996 range_wf(Rel,Res,WF) :- Rel ==[],!, empty_set_wf(Res,WF).
1997 ?range_wf(Rel,Res,WF) :- range_wf1(Rel,Res,WF),
1998 ? propagate_result_to_input(Res,Rel,range,WF).
1999
2000 :- block range_wf1(-,?,?).
2001 range_wf1(Rel,Res,WF) :-
2002 is_custom_explicit_set(Rel,range_wf1),
2003 range_of_explicit_set_wf(Rel,Range,WF), !,
2004 ? equal_object_wf(Range,Res,range_wf1,WF).
2005 range_wf1(Rel,Res,WF) :-
2006 % TO DO : propagate information that card of Res <= card of Rel; similar thing for domain
2007 expand_custom_set_to_list_wf(Rel,Relation,_,range_wf1,WF),
2008 ? newrange2(Relation,[],Res,WF),
2009 quick_propagate_range(Relation,Res,WF).
2010
2011
2012 :- block quick_propagate_range(-,?,?).
2013 quick_propagate_range([],_,_WF).
2014 quick_propagate_range([(_,Y)|T],FullRes,WF) :-
2015 quick_propagation_element_information(FullRes,Y,WF,FullRes1), % should we use a stronger check ?
2016 quick_propagate_range(T,FullRes1,WF).
2017
2018 :- block newrange2(-,?,?,?).
2019 newrange2([],_SoFar,Res,WF) :-
2020 ? empty_set_wf(Res,WF).
2021 newrange2([(X,Y)|T],SoFar,Res,WF) :-
2022 (Res==[]
2023 -> MemRes=pred_true, check_element_of_wf(Y,SoFar,WF)
2024 ; membership_test_wf(SoFar,Y,MemRes,WF),
2025 ? card_greater_equal_check([(X,Y)|T],Res,MemRes), % check that card of Relation is greater or equal to Result; if equal set MemRes to pred_false
2026 (var(MemRes) -> prop_empty_pred_true(Res,MemRes) %,print(delay_range(Y,T)),nl
2027 % TO DO: we could look further in T if we can decide membership for other elements in T ?
2028 ; true)
2029 ),
2030 ? newrange3(MemRes,Y,T,SoFar,Res,WF).
2031
2032 :- block prop_empty_pred_true(-,?).
2033 prop_empty_pred_true([],R) :- !, R=pred_true.
2034 prop_empty_pred_true(_,_).
2035
2036 % card_greater_equal_check(Set1,Set2,EqFlag) : check that cardinality of Set1 is greater or equal to that of Set2; set EqFlag to pred_false if they are equal
2037 % checking is stopped if EqFlag becomes nonvar
2038 % tested by testcase 1061
2039 :- block card_greater_equal_check(-,?,-), card_greater_equal_check(?,-,-).
2040 card_greater_equal_check(_,_,Flag) :- nonvar(Flag),!. % no longer required; even though we could prune failure !? done later in newrange2/newdomain2 ??!!
2041 card_greater_equal_check([],Set2,Flag) :- !,empty_set(Set2),
2042 Flag=pred_false. % Flag set indicates that both sets have same size
2043 card_greater_equal_check(_,[],_) :- !.
2044 ?card_greater_equal_check([_|T],[_|R],Flag) :- !, card_greater_equal_check(T,R,Flag).
2045 % To do: deal with AVL args as Result + also use efficient_card_for_set for closures
2046 %card_greater_equal_check([_|T],Set,Flag) :- efficient_card_for_set(B,CardB,CodeB),!,
2047 % f: 1..7 -->> 1..n & n>=7 & n<10 still does not work well
2048 % TO DO: can we merge code with check_card_greater_equal
2049 card_greater_equal_check(_,_,_).
2050
2051
2052 :- block newrange3(-,?,?,?,?,?).
2053 ?newrange3(pred_true,_Y,T,SoFar,Res,WF) :- newrange2(T,SoFar,Res,WF).
2054 newrange3(pred_false,Y,T,SoFar,Res,WF) :-
2055 kernel_objects:mark_as_non_free(Y,range), % Y is linked to a particular X -> it is not free
2056 add_element_wf(Y,SoFar,SoFar2,WF),
2057 ? equal_cons_wf(Res,Y,Res2,WF),
2058 ? newrange2(T,SoFar2,Res2,WF).
2059
2060
2061 :- assert_must_succeed((kernel_relations:identity_relation_over_wf([],Res,_WF),Res=[])).
2062 :- assert_must_succeed((kernel_relations:identity_relation_over_wf([int(1),int(2)],Res,_WF),
2063 Res=[(int(1),int(1)),(int(2),int(2))])).
2064 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:identity_relation_over_wf([int(2),int(4)],[(int(4),int(4)),(int(2),int(2))],WF),WF)).
2065 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:identity_relation_over_wf([int(1),int(2),int(4)],[(int(4),int(4)),(int(2),int(2)),(int(1),int(1))],WF),WF)).
2066 :- assert_must_fail((kernel_relations:identity_relation_over_wf([int(1)|_],_,_WF),fail)). /* check: no loop */
2067
2068 :- block identity_relation_over_wf(-,?,?).
2069 identity_relation_over_wf(Set1,IDRel,WF) :-
2070 expand_custom_set_to_list_wf(Set1,ESet1,_,identity_relation_over_wf,WF),
2071 identity_relation_over2(ESet1,IDRel,WF).
2072
2073 :- block identity_relation_over2(-,?,?).
2074 identity_relation_over2([],Res,WF) :- empty_set_wf(Res,WF).
2075 identity_relation_over2([X|T1],Res,WF) :- equal_cons_wf(Res,(X,X),T2,WF), % equal_object([(X,X)|T2],Res),
2076 identity_relation_over2(T1,T2,WF).
2077
2078
2079
2080 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:in_identity((int(1),int(1)),[int(1),int(2)],WF),WF)).
2081 :- assert_must_fail((kernel_relations:in_identity((int(1),int(2)),[int(1),int(2)],_WF))).
2082 :- assert_must_fail((kernel_relations:in_identity((int(3),int(3)),[int(1),int(2)],_WF))).
2083 :- assert_must_fail((kernel_relations:in_identity((int(1),int(2)),[],_WF))).
2084 in_identity((X,Y),Domain,WF) :-
2085 ? equal_object_wf(X,Y,in_identity,WF), check_element_of_wf(X,Domain,WF).
2086
2087 :- assert_must_fail((kernel_relations:not_in_identity((int(1),int(1)),[int(1),int(2)],_WF))).
2088 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_in_identity((int(1),int(2)),[int(1),int(2)],WF),WF)).
2089 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_in_identity((int(3),int(3)),[int(1),int(2)],WF),WF)).
2090 :- assert_must_succeed((kernel_relations:not_in_identity((int(1),int(2)),[],_WF))).
2091 not_in_identity((X,Y),Domain,WF) :-
2092 equality_objects_wf(X,Y,Eq,WF),
2093 not_in_id2(Eq,X,Domain,WF).
2094
2095 :- block not_in_id2(-,?,?,?).
2096 not_in_id2(pred_true,X,Domain,WF) :- not_element_of_wf(X,Domain,WF).
2097 not_in_id2(pred_false,_,_,_).
2098
2099
2100 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:invert_relation_wf([(int(1),int(2)),(int(3),int(4)),(int(5),int(6))], [(int(6),int(5)),(int(2),int(1)),(int(4),int(3))],WF),WF)).
2101 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:invert_relation_wf([(int(1),int(2))], [(int(2),int(1))],WF),WF)).
2102 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:invert_relation_wf([], [],WF),WF)).
2103 :- assert_must_succeed((kernel_relations:invert_relation_wf(X,X,_),X = [])).
2104 :- assert_must_succeed((kernel_relations:invert_relation_wf(X,X,_),X = [(int(2),int(2))])).
2105 :- assert_must_succeed((kernel_relations:invert_relation_wf(X,[(int(1),int(2)),(int(7),int(6))],_WF),
2106 X = [(int(2),int(1)),(int(6),int(7))])).
2107 :- assert_must_succeed((kernel_relations:invert_relation_wf([(int(1),int(2)),(int(7),int(6))],X,_WF),
2108 X = [(int(2),int(1)),(int(6),int(7))])).
2109 :- assert_must_succeed((kernel_relations:invert_relation_wf([(int(1),int(2)),(int(7),int(6))],
2110 [(int(6),int(7)),(int(2),int(1))],_WF))).
2111 :- assert_must_succeed((kernel_relations:invert_relation_wf(closure([a,b],[string,boolean],b(truth,pred,[])),
2112 closure([b,a],[boolean,string],b(truth,pred,[])),_WF))).
2113
2114 :- block invert_relation_wf(-,-,?).
2115 invert_relation_wf(R,IR,WF) :-
2116 % (nonvar(R) -> invert_relation2(R,IR) ; invert_relation2(IR,R)).
2117 ? invert_relation2(R,IR,WF). % , print_term_summary(invert_relation(R,IR)).
2118 /* Optimization for some types of closures: Instead of expanding the closures, we just
2119 swap the parameters. This does not work with closures wich have only one parameter
2120 wich is a pair */
2121 invert_relation2(CS,R,WF) :- nonvar(CS),is_custom_explicit_set_nonvar(CS),!,
2122 ? invert_explicit_set(CS,ICS), equal_object_wf(R,ICS,invert_relation2_1,WF).
2123 invert_relation2(R,CS,WF) :- nonvar(CS),is_custom_explicit_set_nonvar(CS),!,
2124 invert_explicit_set(CS,ICS), equal_object_wf(R,ICS,invert_relation2_2,WF).
2125 %invert_relation2(closure([P1,P2],[T1,T2],Clo),closure([P2,P1],[T2,T1],Clo)) :- !.
2126 invert_relation2(R,IR,WF) :- %try_expand_custom_set_wf(R,ER,invert,WF),
2127 % (nonvar(R) -> invert_relation3(R,IR)
2128 % ; invert_relation3(IR,R),(ground(IR)-> true ; invert_relation3(R,IR))).
2129 ? invert_relation3(R,IR,WF,1), invert_relation3(IR,R,WF,1).
2130
2131 :- block invert_relation3(-,?,?,?).
2132 invert_relation3(closure(P,T,B),Res,WF,_) :- invert_explicit_set(closure(P,T,B),ICS),
2133 equal_object_wf(Res,ICS,invert_relation3_1,WF).
2134 invert_relation3(avl_set(S),Res,WF,_) :- invert_explicit_set(avl_set(S),ICS),
2135 equal_object_wf(Res,ICS,invert_relation3_2,WF).
2136 ?invert_relation3([],Res,WF,_) :- empty_set_wf(Res,WF).
2137 invert_relation3([(X,Y)|T],Res,WF,Depth) :-
2138 D1 is Depth+1, get_wait_flag(D1,invert_relation3,WF,LWF),
2139 equal_cons_lwf(Res,(Y,X),IT,LWF,WF),
2140 ? invert_relation3(T,IT,WF,D1).
2141
2142
2143
2144
2145 ?tuple_of(X,Y,R) :- check_element_of((X,Y),R).
2146 %tuple_of_wf(X,Y,R,WF) :- check_element_of_wf((X,Y),R,WF).
2147
2148
2149 % RELATIONAL COMPOSITION (;)
2150
2151 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:in_composition_wf((int(11),int(22)),
2152 [(int(11),int(33))],[(int(33),int(22))],WF),WF)).
2153 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:in_composition_wf((int(11),int(22)),
2154 [(int(11),int(12)),(int(11),int(33))],
2155 [(int(33),int(12)),(int(33),int(22))],WF),WF)).
2156 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:in_composition_wf((int(11),int(12)),
2157 [(int(11),int(12)),(int(11),int(33))],
2158 [(int(33),int(12)),(int(33),int(22))],WF),WF)).
2159 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:in_composition_wf((int(11),int(22)),
2160 [(int(11),[int(33),int(32)])],
2161 [([int(32),int(33)],int(22))],WF),WF)).
2162 :- assert_must_succeed(exhaustive_kernel_fail_check_wfdet(kernel_relations:in_composition_wf((int(11),int(33)),
2163 [(int(11),int(12)),(int(11),int(33))],
2164 [(int(33),int(12)),(int(33),int(22))],WF),WF)).
2165 % check if (X,Y) element of (F ; G)
2166 in_composition_wf((X,Y),F,G,WF) :-
2167 check_element_of_wf((X,Z1),F,WF), % no need to enumerate Z (TODO: check)
2168 equal_object_wf(Z1,Z2,check_element_of_wf,WF),
2169 check_element_of_wf((Z2,Y),G,WF).
2170
2171 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:not_in_composition_wf((int(11),int(33)),
2172 [(int(11),int(33))],[(int(33),int(22))],WF),WF)).
2173 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:not_in_composition_wf((int(33),int(22)),
2174 [(int(11),int(33))],[(int(33),int(22))],WF),WF)).
2175
2176 % just evaluates arguments; TODO: improve or at least pass Type (for symbolic composition)
2177 not_in_composition_wf(Couple,F,G,WF) :-
2178 rel_composition_wf(F,G,Comp,_UnknownType,WF),
2179 not_element_of_wf(Couple,Comp,WF).
2180
2181 :- assert_must_succeed(exhaustive_kernel_check(kernel_relations:rel_composition([(int(1),int(2)),(int(3),int(4)),(int(5),int(6))], [(int(6),int(7)),(int(2),int(1)),(int(22),int(22)),(int(4),int(33))],
2182 [(int(1),int(1)),(int(5),int(7)),(int(3),int(33))]))).
2183 :- assert_must_succeed(exhaustive_kernel_check(kernel_relations:rel_composition([], [(int(6),int(7)),(int(2),int(1)),(int(22),int(22)),(int(4),int(33))],[]))).
2184 :- assert_must_succeed(exhaustive_kernel_check(kernel_relations:rel_composition([(int(6),int(7)),(int(2),int(1)),(int(22),int(22)),(int(4),int(33))],[],[]))).
2185 :- assert_must_succeed(exhaustive_kernel_check(kernel_relations:rel_composition([],[],[]))).
2186 :- assert_must_succeed((kernel_relations:rel_composition([(int(1),int(2)),(int(7),int(6))],
2187 [(int(1),int(11))],X),X = [])).
2188 :- assert_must_succeed((kernel_relations:rel_composition([(int(1),int(2)),(int(7),int(6))],[],X),X = [])).
2189 :- assert_must_succeed((kernel_relations:rel_composition([(int(1),int(2)),(int(7),int(6))],
2190 [(int(2),int(11))],X),
2191 kernel_objects:equal_object(X,[(int(1),int(11))]))).
2192 :- assert_must_succeed((kernel_relations:rel_composition([(int(1),int(2)),(int(7),int(2))],[(int(2),int(11))],X),
2193 ground(X), kernel_relations:equal_object(X,[(int(1),int(11)),(int(7),int(11))]))).
2194 :- assert_must_succeed((kernel_relations:rel_composition([(int(1),int(2)),(int(7),int(5))],
2195 [(int(2),int(11)),(int(2),int(4))],X),
2196 kernel_objects:equal_object(X,[(int(1),int(11)),(int(1),int(4))]))).
2197 :- assert_must_succeed((kernel_relations:rel_composition([(int(1),int(2)),(int(1),int(5))],
2198 [(int(2),int(11)),(int(5),int(11))],X),
2199 kernel_objects:equal_object(X,[(int(1),int(11))]))).
2200 :- assert_must_succeed((kernel_relations:rel_composition([(int(1),[int(1)]),(int(1),[int(2),int(5)])],
2201 [([int(1),int(2)],int(13)),([int(5),int(2)],int(12))],X),
2202 kernel_objects:equal_object(X,[(int(1),int(12))]))).
2203
2204 rel_composition(Rel1,Rel2,Comp) :- % only used in unit_tests above
2205 init_wait_flags(WF,[rel_composition]),
2206 rel_composition_wf(Rel1,Rel2,Comp,_UnknownType,WF),
2207 ground_wait_flags(WF).
2208
2209 :- block rel_composition_wf(-,-,?,?,?).
2210 rel_composition_wf(Rel1,Rel2,Comp,_,WF) :-
2211 (Rel1==[] ; Rel2==[]),
2212 !,
2213 empty_set_wf(Comp,WF).
2214 rel_composition_wf(Rel1,Rel2,Comp,Type,WF) :-
2215 opt_push_wait_flag_call_stack_info(WF,b_operator_call(composition,[Rel1,Rel2],unknown),WF2),
2216 ? rel_composition1(Rel1,Rel2,Comp,Type,WF2).
2217
2218 :- use_module(closures,[is_infinite_non_injective_closure/1]).
2219
2220 :- block rel_composition1(-,?,?,?,?),rel_composition1(?,-,?,?,?).
2221 rel_composition1(Rel1,Rel2,Comp,_,WF) :-
2222 (Rel1==[] ; Rel2==[]),!, empty_set_wf(Comp,WF).
2223 rel_composition1(Rel1,Rel2,Comp,Type,WF) :- keep_symbolic(Rel1),
2224 ? (Rel2 = avl_set(_), \+ is_infinite_non_injective_closure(Rel1)
2225 -> SYMBOLIC=false
2226 ; SYMBOLIC=symbolic),
2227 symbolic_composition(Rel1,Rel2,SYMBOLIC,Type,Rel3),
2228 !,
2229 equal_object_wf(Comp,Rel3,rel_composition1_0,WF).
2230 rel_composition1(Rel1,Rel2,Comp,_,WF) :-
2231 rel_composition_for_explicit_set(Rel1,Rel2,Res),!, % treats finite Rel1 and avl_set for Rel2
2232 ? equal_object_wf(Res,Comp,rel_composition1_1,WF).
2233 rel_composition1(Rel1,Rel2,Comp,Type,WF) :- Rel2=closure(_,_,_),
2234 keep_symbolic(Rel2),
2235 % we know keep_symbolic(Rel1) is false
2236 ? (dom_for_specific_closure(Rel2,Domain,function(_),WF) % TO DO: also deal with relations; in SYMBOLIC mode this may be counter productive; see function_composition ast cleanup rule
2237 -> !,
2238 on_enumeration_warning(expand_custom_set_to_list_wf(Rel1,Relation1,_,rel_composition1,WF),R=failed),
2239 (R==failed % expansion of Rel1 failed; use symbolic composition
2240 -> symbolic_composition(Rel1,Rel2,true,Type,Rel3),
2241 equal_object_optimized(Rel3,Comp,rel_composition1_4)
2242 ? ; rel_compose_with_inf_fun(Relation1,Domain,Rel2,Comp,WF)
2243 % this is like map Rel2 over Rel1 in functional programmming
2244 )
2245 ; symbolic_composition(Rel1,Rel2,false,Type,Rel3),
2246 !,
2247 expand_custom_set_wf(Rel3,CRes,rel_composition,WF),% do we need to expand ?
2248 equal_object_optimized(CRes,Comp,rel_composition1_4)
2249 ).
2250 rel_composition1(Rel1,Rel2,Comp,_,WF) :-
2251 expand_custom_set_to_list_wf(Rel1,Relation1,_,rel_composition1_2,WF),
2252 expand_custom_set_to_list_wf(Rel2,Relation2,_,rel_composition1_3,WF),
2253 rel_compose2(Relation1,Relation2,Comp,WF).
2254
2255
2256 :- use_module(btypechecker, [l_unify_types_strict/2]).
2257 symbolic_composition(Rel1,Rel2,SYMBOLIC,Type,Rel3) :-
2258 get_set_type(Type,couple(TX,TZ)),
2259 mnf_get_relation_types(Rel1,TX1,TY1),
2260 mnf_get_relation_types(Rel2,TY2,TZ2),
2261 (l_unify_types_strict([TX1,TY1,TZ],[TX,TY2,TZ2]) -> true
2262 ; add_internal_error('Could not unify range/domain types: ',l_unify_types_strict([TX1,TY1,TZ],[TX,TY2,TZ2])),
2263 fail
2264 ),
2265 ground((TX1,TY1,TZ)), % avoid creating a closure with non-ground type list
2266 rel_comp_closure(Rel1,Rel2,TX1,TY1,TZ,SYMBOLIC,Rel3).
2267 % generate a closure for {xx,zz | #(yy).(xx|->yy : Rel1 & yy|->zz : Rel2)}
2268 % TO DO: maybe detect special cases: Rel1 is a function/cartesian product, e.g., (((0 .. 76) * (0 .. 76)) * {FALSE}) ; {(FALSE|->0),(TRUE|->1)}
2269 :- use_module(bsyntaxtree, [conjunct_predicates_with_pos_info/3,update_used_ids/3 ]).
2270 rel_comp_closure(Rel1,Rel2,TX,TY,TZ,SYMBOLIC,closure(Args,Types,CBody)) :-
2271 Args = ['_rel_comp1','_rel_comp2'], Types = [TX,TZ],
2272 couple_member_pred('_rel_comp1',TX,'_zzzz_unary',TY,Rel1, Pred1),
2273 couple_member_pred('_zzzz_unary',TY,'_rel_comp2',TZ,Rel2, Pred2),
2274 UsedIds = ['_rel_comp1','_rel_comp2','_zzzz_unary'], % avoid having to call find_identifier_uses
2275 %conjunct_predicates([Pred1,Pred2],P12a), bsyntaxtree:check_computed_used_ids(P12a,UsedIds),
2276 %safe_create_texpr(conjunct(Pred1,Pred2),pred,[used_ids(UsedIds)],P12),
2277 conjunct_predicates_with_pos_info(Pred1,Pred2,P12a),
2278 update_used_ids(P12a,UsedIds,P12),
2279 %b_interpreter_components:create_unsimplified_exists([b(identifier('_zzzz_unary'),TY,[])],P12,Body),
2280 bsyntaxtree:create_exists_opt_liftable([b(identifier('_zzzz_unary'),TY,[])],P12,Body), % cf Thales_All/rule_zcpa2 test 2287
2281 (SYMBOLIC==symbolic
2282 -> mark_bexpr_as_symbolic(Body,CBody)
2283 ; CBody=Body).
2284
2285 % generate predicate for X|->Y : Rel
2286 couple_member_pred(X,TX,Y,TY,Rel, Pred) :-
2287 Pred = b(member(b(couple(b(identifier(X),TX,[]),
2288 b(identifier(Y),TY,[])),couple(TX,TY),[]),
2289 b(value(Rel),set(couple(TX,TY)),[])),pred,[]).
2290
2291 :- block rel_compose2(-,?,?,?).
2292 rel_compose2([],_,Out,WF) :- empty_set_wf(Out,WF).
2293 rel_compose2([(X,Y)|T],Rel2,Out,WF) :-
2294 rel_extract(Rel2,X,Y,OutXY,[],WF),
2295 % rel_extract(Rel2,X,Y,Out,OutRem),
2296 rel_compose2(T,Rel2,OutRem,WF),
2297 union_wf(OutRem,OutXY,Out,WF). % used to call union wihout wf; makes test 1394 fail
2298
2299 :- block rel_extract(-,?,?,?,?,?).
2300 rel_extract([],_,_,Rem,Rem,_WF). % should we use equal_object here ?????
2301 rel_extract([(Y1,Z)|T],X,Y,Res,Rem,WF) :-
2302 rel_extract(T,X,Y,CT,Rem,WF),
2303 equality_objects_wf(Y1,Y,EqRes,WF),
2304 rel_extract2(EqRes,Z,X,CT,Res,WF).
2305
2306 :- block rel_extract2(-,?,?,?,?,?).
2307 ?rel_extract2(pred_true, Z, X,CT,Res,WF) :- add_element_wf((X,Z),CT,Res,WF).
2308 rel_extract2(pred_false,_Z,_X,CT,Res,_WF) :- Res = CT.
2309
2310
2311 % relational composition of a finite relation with an infinite or symbolic function
2312 rel_compose_with_inf_fun(R,Dom,Fun,CompRes,WF) :-
2313 ? rel_compose_with_inf_fun_acc(R,Dom,Fun,[],CompRes,WF).
2314 :- block rel_compose_with_inf_fun_acc(-,?,?,?,?,?).
2315 rel_compose_with_inf_fun_acc([],_Dom,_Rel2,Acc,Comp,WF) :-
2316 ? equal_object_wf(Comp,Acc,rel_compose_with_inf_fun_acc,WF).
2317 rel_compose_with_inf_fun_acc([(X,Y)|T],Dom,Fun,Acc,CompRes,WF) :-
2318 membership_test_wf(Dom,Y,MemRes,WF), % check if Y is in the domain of the symbolic relation
2319 ? rel_compose_with_inf_fun_acc_aux(MemRes,X,Y,T,Dom,Fun,Acc,CompRes,WF).
2320
2321 :- block rel_compose_with_inf_fun_acc_aux(-,?,?,?, ?,?,?,?, ?).
2322 rel_compose_with_inf_fun_acc_aux(pred_true,X,Y,T,Dom,Fun,Acc,CompRes,WF) :-
2323 ? apply_to(Fun,Y,FY,WF), % TO DO: generalize to image so that we can apply it also to infinite relations ?
2324 add_element_wf((X,FY),Acc,NewAcc,WF),
2325 ? rel_compose_with_inf_fun_acc(T,Dom,Fun,NewAcc,CompRes,WF).
2326 rel_compose_with_inf_fun_acc_aux(pred_false,_X,_Y,T,Dom,Fun,Acc,Comp,WF) :-
2327 rel_compose_with_inf_fun_acc(T,Dom,Fun,Acc,Comp,WF).
2328
2329 % TO DO: if we obtain a list such as [(int(1),X),...] in Acc rather than an avl_set,
2330 % we may still be able to sort and avoid quadratic comparisons if e.g.
2331 % first component is a data-type where equality can be decided by unification (integer, bool, global(GS), ...)
2332 % we could put the optimisation into add_element_wf ?
2333 % TO DO: special version for avl_set as relation?
2334
2335 /*
2336 Note: old version; has performance problem, 2021/02_Feb/CDS
2337 the add_element_wf calls below can only construct/instantiate result when empty_set_wf reached
2338 and a lot of pending co-routines pile up for long relation lists
2339
2340 :- block rel_compose_with_inf_fun(-,?,?,?,?).
2341 rel_compose_with_inf_fun([],_Dom,_Rel2,Comp,WF) :- empty_set_wf(Comp,WF).
2342 rel_compose_with_inf_fun([(X,Y)|T],Dom,Fun,CompRes,WF) :-
2343 membership_test_wf(Dom,Y,MemRes,WF), rel_compose_with_inf_fun_aux(MemRes,X,Y,T,Dom,Fun,CompRes,WF).
2344
2345 :- block rel_compose_with_inf_fun_aux(-,?,?,?, ?,?,?,?).
2346 rel_compose_with_inf_fun_aux(pred_true,X,Y,T,Dom,Fun,CompRes,WF) :-
2347 apply_to(Fun,Y,FY,WF),
2348 add_element_wf((X,FY),CT,CompRes,WF),
2349 rel_compose_with_inf_fun(T,Dom,Fun,CT,WF).
2350 rel_compose_with_inf_fun_aux(pred_false,_X,_Y,T,Dom,Fun,Comp,WF) :-
2351 rel_compose_with_inf_fun(T,Dom,Fun,Comp,WF).
2352 */
2353
2354 :- assert_must_abort_wf(kernel_relations:rel_iterate_wf([],int(-1),_R,set(couple(integer,integer)),WF),WF).
2355 :- assert_must_succeed(exhaustive_kernel_check(kernel_relations:rel_iterate_wf([], int(2),[],set(couple(integer,integer)),_WF))).
2356 :- assert_must_succeed(exhaustive_kernel_check(kernel_relations:rel_iterate_wf([(int(1),int(2)),(int(3),int(4)),(int(5),int(6))], int(1),[(int(1),int(2)),(int(3),int(4)),(int(5),int(6))],set(couple(integer,integer)),_WF))).
2357 :- assert_must_succeed(exhaustive_kernel_check(kernel_relations:rel_iterate_wf([(pred_true,pred_true)], int(0),
2358 [(pred_true,pred_true),(pred_false,pred_false)],set(couple(boolean,boolean)),_WF))).
2359 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:rel_iterate_wf([(int(1),int(2)),
2360 (int(2),int(4)),(int(4),int(6))], int(2),[(int(1),int(4)),(int(2),int(6))],
2361 set(couple(integer,integer)),WF),WF)).
2362 :- assert_must_succeed((kernel_relations:rel_iterate_wf(R,int(1),X,set(couple(integer,integer)),_WF), R=[],
2363 kernel_relations:equal_object(X,R))).
2364 :- assert_must_succeed((kernel_relations:rel_iterate_wf(R,int(1),X,set(couple(integer,integer)),_WF),
2365 R=[(int(1),int(2)),(int(2),int(3))],
2366 kernel_relations:equal_object(X,R))).
2367 :- assert_must_succeed((kernel_relations:rel_iterate_wf(R,int(2),X,set(couple(integer,integer)),_WF),
2368 R=[(int(1),int(2)),(int(2),int(3))],
2369 kernel_relations:equal_object(X,[(int(1),int(3))]))).
2370 :- assert_must_succeed((kernel_relations:rel_iterate_wf(R,int(3),X,set(couple(integer,integer)),_WF),
2371 R=[(int(1),int(2)),(int(2),int(3))],
2372 kernel_relations:equal_object(X,[]))).
2373 :- assert_must_succeed((kernel_relations:rel_iterate_wf(R,int(3),X,set(couple(integer,integer)),_WF),
2374 R=[(int(1),int(2)),(int(2),int(3)),(int(1),int(1))],
2375 kernel_relations:equal_object(X,[(int(1),int(1)),(int(1),int(2)),(int(1),int(3))]))).
2376
2377 rel_iterate_wf(Rel,int(Nr),Res,Type,WF) :-
2378 opt_push_wait_flag_call_stack_info(WF,b_operator_call(iterate,
2379 [Nr,Rel],unknown),WF2),
2380 rel_iterate1(Nr,Rel,Res,Type,WF2).
2381
2382 :- block rel_iterate1(-,?,?,?,?).
2383 rel_iterate1(X,Rel,Res,Type,WF) :-
2384 %value_variables(Rel,GrV),
2385 rel_iterate2(X,Rel,Res,Type,WF).
2386
2387 rel_iterate2(X,Rel,Res,Type,WF) :-
2388 ( X=1 -> equal_object_wf(Res,Rel,rel_iterate2,WF)
2389 ; X>1 -> X1 is X-1,
2390 rel_iterate2(X1,Rel,R1,Type,WF),
2391 rel_composition_wf(Rel,R1,Res,Type,WF)
2392 ; X=0 -> rel_iterate0(Rel,Type,Res,WF)
2393 ; add_wd_error('negative index in iterate',X,WF)
2394 ).
2395
2396 :- use_module(bsyntaxtree,[get_set_type/2]).
2397 :- block rel_iterate0(?,-,?,?).
2398 rel_iterate0(_Rel,EType,Res,WF) :-
2399 get_set_type(EType,couple(Type,Type)),
2400 event_b_identity_for_type(Type,Res,WF).
2401
2402 :- use_module(typing_tools,[is_infinite_type/1]).
2403 event_b_identity_for_type(Type,Res,WF) :-
2404 create_texpr(identifier('_zzzz_unary'),Type,[],TIdentifier1), % was [generated]
2405 create_texpr(identifier('_zzzz_binary'),Type,[],TIdentifier2), % was [generated]
2406 (is_infinite_type(Type) -> Info = [prob_annotation('SYMBOLIC')] ; Info =[]),
2407 create_texpr(equal(TIdentifier1,TIdentifier2),pred,Info,TPred),
2408 construct_closure(['_zzzz_unary','_zzzz_binary'],[Type,Type],TPred,CRes),
2409 % for small types we could do: all_objects_of_type(Type,All), identity_relation_over_wf(All,CRes,WF)
2410 %, print(constructed_eventb_identity(Res)),nl
2411 equal_object_wf(Res,CRes,WF).
2412
2413
2414 :- assert_must_succeed(exhaustive_kernel_check(kernel_relations:direct_product_wf([],[(int(1),int(11))],[],_WF))).
2415 :- assert_must_succeed(exhaustive_kernel_check(kernel_relations:direct_product_wf([(int(1),int(2)),(int(7),int(6))],
2416 [(int(1),int(11))],[(int(1),(int(2),int(11)))],_WF))).
2417 :- assert_must_succeed(exhaustive_kernel_check(kernel_relations:direct_product_wf([(int(1),int(2)),(int(7),int(6))],
2418 [(int(2),int(11))],[],_WF))).
2419 :- assert_must_succeed((kernel_relations:direct_product_wf([(int(1),int(2)),(int(7),int(6))],
2420 [(int(2),int(11))],X,_WF),
2421 X = [])).
2422 :- assert_must_succeed((kernel_relations:direct_product_wf([(int(1),int(2)),(int(7),int(6))],
2423 [(int(1),int(11))],X,_WF),
2424 kernel_objects:equal_object(X,[(int(1),(int(2),int(11)))]))).
2425 :- assert_must_succeed((kernel_relations:direct_product_wf([(int(1),int(2)),(int(1),int(6))],
2426 [(int(1),int(11))],X,_WF),
2427 kernel_objects:equal_object(X,[(int(1),(int(2),int(11))),(int(1),(int(6),int(11)))]))).
2428 :- assert_must_succeed((kernel_relations:direct_product_wf([(int(1),int(2)),(int(2),int(6))],
2429 [(int(1),int(11)),(int(1),int(12))],X,_WF),
2430 kernel_objects:equal_object(X,[(int(1),(int(2),int(11))),(int(1),(int(2),int(12)))]))).
2431 :- assert_must_succeed((kernel_relations:direct_product_wf([(int(1),int(2)),(int(2),int(6))],
2432 [(int(1),int(11)),(int(1),int(12))],
2433 [(int(1),(int(2),int(11))),(int(1),(int(2),int(12)))],_WF))).
2434 :- assert_must_succeed((kernel_relations:direct_product_wf(avl_set(node((fd(1,'Name'),fd(2,'Name')),true,1,empty,node((fd(2,'Name'),fd(3,'Name')),true,0,empty,empty))),
2435 avl_set(node((fd(1,'Name'),fd(2,'Name')),true,1,empty,node((fd(2,'Name'),fd(3,'Name')),true,0,empty,empty))),
2436 avl_set(node((fd(1,'Name'),fd(2,'Name'),fd(2,'Name')),true,1,empty,node((fd(2,'Name'),fd(3,'Name'),fd(3,'Name')),true,0,empty,empty)))
2437 ,_WF))).
2438
2439 :- block direct_product_wf(-,?,?,?),direct_product_wf(?,-,?,?).
2440 direct_product_wf(Rel1,Rel2,Prod,WF) :-
2441 try_expand_and_convert_to_avl_with_check(Rel1,E1,direct_product), % to do: try_expand_and_convert_to_avl_unless_large_wf(Rel1,E1,WF),
2442 try_expand_and_convert_to_avl_with_check(Rel2,E2,direct_product),
2443 direct_product_wf1(E1,E2,Prod,WF).
2444
2445 direct_product_wf1(Rel1,Rel2,Prod,WF) :-
2446 direct_product_explicit_set(Rel1,Rel2,Res),!,
2447 equal_object_wf(Prod,Res,direct_product_wf1,WF).
2448 direct_product_wf1(Rel1,Rel2,Prod,WF) :-
2449 expand_custom_set_to_list_wf(Rel1,Relation1,_,direct_product_wf1_1,WF),
2450 expand_custom_set_to_list_wf(Rel2,Relation2,_,direct_product_wf1_2,WF),
2451 direct_product2(Relation1,Relation2,Prod,WF),
2452 direct_product_backwards(Relation1,Relation2,Prod,WF).
2453
2454 :- block direct_product2(-,?,?,?).
2455 direct_product2([],_,Out,WF) :- equal_object_wf(Out,[],direct_product2,WF).
2456 direct_product2([(X,Y)|T],Rel2,Out,WF) :-
2457 direct_product_tuple(Rel2,X,Y,Out,OutRem,WF),
2458 direct_product2(T,Rel2,OutRem,WF).
2459
2460 :- block direct_product_tuple(-,?,?,?,?,?).
2461 direct_product_tuple([],_,_,Res,Rem,WF) :- equal_object_optimized_wf(Res,Rem,direct_product_tuple,WF).
2462 direct_product_tuple([(X2,Z)|T],X,Y,Res,Rem,WF) :-
2463 direct_product_tuple(T,X,Y,CT,Rem,WF),
2464 equality_objects_wf(X2,X,EqRes,WF),
2465 direct_product_tuple3(EqRes,X,Y,Z,CT,Res,WF).
2466
2467 :- block direct_product_tuple3(-,?,?,?,?,?,?).
2468 direct_product_tuple3(pred_true,X,Y,Z,CT,Res,WF) :-
2469 ? equal_cons_wf(Res,(X,(Y,Z)),CT,WF). /* no need for add_element as output uniquely determines X,Y,Z !?*/
2470 direct_product_tuple3(pred_false,_X,_Y,_Z,CT,Res,WF) :- equal_object_optimized_wf(Res,CT,direct_product_tuple3,WF).
2471
2472 :- block direct_product_backwards(?,?,-,?).
2473 % Propagate information backwards from result to arguments
2474 direct_product_backwards(R1,R2,Prod,WF) :-
2475 ((ground_value(R1) ; ground_value(R2)) -> true
2476 ; expand_custom_set_to_list_wf(Prod,ProdList,_,direct_product_backwards,WF),
2477 direct_product_propagate_back(ProdList,R1,R2,WF)
2478 ).
2479
2480 :- block direct_product_propagate_back(-,?,?,?).
2481 direct_product_propagate_back([],_,_,_WF).
2482 direct_product_propagate_back([(X,(Y,Z))|T],R1,R2,WF) :-
2483 check_element_of_wf((X,Y),R1,WF), check_element_of_wf((X,Z),R2,WF),
2484 direct_product_propagate_back(T,R1,R2,WF).
2485
2486 :- assert_must_succeed(exhaustive_kernel_check(kernel_relations:parallel_product([],[(int(3),int(4))],[]))).
2487 :- assert_must_succeed(exhaustive_kernel_check(kernel_relations:parallel_product([(int(1),int(2))],
2488 [(int(3),int(4))],[((int(1),int(3)),(int(2),int(4)))]))).
2489 :- assert_must_succeed((kernel_relations:parallel_product([(int(1),int(2))],
2490 [(int(3),int(4))],X), ground(X),
2491 equal_object(X,[((int(1),int(3)),(int(2),int(4)))]))).
2492 :- assert_must_succeed((kernel_relations:parallel_product([(int(1),int(2))],
2493 [(int(3),int(4))],[((int(1),int(3)),(int(2),int(4)))]))).
2494 :- assert_must_succeed((kernel_relations:parallel_product([(int(1),int(2))], [],X),X == [])).
2495 :- assert_must_succeed((kernel_relations:parallel_product([], [(int(3),int(4))],X),X == [])).
2496
2497 parallel_product(Rel1,Rel2,Prod) :- parallel_product_wf(Rel1,Rel2,Prod,no_wf_available).
2498
2499 :- block parallel_product_wf(-,?,?,?),parallel_product_wf(?,-,?,?).
2500 % NOTE: we now have in_parallel_product; as such parallel products are kept symbolic
2501 %parallel_product_wf(Rel1,Rel2,Prod,WF) :- (keep_symbolic(Rel1) -> true ; keep_symbolic(Rel2)),
2502 % print_term_summary(parallel_product(Rel1,Rel2,Prod)),nl,
2503 %% % TO DO: generate closure
2504 % %{xy,mn|#(x,y,m,n).(xy=(x,y) & mn=(m,n) & (x,m):S & (y,n):R)}
2505 % fail.
2506 parallel_product_wf(Rel1,Rel2,Prod,WF) :-
2507 expand_custom_set_to_list_wf(Rel1,Relation1,_,parallel_product_1,WF),
2508 expand_custom_set_to_list_wf(Rel2,Relation2,_,parallel_product_2,WF),
2509 parallel_product2(Relation1,Relation2,ProdRes,WF),
2510 equal_object_optimized_wf(ProdRes,Prod,parallel_product,WF).
2511
2512 :- use_module(kernel_equality,[conjoin_test/4]).
2513 %(Rel1||Rel2) = {(x,y),(m,n)| (x,m):Rel1 & (y,n):Rel2}
2514
2515 % TO DO: use this in b_interpreter_check:
2516 in_parallel_product_test(((X,Y),(M,N)),Rel1,Rel2,Result,WF) :-
2517 conjoin_test(MemRes1,MemRes2,Result,WF),
2518 membership_test_wf(Rel1,(X,M),MemRes1,WF),
2519 membership_test_wf(Rel2,(Y,N),MemRes2,WF).
2520
2521 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:in_parallel_product_wf(((int(1),int(2)),(int(11),int(22))),[(int(1),int(11))],[(int(2),int(22))],WF),WF)).
2522
2523 in_parallel_product_wf(El,Rel1,Rel2,WF) :-
2524 in_parallel_product_test(El,Rel1,Rel2,pred_true,WF).
2525
2526
2527 :- assert_must_succeed(exhaustive_kernel_check(kernel_relations:not_in_parallel_product_wf(((int(1),int(11)),(int(2),int(22))),[(int(1),int(11))],[(int(2),int(22))],_WF))).
2528
2529 not_in_parallel_product_wf(El,Rel1,Rel2,WF) :-
2530 in_parallel_product_test(El,Rel1,Rel2,pred_false,WF).
2531
2532
2533 :- block parallel_product2(-,?,?,?).
2534 parallel_product2([],_,Out,WF) :- empty_set_wf(Out,WF).
2535 parallel_product2([(X,Y)|T],Rel2,Out,WF) :-
2536 parallel_product_tuple(Rel2,X,Y,Out,Tail,WF),
2537 parallel_product2(T,Rel2,Tail,WF).
2538
2539 :- block parallel_product_tuple(-,?,?,?,?,?).
2540 parallel_product_tuple([],_,_,Tail1,Tail2,WF) :- equal_object_wf(Tail1,Tail2,parallel_product_tuple,WF).
2541 parallel_product_tuple([(X2,Y2)|T],X,Y,Rel2,Tail,WF) :-
2542 equal_object_wf(Rel2,[((X,X2),(Y,Y2))|RT],parallel_product_tuple,WF),
2543 parallel_product_tuple(T,X,Y,RT,Tail,WF).
2544
2545
2546 % -------------------------------------------------
2547
2548 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_partial_function([(int(1),int(6)),(int(2),int(7))],[int(1)],[int(7),int(6)],WF),WF)). %% with wf_det leads to residue custom_explicit_sets:b_not_test_closure_enum
2549 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_partial_function([(int(1),int(6)),(int(2),int(7))],[int(1),int(2)],[int(8),int(6)],WF),WF)).
2550 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_partial_function([(int(1),int(6)),(int(2),int(7)),(int(1),int(7))],[int(1),int(2)],[int(7),int(6)],WF),WF)).
2551 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_partial_function([(int(1),int(6)),(int(1),int(7))],[int(1)],[int(7),int(6)],WF),WF)).
2552 :- assert_must_succeed(exhaustive_kernel_fail_check_wfdet(kernel_relations:not_partial_function([(int(1),int(6)),(int(2),int(7))],[int(1),int(2)],[int(7),int(6)],WF),WF)).
2553 :- assert_must_succeed(exhaustive_kernel_fail_check_wfdet(kernel_relations:not_partial_function([(int(1),int(6))],[int(1),int(2)],[int(7),int(6)],WF),WF)).
2554 :- assert_must_fail((kernel_relations:not_partial_function([],[int(1)],[int(7)],_WF))).
2555 :- assert_must_fail((kernel_relations:not_partial_function(X,[int(1)],[int(7)],_WF),
2556 X = [(int(1),int(7))])).
2557 :- assert_must_fail((kernel_relations:not_partial_function(X,[int(1),int(2)],[int(7)],_WF),
2558 X = [(int(2),int(7)),(int(1),int(7))])).
2559 :- assert_must_fail((kernel_relations:not_partial_function(X,[[(int(1),int(2))],[(int(1),int(3)),(int(2),int(3))]],
2560 [int(7),int(6)],_WF),
2561 X = [([(int(1),int(2))],int(7)),
2562 ([(int(2),int(3)),(int(1),int(3))],int(6))])).
2563 :- assert_must_fail((kernel_relations:not_partial_function(X,[[(int(1),int(2))],[(int(1),int(3)),(int(2),int(3))]],
2564 [int(7),int(6)],_WF),
2565 X = [([(int(2),int(3)),(int(1),int(3))],int(6))])).
2566 :- assert_must_fail((kernel_relations:not_partial_function(X,[[(int(1),int(2))],[(int(1),int(3)),(int(2),int(3))]],
2567 [int(7),int(6)],_WF),
2568 X = [([(int(1),int(2))],int(7)),
2569 ([(int(2),int(3)),(int(1),int(3))],int(6))])).
2570 :- assert_must_fail((kernel_relations:not_partial_function(X,[int(1)],[[int(7),int(6)]],_WF),
2571 X = [(int(1),[int(6),int(7)])])).
2572 :- assert_must_fail((kernel_relations:not_partial_function(X,[int(1),int(2)],[int(7),int(6)],_WF),
2573 X = [(int(2),int(7)),(int(1),int(7))])).
2574 :- assert_must_succeed((kernel_relations:not_partial_function(X,[int(1),int(2)],[int(7),int(6)],_WF),
2575 X = [(int(2),int(7)),(int(2),int(6))])).
2576 :- assert_must_succeed((kernel_relations:not_partial_function(X,[int(1),int(2)],[int(7),int(6)],_WF),
2577 X = [(int(2),int(7)),(int(1),int(2))])).
2578 :- assert_must_succeed((kernel_relations:not_partial_function(X,[int(1),int(2)],[int(7),int(6)],_WF),
2579 X = [(int(2),int(7)),(int(3),int(6))])).
2580 :- assert_must_succeed((kernel_relations:not_partial_function(X,[int(1),int(2)],[int(7),int(6)],_WF),
2581 X = [(int(2),int(7)),(int(2),int(5))])).
2582 :- assert_must_succeed((kernel_relations:not_partial_function(X,[int(1),int(2)],[int(7),int(6)],_WF),
2583 X = [(int(1),int(7)),(int(2),int(6)),(int(2),int(7))])).
2584 :- assert_must_fail((kernel_relations:not_partial_function(X,global_set('NATURAL1'),global_set('NATURAL1'),_WF),
2585 X = [(int(1),int(7)),(int(5),int(75))])).
2586 :- assert_must_fail((kernel_relations:not_partial_function(X,global_set('NATURAL'),global_set('NATURAL1'),_WF),
2587 X = [(int(1),int(7)),(int(0),int(7))])).
2588 :- assert_must_succeed((kernel_relations:not_partial_function(X,global_set('NATURAL'),global_set('NATURAL1'),_WF),
2589 X = [(int(1),int(7)),(int(-1),int(7))])).
2590 :- assert_must_succeed((kernel_relations:not_partial_function(X,global_set('NATURAL1'),global_set('NATURAL1'),_WF),
2591 X = [(int(1),int(7)),(int(0),int(7))])).
2592 :- assert_must_fail((kernel_relations:not_partial_function(X,global_set('Name'),global_set('Code'),_WF),
2593 X = [(fd(1,'Name'),fd(1,'Code'))])).
2594 :- assert_must_fail((kernel_relations:not_partial_function(X,global_set('NATURAL'),global_set('Code'),_WF),
2595 X = [(int(1),fd(1,'Code')),(int(0),fd(1,'Code')),(int(88),fd(2,'Code'))])).
2596 :- assert_must_fail((kernel_relations:not_partial_function(X,global_set('NATURAL'),global_set('Code'),_WF),
2597 X = [(int(1),fd(1,'Code')),(int(0),fd(1,'Code')),(int(2),fd(2,'Code'))])).
2598 :- assert_must_succeed((kernel_relations:not_partial_function([(fd(1,'Code'),int(1)),(fd(1,'Code'),int(2))],
2599 global_set('Code'),global_set('NAT1'),_WF) )).
2600
2601 :- block not_partial_function(-,?,?,?).
2602 not_partial_function([],_Domain,_Range,_WF) :- !,fail.
2603 not_partial_function(FF,Domain,Range,WF) :- nonvar(FF),custom_explicit_sets:is_definitely_maximal_set(Range),
2604 % we do not need the Range; this means we can match more closures (e.g., lambda)
2605 ? custom_explicit_sets:dom_for_specific_closure(FF,FFDomain,function(_),WF),!,
2606 not_subset_of_wf(FFDomain,Domain,WF).
2607 not_partial_function(FF,Domain,Range,WF) :- nonvar(FF),
2608 custom_explicit_sets:dom_range_for_specific_closure(FF,FFDomain,FFRange,function(_),WF),!,
2609 not_both_subset_of(FFDomain,FFRange,Domain,Range,WF).
2610 not_partial_function(FF,Domain,Range,WF) :- nonvar(FF), FF=closure(P,T,Pred),
2611 % example: f = %t.(t : NATURAL|t + 100) & f /: NATURAL +-> NATURAL
2612 is_lambda_value_domain_closure(P,T,Pred, FFDomain,_Expr),
2613 get_range_id_expression(P,T,TRangeID),!,
2614 subset_test(FFDomain,Domain,SubRes,WF),
2615 when(nonvar(SubRes),
2616 (SubRes=pred_false -> true % not a subset -> it is not a partial function over the domain
2617 ; check_not_lambda_closure_range(P,T,Pred,TRangeID,Range,WF))).
2618 not_partial_function(R,Domain,Range,WF) :-
2619 expand_and_convert_to_avl_set_warn(R,AER,not_partial_function,'ARG /: ? +-> ?',WF),!,
2620 % TO DO: expand_and_convert_to_avl_set_catch and provide symbolic treatment similar to partial_function
2621 % e.g., to support f = NATURAL1 * {22,33} & not(f: NATURAL1 +-> NATURAL)
2622 is_not_avl_partial_function(AER,Domain,Range,WF).
2623 not_partial_function(R,Domain,Range,WF) :-
2624 expand_custom_set_to_list_wf(R,ER,_,not_partial_function,WF),
2625 not_pf(ER,[],Domain,Range,WF).
2626
2627 is_not_avl_partial_function(AER,Domain,Range,WF) :-
2628 (is_avl_partial_function(AER)
2629 -> is_not_avl_relation_over_domain_range(AER,Domain,Range,WF)
2630 ; true
2631 ).
2632
2633 :- block not_pf(-,?,?,?,?).
2634 not_pf([],_,_,_,_) :- fail.
2635 not_pf([(X,Y)|T],SoFar,Dom,Ran,WF) :-
2636 membership_test_wf_with_force(SoFar,X,MemRes,WF),
2637 not_pf2(MemRes,X,Y,T,SoFar,Dom,Ran,WF).
2638
2639 :- block not_pf2(-,?,?,?,?,?,?,?).
2640 not_pf2(pred_true,_X,_Y,_T,_SoFar,_Dom,_Ran,_WF). /* then not a function */
2641 not_pf2(pred_false,X,Y,T,SoFar,Dom,Ran,WF) :-
2642 membership_test_wf_with_force(Dom,X,MemRes,WF), % creates a choice point in SMT mode
2643 not_pf2a(MemRes,X,Y,T,SoFar,Dom,Ran,WF).
2644
2645 :- block not_pf2a(-,?,?,?,?,?,?,?).
2646 not_pf2a(pred_false,_X,_Y,_T,_SoFar,_Dom,_Ran,_WF). /* function, but domain wrong */
2647 not_pf2a(pred_true,X,Y,T,SoFar,Dom,Ran,WF) :-
2648 remove_element_wf_if_not_infinite_or_closure(X,Dom,Dom2,WF,_LWF,Done), %% provide _LWF ??
2649 not_pf2b(Done,X,Y,T,SoFar,Dom2,Ran,WF).
2650
2651 :- block not_pf2b(-, ?,?,?, ?,?,?, ?).
2652 not_pf2b(_Done, X,Y,T, SoFar,Dom2,Ran, WF) :-
2653 add_element_wf(X,SoFar,SoFar2,WF),
2654 (T==[] -> not_element_of_wf(Y,Ran,WF)
2655 ; membership_test_wf_with_force(Ran,Y,MemRes,WF),
2656 prop_empty_pred_false(T,MemRes), % if T=[] -> Y must not be in Ran
2657 not_pf3(MemRes,T,SoFar2,Dom2,Ran,WF)).
2658
2659 :- block prop_empty_pred_false(-,?).
2660 prop_empty_pred_false([],R) :- !, R=pred_false.
2661 prop_empty_pred_false(_,_).
2662
2663 :- block not_pf3(-,?,?,?,?,?).
2664 not_pf3(pred_false,_T,_SoFar,_Dom2,_Ran,_WF). /* illegal range */
2665 not_pf3(pred_true,T,SoFar,Dom2,Ran,WF) :-
2666 not_pf(T,SoFar,Dom2,Ran,WF).
2667
2668 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:partial_function_wf([(int(1),int(6)),(int(2),int(7))],[int(1),int(2)],[int(7),int(6)],WF),WF)).
2669 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:partial_function_wf([(int(1),int(1)),(int(2),int(1))],global_set('NATURAL'),global_set('NATURAL'),WF),WF)).
2670 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:partial_function_wf([(int(2),int(7))],[int(1),int(2)],[int(7),int(6)],WF),WF)).
2671 :- assert_must_succeed(exhaustive_kernel_fail_check_wfdet(kernel_relations:partial_function_wf([(int(2),int(6)),(int(2),int(7))],[int(1),int(2)],[int(7),int(6)],WF),WF)).
2672 :- assert_must_succeed(exhaustive_kernel_fail_check_wfdet(kernel_relations:partial_function_wf([(pred_true,int(6)),(pred_true,int(7))],[pred_false,pred_true],[int(7),int(6)],WF),WF)).
2673 :- assert_must_succeed(exhaustive_kernel_fail_check_wfdet(kernel_relations:partial_function_wf([(term(floating(1.0)),int(6)),(term(floating(1.0)),int(7))],[term(floating(1.0)),term(floating(2.0))],[int(7),int(6)],WF),WF)).
2674 :- assert_must_succeed((kernel_relations:partial_function([],[int(1)],[int(7)]))).
2675 :- assert_must_succeed((kernel_relations:partial_function(X,[int(1)],[int(7)]),
2676 X = [(int(1),int(7))])).
2677 :- assert_must_succeed((kernel_relations:partial_function(X,[int(1),int(2)],[int(7)]),
2678 equal_object(X,[(int(2),int(7)),(int(1),int(7))]))).
2679 :- assert_must_succeed((findall(X,kernel_relations:partial_function(X,[int(1),int(2)],[int(7)]),L),
2680 length(L,Len), Len >= 4,
2681 (preferences:get_preference(convert_comprehension_sets_into_closures,true) -> true ; Len=4) )).
2682 :- assert_must_succeed((kernel_relations:partial_function(X,[[(int(1),int(2))],[(int(1),int(3)),(int(2),int(3))]],
2683 [int(7),int(6)]),
2684 equal_object(X,[([(int(1),int(2))],int(7)),
2685 ([(int(2),int(3)),(int(1),int(3))],int(6))]))).
2686 :- assert_must_succeed((kernel_relations:partial_function_wf(X,[[(int(1),int(2))],[(int(1),int(3)),(int(2),int(3))]],
2687 [int(7),int(6)],_WF),
2688 X = [([(int(2),int(3)),(int(1),int(3))],int(6))])).
2689 :- assert_must_succeed((kernel_relations:partial_function_wf(X,[[(int(1),int(2))],[(int(1),int(3)),(int(2),int(3))]],
2690 [int(7),int(6)],_WF),
2691 X = [([(int(1),int(2))],int(7)),
2692 ([(int(2),int(3)),(int(1),int(3))],int(6))])).
2693 :- assert_must_succeed((kernel_relations:partial_function_wf(X,[int(1)],[[int(7),int(6)]],_WF),
2694 X = [(int(1),[int(6),int(7)])])).
2695 :- assert_must_succeed((kernel_relations:partial_function_wf(X,global_set('NATURAL1'),global_set('NATURAL1'),_WF),
2696 X = [(int(1),int(7)),(int(5),int(75))])).
2697 :- assert_must_succeed((kernel_relations:partial_function_wf(X,global_set('NATURAL'),global_set('NATURAL1'),_WF),
2698 X = [(int(1),int(7)),(int(0),int(7))])).
2699 :- assert_must_fail((kernel_relations:partial_function_wf(X,global_set('NATURAL'),global_set('NATURAL1'),_WF),
2700 X = [(int(1),int(7)),(int(-1),int(7))])).
2701 :- assert_must_fail((kernel_relations:partial_function_wf(X,global_set('NATURAL1'),global_set('NATURAL1'),_WF),
2702 X = [(int(1),int(7)),(int(0),int(7))])).
2703 :- assert_must_fail((kernel_relations:partial_function_wf(X,[int(1),int(2)],[int(7),int(6)],_WF),
2704 X = [(int(2),int(7)),(int(2),int(6))])).
2705 :- assert_must_succeed((kernel_relations:partial_function_wf(X,global_set('Name'),global_set('Code'),_WF),
2706 X = [(fd(1,'Name'),fd(1,'Code'))])).
2707 :- assert_must_succeed((kernel_relations:partial_function_wf(X,global_set('NATURAL'),global_set('Code'),_WF),
2708 X = [(int(1),fd(1,'Code')),(int(0),fd(1,'Code')),(int(88),fd(2,'Code'))])).
2709 :- assert_must_succeed((kernel_relations:partial_function_wf(X,global_set('NATURAL'),global_set('Code'),_WF),
2710 X = [(int(1),fd(1,'Code')),(int(0),fd(1,'Code')),(int(2),fd(2,'Code'))])).
2711
2712 partial_function(R,Domain,Range) :- init_wait_flags(WF,[partial_function]),
2713 partial_function_wf(R,Domain,Range,WF),
2714 ground_wait_flags(WF).
2715
2716 :- use_module(kernel_equality,[get_cardinality_powset_wait_flag/5]).
2717 :- use_module(closures,[is_lambda_value_domain_closure/5]).
2718 :- block partial_function_wf(-,-,?,?).
2719 partial_function_wf(R,_Domain,_Range,_WF) :- R==[], !.
2720 partial_function_wf(R,Domain,Range,WF) :- (Domain==[] ; Range==[]), !, empty_set_wf(R,WF).
2721 partial_function_wf(FF,Domain,Range,WF) :- nonvar(FF),
2722 custom_explicit_sets:is_definitely_maximal_set(Range),
2723 % we do not need the Range; this means we can match more closures (e.g., lambda)
2724 ? custom_explicit_sets:dom_for_specific_closure(FF,FFDomain,function(_),WF),!,
2725 check_domain_subset_for_closure_wf(FF,FFDomain,Domain,WF).
2726 partial_function_wf(FF,Domain,Range,WF) :- nonvar(FF),
2727 % TODO: this will fail if is_definitely_maximal_set was true above !
2728 custom_explicit_sets:dom_range_for_specific_closure(FF,FFDomain,FFRange,function(_),WF),!,
2729 % same as for total_function_wf check
2730 check_domain_subset_for_closure_wf(FF,FFDomain,Domain,WF),
2731 check_range_subset_for_closure_wf(FF,FFRange,Range,WF).
2732 partial_function_wf(FF,Domain,Range,WF) :- nonvar(FF), FF=closure(P,T,Pred),
2733 % example: f = %x.(x:NATURAL1|x+1) & f: NATURAL1 +-> NATURAL
2734 is_lambda_value_domain_closure(P,T,Pred, FFDomain,_Expr),
2735 get_range_id_expression(P,T,TRangeID),
2736 !,
2737 check_domain_subset_for_closure_wf(FF,FFDomain,Domain,WF),
2738 opt_push_wait_flag_call_stack_info(WF,b_operator_call(subset,
2739 [b_operator(range,[FF]),Range],unknown),WF3),
2740 check_lambda_closure_range(P,T,Pred,TRangeID,Range,WF3). % we could use symbolic_range_subset_check
2741 partial_function_wf(R,Domain,Range,WF) :-
2742 expand_and_convert_to_avl_set_catch(R,AER,partial_function_wf,'ARG : ? +-> ?',ResultStatus,WF),!,
2743 (ResultStatus=avl_set
2744 ? -> is_avl_partial_function_over(AER,Domain,Range,WF)
2745 ; % ResultStatus=keep symbolic
2746 (debug_level_inactive_for(19) -> true ; print('SYMBOLIC +-> check : '),translate:print_bvalue(R),nl),
2747 % can deal with, e.g., f = %x.(x:NATURAL|x+1) & g = f <+ {0|->0} & g : INTEGER +-> INTEGER
2748 symbolic_domain_subset_check(R,Domain,WF),
2749 symbolic_range_subset_check(R,Range,WF),
2750 symbolic_functionality_check(R,WF)
2751 ).
2752 partial_function_wf(R,Domain,Range,WF) :-
2753 get_cardinality_powset_wait_flag(Domain,partial_function_wf,WF,Card,CWF),
2754 % probably we should compute real cardinality of set of partial functions over Domain +-> Range ?
2755 % the powset waitflag uses 2^Card as priority; is the number of partial functions when Range contains just a single element
2756 % slows down test 1088: TO DO investigate
2757 % get_cardinality_partial_function_wait_flag(Domain,Range,partial_function_wf,WF,Card,_,CWF),
2758 %% Maybe we should only enumerate partial functions for domain variables ; e.g., not f <+ {x |-> y} : T +-> S
2759 %% print_bt_message(pf_dom_card(Card)),nl, %%%
2760 % probably we should use a special version when R is var
2761 propagate_empty_set_wf(Domain,dom_pf,R,WF),
2762 propagate_empty_set_wf(Range,ran_pf,R,WF),
2763 ? (var(R) -> pf_var_r(R,var,Domain,Range,Card,WF,CWF) ; pf_var_r(R,nonvar,Domain,Range,Card,WF,CWF)).
2764
2765 % symbolic dom(R) <: Domain check for closures
2766 symbolic_domain_subset_check(R,Domain,WF) :-
2767 opt_push_wait_flag_call_stack_info(WF,b_operator_call(subset,
2768 [b_operator(domain,[R]),Domain],unknown),WF2),
2769 domain_subtraction_wf(Domain,R,Res,WF2), % works symbolically
2770 (debug_level_inactive_for(19) -> true ; print('Domain Violations: '),translate:print_bvalue(Res),nl),
2771 empty_set_wf(Res,WF2). % empty_set does a symbolic treatment calling gen_typed_ids and b_not_test_exists:
2772 % symbolic ran(R) <: Range check for closures
2773 symbolic_range_subset_check(R,Range,WF) :-
2774 opt_push_wait_flag_call_stack_info(WF,b_operator_call(subset,
2775 [b_operator(range,[R]),Range],unknown),WF2),
2776 range_subtraction_wf(R,Range,Res,WF2), % works symbolically
2777 (debug_level_inactive_for(19) -> true ; print('Range Violations: '),translate:print_bvalue(Res),nl),
2778 empty_set_wf(Res,WF2). % works symbolically
2779 symbolic_functionality_check(Closure,WF) :-
2780 custom_explicit_sets:symbolic_functionality_check_closure(Closure,ViolationsClosure),!,
2781 (debug_level_inactive_for(19) -> true ; print('FUNCTIONALITY Violations: '),translate:print_bvalue(ViolationsClosure),nl),
2782 empty_set_wf(ViolationsClosure,WF). % works symbolically
2783 symbolic_functionality_check(R,WF) :-
2784 add_error_wf(symbolic_functionality_check,'Could not check functionality of:',R,R,WF).
2785
2786 symbolic_injectivity_check(Closure,WF) :-
2787 custom_explicit_sets:symbolic_injectivity_check_closure(Closure,ViolationsClosure),!,
2788 (debug_level_inactive_for(19) -> true ; print('INJECTIVITY Violations: '),translate:print_bvalue(ViolationsClosure),nl),
2789 empty_set_wf(ViolationsClosure,WF). % works symbolically
2790 symbolic_injectivity_check(R,WF) :-
2791 add_error_wf(symbolic_injectivity_check,'Could not check injectivity of:',R,R,WF).
2792
2793
2794 is_avl_partial_function_over(AER,Domain,Range,WF) :-
2795 is_avl_partial_function(AER),
2796 ? is_avl_relation_over_domain(AER,Domain,WF),
2797 ? is_avl_relation_over_range(AER,Range,WF).
2798
2799 % symbolically check that the range of lambda closure is a subset of a given Range
2800 % TRangeID is obtained by calling get_range_id_expression(P,T,TRangeID)
2801 check_lambda_closure_range(P,T,Pred,TRangeID,Range,WF) :-
2802 opt_push_wait_flag_call_stack_info(WF,b_operator_call(subset,
2803 [b_operator(range,[closure(P,T,Pred)]),Range],unknown),WF2),
2804 % CHECK not(#P.(Pred & TRangeID /: Range))
2805 get_not_in_range_pred_aux(Pred,TRangeID,Range,Pred2),
2806 is_empty_closure_wf(P,T,Pred2,WF2). % do we need to rename _lambda_result_ using rename_lambda_result_id ?
2807 % now the negation thereof:
2808 check_not_lambda_closure_range(P,T,Pred,TRangeID,Range,WF) :-
2809 opt_push_wait_flag_call_stack_info(WF,b_operator_call(not_subset,
2810 [b_operator(range,[closure(P,T,Pred)]),Range],unknown),WF2),
2811 % CHECK (#P.(Pred & TRangeID /: Range))
2812 get_not_in_range_pred_aux(Pred,TRangeID,Range,Pred2),
2813 is_non_empty_closure_wf(P,T,Pred2,WF2).
2814 test_lambda_closure_range(P,T,Pred,TRangeID,Range,Res,WF) :-
2815 opt_push_wait_flag_call_stack_info(WF,b_operator_call(subset, % it is actually a reify check
2816 [b_operator(range,[closure(P,T,Pred)]),Range],unknown),WF2),
2817 % reify not(#P.(Pred & TRangeID /: Range))
2818 get_not_in_range_pred_aux(Pred,TRangeID,Range,Pred2),
2819 test_empty_closure_wf(P,T,Pred2,Res,WF2).
2820
2821 get_not_in_range_pred_aux(Pred,TRangeID,Range,NewPred) :- % construct (Pred & TRangeID /: Range)
2822 ExpectedRange = b(value(Range),set(RanT),[]),
2823 get_texpr_type(TRangeID,RanT),
2824 safe_create_texpr(not_member(TRangeID,ExpectedRange),pred,NotMemCheck),
2825 conjunct_predicates([Pred,NotMemCheck],NewPred).
2826
2827
2828 % if first argument is empty, second argument must also be empty
2829 :- block propagate_empty_set_wf(-,?,?,?).
2830 propagate_empty_set_wf([],_PP,A,WF) :- !, %print(prop_empty(_PP,A)),nl,
2831 kernel_objects:empty_set_wf(A,WF). % TO DO: add WF
2832 propagate_empty_set_wf(_,_,_,_).
2833
2834 :- block pf_var_r(-,?,?,?,?,?,-).
2835 pf_var_r(R,var,Domain,Range,_Card,WF,_CWF) :- % if R was var: see if it is now an AVL set; otherwise we have already checked it
2836 expand_and_convert_to_avl_set_warn(R,AER,pf_var_r,'ARG : ? +-> ?',WF),!,
2837 ? is_avl_partial_function_over(AER,Domain,Range,WF).
2838 pf_var_r(R,_,Domain,Range,Card,WF,CWF) :-
2839 expand_custom_set_to_list_wf(R,ER,_,partial_function_wf,WF),
2840 %get_last_wait_flag(partial_fun(Domain),WF,LWF),
2841 ? pf_w(ER,[],Domain,Range,Card,_Large,WF,CWF).
2842
2843 pf_w(T,SoFar,Dom,Ran,Card,Large,WF,LWF) :-
2844 (Card==0 -> T=[]
2845 ? ; pf(T,SoFar,Dom,Ran,Card,Large,WF,LWF)).
2846
2847 :- block pf(-,?,?,?,?,?,?,-).
2848 pf(LIST,_,_,_,_,_WF,_,_LWF) :- LIST==[],!. % avoid leaving choicepoint
2849 pf(AVL,SoFar,Dom,Ran,Card,Large,WF,LWF) :- nonvar(AVL),AVL=avl_set(_A),
2850 add_internal_error('AVL arg: ',pf(AVL,SoFar,Dom,Ran,Card,Large,WF,LWF)),fail.
2851 pf([],_,_,_,_,_WF,_,_LWF).
2852 pf(LIST,SoFar,Dom,Ran,Card,Large,WF,LWF) :-
2853 (var(LIST) -> ListWasVar = true ; ListWasVar = false), % is ListWasVar = true we are doing the enumeration driven by LWF being ground
2854 LIST = [(X,Y)|T],
2855 ? dec_card(Card,NC),/* Card ensures we do not build too big lists */
2856 Dom \== [],
2857 ? remove_domain_element(ListWasVar,X,Y,Dom,Dom2,Large,WF,LWF,Done),
2858 ? check_element_of_wf(Y,Ran,WF),
2859 ? pf1(Done, X,Y,T,SoFar,Dom2,Ran,NC,Large,WF,LWF).
2860
2861 :- block dec_card(-,?).
2862 dec_card(inf,NewC) :- !, NewC=inf.
2863 dec_card(inf_overflow,NewC) :- !, NewC=inf_overflow.
2864 dec_card(C,NewC) :- C>0, NewC is C-1.
2865
2866 :- block pf1(-, ?,?,?,?,?,?,?,?,?,?).
2867 pf1(_Done, X,_Y,T,SoFar,Dom2,Ran,Card,Large,WF,LWF) :-
2868 not_element_of_wf(X,SoFar,WF), /* check that it is a function */
2869 %% check_element_of_wf(Y,Ran,WF), % this check is now done above in pf
2870 add_new_element_wf(X,SoFar,SoFar2,WF),
2871 ? pf_w(T,SoFar2,Dom2,Ran,Card,Large,WF,LWF).
2872
2873 remove_domain_element(ListWasVar,X,Y,Dom,Dom2,Large,WF,LWF,Done) :- compute_large(Dom,Large),
2874 ((ListWasVar==true,var(X),var(Y),Large==false,
2875 preference(convert_comprehension_sets_into_closures,false), % not in symbolic mode
2876 ground_value(Dom))
2877 -> %% (X, Y are free and we drive the enumeration: we can influence which element is taken from Dom
2878 remove_a_minimal_element(X,Dom,Dom2,WF,Done) %%%%%%%%%% added Jul 15 2008
2879 ? ; remove_element_wf_if_not_infinite_or_closure(X,Dom,Dom2,WF,LWF,Done)
2880 ).
2881 compute_large(Dom,Large) :- % check if the domain is large; ensure that we compute this only once
2882 (nonvar(Large) -> true
2883 ; var(Dom) -> true
2884 ; dont_expand_this_explicit_set(Dom) -> Large=large
2885 ; Large=false).
2886
2887 :- assert_must_succeed(( kernel_relations:remove_a_minimal_element(X,[int(1)],R,_WF,Done),
2888 X==int(1), Done==true, R=[] )).
2889 :- assert_must_succeed(( init_wait_flags(WF), kernel_relations:remove_a_minimal_element(X,[int(1),int(2),int(3)],R,WF,Done), ground_wait_flags(WF),
2890 X==int(2), Done==true, R=[int(3)] )).
2891 :- assert_must_succeed(( init_wait_flags(WF), kernel_relations:remove_a_minimal_element(X,[int(1),int(2),int(3)],R,WF,Done), ground_wait_flags(WF),
2892 X==int(1), R=[int(2),int(3)], Done==true )).
2893 :- assert_must_succeed(( init_wait_flags(WF), kernel_relations:remove_a_minimal_element(X,[int(1),int(2),int(3)],R,WF,Done), ground_wait_flags(WF),
2894 X==int(3), R=[], Done==true )).
2895 :- assert_must_succeed(( init_wait_flags(WF), CL=closure(['_zzzz_binary'],[integer],b(member( b(identifier('_zzzz_binary'),integer,[]),
2896 b(interval(b(value(int(1)),integer,[]),b(value(int(10)),integer,[])),set(integer),[])),pred,[])),
2897 kernel_relations:remove_a_minimal_element(X,CL,R,WF,Done), ground_wait_flags(WF),
2898 X=int(9), Done==true, kernel_objects:equal_object(R,[int(10)]) )).
2899
2900 /* usage: restrict number of possible choices if element to remove is free */
2901 /* select one element; and disallow all elements appearing before it in the list */
2902 remove_a_minimal_element(X,Set,Res,WF,Done) :-
2903 expand_custom_set_to_list_wf(Set,ESet,EDone,remove_a_minimal_element,WF),
2904 remove_a_minimal_element2(X,ESet,EDone,Res,WF,Done).
2905
2906 :- use_module(kernel_equality,[get_cardinality_wait_flag/4]).
2907 :- block remove_a_minimal_element2(?,?,-,?,?,?).
2908 remove_a_minimal_element2(X,ESet,EDone,Res,WF,Done) :- var(ESet),
2909 % should not happen as we wait for EDone
2910 add_internal_error('Illegal call: ',remove_a_minimal_element2(X,ESet,EDone,Res,WF,Done)),
2911 fail.
2912 remove_a_minimal_element2(X,ESet,_EDone,Res,WF,Done) :-
2913 ESet \= [],
2914 (ESet = [El]
2915 -> X=El, empty_set_wf(Res,WF), Done=true % only one choice
2916 ; get_cardinality_wait_flag(ESet,remove_a_minimal_element2,WF,CWF),
2917 remove_a_minimal_element3(X,ESet,Res,WF,Done,CWF)
2918 ).
2919
2920 :- block remove_a_minimal_element3(?,?,?,?,?,-).
2921 remove_a_minimal_element3(X,ESet,Res,WF,Done,_) :- var(Res), !,
2922 append(_,[X|TRes],ESet), % WHAT IF Res has been instantiated in the meantime ???
2923 equal_object_wf(Res,TRes,remove_a_minimal_element2_2,WF),Done=true.
2924 remove_a_minimal_element3(X,ESet,Res,WF,Done,_) :- %print(remove_min_nonvar_res(Res)),nl,
2925 equal_cons_wf(ESet,X,Res,WF), Done=true.
2926
2927
2928 % reified version of partial function test partial_function_wf:
2929 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:partial_function_test_wf([],[int(1),int(2)],[int(7),int(6)],pred_true,WF),WF)).
2930 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:partial_function_test_wf([(int(2),int(6))],[int(1),int(2)],[int(7),int(6)],pred_true,WF),WF)).
2931 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:partial_function_test_wf([(int(1),int(6)),(int(2),int(7))],[int(1),int(2)],[int(7),int(6)],pred_true,WF),WF)).
2932 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:partial_function_test_wf([(int(2),int(8))],[int(1),int(2)],[int(7),int(6)],pred_false,WF),WF)).
2933 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:partial_function_test_wf([(int(3),int(7))],[int(1),int(2)],[int(7),int(6)],pred_false,WF),WF)).
2934 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:partial_function_test_wf([(int(1),int(7)),(int(1),int(6))],[int(1),int(2)],[int(7),int(6)],pred_false,WF),WF)).
2935
2936 :- use_module(kernel_equality,[subset_test/4]).
2937 :- block partial_function_test_wf(-,?,?,-,?), partial_function_test_wf(?,-,-,-,?).
2938 partial_function_test_wf(FF,Domain,Range,Res,WF) :- Res==pred_true,!,
2939 partial_function_wf(FF,Domain,Range,WF).
2940 partial_function_test_wf(FF,Domain,Range,Res,WF) :- Res==pred_false,!,
2941 not_partial_function(FF,Domain,Range,WF). % TO DO: remove not_partial_function to use check_is_partial_function?
2942 partial_function_test_wf(FF,Domain,Range,Res,WF) :- nonvar(FF),
2943 custom_explicit_sets:is_definitely_maximal_set(Range),
2944 % we do not need the Range; this means we can match more closures (e.g., lambda)
2945 ? custom_explicit_sets:dom_for_specific_closure(FF,FFDomain,function(_),WF),!,
2946 subset_test(FFDomain,Domain,Res,WF).
2947 partial_function_test_wf(FF,Domain,Range,Res,WF) :- nonvar(FF),
2948 % TODO: this will fail if is_definitely_maximal_set was true above !
2949 custom_explicit_sets:dom_range_for_specific_closure(FF,FFDomain,FFRange,function(_),WF),!,
2950 % same as for total_function_wf check
2951 subset_test(FFDomain,Domain,DomainOk,WF),
2952 (DomainOk==pred_false -> Res = pred_false
2953 ; conjoin_test(DomainOk,RangeOk,Res,WF),
2954 subset_test(FFRange,Range,RangeOk,WF)).
2955 partial_function_test_wf(FF,Domain,Range,Res,WF) :- nonvar(FF), FF=closure(P,T,Pred),
2956 % example: f = %x.(x:NATURAL1|x+1) & f: NATURAL1 +-> NATURAL
2957 is_lambda_value_domain_closure(P,T,Pred, FFDomain,_Expr),
2958 get_range_id_expression(P,T,TRangeID),
2959 !,
2960 subset_test(FFDomain,Domain,DomainOk,WF),
2961 (DomainOk == pred_false -> Res=pred_false
2962 ; conjoin_test(DomainOk,RangeOk,Res,WF),
2963 test_lambda_closure_range(P,T,Pred,TRangeID,Range,RangeOk,WF)
2964 ).
2965 partial_function_test_wf(R,Domain,Range,Res,WF) :-
2966 expand_and_convert_to_avl_set_warn(R,AER,partial_function_test_wf,'ARG : ? +-> ?',WF),!,
2967 % TO DO: use expand_and_convert_to_avl_set_catch
2968 (is_avl_partial_function(AER)
2969 -> % TO DO: we could do something similar to this instead: is_not_avl_relation_over_domain_range
2970 domain_of_explicit_set_wf(avl_set(AER),FFDomain,WF),
2971 subset_test(FFDomain,Domain,DomainOk,WF),
2972 (DomainOk == pred_false -> Res=pred_false
2973 ; range_of_explicit_set_wf(avl_set(AER),FFRange,WF),
2974 conjoin_test(DomainOk,RangeOk,Res,WF),
2975 subset_test(FFRange,Range,RangeOk,WF)
2976 )
2977 ; Res=pred_false).
2978 partial_function_test_wf(R,Domain,Range,Res,WF) :-
2979 expand_custom_set_to_list_wf(R,ER,_,partial_function_test_wf,WF),
2980 ? check_is_partial_function_acc_wf(ER,[],Domain,Range,Res,WF).
2981
2982 :- block check_is_partial_function_acc_wf(-,?,?,?,?,?).
2983 check_is_partial_function_acc_wf([],_,_,_,Res,_WF) :- !, Res=pred_true.
2984 check_is_partial_function_acc_wf([(A,FA)|T],Acc,Dom,Ran,Res,WF) :- !,
2985 check_pair_in_domain_range(A,FA,Dom,Ran,MemResDomRan,WF),
2986 (MemResDomRan==pred_false
2987 -> Res = pred_false
2988 ; membership_test_wf(Acc,A,MemResNotFunc,WF),
2989 negate(MemResNotFunc,MemResFunctionality),
2990 conjoin_test(MemResDomRan,MemResFunctionality,PF_Head,WF),
2991 (PF_Head == pred_false -> Res = pred_false
2992 ; T==[] -> Res=PF_Head
2993 ; add_element_wf(A,Acc,NewAcc,WF),
2994 ? conjoin_test(PF_Head,PF_Tail,Res,WF),
2995 ? check_is_partial_function_acc_wf(T,NewAcc,Dom,Ran,PF_Tail,WF))
2996 ).
2997
2998 check_pair_in_domain_range(A,FA,Dom,Ran,MemResDomRan,WF) :-
2999 membership_test_wf(Dom, A,MemResDom,WF), % use membership_test_wf_with_force for SMT mode ??
3000 (MemResDom == pred_false -> MemResDomRan = pred_false
3001 ; membership_test_wf(Ran,FA,MemResRan,WF),
3002 conjoin_test(MemResDom,MemResRan,MemResDomRan,WF)).
3003
3004 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:total_function_wf([(int(1),int(6)),(int(2),int(7))],[int(1),int(2)],[int(7),int(6)],WF),WF)).
3005 :- assert_must_succeed((kernel_relations:total_function(X,[int(1)],[int(7)]),
3006 X = [(int(1),int(7))])).
3007 :- assert_must_succeed((kernel_relations:total_function(X,[int(1),int(2)],[int(7),int(6)]),
3008 kernel_objects:equal_object(X,[(int(2),int(7)),(int(1),int(7))]))).
3009 :- assert_must_succeed((kernel_relations:total_function(X,[[(int(1),int(2))],[(int(1),int(3))]],[int(7),int(6)]),
3010 kernel_objects:equal_object(X,[([(int(1),int(3))],int(7)),([(int(1),int(2))],int(7))]))).
3011 :- assert_must_succeed((kernel_relations:total_function(X,[[(int(1),int(2))],[(int(1),int(3)),(int(2),int(3))]],
3012 [int(7),int(6)]),
3013 kernel_objects:equal_object(X,[([(int(1),int(2))],int(7)),
3014 ([(int(2),int(3)),(int(1),int(3))],int(6))]))).
3015 :- assert_must_succeed((kernel_relations:total_function(X,[int(1)],[[int(7),int(6)]]),
3016 kernel_objects:equal_object(X,[(int(1),[int(6),int(7)])]))).
3017 :- assert_must_succeed((kernel_relations:total_function(X,[[(int(1),int(2))],[(int(1),int(3)),(int(2),int(3))]],
3018 [[int(7),int(6)]]),
3019 kernel_objects:equal_object(X,[([(int(1),int(2))],[int(6),int(7)]),
3020 ([(int(2),int(3)),(int(1),int(3))],[int(6),int(7)])]))).
3021 :- assert_must_succeed((kernel_relations:total_function(X,[ [(int(1),int(3)),(int(2),int(3))]],
3022 [int(6)]),
3023 kernel_objects:equal_object(X,[ ([(int(2),int(3)),(int(1),int(3))], int(6)) ]))).
3024 :- assert_must_succeed((kernel_relations:total_function(X,global_set('Name'),
3025 [[],[fd(1,'Code'),fd(2,'Code')],[fd(1,'Code')],[fd(2,'Code')]]),
3026 kernel_objects:enumerate_basic_type(X,set(couple(global('Name'),set(global('Code'))))),
3027 kernel_objects:equal_object(X,[(fd(3,'Name'),[fd(2,'Code')]),(fd(1,'Name'),[fd(2,'Code')]),(fd(2,'Name'),[])]))).
3028
3029 %:- assert_must_succeed(( kernel_waitflags:init_wait_flags(WF),kernel_relations:total_function_wf(TF,global_set('Code'),
3030 % closure([zzzz],[set(set(couple(integer,boolean)))],
3031 % member(identifier(zzzz),
3032 % pow_subset(value(closure([zzzz],[set(couple(integer,boolean))],
3033 % member('ListExpression'(['Identifier'(zzzz)]),
3034 % 'Seq'(value([pred_true /* bool_true */,pred_false /* bool_false */])))))))),WF),
3035 % kernel_objects:equal_object(TF,[ (fd(1,'Code'), [[],[(int(1),pred_true /* bool_true */)],[(int(1),pred_true /* bool_true */),(int(2),pred_true /* bool_true */)]]),
3036 % (fd(2,'Code'), [[],[(int(1),pred_true /* bool_true */)],[(int(1),pred_true /* bool_true */),(int(2),pred_true /* bool_true */)]]) ]),
3037 % kernel_waitflags:ground_wait_flags(WF) )).
3038
3039 :- assert_must_succeed((kernel_relations:total_function([],[],[int(7)]))).
3040
3041 :- assert_must_fail((kernel_relations:total_function([],[int(1)],[int(7)]))).
3042 :- assert_must_fail((kernel_relations:total_function(X,[int(1),int(2)],[int(7),int(6)]),
3043 kernel_objects:equal_object(X,[(int(2),int(7)),(int(2),int(6))]))).
3044 :- assert_must_fail((kernel_relations:total_function(X,[int(1),int(2)],[int(7),int(6)]),
3045 kernel_objects:equal_object(X,[(int(2),int(7)),(int(1),int(5))]))).
3046 :- assert_must_fail((kernel_relations:total_function(X,[int(1),int(2)],[int(7),int(6)]),
3047 kernel_objects:equal_object(X,[(int(2),int(7))]))).
3048 :- assert_must_fail((kernel_relations:total_function(X,[[(int(1),int(2))],[(int(1),int(3)),(int(2),int(3))]],
3049 [int(7),int(6)]),
3050 kernel_objects:equal_object(X,[([(int(1),int(2))],int(7)),
3051 ([(int(1),int(3)),(int(1),int(3))],int(6))]))).
3052 :- assert_must_fail((kernel_relations:total_function(X,[[(int(1),int(2))],[(int(1),int(3)),(int(2),int(3))]],
3053 [int(7),int(6)]),
3054 kernel_objects:equal_object(X,[([(int(1),int(3)),(int(1),int(3))],int(6))]))).
3055
3056 total_function(R,Domain,Range) :- init_wait_flags(WF,[total_function]),
3057 total_function_wf(R,Domain,Range,WF),
3058 ground_wait_flags(WF).
3059
3060
3061 :- assert_must_succeed((kernel_relations:total_function_wf(X,[int(1),int(2)],[int(7),int(6)],_WF),
3062 nonvar(X),X=[(A,B),(C,D)],A==int(1),C==int(2),\+ ground(B),\+ ground(D), B=int(7),D=int(7) )).
3063
3064 :- block total_function_wf(-,-,-,?).
3065 total_function_wf(FF,Domain,_Range,WF) :- FF == [],!,
3066 empty_set_wf(Domain,WF).
3067 total_function_wf(FF,Domain,Range,WF) :-
3068 Range == [],!,
3069 ? empty_set_wf(FF,WF), empty_set_wf(Domain,WF).
3070 total_function_wf(FF,Domain,Range,WF) :-
3071 % TO DO: if FF or Domain nonvar but \= [] -> check if other variable becomes []
3072 ? total_function_wf1(FF,Domain,Range,WF).
3073
3074 :- block total_function_wf1(?,-,?,?).
3075 total_function_wf1(FF,Domain,_Range,WF) :-
3076 FF==[],!,
3077 empty_set_wf(Domain,WF).
3078 total_function_wf1(FF,Domain,Range,WF) :-
3079 custom_explicit_sets:is_definitely_maximal_set(Range),
3080 % we do not need the Range; this means we can match more closures (e.g., lambda)
3081 (nonvar(FF)
3082 ? -> custom_explicit_sets:dom_for_specific_closure(FF,FFDomain,function(_),WF),
3083 !,
3084 equal_object_wf(FFDomain,Domain,total_function_wf1_1,WF)
3085 ; var(FF),
3086 get_wait_flag1(WF,WF1), var(WF1),
3087 \+ (custom_explicit_sets:get_card_for_specific_custom_set(Domain,Card), number(Card)),
3088 % we have a total_function over a possibly infinite domain,
3089 % better wait: maybe a recursive of other closure will be produced for FF
3090 !,
3091 when( (nonvar(FF) ; nonvar(WF1)), total_function_wf1(FF,Domain,Range,WF))
3092 ).
3093 total_function_wf1(FF,Domain,Range,WF) :- nonvar(FF),
3094 custom_explicit_sets:dom_range_for_specific_closure(FF,FFDomain,FFRange,function(_),WF),!,
3095 equal_object_wf(FFDomain,Domain,total_function_wf1_2,WF),
3096 ? check_range_subset_for_closure_wf(FF,FFRange,Range,WF).
3097 total_function_wf1(R,Domain,Range,WF) :- nonvar(R), R=avl_set(AEF), !,
3098 ? total_function_avl_set(AEF,Domain,Range,WF).
3099 total_function_wf1(FF,Domain,Range,WF) :-
3100 % want to replace FF by closure: needs to be a variable!
3101 var(FF),
3102 % if the total function can not be build up explicitly (i.e. infinite domain)
3103 % TODO: can / should this be relaxed?
3104 ? is_infinite_explicit_set(Domain), % get_card_for_specific_custom_set or is_infinite_or_symbolic_closure
3105 % TO DO: delay if Domain infinite or closure and not yet known and range is type
3106 infer_value_type(Domain,set(DomT)),
3107 ? infer_value_type(Range,set(RanT)),
3108 !,
3109 % IDEA : TF = %x.(x:Domain|DEFAULT) <+ SFF, where SFF is partial function and DEFAULT is some default value
3110 % build up a partial function instead (fulfilling all constraints)
3111 % better? : %x.(x:Domain|IF x:dom(SFF) THEN SFF(x) ELSE DEFAULT)?
3112 partial_function_wf(SFF,Domain,Range,WF),
3113 % next, build up a total function mapping everything to a default value
3114 % this function will be overriden by the partial function to fulfilling
3115 % given constraints
3116 % 1. identifiers for closure
3117 create_texpr(identifier('__domid__'),DomT,[],TDomId),
3118 create_texpr(identifier('__ranid__'),RanT,[],TRanId),
3119 % 2. domain identifier might take all values of the domain
3120 create_texpr(member(TDomId,b(value(Domain),set(DomT),[])),pred,[],DomMember),
3121 % 3. pick a single value for the range identifier
3122 check_element_of_wf(RangeElement,Range,WF),
3123 %% external_functions:observe_value(RangeElement,"range"),external_functions:observe_value(SFF,"pf"),
3124 create_texpr(equal(TRanId,b(value(RangeElement),RanT,[])),pred,[],RanMember),
3125 % 4. conjunct and form closure (should be treated symbolically)
3126 conjunct_predicates([RanMember,DomMember],Pred),
3127 Default = closure(['__domid__','__ranid__'],[DomT,RanT],Pred),
3128 % 5. override default values where needed
3129 override_relation(Default,SFF,FF,WF),
3130 get_last_wait_flag(enum_symb_tf,WF,LastWF),
3131 when(nonvar(LastWF), % if we enum too early test 1619 fails; see also test 2022
3132 % as partial_function_wf does not fully enumerate the new variable SFF we may have to enumerate SFF; see test 2328
3133 (enumerate_basic_type_wf(RangeElement,RanT,WF),
3134 enumerate_basic_type_wf(SFF,set(couple(DomT,RanT)),WF)
3135 )).
3136 total_function_wf1(R,Domain,Range,WF) :-
3137 try_expand_and_convert_to_avl_with_check(Domain,EDomain,keep_intervals(1000),total_function), % avoid multiple expansions, but useless when dom_for_lambda_closure case triggers below ! TO DO: fix
3138 % TO DO: maybe avoid converting intervals which are not fully instantiated ?
3139 % TODO: done by clause above? % TO DO ?: if Range singleton set {R} and Domain infinite: return %x.(x:Domain|R); if Range not empty choose one element
3140 try_expand_and_convert_to_avl_unless_large_wf(R,ER,WF),
3141 propagate_empty_set_wf(Range,tf_range,ER,WF), % if the range of a total function is empty then the function must be empty
3142 ? total_function_wf2(ER,EDomain,Range,WF).
3143
3144 :- block total_function_wf2(?,-,?,?).
3145 total_function_wf2(R,Domain,Range,WF) :- nonvar(R), R=avl_set(AEF), !,
3146 total_function_avl_set(AEF,Domain,Range,WF).
3147 total_function_wf2(R,Domain,Range,WF) :-
3148 cardinality_as_int_wf(Domain,int(Card),WF),
3149 ? total_function_wf3(R,Card,Domain,Range,WF).
3150
3151 :- use_module(kernel_card_arithmetic,[is_inf_or_overflow_card/1]).
3152 total_function_wf3(FF,Card,Domain,Range,WF) :-
3153 nonvar(FF),
3154 ? (number(Card) -> (Card >= 1000 -> true ; is_symbolic_closure(FF)) ; true),
3155 % note: we can have symbolic closures with a finite domain: /*@symbolic */ %p.(p:BOOL|(%t.(t:NATURAL|t+100)))
3156 custom_explicit_sets:dom_for_lambda_closure(FF,FFDomain),
3157 % we have a lambda closure where we cannot determine the range,
3158 % otherwise dom_range_for_specific_closure would have succeeded
3159 % example: f = %x.(x:NATURAL1|x+1) & f: NATURAL1 --> NATURAL
3160 FF = closure(P,T,Pred),
3161 get_range_id_expression(P,T,TRangeID),
3162 !,
3163 equal_object_wf(FFDomain,Domain,total_function1_closure,WF),
3164 % CHECK not(#P.(Pred & P /: Range))
3165 check_lambda_closure_range(P,T,Pred,TRangeID,Range,WF).
3166 total_function_wf3(R,Card,Domain,Range,WF) :- nonvar(Card),is_inf_or_overflow_card(Card),!,
3167 when(nonvar(R), total_function_symbolic(R,Domain,Range,WF)).
3168 total_function_wf3(R,Card,Domain,Range,WF) :-
3169 card_convert_int_to_peano(Card,PeanoCard),
3170 ((nonvar(R);ground(PeanoCard))
3171 -> true
3172 ; get_last_wait_flag(total_fun(Domain),WF,WF1)),
3173 ? when((nonvar(R);ground(PeanoCard);
3174 (nonvar(PeanoCard),nonvar(WF1))), /* mal 12/5/04: changed , into ; 17/3/2008: added WF1 */
3175 /* reason for delaying nonvar(Card): Card grounded bit by bit by cardinality; avoid
3176 triggering too early and missing tf_var */
3177 total_function1(R,Card,PeanoCard,Domain,Range,WF
3178 )).
3179
3180 :- use_module(library(lists),[last/2]).
3181 % for a closure get the identifier or proj expression that represents range values
3182 get_range_id_expression([PairID],[Type],Res) :- !,
3183 Type = couple(_,TX),
3184 TP = b(identifier(PairID),Type,[]),
3185 safe_create_texpr(second_of_pair(TP),TX,Res). % prj2(PairID) ,
3186 %TO DO: test this e.g. with f = /*@symbolic*/ {x|x:NATURAL1*INTEGER & prj2(INTEGER,INTEGER)(x)=prj1(INTEGER,INTEGER)(x)+1} & f: NATURAL1 --> NATURAL
3187 % but currently lambda closure detection in dom_for_lambda_closure cannot handle such closures anyway
3188 get_range_id_expression(P,T,b(identifier(ID),Type,[])) :- last(P,ID), last(T,Type).
3189
3190 total_function_avl_set(AEF,Domain,Range,WF) :-
3191 (Domain = avl_set(Dom) -> is_avl_total_function_over_domain(AEF,Dom)
3192 ; is_avl_partial_function(AEF),
3193 domain_of_explicit_set_wf(avl_set(AEF),AEF_Domain,WF),
3194 equal_object_wf(AEF_Domain,Domain,total_function_avl_set,WF)
3195 ),
3196 ? is_avl_relation_over_range(AEF,Range,WF).
3197
3198 total_function_symbolic(FF,Domain,Range,WF) :-
3199 (debug_level_inactive_for(19) -> true ; print('SYMBOLIC --> check : '),translate:print_bvalue(FF),nl),
3200 % can deal with, e.g., f = %x.(x:NATURAL|x+1) & g = f <+ {0|->0} & g : INTEGER +-> INTEGER
3201 domain_wf(FF,Domain,WF),
3202 symbolic_range_subset_check(FF,Range,WF),
3203 symbolic_functionality_check(FF,WF).
3204
3205 total_function1(FF,Card,PeanoCard,Domain,Range,WF) :- nonvar(Card),is_inf_or_overflow_card(Card),
3206 nonvar(PeanoCard),is_inf_or_overflow_card(PeanoCard),!,
3207 total_function_symbolic(FF,Domain,Range,WF).
3208 total_function1(FF,_,_,Domain,Range,WF) :-
3209 expand_and_convert_to_avl_set_catch(FF,AEF,total_function1,'ARG : ? --> ?',ResultStatus,WF),!,
3210 (ResultStatus=avl_set -> total_function_avl_set(AEF,Domain,Range,WF)
3211 ; % ResultStatus=keep symbolic
3212 % TO DO: ensure no pending co-routine infinite_peano in card_convert_int_to_peano
3213 total_function_symbolic(FF,Domain,Range,WF)
3214 ).
3215 total_function1(R,_,Card,Domain,Range,WF) :-
3216 try_expand_custom_set_wf(R,ER,total_function1,WF),
3217 ? total_function2(ER,Card,Domain,Range,WF).
3218
3219 total_function2(ER,Card,Domain,Range,WF) :-
3220 var(ER),ground(Card),!,
3221 tf_var(TotalFunction,[],Card,Domain,Range,WF),
3222 ER=TotalFunction.
3223 total_function2(ER,Card,Domain,Range,WF) :-
3224 (ground(Card)
3225 -> get_wait_flag(0,tot_fun,WF,LWF) % we seem to know the domain exactly now; see e.g. test 1316
3226 ; get_wait_flag(2,total_function2,WF,LWF)), % ensure we don't start binding function as soon as Card is bound; important for test 1393; should we use another priority ?
3227 ? tf(ER,[],Card,Domain,Range,WF,LWF).
3228
3229 :- block tf(-,?,-,?,?,?,?),tf(-,?,?,?,?,?,-).
3230 ?tf([],_,0,Dom,_,WF,_) :- empty_set_wf(Dom,WF).
3231 tf(FUN,SoFar,s(Card),Dom,Ran,WF,LWF) :- var(FUN),nonvar(Dom), % try setting up skeleton for total fun
3232 remove_exact_first_element(X,Dom,Dom2),not_element_of_wf(X,SoFar,WF),var(FUN),!,
3233 ? FUN = [(X,Y)|T], tf1(X,Y,T,SoFar,Card,Dom2,Ran,WF,LWF).
3234 tf([(X,Y)|T],SoFar,s(Card),Dom,Ran,WF,LWF) :-
3235 ? not_element_of_wf(X,SoFar,WF),
3236 remove_element_wf(X,Dom,Dom2,WF), %mal: 17/3/08 changed to _wf version
3237 ? tf1(X,Y,T,SoFar,Card,Dom2,Ran,WF,LWF).
3238 tf(CS,SoFar,Card,Dom,Ran,WF,LWF) :- nonvar(CS), is_custom_explicit_set(CS),
3239 expand_custom_set_to_list_wf(CS,ER,_,tf,WF),
3240 ? tf(ER,SoFar,Card,Dom,Ran,WF,LWF).
3241 tf1(X,Y,T,SoFar,Card,Dom2,Ran,WF,LWF) :-
3242 ? check_element_of_wf(Y,Ran,WF),
3243 %when((nonvar(T);nonvar(Card)), /* mal 12/5/04: changed , into ; */
3244 add_new_element_wf(X,SoFar,SoFar2,WF), %%% try_expand_and_convert_to_avl
3245 ? tf(T,SoFar2,Card,Dom2,Ran,WF,LWF).
3246
3247 :- block tf_var(-,?,-,?,?,?).
3248 tf_var(F,_,Card,Dom,_,WF) :- Card==0,!,F=[],empty_set_wf(Dom,WF). % avoid choice point
3249 tf_var([],_,0,Dom,_,WF) :- empty_set_wf(Dom,WF).
3250 tf_var([(X,Y)|T],SoFar,s(Card),Dom,Ran,WF) :-
3251 /* supposes that X + Y are unbound */
3252 /* TO DO: rewrite like enumerate <-------------------------- */
3253 ((var(X),var(Y)) -> true ; (print_message(warning,'Nonvar in tf_var: '),
3254 print_message(warning,((X,Y))))),
3255 remove_exact_first_element(X,Dom,Dom2),
3256 not_element_of_wf(X,SoFar,WF),
3257 check_element_of_wf(Y,Ran,WF),
3258 add_new_element_wf(X,SoFar,SoFar2,WF),
3259 tf_var(T,SoFar2,Card,Dom2,Ran,WF).
3260
3261
3262
3263 :- assert_must_succeed((kernel_relations:total_bijection(X,[int(1)],[int(7)]),
3264 X = [(int(1),int(7))])).
3265 :- assert_must_succeed((kernel_relations:total_bijection(X,[int(1),int(2)],[int(7),int(8)]),
3266 kernel_objects:equal_object(X,[(int(2),int(8)),(int(1),int(7))]))).
3267 :- assert_must_fail((kernel_relations:total_bijection(X,[int(1)],[int(7),int(3)]),
3268 X = [(int(1),int(7))])).
3269 :- assert_must_fail((kernel_relations:total_bijection(X,[int(1),int(2)],[int(3)]),
3270 X = [(int(1),int(3)),(int(2),int(3))])).
3271 :- assert_must_fail((kernel_relations:total_bijection(X,[int(1),int(2)],[int(7),int(8)]),
3272 kernel_objects:equal_object(X,[(int(2),int(7)),(int(1),int(7))]))).
3273 :- assert_must_fail((kernel_relations:total_bijection(X,[int(1),int(2)],[int(7),int(8)]),
3274 X = [(int(1),int(7)),(int(1),int(8))])).
3275
3276
3277
3278 total_bijection(R,Domain,Range) :- init_wait_flags(WF,[total_bijection]),
3279 total_bijection_wf(R,Domain,Range,WF),
3280 ground_wait_flags(WF).
3281
3282 :- block total_bijection_wf(?,-,?,?).
3283 total_bijection_wf(FF,Domain,Range,WF) :- nonvar(FF),
3284 custom_explicit_sets:dom_range_for_specific_closure(FF,FFDomain,FFRange,function(bijection),WF),!,
3285 equal_object_wf(FFDomain,Domain,total_bijection_wf_1,WF),
3286 equal_object_wf(FFRange,Range,total_bijection_wf_2,WF).
3287 %(R,Domain,Range,WF) :- Domain==Range,!, print(eq_domain_range),nl, total_injection_wf(R,Domain,Range,WF).
3288 total_bijection_wf(R,Domain,Range,WF) :-
3289 same_cardinality_wf(Domain,Range,WF),
3290 ? total_injection_wf2(R,Domain,Range,WF). % TO DO: use cardinality_as_int_wf ? makes test 1194 fail
3291
3292 %Note: we used to call custom code: total_bijection_wf2(R,Domain,Card,Range,WF).
3293 % total_injection_wf2 gives a considerable performance boost, e.g., for test 1222 ClearSy/alloc_large.mch or NQueens with >->>
3294
3295 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_total_function([(int(1),int(6)),(int(2),int(7))],[int(1),int(2),int(3)],[int(7),int(6)],WF),WF)).
3296 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_total_function([(int(1),int(6)),(int(2),int(7))],[int(1),int(2)],[int(8),int(6)],WF),WF)).
3297 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_total_function([(int(1),int(6)),(int(2),int(7)),(int(1),int(7))],[int(1),int(2)],[int(7),int(6)],WF),WF)).
3298 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_total_function([(int(1),int(6)),(int(1),int(7))],[int(1)],[int(7),int(6)],WF),WF)).
3299 :- assert_must_fail((kernel_relations:not_total_function(X,[int(1)],[int(7)],_WF),
3300 X = [(int(1),int(7))])).
3301 :- assert_must_fail((kernel_relations:not_total_function(X,[int(1),int(2)],[int(7),int(6)],_WF),
3302 X = [(int(2),int(7)),(int(1),int(7))])).
3303 :- assert_must_succeed((kernel_relations:not_total_function([],[int(1)],[int(7)],_WF))).
3304 :- assert_must_succeed((kernel_relations:not_total_function([],[global_set('NAT1')],[global_set('Name')],_WF))).
3305 :- assert_must_succeed((kernel_relations:not_total_function([(int(7),int(7))],[int(1)],[int(7)],_WF))).
3306 :- assert_must_succeed((kernel_relations:not_total_function([(int(1),int(7)), (int(2),int(1))],
3307 [int(1),int(2)],[int(7)],_WF))).
3308 :- assert_must_succeed((kernel_relations:not_total_function(X,[int(1),int(2)],[int(7),int(6)],_WF),
3309 X = [(int(2),int(7)),(int(2),int(6))])).
3310
3311 :- block not_total_function(-,?,?,?), not_total_function(?,-,?,?).
3312 not_total_function(FF,Domain,Range,WF) :- nonvar(FF),custom_explicit_sets:is_definitely_maximal_set(Range),
3313 % we do not need the Range; this means we can match more closures (e.g., lambda)
3314 ? custom_explicit_sets:dom_for_specific_closure(FF,FFDomain,function(_),WF),!,
3315 not_equal_object_wf(FFDomain,Domain,WF).
3316 not_total_function(FF,Domain,Range,WF) :- nonvar(FF),
3317 custom_explicit_sets:dom_range_for_specific_closure(FF,FFDomain,FFRange,function(_),WF),!,
3318 equality_objects_wf(FFDomain,Domain,Result,WF), % not yet implemented ! % TODO ! -> sub_set,equal,super_set
3319 when(nonvar(Result),(Result=pred_false -> true ; not_subset_of_wf(FFRange,Range,WF))).
3320 not_total_function(FF,Domain,Range,WF) :- nonvar(FF), FF=closure(P,T,Pred),
3321 % example: f = %t.(t : NATURAL|t + 100) & f /: NATURAL +-> NATURAL
3322 is_lambda_value_domain_closure(P,T,Pred, FFDomain,_Expr),
3323 get_range_id_expression(P,T,TRangeID),!,
3324 equality_objects_wf(FFDomain,Domain,SubRes,WF), % compare: subset_test for not_partial_function
3325 when(nonvar(SubRes),
3326 (SubRes=pred_false -> true % not equal -> it is not a total function over the domain
3327 ; check_not_lambda_closure_range(P,T,Pred,TRangeID,Range,WF))).
3328 not_total_function(R,Domain,Range,WF) :-
3329 try_expand_and_convert_to_avl_with_check(R,ER,not_total_function_range),
3330 try_expand_and_convert_to_avl_unless_large_wf(Range,ERange,WF),
3331 not_total_function2(ER,Domain,ERange,WF).
3332
3333 % repeat block, in case Domain or R is a closure
3334 :- block not_total_function2(-,?,?,?), not_total_function2(?,-,?,?).
3335 not_total_function2(R,Domain,Range,WF) :-
3336 expand_and_convert_to_avl_set_warn(R,AER,not_total_function2,'ARG /: ? --> ?',WF),
3337 !,
3338 not_total_function_avl(AER,Domain,Range,WF).
3339 not_total_function2(R,Domain,ERange,WF) :-
3340 expand_custom_set_to_list_wf(R,ER,_,not_total_function2,WF),
3341 try_expand_and_convert_to_avl_with_check(Domain,EDomain,keep_intervals(1000),not_total_function_domain),
3342 not_tf(ER,[],EDomain,ERange,WF).
3343
3344 not_total_function_avl(_AER,Domain,_Range,_WF) :- is_infinite_explicit_set(Domain),!,
3345 true. % a finite AVL set cannot be a total function over an infinite domain
3346 not_total_function_avl(AER,Domain,Range,WF) :-
3347 expand_and_convert_to_avl_set_warn(Domain,ADom,not_total_function2,'? /: ARG --> ?',WF),
3348 !,
3349 (is_avl_total_function_over_domain(AER,ADom)
3350 ->
3351 is_not_avl_relation_over_range(AER,Range,WF)
3352 ; true
3353 ).
3354 not_total_function_avl(AER,EDomain,ERange,WF) :-
3355 expand_custom_set_to_list_wf(avl_set(AER),ER,_,not_total_function_avl,WF),
3356 not_tf(ER,[],EDomain,ERange,WF).
3357
3358
3359 :- use_module(kernel_equality,[membership_test_wf_with_force/4]).
3360
3361 :- block not_tf(-,?,?,?,?).
3362 not_tf([],_,Domain,_,WF) :- not_empty_set_wf(Domain,WF).
3363 not_tf([(X,Y)|T],SoFar,Dom,Ran,WF) :- membership_test_wf_with_force(SoFar,X,MemRes,WF),
3364 not_tf2(MemRes,X,Y,T,SoFar,Dom,Ran,WF).
3365
3366 :- block not_tf2(-,?,?,?, ?,?,?,?). %, not_tf2(?,?,?,?, -,?,?), not_tf2(?,?,?,?, ?,-,?).
3367 not_tf2(pred_true,_X,_,_T,_SoFar,_Dom,_Ran,_WF).% :- check_element_of_lazy(X,SoFar,WF).
3368 not_tf2(pred_false,X,Y,T,SoFar,Dom,Ran,WF) :-
3369 %not_element_of_wf(X,SoFar,WF),
3370 membership_test_wf_with_force(Dom,X,MemRes,WF),
3371 not_tf3(MemRes,X,Y,T,SoFar,Dom,Ran,WF).
3372
3373 :- block not_tf3(-, ?,?,?,?, ?,?,?).
3374 not_tf3(pred_false,_X,_Y,_T,_SoFar,_Dom,_Ran,_WF).
3375 not_tf3(pred_true,X,Y,T,SoFar,Dom,Ran,WF) :-
3376 remove_element_wf(X,Dom,Dom2,WF),
3377 membership_test_wf_with_force(Ran,Y,MemRes,WF),
3378 not_tf4(MemRes,X,Y,T,SoFar,Dom2,Ran,WF).
3379
3380 :- block not_tf4(-, ?,?,?,?, ?,?,?).
3381 not_tf4(pred_false,_X,_Y,_T,_SoFar,_Dom2,_Ran,_WF).
3382 not_tf4(pred_true,X,_Y,T,SoFar,Dom2,Ran,WF) :-
3383 %check_element_of_wf(Y,Ran,WF), %DO WE NEED THIS ????
3384 add_new_element_wf(X,SoFar,SoFar2,WF),
3385 not_tf(T,SoFar2,Dom2,Ran,WF).
3386
3387
3388
3389 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_total_bijection([(int(1),int(6)),(int(2),int(7))],[int(1),int(2),int(3)],[int(7),int(6)],WF),WF)).
3390 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_total_bijection([(int(1),int(6)),(int(2),int(7))],[int(1),int(2)],[int(8),int(6)],WF),WF)).
3391 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_total_bijection([(int(1),int(6)),(int(2),int(7)),(int(1),int(7))],[int(1),int(2)],[int(7),int(6)],WF),WF)).
3392 :- assert_must_fail((kernel_relations:not_total_bijection(X,[int(1)],[int(7)],_WF),
3393 X = [(int(1),int(7))])).
3394 :- assert_must_fail((kernel_relations:not_total_bijection(X,[int(1),int(2)],[int(7),int(6)],_WF),
3395 X = [(int(2),int(7)),(int(1),int(6))])).
3396 :- assert_must_fail((kernel_relations:not_total_bijection(X,[int(1),int(2)],[int(7),int(6)],_WF),
3397 X = [(int(1),int(7)),(int(2),int(6))])).
3398 :- assert_must_succeed((kernel_relations:not_total_bijection(X,[int(1),int(2)],[int(3)],_WF),
3399 X = [(int(1),int(3)),(int(2),int(3))])).
3400 :- assert_must_succeed((kernel_relations:not_total_bijection(X,[int(1),int(2)],[int(7),int(6)],_WF),
3401 X = [(int(2),int(7)),(int(1),int(7))])).
3402 :- assert_must_succeed((kernel_relations:not_total_bijection(X,[int(1)],[int(7),int(8)],_WF),
3403 X = [(int(1),int(7))])).
3404 :- assert_must_succeed((kernel_relations:not_total_bijection(X,[int(1),int(2)],[int(7)],_WF),
3405 X = [(int(2),int(7))])).
3406 :- assert_must_succeed((kernel_relations:not_total_bijection([],[int(1)],[int(7)],_WF))).
3407 :- assert_must_succeed((kernel_relations:not_total_bijection([(int(7),int(7))],[int(1)],[int(7)],_WF))).
3408 :- assert_must_succeed((kernel_relations:not_total_bijection([(int(1),int(7)), (int(2),int(1))],
3409 [int(1),int(2)],[int(7)],_WF))).
3410 :- assert_must_succeed((kernel_relations:not_total_bijection(X,[int(1),int(2)],[int(7),int(6)],_WF),
3411 X = [(int(2),int(7)),(int(2),int(6))])).
3412
3413 :- block not_total_bijection(-,?,?,?), not_total_bijection(?,-,?,?).
3414 not_total_bijection(FF,Domain,Range,WF) :-
3415 custom_explicit_sets:dom_range_for_specific_closure(FF,FFDomain,FFRange,function(bijection),WF),!,
3416 not_equal_object_wf((FFDomain,FFRange),(Domain,Range),WF).
3417 not_total_bijection(avl_set(_),Domain,_Range,_WF) :-
3418 ? is_infinite_explicit_set(Domain),!.
3419 % a finite set cannot be a total bijection over an infinite domain, see test 1641
3420 not_total_bijection(R,Domain,Range,WF) :-
3421 try_expand_custom_set_wf(R,ER,not_total_bijection,WF),
3422 not_tot_bij(ER,[],Domain,Range,WF).
3423
3424 :- block not_tot_bij(-,?,?,?,?).
3425 not_tot_bij([],_,Domain,Range,WF) :- empty_not_tot_bij(Domain,Range,WF).
3426 not_tot_bij([(X,Y)|T],SoFar,Dom,Ran,WF) :- membership_test_wf(SoFar,X,MemRes,WF),
3427 not_tot_bij2(MemRes,X,Y,T,SoFar,Dom,Ran,WF).
3428
3429 :- use_module(kernel_equality,[empty_set_test_wf/3]).
3430 :- block empty_not_tot_bij(-,?,?).
3431 empty_not_tot_bij(Domain,Range,WF) :-
3432 empty_set_test_wf(Domain,EqRes,WF),
3433 empty_not_tot_bij2(EqRes,Range,WF).
3434 :- block empty_not_tot_bij2(-,?,?).
3435 empty_not_tot_bij2(pred_false,_,_).
3436 empty_not_tot_bij2(pred_true,Range,WF) :- not_empty_set_wf(Range,WF).
3437
3438 :- block not_tot_bij2(-,?,?,?,?,?,?,?).
3439 not_tot_bij2(pred_true,_X,_,_T,_SoFar,_Dom,_Ran,_WF).
3440 not_tot_bij2(pred_false,X,Y,T,SoFar,Dom,Ran,WF) :-
3441 membership_test_wf(Dom,X,MemRes,WF),
3442 not_tot_bij3(MemRes,X,Y,T,SoFar,Dom,Ran,WF).
3443
3444 :- block not_tot_bij3(-,?,?,?,?,?,?,?).
3445 not_tot_bij3(pred_false,_X,_,_T,_SoFar,_Dom,_Ran,_WF). % X not a member of domain
3446 not_tot_bij3(pred_true,X,Y,T,SoFar,Dom,Ran,WF) :-
3447 remove_element_wf(X,Dom,Dom2,WF),
3448 membership_test_wf(Ran,Y,MemRes,WF),
3449 not_tot_bij4(MemRes,X,Y,T,SoFar,Dom2,Ran,WF).
3450
3451 :- block not_tot_bij4(-,?,?,?,?,?,?,?).
3452 not_tot_bij4(pred_false,_X,_,_T,_SoFar,_Dom2,_Ran,_WF). % Y not a member of range
3453 not_tot_bij4(pred_true,X,Y,T,SoFar,Dom2,Ran,WF) :-
3454 remove_element_wf(Y,Ran,Ran2,WF),
3455 add_element_wf(X,SoFar,SoFar2,WF),
3456 not_tot_bij(T,SoFar2,Dom2,Ran2,WF).
3457
3458
3459
3460 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:range_restriction_wf([(int(1),int(2)),(int(2),int(3))],[int(3)],[(int(2),int(3))],WF),WF)).
3461 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:range_restriction_wf([(int(1),int(2)),(int(2),int(3))],[int(2),int(3)],[(int(1),int(2)),(int(2),int(3))],WF),WF)).
3462 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:range_restriction_wf([],[int(2),int(3)],[],WF),WF)).
3463 :- assert_must_succeed((kernel_relations:range_restriction_wf([],[int(1)],[],_WF))).
3464 :- assert_must_succeed((kernel_relations:range_restriction_wf([],[],[],_WF))).
3465 :- assert_must_succeed((kernel_relations:range_restriction_wf([(int(1),int(2))],[int(1)],[],_WF))).
3466 :- assert_must_succeed((kernel_relations:range_restriction_wf([(int(1),int(2))],[int(2)],[(int(1),int(2))],_WF))).
3467 :- assert_must_succeed((kernel_relations:range_restriction_wf(X,[fd(3,'Name')],R,_WF),
3468 X = [(int(1),fd(3,'Name')),(int(2),fd(3,'Name'))],
3469 kernel_objects:equal_object(X,R))).
3470 :- assert_must_succeed((kernel_relations:range_restriction_wf(X,Y,R,_WF),
3471 X = [(int(1),fd(3,'Name')),(int(2),fd(3,'Name'))],Y=global_set('Name'),
3472 kernel_objects:equal_object(X,R))).
3473 :- assert_must_fail((kernel_relations:range_restriction_wf(X,[fd(3,'Name')],R,_WF),
3474 X = [(int(1),fd(3,'Name')),(int(2),fd(1,'Name'))],
3475 kernel_objects:equal_object(X,R))).
3476
3477 :- block range_restriction_wf(-,?,?,?),range_restriction_wf(?,-,-,?).
3478
3479 range_restriction_wf(R,S,Res,WF) :- /* R |> S */
3480 ok_to_try_restriction_explicit_set(S,R,Res),
3481 range_restriction_explicit_set_wf(R,S,SR,WF),!,
3482 ? equal_object_wf(SR,Res,range_restriction,WF).
3483 range_restriction_wf(R,S,Res,WF) :- /* R |> S */
3484 expand_custom_set_to_list_wf(R,ER,_,range_restriction,WF),
3485 ? relation_restriction_wf(ER,S,Res,pred_true,range,WF).
3486
3487 % heuristic: should we try restriction_explicit_set or
3488 % is relation_restriction with its stronger constraint propagation better
3489 ok_to_try_restriction_explicit_set(S,R,Res) :-
3490 nonvar(S),
3491 (var(Res) -> true
3492 ; S=avl_set(_),
3493 nonvar(R), R=avl_set(_) % otherwise constraint propagation from normal relation_restriction better
3494 ).
3495
3496 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:range_subtraction_wf([],[int(2)],[],WF),WF)).
3497 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:range_subtraction_wf([(int(1),int(2)),(int(2),int(3))],[int(2)],[(int(2),int(3))],WF),WF)).
3498 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:range_subtraction_wf([(int(1),int(2)),(int(2),int(3))],[],[(int(1),int(2)),(int(2),int(3))],WF),WF)).
3499 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:range_subtraction_wf([(int(1),int(2)),(int(2),int(3))],[int(1)],[(int(1),int(2)),(int(2),int(3))],WF),WF)).
3500
3501 :- block range_subtraction_wf(-,?,?,?),range_subtraction_wf(?,-,-,?).
3502 range_subtraction_wf(R,S,Res,WF) :- /* R |>> S */
3503 S==[],!,
3504 equal_object_wf(R,Res,range_subtraction1,WF).
3505 range_subtraction_wf(R,S,Res,WF) :- /* R |>> S */
3506 ok_to_try_restriction_explicit_set(S,R,Res),
3507 range_subtraction_explicit_set_wf(R,S,SR,WF),!,
3508 ? equal_object_wf(SR,Res,range_subtraction2,WF).
3509 range_subtraction_wf(R,S,Res,WF) :- /* R |>> S */
3510 expand_custom_set_to_list_wf(R,ER,_,range_subtraction,WF),
3511 relation_restriction_wf(ER,S,Res,pred_false,range,WF).
3512
3513 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:in_range_restriction_wf((int(2),int(3)),[(int(2),int(3)),(int(1),int(3))],[int(33),int(3)],WF),WF)).
3514 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:in_range_restriction_wf((int(1),int(3)),[(int(2),int(3)),(int(1),int(3))],[int(3)],WF),WF)).
3515
3516 :- block in_range_restriction_wf(-,-,-,?).
3517 in_range_restriction_wf(Pair,Rel,Set,WF) :-
3518 (treat_arg_symbolically(Set) ; treat_arg_symbolically(Rel)
3519 ; preference(convert_comprehension_sets_into_closures,true)),
3520 !,
3521 Rel \== [], % avoid setting up check_element_of for X then
3522 % x |-> y : Rel |>> Set <=> x|->y : Rel & y: Set
3523 check_element_of_wf(Pair,Rel,WF),
3524 Pair = (_,P2),
3525 check_element_of_wf(P2,Set,WF).
3526 in_range_restriction_wf(Pair,Rel,Set,WF) :-
3527 range_restriction_wf(Rel,Set,Res,WF),
3528 check_element_of_wf(Pair,Res,WF).
3529
3530 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:not_in_range_restriction_wf((int(2),int(3)),[(int(2),int(3)),(int(1),int(3))],[int(1),int(2)],WF),WF)).
3531 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:not_in_range_restriction_wf((int(11),int(3)),[(int(2),int(3)),(int(1),int(3))],[int(33),int(2)],WF),WF)).
3532
3533 :- block not_in_range_restriction_wf(-,-,-,?).
3534 not_in_range_restriction_wf(Pair,Rel,Set,WF) :-
3535 range_restriction_wf(Rel,Set,Res,WF),
3536 not_element_of_wf(Pair,Res,WF).
3537
3538 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:in_range_subtraction_wf((int(2),int(3)),[(int(2),int(3)),(int(1),int(3))],[int(33),int(1)],WF),WF)).
3539 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:in_range_subtraction_wf((int(1),int(3)),[(int(2),int(3)),(int(1),int(3))],[],WF),WF)).
3540
3541 :- block in_range_subtraction_wf(-,-,-,?).
3542 in_range_subtraction_wf(Pair,Rel,Set,WF) :-
3543 (treat_arg_symbolically(Set) ; treat_arg_symbolically(Rel)
3544 ; preference(convert_comprehension_sets_into_closures,true)),
3545 !,
3546 Rel \== [], % avoid setting up check_element_of for X then
3547 % x |-> y : Rel |>> Set <=> x|->y : Rel & y/: Set
3548 check_element_of_wf(Pair,Rel,WF),
3549 Pair = (_,P2),
3550 not_element_of_wf(P2,Set,WF).
3551 in_range_subtraction_wf(Pair,Rel,Set,WF) :-
3552 range_subtraction_wf(Rel,Set,Res,WF),
3553 check_element_of_wf(Pair,Res,WF).
3554
3555 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:not_in_range_subtraction_wf((int(2),int(3)),[(int(2),int(3)),(int(1),int(3))],[int(3),int(2)],WF),WF)).
3556 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:not_in_range_subtraction_wf((int(11),int(3)),[(int(2),int(3)),(int(1),int(3))],[int(33),int(2)],WF),WF)).
3557
3558 :- block not_in_range_subtraction_wf(-,-,-,?).
3559 not_in_range_subtraction_wf(Pair,Rel,Set,WF) :-
3560 range_subtraction_wf(Rel,Set,Res,WF),
3561 not_element_of_wf(Pair,Res,WF).
3562
3563
3564
3565 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:in_domain_restriction_wf((int(2),int(3)),[int(33),int(2)],[(int(2),int(3)),(int(1),int(3))],WF),WF)).
3566 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:in_domain_restriction_wf((int(1),int(3)),[int(1)],[(int(2),int(3)),(int(1),int(3))],WF),WF)).
3567
3568 :- block in_domain_restriction_wf(-,-,-,?).
3569 in_domain_restriction_wf(Pair,Set,Rel,WF) :-
3570 (treat_arg_symbolically(Set) ; treat_arg_symbolically(Rel)
3571 ; preference(convert_comprehension_sets_into_closures,true)),
3572 !,
3573 Rel \== [], % avoid setting up check_element_of for X then
3574 % x |-> y : Set <| Rel <=> x|->y : Rel & x: Set
3575 check_element_of_wf(Pair,Rel,WF),
3576 Pair = (P1,_),
3577 check_element_of_wf(P1,Set,WF).
3578 in_domain_restriction_wf(Pair,Set,Rel,WF) :-
3579 domain_restriction_wf(Set,Rel,Res,WF),
3580 check_element_of_wf(Pair,Res,WF).
3581
3582 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:not_in_domain_restriction_wf((int(2),int(3)),[int(33),int(1)],[(int(2),int(3)),(int(1),int(3))],WF),WF)).
3583 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:not_in_domain_restriction_wf((int(11),int(3)),[int(11),int(2)],[(int(2),int(3)),(int(1),int(3))],WF),WF)).
3584
3585 :- block not_in_domain_restriction_wf(-,-,-,?).
3586 not_in_domain_restriction_wf(Pair,Set,Rel,WF) :-
3587 domain_restriction_wf(Set,Rel,Res,WF),
3588 not_element_of_wf(Pair,Res,WF).
3589
3590 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:domain_restriction_wf([int(2),int(4)],[(int(1),int(4)),(int(2),int(3))],[(int(2),int(3))],WF),WF)).
3591 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:domain_restriction_wf([int(1),int(2)],[(int(1),int(2)),(int(2),int(3))],[(int(1),int(2)),(int(2),int(3))],WF),WF)).
3592 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:domain_restriction_wf([int(2),int(3)],[],[],WF),WF)).
3593 :- assert_must_succeed((kernel_relations:domain_restriction_wf([int(1)],[],[],_WF))).
3594 :- assert_must_succeed((kernel_relations:domain_restriction_wf([int(1)],[],R,_WF), R==[])).
3595 :- assert_must_fail((kernel_relations:domain_restriction_wf(_,[],R,_WF), R=[int(_)|_])).
3596 :- assert_must_succeed((kernel_relations:domain_restriction_wf([int(2)],[(int(1),int(2))],[],_WF))).
3597 :- assert_must_succeed((kernel_relations:domain_restriction_wf([],[(int(1),int(2))],[],_WF))).
3598 :- assert_must_succeed((kernel_relations:domain_restriction_wf([int(1)],[(int(1),int(2))],[(int(1),int(2))],_WF))).
3599 :- assert_must_succeed((kernel_relations:domain_restriction_wf([int(1)],[(int(1),int(2)),(int(2),_)],_,_WF))).
3600 :- assert_must_succeed((kernel_relations:domain_restriction_wf([int(2),int(1)],X,R,_WF),
3601 X = [(int(1),fd(3,'Name')),(int(2),fd(3,'Name'))],
3602 kernel_objects:equal_object(X,R))).
3603
3604
3605 :- block domain_restriction_wf(?,-,?,?),domain_restriction_wf(-,?,-,?).
3606 domain_restriction_wf(S,R,Res,WF) :- /* S <| R */
3607 ok_to_try_restriction_explicit_set(S,R,Res),
3608 domain_restriction_explicit_set_wf(S,R,SR,WF),!,
3609 ? equal_object_wf(SR,Res,domain_restriction,WF).
3610 domain_restriction_wf(S,R,Res,WF) :- /* S <| R */
3611 expand_custom_set_to_list_wf(R,ER,_,domain_restriction,WF),
3612 relation_restriction_wf(ER,S,Res,pred_true,domain,WF).
3613
3614 % a predicate to compute domain/range restriction/subtraction
3615 :- block relation_restriction_wf(?,-,- ,?,?,?),
3616 relation_restriction_wf(-,?,? ,?,?,?).
3617 relation_restriction_wf([],_S,Res,_AddWhen,_DomOrRange,WF) :-
3618 ? empty_set_wf(Res,WF).
3619 relation_restriction_wf([(X,Y)|T],S,Res,AddWhen,DomOrRange,WF) :-
3620 (DomOrRange=domain
3621 -> membership_test_wf(S,X,MemRes,WF) % TO DO: pass WF !
3622 ; membership_test_wf(S,Y,MemRes,WF)),
3623 (nonvar(MemRes)
3624 %MemRes==AddWhen % MemRes already set; we will ensure that (X,Y) in Res below; this slows down Alstom Compilation Regle !
3625 % doing the membership_test on the result Res if MemRes\==AddWhen only makes sense if we cannot fully compute the restriction ?? i.e. if T is not a closed list ?
3626 -> true %,(MemRes==AddWhen -> true ; print_term_summary(relation_restriction([(X,Y)|T],S,Res,AddWhen,DomOrRange)),nl)
3627 ; (AddWhen=pred_true -> InResult=MemRes
3628 ; negate(InResult,MemRes)), % from bool_pred
3629 ? membership_test_wf(Res,(X,Y),InResult,WF)
3630 % TO DO: same for explicit version; gets called e.g. if S = 1..n (1..n <| [1,2,3] = [1,2])
3631 % can now solve e.g. {x|x <| [1,2,3] = [1,2] & card(x)=2} = {{1,2}}
3632 % or x <| s = [1,2,3] \/ {29|->29} & x <: 1..100 & s = %i.(i:1..50|i)
3633 ),
3634 ? relation_restriction_aux(MemRes,X,Y,T,S,Res,AddWhen,DomOrRange,WF).
3635 :- block relation_restriction_aux(-,?,?,?,?,?, ?,?,?).
3636 relation_restriction_aux(MemRes,X,Y,T,S,Res,AddWhen,DomOrRange,WF) :-
3637 MemRes==AddWhen,!, % (X,Y) should be added to result
3638 % TO DO: collect result until we delay ? and then do equal_object ?
3639 ? equal_cons(Res,(X,Y),RT), % was : equal_object([(X,Y)|RT],Res),
3640 %equal_cons_wf(Res,(X,Y),RT,WF), % makes tests 982, 1302, 1303 fail; TO DO: investigate
3641 %when(nonvar(RT), % causes problem for test 982
3642 ? relation_restriction_wf(T,S,RT,AddWhen,DomOrRange,WF).
3643 relation_restriction_aux(_MemRes,_X,_,T,S,RT,AddWhen,DomOrRange,WF) :-
3644 % the couple is filtered out
3645 ? relation_restriction_wf(T,S,RT,AddWhen,DomOrRange,WF).
3646
3647
3648 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:domain_subtraction_wf([int(1),int(3)],[(int(1),int(4)),(int(2),int(3))],[(int(2),int(3))],WF),WF)).
3649 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:domain_subtraction_wf([int(3),int(4)],[(int(1),int(2)),(int(2),int(3))],[(int(1),int(2)),(int(2),int(3))],WF),WF)).
3650 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:domain_subtraction_wf([int(1)],[],[],WF),WF)).
3651 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:domain_subtraction_wf([],[(int(11),int(21))],[(int(11),int(21))],WF),WF)).
3652 :- assert_must_succeed((kernel_relations:domain_subtraction_wf([int(1)],[(int(1),int(2))],[],_WF))).
3653 :- assert_must_succeed((kernel_relations:domain_subtraction_wf([int(3)],[(int(1),int(2))],[(int(1),int(2))],_WF))).
3654 :- assert_must_succeed((kernel_relations:domain_subtraction_wf([int(1)],[(int(1),int(2)),(int(2),int(X))],R,_WF),
3655 R=[(int(2),int(YY))], YY==X)).
3656 :- assert_must_succeed((kernel_relations:domain_subtraction_wf([int(5),int(3)],X,R,_WF),
3657 X = [(int(1),fd(3,'Name')),(int(2),fd(3,'Name'))],
3658 kernel_objects:equal_object(X,R))).
3659 :- block domain_subtraction_wf(?,-,?,?),domain_subtraction_wf(-,?,-,?).
3660 domain_subtraction_wf(S,R,Res,WF) :- S==[],!,
3661 equal_object_wf(R,Res,domain_subtraction1,WF).
3662 domain_subtraction_wf(S,R,Res,WF) :- /* S <<| R */
3663 ok_to_try_restriction_explicit_set(S,R,Res),
3664 domain_subtraction_explicit_set_wf(S,R,SR,WF),!,
3665 ? equal_object_wf(SR,Res,domain_subtraction2,WF).
3666 domain_subtraction_wf(S,R,Res,WF) :- /* S <<| R */
3667 expand_custom_set_to_list_wf(R,ER,_,domain_subtraction,WF),
3668 try_expand_and_convert_to_avl_with_check(S,AS,keep_intervals(500),domain_subtraction),
3669 % (ground(ER) -> domain_subtraction_acc(ER,AS,[],Res) ;
3670 ? relation_restriction_wf(ER,AS,Res,pred_false,domain,WF)
3671 % )
3672 .
3673
3674
3675
3676 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:in_domain_subtraction_wf((int(2),int(3)),[int(33),int(1)],[(int(2),int(3)),(int(1),int(3))],WF),WF)).
3677 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:in_domain_subtraction_wf((int(2),int(3)),[],[(int(2),int(3)),(int(1),int(3))],WF),WF)).
3678
3679 :- block in_domain_subtraction_wf(-,-,-,?).
3680
3681 in_domain_subtraction_wf(Pair,Set,Rel,WF) :-
3682 ? (treat_arg_symbolically(Set) ; treat_arg_symbolically(Rel)
3683 ; preference(convert_comprehension_sets_into_closures,true)),
3684 !,
3685 Rel \== [], % avoid setting up check_element_of for X then
3686 % x |-> y : Set <<| Rel <=> x|->y : Rel & x/: Set
3687 check_element_of_wf(Pair,Rel,WF),
3688 Pair = (P1,_),
3689 not_element_of_wf(P1,Set,WF).
3690 in_domain_subtraction_wf(Pair,Set,Rel,WF) :-
3691 domain_subtraction_wf(Set,Rel,Res,WF),
3692 check_element_of_wf(Pair,Res,WF).
3693
3694
3695 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:not_in_domain_subtraction_wf((int(2),int(3)),[int(33),int(2)],[(int(2),int(3)),(int(1),int(3))],WF),WF)).
3696 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:not_in_domain_subtraction_wf((int(11),int(3)),[int(33),int(2)],[(int(2),int(3)),(int(1),int(3))],WF),WF)).
3697
3698 :- block not_in_domain_subtraction_wf(-,-,-,?).
3699 not_in_domain_subtraction_wf(Pair,Set,Rel,WF) :-
3700 domain_subtraction_wf(Set,Rel,Res,WF),
3701 not_element_of_wf(Pair,Res,WF).
3702
3703 % similar to kernel_objects, but adds case for [_|_]
3704 treat_arg_symbolically(X) :- var(X),!.
3705 treat_arg_symbolically([H|T]) :- \+ ground(H) ; treat_arg_symbolically(T).
3706 treat_arg_symbolically(global_set(_)).
3707 treat_arg_symbolically(freetype(_)).
3708 treat_arg_symbolically(closure(P,T,B)) :- \+ kernel_objects:small_interval(P,T,B).
3709
3710 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:override_relation([(int(1),int(2))],[(int(1),int(3))],[(int(1),int(3))],WF),WF)).
3711 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:override_relation([(int(1),int(2))],[(int(2),int(3))],[(int(1),int(2)),(int(2),int(3))],WF),WF)).
3712 :- assert_must_succeed((kernel_relations:override_relation([(int(1),int(2)),(int(2),int(4))],[(int(1),int(3))],X,_WF),
3713 kernel_objects:equal_object(X,[(int(2),int(4)),(int(1),int(3))]))).
3714 :- assert_must_succeed((kernel_relations:override_relation([(int(1),int(2)),(int(2),int(4))],[(int(3),int(6))],X,_WF),
3715 kernel_objects:equal_object(X,[(int(2),int(4)),(int(1),int(2)),(int(3),int(6))]))).
3716
3717 :- block override_relation(-,-,?,?). % overwrite AST node
3718 override_relation(R,S,Res,WF) :- R==[],!, equal_object_wf(S,Res,override_relation1,WF).
3719 override_relation(R,S,Res,WF) :- S==[],!, equal_object_wf(R,Res,override_relation2,WF).
3720 override_relation(R,S,Res,WF) :-
3721 opt_push_wait_flag_call_stack_info(WF,b_operator_call(overwrite,[R,S],unknown),WF2),
3722 ? override_relation2(R,S,Res,WF2).
3723
3724 override_relation2(R,S,Res,WF) :- Res==[],!, empty_set_wf(S,WF), empty_set_wf(R,WF).
3725 override_relation2(R,S,Res,WF) :- /* R <+ S */
3726 ? override_custom_explicit_set_wf(R,S,ORes,WF),!,
3727 equal_object_wf(ORes,Res,override_relation3,WF).
3728 override_relation2(R,S,Res,WF) :- /* R <+ S */
3729 domain_wf(S,DS,WF),
3730 domain_subtraction_wf(DS,R,DSR,WF),
3731 ? union_wf(DSR,S,Res,WF). % in principle we could call disjoint_union_wf, but fails 1112, 1751
3732
3733 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:in_override_relation_wf((int(1),int(2)),[(int(1),int(2))],[(int(2),int(3))],WF),WF)).
3734 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:in_override_relation_wf((int(2),int(3)),[(int(1),int(2))],[(int(2),int(3))],WF),WF)).
3735 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:in_override_relation_wf((int(2),int(3)),[(int(1),int(2)),(int(2),int(4))],[(int(2),int(3))],WF),WF)).
3736 :- assert_must_succeed(exhaustive_kernel_fail_check_wf(kernel_relations:in_override_relation_wf((int(2),int(4)),[(int(1),int(2)),(int(2),int(4))],[(int(2),int(3))],WF),WF)).
3737
3738 :- block in_override_relation_wf(-,-,-,?).
3739 in_override_relation_wf(Pair,Rel1,S,WF) :- S==[],!, % Pair: Rel1 <+ S
3740 check_element_of_wf(Pair,Rel1,WF).
3741 in_override_relation_wf(Pair,Rel1,S,WF) :- Rel1==[],!,
3742 check_element_of_wf(Pair,S,WF).
3743 in_override_relation_wf((X,Y),Rel1,S,WF) :-
3744 (treat_arg_symbolically(S) ; treat_arg_symbolically(Rel1)
3745 ; preference(convert_comprehension_sets_into_closures,true)),
3746 !,
3747 domain_wf(S,DS,WF),
3748 membership_test_wf(DS,X,MemRes,WF),
3749 in_override_aux(MemRes,X,Y,Rel1,S,WF).
3750 in_override_relation_wf(Pair,Rel1,S,WF) :-
3751 override_relation(Rel1,S,Res,WF),
3752 check_element_of_wf(Pair,Res,WF).
3753
3754 :- block in_override_aux(-,?,?,?,?,?).
3755 in_override_aux(pred_true,X,Y,_R,S,WF) :-
3756 check_element_of_wf((X,Y),S,WF).
3757 in_override_aux(pred_false,X,Y,R,_S,WF) :-
3758 check_element_of_wf((X,Y),R,WF).
3759
3760 :- assert_must_succeed(exhaustive_kernel_fail_check_wf(kernel_relations:not_in_override_relation_wf((int(2),int(3)),[(int(1),int(2)),(int(2),int(4))],[(int(2),int(3))],WF),WF)).
3761 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_in_override_relation_wf((int(2),int(4)),[(int(1),int(2)),(int(2),int(4))],[(int(2),int(3))],WF),WF)).
3762
3763 :- block not_in_override_relation_wf(-,-,-,?).
3764 not_in_override_relation_wf(Pair,Rel1,S,WF) :- S==[],!, % Pair: Rel1 <+ S
3765 not_element_of_wf(Pair,Rel1,WF).
3766 not_in_override_relation_wf(Pair,Rel1,S,WF) :- Rel1==[],!,
3767 not_element_of_wf(Pair,S,WF).
3768 not_in_override_relation_wf((X,Y),Rel1,S,WF) :-
3769 (treat_arg_symbolically(S) ; treat_arg_symbolically(Rel1)
3770 ; preference(convert_comprehension_sets_into_closures,true)),
3771 !,
3772 domain_wf(S,DS,WF),
3773 membership_test_wf(DS,X,MemRes,WF),
3774 not_in_override_aux(MemRes,X,Y,Rel1,S,WF).
3775 not_in_override_relation_wf(Pair,Rel1,S,WF) :-
3776 override_relation(Rel1,S,Res,WF),
3777 not_element_of_wf(Pair,Res,WF).
3778
3779 :- block not_in_override_aux(-,?,?,?,?,?).
3780 not_in_override_aux(pred_true,X,Y,_R,S,WF) :-
3781 not_element_of_wf((X,Y),S,WF).
3782 not_in_override_aux(pred_false,X,Y,R,_S,WF) :-
3783 not_element_of_wf((X,Y),R,WF).
3784
3785 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:override([],int(1),int(3),[(int(1),int(3))],WF),WF)).
3786 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:override([(int(1),int(2)),(int(2),int(6))],int(1),int(3),[(int(1),int(3)),(int(2),int(6))],WF),WF)).
3787 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:override([(int(1),int(2)),(int(2),int(6))],int(2),int(3),[(int(1),int(2)),(int(2),int(3))],WF),WF)).
3788
3789 % override for a single pair
3790 :- block override(-,?,?,?,?), override(?,-,?,?,?),
3791 override(?,?,-,?,?). % also wait on Y; try to generate avl if possible; can only be used in substitution anyway
3792 /* R <+ {X |-> Y} as used by substitution R(X) := Y */
3793 override(R,X,Y,Res,WF) :-
3794 override_pair_explicit_set(R,X,Y,ORes),!,
3795 equal_object_wf(ORes,Res,override1,WF).
3796 override(R,X,Y,Res,WF) :-
3797 if(try_expand_custom_set_to_list(R,ER,_,override),
3798 (
3799 override2(ER,X,Y,[(X,Y)],ORes,WF),
3800 equal_object_wf(ORes,Res,override2,WF)),
3801 ( %print_term_summary(exception(R)), % Virtual Timeout exception occured
3802 override_relation(R,[(X,Y)],Res,WF)
3803 )).
3804
3805 :- block override2(-,?,?,?,?,?).
3806 override2([],_X,_Y,Remainder,Res,WF) :- equal_object_optimized_wf(Remainder,Res,override2,WF). %equal_object(Remainder,Res).
3807 override2([(V,W)|T],X,Y,Remainder,Res,WF) :-
3808 equality_objects_wf(V,X,EqRes,WF),
3809 override2c(EqRes,V,W,T,X,Y,Remainder,Res,WF).
3810
3811 :- block override2c(-, ?,?,?, ?,?,?,?,?).
3812 override2c(pred_true,_V,_W,T,X,Y,_Remainder,Res,WF) :-
3813 equal_cons_wf(Res,(X,Y),T2,WF),
3814 override2(T,X,Y,[],T2,WF). /* set remainder to [], we have already added (X,Y) */
3815 override2c(pred_false,V,W,T,X,Y,Remainder,Res,WF) :-
3816 equal_cons_wf(Res,(V,W),T2,WF),
3817 override2(T,X,Y,Remainder,T2,WF).
3818
3819
3820
3821 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:image_wf([(int(1),int(2))],[int(1)],[int(2)],WF),WF)).
3822 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:image_wf([(int(1),int(2)),(int(2),int(2)),(int(3),int(3))],[int(1),int(2)],[int(2)],WF),WF)).
3823 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:image_wf([(int(1),int(2)),(int(2),int(2)),(int(1),int(3)),(int(4),int(4))],[int(1),int(2)],[int(2),int(3)],WF),WF)).
3824 :- assert_must_succeed(exhaustive_kernel_fail_check_wfdet(kernel_relations:image_wf([(int(1),int(2)),(int(2),int(2)),(int(1),int(3)),(int(4),int(4))],[int(2)],[int(2),int(3)],WF),WF)).
3825 :- assert_must_succeed(exhaustive_kernel_fail_check_wfdet(kernel_relations:image_wf([(term(floating(1.0)),term(floating(2.0))),(term(floating(2.0)),term(floating(2.0))),(term(floating(1.0)),term(floating(3.0))),(term(floating(4.0)),term(floating(4.0)))],[term(floating(2.0))],[term(floating(2.0)),term(floating(3.0))],WF),WF)).
3826 :- assert_must_succeed(kernel_relations:image_wf([(int(1),int(2))],[int(1)],[int(2)],_WF)).
3827 :- assert_must_succeed(kernel_relations:image_wf([(int(1),int(2))],[int(2)],[],_WF)).
3828 :- assert_must_succeed(kernel_relations:image_wf([(int(1),int(2))],[int(3)],[],_WF)).
3829 :- assert_must_succeed((kernel_relations:image_wf([(int(1),int(2)),(int(1),int(3))],
3830 [int(X)],R,_WF), X=1, kernel_objects:equal_object(R,[int(2),int(3)]))).
3831 :- assert_must_succeed((kernel_relations:image_wf([([int(1),int(2)],int(6)),
3832 ([int(1),int(2),int(3)],int(7)),
3833 ([int(2),int(1)],int(8))],
3834 [[int(X),int(1)]],R,_WF), X=2,
3835 kernel_objects:equal_object(R,[int(6),int(8)]))).
3836 :- assert_must_succeed(kernel_relations:image_wf([(int(1),int(2)),(int(2),int(2))],[int(1),int(2)],[int(2)],_WF)).
3837 :- assert_must_fail(kernel_relations:image_wf([(int(1),int(2))],[int(1)],[int(1)],_WF)).
3838 :- assert_must_fail(kernel_relations:image_wf([(int(1),int(2))],[int(1)],[],_WF)).
3839
3840
3841 :- block image_wf(-,?,?,?).
3842 image_wf(Rel,_,Res,WF) :- Rel==[],!,empty_set_wf(Res,WF).
3843 image_wf(Rel,S,Res,WF) :-
3844 image_for_id_closure(Rel,S,Img),!, % we don't require S to be known here
3845 equal_object_wf(Img,Res,image_wf_id_closure,WF).
3846 image_wf(Rel,S,Res,WF) :-
3847 ? image_wf0(Rel,S,Res,WF).
3848
3849 :- block image_wf0(?,-,?,?).
3850 image_wf0(Rel,S,Res,WF) :- /* Res = Rel[S] */
3851 (S==[] -> empty_set_wf(Res,WF)
3852 ; opt_push_wait_flag_call_stack_info(WF,b_operator_call(image,[Rel,S],unknown),WF2),
3853 ? image1(Rel,S,Res,WF2) ).
3854
3855 keep_symbolic(R) :- var(R),!,fail.
3856 keep_symbolic(closure(_,_,_)) :- preferences:get_preference(convert_comprehension_sets_into_closures,true),!.
3857 keep_symbolic(R) :- dont_expand_this_explicit_set(R).
3858
3859 :- block image1(-,?,?,?).
3860 image1(Rel,S,Res,WF) :-
3861 ? image_for_explicit_set(Rel,S,Img,WF),!,
3862 ? equal_object_wf(Img,Res,image1_1,WF),
3863 quick_propagate_subset_range(Res,Rel,WF).
3864 %image1(Rel,S,Res,WF) :- expand_custom_set_to_list(S,ES),!, image_of_set(ES,Rel,Res,WF).
3865 image1(Rel,Set,Res,WF) :-
3866 keep_symbolic(Rel),
3867 (preferences:get_preference(convert_comprehension_sets_into_closures,true), % in this case keep_symbolic is always true
3868 ? nonvar(Set),is_infinite_explicit_set(Set) % in this case we have to expand Rel below; what if Rel also infinite ?? --> TO DO : symbolic treatment
3869 -> debug_println(9,infinite_for_image1(Set)),
3870 fail
3871 ; true),
3872 ? ( dom_for_specific_closure(Rel,Domain,function(_),WF)
3873 -> !,
3874 expand_custom_set_to_list_wf(Set,ESet,_,image1,WF), % TO DO: what if keep_symbolic(Set)
3875 ? image_for_inf_fun(ESet,Domain,Rel,[],Res,WF)
3876 ; get_relation_types(Rel,DomType,RangeType),!,
3877 ? image_symbolic(Set,Rel,DomType,RangeType,Res,WF)
3878 ).
3879 image1(Rel,S,Res,WF) :-
3880 on_enumeration_warning(expand_custom_set_to_list_wf(Rel,Relation,_,image1_2,WF), R=failed),
3881 % bad if Rel is a big closure ! image_for_list_relation(Relation,S,Res).
3882 (R==failed ->
3883 mnf_get_relation_types(Rel,DomType,RangeType),% must succeed, as Rel is a closure with types
3884 image_symbolic(S,Rel,DomType,RangeType,Res,WF) % does not treat special case image_for_inf_fun
3885 ; propagate_singleton_image(Relation,S,Res,WF),
3886 % TO DO: we could propagate cardinality constraints about Relation,S and Res
3887 % we could also try to infer all_different constraints in case card(S)=card(Res) and f is a function
3888 ? image_for_list_relation(Relation,S,[],Res,WF)
3889 ).
3890
3891 % keep_symbolic for Rel has succeeded
3892 image_symbolic(Set,Rel,_DomType,_RangeType,Res,WF) :-
3893 is_cartesian_product_closure(Rel,Dom,Ran),!, % (A*B)[Set] == if A/\Set={} THEN {} ELSE B END
3894 test_disjoint_wf(Set,Dom,DisjointResult,WF),
3895 image_sym_disj(DisjointResult,Ran,Res,WF).
3896 image_symbolic(Set,Rel,DomType,RangeType,Res,WF) :-
3897 expand_custom_set_to_list_wf(Set,ESet,_,image1_2,WF),
3898 ? (is_symbolic_closure(Rel) % what if infinite?
3899 -> Symbolic=symbolic_try_expand, ground_value_check((Rel,ESet),GRel) % also wait for ESet to be ground so that we can catch enumeration warning exceptions, cf. test 2428 when theorem and foralls not expanded
3900 ; Symbolic=expand, ground_value_check(Rel,GRel)
3901 ),
3902 ? when(nonvar(GRel), image_for_large_relation(ESet,Rel,Symbolic,DomType,RangeType,[],Res,WF)).
3903 % Alternative: We could compute closure by calculating {yy|#(xx).(xx:Set & xx|->yy:Rel)}
3904 % image_closure(Set,Rel,DomType,RangeType,Closure ),
3905
3906 :- block image_sym_disj(-,?,?,?). % TODO: also propagate from Res to pred_true
3907 image_sym_disj(pred_true,_,Res,WF) :- empty_set_wf(Res,WF).
3908 image_sym_disj(pred_false,Ran,Res,WF) :- equal_object_wf(Res,Ran,WF).
3909
3910 % propagate that f[{x}] = {r1,...,rk} => x|->ri : f (or {x}*{r1,...,rk} <: f); see test 1532
3911 propagate_singleton_image(R,S,Res,_) :-
3912 (var(S) ; var(Res) ; nonvar(R), is_custom_explicit_set(R,psi)), !.
3913 propagate_singleton_image(Relation,S,avl_set(Res),WF) :-
3914 custom_explicit_sets:singleton_set(S,El), % we have the image by a singleton set {El}
3915 expand_custom_set_to_list_wf(avl_set(Res),LR,_,prop_singleton,WF),
3916 !,
3917 l_check_element_of(LR, El, Relation, WF). % propagate x|->ri : f (will force membership)
3918 propagate_singleton_image(_,_,_,_).
3919
3920 l_check_element_of([],_,_,_).
3921 l_check_element_of([H|T],El,Relation,WF) :-
3922 check_element_of_wf((El,H),Relation,WF),
3923 l_check_element_of(T,El,Relation,WF).
3924
3925 % quick_propagate_in_range(Set, Relation,WF) : propagate that Set <: ran(Relation)
3926 :- block quick_propagate_subset_range(-,?,?).
3927 quick_propagate_subset_range(avl_set(_),_,_) :- !.
3928 quick_propagate_subset_range([],_,_) :- !.
3929 quick_propagate_subset_range([H|T],Relation,WF) :- is_custom_explicit_set(Relation,range_wf1),
3930 range_of_explicit_set_wf(Relation,Range,WF), !,
3931 quick_propagation_element_information(Range,H,WF,NewRange),
3932 quick_propagate_subset_range2(T,NewRange,WF).
3933 quick_propagate_subset_range(_,_,_).
3934
3935 :- block quick_propagate_subset_range2(-,?,?).
3936 quick_propagate_subset_range2([H|T],NewRange,WF) :- !,
3937 quick_propagation_element_information(NewRange,H,WF,NewRange1),
3938 quick_propagate_subset_range2(T,NewRange1,WF).
3939 quick_propagate_subset_range2(_,_,_).
3940
3941 :- use_module(btypechecker, [unify_types_strict/2]).
3942 get_relation_types(Value,Domain,Range) :-
3943 infer_value_type(Value,VT),
3944 unify_types_strict(VT,set(couple(Domain,Range))). % deal also with seq types
3945 % VT=set(couple(Domain,Range)).
3946 % a version that must not fail:
3947 mnf_get_relation_types(Value,Domain,Range) :-
3948 (get_relation_types(Value,Domain,Range) -> true
3949 ; add_internal_error('Failed: ',get_relation_types(Value,Domain,Range)),
3950 Domain=any, Range=any).
3951
3952 :- block image_for_large_relation(-,?,?,?,?,?,?,?), image_for_large_relation(?,?,?,?,?,-,?,?).
3953 image_for_large_relation([],_,_,_,_,Acc,Res,WF) :- equal_object_wf(Acc,Res,WF).
3954 image_for_large_relation([XX|T],Rel,Symbolic,DomType,RangeType,Acc,Res,WF) :-
3955 get_image_singleton_closure(XX,DomType,RangeType,Rel, Par,TPara,Body),
3956 expand_closure_direct_if_possible(Symbolic,Par,TPara,Body,ImagesForXX,WF),
3957 union_wf(Acc,ImagesForXX,NewAcc,WF),
3958 ? (T == [] -> equal_object_wf(NewAcc,Res,WF)
3959 ? ; image_for_large_relation(T,Rel,Symbolic,DomType,RangeType,NewAcc,Res,WF)).
3960
3961 get_image_singleton_closure(XX,DomType,RangeType,Rel, [yy], [RangeType], Body) :-
3962 Body = b(member(b(couple(b(value(XX),DomType,[]),
3963 b(identifier(yy),RangeType,[])),couple(DomType,RangeType),[]),
3964 b(value(Rel),set(couple(DomType,RangeType)),[])),pred,[]).
3965 % TO DO: simplify above if we have Rel = closure(P,T,B); which we usually will
3966
3967 expand_closure_direct_if_possible(symbolic_try_expand,Par,Types,Body,Result,WF) :- !,
3968 catch_enumeration_warning_exceptions(
3969 custom_explicit_sets:expand_normal_closure_direct(Par,Types,Body,Result,_Done,WF),
3970 (mark_bexpr_as_symbolic(Body,SBody),
3971 Result = closure(Par,Types,SBody) % TODO: we could set definitely_symbolic for next iteration
3972 ),
3973 false,
3974 ignore(image_for_large_relation)).
3975 expand_closure_direct_if_possible(definitely_symbolic,Par,Types,Body,Result,_WF) :- !,
3976 mark_bexpr_as_symbolic(Body,SBody),
3977 Result = closure(Par,Types,SBody).
3978 expand_closure_direct_if_possible(_,Par,Types,Body,Result,WF) :-
3979 % do not memoize this (many different values):
3980 custom_explicit_sets:expand_normal_closure_direct(Par,Types,Body,Result,_Done,WF).
3981
3982
3983 /* no longer used
3984 % construct a closure for {yy|#(xx).(xx:Set & xx|->yy:Rel)}
3985 image_closure(Set,Rel,DomType,RangeType,Closure ) :- custom_explicit_sets:singleton_set(Set,XX),!,
3986 % do not set up existential quantifier if Set is singleton set
3987 Closure = closure([yy],[RangeType],Body),
3988 Body = b(member(b(couple(b(value(XX),DomType,[]),
3989 b(identifier(yy),RangeType,[])),couple(DomType,RangeType),[]),
3990 b(value(Rel),set(couple(DomType,RangeType)),[])),pred,[]).
3991 image_closure(Set,Rel,DomType,RangeType,Closure ) :-
3992 Closure = closure([yy],[RangeType],Body),
3993 couple_member_pred(xx,DomType,yy,RangeType,Rel, Predxxyy),
3994 Body = b(exists([b(identifier(xx),DomType,[])],
3995 b(conjunct(
3996 b(member(b(identifier(xx),DomType,[]),b(value(Set),set(DomType),[])),pred,[]), % TO DO : force evaluation !
3997 Predxxyy),
3998 pred,[])),pred,[used_ids([yy])]).
3999 */
4000
4001 % very similar to rel_compose_with_inf_fun, indeed f[S] = ran((id(S);f))
4002 :- block image_for_inf_fun(-,?,?,?,?,?).
4003 ?image_for_inf_fun([],_Dom,_Rel2,Acc,Comp,WF) :- equal_object_wf(Acc,Comp,WF).
4004 image_for_inf_fun([X|T],Dom,Fun,Acc,CompRes,WF) :-
4005 membership_test_wf(Dom,X,MemRes,WF),
4006 ? image_for_inf_fun_aux(MemRes,X,T,Dom,Fun,Acc,CompRes,WF).
4007
4008 :- block image_for_inf_fun_aux(-,?,?, ?,?,?,?,?).
4009 image_for_inf_fun_aux(pred_true,X,T,Dom,Fun,Acc,CompRes,WF) :-
4010 ? apply_to(Fun,X,FX,WF), % TO DO: generalize to image so that we can apply it also to infinite relations ?
4011 add_element_wf(FX,Acc,NewAcc,WF), % will block until Acc Known !!
4012 % TO DO USE: equal_cons_wf(CompRes,FX,CT,WF) + accumulator !,
4013 ? image_for_inf_fun(T,Dom,Fun,NewAcc,CompRes,WF).
4014 image_for_inf_fun_aux(pred_false,_X,T,Dom,Fun,Acc,Comp,WF) :-
4015 image_for_inf_fun(T,Dom,Fun,Acc,Comp,WF).
4016
4017
4018 /*
4019 :- block image_of_set(-,?,?,?,?), image_of_set(?,?,-,?,?).
4020 image_of_set([],Rel,ImageSoFar,Res,WF) :- equal_object(ImageSoFar,Res).
4021 image_of_set([H|T],Rel,ImageSoFar,Res,WF) :-
4022 image_of_element(Rel,H,ImageSoFar,SF2,WF),
4023 image_of_set(T,Rel,SF2,Res,WF).
4024
4025 image_of_element([],_,Acc,Res,WF) :- equal_object(Acc,Res).
4026 image_of_element([(A,B)|T],H,Acc,Res,WF) :- equality....
4027 image_of_element(avl_set(),H,Acc,Res,WF) :- ....
4028 image_of_element(closure(),....
4029 */
4030
4031 % Computing the image of a relation which is stored as a list: traverse the relation
4032 :- block image_for_list_relation(-,?,?,?,?).
4033 ?image_for_list_relation([],_,_,Res,WF) :- empty_set_wf(Res,WF).
4034 image_for_list_relation([(X,Y)|T],S,ImageSoFar,Res,WF) :-
4035 ((T==[], definitely_not_empty(Res))
4036 -> MemRes=pred_true, % we need at least one more element for Res
4037 check_element_of_wf(X,S,WF)
4038 ; (Res==[],ImageSoFar==[]) -> MemRes=pred_false, not_element_of_wf(X,S,WF) % Result empty: X cannot be in S
4039 ; membership_test_wf(S,X,MemRes,WF)
4040 ),
4041 ? image4(MemRes,Y,T,S,ImageSoFar,Res,WF).
4042
4043 definitely_not_empty(Set) :- nonvar(Set), Set \== [], \+ functor(Set,closure,3). % Set \= closure(_,_,_).
4044
4045 :- block image4(-, ?,?,?, ?,?,?).
4046 image4(pred_true, Y,T,S, ImageSoFar,Res,WF) :-
4047 (Res==[]
4048 ? -> MemRes=pred_true, check_element_of_wf(Y,ImageSoFar,WF)
4049 ; membership_test_wf(ImageSoFar,Y,MemRes,WF)
4050 ),
4051 ? image5(MemRes,Y,T,S,ImageSoFar,Res,WF).
4052 image4(pred_false, _Y,T,S, ImageSoFar,Res,WF) :-
4053 ? image_for_list_relation(T,S,ImageSoFar,Res,WF).
4054
4055 :- block image5(-, ?,?,? ,?,?,?).
4056 image5(pred_true,_Y,T,S,ImageSoFar,Res,WF) :- /* we have already added Y to the image */
4057 ? image_for_list_relation(T,S,ImageSoFar,Res,WF).
4058 image5(pred_false,Y,T,S,ImageSoFar,Res,WF) :-
4059 add_element_wf(Y,ImageSoFar,ImageSoFar2,WF),
4060 kernel_objects:mark_as_non_free(Y,image), % Y has been added to image, no longer freely choosable
4061 ? equal_cons_wf(Res,Y,Res2,WF),
4062 ? image_for_list_relation(T,S,ImageSoFar2,Res2,WF).
4063
4064
4065
4066 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:image_for_closure1_wf([(int(1),int(2)),(int(2),int(1)),(int(3),int(3))],[int(2)],[int(1),int(2)],WF),WF)).
4067 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:image_for_closure1_wf([(int(1),int(2)),(int(2),int(1)),(int(3),int(3))],[],[],WF),WF)).
4068 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:image_for_closure1_wf([(int(1),int(2)),(int(2),int(1)),(int(3),int(3))],[int(3)],[int(3)],WF),WF)).
4069 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:image_for_closure1_wf([(term(floating(1.0)),term(floating(2.0))),(term(floating(2.0)),term(floating(1.0))),(term(floating(3.0)),term(floating(3.0)))],[term(floating(2.0))],[term(floating(1.0)),term(floating(2.0))],WF),WF)).
4070 % version for computing closure1(Rel)[S]
4071 :- block image_for_closure1_wf(-,?,?,?),image_for_closure1_wf(?,-,?,?).
4072 image_for_closure1_wf(Rel,S,Res,WF) :- (Rel==[] ; S==[]),!,empty_set_wf(Res,WF).
4073 image_for_closure1_wf(Rel,Set,Res,WF) :-
4074 try_expand_and_convert_to_avl_unless_large_wf(Set,ESet,WF),
4075 ? image_for_closure1_wf_aux(Rel,ESet,Res,WF).
4076
4077 :- use_module(library(avl),[avl_height/2]).
4078 image_for_closure1_wf_aux(Rel,S,Res,WF) :-
4079 (nonvar(S),S=avl_set(_)
4080 -> closure1_for_explicit_set_from(Rel,S,Closure1Rel),!,
4081 % if S is known: start from S (currently only deals with Rel=avl_set(_)
4082 range_wf(Closure1Rel,Res,WF)
4083 ; Rel=avl_set(AR), avl_height(AR,AR_Height),
4084 (set_smaller_than(S,4),AR_Height>4
4085 -> !, % TO DO: we could do the same for small S if Rel is large
4086 when(ground(S), (expand_and_convert_to_avl_set(S,ES,image_for_closure1_wf_aux,'closure1(ARG)[?]') ->
4087 closure1_for_explicit_set_from(Rel,avl_set(ES),Closure1Rel),
4088 range_wf(Closure1Rel,Res,WF)
4089 ; image_for_closure1_iterate(Rel,S,[],Res,WF,first_iteration(S))
4090 ))
4091 ; % Don't do this if avl_height too large; then it is probably better to compute the image for S only
4092 AR_Height < 13, % how big should we make this magic constant; or should we time-out ? 2^14=16384
4093 closure1_for_explicit_set(Rel,Closure1Rel),!, % we can compute it effiently; don't use code below
4094 image_wf(Closure1Rel,S,Res,WF)
4095 )
4096 ).
4097 image_for_closure1_wf_aux(Rel,S,Res,WF) :-
4098 ? propagate_result_in_range(Rel,S,Res,WF),
4099 ? image_for_closure1_iterate(Rel,S,[],Res,WF,first_iteration(S)).
4100
4101 % no need to treat avl_sets; already covered as special case above
4102 set_smaller_than([],_).
4103 set_smaller_than([_|T],N) :- N>1, nonvar(T), N1 is N-1, set_smaller_than(T,N1).
4104
4105 image_for_closure1_iterate(Rel,S,Acc,Res,WF,FIRST) :-
4106 image_wf0(Rel,S,Res1,WF),
4107 ground_value_check(Res1,RV),
4108 ? image_for_closure1_check_fix(RV,Rel,Acc,Res1,Res,WF,FIRST).
4109
4110 :- block image_for_closure1_check_fix(-,?,?,?,?,?,?).
4111 image_for_closure1_check_fix(_,Rel,Acc,Res1,Res,WF,FIRST) :-
4112 %try_expand_and_convert_to_avl_unless_large_wf(Res1,ERes1,WF),
4113 difference_set(Res1,Acc,New), % TODO: check if we can pass WF
4114 try_expand_and_convert_to_avl(New,ENew), % we compute difference_set below; we most definitely will need an explicit finite representation
4115 (not_empty_set_wf(ENew,WF),
4116 union(ENew,Acc,Acc1), % Note: we do not call union_wf - should we do this
4117 % upon first iteration remove also S from New -> New2 and pass New2 to image_for_closure1_iterate
4118 % TO DO: investigate whether this also makes sense for further iterations; always remove S
4119 (FIRST=first_iteration(S) -> difference_set(ENew,S,New2) ; New2=ENew),
4120 ? image_for_closure1_iterate(Rel,New2,Acc1,Res,WF,not_first)
4121 ;
4122 ? empty_set_wf(ENew,WF),equal_object_optimized_wf(Acc,Res,image_for_closure1_check_fix,WF)).
4123
4124 % propagate information that if closure1(Rel)[.] = Res => Res <: range(Rel)
4125 % x: 1..n --> 1..n & closure1(x)[{1}] = {} & n=100
4126 :- block propagate_result_in_range(?,?,-,?).
4127 propagate_result_in_range(Rel,_S,_Res,_WF) :-
4128 ground_value(Rel),!. % no propagation required
4129 propagate_result_in_range(Rel,S,[],WF) :- !,
4130 domain_wf(Rel,Domain,WF),
4131 not_subset_of_wf(S,Domain,WF).
4132 propagate_result_in_range(Rel,_,Res,WF) :-
4133 range_wf(Rel,Range,WF),
4134 ? check_subset_of_wf(Res,Range,WF).
4135
4136 :- use_module(probsrc(avl_tools),[avl_height_less_than/2]).
4137
4138 % version for computing iterate(K,Rel)[S]
4139 % iteration AST node
4140 :- block image_for_iterate_wf(?,-,?,?,?,?), image_for_iterate_wf(?,?,-,?,?,?).
4141 image_for_iterate_wf(_Rel,K,S,Res,_,WF) :- S==[],!,
4142 (nonvar(K),K=int(KN),integer(KN), KN<0 -> add_wd_error('negative index in iterate',KN,WF)
4143 ; true), % TODO: we could use a stronger delaying check if find_abort_values is true
4144 empty_set_wf(Res,WF).
4145 image_for_iterate_wf(Rel,int(K),S,Res,Type,WF) :-
4146 image_for_iterate_k(K,Rel,S,Res,Type,WF).
4147
4148 :- block image_for_iterate_k(-,?,?,?,?,?).
4149 image_for_iterate_k(K,_Rel,_S,_Res,_Type,WF) :- K<0, !, % otherwise image_for_iterate_k_loop would not terminate
4150 add_wd_error('negative index in iterate',K,WF).
4151 image_for_iterate_k(K,Rel,S,Res,Type,WF) :-
4152 nonvar(Rel),
4153 Rel=avl_set(AVL),
4154 (var(S) -> avl_height_less_than(AVL,11) ; avl_height_less_than(AVL,3)),
4155 !, % compute the iteration once; possibly better constraint propagation and performance if S enumerated
4156 % e.g. x:{1,10,20} & iterate({1|->10,20|->1,10|->20},2)(x) = 20
4157 rel_iterate_wf(Rel,int(K),RelIterated,Type,WF),
4158 image_wf(RelIterated,S,Res,WF).
4159 image_for_iterate_k(K,Rel,S,Res,_,WF) :-
4160 image_for_iterate_k_loop(K,Rel,S,Res,WF).
4161
4162 :- block image_for_iterate_k_loop(?,?,-,?,?).
4163 image_for_iterate_k_loop(0,_Rel,Acc,Result,WF) :- !,
4164 equal_object_optimized_wf(Acc,Result,image_for_iterate_k,WF).
4165 image_for_iterate_k_loop(K,Rel,Acc,Result,WF) :-
4166 image_wf0(Rel,Acc,Acc1,WF), % we could try and detect fix point if K> some limit or time for iteration is measurable
4167 if((K>10, K mod 10 =:= 0, % check for fixpoint every 10 iterations
4168 nonvar(Acc1), Acc1=avl_set(_), quick_custom_explicit_set_approximate_size(Acc1,Size1),
4169 quick_custom_explicit_set_approximate_size(Acc,Size0),
4170 Size0=Size1, % only check for equality if approximate sizes match
4171 equal_explicit_sets_wf(Acc,Acc1,WF)),
4172 K1=0, % fixpoint found, no need to continue iterating
4173 K1 is K-1),
4174 image_for_iterate_k_loop(K1,Rel,Acc1,Result,WF).
4175
4176 special_operator_for_image(b(Rel,Type,_),Kind,Args) :- special_image_aux(Rel,Type,Kind,Args).
4177 special_image_aux(closure(Rel),_,closure,[Rel]). % we have closure1(Rel)[Set] -> avoid computing full closure
4178 special_image_aux(iteration(Rel,K),Type,iteration(Type),[Rel,K]).
4179 % TODO: reflexive closure, id_closure (this will probably be more natural as special case for a value)
4180
4181 ?image_for_special_operator(closure,[Rel],S,Res,WF) :- image_for_closure1_wf(Rel,S,Res,WF).
4182 image_for_special_operator(iteration(Type),[Rel,K],S,Res,WF) :-
4183 image_for_iterate_wf(Rel,K,S,Res,Type,WF).
4184
4185 :- use_module(kernel_objects,[singleton_set_element/4]).
4186 apply_fun_for_special_operator(Kind,EArgs,FunArg,Res,WF,Span) :-
4187 InitialSet = [FunArg], % TODO: try convert to AVL, note: closure1 not really useful in fun. application context
4188 image_for_special_operator(Kind,EArgs,InitialSet,SetRes,WF),
4189 singleton_set_element(SetRes,Res,Span,WF).
4190
4191 % iterate(%x.(x:NATURAL|x+2),2000)(20) much faster this way, 15 ms vs 4 seconds
4192 % iterate(%x.(x:NATURAL|x+2),2000)[{20}]: ditto
4193
4194
4195 % -----------------------------------
4196
4197 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:apply_to([(int(2),int(22))],int(2),int(22),WF),WF)).
4198 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:apply_to([(int(1),int(22)),(int(3),int(33)),(int(4),int(44))],int(3),int(33),WF),WF)). % used to be wfdet (see in_domain_wf above)
4199 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:apply_to([(int(1),[int(22)]),(int(3),[int(32),int(33)]),(int(4),[int(44)])],int(3),[int(32),int(33)],WF),WF)). % used to be wfdet (see in_domain_wf above)
4200 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:apply_to([(term(floating(1.0)),int(22)),(term(floating(3.0)),int(33)),(term(floating(4.0)),int(44))],term(floating(3.0)),int(33),WF),WF)).
4201 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:apply_to([(string(one),int(22)),(string(three),int(33)),(string(four),int(44))],string(three),int(33),WF),WF)).
4202 :- assert_must_succeed(kernel_relations:apply_to([(int(1),int(2))],int(1),int(2),_WF)).
4203 :- assert_must_succeed((kernel_relations:apply_to(F,int(3),int(2),_WF),F=[(int(3),int(2)),(int(2),int(1))])).
4204 :- assert_must_succeed((kernel_relations:apply_to(F,X,int(1),_WF),F=[(int(3),int(2)),(int(2),int(1))],X=int(2))).
4205 :- assert_must_succeed((kernel_relations:apply_to(F,int(3),_,_WF),F=[(int(3),[int(2),int(3)]),(int(2),[])])).
4206
4207 :- assert_must_fail(kernel_relations:apply_to([(int(1),int(2)),(int(1),int(3))],int(1),int(3),_WF)).
4208 /* input not a function */
4209 ?apply_to(R,X,Y,WF) :- apply_to(R,X,Y,unknown,unknown,WF).
4210 ?apply_to(R,X,Y,Span,WF) :- apply_to(R,X,Y,unknown,Span,WF).
4211
4212 % comment in to perform profiling at function call level; can lead to big slowdowns
4213 %:- load_files(library(system), [when(compile_time), imports([environ/2])]).
4214 %:- use_module(source_profiler,[opt_add_source_location_hits/2]).
4215 %apply_to(_R,_X,_Y,_FunctionType,Span,_WF) :- opt_add_source_location_hits(Span,1),fail.
4216
4217 :- block apply_to(-,-,-,?,?,?).
4218 apply_to(R,X,Y,_FunctionType,Span,WF) :-
4219 % we could check if WD condition discharged in Span
4220 (\+ preferences:preference(find_abort_values,false) ; preference(data_validation_mode,true)),
4221 !,
4222 ? apply_to_var_block_abort(R,X,Y,R,Span,WF). % we have to know R before we can do anything
4223 apply_to(R,X,Y,FunctionType,Span,WF) :-
4224 (var(R),var(X) -> force_in_domain_wf(X,R,WF) ; true),
4225 ? apply_to1(R,X,Y,R,FunctionType,Span,WF).
4226
4227
4228
4229 :- use_module(preferences,[preference/2]).
4230 :- use_module(clpfd_tables,[can_translate_function_to_element_constraint/2,check_apply_with_element_constraint/5]).
4231 :- block apply_to1(-,-,?,?,?,?,?).
4232 apply_to1(R,X,Y,InitialRel,FunctionType,Span,WF) :-
4233 ? (var(R) -> apply_to_var(R,X,Y,InitialRel,Span,WF)
4234 ; R\=[], can_translate_function_to_element_constraint(R,FunctionType) ->
4235 ? check_apply_with_element_constraint(R,X,Y,FunctionType,WF)
4236 ? ; apply_to_nonvar(R,X,Y,InitialRel,Span,WF),
4237 propagate_range_membership(R,Y)
4238 ).
4239 :- block apply_to2(-,-,?,?,?,?).
4240 apply_to2(R,X,Y,InitialRel,Span,WF) :-
4241 (var(R)
4242 ? -> apply_to_var(R,X,Y,InitialRel,Span,WF)
4243 ? ; apply_to_nonvar(R,X,Y,InitialRel,Span,WF)
4244 ).
4245
4246 :- use_module(clpfd_lists,[get_finite_fdset_information/2,combine_fdset_information/3,
4247 assert_fdset_information/2,get_fdset_information/2]).
4248 % tested in test 1478; initially slows down NQueens
4249 %:- block propagate_range_membership(-,?). % not necessary
4250 propagate_range_membership([(_,RanEl)|T],X) :- nonvar(RanEl),
4251 preferences:preference(use_clpfd_solver,true),
4252 preferences:preference(find_abort_values,false),
4253 get_finite_fdset_information(RanEl,Info), % TO DO: try and detect if we can apply element/3 from clpfd
4254 \+ ground(X),
4255 get_fdset_information(X,InfoX),
4256 Info \= InfoX, % avoids NQueens slowdown; TO DO: check if more precise than InfoX; otherwise no use in collecting info
4257 !,
4258 propagate_range_membership(T,Info,X).
4259 propagate_range_membership(_,_).
4260 :- block propagate_range_membership(-,?,?).
4261 propagate_range_membership([],Info,El) :- !,
4262 % note: the information for the first few elements might have become more precise; TO DO: wait until list known and then propagate ?+ keep on propagating ??
4263 assert_fdset_information(Info,El).
4264 propagate_range_membership([(_,RanEl)|T],Acc,X) :-
4265 nonvar(RanEl), % otherwise we have no info: we may just as well stop
4266 get_finite_fdset_information(RanEl,RInfo),
4267 combine_fdset_information(Acc,RInfo,NewAcc),
4268 NewAcc \= no_fdset_info,
4269 !,
4270 propagate_range_membership(T,NewAcc,X).
4271 propagate_range_membership(_,_,_).
4272
4273
4274 apply_to_var(R,X,Y,InitialRel,Span,WF) :-
4275 mark_var_set_as_non_empty(R),
4276 get_wait_flag(1.0,apply_to_var,WF,WF1), % see tests 1393, 1562??
4277 % was: get_wait_flag0(WF,WF1), but see test 1706 (in conjunction for improvement for test 2033)
4278 ? when(((nonvar(WF1),ground(X));nonvar(R)), % only instantiate R when X sufficiently instantiated (TO DO: maybe use some for of equality_objects with existing relation R set up so far ??)
4279 (var(R) ->
4280 R=[(X,Y)|Tail],
4281 optional_functionality_check(Tail,X,WF)
4282 ; apply_to_nonvar(R,X,Y,InitialRel,Span,WF))).
4283
4284 :- block apply_to_var_block_abort(-,?,?,?,?,?).
4285 apply_to_var_block_abort(R,X,Y,InitialRel,Span,WF) :-
4286 ? apply_to_nonvar(R,X,Y,InitialRel,Span,WF).
4287
4288 optional_functionality_check(Tail,X,WF) :-
4289 preferences:preference(disprover_mode,true),!,
4290 not_in_domain_wf(X,Tail,WF). % we assert that R is a function ; when disproving we can assume well-definedness
4291 % Note: this can cut down the search space ; see e.g. test 1230 (but e.g. it will not find a problem with test 1169, RULE_r967_1)
4292 optional_functionality_check(_,_X,_WF). % TO DO: maybe lazily check if we have other elements with X as first arg if find_abort_values is true
4293
4294
4295 :- use_module(closures,[is_recursive_closure/3]).
4296 :- use_module(memoization,[is_memoization_closure/4,apply_to_memoize/8]).
4297 :- load_files(library(system), [when(compile_time), imports([environ/2])]).
4298 :- if(\+ environ(no_wd_checking,true)).
4299 apply_to_nonvar([],X,_Y,InitialRel,Span,WF) :-
4300 \+ preferences:preference(find_abort_values,false),
4301 add_wd_error_span('function applied outside of domain (#2): ', '@fun'(X,InitialRel),Span,WF).
4302 :- endif.
4303 apply_to_nonvar([(X2,Y2)|T],X,Y,InitialRel,Span,WF) :-
4304 equality_objects_wf(X2,X,EqRes,WF),
4305 % this check on Y2 below is important if both Y and Y2 are instantiated but X,X2 not yet
4306 % example: aload_R07_cbc.mch (Savary) or cbc_sequence check for R08_ByteArray for aload_R07 event (test 1349)
4307 % however: slows down test 583 !
4308 (var(EqRes) -> equality_objects_wf(Y2,Y,EqResY,WF),
4309 prop_apply_eqxy(EqResY,EqRes) % propagate: if Y/=Y2 => X/=X2
4310 ; EqResY=not_called),
4311 ? apply_to4(EqRes,EqResY,Y2,T,X,Y,InitialRel,Span,WF).
4312 apply_to_nonvar(avl_set(A),X,Y,_InitialRel,Span,WF) :-
4313 ? apply_to_avl_set(A,X,Y,Span,WF).
4314 apply_to_nonvar(closure(P,T,B),X,Y,_InitialRel,Span,WF) :-
4315 %is_custom_explicit_set(Closure,apply), % should also work for avl_set,...
4316 ? (is_memoization_closure(P,T,B,MemoID)
4317 % Function application with memoization; currently enabled by add /*@desc memo */ pragma to abstract constant
4318 ? -> apply_to_memoize(MemoID,P,T,B,X,Y,Span,WF)
4319 ? ; is_recursive_closure(P,T,B) % TO DO: maybe we should do the same for functions marked as memoize symbolic/uni-directional/computed ? (although we have new rule for check_element_of_function_closure which makes this redundant ??)
4320 -> % print_term_summary(apply_recursive_closure(X,P,T,B)),
4321 %hit_profiler:add_profile_hit(rec_apply_closure_to_nonvar(X,Y,P,T,B,Span,WF)),
4322 ? ground_value_check(X,XV), block_apply_closure_to_nonvar_groundx(XV,X,Y,P,T,B,Span,WF)
4323 ; %hit_profiler:add_profile_hit(apply_closure_to_nonvar(X,Y,P,T,B,Span,WF)),
4324 ? apply_closure_to_nonvar(X,Y,P,T,B,Span,WF)).
4325
4326
4327 :- block block_apply_closure_to_nonvar_groundx(-,?,?, ?,?,?, ?,?).
4328 ?block_apply_closure_to_nonvar_groundx(_,X,Y, P,T,B, Span,WF) :- apply_closure_to_nonvar_groundx(X,Y,P,T,B,Span,WF).
4329
4330 apply_closure_to_nonvar_groundx(X,Y,P,T,B,Span,WF) :-
4331 kernel_tools:ground_bexpr(B),
4332 !, % then if the element of function succeeds there is no need to check WD
4333 ? if(check_element_of_function_closure(X,Y,P,T,B,WF),
4334 true, % No need to check for well-definedness; no pending choice points
4335 apply_closure_to_nonvar_wd_check(X,P,T,B,Span,WF) % here we need to check; it could be that the result Y was instantiated
4336 ).
4337 apply_closure_to_nonvar_groundx(X,Y,P,T,B,Span,WF) :-
4338 apply_closure_to_nonvar(X,Y,P,T,B,Span,WF).
4339
4340 % if we first check preferences:preference(find_abort_values,false) to avoid a choice
4341 % point, we get a big slow-down on Alstom models; e.g., vesg_Mar12
4342 % WARNING: This choice point can be set up in WF0 !
4343 apply_closure_to_nonvar(X,Y,P,T,B,_,WF) :-
4344 (preferences:preference(find_abort_values,false) -> ! ; true), % slow down ???!
4345 ? check_element_of_function_closure(X,Y,P,T,B,WF) .
4346 apply_closure_to_nonvar(X,_,P,T,B,Span,WF) :- % removing this clause doubles runtime of COMPUTE_GRADIENT_CHANGE
4347 apply_closure_to_nonvar_wd_check(X,P,T,B,Span,WF).
4348
4349 apply_closure_to_nonvar_wd_check(X,P,T,B,Span,WF) :-
4350 \+ preferences:preference(find_abort_values,false),
4351 not_in_domain_wf(X,closure(P,T,B),WF),
4352 when((ground(X),ground(closure(P,T,B))),
4353 add_wd_error_span('function applied outside of domain (#3): ', '@fun'(X,closure(P,T,B)),Span,WF)).
4354
4355
4356 % propagate equality_objects between range and domain elements for function application:
4357 :- block prop_apply_eqxy(-,-).
4358 prop_apply_eqxy(Eqy,Eqx) :- var(Eqy),!, (Eqx = pred_true -> Eqy = pred_true ; true).
4359 prop_apply_eqxy(pred_false,pred_false).
4360 prop_apply_eqxy(pred_true,_).
4361
4362 :- block apply_to4(-,?,?, -,?,?,?,?,?).
4363 apply_to4(EqResX,EqResY,Y2, Tail,X,Y,InitialRel,Span,WF) :-
4364 var(EqResX),!, % Tail bound
4365 (Tail == []
4366 -> (preferences:preference(find_abort_values,false)
4367 -> EqResX = pred_true,
4368 ? apply_to4(EqResX,EqResY,Y2, Tail,X,Y,InitialRel,Span,WF)
4369 ; apply_to4_block(EqResX,EqResY,Y2, Tail,X,Y,InitialRel,Span,WF)
4370 )
4371 ; Tail = avl_set(_) -> apply_to4_block(EqResX,EqResY,Y2, Tail,X,Y,InitialRel,Span,WF) % TO DO: improve ! (e.g., expand to list if small or check if X can be in domain,...)
4372 ; Tail = closure(_,_,_) -> apply_to4_block(EqResX,EqResY,Y2, Tail,X,Y,InitialRel,Span,WF)
4373 ; Tail \= [_|_] -> add_internal_error('Illegal Tail: ',apply_to4(EqResX,EqResY,Y2, Tail,X,Y,InitialRel,Span,WF)),fail
4374 ; Tail = [(X3,Y3)|T3], % setup equality check with X3, purpose: detect, e.g., when no other element in tail can match we can force EqResX to pred_true
4375 ? apply_to4_call5(EqResX,EqResY,Y2, Tail,X,Y,InitialRel,Span,WF, X3,Y3,T3)
4376 ).
4377 apply_to4(pred_true,EqResY,Y2, Tail,X,Y,_InitialRel,_,WF) :-
4378 ? (EqResY==not_called -> equal_object_wf(Y2,Y,apply_to4,WF) ; EqResY = pred_true),
4379 optional_functionality_check(Tail,X,WF).
4380 ?apply_to4(pred_false,_EqResY,_Y2,T,X,Y,InitialRel,Span,WF) :- apply_to2(T,X,Y,InitialRel,Span,WF).
4381
4382 % we delay setting up equality_objects until X3 is at least partially known, see test 1715 Alstom_essai2_boucle1
4383 % TO DO: we could check if X3==X above
4384 :- block apply_to4_call5(-,?,?, ?,?,?,?,?,?, -,?,?).
4385 apply_to4_call5(EqResX,EqResY,Y2, Tail,X,Y,InitialRel,Span,WF, _X3,_Y3,_T3) :- nonvar(EqResX),!,
4386 apply_to4(EqResX,EqResY,Y2,Tail,X,Y,InitialRel,Span,WF).
4387 apply_to4_call5(EqResX,EqResY,Y2, _Tail,X,Y,InitialRel,Span,WF, X3,Y3,T3) :- % X3 must now be bound
4388 equality_objects_wf(X3,X,EqRes3,WF),
4389 ? apply_to5(EqResX,EqResY,EqRes3, Y2,X3,Y3,T3, X,Y, InitialRel,Span,WF).
4390
4391 % version which wait suntil first argument known
4392 :- block apply_to4_block(-,?,?, ?,?,?,?,?,?).
4393 apply_to4_block(EqResX,EqResY,Y2, Tail,X,Y,InitialRel,Span,WF) :-
4394 apply_to4(EqResX,EqResY,Y2, Tail,X,Y,InitialRel,Span,WF).
4395
4396
4397 % apply_to5: implements a watched-literal style treatment of function application
4398 % we watch whether X unifies with two elements of the function, if only one element left we can force equality
4399 % TEST:
4400 % f : 11..23 +-> 1..10 & f = {a|->2, b|->3, c|->4} & card({a,b,c})=3 & f(x)=r & a>b & b>c & x>b
4401 :- block apply_to5(-,?,-, ?,?,?,?, ?,?, ?,?,?),apply_to5(-,?,?, ?,?,?,-, ?,?, ?,?,?).
4402 apply_to5(EqRes,EqResY,EqRes3, Y2,_X3,Y3,T3, X,Y, InitialRel,Span,WF) :-
4403 var(EqRes),!,
4404 % EqRes3 and T3 must be known; TO DO: improve predicate so that we have to wait on T3 only when EqRes3=pred_false
4405 (EqRes3 = pred_false -> % we cannot match next element, move tail one forward
4406 (T3 = [] -> EqRes=pred_true ; true),
4407 ? apply_to4(EqRes,EqResY,Y2,T3,X,Y,InitialRel,Span,WF)
4408 ; /* EqRes3 = pred_true */
4409 % we match the next entry in the list; discard Y2 and jump to (X3,Y3) and return as solution
4410 ? equal_object_wf(Y3,Y,apply_to6,WF), optional_functionality_check(T3,X,WF),
4411 % TO DO: we could also do equality_objects if necessary between Y and Y3, as in apply_to4 for Y and Y2
4412 ? opt_force_false(EqRes)
4413 ).
4414 apply_to5(pred_true,EqResY,EqRes3, Y2,X3,Y3,T3, X,Y, _InitialRel,_Span,WF) :-
4415 (EqResY==not_called -> equal_object_wf(Y2,Y,apply_to5,WF) ; EqResY = pred_true),
4416 ? opt_force_false(EqRes3),
4417 optional_functionality_check([(X3,Y3)|T3],X,WF).
4418 apply_to5(pred_false,_EqResY,EqRes3, _Y2,_X3,Y3,T3, X,Y, InitialRel,Span,WF) :-
4419 (var(EqRes3) -> % it can be that EqRes3 is about to be triggered
4420 equality_objects_wf(Y3,Y,EqResY3,WF),
4421 ? prop_apply_eqxy(EqResY3,EqRes3) % propagate: if Y/=Y3 => X/=X3
4422 ; EqResY3=not_called),
4423 ? apply_to4(EqRes3,EqResY3,Y3, T3,X,Y,InitialRel,Span,WF).
4424
4425 opt_force_false(EqRes) :-
4426 (preference(find_abort_values,false) -> EqRes=pred_false
4427 ; true). % TO DO: if EqRes becomes pred_true: raise abort_error as the relation was not a function
4428
4429
4430
4431 /********************************************/
4432 /* surjection_relation(R,Domain,Range) */
4433 /* R : Domain <->> Range */
4434 /********************************************/
4435 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:surjection_relation_wf([(int(1),int(6)),(int(2),int(7)),(int(1),int(7))],[int(1),int(2)],[int(7),int(6)],WF),WF)). % used to be wfdet (see in_domain_wf above)
4436 :- assert_must_succeed(exhaustive_kernel_fail_check_wfdet(kernel_relations:surjection_relation_wf([(int(1),int(6)),(int(2),int(6))],[int(1),int(2)],[int(6),int(7)],WF),WF)).
4437
4438 surjection_relation_wf(R,Domain,Range,WF) :-
4439 is_surjective(R,Range,WF),
4440 % TODO: is not optimal since ran(R)<:Range is already implied by is_surjective and
4441 % checked a second time by relation_over_wf/4
4442 ? relation_over_wf(R,Domain,Range,WF).
4443
4444 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_surjection_relation_wf([(int(1),int(6)),(int(2),int(6))],[int(1),int(2)],[int(6),int(7)],WF),WF)).
4445
4446 not_surjection_relation_wf(R,Domain,Range,WF) :-
4447 expand_custom_set_to_list_wf(R,ER,Done,not_surjection_relation_wf,WF),
4448 not_tot_surj_rel(ER,Done,[],Domain,Range,Range,WF).
4449
4450 /*********************************************/
4451 /* total_surjection_relation(R,Domain,Range) */
4452 /* R : Domain <<->> Range */
4453 /*********************************************/
4454 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:total_surjection_relation_wf([(int(1),int(6)),(int(2),int(7)),(int(1),int(7))],[int(1),int(2)],[int(7),int(6)],WF),WF)).
4455 :- assert_must_succeed(exhaustive_kernel_fail_check_wfdet(kernel_relations:total_surjection_relation_wf([(int(1),int(6)),(int(1),int(7))],[int(1),int(2)],[int(7),int(6)],WF),WF)).
4456 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:total_surjection_relation_wf([(term(floating(1.0)),string(six)),(term(floating(2.0)),string(seven)),(term(floating(1.0)),string(seven))],[term(floating(1.0)),term(floating(2.0))],[string(seven),string(six)],WF),WF)).
4457
4458
4459 :- assert_must_succeed((findall(R,kernel_relations:total_surjection_relation(R,[int(1)],[int(11),int(12)]),L),
4460 lists:maplist(sort,L,SL), sort(SL,SSL), % added May15th due to change in domain_wf (kernel_relations:propagate_result_to_input); TO DO: see if we can go back to just one solution
4461 length(SSL,1))).
4462 %:- assert_must_succeed((findall(R,kernel_relations:total_surjection_relation(R,[int(1),int(2)],[int(11),int(12)]),L), length(L,7))).
4463 % the new domain predicate also instantiates from result; meaning that duplicate solutions are now generated
4464 :- assert_must_succeed((findall(SR,(kernel_relations:total_surjection_relation(R,[int(1),int(2)],[int(11),int(12)]),sort(R,SR)),L), sort(L,SL),length(SL,7))).
4465 :- assert_must_succeed((findall(R,kernel_relations:total_surjection_relation(R,[int(1),int(2)],[int(11)]),L),
4466 length(L,1))).
4467
4468 total_surjection_relation(R,Domain,Range) :- init_wait_flags(WF,[total_surjection_relation]),
4469 total_surjection_relation_wf(R,Domain,Range,WF), ground_wait_flags(WF).
4470
4471 total_surjection_relation_wf(R,Domain,Range,WF) :-
4472 relation_over_wf(R,Domain,Range,WF),
4473 check_relation_is_total(R,Domain,WF), % calls domain which now instantiates R if Domain known
4474 check_relation_is_surjective(R,Range,WF).
4475
4476
4477 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_total_surjection_relation_wf([(int(1),int(6)),(int(1),int(7))],[int(1),int(2)],[int(7),int(6)],WF),WF)).
4478 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_total_surjection_relation_wf([(int(1),int(6)),(int(2),int(6))],[int(1),int(2)],[int(7),int(6)],WF),WF)).
4479 :- assert_must_succeed(exhaustive_kernel_fail_check_wfdet(kernel_relations:not_total_surjection_relation_wf([(int(1),int(6)),(int(2),int(7))],[int(1),int(2)],[int(7),int(6)],WF),WF)).
4480 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_total_surjection_relation_wf([(term(floating(1.0)),string(six)),(term(floating(2.0)),string(seven)),(term(floating(1.0)),string(seven))],[term(floating(1.0)),term(floating(2.0001))],[string(seven),string(six)],WF),WF)).
4481
4482 not_total_surjection_relation_wf(R,Domain,Range,WF) :-
4483 expand_custom_set_to_list_wf(R,ER,Done,not_total_surjection_relation_wf,WF),
4484 not_tot_surj_rel(ER,Done,Domain,Domain,Range,Range,WF).
4485
4486
4487 /********************************************/
4488 /* partial_surjection(R,DomType,RangeType) */
4489 /* R : DomType +->> RangeType */
4490 /********************************************/
4491
4492 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:partial_surjection_wf([(int(1),int(6)),(int(2),int(7))],[int(1),int(2)],[int(7),int(6)],WF),WF)). % used to be wfdet (see in_domain_wf above)
4493 :- assert_must_succeed(exhaustive_kernel_fail_check_wfdet(kernel_relations:partial_surjection_wf([(int(1),int(6)),(int(2),int(7))],[int(1),int(2)],[int(7),int(6),int(2)],WF),WF)).
4494 :- assert_must_succeed((kernel_relations:partial_surjection(X,[int(1),int(2)],[int(7),int(6)]),
4495 kernel_objects:equal_object(X,[(int(2),int(7)),(int(1),int(6))]))).
4496 :- assert_must_succeed((kernel_relations:partial_surjection(X,[int(1),int(2),int(3)],global_set('Name')),
4497 kernel_objects:equal_object(X,[(int(2),fd(1,'Name')),(int(1),fd(2,'Name')),(int(3),fd(3,'Name'))]))).
4498 :- assert_must_succeed((kernel_relations:partial_surjection_wf(X,[int(1),int(2),int(3)],global_set('Name'),_WF),
4499 kernel_objects:equal_object(X,[(int(2),fd(1,'Name')),(int(1),fd(2,'Name')),(int(3),fd(3,'Name'))]))).
4500 :- assert_must_succeed((kernel_relations:partial_surjection(X,[int(1),int(2),int(3)],[int(7),int(6)]),
4501 kernel_objects:equal_object(X,[(int(2),int(7)),(int(1),int(6))]))).
4502 :- assert_must_succeed_multiple((kernel_relations:partial_surjection(X,[int(1),int(2),int(3),int(4)],[int(7),int(6)]),
4503 kernel_objects:equal_object(X,[(int(2),int(7)),(int(1),int(6)),(int(3),int(6))]))). /* mult. */
4504 :- assert_must_succeed((X=[(int(2),int(7)),(int(1),int(6)),(int(3),int(6))],
4505 kernel_relations:partial_surjection(X,[int(1),int(2),int(3),int(4)],[int(7),int(6)]))).
4506 :- assert_must_fail((kernel_relations:partial_surjection(X,[int(1),int(2)],[int(7),int(6)]),
4507 X = [(int(2),int(7)),(int(1),int(6)),(int(1),int(7))])).
4508 :- assert_must_fail((kernel_relations:partial_surjection(X,[int(1),int(2)],[int(7),int(6)]),
4509 X = [(int(2),int(7)),(int(1),int(7))])).
4510 :- assert_must_fail((kernel_relations:partial_surjection(X,[int(1),int(2),int(3)],[int(7),int(6)]),
4511 X = [(int(2),int(7)),(int(1),int(6)),(int(3),int(8))])).
4512 :- assert_must_succeed_multiple((kernel_relations:partial_surjection(_X,
4513 [int(1),int(2),int(3),int(4),int(5),int(6),int(7)],[int(2),int(3),int(4)]) )).
4514 :- assert_must_fail((kernel_relations:partial_surjection(X,[int(1),int(2)],[int(7),int(6)]),
4515 X = [(int(2),int(7)),(int(2),int(6))])).
4516
4517 partial_surjection(R,Domain,Range) :- init_wait_flags(WF,[partial_surjection]),
4518 partial_surjection_wf(R,Domain,Range,WF),
4519 ground_wait_flags(WF).
4520
4521 :- block partial_surjection_wf(-,-,?,?).
4522 partial_surjection_wf(R,Domain,Range,WF) :-
4523 check_card_greater_equal(Domain,geq,Range,CardDom,CardRange),
4524 (surjection_has_to_be_total_injection(CardDom,CardRange)
4525 % LAW: card(setX) = card(setY) => ff: setX +->> setY <=> ff: setX >-> setY
4526 ? -> total_function_wf(R,Domain,Range,WF),
4527 injective(R,WF)
4528 ? ; is_surjective(R,Range,WF),
4529 ? partial_function_wf(R,Domain,Range,WF)
4530 ).
4531
4532
4533 % check_card_greater_equal(A,B) : quick check that card(A) >= card(B); also works with infinite cardinality
4534 % TO DO: replace by a better constraint propagating predicate (also working for partially instantiated lists,...)
4535 % compared with computing card and setting up < constraint: will only compute card if it can be done efficiently + deals with inf
4536 % check_card_greater_equal(SetA,EQ,SetB) ; EQ=eq or geq
4537 :- block check_card_greater_equal(-,?,?,?,?).
4538 check_card_greater_equal([],_,R,0,0) :- !, empty_set(R).
4539 check_card_greater_equal(A,EQ,B,CA,CB) :- check_card_greater_equal2(A,EQ,B,CA,CB).
4540
4541 :- use_module(inf_arith,[block_inf_greater_equal/2]).
4542 :- block check_card_greater_equal2(?,?,-,?,?).
4543 check_card_greater_equal2(A,EQ,B,CardA,CardB) :-
4544 efficient_card_for_set(A,CardA,CodeA),
4545 efficient_card_for_set(B,CardB,CodeB),!,
4546 call(CodeA), call(CodeB),
4547 (EQ=eq -> CardA=CardB ; block_inf_greater_equal(CardA,CardB)).
4548 check_card_greater_equal2(_A,_,_B,'?','?').
4549
4550
4551 :- block is_surjective(-,-,?).
4552 is_surjective(R,Range,WF) :-
4553 ? (var(R) -> setup_surj_range(Range,R,WF)
4554 ; range_wf(R,Range,WF)).
4555
4556 setup_surj_range(Range,R,WF) :-
4557 setup_range(Range,Res,DONE,WF),
4558 ? equal_when_done(Res,R,DONE).
4559 :- block equal_when_done(?,?,-).
4560 ?equal_when_done(Res,R,_DONE) :- equal_object(Res,R).
4561
4562
4563 :- block setup_range(-,?,?,?).
4564 setup_range(global_set(G),Res,DONE,WF) :-
4565 expand_custom_set_wf(global_set(G),ES,setup_range,WF),
4566 setup_range(ES,Res,DONE,WF).
4567 setup_range(freetype(ID),Res,DONE,WF) :-
4568 expand_custom_set_wf(freetype(ID),ES,setup_range,WF), setup_range(ES,Res,DONE,WF).
4569 setup_range(avl_set(S),Res,DONE,WF) :-
4570 expand_custom_set_wf(avl_set(S),ES,setup_range,WF), setup_range(ES,Res,DONE,WF).
4571 setup_range(closure(P,T,B),Res,DONE,WF) :-
4572 expand_custom_set_wf(closure(P,T,B),ES,setup_range,WF), setup_range(ES,Res,DONE,WF).
4573 setup_range([],_,done,_WF).
4574 setup_range([H|T],[(_,H)|ST],DONE,WF) :- setup_range(T,ST,DONE,WF).
4575
4576
4577
4578 :- assert_must_succeed(exhaustive_kernel_fail_check_wf(kernel_relations:not_partial_surjection_wf([(int(1),int(6)),(int(2),int(7))],
4579 [int(1),int(2)],[int(7),int(6)],WF),WF)).
4580 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:not_partial_surjection_wf([(int(1),int(6)),(int(2),int(7))],[int(1),int(2)],
4581 [int(7),int(6),int(2)],WF),WF)).
4582 :- assert_must_fail((kernel_relations:not_partial_surjection(X,[int(1),int(2)],[int(7),int(6)]),
4583 X = [(int(2),int(7)),(int(1),int(6))])).
4584 :- assert_must_succeed((kernel_relations:not_partial_surjection(X,[int(1),int(2)],[int(7),int(6)]),
4585 X = [(int(2),int(7)),(int(2),int(6))])).
4586 :- assert_must_fail((kernel_relations:not_partial_surjection(X,[int(1),int(2),int(3)],[int(7),int(6)]),
4587 X = [(int(2),int(7)),(int(1),int(6))])).
4588 :- assert_must_succeed((kernel_relations:not_partial_surjection(X,[int(1),int(2)],[int(7),int(6)]),
4589 X = [(int(2),int(7)),(int(1),int(6)),(int(1),int(7))])).
4590 :- assert_must_succeed((kernel_relations:not_partial_surjection(X,[int(1),int(2)],[int(7),int(6)]),
4591 X = [(int(2),int(7)),(int(1),int(7))])).
4592 :- assert_must_succeed((kernel_relations:not_partial_surjection(X,[int(1),int(2),int(3)],[int(7),int(6)]),
4593 X = [(int(2),int(7)),(int(1),int(6)),(int(3),int(8))])).
4594
4595
4596
4597 /* /: Domain +->> Range */
4598 not_partial_surjection(R,Domain,Range) :- init_wait_flags(WF,[not_partial_surjection]),
4599 not_partial_surjection_wf(R,Domain,Range,WF),
4600 ground_wait_flags(WF).
4601
4602 :- block not_partial_surjection_wf(-,?,?,?).
4603 not_partial_surjection_wf(R,DomType,RangeType,WF) :-
4604 ? partial_surjection_test_wf(R,DomType,RangeType,pred_false,WF).
4605
4606
4607 %not_surjective_relation_wf(R,DomType,RType,WF) :-
4608 % invert_relation_wf(R,IR,WF),
4609 % not_total_relation_wf(IR,RType,DomType,WF).
4610
4611
4612 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:partial_surjection_test_wf([(int(1),int(6)),(int(2),int(7))],[int(1),int(2)],[int(7),int(6)],pred_true,WF),WF)).
4613 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:partial_surjection_test_wf([(int(1),int(6)),(int(2),int(7))],[int(1),int(2)],[int(7),int(6),int(2)],pred_false,WF),WF)).
4614
4615 partial_surjection_test_wf(R,DomType,RangeType,PredRes,WF) :-
4616 partial_function_test_wf(R,DomType,RangeType,IsPF,WF),
4617 (IsPF==pred_false -> PredRes=pred_false
4618 ; range_wf(R,RelRan,WF),
4619 ? conjoin_test(IsPF,IsSurjective,PredRes,WF),
4620 subset_test(RangeType,RelRan,IsSurjective,WF)
4621 ).
4622
4623
4624 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:total_relation_wf([(int(1),int(6)),(int(2),int(7)),(int(1),int(7))],[int(1),int(2)],[int(7),int(6)],WF),WF)).
4625 :- assert_must_succeed(exhaustive_kernel_fail_check_wfdet(kernel_relations:total_relation_wf([(int(1),int(6)),(int(1),int(7))],[int(1),int(2)],[int(7),int(6)],WF),WF)).
4626 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:total_relation_wf([(term(floating(1.0)),string(six)),(term(floating(2.0)),string(seven)),(term(floating(1.0)),string(seven))],[term(floating(1.0)),term(floating(2.0))],[string(seven),string(six)],WF),WF)).
4627
4628 :- assert_must_succeed((kernel_relations:total_relation_wf(X,[int(1),int(2)],[int(7),int(6)],_WF),
4629 kernel_objects:equal_object(X,[(int(2),int(7)),(int(1),int(6))]))).
4630 :- assert_must_succeed((kernel_relations:total_relation_wf(X,[int(1),int(2)],[int(7),int(6)],_WF),
4631 kernel_objects:equal_object(X,[(int(2),int(7)),(int(1),int(7))]))).
4632 :- assert_must_succeed((kernel_relations:total_relation_wf(X,[int(1),int(2)],[int(7),int(6)],_WF),
4633 kernel_objects:equal_object(X,[(int(2),int(7)),(int(1),int(6)),(int(1),int(7))]))).
4634 :- assert_must_fail((kernel_relations:total_relation_wf(X,[int(1),int(2)],[int(7),int(6)],_WF),
4635 kernel_objects:equal_object(X,[(int(2),int(7)),(int(2),int(6))]))).
4636 :- assert_must_fail((kernel_relations:total_relation_wf(X,[int(1),int(2)],[int(7),int(6)],_WF),
4637 kernel_objects:equal_object(X,[(int(2),int(7))]))).
4638 :- assert_must_fail((kernel_relations:total_relation_wf(X,[int(1),int(2)],[int(7),int(6)],_WF),
4639 kernel_objects:equal_object(X,[(int(2),int(7)),(int(1),int(6)),(int(1),int(8))]))).
4640 :- assert_must_fail((kernel_relations:total_relation_wf(X,[int(1),int(2)],[int(7),int(6)],_WF),
4641 kernel_objects:equal_object(X,[(int(2),int(7)),(int(3),int(6)),(int(1),int(7))]))).
4642 :- assert_must_fail((kernel_relations:total_relation_wf(X,[int(1),int(2)],[int(7),int(6)],_WF),
4643 kernel_objects:equal_object(X,[]))).
4644
4645 /****************************************/
4646 /* total_relation_wf(R,Domain,Range,WF) */
4647 /* R : Domain <<-> Range */
4648 /****************************************/
4649
4650 total_relation_wf(R,Domain,Range,WF) :- relation_over_wf(R,Domain,Range,WF),
4651 check_relation_is_total(R,Domain,WF).
4652
4653 % this predicates assume that the relation's range and domain have already been checked
4654 check_relation_is_total(Relation,Domain,WF) :- domain_wf(Relation,Domain,WF).
4655 check_relation_is_surjective(Relation,Range,WF) :-
4656 range_wf(Relation,Range,WF). % we could also call is_surjective (which does setup_surj_range) ?
4657
4658 :- assert_must_succeed(exhaustive_kernel_fail_check_wfdet(kernel_relations:not_total_relation_wf([(int(1),int(6)),(int(2),int(7)),(int(1),int(7))],[int(1),int(2)],[int(7),int(6)],WF),WF)).
4659 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_total_relation_wf([(int(1),int(6)),(int(1),int(7))],[int(1),int(2)],[int(7),int(6)],WF),WF)).
4660 :- assert_must_fail((kernel_relations:not_total_relation_wf(X,[int(1),int(2)],[int(7),int(6)],_WF),
4661 X = [(int(2),int(7)),(int(1),int(6))])).
4662 :- assert_must_fail((kernel_relations:not_total_relation_wf(X,[int(1),int(2)],[int(7),int(6)],_WF),
4663 X = [(int(2),int(7)),(int(1),int(7))])).
4664 :- assert_must_fail((kernel_relations:not_total_relation_wf(X,[int(1),int(2)],[int(7),int(6)],_WF),
4665 X = [(int(2),int(7)),(int(1),int(6)),(int(1),int(7))])).
4666 :- assert_must_succeed((kernel_relations:not_total_relation_wf(X,[int(1),int(2)],[int(7),int(6)],_WF),
4667 X = [(int(2),int(7)),(int(2),int(6))])).
4668 :- assert_must_succeed((kernel_relations:not_total_relation_wf(X,[int(1),int(2)],[int(7),int(6)],_WF),
4669 X = [(int(2),int(7))])).
4670 :- assert_must_succeed((kernel_relations:not_total_relation_wf(X,[int(1),int(2)],[int(7),int(6)],_WF),
4671 X = [(int(2),int(7)),(int(1),int(6)),(int(1),int(8))])).
4672 :- assert_must_succeed((kernel_relations:not_total_relation_wf(X,[int(1),int(2)],[int(7),int(6)],_WF),
4673 X = [(int(2),int(7)),(int(3),int(6)),(int(1),int(7))])).
4674
4675 :- block not_total_relation_wf(-,?,?,?).
4676 not_total_relation_wf(FF,Domain,Range,WF) :- nonvar(FF),custom_explicit_sets:is_definitely_maximal_set(Range),
4677 % we do not need the Range; this means we can match more closures (e.g., lambda)
4678 custom_explicit_sets:dom_for_specific_closure(FF,FFDomain,function(_),WF),!,
4679 not_equal_object_wf(FFDomain,Domain,WF).
4680 not_total_relation_wf(FF,Domain,Range,WF) :- nonvar(FF),
4681 custom_explicit_sets:dom_range_for_specific_closure(FF,FFDomain,FFRange,function(_),WF),!,
4682 equality_objects_wf(FFDomain,Domain,Result,WF), % not yet implemented ! % TODO ! -> sub_set,equal,super_set
4683 when(nonvar(Result),(Result=pred_false -> true ; not_subset_of_wf(FFRange,Range,WF))).
4684 not_total_relation_wf(R,Domain,Range,WF) :-
4685 expand_custom_set_to_list_wf(R,ER,Done,not_total_relation_wf,WF),
4686 not_tot_surj_rel(ER,Done,Domain,Domain,[],Range,WF). % empty DelRange means we don't do surjective test
4687
4688 % can be used to check not total, not surj, not total surj relation
4689 :- block not_tot_surj_rel(-,?,?,?,?,?,?).
4690 not_tot_surj_rel([],_,DelDomain,_,DelRange,_,WF) :-
4691 at_least_one_set_not_empty(DelDomain,DelRange,WF).
4692 not_tot_surj_rel([_|_],Done,DelDom,Dom,_DelRan,_Ran,_WF) :- nonvar(Done),
4693 Done \= no_check_to_be_done,
4694 nonvar(DelDom),DelDom \= [],
4695 nonvar(Dom),is_infinite_explicit_set(Dom),
4696 !. % a finite expanded list can never be a total relation over an infinite domain
4697 not_tot_surj_rel([(X,Y)|T],_Done,DelDom,Dom,DelRan,Ran,WF) :-
4698 membership_test_wf(Dom,X,MemRes,WF),
4699 not_tr2(MemRes,X,Y,T,DelDom,Dom,DelRan,Ran,WF).
4700
4701 % check if one of the two sets is non-empty
4702 at_least_one_set_not_empty(Set1,Set2,_) :- (Set=Set1 ; Set=Set2),
4703 nonvar(Set),
4704 (Set=avl_set(_) ; Set=[_|_]), % we can avoid leaving choice point
4705 !.
4706 at_least_one_set_not_empty(Set1,_,WF) :- not_empty_set_wf(Set1,WF).
4707 at_least_one_set_not_empty(Set1,Set2,WF) :- empty_set_wf(Set1,WF),not_empty_set_wf(Set2,WF).
4708
4709 :- block not_tr2(-,?,?,?,?,?,?,?,?).
4710 not_tr2(pred_false,_X,_Y,_T,_DelDom,_Dom,_DelRan,_Ran,_WF).
4711 not_tr2(pred_true,X,Y,T,DelDom,Dom,DelRan,Ran,WF) :-
4712 delete_element_wf(X,DelDom,DelDom2,WF), % set DelDom initially to [] to avoid totality check
4713 membership_test_wf(Ran,Y,MemRes,WF),
4714 not_tr3(MemRes,Y,T,DelDom2,Dom,DelRan,Ran,WF).
4715
4716 :- block not_tr3(-,?,?,?,?,?,?,?).
4717 not_tr3(pred_false,_Y,_T,_DelDom2,_Dom,_DelRan,_Ran,_WF).
4718 not_tr3(pred_true,Y,T,DelDom2,Dom,DelRan,Ran,WF) :-
4719 delete_element_wf(Y,DelRan,DelRan2,WF), % set DelRan initially to [] to avoid surjection check
4720 not_tot_surj_rel(T,no_check_to_be_done,DelDom2,Dom,DelRan2,Ran,WF).
4721
4722 /******************************************/
4723 /* total_surjection(R,DomType,RangeType) */
4724 /* R : DomType -->> RangeType */
4725 /******************************************/
4726
4727 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:total_surjection_wf([(int(2),int(6)),(int(1),int(7))],[int(1),int(2)],[int(7),int(6)],WF),WF)). % used to be wfdet (see in_domain_wf above)
4728 :- assert_must_succeed(exhaustive_kernel_succeed_check((kernel_relations:total_surjection_wf([(int(2),int(6)),(int(1),int(7)),(int(3),int(7))],[int(1),int(2),int(3)],[int(7),int(6)],WF),kernel_waitflags:ground_det_wait_flag(WF)))). %% TO DO: get rid of multiple solutions
4729 :- assert_must_succeed((kernel_relations:total_surjection(X,[int(1)],[int(7)]),
4730 kernel_objects:equal_object(X,[(int(1),int(7))]))).
4731 :- assert_must_succeed((kernel_relations:total_surjection(X,[int(1),int(2)],[int(7),int(6)]),
4732 kernel_objects:equal_object(X,[(int(2),int(7)),(int(1),int(6))]))).
4733 :- assert_must_succeed((kernel_relations:total_surjection(X,[int(1),int(2)],[int(7)]),
4734 kernel_objects:equal_object(X,[(int(2),int(7)),(int(1),int(7))]))).
4735 :- assert_must_fail((kernel_relations:total_surjection([],[int(1)],[int(7)]))).
4736 :- assert_must_fail((kernel_relations:total_surjection([(int(7),int(7))],[int(1)],[int(7)]))).
4737 :- assert_must_fail((kernel_relations:total_surjection([(int(1),int(7)), (int(2),int(1))],
4738 [int(1),int(2)],[int(7)]))).
4739 :- assert_must_fail((kernel_relations:total_surjection(X,[int(1),int(2)],[int(7),int(6)]),
4740 kernel_objects:equal_object(X,[(int(2),int(7)),(int(2),int(6))]))).
4741
4742
4743 total_surjection(R,Domain,Range) :- init_wait_flags(WF),
4744 total_surjection_wf(R,Domain,Range,WF),
4745 ground_wait_flags(WF).
4746
4747 :- block total_surjection_wf(-,-,?,?).
4748 total_surjection_wf(R,DomType,RangeType,WF) :-
4749 check_card_greater_equal(DomType,geq,RangeType,CardDom,CardRange),
4750 ? total_function_wf(R,DomType,RangeType,WF),
4751 % setup_surj_range(RangeType,R,WF).
4752 (surjection_has_to_be_total_injection(CardDom,CardRange)
4753 % LAW: card(setX) = card(setY) => ff: setX -->> setY <=> ff: setX >-> setY
4754 -> injective(R,WF) % if domain and range have same cardinality: injection ensures surjectivity, and is more efficient to check/propagate; example when using queens 1..n -->> 1..n for NQueens
4755 ; check_relation_is_surjective(R,RangeType,WF)).
4756 % invert_relation_wf(R,IR,WF), total_relation_wf(IR,RangeType,DomType,WF).
4757
4758 surjection_has_to_be_total_injection(CardDom,CardRange) :- number(CardDom), CardDom=CardRange.
4759 % TO DO: determine the difference in size between Dom and Range and count how many times a range element can occur multiple times (would give better incremental checking)
4760
4761 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_total_surjection_wf([(int(2),int(6)),(int(1),int(7))],[int(1),int(2),int(3)],[int(7),int(6)],WF),WF)).
4762 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_total_surjection_wf([(int(2),int(6)),(int(1),int(6))],[int(1),int(2)],[int(7),int(6)],WF),WF)).
4763 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_total_surjection_wf([(int(2),int(6)),(int(1),int(6)),(int(1),int(7))],[int(1),int(2)],[int(7),int(6)],WF),WF)).
4764 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_total_surjection_wf([(int(2),int(6)),(int(1),int(7)),(int(3),int(7))],[int(1),int(2)],[int(7),int(6)],WF),WF)).
4765 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_total_surjection_wf([(int(2),int(6)),(int(1),int(7)),(int(3),int(8))],[int(1),int(2),int(3)],[int(7),int(6)],WF),WF)).
4766 :- assert_must_succeed(exhaustive_kernel_fail_check_wfdet(kernel_relations:not_total_surjection_wf([(int(2),int(6)),(int(1),int(7))],[int(1),int(2)],[int(7),int(6)],WF),WF)).
4767
4768 :- block not_total_surjection_wf(-,?,?,?), not_total_surjection_wf(?,-,-,?).
4769 not_total_surjection_wf(R,DomType,RangeType,WF) :-
4770 total_function_test_wf(R,DomType,RangeType,PredRes,WF),
4771 not_total_surjection2(PredRes,R,DomType,RangeType,WF).
4772 :- block not_total_surjection2(-,?,?,?,?).
4773 not_total_surjection2(pred_false,_R,_DomType,_RangeType,_WF).
4774 not_total_surjection2(pred_true,R,_DomType,RangeType,WF) :-
4775 range_wf(R,RelRange,WF),
4776 opt_push_wait_flag_call_stack_info(WF,b_operator_call(not_subset,
4777 [RangeType,b_operator(range,[R])],unknown),WF2),
4778 not_subset_of_wf(RangeType,RelRange,WF2).
4779 %not_surjective_relation_wf(R,DomType,RangeType,WF).
4780
4781 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:total_function_test_wf([(int(2),int(6)),(int(1),int(7)),(int(3),int(8))],[int(1),int(2),int(3)],[int(7),int(6)],pred_false,WF),WF)).
4782 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:total_function_test_wf([(int(2),int(6)),(int(1),int(7)),(int(3),int(6))],[int(1),int(2),int(3)],[int(7),int(6)],pred_true,WF),WF)). % used to be wfdet (see in_domain_wf above)
4783 :- assert_must_succeed(exhaustive_kernel_fail_check_wfdet(kernel_relations:total_function_test_wf([(int(2),int(6)),(int(1),int(7))],[int(1),int(2)],[int(7),int(6)],pred_false,WF),WF)).
4784
4785 % reified total function check:
4786 total_function_test_wf(R,DomType,RangeType,PredRes,WF) :-
4787 partial_function_test_wf(R,DomType,RangeType,IsPF,WF),
4788 (IsPF==pred_false -> PredRes=pred_false
4789 ; domain_wf(R,RelDom,WF),
4790 conjoin_test(IsPF,IsTotal,PredRes,WF),
4791 opt_push_wait_flag_call_stack_info(WF,b_operator_call(subset,
4792 [DomType,b_operator(domain,[R])],unknown),WF2),
4793 subset_test(DomType,RelDom,IsTotal,WF2)
4794 ).
4795
4796 /*******************************************/
4797 /* partial_injection(R,DomType,RangeType) */
4798 /* R : DomType >+> RangeType */
4799 /*******************************************/
4800
4801 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:partial_injection_wf([(int(1),int(6)),(int(2),int(7))],[int(1),int(2)],[int(7),int(6)],WF),WF)).
4802 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:partial_injection_wf([(int(1),int(6)),(int(4),int(7)),(int(2),int(8))],[int(1),int(2),int(3),int(4)],[int(7),int(6),int(8),int(9)],WF),WF)).
4803 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:partial_injection_wf([(int(2),int(7))],[int(1),int(2)],[int(7),int(6)],WF),WF)).
4804 :- assert_must_succeed((kernel_relations:partial_injection(X,[int(1)],[int(7)]),
4805 kernel_objects:equal_object(X,[(int(1),int(7))]))).
4806 :- assert_must_succeed((kernel_relations:partial_injection(X,[int(1),int(2)],[int(7),int(6)]),
4807 kernel_objects:equal_object(X,[(int(2),int(7)),(int(1),int(6))]))).
4808 :- assert_must_fail((kernel_relations:partial_injection(X,[int(1),int(2)],[int(7)]),
4809 kernel_objects:equal_object(X,[(int(2),int(7)),(int(1),int(7))]))).
4810 :- assert_must_succeed((kernel_relations:partial_injection([],[int(1)],[int(7)]))).
4811 :- assert_must_fail((kernel_relations:partial_injection([(int(7),int(7))],[int(1)],[int(7)]))).
4812 :- assert_must_fail((kernel_relations:partial_injection([(int(1),int(7)), (int(2),int(1))],
4813 [int(1),int(2)],[int(7)]))).
4814 :- assert_must_fail((kernel_relations:partial_injection(X,[int(1),int(2)],[int(7),int(6)]),
4815 kernel_objects:equal_object(X,[(int(2),int(7)),(int(2),int(6))]))).
4816
4817
4818 partial_injection(R,Domain,Range) :- init_wait_flags(WF),
4819 partial_injection_wf(R,Domain,Range,WF),
4820 ground_wait_flags(WF).
4821
4822 :- block partial_injection_wf(-,-,?,?).
4823 partial_injection_wf(FF,Domain,Range,WF) :- nonvar(FF),
4824 custom_explicit_sets:dom_range_for_specific_closure(FF,FFDomain,FFRange,function(bijection),WF),!,
4825 check_domain_subset_for_closure_wf(FF,FFDomain,Domain,WF),
4826 check_range_subset_for_closure_wf(FF,FFRange,Range,WF).
4827 partial_injection_wf(R,DomType,RangeType,WF) :-
4828 try_expand_and_convert_to_avl_unless_large_wf(R,ER,WF), % should we use very_large?
4829 ? partial_function_wf(ER,DomType,RangeType,WF),
4830 injective(ER,WF).
4831 % invert_relation_wf(R,IR,WF),
4832 % partial_function_wf(IR,RangeType,DomType,WF).
4833
4834 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:injective([(int(1),int(6)),(int(4),int(7)),(int(2),int(8))],WF),WF)).
4835 :- assert_must_succeed(exhaustive_kernel_fail_check_wfdet(kernel_relations:injective([(int(1),int(6)),(int(4),int(7)),(int(2),int(7))],WF),WF)).
4836
4837 :- block injective(-,?).
4838 injective(FF,WF) :-
4839 custom_explicit_sets:dom_range_for_specific_closure(FF,_FFDomain,_FFRange,function(bijection),WF),!.
4840 injective(avl_set(AVL),_WF) :- !,
4841 is_injective_avl_relation(AVL,_Range). % seems slightly faster than injective/3 code below
4842 injective(closure(P,T,B),WF) :- !,
4843 symbolic_injectivity_check(closure(P,T,B),WF).
4844 injective(Rel,WF) :- expand_custom_set_to_list_wf(Rel,ERel,_,injective,WF),
4845 injective(ERel,[],WF).
4846
4847 %:- use_module(library(lists),[maplist/3]).
4848 % for FD-sets we could setup all_different constraint
4849 :- block injective(-,?,?).
4850 injective([],_SoFar,_).
4851 % (maplist(get_fd_val,SoFar,FDL) -> clpfd:all_distinct(FDL) ; true). %clpfd_interface:clpfd_alldifferent(FDL) ; true).
4852 %get_fd_val(int(H),H).
4853 injective([(_From,To)|T],SoFar,WF) :-
4854 not_element_of_wf(To,SoFar,WF), /* check that it is injective */
4855 add_new_element_wf(To,SoFar,SoFar2,WF), %SoFar2=[To|SoFar], could also work and be faster ?
4856 injective(T,SoFar2,WF).
4857 % no case for global_set: it cannot be a relation; two cases below not required because of expand_custom_set_to_list
4858 %injective(avl_set(S),SoFar,WF) :- expand_custom_set_wf(avl_set(S),ES,inj,WF), injective(ES,SoFar,WF).
4859 %injective(closure(P,T,B),SoFar,WF) :- expand_custom_set_wf(closure(P,T,B),ES,inj,WF), injective(ES,SoFar,WF).
4860
4861
4862
4863 /* /: Dom >+> R */
4864
4865 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_partial_injection([(int(1),int(6)),(int(2),int(6))],[int(1),int(2)],[int(7),int(6)],WF),WF)).
4866 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_partial_injection([(int(1),int(6)),(int(1),int(7))],[int(1),int(2)],[int(7),int(6)],WF),WF)).
4867 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_partial_injection([(int(1),int(6)),(int(2),int(8))],[int(1),int(2)],[int(7),int(6)],WF),WF)).
4868 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_partial_injection([(int(1),int(6)),(int(3),int(7))],[int(1),int(2)],[int(7),int(6)],WF),WF)).
4869
4870 :- block not_partial_injection(-,?,?,?).
4871 not_partial_injection(R,DomType,RangeType,WF) :-
4872 partial_function_test_wf(R,DomType,RangeType,IsPF,WF),
4873 not_partial_injection2(IsPF,R,DomType,RangeType,WF).
4874
4875 :- block not_partial_injection2(-,?,?,?,?).
4876 not_partial_injection2(pred_false,_R,_DomType,_RType,_WF).
4877 not_partial_injection2(pred_true,R,DomType,RType,WF) :-
4878 not_injection_wf(R,DomType,RType,WF).
4879
4880 not_injection_wf(R,DomType,RType,WF) :-
4881 invert_relation_wf(R,IR,WF),
4882 not_partial_function(IR,RType,DomType,WF).
4883
4884 /*****************************************/
4885 /* total_injection(R,DomType,RangeType) */
4886 /* R : DomType >-> RangeType */
4887 /*****************************************/
4888
4889 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:total_injection_wf([(int(1),int(6)),(int(2),int(7))],[int(1),int(2)],[int(7),int(6)],WF),WF)).
4890 :- assert_must_succeed(exhaustive_kernel_fail_check_wfdet(kernel_relations:total_injection_wf([(int(1),int(6)),(int(2),int(6))],[int(1),int(2)],[int(7),int(6)],WF),WF)).
4891 :- assert_must_succeed(exhaustive_kernel_fail_check_wf(kernel_relations:not_total_injection([(int(1),int(6)),(int(2),int(7))],[int(1),int(2)],[int(7),int(6)],WF),WF)).
4892 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:not_total_injection([(int(1),int(6)),(int(2),int(6))],[int(1),int(2)],[int(7),int(6)],WF),WF)).
4893 :- assert_must_succeed((kernel_relations:total_injection(X,[int(1)],[int(7)]),
4894 kernel_objects:equal_object(X,[(int(1),int(7))]))).
4895 :- assert_must_succeed((kernel_relations:total_injection(X,[int(1),int(2)],[int(7),int(6)]),
4896 kernel_objects:equal_object(X,[(int(2),int(7)),(int(1),int(6))]))).
4897 :- assert_must_fail((kernel_relations:total_injection(X,[int(1),int(2)],[int(7)]),
4898 kernel_objects:equal_object(X,[(int(2),int(7)),(int(1),int(7))]))).
4899 :- assert_must_fail((kernel_relations:total_injection([],[int(1)],[int(7)]))).
4900 :- assert_must_fail((kernel_relations:total_injection([(int(7),int(7))],[int(1)],[int(7)]))).
4901 :- assert_must_fail((kernel_relations:total_injection([(int(1),int(7)), (int(2),int(1))],
4902 [int(1),int(2)],[int(7)]))).
4903 :- assert_must_fail((kernel_relations:total_injection(X,[int(1),int(2)],[int(7),int(6)]),
4904 kernel_objects:equal_object(X,[(int(2),int(7)),(int(2),int(6))]))).
4905
4906
4907 total_injection(R,Domain,Range) :- init_wait_flags(WF),
4908 total_injection_wf(R,Domain,Range,WF),
4909 ground_wait_flags(WF).
4910
4911 :- block total_injection_wf(-,-,?,?). % with just ?,-,?,? we may wait too long to start injective check
4912 % Note: no need to check: dom_range_for_specific_closure(FF,FFDomain,FFRange,function(bijection)),
4913 total_injection_wf(R,DomType,RangeType,WF) :-
4914 check_card_greater_equal(RangeType,geq,DomType,_,_), % there must be more Range elements than domain elements; pigeonhole principle
4915 ? total_injection_wf2(R,DomType,RangeType,WF).
4916 total_injection_wf2(R,DomType,RangeType,WF) :-
4917 try_expand_and_convert_to_avl_unless_large_wf(R,ER,WF),
4918 ? total_function_wf(ER,DomType,RangeType,WF),
4919 injective(ER,WF).
4920
4921
4922 :- block not_total_injection(-,?,?,?), not_total_injection(?,-,-,?).
4923 not_total_injection(R,DomType,RangeType,WF) :-
4924 total_function_test_wf(R,DomType,RangeType,PredRes,WF),
4925 not_total_injection2(PredRes,R,DomType,RangeType,WF).
4926
4927 :- block not_total_injection2(-,?,?,?,?).
4928 not_total_injection2(pred_false,_R,_Dom,_Ran,_WF).
4929 not_total_injection2(pred_true,R,DomType,RangeType,WF) :-
4930 % TO DO: replace DomType and RangeType by full Type
4931 not_injection_wf(R,DomType,RangeType,WF).
4932
4933 /***********************************/
4934 /* partial_bijection(R,DomType,RangeType) */
4935 /* R : DomType >+>> RangeType */
4936 /***********************************/
4937
4938 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:partial_bijection_wf([(int(1),int(6)),(int(2),int(7))],[int(1),int(2)],[int(7),int(6)],WF),WF)). % used to be wfdet (see in_domain_wf above)
4939 :- assert_must_succeed(exhaustive_kernel_fail_check_wfdet(kernel_relations:partial_bijection_wf([(int(1),int(6)),(int(2),int(6))],[int(1),int(2)],[int(7),int(6)],WF),WF)).
4940 :- assert_must_succeed((partial_bijection(X,[int(1),int(2)],[int(7),int(6)]),
4941 kernel_objects:equal_object(X,[(int(1),int(6)),(int(2),int(7))]))).
4942 :- assert_must_succeed((partial_bijection(X,[int(1),int(2),int(3),int(4)],[int(7),int(6)]),
4943 X = [(int(2),int(7)),(int(3),int(6))])).
4944 :- assert_must_fail((partial_bijection(X,[int(1),int(2)],[int(7),int(6),int(5)]),
4945 X = [(int(2),int(7)),(int(1),int(6))])).
4946
4947 partial_bijection(R,Domain,Range) :- init_wait_flags(WF),
4948 partial_bijection_wf(R,Domain,Range,WF),
4949 ground_wait_flags(WF).
4950
4951 partial_bijection_wf(R,DomType,RangeType,WF) :-
4952 ? partial_injection_wf(R,DomType,RangeType,WF),
4953 ? partial_surjection_wf(R,DomType,RangeType,WF).
4954
4955 :- assert_must_succeed(exhaustive_kernel_fail_check_wf(kernel_relations:not_partial_bijection([(int(1),int(6)),(int(2),int(7))],[int(1),int(2)],[int(7),int(6)],WF),WF)).
4956 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:not_partial_bijection([(int(1),int(6)),(int(2),int(6))],[int(1),int(2)],[int(7),int(6)],WF),WF)).
4957
4958 :- assert_must_succeed(exhaustive_kernel_fail_check_wf(kernel_relations:not_partial_bijection([(int(2),int(7)),(int(1),int(6))],[int(1),int(2)],[int(7),int(6)],WF),WF)).
4959
4960 :- assert_must_succeed(exhaustive_kernel_fail_check_wf(kernel_relations:not_partial_bijection([(int(2),int(7)),(int(3),int(6))],[int(1),int(2),int(3),int(4)],[int(7),int(6)],WF),WF)).
4961 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:not_partial_bijection([(int(2),int(7)),(int(1),int(6))],[int(1),int(2)],[int(7),int(6),int(5)],WF),WF)).
4962
4963
4964 :- block not_partial_bijection(-,?,?,?), not_partial_bijection(?,-,-,?).
4965 not_partial_bijection(R,DomType,RangeType,WF) :-
4966 % >+>> = +->> + injective
4967 partial_surjection_test_wf(R,DomType,RangeType,PredRes,WF),
4968 not_partial_bijection2(PredRes,R,DomType,RangeType,WF).
4969
4970 :- block not_partial_bijection2(-,?,?,?,?).
4971 not_partial_bijection2(pred_false,_R,_DomType,_RangeType,_WF).
4972 not_partial_bijection2(pred_true,R,DomType,RangeType,WF) :-
4973 not_injection_wf(R,DomType,RangeType,WF).
4974
4975
4976
4977 /* The transitive (not reflexive) closure of a relation (closure1) */
4978
4979 :- assert_must_succeed(exhaustive_kernel_check(kernel_relations:relational_trans_closure([(int(1),int(2)),(int(2),int(6))],[(int(1),int(2)),(int(1),int(6)),(int(2),int(6))]))).
4980 :- assert_must_succeed(exhaustive_kernel_check(kernel_relations:relational_trans_closure([(int(1),int(2)),(int(2),int(6)),(int(1),int(3))],[(int(1),int(2)),(int(1),int(3)),(int(1),int(6)),(int(2),int(6))]))).
4981 :- assert_must_succeed(exhaustive_kernel_check(kernel_relations:relational_trans_closure([(int(6),int(7)),(int(1),int(2)),(int(2),int(6)),(int(1),int(3))],[(int(1),int(2)),(int(1),int(3)),(int(1),int(6)),(int(2),int(6)),(int(1),int(7)),(int(2),int(7)),(int(6),int(7))]))).
4982 :- assert_must_succeed((kernel_relations:relational_trans_closure([(int(1),int(4))],X),
4983 kernel_objects:equal_object(X,[(int(1),int(4))]))).
4984 :- assert_must_succeed((kernel_relations:relational_trans_closure([(int(1),int(4)),(int(4),int(2))],X),
4985 kernel_objects:equal_object(X,[(int(1),int(4)),(int(4),int(2)),
4986 (int(1),int(2))]))).
4987 :- assert_must_succeed((kernel_relations:relational_trans_closure([(int(1),int(4)),(int(4),int(2)),(int(2),int(3))],X),
4988 kernel_objects:equal_object(X,[(int(1),int(4)),(int(4),int(2)),(int(2),int(3)),
4989 (int(4),int(3)),(int(1),int(2)),(int(1),int(3))]))).
4990 :- assert_must_succeed((kernel_relations:relational_trans_closure([(int(A),int(2)),(int(2),int(6))],
4991 [(int(1),int(2)),(int(1),int(6)),(int(2),int(6))]),A=1)).
4992
4993 relational_trans_closure(Rel,Res) :- relational_trans_closure_wf(Rel,Res,no_wf_available).
4994
4995 % transitive closure for relations (closure1)
4996 :- block relational_trans_closure_wf(-,?,?).
4997 relational_trans_closure_wf(Relation,Result,WF) :-
4998 try_expand_and_convert_to_avl_with_check(Relation,ARelation,relational_trans_closure_wf),
4999 ? relational_trans_closure2(ARelation,Result,WF).
5000 :- block relational_trans_closure2(-,?,?).
5001 relational_trans_closure2(ARelation,Result,WF) :-
5002 (closure1_for_explicit_set(ARelation,Res)
5003 -> kernel_objects:equal_object_wf(Res,Result,relational_trans_closure_wf,WF)
5004 ; expand_custom_set_to_list_wf(ARelation,ERelation,_,relational_trans_closure2,WF),
5005 is_full_relation(ERelation,WaitVar), % still required??
5006 % we could do a check_subset_of_wf(ERelation,Resul,WF) if Result is nonvar and ERelation not ground
5007 ? compute_trans_closure(ERelation,Result,WaitVar,WF)
5008 ).
5009
5010 :- block compute_trans_closure(?,?,-,?).
5011 compute_trans_closure(Relation,Result,_,WF) :-
5012 ? compute_trans_closure2(Relation,1,Result,WF).
5013
5014 compute_trans_closure2(Relation,Cnt,Result,WF) :-
5015 one_closure_iteration(Relation,Relation,Relation,Result1,Added,Done,WF),
5016 ? compute_trans_closure3(Relation,Cnt,Result1,Added,Done,Result,WF).
5017
5018 :- block compute_trans_closure3(?,?,?,?,-,?,?).
5019 compute_trans_closure3(Relation,Cnt,Result1,Added,_Done,Result,WF) :-
5020 ( equal_object_wf(Result1,Relation,relational_trans_closure_wf,WF), % should we do equality_objects here?
5021 ? equal_object_optimized_wf(Result,Result1,compute_trans_closure,WF)
5022 ;
5023 Added==possibly_added,
5024 not_equal_object_wf(Result1,Relation,WF), % not a fixpoint; continue
5025 IterCnt is Cnt+1,
5026 ? compute_trans_closure2(Result1,IterCnt,Result,WF)
5027 ).
5028
5029 :- block one_closure_iteration(?,?,-,?,?,?,?).
5030 one_closure_iteration([],_,IterRes,OutRel,Added,Done,WF) :-
5031 equal_object_wf(IterRes,OutRel,one_closure_iteration,WF),
5032 (var(Added) -> Added=not_added ; true),
5033 Done=done.
5034 one_closure_iteration([(X,Y)|T],ExpandedPreviousRel,PreviousRel,OutRel,Added,Done,WF) :-
5035 add_tuples(ExpandedPreviousRel,X,Y,PreviousRel,IntRel,Added,DoneTuples,WF),
5036 one_closure_iteration_block(DoneTuples,T,ExpandedPreviousRel,IntRel,OutRel,Added,Done,WF).
5037
5038 :- block one_closure_iteration_block(-,?,?,?,?,?,?,?).
5039 one_closure_iteration_block(_,T,ExpandedPreviousRel,IntRel,OutRel,Added,Done,WF) :-
5040 ? one_closure_iteration(T,ExpandedPreviousRel,IntRel,OutRel,Added,Done,WF).
5041
5042 add_tuples([],_,_,OutRel,OutRel,_Added,done,_).
5043 add_tuples([(X,Y)|T],OX,OY,InRel,OutRel,Added,Done,WF) :-
5044 % add tuple (X,OY) if we have Y=OX
5045 equality_objects_wf(Y,OX,EqRes,WF),
5046 add_tuples_aux(EqRes,X,T,OX,OY,InRel,OutRel,Added,Done,WF).
5047
5048 :- block add_tuples_aux(-,?,?,?,?,?,?,?,?,?).
5049 add_tuples_aux(pred_true,X,T,OX,OY,InRel,OutRel,possibly_added,Done,WF) :-
5050 add_element_wf((X,OY),InRel,IntRel,WF), % add transitive couple X -> OY
5051 ? add_tuples(T,OX,OY,IntRel,OutRel,_,Done,WF).
5052 add_tuples_aux(pred_false,_X,T,OX,OY,InRel,OutRel,Added,Done,WF) :- % no transitive couple needed
5053 ? add_tuples(T,OX,OY,InRel,OutRel,Added,Done,WF).
5054
5055
5056 :- assert_must_succeed((is_full_relation(X,R),var(R),X=[],R==true)).
5057 :- assert_must_succeed((is_full_relation(X,R),var(R),X=[(A,B)|T],var(R),A=int(1),var(R),B=A,var(R),T=[],R==true)).
5058 :- block is_full_relation(-,?).
5059 is_full_relation([],R) :- !,R=true.
5060 is_full_relation([H|T],W) :- !, is_full_relation_aux(H,T,W).
5061 is_full_relation(X,R) :-
5062 add_internal_error('Illegal Set for is_full_relation: ',is_full_relation(X,R)),fail.
5063
5064 :- block is_full_relation_aux(-,?,?).
5065 is_full_relation_aux((X,Y),T,W) :- !, is_full_relation_aux2(X,Y,T,W).
5066 is_full_relation_aux(X,T,W) :-
5067 add_internal_error('Illegal Set for is_full_relation: ',is_full_relation_aux(X,T,W)),fail.
5068 :- block is_full_relation_aux2(-,?,?,?), is_full_relation_aux2(?,-,?,?).
5069 ?is_full_relation_aux2(_X,_Y,T,W) :- is_full_relation(T,W).
5070
5071 /* ------------------ */
5072
5073 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:in_closure1_wf((int(1),int(3)),[(int(1),int(2)),(int(2),int(1)),(int(2),int(3))],WF),WF)). % used to be wfdet (see in_domain_wf above)
5074
5075 in_closure1_wf(Pair,Relation,WF) :- %Pair = (_A,B),
5076 %in_domain_wf_lazy(A,Relation,WF), % done below
5077 %check_element_of_wf((_,B),Relation,WF), % multiple solutions for _, see test 634, 637
5078 ? in_closure1_membership_test_wf(Pair,Relation,pred_true,WF).
5079
5080
5081 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:not_in_closure1_wf((int(1),int(3)),[(int(1),int(2)),(int(2),int(1)),(int(3),int(3))],WF),WF)).
5082
5083 not_in_closure1_wf(Pair,Relation,WF) :-
5084 ? in_closure1_membership_test_wf(Pair,Relation,pred_false,WF).
5085
5086 :- assert_must_succeed((kernel_relations:in_closure1_membership_test_wf((int(1),int(2)),[],Res,_WF),Res==pred_false)).
5087 :- assert_must_succeed((kernel_relations:in_closure1_membership_test_wf((int(1),int(2)),[(int(1),int(2))],Res,_WF),Res==pred_true)).
5088 :- assert_must_succeed((kernel_relations:in_closure1_membership_test_wf((int(1),int(2)),[(int(1),int(3))],Res,_WF),Res==pred_false)).
5089 :- assert_must_succeed((kernel_relations:in_closure1_membership_test_wf((int(1),int(2)),[(int(1),int(3)),(int(3),int(2))],Res,_WF),Res==pred_true)).
5090 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:in_closure1_membership_test_wf((int(1),int(2)),[(int(1),int(3)),(int(3),int(2))],pred_true,WF),WF)). % used to be wfdet (see in_domain_wf above)
5091 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:in_closure1_membership_test_wf((int(11),int(3)),[(int(11),int(3))],pred_true,WF),WF)).
5092 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:in_closure1_membership_test_wf((int(11),int(3)),[(int(11),int(33))],pred_false,WF),WF)).
5093 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:in_closure1_membership_test_wf((int(1),int(3)),[(int(11),int(3))],pred_false,WF),WF)).
5094 :- assert_must_succeed(exhaustive_kernel_check_wf(kernel_relations:in_closure1_membership_test_wf((int(11),int(22)),[(int(11),int(3)),(int(33),int(2)),(int(3),int(22)),(int(11),int(3))],pred_true,WF),WF)). % used to be wfdet (see in_domain_wf above)
5095 :- assert_must_succeed(exhaustive_kernel_check_wfdet(kernel_relations:in_closure1_membership_test_wf((int(11),int(11)),[(int(11),int(3))],pred_false,WF),WF)).
5096
5097 :- block force_in_domain(-,?,?,?).
5098 force_in_domain(pred_false,_A,_Relation,_WF).
5099 force_in_domain(pred_true,A,Relation,WF) :- % force A to be in domain, avoid enumeration warnings,...
5100 % maybe only for non-ground A
5101 ? in_domain_wf_lazy(A,Relation,WF). % slowdown Loop.mch (tests 634, 637) if we use in_domain_wf ?
5102
5103 % (x,y) : closure1(Rel)
5104 :- block in_closure1_membership_test_wf(?,-,?,?).
5105 in_closure1_membership_test_wf((A,B),CSRelation,MemRes,WF) :-
5106 is_custom_explicit_set(CSRelation,in_closure1),
5107 !,
5108 ? image_for_closure1_wf(CSRelation,[A],Image,WF),
5109 ? force_in_domain(MemRes,A,CSRelation,WF),
5110 ? membership_test_wf(Image,B,MemRes,WF).
5111 in_closure1_membership_test_wf((X,Y),Relation,MemRes,WF) :-
5112 expand_custom_set_to_list_wf(Relation,ERelation,_,in_closure1_membership_test_wf,WF),
5113 Discarded = [], % pairs discarded in current iteration
5114 force_in_domain(MemRes,X,Relation,WF),
5115 in_closure1_membership_test_wf2(ERelation,X,Y,Discarded,MemRes,WF).
5116
5117 :- block in_closure1_membership_test_wf2(-,?,?,?,?,?).
5118 in_closure1_membership_test_wf2([],_X,_Y,_,MemRes,_WF) :- MemRes=pred_false.
5119 in_closure1_membership_test_wf2([(V,W)|Rest],X,Y,Discarded,MemRes,WF) :- % TO DO: Rest==[] -->
5120 equality_objects_wf(V,X,VXResult,WF),
5121 in_closure1_membership_test_wf3(VXResult,V,W,Rest,X,Y,Discarded,MemRes,WF).
5122
5123 :- block in_closure1_membership_test_wf3(-,?,?,?,?,?,?,?,?).
5124 in_closure1_membership_test_wf3(pred_false,V,W,Rest,X,Y,Discarded,MemRes,WF) :-
5125 in_closure1_membership_test_wf2(Rest,X,Y,[(V,W)|Discarded],MemRes,WF).
5126 in_closure1_membership_test_wf3(pred_true,V,W,Rest,X,Y,Discarded,MemRes,WF) :- % V=X
5127 propagate_false(MemRes,WYResult),
5128 % TODO: Res=[],Discarded=[] -> MemRes=WYResult
5129 equality_objects_wf(W,Y,WYResult,WF), % MemRes = pred_false => WYResult = pred_false
5130 in_closure1_membership_test_wf4(WYResult,V,W,Rest,X,Y,Discarded,MemRes,WF).
5131
5132 :- block in_closure1_membership_test_wf4(-,?,?,?,?,?,?,?,?).
5133 in_closure1_membership_test_wf4(pred_false,_V,W,Rest,X,Y,Discarded,MemRes,WF) :-
5134 append(Discarded,Rest,Restart),
5135 in_closure1_membership_test_wf2(Restart,W,Y,[],MemRes1,WF),
5136 propagate_false(MemRes,MemRes1), % MemRes = pred_false -> MemRes1=pred_false
5137 when(nonvar(MemRes1),
5138 (MemRes1=pred_true -> MemRes=pred_true
5139 ; in_closure1_membership_test_wf2(Rest,X,Y,Discarded,MemRes,WF) % (V,W) not in Discarded: was not useful
5140 )).
5141 in_closure1_membership_test_wf4(pred_true,_V,_W,_Rest,_X,_Y,_Discarded,MemRes,_WF) :- % W=Y
5142 MemRes = pred_true.
5143 /* ------------------ */
5144
5145 :- block propagate_false(-,?).
5146 propagate_false(pred_false,pred_false).
5147 propagate_false(pred_true,_).
5148