Essai1.p :
----------

Le Code "C" :

int main()
{
int x;
int y;

x = 4;
y = x;
 return(0);
}

La question : ?(x=4)

La preuve :

SPASS derived 2 clauses, backtracked 0 clauses and kept 19 clauses.
SPASS allocated 429 KBytes.
SPASS spent     0:00:00.01 on the problem.
                0:00:00.00 for the input.
                0:00:00.00 for the FLOTTER CNF translation.
                0:00:00.00 for inferences.
                0:00:00.00 for the backtracking.
                0:00:00.00 for the reduction.


Here is a proof with depth 1, length 8 :
1[0:Inp] || fun_main(nil) -> values(x,4)*.
3[0:Inp] || fun_main(nil) values(x,U)* -> values(y,U).
6[0:Inp] ||  -> fun_main(nil)*.
18[0:Inp] || values(y,4)* -> .
19[0:MRR:1.0,6.0] ||  -> values(x,4)*.
22[0:MRR:3.0,6.0] || values(x,U)* -> values(y,U).
25[0:Res:22.1,18.0] || values(x,4)* -> .
26[0:MRR:25.0,19.0] ||  -> .
Formulae used in the proof :

Essai2.p :
----------

Le code "C" :

int main()
{
int x;
int* y;
int z;

x = 4;
y = &x;
*y = 2;
z = *y;

 return(0);
}

La question : ?(x=2)
SPASS derived 2 clauses, backtracked 0 clauses and kept 24 clauses.
SPASS allocated 434 KBytes.
SPASS spent     0:00:00.01 on the problem.
                0:00:00.00 for the input.
                0:00:00.00 for the FLOTTER CNF translation.
                0:00:00.00 for inferences.
                0:00:00.00 for the backtracking.
                0:00:00.00 for the reduction.


Here is a proof with depth 1, length 10 :
3[0:Inp] || fun_main(nil) -> values(y,address(x))*.
5[0:Inp] || fun_main(nil) -> values(x3,2)*.
6[0:Inp] || fun_main(nil) values(y,address(U))* values(x3,V)* -> values(U,V)*.
10[0:Inp] ||  -> fun_main(nil)*.
22[0:Inp] || values(x,2)* -> .
24[0:MRR:5.0,10.0] ||  -> values(x3,2)*.
26[0:MRR:3.0,10.0] ||  -> values(y,address(x))*.
30[0:MRR:6.0,10.0] || values(x3,U)* values(y,address(V))* -> values(V,U)*.
32[0:Res:30.2,22.0] || values(y,address(x))* values(x3,2) -> .
34[0:MRR:32.0,32.1,26.0,24.0] ||  -> .
Formulae used in the proof :

Essai3.p :
----------

meme code que Essai2

La question : ? values(z,2)

La preuve :

Problem: essai.dfg 
SPASS derived 23 clauses, backtracked 0 clauses and kept 45 clauses.
SPASS allocated 441 KBytes.
SPASS spent     0:00:00.03 on the problem.
                0:00:00.00 for the input.
                0:00:00.00 for the FLOTTER CNF translation.
                0:00:00.00 for inferences.
                0:00:00.00 for the backtracking.
                0:00:00.00 for the reduction.


Here is a proof with depth 3, length 15 :
3[0:Inp] || fun_main(nil) -> values(y,address(x))*.
5[0:Inp] || fun_main(nil) -> values(x3,2)*.
6[0:Inp] || fun_main(nil) values(y,address(U))* values(x3,V)* -> values(U,V)*.
7[0:Inp] || fun_main(nil) values(y,address(U))* values(U,V)* -> values(z,V)*.
10[0:Inp] ||  -> fun_main(nil)*.
22[0:Inp] || values(z,2)*+ -> .
24[0:MRR:5.0,10.0] ||  -> values(x3,2)*.
26[0:MRR:3.0,10.0] ||  -> values(y,address(x))*.
30[0:MRR:6.0,10.0] || values(x3,U)* values(y,address(V))*+ -> values(V,U)*.
31[0:MRR:7.0,10.0] || values(U,V)* values(y,address(U))*+ -> values(z,V)*.
45[0:Res:26.0,31.1] || values(x,U)*+ -> values(z,U).
50[0:Res:26.0,30.1] || values(x3,U)+ -> values(x,U)*.
51[0:Res:24.0,50.0] ||  -> values(x,2)*.
52[0:Res:51.0,45.0] ||  -> values(z,2)*.
56[0:MRR:52.0,22.0] ||  -> .
Formulae used in the proof :

Essai4.p :
----------

Le code "C" :

struct strt_s
{
  int n1;
};

int main()
{
  struct strt_s x;
  struct strt_s *y;
  int z; int *p;

  x.n1 = 1;
  p = &x.n1;
  *p = 2;
  y = &x;
  *(&y->n1) = 3;

  return(0);
}

La question : ? values(field(x,n1),2)

Problem: essai.dfg 
SPASS derived 34 clauses, backtracked 0 clauses and kept 62 clauses.
SPASS allocated 456 KBytes.
SPASS spent     0:00:00.10 on the problem.
                0:00:00.00 for the input.
                0:00:00.00 for the FLOTTER CNF translation.
                0:00:00.00 for inferences.
                0:00:00.00 for the backtracking.
                0:00:00.00 for the reduction.

