Debian Codegraph @

src/plugins/wp/tests/wp_acsl/oracle/assigned_initialized_memvar.res.oracle

raw
1 # frama-c -wp [...]
2 [kernel] Parsing assigned_initialized_memvar.i (no preprocessing)
3 [wp] Running WP plugin...
4 [wp] Warning: Missing RTE guards
5 ------------------------------------------------------------
6 Function array
7 ------------------------------------------------------------
8
9 Goal Check 'FAILS' (file assigned_initialized_memvar.i, line 76):
10 Assume {
11 Have: 0 <= i.
12 Have: i <= 9.
13 Type: is_sint32(i_1) /\ is_sint32(i_2).
14 (* Invariant *)
15 Have: (0 <= i_1) /\ (i_1 <= 10) /\
16 (((0 < i_1) ->
17 (forall i_3 : Z. ((0 <= i_3) -> ((i_3 < i_1) -> (v_1[i_3]=true)))))).
18 (* Else *)
19 Have: 10 <= i_1.
20 (* Invariant *)
21 Have: (0 <= i_2) /\ (i_2 <= 10).
22 (* Else *)
23 Have: 10 <= i_2.
24 }
25 Prove: (v[i]=true).
26
27 ------------------------------------------------------------
28
29 Goal Loop assigns 'CHECK':
30 Prove: true.
31
32 ------------------------------------------------------------
33 ------------------------------------------------------------
34 Function comp
35 ------------------------------------------------------------
36
37 Goal Check 'FAILS' (file assigned_initialized_memvar.i, line 131):
38 Assume {
39 Type: is_sint32(i) /\ is_sint32(i_1).
40 (* Invariant *)
41 Have: (0 <= i) /\ (i <= 10) /\
42 (((0 < i) ->
43 (forall i_2 : Z. ((0 <= i_2) -> ((i_2 < i) -> (v[i_2]=true)))))).
44 (* Else *)
45 Have: 10 <= i.
46 (* Invariant *)
47 Have: (0 <= i_1) /\ (i_1 <= 10).
48 (* Else *)
49 Have: 10 <= i_1.
50 }
51 Prove: ((Init_s_0.Init_F1_S_i)=true) /\
52 (forall i_2 : Z. ((0 <= i_2) -> ((i_2 <= 9) ->
53 ((Init_s_0.Init_F1_S_a)[i_2]=true)))).
54
55 ------------------------------------------------------------
56
57 Goal Loop assigns 'CHECK':
58 Prove: true.
59
60 ------------------------------------------------------------
61 ------------------------------------------------------------
62 Function descr
63 ------------------------------------------------------------
64
65 Goal Preservation of Invariant 'CHECK' (file assigned_initialized_memvar.i, line 105):
66 Assume {
67 Type: is_sint32(i) /\ is_sint32(i_1).
68 (* Invariant *)
69 Have: (0 <= i) /\ (i <= 10) /\
70 (((0 < i) ->
71 (forall i_2 : Z. ((0 <= i_2) -> ((i_2 < i) -> (v[i_2]=true)))))).
72 (* Else *)
73 Have: 10 <= i.
74 (* Invariant 'CHECK' *)
75 Have: forall i_2 : Z. ((0 <= i_2) -> ((i_2 <= 9) -> (v[i_2]=true))).
76 (* Loop assigns 'CHECK' *)
77 Have: ((s.F1_S_i) = 0) /\
78 (forall i_2 : Z. ((i_2 != 0) -> ((i_2 != 2) -> ((i_2 != 4) ->
79 ((0 <= i_2) -> ((i_2 <= 9) -> ((s.F1_S_a)[i_2] = v_1[i_2]))))))).
80 (* Invariant 'CHECK' *)
81 Have: ((Init_s_1.Init_F1_S_i)=true) /\
82 (forall i_2 : Z. ((0 <= i_2) -> ((i_2 <= 9) ->
83 ((Init_s_1.Init_F1_S_a)[i_2]=true)))).
84 (* Then *)
85 Have: i_1 <= 9.
86 If i_1 = 0
87 Then {
88 Have: Init_s_1 = Init_s_2.
89 Have: ({ Init_s_2 with Init_F1_S_a = (Init_s_2.Init_F1_S_a)[0 <- true] }) =
90 Init_s_0.
91 }
92 Else {
93 Have: (Init_s_1 = Init_s_3) /\ (s = s_1).
94 If i_1 = 2
95 Then {
96 Have: (Init_s_3 = Init_s_4) /\ (s_1 = s_2).
97 Have: ({ Init_s_4 with Init_F1_S_a = (Init_s_4.Init_F1_S_a)[2 <- true]
98 }) = Init_s_0.
99 }
100 Else {
101 Have: (Init_s_3 = Init_s_5) /\ (s_1 = s_3).
102 If i_1 = 4
103 Then {
104 Have: Init_s_5 = Init_s_6.
105 Have: ({ Init_s_6 with
106 Init_F1_S_a = (Init_s_6.Init_F1_S_a)[4 <- true] }) =
107 Init_s_0.
108 }
109 Else { Have: Init_s_5 = Init_s_0. }
110 }
111 }
112 }
113 Prove: ((Init_s_0.Init_F1_S_i)=true) /\
114 (forall i_2 : Z. ((0 <= i_2) -> ((i_2 <= 9) ->
115 ((Init_s_0.Init_F1_S_a)[i_2]=true)))).
116
117 ------------------------------------------------------------
118
119 Goal Establishment of Invariant 'CHECK' (file assigned_initialized_memvar.i, line 105):
120 Assume {
121 Have: 0 <= i.
122 Have: i <= 9.
123 Type: is_sint32(i_1).
124 (* Invariant *)
125 Have: (0 <= i_1) /\ (i_1 <= 10) /\
126 (((0 < i_1) ->
127 (forall i_2 : Z. ((0 <= i_2) -> ((i_2 < i_1) -> (v[i_2]=true)))))).
128 (* Else *)
129 Have: 10 <= i_1.
130 }
131 Prove: (v[i]=true).
132
133 ------------------------------------------------------------
134
135 Goal Check 'CHECK' (file assigned_initialized_memvar.i, line 111):
136 Prove: true.
137
138 ------------------------------------------------------------
139
140 Goal Loop assigns 'CHECK' (1/5):
141 Prove: true.
142
143 ------------------------------------------------------------
144
145 Goal Loop assigns 'CHECK' (2/5):
146 Effect at line 108
147 Assume {
148 Type: is_sint32(i_2) /\ is_sint32(i_3).
149 (* Goal *)
150 When: (0 <= i_4) /\ (i_4 <= 9) /\ ((i_4 = 0) \/ (i_4 = 2) \/ (i_4 = 4)) /\
151 ((i_1 = 0) \/ (i_1 = 2) \/ (i_1 = 4)).
152 (* Invariant *)
153 Have: (0 <= i_2) /\ (i_2 <= 10) /\
154 (((0 < i_2) ->
155 (forall i_5 : Z. ((0 <= i_5) -> ((i_5 < i_2) -> (v[i_5]=true)))))).
156 (* Else *)
157 Have: 10 <= i_2.
158 (* Invariant 'CHECK' *)
159 Have: forall i_5 : Z. ((0 <= i_5) -> ((i_5 <= 9) -> (v[i_5]=true))).
160 (* Loop assigns 'CHECK' *)
161 Have: ((s.F1_S_i) = 0) /\
162 (forall i_5 : Z. ((i_5 != 0) -> ((i_5 != 2) -> ((i_5 != 4) ->
163 ((0 <= i_5) -> ((i_5 <= 9) -> ((s.F1_S_a)[i_5] = v_1[i_5]))))))).
164 (* Then *)
165 Have: i_3 <= 9.
166 If i_3 = 0
167 Else {
168 Have: s = s_1.
169 If i_3 = 2
170 Then { Have: s_1 = s_2. }
171 Else { Have: s_1 = s_3. }
172 }
173 }
174 Prove: ((i != 0) /\ (i != 2) /\ (i != 4)) \/
175 (exists i_5 : Z. (i_5 <= i_1) /\ (i_1 <= i_5) /\
176 ((i_5 = 0) \/ (i_5 = 2) \/ (i_5 = 4))).
177
178 ------------------------------------------------------------
179
180 Goal Loop assigns 'CHECK' (3/5):
181 Effect at line 109
182 Prove: true.
183
184 ------------------------------------------------------------
185
186 Goal Loop assigns 'CHECK' (4/5):
187 Effect at line 109
188 Prove: true.
189
190 ------------------------------------------------------------
191
192 Goal Loop assigns 'CHECK' (5/5):
193 Effect at line 109
194 Prove: true.
195
196 ------------------------------------------------------------
197 ------------------------------------------------------------
198 Function field
199 ------------------------------------------------------------
200
201 Goal Check 'FAILS' (file assigned_initialized_memvar.i, line 57):
202 Assume {
203 Type: is_sint32(i) /\ is_sint32(i_1).
204 (* Invariant *)
205 Have: (0 <= i) /\ (i <= 10) /\
206 (((0 < i) ->
207 (forall i_2 : Z. ((0 <= i_2) -> ((i_2 < i) -> (v[i_2]=true)))))).
208 (* Else *)
209 Have: 10 <= i.
210 (* Else *)
211 Have: 10 <= i_1.
212 }
213 Prove: ((Init_s_0.Init_F1_S_i)=true) /\
214 (forall i_2 : Z. ((0 <= i_2) -> ((i_2 <= 9) ->
215 ((Init_s_0.Init_F1_S_a)[i_2]=true)))).
216
217 ------------------------------------------------------------
218
219 Goal Loop assigns 'CHECK':
220 Prove: true.
221
222 ------------------------------------------------------------
223 ------------------------------------------------------------
224 Function index
225 ------------------------------------------------------------
226
227 Goal Check 'FAILS' (file assigned_initialized_memvar.i, line 92):
228 Assume {
229 Type: is_sint32(i) /\ is_sint32(i_1).
230 (* Invariant *)
231 Have: (0 <= i) /\ (i <= 10) /\
232 (((0 < i) ->
233 (forall i_2 : Z. ((0 <= i_2) -> ((i_2 < i) -> (v[i_2]=true)))))).
234 (* Else *)
235 Have: 10 <= i.
236 (* Else *)
237 Have: 10 <= i_1.
238 }
239 Prove: ((Init_s_0.Init_F1_S_i)=true) /\
240 (forall i_2 : Z. ((0 <= i_2) -> ((i_2 <= 9) ->
241 ((Init_s_0.Init_F1_S_a)[i_2]=true)))).
242
243 ------------------------------------------------------------
244
245 Goal Loop assigns 'CHECK' (1/2):
246 Prove: true.
247
248 ------------------------------------------------------------
249
250 Goal Loop assigns 'CHECK' (2/2):
251 Effect at line 90
252 Prove: true.
253
254 ------------------------------------------------------------
255 ------------------------------------------------------------
256 Function initialize
257 ------------------------------------------------------------
258
259 Goal Preservation of Invariant 'CHECK' (file assigned_initialized_memvar.i, line 17):
260 Assume {
261 Type: is_sint32(i) /\ is_sint32(1 + i).
262 (* Invariant 'CHECK' *)
263 Have: (0 <= i) /\ (i <= 10) /\
264 (((0 < i) ->
265 (forall i_1 : Z. ((0 <= i_1) -> ((i_1 < i) -> (v[i_1]=true)))))).
266 (* Then *)
267 Have: i <= 9.
268 }
269 Prove: ((-1) <= i) /\
270 (forall i_1 : Z. ((i_1 <= i) -> ((0 <= i_1) ->
271 (v[i <- true][i_1]=true)))).
272
273 ------------------------------------------------------------
274
275 Goal Establishment of Invariant 'CHECK' (file assigned_initialized_memvar.i, line 17):
276 Prove: true.
277
278 ------------------------------------------------------------
279
280 Goal Check 'CHECK' (file assigned_initialized_memvar.i, line 22):
281 Assume {
282 Have: 0 <= i.
283 Have: i <= 9.
284 Type: is_sint32(i_1).
285 (* Invariant 'CHECK' *)
286 Have: (0 <= i_1) /\ (i_1 <= 10) /\
287 (((0 < i_1) ->
288 (forall i_2 : Z. ((0 <= i_2) -> ((i_2 < i_1) -> (v[i_2]=true)))))).
289 (* Else *)
290 Have: 10 <= i_1.
291 }
292 Prove: (v[i]=true).
293
294 ------------------------------------------------------------
295
296 Goal Loop assigns 'CHECK':
297 Prove: true.
298
299 ------------------------------------------------------------
300 ------------------------------------------------------------
301 Function range
302 ------------------------------------------------------------
303
304 Goal Preservation of Invariant 'CHECK' (file assigned_initialized_memvar.i, line 35):
305 Let a = Init_s_0.Init_F1_S_a.
306 Assume {
307 Type: is_sint32(i_1) /\ is_sint32(i).
308 (* Residual *)
309 When: i <= 4.
310 (* Residual *)
311 When: 0 < i.
312 (* Invariant *)
313 Have: (0 <= i_1) /\ (i_1 <= 10) /\
314 (((0 < i_1) ->
315 (forall i_2 : Z. ((0 <= i_2) -> ((i_2 < i_1) -> (v[i_2]=true)))))).
316 (* Else *)
317 Have: 10 <= i_1.
318 (* Invariant 'CHECK' *)
319 Have: forall i_2 : Z. ((0 <= i_2) -> ((i_2 <= 9) -> (v[i_2]=true))).
320 (* Loop assigns 'CHECK' *)
321 Have: ((s.F1_S_i) = 0) /\
322 (forall i_2 : Z. ((0 <= i_2) -> ((i_2 <= 9) ->
323 (((i_2 <= 0) \/ (5 <= i_2)) -> ((s.F1_S_a)[i_2] = v_1[i_2]))))).
324 (* Invariant 'CHECK' *)
325 Have: ((Init_s_0.Init_F1_S_i)=true) /\
326 (forall i_2 : Z. ((0 <= i_2) -> ((i_2 <= 9) -> (a[i_2]=true)))).
327 (* Then *)
328 Have: i <= 9.
329 }
330 Prove: forall i_2 : Z. ((0 <= i_2) -> ((i_2 <= 9) ->
331 (a[i <- true][i_2]=true))).
332
333 ------------------------------------------------------------
334
335 Goal Establishment of Invariant 'CHECK' (file assigned_initialized_memvar.i, line 35):
336 Assume {
337 Have: 0 <= i.
338 Have: i <= 9.
339 Type: is_sint32(i_1).
340 (* Invariant *)
341 Have: (0 <= i_1) /\ (i_1 <= 10) /\
342 (((0 < i_1) ->
343 (forall i_2 : Z. ((0 <= i_2) -> ((i_2 < i_1) -> (v[i_2]=true)))))).
344 (* Else *)
345 Have: 10 <= i_1.
346 }
347 Prove: (v[i]=true).
348
349 ------------------------------------------------------------
350
351 Goal Check 'CHECK' (file assigned_initialized_memvar.i, line 41):
352 Prove: true.
353
354 ------------------------------------------------------------
355
356 Goal Loop assigns 'CHECK' (1/2):
357 Prove: true.
358
359 ------------------------------------------------------------
360
361 Goal Loop assigns 'CHECK' (2/2):
362 Effect at line 39
363 Prove: true.
364
365 ------------------------------------------------------------