Here is a proof with depth 4, length 16 :
5[0:Inp] || fun_main(nil) -> values(x5,address(x))*.
6[0:Inp] || fun_main(nil) -> values(p,address(field(x5,n1)))*.
8[0:Inp] || fun_main(nil) -> values(x6,2)*.
9[0:Inp] || fun_main(nil) values(p,address(U))* values(x6,V)* -> values(U,V)*.
16[0:Inp] ||  -> fun_main(nil)*.
17[0:Inp] || values(U,address(V))* values(field(U,W),X)*+ -> values(field(V,W),X)*.
28[0:Inp] || values(field(x,n1),2)*+ -> .
30[0:MRR:8.0,16.0] ||  -> values(x6,2)*.
34[0:MRR:5.0,16.0] ||  -> values(x5,address(x))*.
39[0:MRR:6.0,16.0] ||  -> values(p,address(field(x5,n1)))*.
42[0:MRR:9.0,16.0] || values(x6,U)* values(p,address(V))*+ -> values(V,U)*.
67[0:Res:39.0,42.1] || values(x6,U)+ -> values(field(x5,n1),U)*.
68[0:Res:30.0,67.0] ||  -> values(field(x5,n1),2)*.
74[0:Res:68.0,17.1] || values(x5,address(U))+ -> values(field(U,n1),2)*.
80[0:Res:34.0,74.0] ||  -> values(field(x,n1),2)*.
81[0:MRR:80.0,28.0] ||  -> .
Formulae used in the proof :


Essai5.p :
----------

Meme code que essai4 

Question : ? values(field(y,n1),2)

La preuve

Problem: essai.dfg 
SPASS derived 73 clauses, backtracked 0 clauses and kept 96 clauses.
SPASS allocated 468 KBytes.
SPASS spent     0:00:00.08 on the problem.
                0:00:00.00 for the input.
                0:00:00.00 for the FLOTTER CNF translation.
                0:00:00.00 for inferences.
                0:00:00.00 for the backtracking.
                0:00:00.01 for the reduction.


Here is a proof with depth 5, length 19 :
5[0:Inp] || fun_main(nil) -> values(x5,address(x))*.
6[0:Inp] || fun_main(nil) -> values(p,address(field(x5,n1)))*.
8[0:Inp] || fun_main(nil) -> values(x6,2)*.
9[0:Inp] || fun_main(nil) values(p,address(U))* values(x6,V)* -> values(U,V)*.
10[0:Inp] || fun_main(nil) -> values(y,address(x))*.
16[0:Inp] ||  -> fun_main(nil)*.
18[0:Inp] || values(U,address(V))* values(W,address(V))* values(field(W,X),Y)*+ -> values(field(U,X),Y)*.
28[0:Inp] || values(field(y,n1),2)*+ -> .
30[0:MRR:8.0,16.0] ||  -> values(x6,2)*.
34[0:MRR:5.0,16.0] ||  -> values(x5,address(x))*.
35[0:MRR:10.0,16.0] ||  -> values(y,address(x))*.
39[0:MRR:6.0,16.0] ||  -> values(p,address(field(x5,n1)))*.
42[0:MRR:9.0,16.0] || values(x6,U)* values(p,address(V))*+ -> values(V,U)*.
67[0:Res:39.0,42.1] || values(x6,U)+ -> values(field(x5,n1),U)*.
68[0:Res:30.0,67.0] ||  -> values(field(x5,n1),2)*.
88[0:Res:68.0,18.2] || values(U,address(V))* values(x5,address(V))*+ -> values(field(U,n1),2)*.
115[0:Res:34.0,88.1] || values(U,address(x))+ -> values(field(U,n1),2)*.
118[0:Res:35.0,115.0] ||  -> values(field(y,n1),2)*.
120[0:MRR:118.0,28.0] ||  -> .
Formulae used in the proof :

Essai6.p :
----------

Meme code :

Question : ? values(field(x,n1),3)

Problem: essai.dfg 
SPASS derived 30 clauses, backtracked 0 clauses and kept 58 clauses.
SPASS allocated 454 KBytes.
SPASS spent     0:00:00.11 on the problem.
                0:00:00.00 for the input.
                0:00:00.00 for the FLOTTER CNF translation.
                0:00:00.00 for inferences.
                0:00:00.00 for the backtracking.
                0:00:00.00 for the reduction.


Here is a proof with depth 4, length 16 :
10[0:Inp] || fun_main(nil) -> values(y,address(x))*.
12[0:Inp] || fun_main(nil) -> values(x9,address(field(y,n1)))*.
13[0:Inp] || fun_main(nil) -> values(x8,3)*.
14[0:Inp] || fun_main(nil) values(x9,address(U))* values(x8,V)* -> values(U,V)*.
16[0:Inp] ||  -> fun_main(nil)*.
17[0:Inp] || values(U,address(V))* values(field(U,W),X)*+ -> values(field(V,W),X)*.
28[0:Inp] || values(field(x,n1),3)*+ -> .
31[0:MRR:13.0,16.0] ||  -> values(x8,3)*.
35[0:MRR:10.0,16.0] ||  -> values(y,address(x))*.
40[0:MRR:12.0,16.0] ||  -> values(x9,address(field(y,n1)))*.
43[0:MRR:14.0,16.0] || values(x8,U)* values(x9,address(V))*+ -> values(V,U)*.
70[0:Res:40.0,43.1] || values(x8,U)+ -> values(field(y,n1),U)*.
71[0:Res:31.0,70.0] ||  -> values(field(y,n1),3)*.
75[0:Res:71.0,17.1] || values(y,address(U))+ -> values(field(U,n1),3)*.
76[0:Res:35.0,75.0] ||  -> values(field(x,n1),3)*.
77[0:MRR:76.0,28.0] ||  -> .
Formulae used in the proof :


Essai7.p :
----------

Le code :

struct mystruct1_t
{ int m1; };

struct strt_s
{ int n1;
  struct mystruct1_t str; };

int main()
{
  struct strt_s x;
  struct strt_s *y;

  x.n1 = 1;
  x.str.m1 = 3;
  y = &x;
  (*y).str.m1 = 5;
  return(0);
}

La question : ? values(field(field(x,str),m1),3)

Problem: essai.dfg 
SPASS derived 60 clauses, backtracked 0 clauses and kept 89 clauses.
SPASS allocated 474 KBytes.
SPASS spent     0:00:00.16 on the problem.
                0:00:00.00 for the input.
                0:00:00.00 for the FLOTTER CNF translation.
                0:00:00.00 for inferences.
                0:00:00.00 for the backtracking.
                0:00:00.01 for the reduction.


Here is a proof with depth 6, length 21 :
5[0:Inp] || fun_main(nil) -> values(x7,address(x))*.
6[0:Inp] || fun_main(nil) -> values(x6,address(field(x7,str)))*.
7[0:Inp] || fun_main(nil) -> values(x5,address(field(x6,m1)))*.
8[0:Inp] || fun_main(nil) -> values(x4,3)*.
9[0:Inp] || fun_main(nil) values(x5,address(U))* values(x4,V)* -> values(U,V)*.
17[0:Inp] ||  -> fun_main(nil)*.
18[0:Inp] || values(U,address(V))* values(field(U,W),X)*+ -> values(field(V,W),X)*.
24[0:Inp] || values(U,address(V))* values(field(field(U,W),X),Y)*+ -> values(field(field(V,W),X),Y)*.
29[0:Inp] || values(field(field(x,str),m1),3)*+ -> .
31[0:MRR:8.0,17.0] ||  -> values(x4,3)*.
35[0:MRR:5.0,17.0] ||  -> values(x7,address(x))*.
39[0:MRR:6.0,17.0] ||  -> values(x6,address(field(x7,str)))*.
40[0:MRR:7.0,17.0] ||  -> values(x5,address(field(x6,m1)))*.
44[0:MRR:9.0,17.0] || values(x4,U)* values(x5,address(V))*+ -> values(V,U)*.
71[0:Res:40.0,44.1] || values(x4,U)+ -> values(field(x6,m1),U)*.
72[0:Res:31.0,71.0] ||  -> values(field(x6,m1),3)*.
78[0:Res:72.0,18.1] || values(x6,address(U))+ -> values(field(U,m1),3)*.
83[0:Res:39.0,78.0] ||  -> values(field(field(x7,str),m1),3)*.
86[0:Res:83.0,24.1] || values(x7,address(U))+ -> values(field(field(U,str),m1),3)*.
108[0:Res:35.0,86.0] ||  -> values(field(field(x,str),m1),3)*.
109[0:MRR:108.0,29.0] ||  -> .
Formulae used in the proof :


Essai7bis.p :
----------

struct mystruct1_t
{ int m1; };

struct strt_s
{ int n1;
  struct mystruct1_t str; };

struct strt2_s
{ 
  int n2;
  struct strt_s str2;
};

int main()
{
  struct strt2_s x;
  struct strt2_s *y;

  x.n2 = 1;
  x.str2.n1 = 3;
  x.str2.str.m1 = 4;

  y = &x;
  (*y).str2.str.m1 = 5;
  return(0);
}

La question : ? values(field(field(field(x,str2),str),m1),5)

La preuve :

Problem: essai.dfg 
SPASS derived 168 clauses, backtracked 0 clauses and kept 185 clauses.
SPASS allocated 532 KBytes.
SPASS spent     0:00:00.36 on the problem.
                0:00:00.00 for the input.
                0:00:00.00 for the FLOTTER CNF translation.
                0:00:00.01 for inferences.
                0:00:00.00 for the backtracking.
                0:00:00.02 for the reduction.


Here is a proof with depth 7, length 26 :
16[0:Inp] || fun_main(nil) -> values(y,address(x))*.
18[0:Inp] || fun_main(nil) -> values(x17,address(field(y,str2)))*.
19[0:Inp] || fun_main(nil) -> values(x16,address(field(x17,str)))*.
20[0:Inp] || fun_main(nil) -> values(x15,address(field(x16,m1)))*.
21[0:Inp] || fun_main(nil) -> values(x14,5)*.
22[0:Inp] || fun_main(nil) values(x15,address(U))* values(x14,V)* -> values(U,V)*.
24[0:Inp] ||  -> fun_main(nil)*.
25[0:Inp] || values(U,address(V))* values(field(U,W),X)*+ -> values(field(V,W),X)*.
31[0:Inp] || values(U,address(V))* values(field(field(U,W),X),Y)*+ -> values(field(field(V,W),X),Y)*.
33[0:Inp] || values(U,address(V))* values(field(field(field(U,W),X),Y),Z)*+ -> values(field(field(field(V,W),X),Y),Z)*.
36[0:Inp] || values(field(field(field(x,str2),str),m1),5)*+ -> .
40[0:MRR:21.0,24.0] ||  -> values(x14,5)*.
45[0:MRR:16.0,24.0] ||  -> values(y,address(x))*.
53[0:MRR:18.0,24.0] ||  -> values(x17,address(field(y,str2)))*.
54[0:MRR:19.0,24.0] ||  -> values(x16,address(field(x17,str)))*.
55[0:MRR:20.0,24.0] ||  -> values(x15,address(field(x16,m1)))*.
59[0:MRR:22.0,24.0] || values(x14,U)* values(x15,address(V))*+ -> values(V,U)*.
70[0:Res:33.2,36.0] || values(U,address(x)) values(field(field(field(U,str2),str),m1),5)*+ -> .
100[0:Res:55.0,59.1] || values(x14,U)+ -> values(field(x16,m1),U)*.
101[0:Res:40.0,100.0] ||  -> values(field(x16,m1),5)*.
106[0:Res:101.0,25.1] || values(x16,address(U))+ -> values(field(U,m1),5)*.
107[0:Res:54.0,106.0] ||  -> values(field(field(x17,str),m1),5)*.
121[0:Res:107.0,31.1] || values(x17,address(U))+ -> values(field(field(U,str),m1),5)*.
130[0:Res:53.0,121.0] ||  -> values(field(field(field(y,str2),str),m1),5)*.
231[0:Res:130.0,70.1] || values(y,address(x))* -> .
232[0:MRR:231.0,45.0] ||  -> .
Formulae used in the proof :


Essai8.p :
----------

Le code "C" :

int foo(int x, int y)
{ return(x); }

int bar(int x, int y)
{ return(x-y); }

int main(int argc,char* argv[])
{
  int r1;
  int x,y;
  
  x = 1; y = 2;
  
  r1 = foo(x,y); /* r1=1+2=3 */
  r1 = bar(6,y); /* r1=6-2=4 */
  return(0);
}

La question : ? values(r1,1)

La preuve :

Problem: essai.dfg 
SPASS derived 42 clauses, backtracked 0 clauses and kept 74 clauses.
SPASS allocated 456 KBytes.
SPASS spent     0:00:00.07 on the problem.
                0:00:00.00 for the input.
                0:00:00.00 for the FLOTTER CNF translation.
                0:00:00.00 for inferences.
                0:00:00.00 for the backtracking.
                0:00:00.00 for the reduction.


Here is a proof with depth 3, length 18 :
1[0:Inp] || fun_foo(nil) values(foo_1,U)* -> values(foo_return,U).
4[0:Inp] || fun_main(nil) -> values(x,1)*.
8[0:Inp] || fun_main(nil) -> values(foo_1,x)*.
10[0:Inp] || fun_main(nil) -> fun_foo(nil)*.
11[0:Inp] || fun_main(nil) values(foo_return,U)* -> values(r1,U).
20[0:Inp] ||  -> fun_main(nil)*.
31[0:Inp] || values(U,V)*+ values(W,U)* -> values(W,V)*.
32[0:Inp] || values(r1,1)*+ -> .
33[0:MRR:10.0,20.0] ||  -> fun_foo(nil)*.
35[0:MRR:4.0,20.0] ||  -> values(x,1)*.
37[0:MRR:8.0,20.0] ||  -> values(foo_1,x)*.
45[0:MRR:1.0,33.0] || values(foo_1,U)*+ -> values(foo_return,U).
48[0:MRR:11.0,20.0] || values(foo_return,U)*+ -> values(r1,U).
55[0:Res:37.0,45.0] ||  -> values(foo_return,x)*.
58[0:Res:55.0,48.0] ||  -> values(r1,x)*.
64[0:Res:35.0,31.0] || values(U,x)+ -> values(U,1)*.
91[0:Res:58.0,64.0] ||  -> values(r1,1)*.
94[0:MRR:91.0,32.0] ||  -> .
Formulae used in the proof :


Essai9.p :
----------

Le code "C" :

int foo(int x, int y)
{ return(x+y); }

int bar(int x, int y)
{ return(x-y); }

int (*fp)(int x, int y);

int main(int argc,char* argv[])
{
  int r1;
  int x,y;
  
  x = 1; y = 2;
  
  fp = foo; 
  r1 = (*fp)(x,y); /* r1=1+2=3 */
  fp = bar;
  r1 = (*fp)(6,y); /* r1=6-2=4 */
  return(0);
}

La question : ? values(r1,1)

La preuve :

Problem: essai.dfg 
SPASS derived 42 clauses, backtracked 0 clauses and kept 74 clauses.
SPASS allocated 456 KBytes.
SPASS spent     0:00:00.09 on the problem.
                0:00:00.00 for the input.
                0:00:00.00 for the FLOTTER CNF translation.
                0:00:00.00 for inferences.
                0:00:00.00 for the backtracking.
                0:00:00.00 for the reduction.


Here is a proof with depth 3, length 18 :
1[0:Inp] || fun_foo(nil) values(foo_1,U)* -> values(foo_return,U).
4[0:Inp] || fun_main(nil) -> values(x,1)*.
8[0:Inp] || fun_main(nil) -> values(foo_1,x)*.
10[0:Inp] || fun_main(nil) -> fun_foo(nil)*.
11[0:Inp] || fun_main(nil) values(foo_return,U)* -> values(r1,U).
20[0:Inp] ||  -> fun_main(nil)*.
31[0:Inp] || values(U,V)*+ values(W,U)* -> values(W,V)*.
32[0:Inp] || values(r1,1)*+ -> .
33[0:MRR:10.0,20.0] ||  -> fun_foo(nil)*.
35[0:MRR:4.0,20.0] ||  -> values(x,1)*.
37[0:MRR:8.0,20.0] ||  -> values(foo_1,x)*.
45[0:MRR:1.0,33.0] || values(foo_1,U)*+ -> values(foo_return,U).
48[0:MRR:11.0,20.0] || values(foo_return,U)*+ -> values(r1,U).
55[0:Res:37.0,45.0] ||  -> values(foo_return,x)*.
58[0:Res:55.0,48.0] ||  -> values(r1,x)*.
64[0:Res:35.0,31.0] || values(U,x)+ -> values(U,1)*.
91[0:Res:58.0,64.0] ||  -> values(r1,1)*.
94[0:MRR:91.0,32.0] ||  -> .
Formulae used in the proof :

Essai10.p :
-----------

Le code :

int echange(int *x, int *y)
{
  int z;
  z = *y;
  *y = *x;
  *x =z;
  return(*x);
}

int main(int argc, 
         char* argv[])
{
  int x,y,z;
  x = 1; y = 2;  
  z=echange(&x,&y);
  return(0);
}

La question : ? values(x,2)


La preuve :

Problem: essai.dfg 
SPASS derived 31 clauses, backtracked 0 clauses and kept 63 clauses.
SPASS allocated 454 KBytes.
SPASS spent     0:00:00.09 on the problem.
                0:00:00.00 for the input.
                0:00:00.00 for the FLOTTER CNF translation.
                0:00:00.00 for inferences.
                0:00:00.00 for the backtracking.
                0:00:00.00 for the reduction.


Here is a proof with depth 5, length 31 :
1[0:Inp] || fun_echange(nil) values(echange_2,address(U))* values(U,V)* -> values(echange_3,V)*.
5[0:Inp] || fun_echange(nil) values(echange_3,U)* -> values(echange_6,U).
6[0:Inp] || fun_echange(nil) values(echange_1,address(U))* values(echange_6,V)* -> values(U,V)*.
10[0:Inp] || fun_main(nil) -> values(y,2)*.
12[0:Inp] || fun_main(nil) -> values(x7,address(x))*.
13[0:Inp] || fun_main(nil) -> values(x8,address(y))*.
14[0:Inp] || fun_main(nil) -> values(echange_1,x7)*.
15[0:Inp] || fun_main(nil) -> values(echange_2,x8)*.
16[0:Inp] || fun_main(nil) -> fun_echange(nil)*.
20[0:Inp] ||  -> fun_main(nil)*.
31[0:Inp] || values(U,V)*+ values(W,U)* -> values(W,V)*.
32[0:Inp] || values(x,2)*+ -> .
33[0:MRR:16.0,20.0] ||  -> fun_echange(nil)*.
35[0:MRR:10.0,20.0] ||  -> values(y,2)*.
36[0:MRR:14.0,20.0] ||  -> values(echange_1,x7)*.
37[0:MRR:15.0,20.0] ||  -> values(echange_2,x8)*.
39[0:MRR:12.0,20.0] ||  -> values(x7,address(x))*.
40[0:MRR:13.0,20.0] ||  -> values(x8,address(y))*.
42[0:MRR:5.0,33.0] || values(echange_3,U)*+ -> values(echange_6,U).
47[0:MRR:1.0,33.0] || values(U,V)* values(echange_2,address(U))*+ -> values(echange_3,V)*.
50[0:MRR:6.0,33.0] || values(echange_6,U)* values(echange_1,address(V))*+ -> values(V,U)*.
52[0:Res:50.2,32.0] || values(echange_6,2) values(echange_1,address(x))* -> .
64[0:Res:39.0,31.0] || values(U,x7)+ -> values(U,address(x))*.
65[0:Res:40.0,31.0] || values(U,x8)+ -> values(U,address(y))*.
68[0:Res:37.0,65.0] ||  -> values(echange_2,address(y))*.
69[0:Res:68.0,47.1] || values(y,U)+ -> values(echange_3,U)*.
71[0:Res:35.0,69.0] ||  -> values(echange_3,2)*.
72[0:Res:71.0,42.0] ||  -> values(echange_6,2)*.
76[0:MRR:52.0,72.0] || values(echange_1,address(x))*+ -> .
82[0:Res:36.0,64.0] ||  -> values(echange_1,address(x))*.
83[0:MRR:82.0,76.0] ||  -> .
Formulae used in the proof :

Essai11.p :
-----------

Le code :

int echange(int x, int y)
{
  int z;
  z = x; x = y; y = z;
  return(x);
}


int main(int argc, 
         char* argv[])
{
  int x,y,z;
  x = 1; y = 2;
  z=echange(x,y);
  return(0);
}

La question : ? values(x,2)

La preuve : Pas de preuve (normal pas d'echange par les adresses)


Problem: essai.dfg 
SPASS derived 109 clauses, backtracked 0 clauses and kept 119 clauses.
SPASS allocated 467 KBytes.
SPASS spent     0:00:00.20 on the problem.
                0:00:00.00 for the input.
                0:00:00.00 for the FLOTTER CNF translation.
                0:00:00.00 for inferences.
                0:00:00.00 for the backtracking.
                0:00:00.00 for the reduction.



 The saturated set of worked-off clauses is :
145[0:Res:119.0,29.0] || values(U,echange_1)+ -> values(U,1)*.
141[0:Res:120.0,29.0] || values(U,echange_3)+ -> values(U,1)*.
138[0:Res:121.0,29.0] || values(U,echange_4)+ -> values(U,1)*.
136[0:Res:123.0,29.0] || values(U,echange_2)+ -> values(U,1)*.
137[0:Res:122.0,29.0] || values(U,echange_5)+ -> values(U,1)*.
133[0:Res:124.0,29.0] || values(U,echange_6)+ -> values(U,1)*.
132[0:Res:125.0,29.0] || values(U,echange_return)+ -> values(U,1)*.
130[0:Res:126.0,29.0] || values(U,z)+ -> values(U,1)*.
128[0:Res:127.0,29.0] || values(U,x6)+ -> values(U,1)*.

118[0:Res:92.0,29.0] || values(U,echange_1)+ -> values(U,2)*.
114[0:Res:93.0,29.0] || values(U,echange_2)+ -> values(U,2)*.
111[0:Res:94.0,29.0] || values(U,echange_3)+ -> values(U,2)*.
108[0:Res:95.0,29.0] || values(U,echange_5)+ -> values(U,2)*.
107[0:Res:96.0,29.0] || values(U,echange_4)+ -> values(U,2)*.
106[0:Res:97.0,29.0] || values(U,echange_6)+ -> values(U,2)*.
105[0:Res:98.0,29.0] || values(U,echange_return)+ -> values(U,2)*.
103[0:Res:99.0,29.0] || values(U,z)+ -> values(U,2)*.
101[0:Res:100.0,29.0] || values(U,x6)+ -> values(U,2)*.
148[0:Res:100.0,48.0] || values(x,x6)*+ -> .
146[0:Res:33.0,48.0] || values(x,y)*+ -> .
149[0:Res:99.0,48.0] || values(x,z)*+ -> .
150[0:Res:98.0,48.0] || values(x,echange_return)*+ -> .
151[0:Res:97.0,48.0] || values(x,echange_6)*+ -> .
152[0:Res:96.0,48.0] || values(x,echange_4)*+ -> .
147[0:Res:64.0,48.0] || values(x,x5)*+ -> .
153[0:Res:95.0,48.0] || values(x,echange_5)*+ -> .
154[0:Res:94.0,48.0] || values(x,echange_3)*+ -> .
155[0:Res:93.0,48.0] || values(x,echange_2)*+ -> .
156[0:Res:92.0,48.0] || values(x,echange_1)*+ -> .
48[0:Res:29.2,30.0] || values(U,2)*+ values(x,U)* -> .
119[0:Res:34.0,69.0] ||  -> values(echange_1,1)*.
120[0:Res:49.0,69.0] ||  -> values(echange_3,1)*.
121[0:Res:50.0,69.0] ||  -> values(echange_4,1)*.
122[0:Res:53.0,69.0] ||  -> values(echange_5,1)*.
28[0:Inp] || values(U,address(V)) values(W,address(V)) values(field(field(field(U,X),Y),V),Z)*+ -> values(field(field(field(W,X),Y),V),Z)*.
123[0:Res:57.0,69.0] ||  -> values(echange_2,1)*.
124[0:Res:60.0,69.0] ||  -> values(echange_6,1)*.
125[0:Res:61.0,69.0] ||  -> values(echange_return,1)*.

126[0:Res:66.0,69.0] ||  -> values(z,1)*.
26[0:Inp] || values(U,address(V))* values(W,address(V))* values(field(field(U,X),Y),Z)*+ -> values(field(field(W,X),Y),Z)*.
127[0:Res:68.0,69.0] ||  -> values(x6,1)*.
69[0:Res:32.0,29.0] || values(U,x)+ -> values(U,1)*.
70[0:Res:63.0,29.0] || values(U,x4)+ -> values(U,1)*.
92[0:Res:51.0,71.0] ||  -> values(echange_1,2)*.
27[0:Inp] || values(U,address(V))* values(field(field(field(U,W),X),Y),Z)*+ -> values(field(field(field(V,W),X),Y),Z)*.
93[0:Res:35.0,71.0] ||  -> values(echange_2,2)*.
94[0:Res:52.0,71.0] ||  -> values(echange_3,2)*.
95[0:Res:54.0,71.0] ||  -> values(echange_5,2)*.
96[0:Res:55.0,71.0] ||  -> values(echange_4,2)*.
21[0:Inp] || values(U,address(field(V,W)))*+ values(V,address(field(X,Y)))* -> values(U,address(field(field(X,Y),W)))*.
97[0:Res:59.0,71.0] ||  -> values(echange_6,2)*.
98[0:Res:62.0,71.0] ||  -> values(echange_return,2)*.
99[0:Res:65.0,71.0] ||  -> values(z,2)*.
100[0:Res:67.0,71.0] ||  -> values(x6,2)*.
23[0:Inp] || values(U,address(V))* values(W,address(V))* values(offset(W,X),Y)*+ -> values(offset(U,X),Y)*.
71[0:Res:33.0,29.0] || values(U,y)+ -> values(U,2)*.
72[0:Res:64.0,29.0] || values(U,x5)+ -> values(U,2)*.
73[0:Res:34.0,29.0] || values(U,echange_1)*+ -> values(U,x).
74[0:Res:51.0,29.0] || values(U,echange_1)*+ -> values(U,y).

20[0:Inp] || values(U,address(V))* values(W,address(V))* values(field(W,X),Y)*+ -> values(field(U,X),Y)*.
75[0:Res:35.0,29.0] || values(U,echange_2)*+ -> values(U,y).
76[0:Res:52.0,29.0] || values(U,echange_3)*+ -> values(U,y).
77[0:Res:54.0,29.0] || values(U,echange_5)*+ -> values(U,y).
78[0:Res:55.0,29.0] || values(U,echange_4)*+ -> values(U,y).
25[0:Inp] || values(U,address(V))* values(field(field(U,W),X),Y)*+ -> values(field(field(V,W),X),Y)*.
79[0:Res:59.0,29.0] || values(U,echange_6)*+ -> values(U,y).
80[0:Res:62.0,29.0] || values(U,echange_return)*+ -> values(U,y).
81[0:Res:65.0,29.0] || values(U,z)+ -> values(U,y)*.
82[0:Res:67.0,29.0] || values(U,x6)*+ -> values(U,y).
22[0:Inp] || values(U,address(V))* values(offset(U,W),X)*+ -> values(offset(V,W),X)*.
83[0:Res:36.0,29.0] || values(U,main_return)+ -> values(U,0)*.
84[0:Res:49.0,29.0] || values(U,echange_3)*+ -> values(U,x).
85[0:Res:50.0,29.0] || values(U,echange_4)*+ -> values(U,x).
86[0:Res:53.0,29.0] || values(U,echange_5)*+ -> values(U,x).
19[0:Inp] || values(U,address(V))* values(field(U,W),X)*+ -> values(field(V,W),X)*.
87[0:Res:57.0,29.0] || values(U,echange_2)*+ -> values(U,x).
88[0:Res:60.0,29.0] || values(U,echange_6)*+ -> values(U,x).
89[0:Res:61.0,29.0] || values(U,echange_return)*+ -> values(U,x).
90[0:Res:66.0,29.0] || values(U,z)+ -> values(U,x)*.
24[0:Inp] || values(U,V)* values(offset(W,U),X)*+ -> values(offset(W,V),X)*.
91[0:Res:68.0,29.0] || values(U,x6)+ -> values(U,x)*.
29[0:Inp] || values(U,V)*+ values(W,U)* -> values(W,V)*.
67[0:Res:65.0,47.0] ||  -> values(x6,y)*.
68[0:Res:66.0,47.0] ||  -> values(x6,x)*.

47[0:MRR:16.0,18.0] || values(z,U)+ -> values(x6,U)*.
65[0:Res:62.0,46.0] ||  -> values(z,y)*.
66[0:Res:61.0,46.0] ||  -> values(z,x)*.
46[0:MRR:15.0,18.0] || values(echange_return,U)*+ -> values(z,U).
64[0:Res:33.0,45.0] ||  -> values(x5,2)*.
45[0:MRR:11.0,18.0] || values(y,U)+ -> values(x5,U)*.
63[0:Res:32.0,44.0] ||  -> values(x4,1)*.
44[0:MRR:9.0,18.0] || values(x,U)*+ -> values(x4,U).
61[0:Res:34.0,43.0] ||  -> values(echange_return,x)*.
62[0:Res:51.0,43.0] ||  -> values(echange_return,y)*.
43[0:MRR:7.0,31.0] || values(echange_1,U)*+ -> values(echange_return,U).
59[0:Res:35.0,42.0] ||  -> values(echange_6,y)*.
60[0:Res:57.0,42.0] ||  -> values(echange_6,x)*.
42[0:MRR:6.0,31.0] || values(echange_2,U)*+ -> values(echange_6,U).
57[0:Res:49.0,41.0] ||  -> values(echange_2,x)*.
41[0:MRR:5.0,31.0] || values(echange_3,U)+ -> values(echange_2,U)*.
55[0:Res:52.0,38.0] ||  -> values(echange_4,y)*.
53[0:Res:34.0,40.0] ||  -> values(echange_5,x)*.
54[0:Res:51.0,40.0] ||  -> values(echange_5,y)*.
52[0:Res:51.0,37.0] ||  -> values(echange_3,y)*.
40[0:MRR:4.0,31.0] || values(echange_1,U)*+ -> values(echange_5,U).
51[0:Res:35.0,39.0] ||  -> values(echange_1,y)*.
39[0:MRR:3.0,31.0] || values(echange_2,U)+ -> values(echange_1,U)*.
50[0:Res:49.0,38.0] ||  -> values(echange_4,x)*.
49[0:Res:34.0,37.0] ||  -> values(echange_3,x)*.
38[0:MRR:2.0,31.0] || values(echange_3,U)*+ -> values(echange_4,U).
37[0:MRR:1.0,31.0] || values(echange_1,U)*+ -> values(echange_3,U).
30[0:Inp] || values(x,2)*+ -> .
36[0:MRR:17.0,18.0] ||  -> values(main_return,0)*.
35[0:MRR:13.0,18.0] ||  -> values(echange_2,y)*.
34[0:MRR:12.0,18.0] ||  -> values(echange_1,x)*.
33[0:MRR:10.0,18.0] ||  -> values(y,2)*.
32[0:MRR:8.0,18.0] ||  -> values(x,1)*.
31[0:MRR:14.0,18.0] ||  -> fun_echange(nil)*.
18[0:Inp] ||  -> fun_main(nil)*.


Essai12.p :
-----------

Meme code 

Question : ? values(z,1)

Preuve :

Problem: essai.dfg 
SPASS derived 81 clauses, backtracked 0 clauses and kept 100 clauses.
SPASS allocated 462 KBytes.
SPASS spent     0:00:00.06 on the problem.
                0:00:00.00 for the input.
                0:00:00.00 for the FLOTTER CNF translation.
                0:00:00.00 for inferences.
                0:00:00.00 for the backtracking.
                0:00:00.00 for the reduction.


Here is a proof with depth 3, length 18 :
7[0:Inp] || fun_echange(nil) values(echange_1,U)* -> values(echange_return,U).
8[0:Inp] || fun_main(nil) -> values(x,1)*.
12[0:Inp] || fun_main(nil) -> values(echange_1,x)*.
14[0:Inp] || fun_main(nil) -> fun_echange(nil)*.
15[0:Inp] || fun_main(nil) values(echange_return,U)* -> values(z,U).
18[0:Inp] ||  -> fun_main(nil)*.
29[0:Inp] || values(U,V)*+ values(W,U)* -> values(W,V)*.
30[0:Inp] || values(z,1)*+ -> .
31[0:MRR:14.0,18.0] ||  -> fun_echange(nil)*.
32[0:MRR:8.0,18.0] ||  -> values(x,1)*.
34[0:MRR:12.0,18.0] ||  -> values(echange_1,x)*.
43[0:MRR:7.0,31.0] || values(echange_1,U)*+ -> values(echange_return,U).
46[0:MRR:15.0,18.0] || values(echange_return,U)*+ -> values(z,U).
62[0:Res:34.0,43.0] ||  -> values(echange_return,x)*.
67[0:Res:62.0,46.0] ||  -> values(z,x)*.
70[0:Res:32.0,29.0] || values(U,x)+ -> values(U,1)*.
127[0:Res:67.0,70.0] ||  -> values(z,1)*.
129[0:MRR:127.0,30.0] ||  -> .
Formulae used in the proof :

Essai13.p :
-----------

Le code :

int main()
{
  int myarray[3];

  myarray[0] = 0;
  myarray[1] = 1;
  myarray[2] = 2;
  return(0);
}


La question : values(offset(myarray,1),1)

Problem: essai.dfg 
SPASS derived 73 clauses, backtracked 0 clauses and kept 108 clauses.
SPASS allocated 478 KBytes.
SPASS spent     0:00:00.05 on the problem.
                0:00:00.00 for the input.
                0:00:00.00 for the FLOTTER CNF translation.
                0:00:00.00 for inferences.
                0:00:00.00 for the backtracking.
                0:00:00.01 for the reduction.


Here is a proof with depth 6, length 27 :
8[0:Inp] || fun_main(nil) -> values(x10,address(myarray))*.
9[0:Inp] || fun_main(nil) values(x10,U)* -> values(x9,U).
10[0:Inp] || fun_main(nil) -> values(x12,1)*.
11[0:Inp] || fun_main(nil) values(x12,U) -> values(x11,U)*.
12[0:Inp] || fun_main(nil) -> values(x8,address(offset(x9,x11)))*.
13[0:Inp] || fun_main(nil) -> values(x7,1)*.
14[0:Inp] || fun_main(nil) values(x8,address(U))* values(x7,V)* -> values(U,V)*.
23[0:Inp] ||  -> fun_main(nil)*.
27[0:Inp] || values(U,address(V))* values(offset(U,W),X)*+ -> values(offset(V,W),X)*.
29[0:Inp] || values(U,V)* values(offset(W,U),X)*+ -> values(offset(W,V),X)*.
35[0:Inp] || values(offset(myarray,1),1)*+ -> .
38[0:MRR:10.0,23.0] ||  -> values(x12,1)*.
39[0:MRR:13.0,23.0] ||  -> values(x7,1)*.
44[0:MRR:8.0,23.0] ||  -> values(x10,address(myarray))*.
48[0:MRR:9.0,23.0] || values(x10,U)*+ -> values(x9,U).
49[0:MRR:11.0,23.0] || values(x12,U)+ -> values(x11,U)*.
53[0:MRR:12.0,23.0] ||  -> values(x8,address(offset(x9,x11)))*.
56[0:MRR:14.0,23.0] || values(x7,U)* values(x8,address(V))*+ -> values(V,U)*.
67[0:Res:44.0,48.0] ||  -> values(x9,address(myarray))*.
68[0:Res:38.0,49.0] ||  -> values(x11,1)*.
95[0:Res:53.0,56.1] || values(x7,U)+ -> values(offset(x9,x11),U)*.
98[0:Res:39.0,95.0] ||  -> values(offset(x9,x11),1)*.
100[0:Res:98.0,29.1] || values(x11,U)+ -> values(offset(x9,U),1)*.
102[0:Res:68.0,100.0] ||  -> values(offset(x9,1),1)*.
111[0:Res:102.0,27.1] || values(x9,address(U))+ -> values(offset(U,1),1)*.
133[0:Res:67.0,111.0] ||  -> values(offset(myarray,1),1)*.
134[0:MRR:133.0,35.0] ||  -> .
Formulae used in the proof :


Essai14.p :
-----------

Le code :

int main()
{
  int myarray[3];
  int x;
  
  x =0;
  myarray[x] = x;
  x =1;
  myarray[x] = x;
  x =2;
  myarray[x] = x;
  return(0);
}

La question : values(offset(myarray,1),1)

La preuve : 

Problem: essai.dfg 
SPASS derived 252 clauses, backtracked 0 clauses and kept 290 clauses.
SPASS allocated 522 KBytes.
SPASS spent     0:00:00.12 on the problem.
                0:00:00.00 for the input.
                0:00:00.00 for the FLOTTER CNF translation.
                0:00:00.00 for inferences.
                0:00:00.00 for the backtracking.
                0:00:00.02 for the reduction.


Here is a proof with depth 5, length 28 :
9[0:Inp] || fun_main(nil) -> values(x,1)*.
19[0:Inp] || fun_main(nil) -> values(x17,address(myarray))*.
20[0:Inp] || fun_main(nil) values(x17,U) -> values(x16,U)*.
21[0:Inp] || fun_main(nil) values(x,U)* -> values(x18,U).
22[0:Inp] || fun_main(nil) -> values(x15,address(offset(x16,x18)))*.
23[0:Inp] || fun_main(nil) values(x,U)* -> values(x14,U).
24[0:Inp] || fun_main(nil) values(x15,address(U))* values(x14,V)* -> values(U,V)*.
26[0:Inp] ||  -> fun_main(nil)*.
30[0:Inp] || values(U,address(V))* values(offset(U,W),X)*+ -> values(offset(V,W),X)*.
32[0:Inp] || values(U,V)* values(offset(W,U),X)*+ -> values(offset(W,V),X)*.
38[0:Inp] || values(offset(myarray,1),1)*+ -> .
40[0:MRR:9.0,26.0] ||  -> values(x,1)*.
45[0:MRR:19.0,26.0] ||  -> values(x17,address(myarray))*.
55[0:MRR:20.0,26.0] || values(x17,U)+ -> values(x16,U)*.
56[0:MRR:21.0,26.0] || values(x,U)*+ -> values(x18,U).
57[0:MRR:23.0,26.0] || values(x,U)*+ -> values(x14,U).
60[0:MRR:22.0,26.0] ||  -> values(x15,address(offset(x16,x18)))*.
63[0:MRR:24.0,26.0] || values(x14,U)* values(x15,address(V))*+ -> values(V,U)*.
69[0:Res:30.2,38.0] || values(U,address(myarray)) values(offset(U,1),1)*+ -> .
94[0:Res:45.0,55.0] ||  -> values(x16,address(myarray))*.
96[0:Res:40.0,56.0] ||  -> values(x18,1)*.
99[0:Res:40.0,57.0] ||  -> values(x14,1)*.
143[0:Res:60.0,63.1] || values(x14,U)+ -> values(offset(x16,x18),U)*.
169[0:Res:99.0,143.0] ||  -> values(offset(x16,x18),1)*.
175[0:Res:169.0,32.1] || values(x18,U)+ -> values(offset(x16,U),1)*.
295[0:Res:96.0,175.0] ||  -> values(offset(x16,1),1)*.
318[0:Res:295.0,69.1] || values(x16,address(myarray))* -> .
319[0:MRR:318.0,94.0] ||  -> .
Formulae used in the proof :


Essai15.p :
-----------

Le code :

int main()
{
  int myarray[3];
  int i;
  
  for (i=0;i<3;i++)
    {
      myarray[i] = i;
    };
  return(0);
}

La question : values(offset(myarray,1),1)


Ici notre modele par clauses n'est pas adequat.

On ne sait pas que : for (i=0;i<3;i++) => {values(i,1)} + {values(i,2)} + {values(i,3)}